update

2026-10-03 01:17:27 +02:00
parent 24a03ed1ee
commit 5f9442497a
27 changed files with 1040 additions and 871 deletions
--- a/scripts/ui/style.gd
+++ b/scripts/ui/style.gd
@@ -309,43 +309,79 @@ 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.

-## Ab episch bewegt sich der Glanz; dann zeichnet die Karte jeden Frame neu.
+## Ab Super 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


-## Farbe einer Stufe; mythisch schillert über die Zeit durch alle Farben.
+## Farbe einer Stufe; Ultimate Rare schillert über die Zeit durch alle Farben.
 static func rarity_color(rar: String, seed: int = 0) -> Color:
-    if rar == "mythisch" and animations:
+    if rar == "Ultimate Rare" 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.
+## Rahmenfarbe einer Stufe: Common 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)
+    return Color("3a3e4c") if rar == "Common" 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:
+## Farbe des Kartennamens: Rare silbern, Ultra Rare golden, Ultimate Rare schillernd, sonst weiß.
+static func rarity_name_color(rar: String, seed: int = 0) -> Color:
+    match rar:
+        "Rare", "Ultra Rare", "Ultimate Rare":
+            return lighter(rarity_color(rar, seed), 0.25)
+    return TEXT
+
+
+## Ultimate Rare zeigt das Bild als Relief (Licht- und Schattenkante).
+static func rarity_relief(rar: String) -> bool:
+    return Cards.RARITIES.find(rar) >= 4
+
+
+## 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)]])
+        return
    var phase := (seed % 100) / 100.0
-    if lvl >= 2 and animations:
+    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)
+
+
+## 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
-    for layer in [[1.0, 0.07], [0.55, 0.09], [0.22, 0.13]]:
+    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):
            if poly.size() >= 3 and _area(poly) > 2.0:  # Splitter am Rand lassen sich nicht zeichnen
-                ci.draw_colored_polygon(poly, Color(1, 1, 1, layer[1]))
+                ci.draw_colored_polygon(poly, layer[1])


 static func _area(poly: PackedVector2Array) -> float:
@@ -357,15 +393,13 @@ static func _area(poly: PackedVector2Array) -> float:
    return absf(a) / 2.0


-## Funkeln ab legendär: kleine Sterne, die aufblitzen und vergehen; ganz zum Schluss zeichnen.
+## 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:
-    var lvl := Cards.RARITIES.find(rar)
-    if lvl < 3:
+    if Cards.RARITIES.find(rar) < 4:
        return
    var t := Time.get_ticks_msec() / 1000.0
-    var n := 5 if lvl == 3 else 9
-    for i in n:
+    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
@@ -388,9 +422,9 @@ 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 selten).
+## 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 == "gewöhnlich":
+    if rar == "Common":
        return
    var col := rarity_color(rar, seed)
    var diamond := func(h: float, k: Color) -> void:
@@ -400,23 +434,28 @@ static func rarity_gem(ci: CanvasItem, rar: String, c: Vector2, s: float, seed:
    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.
+## Hintergrund in der Farbe des ersten Elements; weitere Elemente zeigt element_medallion.
 static func fill_elements(ci: CanvasItem, rect: Rect2, elements: Array, radius: int = 8) -> void:
-    if elements.size() == 1:
-        ci.draw_style_box(box(Cards.ELEMENT_COLORS[elements[0]], radius), rect)
-        return
+    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()
-    var w := rect.size.x / n
    for i in n:
-        var sb := StyleBoxFlat.new()
-        sb.bg_color = Cards.ELEMENT_COLORS[elements[i]]
-        if i == 0:
-            sb.corner_radius_top_left = radius
-            sb.corner_radius_bottom_left = radius
-        if i == n - 1:
-            sb.corner_radius_top_right = radius
-            sb.corner_radius_bottom_right = radius
-        ci.draw_style_box(sb, Rect2(rect.position + Vector2(floorf(i * w), 0), Vector2(ceilf(w), rect.size.y)))
+        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)


 # --- Kartenteile ------------------------------------------------------
@@ -444,20 +483,18 @@ static func stat_circle(ci: CanvasItem, c: Vector2, r: float, value: String, col
    text_outlined(ci, value, font, Color.WHITE, c, "center", 3)


-## Schlüsselwort als Symbol auf dunklem Kreis: Schild Schild, Doppelschlag gekreuzte Klingen.
+## Eigenschaft als Symbol auf dunklem Kreis: Spott Ausrufezeichen, Flink Doppelpfeil,
+## Regeneration Kreuz, 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)
+        "Spott":
+            ci.draw_line(c + Vector2(0, -r * 0.7), c + Vector2(0, r * 0.2), col, w * 1.6)
+            ci.draw_circle(c + Vector2(0, r * 0.6), w * 0.95, col)
+        "Regeneration":
+            ci.draw_line(c + Vector2(0, -r * 0.7), c + Vector2(0, r * 0.7), col, w * 1.5)
+            ci.draw_line(c + Vector2(-r * 0.7, 0), c + Vector2(r * 0.7, 0), col, w * 1.5)
        "Flink":
            for i in 2:
                var x := c.x - r * 0.55 + i * r * 0.55
@@ -471,10 +508,24 @@ static func keyword_icon(ci: CanvasItem, kw: String, c: Vector2, r: float, col:

 # --- Kartensymbole (prozedural, je Element) --------------------------

-static func glyph(ci: CanvasItem, card, center: Vector2, size: float, alpha: float = 0.95) -> void:
+## relief: Schatten- und Lichtkante unter dem Symbol (Ultimate Rare).
+static func glyph(ci: CanvasItem, card, center: Vector2, size: float, alpha: float = 0.95, relief: bool = false) -> void:
+    if relief:
+        ci.draw_set_transform(Vector2(2, 2))
+        _glyph_plain(ci, card, center, size, Color(0, 0, 0, alpha * 0.6))
+        ci.draw_set_transform(Vector2(-1, -1))
+        _glyph_plain(ci, card, center, size, Color(1, 1, 1, alpha * 0.5))
+        ci.draw_set_transform(Vector2.ZERO)
+    _glyph_plain(ci, card, center, size, Color(0, 0, 0, 0), alpha)
+
+
+## Symbol in einer festen Farbe (Relief) oder, bei durchsichtigem tint, in Elementfarben.
+static func _glyph_plain(ci: CanvasItem, card, center: Vector2, size: float, tint: Color, 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 = alpha
+    if tint.a > 0:
+        col = tint
    var elems: Array = card.elements
    if elems.size() == 1:
        _element_glyph(ci, elems[0], center, size, variant, col)
@@ -483,6 +534,8 @@ static func glyph(ci: CanvasItem, card, center: Vector2, size: float, alpha: flo
    _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 = alpha
+    if tint.a > 0:
+        col2 = tint
    _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)