Add goals

game_state.gd

@@ -12,8 +12,33 @@ enum CurrencyType { gold, gems }
 # ==========================================
 # STATE VARIABLES
 # ==========================================
-var gold: BigNumber = BigNumber.from_float(0.0)
-var gems: BigNumber = BigNumber.from_float(0.0)
+var _current_currency: Dictionary = {}
+var _total_currency_acquired: Dictionary = {}
+
+var gold: BigNumber:
+	get:
+		return _get_current_currency_ref(CurrencyType.gold)
+	set(value):
+		_set_current_currency(CurrencyType.gold, value)
+
+var gems: BigNumber:
+	get:
+		return _get_current_currency_ref(CurrencyType.gems)
+	set(value):
+		_set_current_currency(CurrencyType.gems, value)
+
+var total_gold_acquired: BigNumber:
+	get:
+		return _get_total_currency_ref(CurrencyType.gold)
+	set(value):
+		_set_total_currency(CurrencyType.gold, value)
+
+var total_gems_acquired: BigNumber:
+	get:
+		return _get_total_currency_ref(CurrencyType.gems)
+	set(value):
+		_set_total_currency(CurrencyType.gems, value)
+
 var generator_states: Dictionary = {}
 
 var last_save_time: int = 0 # Unix timestamp
@@ -26,35 +51,47 @@ const GENERATOR_UNLOCKED_KEY: String = "unlocked"
 const GENERATOR_AVAILABLE_KEY: String = "available"
 
 func _ready() -> void:
+	_initialize_currency_maps()
 	load_game()
 
 # ==========================================
 # STATE MODIFIERS
 # ==========================================
 func add_gold(amount: BigNumber) -> void:
-	gold.add_in_place(amount)
-	currency_changed.emit(CurrencyType.gold, gold)
+	add_currency(CurrencyType.gold, amount)
 
 func spend_gold(cost: BigNumber) -> bool:
-	if gold.is_greater_than(cost) or gold.is_equal_to(cost):
-		var negative_cost = BigNumber.new(-cost.mantissa, cost.exponent)
-		gold.add_in_place(negative_cost)
-		currency_changed.emit(CurrencyType.gold, gold)
-		return true
-	return false
+	return spend_currency(CurrencyType.gold, cost)
 
 func add_gems(amount: BigNumber) -> void:
-	gems.add_in_place(amount)
-	currency_changed.emit(CurrencyType.gems, gems)
+	add_currency(CurrencyType.gems, amount)
 
 func spend_gems(cost: BigNumber) -> bool:
-	if gems.is_greater_than(cost) or gems.is_equal_to(cost):
-		var negative_cost = BigNumber.new(-cost.mantissa, cost.exponent)
-		gems.add_in_place(negative_cost)
-		currency_changed.emit(CurrencyType.gems, gems)
+	return spend_currency(CurrencyType.gems, cost)
+
+func add_currency(currency: CurrencyType, amount: BigNumber) -> void:
+	if amount.mantissa > 0.0:
+		_get_total_currency_ref(currency).add_in_place(amount)
+
+	var current: BigNumber = _get_current_currency_ref(currency)
+	current.add_in_place(amount)
+	currency_changed.emit(currency, current)
+
+func spend_currency(currency: CurrencyType, cost: BigNumber) -> bool:
+	var current: BigNumber = _get_current_currency_ref(currency)
+	if current.is_greater_than(cost) or current.is_equal_to(cost):
+		var negative_cost: BigNumber = BigNumber.new(-cost.mantissa, cost.exponent)
+		current.add_in_place(negative_cost)
+		currency_changed.emit(currency, current)
 		return true
 	return false
 
+func get_currency_amount(currency: CurrencyType) -> BigNumber:
+	return _get_current_currency_ref(currency)
+
+func get_total_currency_acquired(currency: CurrencyType) -> BigNumber:
+	return _get_total_currency_ref(currency)
+
 func register_generator(generator_id: StringName, unlocked: bool = false, available: bool = false) -> void:
 	var key: String = String(generator_id)
 	if key.is_empty():
@@ -132,6 +169,8 @@ func save_game() -> void:
 	var save_data = {
 		"gold": gold.serialize(),
 		"gems": gems.serialize(),
+		"total_gold_acquired": total_gold_acquired.serialize(),
+		"total_gems_acquired": total_gems_acquired.serialize(),
 		"generator_states": _serialize_generator_states(),
 		"last_save_time": Time.get_unix_time_from_system()
 	}
@@ -150,9 +189,59 @@ func load_game() -> void:
 		if parsed is Dictionary:
 			gold = BigNumber.deserialize(parsed.get("gold", {}))
 			gems = BigNumber.deserialize(parsed.get("gems", {}))
+			total_gold_acquired = _deserialize_total_currency(parsed.get("total_gold_acquired", null), gold)
+			total_gems_acquired = _deserialize_total_currency(parsed.get("total_gems_acquired", null), gems)
 			generator_states = _deserialize_generator_states(parsed.get("generator_states", {}))
 			last_save_time = parsed.get("last_save_time", Time.get_unix_time_from_system())
 
+func _deserialize_total_currency(raw_total: Variant, current_amount: BigNumber) -> BigNumber:
+	var minimum_total: BigNumber = _copy_big_number(current_amount)
+	if minimum_total.mantissa < 0.0:
+		minimum_total = BigNumber.from_float(0.0)
+
+	if not (raw_total is Dictionary):
+		return minimum_total
+
+	var parsed_total: BigNumber = BigNumber.deserialize(raw_total)
+	if parsed_total.mantissa < 0.0:
+		return minimum_total
+	if parsed_total.is_less_than(minimum_total):
+		return minimum_total
+	return parsed_total
+
+func _copy_big_number(value: BigNumber) -> BigNumber:
+	return BigNumber.new(value.mantissa, value.exponent)
+
+func _initialize_currency_maps() -> void:
+	_set_current_currency(CurrencyType.gold, BigNumber.from_float(0.0))
+	_set_current_currency(CurrencyType.gems, BigNumber.from_float(0.0))
+	_set_total_currency(CurrencyType.gold, BigNumber.from_float(0.0))
+	_set_total_currency(CurrencyType.gems, BigNumber.from_float(0.0))
+
+func _get_current_currency_ref(currency: CurrencyType) -> BigNumber:
+	var value: Variant = _current_currency.get(currency)
+	if value is BigNumber:
+		return value
+
+	var fallback: BigNumber = BigNumber.from_float(0.0)
+	_current_currency[currency] = fallback
+	return fallback
+
+func _get_total_currency_ref(currency: CurrencyType) -> BigNumber:
+	var value: Variant = _total_currency_acquired.get(currency)
+	if value is BigNumber:
+		return value
+
+	var fallback: BigNumber = BigNumber.from_float(0.0)
+	_total_currency_acquired[currency] = fallback
+	return fallback
+
+func _set_current_currency(currency: CurrencyType, value: BigNumber) -> void:
+	_current_currency[currency] = _copy_big_number(value)
+
+func _set_total_currency(currency: CurrencyType, value: BigNumber) -> void:
+	_total_currency_acquired[currency] = _copy_big_number(value)
+
 func _default_generator_state(unlocked: bool, available: bool) -> Dictionary:
 	return {
 		GENERATOR_OWNED_KEY: 0,