1050 lines
37 KiB
GDScript
1050 lines
37 KiB
GDScript
class_name BattleScreen
|
|
extends Control
|
|
## Kampf: Zustand, Eingabe und Abgleich der Ansicht. Layout in BattleLayout, Animationen in BattleFx.
|
|
## Modi: Einzelspieler, Kampagne, Netzwerk (Host, Mitspieler oder Zuschauer).
|
|
|
|
var app
|
|
var stage := -1 # Kampagnenstufe oder -1
|
|
var net_play := false # Netzwerkspiel (auch als Zuschauer)
|
|
var online_seat := -1 # Netzwerk: eigener Platz, Zuschauer -1
|
|
var net: Net
|
|
var game: Game
|
|
var perspective: Game.Player # der Mensch, dessen Hand unten liegt
|
|
var fx: BattleFx
|
|
var selected = null # Game.Creature
|
|
var pending = null # Cards.Card, wartet auf Ziel
|
|
var fusing := false # Verschmelzen gewählt: zwei eigene Wesen anklicken
|
|
var fuse_first = null # Game.Creature, erstes Wesen der Verschmelzung
|
|
var msg_t := 0.0
|
|
var ai_delay := 0.75
|
|
var ai_timer := 0.0
|
|
var ai_task := -1 # WorkerThreadPool-Aufgabe der laufenden KI-Berechnung
|
|
var ai_copy: Game # Spielkopie, auf der die KI rechnet
|
|
var ai_box := {} # Ergebnis der Berechnung (vom Thread befüllt)
|
|
var reward := -1
|
|
var ended := false
|
|
var pad: BattleGamepad
|
|
var gp_zone: String:
|
|
get:
|
|
return pad.zone
|
|
var gp_index: int:
|
|
get:
|
|
return pad.index
|
|
var skip_ai := false # Gegnerzüge im Schnelldurchlauf
|
|
var smart_ai := true # Vorausschau-KI (Leicht: einfache KI)
|
|
var undo_state: Game = null # Zustand vor der letzten rückgängig machbaren Aktion
|
|
var undo_log_len := 0
|
|
var undo_t := 0.0
|
|
|
|
# Ansichten (auch für Tests)
|
|
var tiles := {}
|
|
var hand_views: Array = []
|
|
var shop_views: Array = []
|
|
var own_views: Array = []
|
|
var enemy_views: Array = []
|
|
var hero_panels := {} # Player -> Panel
|
|
var hero_labels := {}
|
|
var flash_until := {} # Spielerindex -> Zeitpunkt (ms)
|
|
|
|
var hero_layer: Control
|
|
var tile_layer: Control
|
|
var hand_layer: Control
|
|
var shop_layer: Control
|
|
var log_overlay: Control
|
|
var b_log: Button
|
|
var status_panel: Panel
|
|
var fx_layer: Control
|
|
var log_box: RichTextLabel
|
|
var preview_holder: Control
|
|
var name_label: Label
|
|
var life_label: Label
|
|
var energy_label: Label
|
|
var income_label: Label
|
|
var status_label: Label
|
|
var msg_label: Label
|
|
var b_end: Button
|
|
var b_fuse: Button
|
|
var b_reroll: Button
|
|
var b_giveup: Button
|
|
var field_view: FieldView
|
|
var link_view: Links # Resonanzlinien unter den Feldreihen
|
|
var info_label: Label # Vorschau: Resonanz, Feld, Feldkombo
|
|
var board_panel: Panel # eigenes Brett, färbt sich mit dem Feld
|
|
var arrivals := {} # uid -> Rect2: Wesen, das gerade aus der Hand aufs Brett fliegt
|
|
var banner_turn := -1 # Zug, für den die Zugansage schon lief
|
|
var deal_shop := false # nächster Aufbau teilt den Laden animiert aus
|
|
var overlay: Control
|
|
var result_label: Label
|
|
var reward_label: Label
|
|
var notice_label: Label
|
|
var confirm: Control
|
|
var cursor_layer: Control
|
|
var wait_label: Label
|
|
var b_skip: Button
|
|
var b_undo: Button
|
|
|
|
|
|
func _init(campaign_stage: int = -1) -> void:
|
|
stage = campaign_stage
|
|
|
|
|
|
static func online(seat: int) -> BattleScreen:
|
|
var b := BattleScreen.new(-1)
|
|
b.net_play = true
|
|
b.online_seat = seat
|
|
return b
|
|
|
|
|
|
func is_online() -> bool:
|
|
return net_play
|
|
|
|
|
|
## Zuschauer im Netzwerk: kein eigener Platz, keine Hand.
|
|
func spectating() -> bool:
|
|
return is_online() and online_seat < 0
|
|
|
|
|
|
func is_client() -> bool:
|
|
return is_online() and not net.is_host
|
|
|
|
|
|
func counts_for_profile() -> bool:
|
|
return not is_online()
|
|
|
|
|
|
func _ready() -> void:
|
|
var s: Dictionary = app.profile.settings
|
|
fx = BattleFx.new(self)
|
|
fx.enabled = s.animations
|
|
pad = BattleGamepad.new(self)
|
|
ai_delay = 0.75 / float(s.ai_speed)
|
|
_build_static()
|
|
if is_online():
|
|
net = app.net
|
|
net.ended.connect(_on_net_ended)
|
|
net.migrated.connect(_on_migrated)
|
|
net.status_changed.connect(_on_net_status)
|
|
if net.is_host:
|
|
game = net.game
|
|
net.action_applied.connect(after_action)
|
|
else:
|
|
net.snapshot_received.connect(_on_snapshot)
|
|
wait_label.visible = true
|
|
return # der erste Zustand kommt vom Host
|
|
elif stage >= 0:
|
|
var r := Game.make_rng()
|
|
game = Game.new_battle_with(Campaign.opponent(stage), r, false, own_rules())
|
|
else:
|
|
game = Game.new_battle(Game.make_rng(), own_rules())
|
|
smart_ai = bool(app.profile.difficulty().smart) or not counts_for_profile()
|
|
_begin()
|
|
|
|
|
|
## Kartenoptik, Gegnerleben (Schwierigkeit) und das eigene Merkmal (nach Kapitel 1).
|
|
func own_rules() -> Dictionary:
|
|
var p: Profile = app.profile
|
|
var rules := {"looks": p.looks()}
|
|
if stage < 0:
|
|
rules["opponent_life"] = int(p.difficulty().life)
|
|
if p.perk != "" and p.perk_unlocked():
|
|
rules["human_perks"] = [p.perk]
|
|
return rules
|
|
|
|
|
|
func _begin() -> void:
|
|
if is_online():
|
|
perspective = game.players[maxi(online_seat, 0)]
|
|
else:
|
|
game.events.clear()
|
|
perspective = game.current() if game.current().is_human else game.humans[0]
|
|
build_hero_boxes()
|
|
if is_online() and net.is_host:
|
|
net.broadcast()
|
|
game.events.clear()
|
|
refresh()
|
|
announce_turn()
|
|
|
|
|
|
func _build_static() -> void:
|
|
var L := BattleLayout
|
|
# oben links: Aufgeben und Verlauf, klein
|
|
b_giveup = Style.button(self, "Aufgeben", L.B_GIVEUP, func(): confirm.visible = true)
|
|
b_giveup.add_theme_font_size_override("font_size", 13)
|
|
b_log = Style.button(self, "Verlauf", L.B_LOG, toggle_log)
|
|
b_log.add_theme_font_size_override("font_size", 13)
|
|
# Mitte: Feldband, Meldung, eigenes Brett mit fünf Plätzen, eigene Leiste links daneben
|
|
Style.panel(self, L.FIELD, Style.darker(Style.PANEL, 0.9), 8)
|
|
field_view = FieldView.new(L.FIELD)
|
|
add_child(field_view)
|
|
msg_label = Style.label(self, "", 15, Style.ORANGE, L.MSG, "center", true)
|
|
board_panel = Style.panel(self, L.OWN_PANEL, Style.darker(Style.PANEL, 0.8), 10)
|
|
var slots := Control.new()
|
|
slots.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
slots.draw.connect(func():
|
|
for j in Game.MAX_BOARD:
|
|
Style.border(slots, L.own_slot(j), Color(1, 1, 1, 0.08), 2, 8)
|
|
Style.border(slots, L.opp_slot(j), Color(1, 1, 1, 0.05), 2, 8))
|
|
add_child(slots)
|
|
status_panel = Style.panel(self, L.STATUS)
|
|
var sx: float = L.STATUS.position.x
|
|
var sy: float = L.STATUS.position.y
|
|
name_label = Style.label(self, "", 18, Style.TEXT, Rect2(sx + 12, sy + 8, 190, 26), "left", true)
|
|
name_label.clip_text = true
|
|
life_label = Style.label(self, "", 26, Style.RED, Rect2(sx + 12, sy + 40, 190, 34), "left", true)
|
|
energy_label = Style.label(self, "", 26, Style.BLUE, Rect2(sx + 12, sy + 78, 100, 34), "left", true)
|
|
income_label = Style.label(self, "", 15, Style.MUTED, Rect2(sx + 100, sy + 88, 100, 22), "left")
|
|
status_label = Style.label(self, "", 13, Style.MUTED, Rect2(sx + 12, sy + 124, 190, 22), "left")
|
|
b_fuse = Style.button(self, "Verschmelzen", L.B_FUSE, toggle_fuse, Color("3c2858"))
|
|
b_fuse.add_theme_font_size_override("font_size", 15)
|
|
b_fuse.visible = false
|
|
b_undo = Style.button(self, "Rückgängig", L.B_UNDO, undo)
|
|
b_undo.add_theme_font_size_override("font_size", 15)
|
|
b_undo.visible = false
|
|
# unten: Laden mit Neuwürfeln links und Zug beenden rechts
|
|
b_reroll = Style.button(self, "", L.B_REROLL, do_reroll, Color("285a5a"))
|
|
b_reroll.add_theme_font_size_override("font_size", 15)
|
|
b_end = Style.button(self, "Zug beenden", L.B_END, end_turn, Style.PRIMARY)
|
|
b_end.add_theme_font_size_override("font_size", 20)
|
|
b_skip = Style.button(self, "Gegnerzüge überspringen", L.B_END, func(): skip_ai = true)
|
|
b_skip.add_theme_font_size_override("font_size", 14)
|
|
b_skip.visible = false
|
|
wait_label = Style.label(self, "Warte auf den Host …", 22, Style.MUTED, Rect2(0, 300, 1280, 40), "center")
|
|
wait_label.visible = false
|
|
hero_layer = _layer()
|
|
link_view = Links.new()
|
|
add_child(link_view)
|
|
tile_layer = _layer()
|
|
hand_layer = _layer()
|
|
shop_layer = _layer()
|
|
preview_holder = _layer()
|
|
info_label = Style.label(self, "", 13, Style.TEXT, Rect2(0, 0, 220, 60), "center")
|
|
info_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
info_label.visible = false
|
|
fx_layer = _layer()
|
|
cursor_layer = _layer()
|
|
# Verlauf als Überlagerung
|
|
log_overlay = Style.overlay(self)
|
|
log_overlay.get_child(0).gui_input.connect(func(ev):
|
|
if ev is InputEventMouseButton and ev.pressed:
|
|
log_overlay.visible = false)
|
|
Style.panel(log_overlay, L.LOG_PANEL, Style.PANEL, 10, Style.MUTED, 2)
|
|
Style.label(log_overlay, "Verlauf", 20, Style.GOLD, Rect2(L.LOG_PANEL.position + Vector2(20, 12), Vector2(300, 30)), "left", true)
|
|
log_box = RichTextLabel.new()
|
|
log_box.position = L.LOG_PANEL.position + Vector2(20, 50)
|
|
log_box.size = L.LOG_PANEL.size - Vector2(40, 110)
|
|
log_box.bbcode_enabled = true
|
|
log_box.scroll_following = true
|
|
log_box.add_theme_font_size_override("normal_font_size", 14)
|
|
log_box.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
log_overlay.add_child(log_box)
|
|
Style.button(log_overlay, "Schließen", Rect2(L.LOG_PANEL.end.x - 180, L.LOG_PANEL.end.y - 52, 160, 40), func(): log_overlay.visible = false)
|
|
# Spielende
|
|
overlay = _overlay()
|
|
result_label = Style.label(overlay, "", 56, Style.GREEN, Rect2(0, 250, 1280, 80), "center", true)
|
|
reward_label = Style.label(overlay, "", 26, Style.GOLD, Rect2(0, 335, 1280, 40), "center")
|
|
notice_label = Style.label(overlay, "", 18, Style.GREEN, Rect2(0, 385, 1280, 80), "center")
|
|
Style.button(overlay, "Zurück zum Menü", Rect2(530, 480, 220, 50), leave, Color("285a3c"))
|
|
confirm = Style.confirm(self, "Wirklich aufgeben?", "", "Ja, aufgeben", leave, "Weiterspielen")
|
|
|
|
|
|
func toggle_log() -> void:
|
|
log_overlay.visible = not log_overlay.visible
|
|
|
|
|
|
func _layer() -> Control:
|
|
var c := Control.new()
|
|
c.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
add_child(c)
|
|
return c
|
|
|
|
|
|
func _overlay() -> Control:
|
|
return Style.overlay(self)
|
|
|
|
|
|
func leave() -> void:
|
|
if is_online():
|
|
net.leave()
|
|
app.show_screen(MenuScreen.new())
|
|
|
|
|
|
# --- Layout-Helfer ------------------------------------------------------------------
|
|
|
|
## Der Gegner aus Sicht der eigenen Perspektive (Zuschauer: der zweite Spieler).
|
|
func opponent() -> Game.Player:
|
|
return game.enemy_of(perspective)
|
|
|
|
|
|
func others() -> Array:
|
|
return [opponent()]
|
|
|
|
|
|
func slot_rect(p: Game.Player, j: int) -> Rect2:
|
|
if p == perspective:
|
|
return BattleLayout.own_slot(j)
|
|
return BattleLayout.opp_slot(j)
|
|
|
|
|
|
func ref_key(ref: Dictionary) -> String:
|
|
return "c%d" % ref.uid if ref.kind == "creature" else "p%d" % ref.index
|
|
|
|
|
|
func target_center(ref: Dictionary) -> Vector2:
|
|
if ref.kind == "creature":
|
|
if tiles.has(ref.uid):
|
|
var t: CreatureView = tiles[ref.uid]
|
|
return t.slot + t.size / 2
|
|
return Vector2(-1, -1)
|
|
var p: Game.Player = game.players[ref.index]
|
|
if p == perspective:
|
|
return BattleLayout.STATUS.get_center()
|
|
if hero_panels.has(p):
|
|
var panel: Panel = hero_panels[p]
|
|
return panel.position + panel.size / 2
|
|
return Vector2(-1, -1)
|
|
|
|
|
|
## Kasten des Gegners oben in der Mitte; ein Klick zielt auf den Helden.
|
|
func build_hero_boxes() -> void:
|
|
Style.clear(hero_layer)
|
|
hero_panels = {}
|
|
hero_labels = {}
|
|
var o := opponent()
|
|
var box := BattleLayout.OPP_BOX
|
|
var panel := Style.panel(hero_layer, box)
|
|
panel.gui_input.connect(func(ev):
|
|
if ev is InputEventMouseButton and ev.pressed and ev.button_index == MOUSE_BUTTON_LEFT:
|
|
on_click("hero", o))
|
|
if not o.perks.is_empty():
|
|
panel.tooltip_text = "Merkmal: " + ", ".join(o.perks.map(func(k): return Game.PERKS[k]))
|
|
hero_panels[o] = panel
|
|
var labels := {}
|
|
var title: String = ("%s · %s" % [o.name, o.title]) if o.title != "" else o.name
|
|
if not o.perks.is_empty():
|
|
title += " ★"
|
|
labels["name"] = Style.label(hero_layer, title, 18, Style.TEXT, Rect2(box.position.x + 8, box.position.y + 4, box.size.x - 16, 22), "left", true)
|
|
labels.name.clip_text = true
|
|
labels.name.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
|
labels["life"] = Style.label(hero_layer, "", 20, Style.RED, Rect2(box.position.x + 8, box.position.y + 30, 120, 24), "left", true)
|
|
labels["stats"] = Style.label(hero_layer, "", 14, Style.MUTED, Rect2(box.position.x + 80, box.position.y + 34, box.size.x - 88, 20), "right")
|
|
hero_labels[o] = labels
|
|
|
|
|
|
# --- Ablauf und Eingabe ------------------------------------------------------------------
|
|
|
|
func my_turn() -> bool:
|
|
if spectating():
|
|
return false
|
|
return game != null and game.winner == "" and game.current() == perspective
|
|
|
|
|
|
func any_overlay() -> bool:
|
|
return confirm.visible or overlay.visible or log_overlay.visible
|
|
|
|
|
|
func _input(event: InputEvent) -> void:
|
|
if game == null:
|
|
return
|
|
if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_RIGHT:
|
|
cancel_all()
|
|
return
|
|
if event is InputEventJoypadButton and event.pressed:
|
|
pad.button(event.button_index)
|
|
return
|
|
if not (event is InputEventKey and event.pressed and not event.echo):
|
|
return
|
|
match event.keycode:
|
|
KEY_ESCAPE:
|
|
if confirm.visible:
|
|
confirm.visible = false
|
|
elif log_overlay.visible:
|
|
log_overlay.visible = false
|
|
elif selected != null or pending != null or fusing:
|
|
cancel_all()
|
|
elif not any_overlay():
|
|
confirm.visible = true
|
|
KEY_SPACE:
|
|
if my_turn() and not any_overlay():
|
|
end_turn()
|
|
elif b_skip.visible:
|
|
skip_ai = true
|
|
KEY_U:
|
|
if b_undo.visible:
|
|
undo()
|
|
KEY_ENTER, KEY_KP_ENTER:
|
|
if overlay.visible:
|
|
leave()
|
|
_:
|
|
if event.keycode >= KEY_1 and event.keycode <= KEY_9 and my_turn() and not any_overlay():
|
|
var idx: int = event.keycode - KEY_1
|
|
if idx < perspective.hand.size():
|
|
on_click("hand", perspective.hand[idx])
|
|
|
|
|
|
func cancel_all() -> void:
|
|
if confirm.visible:
|
|
confirm.visible = false
|
|
cancel()
|
|
refresh()
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if game == null:
|
|
return
|
|
msg_t = maxf(0.0, msg_t - delta)
|
|
if msg_t <= 0.0 and msg_label.text != "":
|
|
msg_label.text = ""
|
|
if undo_t > 0.0:
|
|
undo_t -= delta
|
|
if undo_t <= 0.0:
|
|
clear_undo()
|
|
if is_online() and net.is_host:
|
|
net.tick()
|
|
if game.winner != "":
|
|
if not ended:
|
|
ended = true
|
|
_finish()
|
|
return
|
|
var cur := game.current()
|
|
if cur.is_human:
|
|
return
|
|
if is_client():
|
|
return
|
|
if skip_ai:
|
|
ai_timer = 0.0
|
|
else:
|
|
ai_timer -= delta
|
|
var action: Dictionary
|
|
if smart_ai:
|
|
# Die Vorausschau rechnet im Hintergrund auf einer Kopie, schon während der Wartezeit,
|
|
# damit Animationen nicht stocken.
|
|
if ai_task < 0:
|
|
_start_ai(cur)
|
|
if ai_timer > 0 or not WorkerThreadPool.is_task_completed(ai_task):
|
|
return
|
|
WorkerThreadPool.wait_for_task_completion(ai_task)
|
|
ai_task = -1
|
|
action = AI.map_action(game, ai_copy, ai_box.action)
|
|
ai_copy = null
|
|
else:
|
|
if ai_timer > 0:
|
|
return
|
|
action = AI.choose_action_greedy(game, cur)
|
|
AI.apply_action(game, cur, action)
|
|
ai_timer = ai_delay * (0.6 if action.type == "end" else 1.0)
|
|
if game.current().is_human:
|
|
skip_ai = false
|
|
after_action()
|
|
|
|
|
|
func _start_ai(cur: Game.Player) -> void:
|
|
ai_copy = game.clone()
|
|
var copy := ai_copy
|
|
var idx := game.current_idx
|
|
var box := ai_box
|
|
ai_task = WorkerThreadPool.add_task(func(): box["action"] = AI.choose_action(copy, copy.players[idx]))
|
|
|
|
|
|
func _exit_tree() -> void:
|
|
if ai_task >= 0:
|
|
WorkerThreadPool.wait_for_task_completion(ai_task)
|
|
ai_task = -1
|
|
|
|
|
|
func _finish() -> void:
|
|
var won := game.winner == "human"
|
|
if counts_for_profile():
|
|
var factor: float = float(app.profile.difficulty().reward) if stage < 0 else 1.0
|
|
reward = app.profile.record_battle(won, stage, factor)
|
|
app.save()
|
|
app.sfx.play("win" if won else "lose")
|
|
else:
|
|
var wp := game.winner_player
|
|
var mine: bool = wp != null and wp == perspective
|
|
app.sfx.play("win" if mine else "lose")
|
|
refresh()
|
|
|
|
|
|
func say(m: String) -> void:
|
|
msg_t = 2.5
|
|
msg_label.text = m
|
|
|
|
|
|
func cancel() -> void:
|
|
selected = null
|
|
pending = null
|
|
fusing = false
|
|
fuse_first = null
|
|
|
|
|
|
func play(card: Cards.Card, target) -> void:
|
|
if is_client():
|
|
net.send_action({"type": "play", "hand": perspective.hand.find(card), "target": Net.ref_dict(target) if target != null else null})
|
|
return
|
|
var before: Game = game.clone() if not is_online() else null
|
|
var log_len := game.log.size()
|
|
var from := _hand_rect_of(card)
|
|
var err := game.play_card(perspective, card, target)
|
|
if err != "":
|
|
say(tr(err))
|
|
return
|
|
if from.size.x > 0 and not perspective.board.is_empty() and perspective.board[-1].card == card:
|
|
arrivals[perspective.board[-1].uid] = from
|
|
# Rückgängig nur, wenn nichts weiter passiert ist (keine Effekte und keine Kombos)
|
|
if before != null and game.events.size() == 1 and game.events[0].type == "play":
|
|
undo_state = before
|
|
undo_log_len = log_len
|
|
undo_t = 6.0
|
|
else:
|
|
clear_undo()
|
|
|
|
|
|
## Verschmelzen an- und abwählen (zwei eigene Wesen, siehe Game.fuse).
|
|
func toggle_fuse() -> void:
|
|
var on := not fusing
|
|
cancel()
|
|
fusing = on
|
|
say(tr("Zwei eigene Wesen wählen") if on else tr("Abgebrochen"))
|
|
after_action()
|
|
|
|
|
|
## Kauft ein Angebot aus dem Laden auf die Hand.
|
|
func do_buy(slot: int) -> void:
|
|
clear_undo()
|
|
if is_client():
|
|
net.send_action({"type": "buy", "slot": slot})
|
|
return
|
|
var from := BattleLayout.shop_rect(slot)
|
|
var offer = perspective.shop[slot] if slot < perspective.shop.size() else null
|
|
var err := game.buy(perspective, slot)
|
|
if err != "":
|
|
say(tr(err))
|
|
elif offer != null:
|
|
fx.sfx("buy")
|
|
fx.fly_card(offer, from, BattleLayout.hand_rect(perspective.hand.size(), perspective.hand.size() - 1),
|
|
Cards.RARITIES[int(perspective.looks.get(offer.id, 0))])
|
|
|
|
|
|
## Würfelt den Laden neu (kostet Mana).
|
|
func do_reroll() -> void:
|
|
if not my_turn() or any_overlay():
|
|
return
|
|
clear_undo()
|
|
if is_client():
|
|
net.send_action({"type": "reroll"})
|
|
after_action()
|
|
return
|
|
var err := game.reroll(perspective)
|
|
if err != "":
|
|
say(tr(err))
|
|
else:
|
|
deal_shop = true
|
|
after_action()
|
|
|
|
|
|
func do_fuse(a, b) -> void:
|
|
cancel()
|
|
clear_undo()
|
|
if is_client():
|
|
net.send_action({"type": "fuse", "uid": a.uid, "other": b.uid})
|
|
return
|
|
var err := game.fuse(perspective, a, b)
|
|
if err != "":
|
|
say(tr(err))
|
|
|
|
|
|
func clear_undo() -> void:
|
|
undo_state = null
|
|
undo_t = 0.0
|
|
b_undo.visible = false
|
|
|
|
|
|
## Nimmt das letzte Ausspielen eines Wesens zurück (nur solange nichts Verdecktes offenbart wurde).
|
|
func undo() -> void:
|
|
if undo_state == null:
|
|
return
|
|
var idx := game.players.find(perspective)
|
|
var restored := undo_state
|
|
restored.quiet = false
|
|
restored.rng = game.rng
|
|
restored.log = game.log.slice(0, undo_log_len)
|
|
restored.say("Rückgängig.")
|
|
game = restored
|
|
perspective = game.players[idx]
|
|
if is_online() and net.is_host:
|
|
net.game = game
|
|
clear_undo()
|
|
cancel()
|
|
build_hero_boxes()
|
|
after_action()
|
|
|
|
|
|
func end_turn() -> void:
|
|
if not my_turn():
|
|
return
|
|
cancel()
|
|
clear_undo()
|
|
if is_client():
|
|
net.send_action({"type": "end"})
|
|
return
|
|
game.end_turn()
|
|
ai_timer = ai_delay
|
|
after_action()
|
|
|
|
|
|
func on_click(kind: String, obj) -> void:
|
|
var g := game
|
|
if not my_turn() or any_overlay():
|
|
return
|
|
if fusing:
|
|
if kind != "own":
|
|
cancel()
|
|
say(tr("Abgebrochen"))
|
|
elif fuse_first == null:
|
|
fuse_first = obj
|
|
say(tr("Zweites Wesen wählen"))
|
|
elif obj == fuse_first:
|
|
fuse_first = null
|
|
else:
|
|
do_fuse(fuse_first, obj)
|
|
after_action()
|
|
return
|
|
if pending != null:
|
|
var card = pending
|
|
pending = null
|
|
if obj in g.valid_targets(perspective, card.target_type()):
|
|
play(card, obj)
|
|
else:
|
|
say(tr("Abgebrochen"))
|
|
after_action()
|
|
return
|
|
if selected != null:
|
|
var cr = selected
|
|
selected = null
|
|
if kind == "enemy" or kind == "hero":
|
|
clear_undo()
|
|
if is_client():
|
|
net.send_action({"type": "attack", "uid": cr.uid, "target": Net.ref_dict(obj)})
|
|
else:
|
|
var err := g.attack(cr, obj)
|
|
if err != "":
|
|
say(tr(err))
|
|
after_action()
|
|
return
|
|
match kind:
|
|
"shop":
|
|
do_buy(int(obj))
|
|
"hand":
|
|
var ok := g.can_play(perspective, obj)
|
|
if not ok[0]:
|
|
say(tr(ok[1]))
|
|
elif obj.target_type() != "" and not g.valid_targets(perspective, obj.target_type()).is_empty():
|
|
pending = obj
|
|
say(tr("Wähle ein Ziel"))
|
|
else:
|
|
play(obj, null)
|
|
"own":
|
|
if obj.can_attack():
|
|
selected = obj
|
|
say(tr("Wähle ein Angriffsziel"))
|
|
else:
|
|
say(tr("%s kann nicht angreifen") % obj.card.title())
|
|
after_action()
|
|
|
|
|
|
func on_tile_click(cr: Game.Creature) -> void:
|
|
var o = cr.owner()
|
|
if o == null:
|
|
return
|
|
if o == perspective:
|
|
on_click("own", cr)
|
|
elif o.alive():
|
|
on_click("enemy", cr)
|
|
|
|
|
|
## Zugansage, wenn der eigene Zug beginnt.
|
|
func announce_turn() -> void:
|
|
if game == null or not my_turn() or banner_turn == game.turn:
|
|
return
|
|
banner_turn = game.turn
|
|
fx.banner(tr("Dein Zug"), Style.GOLD)
|
|
fx.sfx("turn")
|
|
deal_shop = true
|
|
refresh()
|
|
|
|
|
|
func _hand_rect_of(card: Cards.Card) -> Rect2:
|
|
for v in hand_views:
|
|
if v.card == card:
|
|
return Rect2(v.position, v.size)
|
|
return Rect2()
|
|
|
|
|
|
## Vorschau schwebt neben der gezeigten Karte (anchor), darunter die Zusatzzeile (info).
|
|
func show_preview(card, entered: bool, owner_looks: Dictionary = {}, info: String = "", anchor: Rect2 = Rect2()) -> void:
|
|
Style.clear(preview_holder)
|
|
info_label.visible = entered and info != ""
|
|
info_label.text = info if entered else ""
|
|
if entered and card != null:
|
|
var r := BattleLayout.preview_rect(anchor)
|
|
var v := CardView.new(card, r.size, false, Cards.RARITIES[int(owner_looks.get(card.id, 0))])
|
|
v.position = r.position
|
|
v.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
preview_holder.add_child(v)
|
|
var ir := BattleLayout.info_rect(r)
|
|
info_label.position = ir.position
|
|
info_label.size = ir.size
|
|
|
|
|
|
## Eigene Hand- und Ladenkarte: zeigt, was das Ausspielen jetzt brächte, und markiert den Kombo-Partner.
|
|
func show_hand_preview(card: Cards.Card, entered: bool, anchor: Rect2 = Rect2()) -> void:
|
|
var f := game.forecast(perspective, card)
|
|
var lines: Array[String] = []
|
|
var parts: Array[String] = []
|
|
if f.resonance > 0:
|
|
parts.append(tr("Resonanz +%d") % f.resonance)
|
|
if f.field > 0:
|
|
parts.append(tr("Feld +%d") % f.field)
|
|
if not parts.is_empty():
|
|
lines.append(" · ".join(parts))
|
|
if f.combo != "":
|
|
lines.append(tr("Feldkombo %s mit %s: %s") % [tr(f.combo), f.partner.card.title(), tr(Cards.FIELD_COMBO_TEXT[f.combo])])
|
|
for t in tiles.values():
|
|
t.mark = ""
|
|
t.queue_redraw()
|
|
if entered and f.partner != null and tiles.has(f.partner.uid):
|
|
tiles[f.partner.uid].mark = f.combo
|
|
tiles[f.partner.uid].queue_redraw()
|
|
show_preview(card, entered, perspective.looks, "\n".join(lines), anchor)
|
|
|
|
|
|
## Hand- und Ladenkarte tragen ihren Bonus und ihre Feldkombo als Vorschau.
|
|
func apply_forecast(v: CardView) -> void:
|
|
var f := game.forecast(perspective, v.card)
|
|
v.bonus = f.resonance + f.field
|
|
v.tag = f.combo
|
|
|
|
|
|
## Was den Angriff eines Wesens gerade hebt.
|
|
func creature_info(cr: Game.Creature) -> String:
|
|
var parts: Array[String] = []
|
|
if cr.resonance > 0:
|
|
parts.append(tr("Resonanz +%d") % cr.resonance)
|
|
if cr.field_bonus > 0:
|
|
parts.append(tr("Feld +%d") % cr.field_bonus)
|
|
var perk := cr.power() - cr.attack - cr.resonance - cr.field_bonus
|
|
if perk > 0:
|
|
parts.append(tr("Merkmal +%d") % perk)
|
|
return " · ".join(parts)
|
|
|
|
|
|
## Elementvorteil gegen ein mögliches Ziel: des gewählten Angreifers oder eines Schadenszaubers auf der Hand.
|
|
func matchup_for(cr: Game.Creature, valid: Array) -> int:
|
|
if selected != null and game.can_attack(selected, cr)[0]:
|
|
return Game.matchup_bonus(selected, cr)
|
|
if pending != null and cr in valid and pending.effects.any(func(fx): return fx.kind == "damage" and fx.target in Cards.CHOSEN_TARGETS):
|
|
return Cards.matchup(pending.elements, cr.card.elements)
|
|
return 0
|
|
|
|
|
|
## Resonanzgruppen je Reihe: Wesen mit gleichem Element werden unter der Reihe verbunden.
|
|
func resonance_groups() -> Array:
|
|
var out := []
|
|
for p in game.players:
|
|
var k := 0
|
|
for e in Cards.ELEMENTS:
|
|
var xs: Array[float] = []
|
|
for j in p.board.size():
|
|
if e in p.board[j].card.elements:
|
|
xs.append(slot_rect(p, j).get_center().x)
|
|
if xs.size() < 2:
|
|
continue
|
|
out.append({"color": Style.lighter(Cards.ELEMENT_COLORS[e], 0.25), "y": slot_rect(p, 0).end.y + 4 + k * 6, "xs": xs})
|
|
k += 1
|
|
return out
|
|
|
|
|
|
class Links extends Control:
|
|
var groups: Array = []
|
|
|
|
func _init() -> void:
|
|
set_anchors_preset(Control.PRESET_FULL_RECT)
|
|
mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
|
|
func _draw() -> void:
|
|
for gr in groups:
|
|
var y: float = gr.y
|
|
draw_line(Vector2(gr.xs[0], y), Vector2(gr.xs[-1], y), gr.color, 3.0)
|
|
for x in gr.xs:
|
|
draw_circle(Vector2(x, y), 4.0, gr.color)
|
|
|
|
|
|
# --- Netzwerk -------------------------------------------------------------------------------
|
|
|
|
func _on_snapshot(snap: Dictionary) -> void:
|
|
var first := game == null
|
|
game = Game.from_snapshot(snap)
|
|
wait_label.visible = false
|
|
if first:
|
|
_begin()
|
|
return
|
|
perspective = game.players[maxi(online_seat, 0)]
|
|
build_hero_boxes()
|
|
after_action()
|
|
|
|
|
|
## Host-Wechsel: das Spiel läuft jetzt auf diesem Rechner weiter.
|
|
func _on_migrated() -> void:
|
|
game = net.game
|
|
if not net.action_applied.is_connected(after_action):
|
|
net.action_applied.connect(after_action)
|
|
wait_label.visible = false
|
|
perspective = game.players[online_seat]
|
|
build_hero_boxes()
|
|
say("Du bist jetzt Host.")
|
|
after_action()
|
|
|
|
|
|
func _on_net_status() -> void:
|
|
wait_label.text = net.status
|
|
wait_label.visible = true
|
|
|
|
|
|
func _on_net_ended(reason: String) -> void:
|
|
if game == null or game.winner == "":
|
|
say(reason)
|
|
await get_tree().create_timer(1.5).timeout
|
|
if is_inside_tree():
|
|
app.show_screen(MenuScreen.new())
|
|
|
|
|
|
# --- Ereignisse ----------------------------------------------------------------------------
|
|
|
|
## Nach jeder Aktion: Ereignisse sichern, Ansicht angleichen, Animationen abspielen.
|
|
func after_action() -> void:
|
|
if is_online() and net.is_host:
|
|
net.broadcast()
|
|
var evs := game.events.duplicate()
|
|
game.events.clear()
|
|
var centers := {}
|
|
for ev in evs:
|
|
for key in ["target", "attacker", "source"]:
|
|
if ev.has(key):
|
|
centers[ref_key(ev[key])] = target_center(ev[key])
|
|
refresh()
|
|
fx.play_events(evs, centers)
|
|
announce_turn()
|
|
|
|
|
|
# --- Ansicht angleichen --------------------------------------------------------------------
|
|
|
|
func refresh() -> void:
|
|
if game == null:
|
|
return
|
|
var g := game
|
|
var h := perspective
|
|
var now := Time.get_ticks_msec()
|
|
var mine := my_turn()
|
|
var valid: Array = g.valid_targets(h, pending.target_type()) if pending != null else []
|
|
hand_views = []
|
|
shop_views = []
|
|
own_views = []
|
|
enemy_views = []
|
|
|
|
for o in others():
|
|
var panel: Panel = hero_panels[o]
|
|
var bcol = null
|
|
var bw := 0
|
|
if g.current() == o:
|
|
bcol = Style.BLUE
|
|
bw = 3
|
|
if o in valid or (selected != null and o.alive() and g.can_attack(selected, o)[0]):
|
|
bcol = Style.ORANGE
|
|
bw = 3
|
|
if int(flash_until.get(g.players.find(o), 0)) > now:
|
|
bcol = Style.RED
|
|
bw = 4
|
|
panel.add_theme_stylebox_override("panel", Style.box(Style.PANEL if o.alive() else Style.darker(Style.PANEL, 0.6), 8, bcol, bw))
|
|
panel.mouse_filter = Control.MOUSE_FILTER_STOP if o.alive() else Control.MOUSE_FILTER_IGNORE
|
|
var labels: Dictionary = hero_labels[o]
|
|
labels.name.add_theme_color_override("font_color", Style.TEXT if o.alive() else Style.MUTED)
|
|
if o.alive():
|
|
labels.life.text = "♥ %d" % maxi(o.life, 0)
|
|
labels.stats.text = "Hand %d ◆ %d (+%d)" % [o.hand.size(), o.energy, o.max_energy]
|
|
else:
|
|
labels.life.text = "besiegt"
|
|
labels.life.add_theme_color_override("font_color", Style.MUTED)
|
|
labels.stats.text = ""
|
|
|
|
var seen := {}
|
|
for p in g.players:
|
|
for j in p.board.size():
|
|
var cr: Game.Creature = p.board[j]
|
|
var rect := slot_rect(p, j)
|
|
seen[cr.uid] = true
|
|
var tile: CreatureView
|
|
if tiles.has(cr.uid):
|
|
tile = tiles[cr.uid]
|
|
tile.creature = cr
|
|
if tile.size != rect.size: # erst die Mindestgröße, sonst bleibt die Kachel groß
|
|
tile.custom_minimum_size = rect.size
|
|
tile.size = rect.size
|
|
tile.pivot_offset = rect.size / 2
|
|
tile.set_process(Style.rarity_animated(tile.rarity()))
|
|
else:
|
|
tile = CreatureView.new(cr, rect.size)
|
|
tile.position = rect.position
|
|
tile.slot = rect.position
|
|
tiles[cr.uid] = tile
|
|
tile_layer.add_child(tile)
|
|
var looks: Dictionary = p.looks
|
|
tile.hover.connect(func(card, entered): show_preview(card, entered, looks, creature_info(tile.creature) if entered else "", Rect2(tile.slot, tile.size)))
|
|
var uid := cr.uid
|
|
tile.clicked.connect(func(_v):
|
|
var c := game.find_creature(uid)
|
|
if c != null:
|
|
on_tile_click(c))
|
|
if arrivals.has(cr.uid):
|
|
fx.fly_in(tile, arrivals[cr.uid])
|
|
arrivals.erase(cr.uid)
|
|
else:
|
|
fx.pop_in(tile)
|
|
tile.slot = rect.position
|
|
if not tile.busy and tile.position != rect.position:
|
|
fx.move_to(tile, rect.position)
|
|
var b = null
|
|
var w := 2
|
|
if cr == selected or cr == fuse_first:
|
|
b = Style.YELLOW
|
|
w = 4
|
|
elif fusing and p == h and mine:
|
|
b = Style.PURPLE
|
|
w = 3
|
|
elif cr in valid or (selected != null and g.can_attack(selected, cr)[0]):
|
|
b = Style.ORANGE
|
|
w = 3
|
|
elif p == h and mine and cr.can_attack():
|
|
b = Style.GREEN
|
|
w = 3
|
|
tile.border = b
|
|
tile.width = w
|
|
tile.mark = ""
|
|
tile.matchup = matchup_for(cr, valid)
|
|
tile.queue_redraw()
|
|
if p == h:
|
|
own_views.append(tile)
|
|
else:
|
|
enemy_views.append(tile)
|
|
for uid in tiles.keys():
|
|
if not seen.has(uid):
|
|
var t: CreatureView = tiles[uid]
|
|
tiles.erase(uid)
|
|
fx.fade_out(t)
|
|
link_view.groups = resonance_groups()
|
|
link_view.queue_redraw()
|
|
|
|
Style.clear(shop_layer)
|
|
if not spectating():
|
|
for i in h.shop.size():
|
|
var offer = h.shop[i]
|
|
var sr := BattleLayout.shop_rect(i)
|
|
if offer == null:
|
|
Style.panel(shop_layer, sr, Style.darker(Style.PANEL, 0.8), 8, Style.PANEL_LIGHT, 2)
|
|
continue
|
|
var sv := CardView.new(offer, sr.size, false, Cards.RARITIES[int(h.looks.get(offer.id, 0))])
|
|
sv.position = sr.position
|
|
sv.lift = mine
|
|
apply_forecast(sv)
|
|
sv.dim = not mine or h.energy < offer.cost or h.hand.size() >= Game.MAX_HAND
|
|
sv.hover.connect(func(c, e): show_hand_preview(c, e, Rect2(sv.position, sv.size)))
|
|
var slot := i
|
|
sv.set_meta("slot", slot) # der Platz im Laden, auch für das Gamepad
|
|
sv.clicked.connect(func(_view): on_click("shop", slot))
|
|
shop_layer.add_child(sv)
|
|
shop_views.append(sv)
|
|
if deal_shop:
|
|
fx.deal(sv, i)
|
|
deal_shop = false
|
|
|
|
Style.clear(hand_layer)
|
|
if spectating():
|
|
Style.label(hand_layer, "Zuschauer: Hände sind verdeckt", 18, Style.MUTED, Rect2(240, BattleLayout.HAND_Y + 18, 800, 30), "center")
|
|
else:
|
|
for i in h.hand.size():
|
|
var card: Cards.Card = h.hand[i]
|
|
var playable: bool = mine and g.can_play(h, card)[0]
|
|
var r := BattleLayout.hand_rect(h.hand.size(), i)
|
|
var v := CardView.new(card, r.size, false, Cards.RARITIES[int(h.looks.get(card.id, 0))])
|
|
v.position = r.position
|
|
v.lift = mine
|
|
apply_forecast(v)
|
|
if card == pending:
|
|
v.border = Style.YELLOW
|
|
elif playable:
|
|
v.border = Style.GREEN
|
|
v.dim = not playable
|
|
v.hover.connect(func(c, e): show_hand_preview(c, e, Rect2(v.position, v.size)))
|
|
v.clicked.connect(func(_view): on_click("hand", card))
|
|
hand_layer.add_child(v)
|
|
hand_views.append(v)
|
|
|
|
var bar_border = Style.BLUE if mine else null
|
|
if int(flash_until.get(g.players.find(h), 0)) > now:
|
|
bar_border = Style.RED
|
|
status_panel.add_theme_stylebox_override("panel", Style.box(Style.PANEL, 8, bar_border, 3 if bar_border != null else 0))
|
|
var board_col := Style.darker(Style.PANEL, 0.8)
|
|
if g.field_element != "":
|
|
board_col = board_col.lerp(Cards.ELEMENT_COLORS[g.field_element], 0.22) # das Feld färbt das Brett
|
|
board_panel.add_theme_stylebox_override("panel", Style.box(board_col, 10))
|
|
name_label.text = h.name
|
|
life_label.text = "♥ %d" % maxi(h.life, 0)
|
|
energy_label.text = "◆ %d" % h.energy
|
|
income_label.text = tr("+%d je Zug") % h.max_energy
|
|
status_label.text = (tr("Zug %d · Du bist dran") % g.turn) if mine else (tr("Zug %d · %s ist dran …") % [g.turn, g.current().name])
|
|
if spectating():
|
|
status_label.text = tr("Zuschauer") + " · " + status_label.text
|
|
b_end.disabled = not mine
|
|
var ai_running: bool = g.winner == "" and not g.current().is_human and not is_client()
|
|
b_skip.visible = ai_running
|
|
b_end.visible = not ai_running and not spectating()
|
|
b_undo.visible = undo_state != null and mine
|
|
b_fuse.visible = mine and not spectating() and h.board.size() >= 2
|
|
b_reroll.visible = mine and not spectating()
|
|
b_reroll.text = tr("Neu würfeln ◆ %d") % Game.REROLL_COST
|
|
b_reroll.disabled = h.energy < Game.REROLL_COST
|
|
b_fuse.text = tr("Abbrechen") if fusing else tr("Verschmelzen")
|
|
field_view.update_from(g)
|
|
var lines: Array[String] = []
|
|
var start := maxi(0, g.log.size() - 60)
|
|
for i in range(start, g.log.size()):
|
|
var line := g.log[i]
|
|
if line.begins_with("---"):
|
|
lines.append("[color=#6eaaf0]%s[/color]" % line)
|
|
elif line.begins_with("Das Feld wird"):
|
|
lines.append("[color=#8c78dc]%s[/color]" % line)
|
|
elif line.begins_with("Feldkombo"):
|
|
lines.append("[color=#f5c850]%s[/color]" % line)
|
|
else:
|
|
lines.append(line)
|
|
log_box.text = "\n".join(lines)
|
|
pad.draw_cursor()
|
|
|
|
if g.winner != "":
|
|
var wp := g.winner_player
|
|
if counts_for_profile():
|
|
var won := g.winner == "human"
|
|
result_label.text = "Sieg!" if won else "Niederlage"
|
|
result_label.add_theme_color_override("font_color", Style.GREEN if won else Style.RED)
|
|
reward_label.text = "+%d Münzen" % maxi(reward, 0)
|
|
var notes: Array[String] = app.profile.take_notices()
|
|
if not notes.is_empty():
|
|
notice_label.text = "\n".join(notes)
|
|
else:
|
|
var mine_win: bool = wp != null and wp == perspective
|
|
result_label.text = ("%s gewinnt!" % wp.name) if wp != null and wp.is_human else "Die KI gewinnt"
|
|
result_label.add_theme_color_override("font_color", Style.GREEN if mine_win else Style.RED)
|
|
reward_label.text = "Gemeinsame Partie, keine Münzen"
|
|
overlay.visible = true
|
|
confirm.visible = false
|
|
|