update

scripts/ui/style.gd

@@ -4,6 +4,7 @@ class_name Style
 const FONT: FontFile = preload("res://assets/fonts/DejaVuSans.ttf")
 const FONT_BOLD: FontFile = preload("res://assets/fonts/DejaVuSans-Bold.ttf")
 static var font_scale := 1.0  # Einstellung „Große Schrift“
+static var animations := true  # Einstellung „Animationen“: der Glanz seltener Karten bewegt sich
 
 const BG := Color("1a1c24")
 const PANEL := Color("282b36")
@@ -17,6 +18,11 @@ const BLUE := Color("6eaaf0")
 const YELLOW := Color("ffe65a")
 const ORANGE := Color("ff963c")
 const PURPLE := Color("8c78dc")
+const AMBER := Color("f0b429")   # Angriff
+const CRIMSON := Color("d64545") # Leben
+const MANA := Color("3a78d2")    # Kostenkristall
+const PRIMARY := Color("285a3c") # Hauptaktion
+const DANGER := Color("5a2828")
 
 
 ## Schriftgröße mit der Einstellung „Große Schrift“.
@@ -80,7 +86,11 @@ static func panel(parent: Node, rect: Rect2, bg: Color = PANEL, radius: int = 8,
     var p := Panel.new()
     p.position = rect.position
     p.size = rect.size
-    p.add_theme_stylebox_override("panel", box(bg, radius, border_col, border_w))
+    var sb := box(bg, radius, border_col, border_w)
+    sb.shadow_color = Color(0, 0, 0, 0.35)
+    sb.shadow_size = 6
+    sb.shadow_offset = Vector2(0, 3)
+    p.add_theme_stylebox_override("panel", sb)
     p.mouse_filter = Control.MOUSE_FILTER_IGNORE
     parent.add_child(p)
     return p
@@ -115,10 +125,35 @@ static func button(parent: Node, text: String, rect: Rect2, on_pressed: Callable
         b.add_theme_stylebox_override("normal", box(color, 8, MUTED, 2))
         b.add_theme_stylebox_override("hover", box(lighter(color), 8, MUTED, 2))
         b.add_theme_stylebox_override("pressed", box(darker(color), 8, MUTED, 2))
+    juice(b)
     parent.add_child(b)
     return b
 
 
+## Knöpfe federn beim Drücken kurz ein.
+static func juice(b: Button) -> void:
+    b.button_down.connect(func():
+        if animations:
+            b.pivot_offset = b.size / 2
+            b.create_tween().tween_property(b, "scale", Vector2(0.96, 0.96), 0.05))
+    b.button_up.connect(func():
+        if animations:
+            b.pivot_offset = b.size / 2
+            b.create_tween().tween_property(b, "scale", Vector2.ONE, 0.12).set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT))
+
+
+## Kopfzeile eines Unterbildschirms: Titel links, Zurück rechts oben.
+static func header(parent: Node, title: String, on_back: Callable) -> Button:
+    label(parent, title, 34, GOLD, Rect2(40, 22, 700, 46), "left", true)
+    return button(parent, "Zurück", Rect2(1120, 26, 120, 40), on_back)
+
+
+## Kleine Kachel mit Text, etwa für Münzen und Staub.
+static func chip(parent: Node, text: String, rect: Rect2, color: Color = GOLD) -> Label:
+    panel(parent, rect, darker(PANEL, 0.9), rect.size.y / 2, PANEL_LIGHT, 1)
+    return label(parent, text, 17, color, rect, "center", true)
+
+
 ## Vertikal zentrierte Spalte (Container-Layout für Menübildschirme).
 static func column(parent: Node, width: float, top: float, sep: int = 12) -> VBoxContainer:
     var v := VBoxContainer.new()
@@ -230,6 +265,33 @@ static func text(ci: CanvasItem, s: String, size_in: int, color: Color, pos: Vec
     ci.draw_string(font, Vector2(x, y + font.get_ascent(size)), s, HORIZONTAL_ALIGNMENT_LEFT, -1, size, color)
 
 
+## Text mit dunklem Rand: bleibt auf jeder Farbe lesbar (Werte, Kosten).
+static func text_outlined(ci: CanvasItem, s: String, size_in: int, color: Color, pos: Vector2, anchor: String = "center", outline: int = 4) -> void:
+    var size := fs(size_in)
+    var dim := FONT_BOLD.get_string_size(s, HORIZONTAL_ALIGNMENT_LEFT, -1, size)
+    var x := pos.x
+    var y := pos.y
+    match anchor:
+        "center":
+            x -= dim.x / 2
+            y -= dim.y / 2
+        "midtop":
+            x -= dim.x / 2
+        "midleft":
+            y -= dim.y / 2
+    var at := Vector2(x, y + FONT_BOLD.get_ascent(size))
+    ci.draw_string_outline(FONT_BOLD, at, s, HORIZONTAL_ALIGNMENT_LEFT, -1, size, outline, Color(0.05, 0.05, 0.08, 0.95))
+    ci.draw_string(FONT_BOLD, at, s, HORIZONTAL_ALIGNMENT_LEFT, -1, size, color)
+
+
+## Schriftgröße, mit der ein Text in eine Breite passt (bis zur Mindestgröße).
+static func fit_size(s: String, bold: bool, size: int, max_w: float, min_size: int = 9) -> int:
+    var font: Font = FONT_BOLD if bold else FONT
+    while size > min_size and font.get_string_size(s, HORIZONTAL_ALIGNMENT_LEFT, -1, fs(size)).x > max_w:
+        size -= 1
+    return size
+
+
 static func fit(s: String, bold: bool, size: int, max_w: float) -> String:
     var font: Font = FONT_BOLD if bold else FONT
     while font.get_string_size(s, HORIZONTAL_ALIGNMENT_LEFT, -1, size).x > max_w and s.length() > 3:
@@ -246,6 +308,88 @@ static func border(ci: CanvasItem, rect: Rect2, color: Color, width: int, radius
     ci.draw_style_box(sb, rect)
 
 
+# --- Seltenheit als Aussehen ------------------------------------------------------
+
+## Ab episch bewegt sich der Glanz; dann zeichnet die Karte jeden Frame neu.
+static func rarity_animated(rar: String) -> bool:
+    return animations and Cards.RARITIES.find(rar) >= 2
+
+
+## Farbe einer Stufe; mythisch schillert über die Zeit durch alle Farben.
+static func rarity_color(rar: String, seed: int = 0) -> Color:
+    if rar == "mythisch" and animations:
+        return Color.from_hsv(fmod(Time.get_ticks_msec() / 1000.0 * 0.12 + (seed % 97) / 97.0, 1.0), 0.55, 1.0)
+    return Cards.RARITY_COLORS[rar]
+
+
+## Rahmenfarbe einer Stufe: gewöhnlich bleibt schlicht, alles darüber trägt seine Farbe.
+static func rarity_frame(rar: String, seed: int = 0) -> Color:
+    return Color("3a3e4c") if rar == "gewöhnlich" else rarity_color(rar, seed)
+
+
+## Lichtstreifen wie auf einer Folienkarte: selten steht er, ab episch wandert er über die Karte.
+static func rarity_sheen(ci: CanvasItem, rect: Rect2, rar: String, seed: int) -> void:
+    var lvl := Cards.RARITIES.find(rar)
+    if lvl < 1:
+        return
+    var phase := (seed % 100) / 100.0
+    if lvl >= 2 and animations:
+        phase = fmod(Time.get_ticks_msec() / 2500.0 + phase, 1.0)
+    var frame := PackedVector2Array([rect.position, Vector2(rect.end.x, rect.position.y), rect.end, Vector2(rect.position.x, rect.end.y)])
+    var w := rect.size.x * 0.34
+    var k := rect.size.y * 0.75  # Schräge
+    var x0 := rect.position.x - w + (rect.size.x + w + k) * phase
+    for layer in [[1.0, 0.07], [0.55, 0.09], [0.22, 0.13]]:
+        var lw: float = w * layer[0]
+        var lx := x0 + (w - lw) / 2
+        var band := PackedVector2Array([Vector2(lx, rect.position.y), Vector2(lx + lw, rect.position.y), Vector2(lx + lw - k, rect.end.y), Vector2(lx - k, rect.end.y)])
+        for poly in Geometry2D.intersect_polygons(band, frame):
+            ci.draw_colored_polygon(poly, Color(1, 1, 1, layer[1]))
+
+
+## Funkeln ab legendär: kleine Sterne, die aufblitzen und vergehen; ganz zum Schluss zeichnen.
+## avoid: Bereich, der frei bleibt (der Kartentext).
+static func rarity_sparkle(ci: CanvasItem, rect: Rect2, rar: String, seed: int, avoid: Rect2 = Rect2()) -> void:
+    var lvl := Cards.RARITIES.find(rar)
+    if lvl < 3:
+        return
+    var t := Time.get_ticks_msec() / 1000.0
+    var n := 5 if lvl == 3 else 9
+    for i in n:
+        var h := absi(hash(Vector2i(seed, i)))
+        var p := rect.position + Vector2(8 + (h % 1000) / 1000.0 * (rect.size.x - 16), 8 + ((h / 1000) % 1000) / 1000.0 * (rect.size.y - 16))
+        var tw := 0.5 + 0.5 * sin(t * 2.5 + i * 1.9 + seed % 7) if animations else 0.35 + 0.65 * ((i * 7 + seed) % 5) / 4.0
+        if tw < 0.15 or avoid.has_point(p):
+            continue
+        var s := 2.0 + 4.0 * tw
+        var col := Color(1, 1, 1, 0.3 + 0.65 * tw)
+        ci.draw_line(p - Vector2(s, 0), p + Vector2(s, 0), col, 1.4)
+        ci.draw_line(p - Vector2(0, s), p + Vector2(0, s), col, 1.4)
+        ci.draw_circle(p, 1.3, col)
+
+
+## Weicher Schein um eine Karte höherer Stufe; vor dem Hintergrund zeichnen.
+static func glow(ci: CanvasItem, rect: Rect2, color: Color, radius: int = 8, spread: int = 8) -> void:
+    var sb := StyleBoxFlat.new()
+    sb.bg_color = Color(0, 0, 0, 0)
+    sb.set_corner_radius_all(radius)
+    sb.shadow_color = Color(color, 0.6)
+    sb.shadow_size = spread
+    ci.draw_style_box(sb, rect)
+
+
+## Edelstein in der Farbe der Stufe (ab selten).
+static func rarity_gem(ci: CanvasItem, rar: String, c: Vector2, s: float, seed: int = 0) -> void:
+    if rar == "gewöhnlich":
+        return
+    var col := rarity_color(rar, seed)
+    var diamond := func(h: float, k: Color) -> void:
+        ci.draw_colored_polygon(PackedVector2Array([c + Vector2(0, -h), c + Vector2(h * 0.72, 0), c + Vector2(0, h), c + Vector2(-h * 0.72, 0)]), k)
+    diamond.call(s + 2, Color("14141c"))
+    diamond.call(s, col)
+    ci.draw_colored_polygon(PackedVector2Array([c + Vector2(0, -s * 0.7), c + Vector2(s * 0.3, -s * 0.15), c + Vector2(-s * 0.35, -s * 0.1)]), Color(1, 1, 1, 0.55))
+
+
 ## Hintergrund in Elementfarbe; ein verschmolzenes Wesen zeigt seine Elemente als Streifen.
 static func fill_elements(ci: CanvasItem, rect: Rect2, elements: Array, radius: int = 8) -> void:
     if elements.size() == 1:
@@ -265,12 +409,63 @@ static func fill_elements(ci: CanvasItem, rect: Rect2, elements: Array, radius:
         ci.draw_style_box(sb, Rect2(rect.position + Vector2(floorf(i * w), 0), Vector2(ceilf(w), rect.size.y)))
 
 
+# --- Kartenteile ------------------------------------------------------
+
+## Kostenkristall: sechseckig, blau, Zahl in der Mitte.
+static func cost_crystal(ci: CanvasItem, c: Vector2, r: float, cost: int, font: int) -> void:
+    var pts := PackedVector2Array()
+    var outer := PackedVector2Array()
+    for i in 6:
+        var a := -PI / 2 + i * PI / 3
+        pts.append(c + Vector2(cos(a), sin(a)) * r)
+        outer.append(c + Vector2(cos(a), sin(a)) * (r + 2))
+    ci.draw_colored_polygon(outer, Color("14141c"))
+    ci.draw_colored_polygon(pts, MANA)
+    var shine := PackedVector2Array([pts[5], pts[0], c + Vector2(0, -r * 0.1), c + Vector2(-r * 0.55, r * 0.15)])
+    ci.draw_colored_polygon(shine, Color(1, 1, 1, 0.22))
+    text_outlined(ci, str(cost), font, Color.WHITE, c, "center", 3)
+
+
+## Wertkreis (Angriff gelb, Leben rot) mit Zahl.
+static func stat_circle(ci: CanvasItem, c: Vector2, r: float, value: String, color: Color, font: int) -> void:
+    ci.draw_circle(c, r + 2, Color("14141c"))
+    ci.draw_circle(c, r, color)
+    ci.draw_circle(c + Vector2(-r * 0.25, -r * 0.3), r * 0.45, Color(1, 1, 1, 0.16))
+    text_outlined(ci, value, font, Color.WHITE, c, "center", 3)
+
+
+## Schlüsselwort als Symbol auf dunklem Kreis: Wächter Mauer, Schild Schild, Flink Doppelpfeil,
+## Doppelschlag gekreuzte Klingen.
+static func keyword_icon(ci: CanvasItem, kw: String, c: Vector2, r: float, col: Color = Color("f2f2f6")) -> void:
+    ci.draw_circle(c, r + 3, Color(0.05, 0.05, 0.08, 0.7))
+    var w := maxf(1.5, r * 0.22)
+    match kw:
+        "Wächter":
+            ci.draw_rect(Rect2(c + Vector2(-r * 0.75, -r * 0.15), Vector2(r * 1.5, r * 0.85)), col)
+            for i in 3:
+                ci.draw_rect(Rect2(c + Vector2(-r * 0.75 + i * r * 0.6, -r * 0.6), Vector2(r * 0.3, r * 0.5)), col)
+        "Schild":
+            var pts := PackedVector2Array([c + Vector2(-r * 0.7, -r * 0.65), c + Vector2(r * 0.7, -r * 0.65), c + Vector2(r * 0.7, r * 0.05),
+                c + Vector2(0, r * 0.8), c + Vector2(-r * 0.7, r * 0.05)])
+            ci.draw_colored_polygon(pts, col)
+            ci.draw_line(c + Vector2(0, -r * 0.55), c + Vector2(0, r * 0.6), Color(0.05, 0.05, 0.08, 0.6), w)
+        "Flink":
+            for i in 2:
+                var x := c.x - r * 0.55 + i * r * 0.55
+                ci.draw_polyline(PackedVector2Array([Vector2(x, c.y - r * 0.6), Vector2(x + r * 0.5, c.y), Vector2(x, c.y + r * 0.6)]), col, w)
+        "Doppelschlag":
+            ci.draw_line(c + Vector2(-r * 0.65, r * 0.65), c + Vector2(r * 0.6, -r * 0.6), col, w)
+            ci.draw_line(c + Vector2(r * 0.65, r * 0.65), c + Vector2(-r * 0.6, -r * 0.6), col, w)
+            ci.draw_line(c + Vector2(-r * 0.7, r * 0.35), c + Vector2(-r * 0.35, r * 0.7), col, w)
+            ci.draw_line(c + Vector2(r * 0.7, r * 0.35), c + Vector2(r * 0.35, r * 0.7), col, w)
+
+
 # --- Kartensymbole (prozedural, je Element) --------------------------
 
-static func glyph(ci: CanvasItem, card, center: Vector2, size: float) -> void:
+static func glyph(ci: CanvasItem, card, center: Vector2, size: float, alpha: float = 0.95) -> void:
     var variant := absi(hash(card.id)) % 3
     var col := lighter(Cards.ELEMENT_COLORS[card.elements[0]], 0.38)
-    col.a = 0.95
+    col.a = alpha
     var elems: Array = card.elements
     if elems.size() == 1:
         _element_glyph(ci, elems[0], center, size, variant, col)
@@ -278,7 +473,7 @@ static func glyph(ci: CanvasItem, card, center: Vector2, size: float) -> void:
     # Verschmolzen: die ersten beiden Elemente nebeneinander, ab dem dritten ein Ring
     _element_glyph(ci, elems[0], center + Vector2(-size * 0.28, 0), size * 0.62, variant, col)
     var col2 := lighter(Cards.ELEMENT_COLORS[elems[1]], 0.38)
-    col2.a = 0.95
+    col2.a = alpha
     _element_glyph(ci, elems[1], center + Vector2(size * 0.28, 0), size * 0.62, variant, col2)
     if elems.size() >= 3:
         ci.draw_arc(center, size * 0.72, 0, TAU, 40, Color(col, 0.5), 2)
@@ -321,7 +516,7 @@ static func _flame(ci: CanvasItem, c: Vector2, h: float, col: Color) -> void:
     ci.draw_colored_polygon(pts, col)
     var inner := PackedVector2Array([
         c + Vector2(0, -h * 0.35), c + Vector2(w * 0.25, h * 0.35), c + Vector2(0, h * 0.75), c + Vector2(-w * 0.25, h * 0.35)])
-    ci.draw_colored_polygon(inner, Color(1.0, 0.9, 0.5, 0.75))
+    ci.draw_colored_polygon(inner, Color(1.0, 0.9, 0.5, 0.75 * col.a))
 
 
 ## Dezenter Hintergrund: Farbverlauf und schräge Linien.