update

scripts/ui/style.gd

@@ -151,7 +151,9 @@ static func header(parent: Node, title: String, on_back: Callable) -> Button:
 ## 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)
+    var l := label(parent, text, 17, color, rect, "center", true)
+    l.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
+    return l
 
 
 ## Vertikal zentrierte Spalte (Container-Layout für Menübildschirme).
@@ -309,13 +311,14 @@ static func border(ci: CanvasItem, rect: Rect2, color: Color, width: int, radius
 
 
 # --- Seltenheit als Aussehen ------------------------------------------------------
-# Common matt; Rare silberner Name und Rahmen mit stehendem Glanzstreifen; Super Rare Holo-Bild
-# (wandernder Regenbogenschimmer); Ultra Rare goldener Name und Rahmen plus Holo-Bild;
-# Ultimate Rare Relief, Holo auf Bild und Rahmen, Funkeln, schillernde Farben.
+# Common matt; Rare silbern glänzender Name; Super Rare Holo-Bild (wandernder Regenbogen im
+# Bildkreis); Ultra Rare goldener Name und Holo-Bild; Ultimate Rare goldener Name, goldenes
+# Bild, glänzende Werte, Schimmer über die ganze Karte, Funkeln und schillernder Rahmen.
+# Rahmen und Schein tragen ab Rare die Stufenfarbe.
 
-## Ab Super Rare bewegt sich der Glanz; dann zeichnet die Karte jeden Frame neu.
+## Ab Rare 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
+    return animations and Cards.RARITIES.find(rar) >= 1
 
 
 ## Farbe einer Stufe; Ultimate Rare schillert über die Zeit durch alle Farben.
@@ -330,56 +333,138 @@ static func rarity_frame(rar: String, seed: int = 0) -> Color:
     return Color("3a3e4c") if rar == "Common" else rarity_color(rar, seed)
 
 
-## Farbe des Kartennamens: Rare silbern, Ultra Rare golden, Ultimate Rare schillernd, sonst weiß.
-static func rarity_name_color(rar: String, seed: int = 0) -> Color:
+## Farbe des Kartennamens: Rare silbern, Ultra und Ultimate Rare golden, sonst weiß.
+static func rarity_name_color(rar: String) -> Color:
     match rar:
-        "Rare", "Ultra Rare", "Ultimate Rare":
-            return lighter(rarity_color(rar, seed), 0.25)
+        "Rare":
+            return Cards.RARITY_COLORS["Rare"]
+        "Ultra Rare", "Ultimate Rare":
+            return Cards.RARITY_COLORS["Ultra Rare"]
     return TEXT
 
 
+## Der Name glänzt bei Rare (silbern), Ultra und Ultimate Rare (golden).
+static func rarity_name_shiny(rar: String) -> bool:
+    return rar in ["Rare", "Ultra Rare", "Ultimate Rare"]
+
+
+## Ultimate Rare: auch Kosten, Angriff und Leben glänzen.
+static func rarity_stats_shiny(rar: String) -> bool:
+    return rar == "Ultimate Rare"
+
+
 ## Ultimate Rare zeigt das Bild als Relief (Licht- und Schattenkante).
 static func rarity_relief(rar: String) -> bool:
-    return Cards.RARITIES.find(rar) >= 4
+    return rar == "Ultimate Rare"
 
 
-## Glanz wie auf einer Folienkarte. Rare: ein stehender weißer Streifen über die Karte.
-## Ab Super Rare: Holo, ein wandernder Regenbogenschimmer über das Bild (picture); Ultimate Rare
-## zusätzlich schwach über die ganze Karte.
-static func rarity_sheen(ci: CanvasItem, rect: Rect2, rar: String, seed: int, picture: Rect2 = Rect2()) -> void:
-    var lvl := Cards.RARITIES.find(rar)
-    if lvl < 1:
-        return
-    if picture.size.x <= 0:
-        picture = rect
-    if lvl == 1:
-        _sheen_bands(ci, rect, (seed % 100) / 100.0, [[1.0, Color(1, 1, 1, 0.07)], [0.55, Color(1, 1, 1, 0.09)], [0.22, Color(1, 1, 1, 0.13)]])
+## Kartenname links in rect, immer eine Zeile, nie abgeschnitten: die Schrift schrumpft bis
+## drei Punkte unter die Vorgabe, danach wird der Text schmaler gezeichnet (wie bei langen
+## Yu-Gi-Oh-Namen).
+static func card_name(ci: CanvasItem, s: String, size_in: int, rar: String, rect: Rect2, seed: int) -> void:
+    var fsize := fit_size(s, true, size_in, rect.size.x, maxi(8, size_in - 3))
+    var w := FONT_BOLD.get_string_size(s, HORIZONTAL_ALIGNMENT_LEFT, -1, fs(fsize)).x
+    var squeeze := minf(1.0, rect.size.x / maxf(w, 1.0))
+    var y := rect.position.y + (rect.size.y - FONT_BOLD.get_height(fs(fsize))) / 2
+    ci.draw_set_transform(Vector2(rect.position.x, y), 0.0, Vector2(squeeze, 1.0))
+    if rarity_name_shiny(rar):
+        shiny_text(ci, s, fsize, rarity_name_color(rar), Vector2.ZERO, "topleft", seed)
+    else:
+        text(ci, s, fsize, rarity_name_color(rar), Vector2.ZERO, "topleft", true)
+    ci.draw_set_transform(Vector2.ZERO)
+
+
+## Metallisch glänzender fetter Text: dunkler Schatten, Grundfarbe, darüber Buchstabe für
+## Buchstabe ein heller Streifen, der mit Animation über den Text läuft.
+static func shiny_text(ci: CanvasItem, s: String, size_in: int, color: Color, pos: Vector2, anchor: String, seed: int) -> 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 phase := (seed % 100) / 100.0
+    if animations:
+        phase = fmod(Time.get_ticks_msec() / 1800.0 + phase, 1.0)
+    var at := Vector2(x, y + FONT_BOLD.get_ascent(size))
+    ci.draw_string(FONT_BOLD, at + Vector2(1, 1), s, HORIZONTAL_ALIGNMENT_LEFT, -1, size, Color(0, 0, 0, 0.55))
+    var cx := x
+    for i in s.length():
+        var ch := s[i]
+        var w := FONT_BOLD.get_string_size(ch, HORIZONTAL_ALIGNMENT_LEFT, -1, size).x
+        var d := absf(fmod((cx + w / 2 - x) / maxf(dim.x, 1.0) - phase * 1.6 + 0.3 + 2.0, 1.0) - 0.5) * 2.0  # 0 am Streifen
+        var k := clampf(1.0 - d * 2.4, 0.0, 1.0)
+        ci.draw_string(FONT_BOLD, Vector2(cx, at.y), ch, HORIZONTAL_ALIGNMENT_LEFT, -1, size, color.lerp(Color.WHITE, 0.1 + 0.75 * k))
+        cx += w
+
+
+## Glanz wie auf einer Folienkarte, auf clip beschnitten. lvl 2 und 3: Holo, ein wandernder
+## Regenbogenschimmer; lvl 4: goldene Bänder.
+static func sheen(ci: CanvasItem, clip: PackedVector2Array, bounds: Rect2, seed: int, gold: bool = false) -> void:
+    var phase := (seed % 100) / 100.0
+    if animations:
+        phase = fmod(Time.get_ticks_msec() / 2500.0 + phase, 1.0)
+    var layers := []
+    for i in 4:
+        var col := Color(1.0, 0.86, 0.45, 0.2 - i * 0.03) if gold else Color.from_hsv(fmod(phase + i * 0.17, 1.0), 0.6, 1.0, 0.16)
+        layers.append([1.0 - i * 0.22, col])
+    _sheen_bands(ci, clip, bounds, phase, layers)
+
+
+## Ultimate Rare: schwacher schillernder Schimmer über die ganze Karte.
+static func card_sheen(ci: CanvasItem, rect: Rect2, rar: String, seed: int) -> void:
+    if rar != "Ultimate Rare":
         return
     var phase := (seed % 100) / 100.0
     if animations:
         phase = fmod(Time.get_ticks_msec() / 2500.0 + phase, 1.0)
-    var holo := []
-    for i in 4:
-        holo.append([1.0 - i * 0.22, Color.from_hsv(fmod(phase + i * 0.17, 1.0), 0.6, 1.0, 0.16)])
-    _sheen_bands(ci, picture, phase, holo)
-    if lvl >= 4:
-        var soft := []
-        for i in 3:
-            soft.append([1.0 - i * 0.3, Color.from_hsv(fmod(phase + 0.5 + i * 0.2, 1.0), 0.5, 1.0, 0.07)])
-        _sheen_bands(ci, rect, fmod(phase + 0.5, 1.0), soft)
+    var soft := []
+    for i in 3:
+        soft.append([1.0 - i * 0.3, Color.from_hsv(fmod(phase + 0.5 + i * 0.2, 1.0), 0.5, 1.0, 0.07)])
+    _sheen_bands(ci, rect_poly(rect), rect, fmod(phase + 0.5, 1.0), soft)
 
 
-## Schräge Streifen über rect, auf rect beschnitten. layers: [Breitenanteil, Farbe].
-static func _sheen_bands(ci: CanvasItem, rect: Rect2, phase: float, layers: Array) -> void:
-    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
+static func rect_poly(rect: Rect2) -> PackedVector2Array:
+    return PackedVector2Array([rect.position, Vector2(rect.end.x, rect.position.y), rect.end, Vector2(rect.position.x, rect.end.y)])
+
+
+static func circle_poly(c: Vector2, r: float, steps: int = 40) -> PackedVector2Array:
+    var pts := PackedVector2Array()
+    for i in steps:
+        var a := TAU * i / steps
+        pts.append(c + Vector2(cos(a), sin(a)) * r)
+    return pts
+
+
+## Rechteck mit runden Ecken als Polygon (für Beschnitt).
+static func rounded_poly(rect: Rect2, radius: float) -> PackedVector2Array:
+    var pts := PackedVector2Array()
+    var r := minf(radius, minf(rect.size.x, rect.size.y) / 2)
+    var corners := [[rect.end - Vector2(r, r), 0.0], [Vector2(rect.position.x + r, rect.end.y - r), PI / 2],
+        [rect.position + Vector2(r, r), PI], [Vector2(rect.end.x - r, rect.position.y + r), PI * 1.5]]
+    for corner in corners:
+        for k in 7:
+            var a: float = corner[1] + PI / 2 * k / 6
+            pts.append(corner[0] + Vector2(cos(a), sin(a)) * r)
+    return pts
+
+
+## Schräge Streifen über bounds, auf clip beschnitten. layers: [Breitenanteil, Farbe].
+static func _sheen_bands(ci: CanvasItem, clip: PackedVector2Array, bounds: Rect2, phase: float, layers: Array) -> void:
+    var w := bounds.size.x * 0.34
+    var k := bounds.size.y * 0.75  # Schräge
+    var x0 := bounds.position.x - w + (bounds.size.x + w + k) * phase
     for layer in layers:
         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):
+        var band := PackedVector2Array([Vector2(lx, bounds.position.y), Vector2(lx + lw, bounds.position.y), Vector2(lx + lw - k, bounds.end.y), Vector2(lx - k, bounds.end.y)])
+        for poly in Geometry2D.intersect_polygons(band, clip):
             if poly.size() >= 3 and _area(poly) > 2.0:  # Splitter am Rand lassen sich nicht zeichnen
                 ci.draw_colored_polygon(poly, layer[1])
 
@@ -394,16 +479,15 @@ static func _area(poly: PackedVector2Array) -> float:
 
 
 ## Funkeln bei Ultimate Rare: 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:
-    if Cards.RARITIES.find(rar) < 4:
+static func rarity_sparkle(ci: CanvasItem, rect: Rect2, rar: String, seed: int) -> void:
+    if rar != "Ultimate Rare":
         return
     var t := Time.get_ticks_msec() / 1000.0
     for i in 9:
         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):
+        if tw < 0.15:
             continue
         var s := 2.0 + 4.0 * tw
         var col := Color(1, 1, 1, 0.3 + 0.65 * tw)
@@ -422,65 +506,70 @@ static func glow(ci: CanvasItem, rect: Rect2, color: Color, radius: int = 8, spr
     ci.draw_style_box(sb, rect)
 
 
-## Edelstein in der Farbe der Stufe (ab Rare).
-static func rarity_gem(ci: CanvasItem, rar: String, c: Vector2, s: float, seed: int = 0) -> void:
-    if rar == "Common":
-        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 der Farbe des ersten Elements; weitere Elemente zeigt element_medallion.
+## Hintergrund in den Farben der Elemente: ein Element füllt die Karte, verschmolzene Wesen
+## tragen je Element einen senkrechten Streifen.
 static func fill_elements(ci: CanvasItem, rect: Rect2, elements: Array, radius: int = 8) -> void:
     ci.draw_style_box(box(Cards.ELEMENT_COLORS[elements[0]], radius), rect)
-
-
-## Medaillon eines verschmolzenen Wesens: ein Kreis hinter dem Bild, als Tortenstücke in den
-## Farben seiner Elemente, mit dunklem Rand.
-static func element_medallion(ci: CanvasItem, c: Vector2, r: float, elements: Array) -> void:
-    ci.draw_circle(c, r + 3, Color(0.05, 0.05, 0.08, 0.75))
-    var n := elements.size()
-    for i in n:
-        var from := -PI / 2 + TAU * i / n
-        var to := -PI / 2 + TAU * (i + 1) / n
-        var pts := PackedVector2Array([c])
-        var steps := 24
-        for k in steps + 1:
-            var ang := lerpf(from, to, float(k) / steps)
-            pts.append(c + Vector2(cos(ang), sin(ang)) * r)
-        ci.draw_colored_polygon(pts, Cards.ELEMENT_COLORS[elements[i]])
-    for i in n:
-        var ang := -PI / 2 + TAU * i / n
-        ci.draw_line(c, c + Vector2(cos(ang), sin(ang)) * r, Color(0.05, 0.05, 0.08, 0.75), 2.0)
+    if elements.size() < 2:
+        return
+    var clip := rounded_poly(rect, radius)
+    var w := rect.size.x / elements.size()
+    for i in range(1, elements.size()):
+        var strip := Rect2(rect.position.x + w * i, rect.position.y, w, rect.size.y)
+        for poly in Geometry2D.intersect_polygons(rect_poly(strip), clip):
+            if poly.size() >= 3:
+                ci.draw_colored_polygon(poly, Cards.ELEMENT_COLORS[elements[i]])
+        ci.draw_line(strip.position + Vector2(0, 2), Vector2(strip.position.x, strip.end.y - 2), Color(0.05, 0.05, 0.08, 0.5), 1.5)
 
 
 # --- Kartenteile ------------------------------------------------------
 
-## Kostenkristall: sechseckig, blau, Zahl in der Mitte.
-static func cost_crystal(ci: CanvasItem, c: Vector2, r: float, cost: int, font: int) -> void:
+## Bild der Karte: dunkler Kreis mit Ring in der Elementfarbe, darin das Symbol der Bildkarte
+## (bei Verschmelzungen die des stärkeren Elternteils). Ab Super Rare glänzt der Kreis (Holo),
+## bei Ultimate Rare golden und als Relief.
+static func picture(ci: CanvasItem, card, c: Vector2, r: float, rar: String, seed: int) -> void:
+    var src = card.art_card()
+    var ring := lighter(Cards.ELEMENT_COLORS[src.elements[0]], 0.3)
+    ci.draw_circle(c, r + 3, Color(0.05, 0.05, 0.08, 0.8))
+    ci.draw_circle(c, r, Color(0.09, 0.09, 0.13, 0.9))
+    glyph(ci, src, c, r * 1.3, 0.95, rarity_relief(rar))
+    var lvl := Cards.RARITIES.find(rar)
+    if lvl >= 2:
+        sheen(ci, circle_poly(c, r), Rect2(c - Vector2(r, r), Vector2(r * 2, r * 2)), seed, lvl >= 4)
+    ci.draw_arc(c, r + 1.5, 0, TAU, 48, Color(1.0, 0.86, 0.45) if lvl >= 4 else ring, 3.0, true)
+
+
+## Kostenkristall: sechseckig, blau, Zahl in der Mitte; shiny: goldene, glänzende Zahl.
+static func cost_crystal(ci: CanvasItem, c: Vector2, r: float, cost: int, font: int, shiny: bool = false) -> 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(outer, Color(1.0, 0.86, 0.45) if shiny else 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)
+    _stat_text(ci, str(cost), font, Color.WHITE, c, shiny)
 
 
-## Wertkreis (Angriff gelb, Leben rot) mit Zahl.
-static func stat_circle(ci: CanvasItem, c: Vector2, r: float, value: String, color: Color, font: int, text_col: Color = Color.WHITE) -> void:
-    ci.draw_circle(c, r + 2, Color("14141c"))
+## Wertkreis (Angriff gelb, Leben blau) mit Zahl; shiny: goldener Ring, glänzende Zahl.
+static func stat_circle(ci: CanvasItem, c: Vector2, r: float, value: String, color: Color, font: int, text_col: Color = Color.WHITE, shiny: bool = false) -> void:
+    ci.draw_circle(c, r + 2, Color(1.0, 0.86, 0.45) if shiny else 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, text_col, c, "center", 3)
+    _stat_text(ci, value, font, text_col, c, shiny)
+
+
+static func _stat_text(ci: CanvasItem, s: String, font: int, col: Color, c: Vector2, shiny: bool) -> void:
+    if shiny and col == Color.WHITE:
+        var size := fs(font)
+        var dim := FONT_BOLD.get_string_size(s, HORIZONTAL_ALIGNMENT_LEFT, -1, size)
+        ci.draw_string_outline(FONT_BOLD, c - dim / 2 + Vector2(0, FONT_BOLD.get_ascent(size)), s, HORIZONTAL_ALIGNMENT_LEFT, -1, size, 3, Color(0.05, 0.05, 0.08, 0.95))
+        shiny_text(ci, s, font, Color(1.0, 0.86, 0.45), c, "center", int(c.x + c.y))
+    else:
+        text_outlined(ci, s, font, col, c, "center", 3)
 
 
 ## Eigenschaft als Symbol auf dunklem Kreis: Spott Ausrufezeichen, Flink Doppelpfeil,
@@ -568,6 +657,11 @@ static func _element_glyph(ci: CanvasItem, element: String, c: Vector2, size: fl
             for i in 2 + variant:
                 var r := h * (1.0 - i * 0.28)
                 ci.draw_arc(c + Vector2(i * size * 0.06, 0), r, PI * 0.2 + i * 0.4, PI * 1.5 + i * 0.4, 20, col, maxf(2, size * 0.09))
+        _:  # Neutral: ein schlichter Schild
+            var w := h * 0.8
+            var pts := PackedVector2Array([c + Vector2(-w, -h * 0.8), c + Vector2(w, -h * 0.8), c + Vector2(w, h * 0.1), c + Vector2(0, h), c + Vector2(-w, h * 0.1)])
+            ci.draw_polyline(pts + PackedVector2Array([pts[0]]), col, maxf(2, size * 0.09))
+            ci.draw_line(c + Vector2(0, -h * 0.5), c + Vector2(0, h * 0.6), col, maxf(2, size * 0.07))
 
 
 static func _flame(ci: CanvasItem, c: Vector2, h: float, col: Color) -> void: