105 lines
4.5 KiB
GDScript
105 lines
4.5 KiB
GDScript
class_name NetState
|
|
## Serialisierter Spielzustand für das Netzwerk (ausgelagert aus den Spielregeln).
|
|
|
|
|
|
## Karten reisen als ID; eigene Exemplare mit Schlüsselwörtern und verschmolzene als Ganzes.
|
|
static func card_ref(c: Cards.Card):
|
|
return c.id if Cards.has_id(c.id) and c.keywords.is_empty() and c.fusions == 0 else c.to_dict()
|
|
|
|
|
|
static func card_of(ref) -> Cards.Card:
|
|
return Cards.Card.from_dict(ref) if ref is Dictionary else Cards.by_id(ref).copy()
|
|
|
|
|
|
## Zustand aus Sicht eines Spielers: fremde Hand nur als Anzahl, fremde
|
|
## verdeckte Wesen ohne Karte und Werte. viewer -1: alles sichtbar (Host-Wechsel); -2: Zuschauer.
|
|
static func snapshot(g: Game, viewer: int) -> Dictionary:
|
|
var ps := []
|
|
for i in g.players.size():
|
|
var p: Game.Player = g.players[i]
|
|
var mine := i == viewer or viewer == -1
|
|
var board := []
|
|
for c in p.board:
|
|
var masked: bool = c.hidden and not mine
|
|
board.append({"uid": c.uid, "card": card_ref(Cards.unknown() if masked else c.card),
|
|
"attack": 0 if masked else c.attack, "health": 0 if masked else c.health,
|
|
"max_health": 0 if masked else c.max_health, "attacks_done": c.attacks_done,
|
|
"ready": c.ready, "hidden": c.hidden, "aura": c.aura})
|
|
ps.append({"name": p.name, "title": p.title, "is_human": p.is_human, "life": p.life, "max_life": p.max_life,
|
|
"energy": p.energy, "max_energy": p.max_energy, "start_bonus": p.start_bonus,
|
|
"order": p.order, "perks": p.perks, "looks": p.looks, "turns": p.turns,
|
|
"hand": p.hand.map(card_ref) if mine else p.hand.size(), "board": board})
|
|
var evs := []
|
|
for ev in g.events:
|
|
var e: Dictionary = ev.duplicate()
|
|
if e.has("card"):
|
|
e["card"] = card_ref(e.card)
|
|
evs.append(e)
|
|
return {"players": ps, "human": g.players.find(g.human), "turn": g.turn, "current_idx": g.current_idx,
|
|
"winner": g.winner, "winner_player": g.players.find(g.winner_player) if g.winner_player != null else -1,
|
|
"next_uid": g.next_uid, "deck_size": g.deck.size(),
|
|
"log": g.log.slice(maxi(0, g.log.size() - 80)), "events": evs}
|
|
|
|
|
|
## Baut einen Spielzustand aus einem Snapshot; verborgene Karten werden durch Platzhalter ersetzt.
|
|
static func from_snapshot(d: Dictionary) -> Game:
|
|
var placeholder: Cards.Card = Cards.all()[0]
|
|
var list := []
|
|
for pd in d.players:
|
|
var p := Game.Player.new(pd.name, pd.is_human, int(pd.life), pd.title)
|
|
p.max_life = int(pd.max_life)
|
|
p.energy = int(pd.energy)
|
|
p.max_energy = int(pd.max_energy)
|
|
p.start_bonus = int(pd.start_bonus)
|
|
p.order = int(pd.order)
|
|
p.perks = Array(pd.perks)
|
|
for cid in pd.get("looks", {}):
|
|
p.looks[cid] = int(pd.looks[cid])
|
|
p.turns = int(pd.turns)
|
|
if pd.hand is Array:
|
|
for ref in pd.hand:
|
|
p.hand.append(card_of(ref))
|
|
else:
|
|
for i in int(pd.hand):
|
|
p.hand.append(placeholder)
|
|
for cd in pd.board:
|
|
var card := card_of(cd.card)
|
|
var c := Game.Creature.new(card, p, int(cd.uid))
|
|
c.attack = int(cd.attack)
|
|
c.health = int(cd.health)
|
|
c.max_health = int(cd.max_health)
|
|
c.attacks_done = int(cd.get("attacks_done", 0))
|
|
c.ready = bool(cd.get("ready", false))
|
|
c.hidden = bool(cd.get("hidden", false))
|
|
c.aura = int(cd.get("aura", 0))
|
|
p.board.append(c)
|
|
list.append(p)
|
|
var hi := int(d.human)
|
|
var g := Game.new(list[hi], list[1 - hi], RandomNumberGenerator.new())
|
|
g.players = list
|
|
g.turn = int(d.turn)
|
|
g.current_idx = int(d.current_idx)
|
|
g.winner = d.winner
|
|
g.winner_player = list[int(d.winner_player)] if int(d.winner_player) >= 0 else null
|
|
g.next_uid = int(d.next_uid)
|
|
for i in int(d.get("deck_size", 0)):
|
|
g.deck.append(placeholder) # nur die Größe zählt; gezogen wird beim Host
|
|
for line in d.log:
|
|
g.log.append(str(line))
|
|
for ev in d.events:
|
|
var e: Dictionary = ev.duplicate()
|
|
if e.has("card"):
|
|
e["card"] = card_of(e.card)
|
|
for key in ["player", "uid", "amount"]:
|
|
if e.has(key):
|
|
e[key] = int(e[key])
|
|
for key in ["target", "attacker"]:
|
|
if e.has(key):
|
|
var r: Dictionary = e[key]
|
|
if r.has("uid"):
|
|
r["uid"] = int(r.uid)
|
|
if r.has("index"):
|
|
r["index"] = int(r.index)
|
|
g.events.append(e)
|
|
return g
|