Dinger: Kartenspiel in Godot 4.7
Elemente, Kombos, Fallen, KI mit Vorausschau, Kampagne, Hotseat und Netzwerk, Werkstatt, Erfolge, Tagesaufgaben, Tests und Exporte. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QPgKvy5W9WRNFHjkm5QsHx
This commit is contained in:
Team3
854
scripts/game.gd
Normal file
854
scripts/game.gd
Normal file
@@ -0,0 +1,854 @@
|
||||
class_name Game
|
||||
extends RefCounted
|
||||
## Spielregeln: Spieler, Wesen, Züge, Angriffe, Effekte, Feldkombos, Resonanz.
|
||||
|
||||
const MAX_BOARD := 5
|
||||
const MAX_HAND := 8
|
||||
const MAX_ENERGY := 10
|
||||
const START_HAND := 4
|
||||
# Jeder gegen jeden: alle Spieler haben dieselben Regeln und dasselbe Startleben.
|
||||
const START_LIFE := 30
|
||||
const MAX_OPPONENTS := 5
|
||||
|
||||
const RESONANCE_MAX := 4
|
||||
const MAX_TRAPS := 2
|
||||
|
||||
# Merkmale der Kampagnen-Bosse (Player.perks).
|
||||
const PERKS := {
|
||||
"feuer_angriff": "Feuerwesen haben +1 Angriff",
|
||||
"flink_angriff": "Flinke Wesen haben +1 Angriff",
|
||||
"waechter_leben": "Wächter kommen mit +2 Leben",
|
||||
"extra_karten": "Zieht 2 Karten pro Zug",
|
||||
"leben_35": "Beginnt mit 35 Leben",
|
||||
"zauber_schaden": "Schadenszauber machen +1 Schaden",
|
||||
"schild_wesen": "Wesen kommen mit Schild",
|
||||
"alle_flink": "Alle Wesen sind flink",
|
||||
"start_energie": "Beginnt mit 3 Energie",
|
||||
"resonanz_doppelt": "Resonanz zählt doppelt",
|
||||
}
|
||||
|
||||
## Für wiederholbare Tests: 0 = echter Zufall, sonst Startwert (zählt je Aufruf hoch).
|
||||
static var test_seed := 0
|
||||
|
||||
|
||||
static func make_rng() -> RandomNumberGenerator:
|
||||
var r := RandomNumberGenerator.new()
|
||||
if test_seed != 0:
|
||||
r.seed = test_seed
|
||||
test_seed += 1
|
||||
else:
|
||||
r.randomize()
|
||||
return r
|
||||
|
||||
const DECK_SIZE := 20
|
||||
const MAX_COPIES := 3
|
||||
const MAX_DECK_ELEMENTS := 2
|
||||
const OPPONENT_RARITY_WEIGHT := {"gewöhnlich": 6.0, "selten": 3.0, "episch": 2.0, "legendär": 1.0, "mythisch": 0.3}
|
||||
|
||||
|
||||
class Creature extends RefCounted:
|
||||
var card: Cards.Card
|
||||
var owner_ref: WeakRef # schwache Referenz: kein Zyklus Spieler <-> Wesen
|
||||
var name: String
|
||||
var uid: int
|
||||
var attack: int
|
||||
var resonance := 0 # +1, wenn ein anderes eigenes Wesen ein Element teilt
|
||||
var health: int
|
||||
var max_health: int
|
||||
var shield: bool
|
||||
var frozen := false
|
||||
var ready: bool
|
||||
var attacks_left: int
|
||||
|
||||
func _init(c: Cards.Card, o, id: int) -> void:
|
||||
card = c
|
||||
owner_ref = weakref(o)
|
||||
name = c.name
|
||||
uid = id
|
||||
attack = c.attack
|
||||
health = c.health
|
||||
max_health = c.health
|
||||
shield = "Schild" in c.keywords
|
||||
ready = "Flink" in c.keywords
|
||||
attacks_left = attacks_per_turn() if ready else 0
|
||||
|
||||
func owner():
|
||||
return owner_ref.get_ref()
|
||||
|
||||
## Angriffswert inklusive Resonanz und Boss-Merkmalen.
|
||||
func power() -> int:
|
||||
var v := attack + resonance
|
||||
var o = owner()
|
||||
if o != null:
|
||||
if "feuer_angriff" in o.perks and "Feuer" in card.elements:
|
||||
v += 1
|
||||
if "flink_angriff" in o.perks and "Flink" in card.keywords:
|
||||
v += 1
|
||||
return v
|
||||
|
||||
func attacks_per_turn() -> int:
|
||||
return 2 if "Doppelschlag" in card.keywords else 1
|
||||
|
||||
func taunt() -> bool:
|
||||
return "Wächter" in card.keywords
|
||||
|
||||
func can_attack() -> bool:
|
||||
return ready and attacks_left > 0 and not frozen and power() > 0
|
||||
|
||||
func clone(new_owner) -> Creature:
|
||||
var c := Creature.new(card, new_owner, uid)
|
||||
c.attack = attack
|
||||
c.resonance = resonance
|
||||
c.health = health
|
||||
c.max_health = max_health
|
||||
c.shield = shield
|
||||
c.frozen = frozen
|
||||
c.ready = ready
|
||||
c.attacks_left = attacks_left
|
||||
return c
|
||||
|
||||
|
||||
class Player extends RefCounted:
|
||||
var name: String
|
||||
var title: String
|
||||
var is_human: bool
|
||||
var life: int
|
||||
var max_life: int
|
||||
var deck: Array = []
|
||||
var hand: Array = []
|
||||
var board: Array = []
|
||||
var energy := 0
|
||||
var max_energy := 0
|
||||
var fatigue := 0
|
||||
var start_bonus := 0 # einmalige Extra-Energie im ersten Zug (Ausgleich fürs Nachziehen)
|
||||
var traps: Array = [] # verdeckt liegende Fallenkarten
|
||||
var order := 0 # Platz in der Zugreihenfolge
|
||||
var perks: Array = [] # Boss-Merkmale (siehe PERKS)
|
||||
var turns := 0 # begonnene eigene Züge
|
||||
var mulligan_done := false
|
||||
|
||||
func _init(n: String, d: Array, h: bool, l: int, t: String = "") -> void:
|
||||
name = n
|
||||
title = t
|
||||
is_human = h
|
||||
life = l
|
||||
max_life = l
|
||||
deck = d.duplicate()
|
||||
|
||||
func alive() -> bool:
|
||||
return life > 0
|
||||
|
||||
func clone() -> Player:
|
||||
var p := Player.new(name, deck, is_human, life, title)
|
||||
p.max_life = max_life
|
||||
p.hand = hand.duplicate()
|
||||
p.energy = energy
|
||||
p.max_energy = max_energy
|
||||
p.fatigue = fatigue
|
||||
p.start_bonus = start_bonus
|
||||
p.traps = traps.duplicate()
|
||||
p.order = order
|
||||
p.perks = perks.duplicate()
|
||||
p.turns = turns
|
||||
p.mulligan_done = mulligan_done
|
||||
for c in board:
|
||||
p.board.append(c.clone(p))
|
||||
return p
|
||||
|
||||
|
||||
var human: Player # der (erste) menschliche Spieler
|
||||
var humans: Array = [] # alle menschlichen Spieler (Hotseat: mehrere)
|
||||
var opponents: Array = [] # alle außer dem ersten Menschen
|
||||
var players: Array = [] # in Zugreihenfolge
|
||||
var winner_player: Player = null
|
||||
var rng: RandomNumberGenerator
|
||||
var turn := 0
|
||||
var current_idx := 0
|
||||
var log: Array[String] = []
|
||||
var events: Array = [] # strukturierte Ereignisse für Animationen
|
||||
var winner := "" # "", "human" oder "opponents"
|
||||
var quiet := false # in KI-Kopien: kein Verlauf, keine Ereignisse
|
||||
var next_uid := 1
|
||||
|
||||
|
||||
func _init(h: Player, opps: Array, r: RandomNumberGenerator = null) -> void:
|
||||
human = h
|
||||
opponents = opps
|
||||
players = [h] + opps
|
||||
humans = players.filter(func(p): return p.is_human)
|
||||
if r == null:
|
||||
r = make_rng()
|
||||
rng = r
|
||||
|
||||
|
||||
func current() -> Player:
|
||||
return players[current_idx]
|
||||
|
||||
|
||||
func say(t: String) -> void:
|
||||
if not quiet:
|
||||
log.append(t)
|
||||
|
||||
|
||||
func emit(ev: Dictionary) -> void:
|
||||
if not quiet:
|
||||
events.append(ev)
|
||||
|
||||
|
||||
func ref_of(target) -> Dictionary:
|
||||
if target is Creature:
|
||||
return {"kind": "creature", "uid": target.uid}
|
||||
return {"kind": "player", "index": players.find(target)}
|
||||
|
||||
|
||||
## Jeder gegen jeden: alle anderen lebenden Spieler sind Gegner.
|
||||
func enemies_of(p: Player) -> Array:
|
||||
return players.filter(func(o): return o != p and o.alive())
|
||||
|
||||
|
||||
func find_creature(uid: int) -> Creature:
|
||||
for p in players:
|
||||
for c in p.board:
|
||||
if c.uid == uid:
|
||||
return c
|
||||
return null
|
||||
|
||||
|
||||
## Unabhängige Kopie des Spielzustands (für die KI-Vorausschau).
|
||||
func clone() -> Game:
|
||||
var copies := []
|
||||
for p in players:
|
||||
copies.append(p.clone())
|
||||
var idx := players.find(human)
|
||||
var g := Game.new(copies[idx], copies.slice(0, idx) + copies.slice(idx + 1), RandomNumberGenerator.new())
|
||||
g.players = copies # gleiche Zugreihenfolge wie das Original
|
||||
g.turn = turn
|
||||
g.current_idx = current_idx
|
||||
g.winner = winner
|
||||
g.next_uid = next_uid
|
||||
g.quiet = true
|
||||
return g
|
||||
|
||||
|
||||
## Kopie aus Sicht von p: fremde Fallen sind unbekannt und fehlen (die KI schummelt nicht).
|
||||
func clone_for(p: Player) -> Game:
|
||||
var g := clone()
|
||||
var p2: Player = g.players[players.find(p)]
|
||||
for q in g.players:
|
||||
if q != p2:
|
||||
q.traps = []
|
||||
return g
|
||||
|
||||
|
||||
# --- Zugablauf ---------------------------------------------------------------
|
||||
|
||||
func start(fixed_order: bool = false) -> void:
|
||||
if not fixed_order:
|
||||
shuffle(players, rng) # zufällige Zugreihenfolge
|
||||
for i in players.size():
|
||||
var p: Player = players[i]
|
||||
p.order = i
|
||||
if "start_energie" in p.perks:
|
||||
p.max_energy = 2
|
||||
shuffle(p.deck, rng)
|
||||
# Wer nicht beginnt, startet mit einer Karte mehr und hat im ersten Zug
|
||||
# einmalig 1 Energie extra (Ausgleich für den Startvorteil).
|
||||
draw(p, START_HAND + (0 if i == 0 else 1))
|
||||
p.start_bonus = 0 if i == 0 else 1
|
||||
turn = 1
|
||||
current_idx = 0
|
||||
say("Zugreihenfolge: " + ", ".join(players.map(func(p): return p.name)))
|
||||
for p in players:
|
||||
for perk in p.perks:
|
||||
say("%s: %s." % [p.name, PERKS[perk]])
|
||||
begin_turn(current())
|
||||
|
||||
|
||||
func draw(p: Player, n: int = 1) -> void:
|
||||
for i in n:
|
||||
if p.deck.is_empty():
|
||||
p.fatigue += 1
|
||||
say("%s hat keine Karten mehr und erleidet %d Schaden." % [p.name, p.fatigue])
|
||||
damage(p, p.fatigue)
|
||||
continue
|
||||
var card = p.deck.pop_back()
|
||||
if p.hand.size() >= MAX_HAND:
|
||||
say("%s: Hand voll, %s verbrennt." % [p.name, card.name])
|
||||
else:
|
||||
p.hand.append(card)
|
||||
check_end()
|
||||
|
||||
|
||||
func begin_turn(p: Player) -> void:
|
||||
p.max_energy = mini(MAX_ENERGY, p.max_energy + 1)
|
||||
p.energy = p.max_energy
|
||||
if p.start_bonus > 0:
|
||||
p.energy += p.start_bonus
|
||||
say("%s erhält %d Energie extra für den späteren Start." % [p.name, p.start_bonus])
|
||||
p.start_bonus = 0
|
||||
for c in p.board:
|
||||
c.ready = true
|
||||
if c.frozen:
|
||||
c.frozen = false
|
||||
c.attacks_left = 0
|
||||
say("%s taut auf und setzt aus." % c.name)
|
||||
else:
|
||||
c.attacks_left = c.attacks_per_turn()
|
||||
p.turns += 1
|
||||
say("--- Zug %d: %s ---" % [turn, p.name])
|
||||
emit({"type": "turn", "player": players.find(p)})
|
||||
draw(p, 2 if "extra_karten" in p.perks else 1)
|
||||
|
||||
|
||||
## Tauscht einmalig im ersten eigenen Zug Karten der Hand: zurück ins Deck, mischen, nachziehen.
|
||||
func mulligan(p: Player, cards: Array) -> String:
|
||||
if p.mulligan_done:
|
||||
return "Schon getauscht"
|
||||
if p != current() or p.turns != 1:
|
||||
return "Nur im ersten eigenen Zug"
|
||||
p.mulligan_done = true
|
||||
var n := 0
|
||||
for c in cards:
|
||||
if c in p.hand:
|
||||
p.hand.erase(c)
|
||||
p.deck.append(c)
|
||||
n += 1
|
||||
if n > 0:
|
||||
shuffle(p.deck, rng)
|
||||
draw(p, n)
|
||||
say("%s tauscht %d Karten." % [p.name, n] if n > 0 else "%s behält die Hand." % p.name)
|
||||
emit({"type": "mulligan", "player": players.find(p), "count": n})
|
||||
return ""
|
||||
|
||||
|
||||
func end_turn() -> void:
|
||||
if winner != "":
|
||||
return
|
||||
var n := players.size()
|
||||
for i in range(1, n + 1):
|
||||
var idx := (current_idx + i) % n
|
||||
if players[idx].alive():
|
||||
if idx <= current_idx:
|
||||
turn += 1
|
||||
current_idx = idx
|
||||
break
|
||||
begin_turn(current())
|
||||
|
||||
|
||||
# --- Karten spielen ----------------------------------------------------------
|
||||
|
||||
func can_play(p: Player, card: Cards.Card) -> Array:
|
||||
if winner != "" or p != current():
|
||||
return [false, "Nicht dein Zug"]
|
||||
if p.energy < card.cost:
|
||||
return [false, "Nicht genug Energie"]
|
||||
if card.is_creature() and p.board.size() >= MAX_BOARD:
|
||||
return [false, "Dein Feld ist voll"]
|
||||
if card.is_trap() and p.traps.size() >= MAX_TRAPS:
|
||||
return [false, "Höchstens %d Fallen" % MAX_TRAPS]
|
||||
var tt := card.target_type()
|
||||
if tt != "" and not card.is_creature() and valid_targets(p, tt).is_empty():
|
||||
return [false, "Kein gültiges Ziel"]
|
||||
return [true, ""]
|
||||
|
||||
|
||||
func valid_targets(p: Player, target_type: String) -> Array:
|
||||
var enemies := enemies_of(p)
|
||||
var creatures := []
|
||||
for e in enemies:
|
||||
creatures.append_array(e.board)
|
||||
match target_type:
|
||||
"enemy_creature":
|
||||
return creatures
|
||||
"enemy_any":
|
||||
return creatures + enemies
|
||||
"friendly_creature":
|
||||
return p.board.duplicate()
|
||||
return []
|
||||
|
||||
|
||||
## Spielt eine Karte. Gibt "" zurück oder eine Fehlermeldung.
|
||||
func play_card(p: Player, card: Cards.Card, target = null) -> String:
|
||||
var ok := can_play(p, card)
|
||||
if not ok[0]:
|
||||
return ok[1]
|
||||
var tt := card.target_type()
|
||||
if tt != "":
|
||||
var valid := valid_targets(p, tt)
|
||||
if not valid.is_empty() and not (target in valid):
|
||||
return "Ungültiges Ziel"
|
||||
if valid.is_empty():
|
||||
target = null
|
||||
p.hand.erase(card)
|
||||
p.energy -= card.cost
|
||||
if card.is_trap():
|
||||
p.traps.append(card)
|
||||
say("%s legt eine Falle." % p.name)
|
||||
emit({"type": "trap_set", "player": players.find(p)})
|
||||
check_end()
|
||||
return ""
|
||||
say("%s spielt %s." % [p.name, card.name])
|
||||
var cr: Creature = null
|
||||
var bonus := 0
|
||||
if card.is_creature():
|
||||
cr = _enter(p, card)
|
||||
else:
|
||||
emit({"type": "spell", "player": players.find(p), "card": card})
|
||||
if "zauber_schaden" in p.perks:
|
||||
bonus = 1
|
||||
for fx in card.effects:
|
||||
resolve(p, fx, target, cr, bonus)
|
||||
if cr != null and cr in p.board:
|
||||
for e in enemies_of(p):
|
||||
if not (cr in p.board):
|
||||
break
|
||||
trigger_trap(e, "creature_played", cr)
|
||||
if cr != null and cr in p.board:
|
||||
trigger_field_combos(p, cr)
|
||||
update_resonance()
|
||||
cleanup()
|
||||
check_end()
|
||||
return ""
|
||||
|
||||
|
||||
## Feldkombo: das neue Wesen bildet mit dem ersten eigenen Wesen aus anderem
|
||||
## Element eine Kombo; pro Ausspielen löst höchstens eine Kombo aus.
|
||||
func trigger_field_combos(p: Player, cr: Creature) -> void:
|
||||
for other in p.board:
|
||||
if other == cr:
|
||||
continue
|
||||
for e1 in cr.card.elements:
|
||||
for e2 in other.card.elements:
|
||||
if e1 == e2:
|
||||
continue
|
||||
var name := Cards.combo_name([e1, e2])
|
||||
say("Feldkombo %s: %s." % [name, Cards.FIELD_COMBO_TEXT[name]])
|
||||
emit({"type": "combo", "name": name, "player": players.find(p), "uid": cr.uid})
|
||||
resolve(p, Cards.field_combo_effect(name), null, cr)
|
||||
return
|
||||
|
||||
|
||||
## Löst die erste passende Falle von owner aus. Gibt true zurück, wenn der
|
||||
## auslösende Angriff abgebrochen wird.
|
||||
func trigger_trap(owner: Player, trigger: String, source: Creature) -> bool:
|
||||
for trap in owner.traps:
|
||||
if trap.trigger != trigger:
|
||||
continue
|
||||
owner.traps.erase(trap)
|
||||
say("Falle von %s: %s!" % [owner.name, trap.name])
|
||||
emit({"type": "trap", "player": players.find(owner), "card": trap, "source": ref_of(source)})
|
||||
var cancel := false
|
||||
for fx in trap.effects:
|
||||
if fx.kind == "cancel":
|
||||
cancel = true
|
||||
else:
|
||||
resolve(owner, fx, null, source)
|
||||
cleanup()
|
||||
return cancel
|
||||
return false
|
||||
|
||||
|
||||
## Wesen betritt das Feld; Boss-Merkmale wirken beim Eintritt.
|
||||
func _enter(p: Player, card: Cards.Card) -> Creature:
|
||||
var cr := Creature.new(card, p, next_uid)
|
||||
next_uid += 1
|
||||
if "waechter_leben" in p.perks and cr.taunt():
|
||||
cr.health += 2
|
||||
cr.max_health += 2
|
||||
if "schild_wesen" in p.perks:
|
||||
cr.shield = true
|
||||
if "alle_flink" in p.perks:
|
||||
cr.ready = true
|
||||
cr.attacks_left = cr.attacks_per_turn()
|
||||
p.board.append(cr)
|
||||
emit({"type": "play", "player": players.find(p), "uid": cr.uid, "card": card})
|
||||
return cr
|
||||
|
||||
|
||||
## Setzt ein Wesen aufs Feld (Fallen, Effekte).
|
||||
func summon(p: Player, card: Cards.Card) -> void:
|
||||
if p.board.size() >= MAX_BOARD:
|
||||
say("%s: kein Platz für %s." % [p.name, card.name])
|
||||
return
|
||||
_enter(p, card)
|
||||
say("%s beschwört %s." % [p.name, card.name])
|
||||
update_resonance()
|
||||
|
||||
|
||||
## Resonanz: +1 Angriff je anderem eigenen Wesen, das ein Element teilt (höchstens +4).
|
||||
func update_resonance() -> void:
|
||||
for p in players:
|
||||
for c in p.board:
|
||||
var bonus := 0
|
||||
for o in p.board:
|
||||
if o != c and o.card.elements.any(func(e): return e in c.card.elements):
|
||||
bonus += 1
|
||||
c.resonance = mini(bonus, RESONANCE_MAX) * (2 if "resonanz_doppelt" in p.perks else 1)
|
||||
|
||||
|
||||
func resolve(p: Player, fx: Cards.Effect, target, source: Creature = null, bonus: int = 0) -> void:
|
||||
var enemies := enemies_of(p)
|
||||
var enemy_creatures := []
|
||||
for e in enemies:
|
||||
enemy_creatures.append_array(e.board)
|
||||
var targets := []
|
||||
if fx.target in Cards.CHOSEN_TARGETS:
|
||||
targets = [target] if target != null else []
|
||||
elif fx.target == "all_enemy_creatures":
|
||||
targets = enemy_creatures
|
||||
elif fx.target == "all_enemy_heroes":
|
||||
targets = enemies.duplicate()
|
||||
elif fx.target == "all_enemies":
|
||||
targets = enemy_creatures + enemies
|
||||
elif fx.target == "all_friendly_creatures":
|
||||
targets = p.board.duplicate()
|
||||
elif fx.target == "self_hero":
|
||||
targets = [p]
|
||||
elif fx.target == "self_creature" or fx.target == "trigger_source":
|
||||
targets = [source] if source != null else []
|
||||
elif fx.target == "strongest_enemy_creature":
|
||||
var best: Creature = null
|
||||
for c in enemy_creatures:
|
||||
if best == null or c.power() > best.power():
|
||||
best = c
|
||||
targets = [best] if best != null else []
|
||||
elif fx.target == "weakest_enemy_hero":
|
||||
var weakest: Player = null
|
||||
for e in enemies:
|
||||
if weakest == null or e.life < weakest.life:
|
||||
weakest = e
|
||||
targets = [weakest] if weakest != null else []
|
||||
else:
|
||||
targets = [null]
|
||||
for t in targets:
|
||||
match fx.kind:
|
||||
"damage":
|
||||
damage(t, fx.amount + bonus)
|
||||
"heal":
|
||||
t.life = mini(t.max_life, t.life + fx.amount)
|
||||
say("%s heilt sich um %d." % [t.name, fx.amount])
|
||||
emit({"type": "heal", "target": ref_of(t), "amount": fx.amount})
|
||||
"draw":
|
||||
draw(p, fx.amount)
|
||||
"freeze":
|
||||
t.frozen = true
|
||||
t.attacks_left = 0
|
||||
say("%s ist eingefroren." % t.name)
|
||||
emit({"type": "freeze", "target": ref_of(t)})
|
||||
"bounce":
|
||||
var o = t.owner()
|
||||
o.board.erase(t)
|
||||
emit({"type": "bounce", "target": ref_of(t)})
|
||||
if o.hand.size() < MAX_HAND:
|
||||
o.hand.append(t.card)
|
||||
say("%s kehrt auf die Hand zurück." % t.name)
|
||||
else:
|
||||
say("%s wird weggeweht (Hand voll)." % t.name)
|
||||
"buff":
|
||||
t.attack += fx.amount
|
||||
t.health += fx.amount2
|
||||
t.max_health += fx.amount2
|
||||
say("%s erhält +%d/+%d." % [t.name, fx.amount, fx.amount2])
|
||||
emit({"type": "buff", "target": ref_of(t), "text": "+%d/+%d" % [fx.amount, fx.amount2]})
|
||||
"shield":
|
||||
t.shield = true
|
||||
say("%s erhält Schild." % t.name)
|
||||
emit({"type": "buff", "target": ref_of(t), "text": "Schild"})
|
||||
"summon":
|
||||
summon(p, Cards.by_id(fx.card_id))
|
||||
|
||||
|
||||
# --- Kampf -------------------------------------------------------------------
|
||||
|
||||
func can_attack(cr: Creature, target) -> Array:
|
||||
if winner != "" or cr.owner() != current():
|
||||
return [false, "Nicht dein Zug"]
|
||||
if not cr.can_attack():
|
||||
return [false, "%s kann nicht angreifen" % cr.name]
|
||||
var tgt_owner = target.owner() if target is Creature else target
|
||||
if not (tgt_owner in enemies_of(cr.owner())):
|
||||
return [false, "Kein gültiges Ziel"]
|
||||
var has_taunt := false
|
||||
for c in tgt_owner.board:
|
||||
if c.taunt():
|
||||
has_taunt = true
|
||||
if has_taunt and not (target is Creature and target.taunt()):
|
||||
return [false, "Ein Wächter muss zuerst angegriffen werden"]
|
||||
return [true, ""]
|
||||
|
||||
|
||||
## Greift an. Gibt "" zurück oder eine Fehlermeldung.
|
||||
func attack(cr: Creature, target) -> String:
|
||||
var ok := can_attack(cr, target)
|
||||
if not ok[0]:
|
||||
return ok[1]
|
||||
cr.attacks_left -= 1
|
||||
say("%s greift %s an." % [cr.name, target.name])
|
||||
emit({"type": "attack", "attacker": ref_of(cr), "target": ref_of(target)})
|
||||
var tgt_owner: Player = target.owner() if target is Creature else target
|
||||
var cancelled := trigger_trap(tgt_owner, "attacked", cr)
|
||||
if cancelled or not (cr in cr.owner().board) or (target is Creature and not (target in tgt_owner.board)):
|
||||
check_end()
|
||||
return ""
|
||||
damage(target, cr.power())
|
||||
if target is Creature:
|
||||
damage(cr, target.power())
|
||||
cleanup()
|
||||
check_end()
|
||||
return ""
|
||||
|
||||
|
||||
func damage(target, amount: int) -> void:
|
||||
if amount <= 0:
|
||||
return
|
||||
if target is Creature:
|
||||
if target.shield:
|
||||
target.shield = false
|
||||
say("Schild von %s blockt den Schaden." % target.name)
|
||||
emit({"type": "blocked", "target": ref_of(target)})
|
||||
return
|
||||
target.health -= amount
|
||||
else:
|
||||
target.life -= amount
|
||||
say("%s erleidet %d Schaden." % [target.name, amount])
|
||||
emit({"type": "damage", "target": ref_of(target), "amount": amount})
|
||||
|
||||
|
||||
func cleanup() -> void:
|
||||
var died := false
|
||||
for p in players:
|
||||
for c in p.board.duplicate():
|
||||
if c.health <= 0:
|
||||
p.board.erase(c)
|
||||
say("%s stirbt." % c.name)
|
||||
emit({"type": "death", "target": ref_of(c)})
|
||||
died = true
|
||||
if died:
|
||||
update_resonance()
|
||||
|
||||
|
||||
## Ende: nur noch ein Spieler übrig, oder kein Mensch mehr am Tisch.
|
||||
func check_end() -> void:
|
||||
if winner != "":
|
||||
return
|
||||
var alive := players.filter(func(p): return p.alive())
|
||||
var humans_alive := alive.filter(func(p): return p.is_human)
|
||||
if humans_alive.is_empty():
|
||||
winner = "opponents"
|
||||
winner_player = alive[0] if alive.size() == 1 else null
|
||||
say("Du wurdest besiegt." if humans.size() == 1 else "Alle Spieler sind besiegt, die KI gewinnt.")
|
||||
elif alive.size() == 1:
|
||||
winner = "human"
|
||||
winner_player = alive[0]
|
||||
say("Alle Gegner sind besiegt!" if humans.size() == 1 else "%s gewinnt!" % winner_player.name)
|
||||
|
||||
|
||||
# --- Zustand für das Netzwerk -------------------------------------------------
|
||||
|
||||
## Serialisierter Zustand aus Sicht eines Spielers: fremde Hände, Decks und Fallen nur als Anzahl.
|
||||
func snapshot(viewer: int) -> Dictionary:
|
||||
var ps := []
|
||||
for i in players.size():
|
||||
var p: Player = players[i]
|
||||
var mine := i == viewer
|
||||
var board := []
|
||||
for c in p.board:
|
||||
board.append({"uid": c.uid, "card": c.card.id, "attack": c.attack, "resonance": c.resonance,
|
||||
"health": c.health, "max_health": c.max_health, "shield": c.shield, "frozen": c.frozen,
|
||||
"ready": c.ready, "attacks_left": c.attacks_left})
|
||||
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, "fatigue": p.fatigue, "start_bonus": p.start_bonus,
|
||||
"order": p.order, "perks": p.perks, "turns": p.turns, "mulligan_done": p.mulligan_done,
|
||||
"hand": p.hand.map(func(c): return c.id) if mine else p.hand.size(),
|
||||
"deck": p.deck.size(), "traps": p.traps.map(func(c): return c.id) if mine else p.traps.size(),
|
||||
"board": board})
|
||||
var evs := []
|
||||
for ev in events:
|
||||
var e: Dictionary = ev.duplicate()
|
||||
if e.has("card"):
|
||||
e["card"] = e.card.id
|
||||
evs.append(e)
|
||||
return {"players": ps, "human": players.find(human), "turn": turn, "current_idx": current_idx,
|
||||
"winner": winner, "winner_player": players.find(winner_player) if winner_player != null else -1,
|
||||
"next_uid": next_uid, "log": log.slice(maxi(0, 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 := 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.fatigue = int(pd.fatigue)
|
||||
p.start_bonus = int(pd.start_bonus)
|
||||
p.order = int(pd.order)
|
||||
p.perks = Array(pd.perks)
|
||||
p.turns = int(pd.turns)
|
||||
p.mulligan_done = bool(pd.mulligan_done)
|
||||
if pd.hand is Array:
|
||||
for cid in pd.hand:
|
||||
p.hand.append(Cards.by_id(cid))
|
||||
else:
|
||||
for i in int(pd.hand):
|
||||
p.hand.append(placeholder)
|
||||
for i in int(pd.deck):
|
||||
p.deck.append(placeholder)
|
||||
if pd.traps is Array:
|
||||
for cid in pd.traps:
|
||||
p.traps.append(Cards.by_id(cid))
|
||||
else:
|
||||
for i in int(pd.traps):
|
||||
p.traps.append(placeholder)
|
||||
for cd in pd.board:
|
||||
var c := Creature.new(Cards.by_id(cd.card), p, int(cd.uid))
|
||||
c.attack = int(cd.attack)
|
||||
c.resonance = int(cd.resonance)
|
||||
c.health = int(cd.health)
|
||||
c.max_health = int(cd.max_health)
|
||||
c.shield = bool(cd.shield)
|
||||
c.frozen = bool(cd.frozen)
|
||||
c.ready = bool(cd.ready)
|
||||
c.attacks_left = int(cd.attacks_left)
|
||||
p.board.append(c)
|
||||
list.append(p)
|
||||
var hi := int(d.human)
|
||||
var g := Game.new(list[hi], list.slice(0, hi) + list.slice(hi + 1), 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 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"] = Cards.by_id(e.card)
|
||||
for key in ["player", "uid", "count", "amount"]:
|
||||
if e.has(key):
|
||||
e[key] = int(e[key])
|
||||
for key in ["target", "attacker", "source"]:
|
||||
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
|
||||
|
||||
|
||||
# --- Deckregeln und Gegner ---------------------------------------------------
|
||||
|
||||
static func shuffle(arr: Array, r: RandomNumberGenerator) -> void:
|
||||
for i in range(arr.size() - 1, 0, -1):
|
||||
var j := r.randi_range(0, i)
|
||||
var tmp = arr[i]
|
||||
arr[i] = arr[j]
|
||||
arr[j] = tmp
|
||||
|
||||
|
||||
static func deck_elements(cards: Array) -> Array:
|
||||
var out := []
|
||||
for c in cards:
|
||||
for e in c.elements:
|
||||
if not (e in out):
|
||||
out.append(e)
|
||||
return out
|
||||
|
||||
|
||||
## Prüft ein Deck. owned: Dictionary id -> Anzahl (null = keine Besitzprüfung).
|
||||
static func validate_deck(cards: Array, owned = null) -> Array:
|
||||
if cards.size() != DECK_SIZE:
|
||||
return [false, "Deck braucht genau %d Karten (%d)" % [DECK_SIZE, cards.size()]]
|
||||
var counts := {}
|
||||
for c in cards:
|
||||
counts[c.id] = counts.get(c.id, 0) + 1
|
||||
for cid in counts:
|
||||
if counts[cid] > MAX_COPIES:
|
||||
return [false, "Höchstens %dx dieselbe Karte" % MAX_COPIES]
|
||||
if owned != null and owned.get(cid, 0) < counts[cid]:
|
||||
return [false, "Karte nicht oft genug in der Sammlung"]
|
||||
if deck_elements(cards).size() > MAX_DECK_ELEMENTS:
|
||||
return [false, "Höchstens %d Elemente im Deck" % MAX_DECK_ELEMENTS]
|
||||
return [true, ""]
|
||||
|
||||
|
||||
## Gegnerdeck aus den Elementen. bias > 1 bevorzugt seltene Karten (Kampagne).
|
||||
static func build_opponent_deck(r: RandomNumberGenerator, elements: Array, bias: float = 1.0) -> Array:
|
||||
var pool := Cards.all().filter(func(c): return c.elements.all(func(e): return e in elements))
|
||||
var weights := PackedFloat32Array()
|
||||
for c in pool:
|
||||
var w: float = OPPONENT_RARITY_WEIGHT[c.rarity]
|
||||
weights.append(w / bias if c.rarity == "gewöhnlich" else w * bias)
|
||||
var deck := []
|
||||
var counts := {}
|
||||
while deck.size() < DECK_SIZE:
|
||||
var c = pool[r.rand_weighted(weights)]
|
||||
if counts.get(c.id, 0) < MAX_COPIES:
|
||||
counts[c.id] = counts.get(c.id, 0) + 1
|
||||
deck.append(c)
|
||||
return deck
|
||||
|
||||
|
||||
static func random_opponent(r: RandomNumberGenerator, index: int, life: int = START_LIFE) -> Player:
|
||||
var elements: Array
|
||||
if r.randf() < 0.4:
|
||||
elements = [Cards.ELEMENTS[r.randi_range(0, Cards.ELEMENTS.size() - 1)]]
|
||||
else:
|
||||
var pool: Array = Cards.ELEMENTS.duplicate()
|
||||
shuffle(pool, r)
|
||||
elements = [pool[0], pool[1]]
|
||||
return Player.new("Gegner %d" % index, build_opponent_deck(r, elements), false, life,
|
||||
Cards.combo_name(elements) + "-Magier")
|
||||
|
||||
|
||||
## rules: {"human_perks": [...], "everyone_perk": String, "start_life": int}
|
||||
static func new_battle(deck: Array, n_opp: int, r: RandomNumberGenerator = null, rules: Dictionary = {}) -> Game:
|
||||
assert(n_opp >= 1 and n_opp <= MAX_OPPONENTS, "1 bis 5 Gegner")
|
||||
if r == null:
|
||||
r = make_rng()
|
||||
var opps := []
|
||||
for i in n_opp:
|
||||
opps.append(random_opponent(r, i + 1))
|
||||
return new_battle_with(deck, opps, r, false, rules)
|
||||
|
||||
|
||||
static func new_battle_with(deck: Array, opps: Array, r: RandomNumberGenerator = null, fixed_order: bool = false, rules: Dictionary = {}) -> Game:
|
||||
if r == null:
|
||||
r = make_rng()
|
||||
var human := Player.new("Du", deck, true, START_LIFE)
|
||||
human.perks = Array(rules.get("human_perks", []))
|
||||
var g := Game.new(human, opps, r)
|
||||
var everyone: String = rules.get("everyone_perk", "")
|
||||
for p in g.players:
|
||||
if everyone != "" and not (everyone in p.perks):
|
||||
p.perks.append(everyone)
|
||||
if rules.has("start_life"):
|
||||
p.life = int(rules.start_life)
|
||||
p.max_life = p.life
|
||||
elif "leben_35" in p.perks and p.life == START_LIFE:
|
||||
p.life = 35
|
||||
p.max_life = 35
|
||||
g.start(fixed_order)
|
||||
return g
|
||||
|
||||
|
||||
## Hotseat: mehrere Menschen am selben Rechner, dazu KI-Gegner.
|
||||
static func new_hotseat(human_decks: Array, n_ai: int, r: RandomNumberGenerator = null) -> Game:
|
||||
assert(human_decks.size() >= 1 and human_decks.size() + n_ai <= MAX_OPPONENTS + 1, "höchstens 6 am Tisch")
|
||||
if r == null:
|
||||
r = make_rng()
|
||||
var first := Player.new("Spieler 1", human_decks[0], true, START_LIFE)
|
||||
var others := []
|
||||
for i in range(1, human_decks.size()):
|
||||
others.append(Player.new("Spieler %d" % (i + 1), human_decks[i], true, START_LIFE))
|
||||
for i in n_ai:
|
||||
others.append(random_opponent(r, i + 1))
|
||||
var g := Game.new(first, others, r)
|
||||
g.start()
|
||||
return g
|
||||
Reference in New Issue
Block a user