update

scripts/profile.gd

@@ -16,9 +16,9 @@ const REWARD_WIN := 100
 const REWARD_LOSS := 50
 # Schwierigkeit: Leben der Gegner, KI und Münzen.
 const DIFFICULTIES := {
-    "leicht": {"name": "Leicht", "life": 25, "reward": 0.75, "smart": false},
-    "normal": {"name": "Normal", "life": 30, "reward": 1.0, "smart": true},
-    "schwer": {"name": "Schwer", "life": 35, "reward": 1.5, "smart": true},
+	"leicht": {"name": "Leicht", "life": 25, "reward": 0.75, "smart": false},
+	"normal": {"name": "Normal", "life": 30, "reward": 1.0, "smart": true},
+	"schwer": {"name": "Schwer", "life": 35, "reward": 1.5, "smart": true},
 }
 # Sammlung: eine Stufe abgeben bringt Staub, eine Stufe aufwerten kostet Staub.
 const DUST_DISMANTLE := {"Common": 50, "Rare": 100, "Super Rare": 200, "Ultra Rare": 500, "Ultimate Rare": 1000}
@@ -36,215 +36,215 @@ var perk := ""            # gewähltes eigenes Merkmal (nach Kapitel 1)
 
 ## Neues Profil: noch ohne Karten, das Startdeck wählt der Spieler (choose_start).
 static func starter() -> Profile:
-    var p := Profile.new()
-    p.coins = START_COINS
-    return p
+	var p := Profile.new()
+	p.coins = START_COINS
+	return p
 
 
 ## Hat der Spieler schon ein Startdeck gewählt?
 func started() -> bool:
-    return not collection.is_empty()
+	return not collection.is_empty()
 
 
 ## Das Startdeck eines Elements wird Sammlung und Stapel.
 func choose_start(element: String) -> void:
-    collection = {}
-    deck = DeckGen.start_deck(element)
-    for id in deck:
-        collection[id] = 0
+	collection = {}
+	deck = DeckGen.start_deck(element)
+	for id in deck:
+		collection[id] = 0
 
 
 ## Lädt den Spielstand; bei Schaden die Sicherung; sonst ein neues Profil.
 static func load_or_new(path: String = SAVE_PATH) -> Profile:
-    for candidate in [path, path + ".bak"]:
-        if FileAccess.file_exists(candidate):
-            var json := JSON.new()
-            if json.parse(FileAccess.get_file_as_string(candidate)) == OK and json.data is Dictionary:
-                return from_dict(json.data)
-    if FileAccess.file_exists(path):
-        DirAccess.rename_absolute(ProjectSettings.globalize_path(path), ProjectSettings.globalize_path(path) + ".corrupt")
-    var p := starter()
-    p.save(path)
-    return p
+	for candidate in [path, path + ".bak"]:
+		if FileAccess.file_exists(candidate):
+			var json := JSON.new()
+			if json.parse(FileAccess.get_file_as_string(candidate)) == OK and json.data is Dictionary:
+				return from_dict(json.data)
+	if FileAccess.file_exists(path):
+		DirAccess.rename_absolute(ProjectSettings.globalize_path(path), ProjectSettings.globalize_path(path) + ".corrupt")
+	var p := starter()
+	p.save(path)
+	return p
 
 
 ## Liest jede Spielstand-Version; ältere Stände behalten Münzen, Staub, Kampagne und
 ## Einstellungen und bekommen die Startsammlung.
 static func from_dict(d: Dictionary) -> Profile:
-    var p := Profile.new()
-    p.coins = int(d.get("coins", 0))
-    p.dust = int(d.get("dust", 0))
-    p.campaign_stage = int(d.get("campaign_stage", 0))
-    if int(d.get("version", 1)) >= SAVE_VERSION:
-        var coll = d.get("collection", {})
-        for cid in coll:
-            if Cards.has_id(cid):
-                p.collection[cid] = clampi(int(coll[cid]), 0, Cards.RARITIES.size() - 1)
-        var ids := []
-        for cid in d.get("deck", []):
-            if p.collection.has(cid) and not (cid in ids):
-                ids.append(cid)
-        p.deck = ids.slice(0, Game.DECK_MAX)
-    var se = d.get("settings", {})
-    p.settings = {"volume": float(se.get("volume", 0.0)), "music": float(se.get("music", 0.0)),
-        "ai_speed": float(se.get("ai_speed", 1.0)), "animations": bool(se.get("animations", true)),
-        "language": str(se.get("language", "de")), "difficulty": str(se.get("difficulty", "normal")),
-        "big_font": bool(se.get("big_font", false))}
-    if not DIFFICULTIES.has(p.settings.difficulty):
-        p.settings.difficulty = "normal"
-    p.perk = str(d.get("perk", ""))
-    if not Game.PERKS.has(p.perk):
-        p.perk = ""
-    return p
+	var p := Profile.new()
+	p.coins = int(d.get("coins", 0))
+	p.dust = int(d.get("dust", 0))
+	p.campaign_stage = int(d.get("campaign_stage", 0))
+	if int(d.get("version", 1)) >= SAVE_VERSION:
+		var coll = d.get("collection", {})
+		for cid in coll:
+			if Cards.has_id(cid):
+				p.collection[cid] = clampi(int(coll[cid]), 0, Cards.RARITIES.size() - 1)
+		var ids := []
+		for cid in d.get("deck", []):
+			if p.collection.has(cid) and not (cid in ids):
+				ids.append(cid)
+		p.deck = ids.slice(0, Game.DECK_MAX)
+	var se = d.get("settings", {})
+	p.settings = {"volume": float(se.get("volume", 0.0)), "music": float(se.get("music", 0.0)),
+		"ai_speed": float(se.get("ai_speed", 1.0)), "animations": bool(se.get("animations", true)),
+		"language": str(se.get("language", "de")), "difficulty": str(se.get("difficulty", "normal")),
+		"big_font": bool(se.get("big_font", false))}
+	if not DIFFICULTIES.has(p.settings.difficulty):
+		p.settings.difficulty = "normal"
+	p.perk = str(d.get("perk", ""))
+	if not Game.PERKS.has(p.perk):
+		p.perk = ""
+	return p
 
 
 func to_dict() -> Dictionary:
-    return {"version": SAVE_VERSION, "coins": coins, "dust": dust, "collection": collection, "deck": deck,
-        "campaign_stage": campaign_stage, "settings": settings, "perk": perk}
+	return {"version": SAVE_VERSION, "coins": coins, "dust": dust, "collection": collection, "deck": deck,
+		"campaign_stage": campaign_stage, "settings": settings, "perk": perk}
 
 
 ## Speichert und sichert den vorherigen Stand als .bak.
 func save(path: String = SAVE_PATH) -> void:
-    var abs := ProjectSettings.globalize_path(path)
-    if FileAccess.file_exists(path):
-        DirAccess.copy_absolute(abs, abs + ".bak")
-    var f := FileAccess.open(path, FileAccess.WRITE)
-    f.store_string(JSON.stringify(to_dict(), "\t"))
-    f.close()
+	var abs := ProjectSettings.globalize_path(path)
+	if FileAccess.file_exists(path):
+		DirAccess.copy_absolute(abs, abs + ".bak")
+	var f := FileAccess.open(path, FileAccess.WRITE)
+	f.store_string(JSON.stringify(to_dict(), "\t"))
+	f.close()
 
 
 func take_notices() -> Array[String]:
-    var out := notices.duplicate()
-    notices.clear()
-    return out
+	var out := notices.duplicate()
+	notices.clear()
+	return out
 
 
 # --- Sammlung und Stapel -----------------------------------------------------------
 
 func owns(cid: String) -> bool:
-    return collection.has(cid)
+	return collection.has(cid)
 
 
 func level(cid: String) -> int:
-    return int(collection.get(cid, 0))
+	return int(collection.get(cid, 0))
 
 
 func rarity(cid: String) -> String:
-    return Cards.RARITIES[level(cid)]
+	return Cards.RARITIES[level(cid)]
 
 
 ## Karten-ID -> Stufe für den Kampf (nur aufgewertete Karten, siehe Game.Player.looks).
 func looks() -> Dictionary:
-    var out := {}
-    for cid in collection:
-        if int(collection[cid]) > 0:
-            out[cid] = int(collection[cid])
-    return out
+	var out := {}
+	for cid in collection:
+		if int(collection[cid]) > 0:
+			out[cid] = int(collection[cid])
+	return out
 
 
 ## Der Stapel für den Kampf: der gewählte, mit weiteren eigenen Karten bis DECK_MIN aufgefüllt,
 ## falls er zu klein ist (Karten können durch Zerlegen wegfallen).
 func deck_cards() -> Array:
-    return DeckGen.fill(deck.filter(func(id): return collection.has(id)), collection.keys(), Game.DECK_MIN)
+	return DeckGen.fill(deck.filter(func(id): return collection.has(id)), collection.keys(), Game.DECK_MIN, collection)
 
 
 ## Karte in den Stapel oder heraus. Gibt "" zurück oder eine Fehlermeldung.
 func toggle_deck(cid: String) -> String:
-    if cid in deck:
-        deck.erase(cid)
-        return ""
-    if not owns(cid):
-        return "Karte nicht in der Sammlung"
-    if deck.size() >= Game.DECK_MAX:
-        return "Der Stapel ist voll (%d Karten)" % Game.DECK_MAX
-    deck.append(cid)
-    return ""
+	if cid in deck:
+		deck.erase(cid)
+		return ""
+	if not owns(cid):
+		return "Karte nicht in der Sammlung"
+	if deck.size() >= Game.DECK_MAX:
+		return "Der Stapel ist voll (%d Karten)" % Game.DECK_MAX
+	deck.append(cid)
+	return ""
 
 
 ## Wertet eine Karte um eine Stufe auf. Gibt "" zurück oder eine Fehlermeldung.
 func upgrade(cid: String) -> String:
-    if not owns(cid):
-        return "Karte nicht in der Sammlung"
-    var lvl := level(cid)
-    if lvl >= Cards.RARITIES.size() - 1:
-        return "Schon auf der höchsten Stufe"
-    var cost: int = DUST_UPGRADE[Cards.RARITIES[lvl + 1]]
-    if dust < cost:
-        return "Nicht genug Staub (%d nötig)" % cost
-    dust -= cost
-    collection[cid] = lvl + 1
-    return ""
+	if not owns(cid):
+		return "Karte nicht in der Sammlung"
+	var lvl := level(cid)
+	if lvl >= Cards.RARITIES.size() - 1:
+		return "Schon auf der höchsten Stufe"
+	var cost: int = DUST_UPGRADE[Cards.RARITIES[lvl + 1]]
+	if dust < cost:
+		return "Nicht genug Staub (%d nötig)" % cost
+	dust -= cost
+	collection[cid] = lvl + 1
+	return ""
 
 
 ## Entzaubern: eine Stufe abgeben bringt Staub; eine Common-Karte verlässt die Sammlung.
 ## Gibt "" zurück oder eine Fehlermeldung.
 func dismantle(cid: String) -> String:
-    if not owns(cid):
-        return "Karte nicht in der Sammlung"
-    var lvl := level(cid)
-    dust += DUST_DISMANTLE[Cards.RARITIES[lvl]]
-    if lvl == 0:
-        collection.erase(cid)
-        deck.erase(cid)
-    else:
-        collection[cid] = lvl - 1
-    return ""
+	if not owns(cid):
+		return "Karte nicht in der Sammlung"
+	var lvl := level(cid)
+	dust += DUST_DISMANTLE[Cards.RARITIES[lvl]]
+	if lvl == 0:
+		collection.erase(cid)
+		deck.erase(cid)
+	else:
+		collection[cid] = lvl - 1
+	return ""
 
 
 ## Herstellen: eine fehlende Karte für Staub als Common. Gibt "" zurück oder eine Fehlermeldung.
 func craft(cid: String) -> String:
-    if owns(cid):
-        return "Karte schon in der Sammlung"
-    if dust < CRAFT_COST:
-        return "Nicht genug Staub (%d nötig)" % CRAFT_COST
-    dust -= CRAFT_COST
-    collection[cid] = 0
-    return ""
+	if owns(cid):
+		return "Karte schon in der Sammlung"
+	if dust < CRAFT_COST:
+		return "Nicht genug Staub (%d nötig)" % CRAFT_COST
+	dust -= CRAFT_COST
+	collection[cid] = 0
+	return ""
 
 
 # --- Booster ----------------------------------------------------------------------
 
 ## Fünf Karten mit gewürfelter Seltenheit.
 static func roll_booster(r: RandomNumberGenerator) -> Array:
-    var rarities := RARITY_WEIGHTS.keys()
-    var weights := PackedFloat32Array(RARITY_WEIGHTS.values())
-    var pool := Cards.all()
-    var out := []
-    for i in BOOSTER_SIZE:
-        var rar: String = rarities[r.rand_weighted(weights)]
-        if i == BOOSTER_SIZE - 1 and out.all(func(x): return x.rarity == "Common"):
-            rar = "Rare"  # mindestens eine Rare pro Booster
-        out.append({"card": pool[r.randi_range(0, pool.size() - 1)], "rarity": rar})
-    return out
+	var rarities := RARITY_WEIGHTS.keys()
+	var weights := PackedFloat32Array(RARITY_WEIGHTS.values())
+	var pool := Cards.all()
+	var out := []
+	for i in BOOSTER_SIZE:
+		var rar: String = rarities[r.rand_weighted(weights)]
+		if i == BOOSTER_SIZE - 1 and out.all(func(x): return x.rarity == "Common"):
+			rar = "Rare"  # mindestens eine Rare pro Booster
+		out.append({"card": pool[r.randi_range(0, pool.size() - 1)], "rarity": rar})
+	return out
 
 
 ## Öffnet einen Booster. Neue Karten kommen in Sammlung und Stapel (solange Platz ist). Von jeder
 ## Karte zählt die seltenste Version: eine höhere ersetzt die alte, die zu Staub wird; eine gleiche
 ## oder niedrigere wird selbst zu Staub. Gibt die Ergebnisse zurück, leer wenn die Münzen nicht reichen.
 func open_booster(r: RandomNumberGenerator = null) -> Array:
-    if coins < BOOSTER_COST:
-        return []
-    if r == null:
-        r = Game.make_rng()
-    coins -= BOOSTER_COST
-    var out := roll_booster(r)
-    for res in out:
-        var lvl: int = Cards.RARITIES.find(res.rarity)
-        res["new"] = not owns(res.card.id)
-        res["upgraded"] = false
-        res["dust"] = 0
-        if res.new:
-            collection[res.card.id] = lvl
-            if deck.size() < Game.DECK_MAX:
-                deck.append(res.card.id)
-        elif lvl > level(res.card.id):
-            res["upgraded"] = true
-            res["dust"] = DUST_DISMANTLE[rarity(res.card.id)]
-            collection[res.card.id] = lvl
-        else:
-            res["dust"] = DUST_DISMANTLE[res.rarity]
-        dust += res.dust
-    return out
+	if coins < BOOSTER_COST:
+		return []
+	if r == null:
+		r = Game.make_rng()
+	coins -= BOOSTER_COST
+	var out := roll_booster(r)
+	for res in out:
+		var lvl: int = Cards.RARITIES.find(res.rarity)
+		res["new"] = not owns(res.card.id)
+		res["upgraded"] = false
+		res["dust"] = 0
+		if res.new:
+			collection[res.card.id] = lvl
+			if deck.size() < Game.DECK_MAX:
+				deck.append(res.card.id)
+		elif lvl > level(res.card.id):
+			res["upgraded"] = true
+			res["dust"] = DUST_DISMANTLE[rarity(res.card.id)]
+			collection[res.card.id] = lvl
+		else:
+			res["dust"] = DUST_DISMANTLE[res.rarity]
+		dust += res.dust
+	return out
 
 
 # --- Kampf und Kampagne -----------------------------------------------------------
@@ -252,20 +252,20 @@ func open_booster(r: RandomNumberGenerator = null) -> Array:
 ## Verbucht ein Kampfergebnis und gibt die Münzbelohnung zurück.
 ## stage >= 0: Kampagnenstufe; ein erster Sieg schaltet die nächste Stufe frei.
 func record_battle(won: bool, stage: int = -1, reward_factor: float = 1.0) -> int:
-    var reward := REWARD_LOSS
-    if won:
-        reward = int(round(REWARD_WIN * reward_factor))
-        if stage >= 0 and stage == campaign_stage:
-            campaign_stage += 1
-            reward = Campaign.stage(stage).reward
-            notices.append("Kampagne: %s besiegt" % Campaign.stage(stage).name)
-    coins += reward
-    return reward
+	var reward := REWARD_LOSS
+	if won:
+		reward = int(round(REWARD_WIN * reward_factor))
+		if stage >= 0 and stage == campaign_stage:
+			campaign_stage += 1
+			reward = Campaign.stage(stage).reward
+			notices.append("Kampagne: %s besiegt" % Campaign.stage(stage).name)
+	coins += reward
+	return reward
 
 
 func difficulty() -> Dictionary:
-    return DIFFICULTIES.get(settings.get("difficulty", "normal"), DIFFICULTIES.normal)
+	return DIFFICULTIES.get(settings.get("difficulty", "normal"), DIFFICULTIES.normal)
 
 
 func perk_unlocked() -> bool:
-    return campaign_stage >= Campaign.STAGES.size()
+	return campaign_stage >= Campaign.STAGES.size()