jmp-games/idle
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add generator buffs (additional test required)

Browse Source
This commit is contained in:
Michele Rossi
2026-03-15 10:06:43 +01:00
parent 7b58c36414
commit 278b073501
19 changed files with 691 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
game_state.gd
View File

@@ -6,6 +6,7 @@ extends Node
# ==========================================
signal currency_changed(currency_id: StringName, new_amount: BigNumber)
signal generator_state_changed(generator_id: StringName, state: Dictionary)
signal generator_buff_level_changed(generator_id: StringName, buff_id: StringName, new_level: int)
# ==========================================
# STATE VARIABLES
@@ -14,6 +15,7 @@ var _current_currency: Dictionary = {}
var _total_currency_acquired: Dictionary = {}
var generator_states: Dictionary = {}
var generator_buff_levels: Dictionary = {}
var last_save_time: int = 0 # Unix timestamp
@@ -25,9 +27,12 @@ const GENERATOR_OWNED_KEY: String = "owned"
const GENERATOR_PURCHASED_COUNT_KEY: String = "purchased_count"
const GENERATOR_UNLOCKED_KEY: String = "unlocked"
const GENERATOR_AVAILABLE_KEY: String = "available"
const GENERATOR_STATES_KEY: String = "generator_states"
const GENERATOR_BUFF_LEVELS_KEY: String = "generator_buff_levels"
const CURRENCIES_KEY: String = "currencies"
const CURRENT_KEY: String = "current"
const TOTAL_KEY: String = "total"
const LAST_SAVE_TIME_KEY: String = "last_save_time"
func _ready() -> void:
_initialize_currency_maps()
@@ -192,14 +197,61 @@ func set_generator_available(generator_id: StringName, value: bool) -> void:
state[GENERATOR_AVAILABLE_KEY] = value
_set_generator_state(generator_id, state)
func register_generator_buff(generator_id: StringName, buff_id: StringName, initial_level: int = 0) -> void:
var generator_key: String = String(generator_id)
var buff_key: String = String(buff_id)
if generator_key.is_empty() or buff_key.is_empty():
return
var levels: Dictionary = _get_generator_buff_levels_ref(generator_id)
if levels.has(buff_key):
var existing_level: int = _to_non_negative_int(levels.get(buff_key, initial_level), initial_level)
if int(levels.get(buff_key, initial_level)) != existing_level:
levels[buff_key] = existing_level
generator_buff_levels[generator_key] = levels
generator_buff_level_changed.emit(StringName(generator_key), StringName(buff_key), existing_level)
return
var sanitized_level: int = _to_non_negative_int(initial_level, 0)
levels[buff_key] = sanitized_level
generator_buff_levels[generator_key] = levels
generator_buff_level_changed.emit(StringName(generator_key), StringName(buff_key), sanitized_level)
func get_generator_buff_level(generator_id: StringName, buff_id: StringName) -> int:
var buff_key: String = String(buff_id)
if buff_key.is_empty():
return 0
var levels: Dictionary = _get_generator_buff_levels_ref(generator_id)
return _to_non_negative_int(levels.get(buff_key, 0), 0)
func set_generator_buff_level(generator_id: StringName, buff_id: StringName, value: int) -> void:
var generator_key: String = String(generator_id)
var buff_key: String = String(buff_id)
if generator_key.is_empty() or buff_key.is_empty():
return
var levels: Dictionary = _get_generator_buff_levels_ref(generator_id)
var next_level: int = _to_non_negative_int(value, 0)
if int(levels.get(buff_key, -1)) == next_level:
return
levels[buff_key] = next_level
generator_buff_levels[generator_key] = levels
generator_buff_level_changed.emit(StringName(generator_key), StringName(buff_key), next_level)
func get_generator_buff_levels(generator_id: StringName) -> Dictionary:
return _get_generator_buff_levels_ref(generator_id).duplicate(true)
# ==========================================
# PERSISTENCE (Save/Load)
# ==========================================
func save_game() -> void:
var save_data = {
CURRENCIES_KEY: _serialize_currency_balances(),
"generator_states": _serialize_generator_states(),
"last_save_time": Time.get_unix_time_from_system()
GENERATOR_STATES_KEY: _serialize_generator_states(),
GENERATOR_BUFF_LEVELS_KEY: _serialize_generator_buff_levels(),
LAST_SAVE_TIME_KEY: Time.get_unix_time_from_system()
}
var file: FileAccess = FileAccess.open(file_name, FileAccess.WRITE)
@@ -218,8 +270,9 @@ func load_game() -> void:
if parsed_data.has(CURRENCIES_KEY):
_load_currency_balances(parsed_data.get(CURRENCIES_KEY, {}))
generator_states = _deserialize_generator_states(parsed_data.get("generator_states", {}))
last_save_time = parsed_data.get("last_save_time", Time.get_unix_time_from_system())
generator_states = _deserialize_generator_states(parsed_data.get(GENERATOR_STATES_KEY, {}))
generator_buff_levels = _deserialize_generator_buff_levels(parsed_data.get(GENERATOR_BUFF_LEVELS_KEY, {}))
last_save_time = parsed_data.get(LAST_SAVE_TIME_KEY, Time.get_unix_time_from_system())
func _load_currency_balances(raw_currencies: Variant) -> void:
if not (raw_currencies is Dictionary):
@@ -378,6 +431,32 @@ func _set_generator_state(generator_id: StringName, state: Dictionary) -> void:
generator_states[key] = sanitized
generator_state_changed.emit(StringName(key), sanitized.duplicate(true))
func _get_generator_buff_levels_ref(generator_id: StringName) -> Dictionary:
var key: String = String(generator_id)
if key.is_empty():
return {}
var existing_raw: Variant = generator_buff_levels.get(key, {})
if existing_raw is Dictionary:
var sanitized: Dictionary = _sanitize_generator_buff_levels(existing_raw)
generator_buff_levels[key] = sanitized
return sanitized
var fallback: Dictionary = {}
generator_buff_levels[key] = fallback
return fallback
func _sanitize_generator_buff_levels(raw_levels: Dictionary) -> Dictionary:
var sanitized_levels: Dictionary = {}
for buff_key_variant in raw_levels.keys():
var buff_key: String = String(buff_key_variant)
if buff_key.is_empty():
continue
sanitized_levels[buff_key] = _to_non_negative_int(raw_levels.get(buff_key_variant, 0), 0)
return sanitized_levels
func _serialize_generator_states() -> Dictionary:
var result: Dictionary = {}
for key_variant in generator_states.keys():
@@ -405,6 +484,35 @@ func _deserialize_generator_states(raw_value: Variant) -> Dictionary:
result[key] = _deserialize_generator_state_entry(entry)
return result
func _serialize_generator_buff_levels() -> Dictionary:
var result: Dictionary = {}
for generator_key_variant in generator_buff_levels.keys():
var generator_key: String = String(generator_key_variant)
if generator_key.is_empty():
continue
var raw_levels: Variant = generator_buff_levels.get(generator_key_variant)
if raw_levels is Dictionary:
result[generator_key] = _sanitize_generator_buff_levels(raw_levels)
return result
func _deserialize_generator_buff_levels(raw_value: Variant) -> Dictionary:
var result: Dictionary = {}
if not (raw_value is Dictionary):
return result
for generator_key_variant in raw_value.keys():
var generator_key: String = String(generator_key_variant)
if generator_key.is_empty():
continue
var raw_levels: Variant = raw_value.get(generator_key_variant)
if raw_levels is Dictionary:
result[generator_key] = _sanitize_generator_buff_levels(raw_levels)
return result
func _serialize_generator_state_entry(raw_state: Dictionary) -> Dictionary:
var owned_value: int = _to_non_negative_int(raw_state.get(GENERATOR_OWNED_KEY, 0), 0)
var purchased_value: int = _to_non_negative_int(raw_state.get(GENERATOR_PURCHASED_COUNT_KEY, owned_value), owned_value)