update

scripts/ui/battle_screen.gd

@@ -1,8 +1,10 @@
 class_name BattleScreen
 extends Control
 ## Kampf: Zustand, Eingabe und Abgleich der Ansicht. Layout in BattleLayout, Animationen in BattleFx.
-## Rechtsklick (oder Y) auf eine Handkarte oder ein eigenes Wesen öffnet das Kartenmenü:
-## verdeckt legen, aufdecken, Eigenschaften kaufen.
+## Mittlere Maustaste auf eine Handkarte legt sie verdeckt. Rechtsklick auf eine Handkarte oder
+## ein eigenes Wesen öffnet das Kartenmenü: verdeckt legen, aufdecken, Eigenschaften kaufen.
+## Verschmelzen: eine Karte auf eine andere ziehen und dort eine Sekunde stillhalten. Mit
+## Gamepad öffnet Y das Menü, dort zusätzlich mit „Verschmelzen mit …“.
 ## Modi: Einzelspieler, Kampagne, Netzwerk (Host, Mitspieler oder Zuschauer).
 
 var app
@@ -14,8 +16,16 @@ var game: Game
 var perspective: Game.Player  # der Mensch, dessen Hand unten liegt
 var fx: BattleFx
 var selected = null          # Game.Creature
-var fusing := false          # Verschmelzen gewählt: zwei eigene Wesen anklicken
-var fuse_first = null        # Game.Creature, erstes Wesen der Verschmelzung
+var fuse_first = null        # Karte oder Wesen, für das im Menü „Verschmelzen mit …“ gewählt wurde
+var hold_time := 1.0         # so lange still über dem Ziel halten, dann verschmelzen die beiden
+var press_target = null      # Karte oder Wesen unter der gedrückten linken Maustaste
+var press_view: Control = null
+var press_pos := Vector2.ZERO
+var drag_ghost: Control = null  # schwebende Kopie der gezogenen Karte
+var drag_target = null       # mögliches Verschmelzungsziel unter dem Zeiger
+var drag_target_view: Control = null
+var hold_t := 0.0
+var hold_pos := Vector2.ZERO
 var msg_t := 0.0
 var ai_delay := 0.75
 var ai_timer := 0.0
@@ -40,7 +50,6 @@ var undo_t := 0.0
 # Ansichten (auch für Tests)
 var tiles := {}
 var hand_views: Array = []
-var pick_views: Array = []   # Karten der offenen Wahl
 var own_views: Array = []
 var enemy_views: Array = []
 var hero_panels := {}        # Player -> Panel
@@ -50,9 +59,6 @@ var flash_until := {}        # Spielerindex -> Zeitpunkt (ms)
 var hero_layer: Control
 var tile_layer: Control
 var hand_layer: Control
-var pick_layer: Control      # Überlagerung der offenen Wahl
-var pick_box: Control        # ihr Inhalt (wird je Wahl neu aufgebaut)
-var pick_key := ""           # welche Wahl gerade aufgebaut ist
 var deck: Deck
 var log_overlay: Control
 var b_log: Button
@@ -67,7 +73,6 @@ var income_label: Label
 var status_label: Label
 var msg_label: Label
 var b_end: Button
-var b_fuse: Button
 var b_giveup: Button
 var element_view: ElementView
 var info_label: Label       # Vorschau: Elementbonus, Merkmale
@@ -197,9 +202,6 @@ func _build_static() -> void:
     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
@@ -222,11 +224,6 @@ func _build_static() -> void:
     info_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
     info_label.visible = false
     fx_layer = _layer()
-    # offene Wahl: drei sehen, eine nehmen (zu Beginn fünf sehen, drei nehmen)
-    pick_layer = Style.overlay(self)
-    pick_box = Control.new()
-    pick_box.mouse_filter = Control.MOUSE_FILTER_IGNORE
-    pick_layer.add_child(pick_box)
     # Kartenmenü: durchsichtiger Fänger, der das Menü beim Klick daneben schließt
     menu_layer = Control.new()
     menu_layer.set_anchors_preset(Control.PRESET_FULL_RECT)
@@ -372,6 +369,20 @@ func _input(event: InputEvent) -> void:
             cancel_all()
         get_viewport().set_input_as_handled()  # sonst schließt derselbe Klick das Menü gleich wieder
         return
+    if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_MIDDLE:
+        var under := get_viewport().gui_get_hovered_control()
+        if under is CardView and under in hand_views and my_turn() and not any_overlay():
+            cancel()
+            play(under.card, true)
+            after_action()
+        get_viewport().set_input_as_handled()
+        return
+    if event is InputEventMouseMotion:
+        _drag_motion(event.position)
+        return
+    if event is InputEventMouseButton and not event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
+        _release()
+        return
     if event is InputEventJoypadButton and event.pressed:
         pad.button(event.button_index)
         return
@@ -385,7 +396,7 @@ func _input(event: InputEvent) -> void:
                 close_menu()
             elif log_overlay.visible:
                 log_overlay.visible = false
-            elif selected != null or fusing:
+            elif selected != null or fuse_first != null:
                 cancel_all()
             elif not any_overlay():
                 confirm.visible = true
@@ -401,11 +412,9 @@ func _input(event: InputEvent) -> void:
             if overlay.visible:
                 leave()
         _:
-            if event.keycode >= KEY_1 and event.keycode <= KEY_9 and not spectating() and not any_overlay():
+            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 not perspective.offer.is_empty():
-                    do_pick(idx)
-                elif my_turn() and idx < perspective.hand.size():
+                if idx < perspective.hand.size():
                     on_click("hand", perspective.hand[idx])
             elif event.keycode == KEY_Z and my_turn() and not any_overlay():
                 on_click("deck", null)
@@ -429,6 +438,15 @@ func _process(delta: float) -> void:
         undo_t -= delta
         if undo_t <= 0.0:
             clear_undo()
+    if drag_ghost != null and drag_target != null:
+        _set_hold(hold_t + delta)
+        if hold_t >= hold_time:
+            var a = press_target
+            var b = drag_target
+            press_target = null
+            _end_drag()
+            do_fuse(a, b)
+            after_action()
     if is_online() and net.is_host:
         net.tick()
     if game.winner != "":
@@ -503,8 +521,109 @@ func say(m: String) -> void:
 
 func cancel() -> void:
     selected = null
-    fusing = false
     fuse_first = null
+    press_target = null
+    _end_drag()
+
+
+# --- Ziehen mit der Maus: Klick beim Loslassen, Verschmelzen nach einer Sekunde über dem Ziel ---
+
+func _press(obj, view: Control, pos: Vector2) -> void:
+    _end_drag()
+    press_target = obj
+    press_view = view
+    press_pos = pos
+
+
+func _drag_motion(pos: Vector2) -> void:
+    if press_target == null:
+        return
+    if drag_ghost == null:
+        if pos.distance_to(press_pos) < 8.0 or not my_turn() or any_overlay():
+            return
+        _start_drag(pos)
+    drag_ghost.position = pos - drag_ghost.size / 2
+    var t = _fusion_target_at(pos)
+    if t != drag_target or pos.distance_to(hold_pos) > 6.0:
+        _set_hold(0.0)
+        drag_target = t
+        drag_target_view = _view_of(t)
+        hold_pos = pos
+
+
+## Loslassen ohne Ziehen ist der Klick.
+func _release() -> void:
+    var obj = press_target
+    var dragged := drag_ghost != null
+    press_target = null
+    _end_drag()
+    if obj == null:
+        return
+    if dragged:
+        refresh()
+    elif obj is Cards.Card:
+        on_click("hand", obj)
+    else:
+        on_tile_click(obj)
+
+
+func _start_drag(pos: Vector2) -> void:
+    show_preview(null, false)
+    if press_target is Cards.Card:
+        var size := Vector2(BattleLayout.HAND_W, BattleLayout.HAND_H) * 0.8
+        drag_ghost = CardView.new(press_target, size, false, press_target.rarity_in(perspective.looks))
+    else:
+        drag_ghost = CreatureView.new(press_target, BattleLayout.own_slot(0).size)
+    drag_ghost.mouse_filter = Control.MOUSE_FILTER_IGNORE
+    drag_ghost.modulate.a = 0.85
+    drag_ghost.position = pos - drag_ghost.size / 2
+    fx_layer.add_child(drag_ghost)
+    if press_view != null:
+        press_view.modulate.a = 0.4
+
+
+func _end_drag() -> void:
+    if drag_ghost != null:
+        drag_ghost.queue_free()
+        drag_ghost = null
+    if is_instance_valid(press_view):
+        press_view.modulate.a = 1.0
+    _set_hold(0.0)
+    drag_target = null
+    drag_target_view = null
+
+
+func _set_hold(v: float) -> void:
+    hold_t = v
+    if is_instance_valid(drag_target_view):
+        drag_target_view.hold = clampf(v / hold_time, 0.0, 1.0) if v > 0.0 else 0.0
+        drag_target_view.queue_redraw()
+
+
+## Karte oder Wesen unter pos, mit dem sich die gezogene Karte verschmelzen lässt.
+func _fusion_target_at(pos: Vector2):
+    for v in (hand_views if press_target is Cards.Card else own_views):
+        var obj = v.card if v is CardView else v.creature
+        var r: Rect2 = Rect2(v.slot, v.size) if v is CreatureView else v.get_global_rect()  # Kacheln zählen an ihrem Platz, auch während sie dorthin gleiten
+        if obj != press_target and r.has_point(pos) and game.can_fuse(perspective, press_target, obj)[0]:
+            return obj
+    return null
+
+
+func _view_of(obj) -> Control:
+    if obj is Cards.Card:
+        for v in hand_views:
+            if v.card == obj:
+                return v
+    elif obj is Game.Creature and tiles.has(obj.uid):
+        return tiles[obj.uid]
+    return null
+
+
+## Mögliche Partner für „Verschmelzen mit …“: andere Handkarten bzw. andere eigene Wesen.
+func fusion_partners(target) -> Array:
+    var pool: Array = perspective.hand if target is Cards.Card else perspective.board
+    return pool.filter(func(o): return o != target and game.can_fuse(perspective, target, o)[0])
 
 
 func play(card: Cards.Card, face_down: bool = false) -> void:
@@ -556,10 +675,12 @@ func do_upgrade(target, keyword: String) -> void:
     after_action()
 
 
-## Kartenmenü neben einer Handkarte oder einem eigenen Wesen.
-func open_menu(target, anchor: Rect2) -> void:
+## Kartenmenü neben einer Handkarte oder einem eigenen Wesen. full: auch verschmelzen anbieten
+## (Gamepad, das nicht ziehen kann).
+func open_menu(target, anchor: Rect2, full: bool = false) -> void:
     if spectating() or not my_turn():
         return
+    cancel()
     Style.clear(menu_layer)
     menu_target = target
     var entries := []  # [Text, Callable, aktiv]
@@ -570,8 +691,14 @@ func open_menu(target, anchor: Rect2) -> void:
         entries.append([tr("Verdeckt legen  ◆ %d") % card.cost, func():
             play(card, true)
             after_action(), ok[0]])
-    elif target.hidden:
+    elif not is_card and target.hidden:
         entries.append([tr("Aufdecken"), func(): do_reveal(target), game.can_reveal(perspective, target)[0]])
+    if full:
+        var partners := fusion_partners(target)
+        entries.append([tr("Verschmelzen mit …  ◆ %d") % card.fusion_cost(), func():
+            fuse_first = target
+            say(tr("Ziel wählen"))
+            refresh(), not partners.is_empty()])
     for kw in Cards.KEYWORDS:
         var k: String = kw
         var ok := game.can_upgrade(perspective, target, k)
@@ -607,16 +734,7 @@ func close_menu() -> void:
     menu_target = null
 
 
-## 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()
-
-
-## Ziehen: kostet Mana, öffnet die Wahl aus drei Karten.
+## Ziehen: kostet Mana, eine Karte kommt auf die Hand.
 func do_draw() -> void:
     clear_undo()
     if is_client():
@@ -629,31 +747,15 @@ func do_draw() -> void:
         fx.sfx("buy")
 
 
-## Nimmt eine Karte der offenen Wahl auf die Hand (jederzeit, auch außerhalb des Zugs).
-func do_pick(index: int) -> void:
-    if spectating() or index < 0 or index >= pick_views.size():
-        return
-    clear_undo()
-    var from := Rect2(pick_views[index].position, pick_views[index].size)
-    var card: Cards.Card = pick_views[index].card
-    if is_client():
-        net.send_action({"type": "pick", "index": index})
-        return
-    var err := game.pick(perspective, index)
-    if err != "":
-        say(tr(err))
-        return
-    fx.sfx("play")
-    fx.fly_card(card, from, BattleLayout.hand_rect(perspective.hand.size(), perspective.hand.size() - 1),
-        Cards.RARITIES[int(perspective.looks.get(card.id, 0))])
-    after_action()
-
-
+## Verschmilzt zwei Handkarten oder zwei eigene Wesen (siehe Game.fuse).
 func do_fuse(a, b) -> void:
     cancel()
     clear_undo()
     if is_client():
-        net.send_action({"type": "fuse", "uid": a.uid, "other": b.uid})
+        if a is Cards.Card:
+            net.send_action({"type": "fuse", "hand": perspective.hand.find(a), "other_hand": perspective.hand.find(b)})
+        else:
+            net.send_action({"type": "fuse", "uid": a.uid, "other": b.uid})
         return
     var err := game.fuse(perspective, a, b)
     if err != "":
@@ -703,17 +805,13 @@ 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
+    if fuse_first != null:
+        var first = fuse_first
+        fuse_first = null
+        if obj != null and obj != first and g.can_fuse(perspective, first, obj)[0]:
+            do_fuse(first, obj)
         else:
-            do_fuse(fuse_first, obj)
+            say(tr("Abgebrochen"))
         after_action()
         return
     if selected != null:
@@ -745,6 +843,8 @@ func on_click(kind: String, obj) -> void:
             if obj.can_attack():
                 selected = obj
                 say(tr("Wähle ein Angriffsziel"))
+            elif not obj.ready:
+                say(tr("%s greift erst im nächsten Zug an") % obj.card.title())
             else:
                 say(tr("%s kann nicht angreifen") % obj.card.title())
     after_action()
@@ -783,7 +883,7 @@ func show_preview(card, entered: bool, owner_looks: Dictionary = {}, info: Strin
     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))])
+        var v := CardView.new(card, r.size, false, card.rarity_in(owner_looks))
         v.position = r.position
         v.mouse_filter = Control.MOUSE_FILTER_IGNORE
         preview_holder.add_child(v)
@@ -792,69 +892,32 @@ func show_preview(card, entered: bool, owner_looks: Dictionary = {}, info: Strin
         info_label.size = ir.size
 
 
-## Eigene Hand- und Wahlkarte: zeigt den Elementbonus, den sie offen gelegt bekäme.
+## Eigene Handkarte: zeigt den Elementbonus, den sie offen gelegt bekäme.
 func show_hand_preview(card: Cards.Card, entered: bool, anchor: Rect2 = Rect2()) -> void:
+    if drag_ghost != null:
+        return
     var a := game.forecast(perspective, card)
     var info := ""
     if a > 0:
         info = tr("Elementbonus +%d/+%d") % [a, a]
-    elif a < 0:
-        info = tr("Elementbonus %d/%d") % [a, a]
     show_preview(card, entered, perspective.looks, info, anchor)
 
 
-## Offene Wahl als Überlagerung: nur neu aufbauen, wenn sich das Angebot geändert hat.
-func build_pick() -> void:
-    var h := perspective
-    var key := ""
-    if not spectating() and not h.offer.is_empty():
-        key = "%d:%s" % [h.picks_left, ",".join(h.offer.map(func(c): return c.id))]
-    if key == pick_key:
-        return
-    pick_key = key
-    Style.clear(pick_box)
-    pick_views = []
-    if key == "":
-        pick_layer.visible = false
-        return
-    var box := BattleLayout.PICK_PANEL
-    Style.panel(pick_box, box, Style.PANEL, 12, Style.GOLD, 2)
-    Style.label(pick_box, tr("Wähle %d von %d") % [h.picks_left, h.offer.size()], 26, Style.GOLD,
-        Rect2(box.position.x, box.position.y + 24, box.size.x, 40), "center", true)
-    for i in h.offer.size():
-        var card: Cards.Card = h.offer[i]
-        var r := BattleLayout.pick_rect(h.offer.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 = true
-        apply_forecast(v)
-        var idx := i
-        v.clicked.connect(func(_view): do_pick(idx))
-        pick_box.add_child(v)
-        pick_views.append(v)
-    pick_layer.visible = true
-    if Style.animations:
-        for i in pick_views.size():
-            fx.deal(pick_views[i], i)
-
-
-## Hand- und Wahlkarten tragen den Elementbonus als Vorschau.
-func apply_forecast(v: CardView) -> void:
-    v.bonus = game.forecast(perspective, v.card)
-
-
-## Was den Angriff eines Wesens gerade hebt oder senkt.
+## Was ein Wesen gerade hebt, was es kann und ob es schon angreift.
 func creature_info(cr: Game.Creature) -> String:
     var parts: Array[String] = []
     if cr.aura > 0:
         parts.append(tr("Elementbonus +%d/+%d") % [cr.aura, cr.aura])
-    elif cr.aura < 0:
-        parts.append(tr("Elementbonus %d/%d") % [cr.aura, cr.aura])
     var perk := cr.power() - cr.attack - cr.aura
     if perk > 0:
         parts.append(tr("Merkmal +%d") % perk)
+    for k in cr.keywords():
+        if not (k in cr.card.keywords):
+            parts.append(tr("%s durch das Element") % tr(k))
     if cr.hidden:
         parts.append(tr("verdeckt"))
+    elif not cr.ready and not cr.has("Flink") and cr.owner() == perspective:
+        parts.append(tr("greift erst im nächsten Zug an"))
     return " · ".join(parts)
 
 
@@ -1020,10 +1083,10 @@ func refresh() -> void:
                     else:
                         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):
+                tile.pressed.connect(func(_v, pos):
                     var c := game.find_creature(uid)
                     if c != null:
-                        on_tile_click(c))
+                        _press(c, tile, pos))
                 if arrivals.has(cr.uid):
                     fx.fly_in(tile, arrivals[cr.uid])
                     arrivals.erase(cr.uid)
@@ -1037,7 +1100,7 @@ func refresh() -> void:
             if cr == selected or cr == fuse_first:
                 b = Style.YELLOW
                 w = 4
-            elif fusing and p == h and mine:
+            elif fuse_first != null and p == h and mine and g.can_fuse(h, fuse_first, cr)[0]:
                 b = Style.PURPLE
                 w = 3
             elif selected != null and g.can_attack(selected, cr)[0]:
@@ -1060,7 +1123,6 @@ func refresh() -> void:
             var t: CreatureView = tiles[uid]
             tiles.erase(uid)
             fx.fade_out(t)
-    build_pick()
     deck.visible = not spectating()
     deck.enabled = mine and g.can_draw(h)[0]
     deck.count = g.deck.size()
@@ -1075,15 +1137,20 @@ func refresh() -> void:
             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))])
+            var v := CardView.new(card, r.size, false, card.rarity_in(h.looks))
             v.position = r.position
             v.lift = mine
-            apply_forecast(v)
-            if playable:
+            v.bonus = g.forecast(h, card)
+            if fuse_first != null and mine and g.can_fuse(h, fuse_first, card)[0]:
+                v.border = Style.PURPLE
+            elif card == fuse_first:
+                v.border = Style.YELLOW
+            elif playable:
                 v.border = Style.GREEN
-            v.dim = not playable
+            v.dim = not playable and card != fuse_first
+            v.drag_enabled = true
             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))
+            v.pressed.connect(func(_view, pos): _press(card, v, pos))
             hand_layer.add_child(v)
             hand_views.append(v)
 
@@ -1103,18 +1170,16 @@ func refresh() -> void:
     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_fuse.text = tr("Abbrechen") if fusing else tr("Verschmelzen")
-    element_view.update_from(g)
+    element_view.update_from(g, h)
     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 " verschmelzen zu " in line or " wird aufgedeckt." in line:
+        elif " verschmelzen " in line or " wird aufgedeckt." in line:
             lines.append("[color=#8c78dc]%s[/color]" % line)
-        elif " bekommt " in line:
+        elif " bekommt " in line or " regeneriert sich." in line:
             lines.append("[color=#5ad282]%s[/color]" % line)
         else:
             lines.append(line)