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

Use GoalData for everything

Browse Source
This commit is contained in:
Michele Rossi
2026-03-21 12:11:38 +01:00
parent 52c23b194e
commit 471a7b10f7
15 changed files with 205 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
core/generator-unlock-goals/TECH_SPEC.md
View File

@@ -1,186 +1,58 @@
# Goal-Based Generator Unlocks - Technical Specification
# Generator-Embedded Unlock Goals - Technical Specification
## Document Status
- Version: 1.0
- Date: 2026-03-14
- Scope: Unlock generators when goal thresholds are reached using one or more currencies.
- Context sources: Amp threads `T-019ce93a-d410-70ad-aaa0-4697dafb0148` and `T-019c846f-2556-75bc-a1aa-fb26cd9ff52a`.
- Version: 2.0
- Date: 2026-03-21
- Scope: Unlock generators from `CurrencyGeneratorData.unlock_goal` when goal thresholds are reached.
## Problem Statement
The project already supports generator state (`unlocked` + `available`) in `GameState`, but unlock
transitions are currently configured only by static defaults (`starts_unlocked`, `starts_available`).
We need progression goals so that a locked generator becomes usable only after the player reaches
specific currency quantities. Goals must support one or more currencies per objective.
Generator unlock progression should be authored where generator behavior lives: `CurrencyGeneratorData`.
The previous scene-level target mapping layer increased setup complexity and created mismatch risk between goal targets and scene content.
## Current Baseline
1. Generator state is persisted in `GameState.generator_states` with keys `owned`, `purchased_count`,
`unlocked`, `available`.
2. `CurrencyGenerator` already exposes `is_unlocked`, `is_available`, and `is_available_to_player()`
and uses them to gate click, auto-production, and purchases.
3. `GeneratorContainer` listens to `GameState.generator_state_changed` and updates button enabled/disabled state.
4. Save/load sanitization already handles generator state schema evolution safely.
This means the unlock feature can be added without changing core purchase/production mechanics.
## Goals And Non-Goals
## Goals
1. Define unlock goals that depend on one or multiple currency thresholds.
2. Evaluate goals automatically when relevant currency values change.
3. Unlock and make target generator available exactly once when a goal is met.
4. Keep behavior deterministic after save/load.
## Non-Goals
1. Adding quests, timed objectives, or repeatable missions.
2. Adding reward types other than generator unlock/availability.
3. Rebalancing generator economy values in this feature.
1. Generator state persists in `GameState.generator_states` (`owned`, `purchased_count`, `unlocked`, `available`).
2. `CurrencyGenerator` already gates interactions using `is_available_to_player()`.
3. Goal primitives remain reusable and data-driven:
- `GoalRequirementData`
- `GoalData`
4. Generator data now owns unlock definition via `unlock_goal: GoalData`.
## Functional Requirements
1. A generator may define one optional unlock goal (`CurrencyGeneratorData.unlock_goal`).
2. Goal completion uses logical AND across requirements.
3. Requirement checks use total acquired currency (`GameState.get_total_currency_acquired_by_id`).
4. Unlock evaluation runs:
- once on generator `_ready()`
- on every `GameState.currency_changed`
5. When a goal is met, runtime sets:
- `GameState.set_generator_unlocked(generator_id, true)`
- `GameState.set_generator_available(generator_id, true)`
6. Unlock transitions are idempotent.
7. Unlock completion emits `CurrencyGenerator.goal_achieved(generator_id, goal_id)` for hooks/UI.
1. A goal targets exactly one generator (`target_generator_id`).
2. A goal contains one or more currency requirements (`requirements[]`).
3. Goal completion rule is logical AND across requirements (all thresholds must be met).
4. Supported currencies must map to existing `GameState.CurrencyType` values (`gold`, `gems`).
5. When completed, a goal sets both:
- `GameState.set_generator_unlocked(target, true)`
- `GameState.set_generator_available(target, true)`
6. Goal completion must be idempotent (re-evaluating does not re-apply side effects).
7. Goal checks must run:
- at runtime on `currency_changed`
- once at startup after loading save data
8. Invalid goal entries (unknown currency, missing target id, malformed amount) must be ignored with a warning,
not a crash.
## Runtime Design
1. `CurrencyGeneratorData` exposes:
- `has_unlock_goal()`
- `is_unlock_goal_met()`
- `get_unlock_goal_id()`
2. `CurrencyGenerator` executes `_evaluate_generator_unlock_goal()`.
3. No scene-level unlock controller is required.
4. Goals debug UI discovers goals from scene generators instead of external target-mapping resources.
## Data Model
## New Config Resources
Goals are now authored as typed resources instead of JSON:
1. `res://core/goals/goal_requirement_data.gd` (`GoalRequirementData`)
2. `res://core/goals/goal_data.gd` (`GoalData`)
3. `res://core/generator-unlock-goals/generator_unlock_goal_data.gd` (`GeneratorUnlockGoalData`)
Example assets:
1. `res://idles/goals/magic_total_30.tres` (goal definition)
2. `res://idles/goals/generator_unlock_knowledge.tres` (goal target binding)
Notes:
1. `GoalData.id` must be unique and stable.
2. `GoalData.requirements` must contain at least one valid `GoalRequirementData`.
3. `GoalRequirementData` stores amount as mantissa/exponent to preserve `BigNumber` semantics.
## Runtime Structures (GDScript)
Runtime data comes from resource classes:
1. `GoalRequirementData`
- `currency: Resource`
- `amount_mantissa: float`
- `amount_exponent: int`
2. `GoalData`
- `id: StringName`
- `requirements: Array[Resource]` (validated as `GoalRequirementData`)
3. `GeneratorUnlockGoalData`
- `target_generator_id: StringName`
- `goal: Resource` (validated as `GoalData`)
No persistent `completed_goals` storage is required for v1 because completion is derived from generator unlock state.
## System Design
## New Runtime Component
Add a scene-level controller script (recommended name: `generator_unlock_system.gd`) responsible for:
1. Loading + validating exported `GeneratorUnlockGoalData` resources.
2. Subscribing to currency change signals.
3. Evaluating pending goals.
4. Triggering generator unlock transitions.
Placement options:
1. Attach to the main gameplay scene root (preferred for prototype).
2. Promote to autoload later if multiple gameplay scenes require shared unlock logic.
## Evaluation Flow
1. On `_ready()`:
- load goals
- connect to `GameState.currency_changed`
- run `evaluate_all_goals()` once
2. On currency change:
- run `evaluate_all_goals()` (or an optimized subset)
3. For each goal:
- skip if target generator already unlocked and available
- verify all requirement thresholds
- if satisfied, unlock target generator and emit debug/info log
## Pseudocode
```gdscript
func _evaluate_goal(goal: UnlockGoal) -> bool:
if GameState.is_generator_unlocked(goal.target_generator_id) and GameState.is_generator_available(goal.target_generator_id):
return false
for requirement in goal.requirements:
var current: BigNumber = _get_currency_amount(requirement.currency)
if current.is_less_than(requirement.amount):
return false
GameState.set_generator_unlocked(goal.target_generator_id, true)
GameState.set_generator_available(goal.target_generator_id, true)
return true
```
## UI/UX Behavior
1. Existing `GeneratorContainer` behavior already prevents interaction while locked.
2. Optional v1.1 enhancement: show a compact "Unlock requirement" line for locked generators.
3. On unlock, UI updates automatically through existing `generator_state_changed` signal path.
## Error Handling And Validation
1. File open failure: log warning and disable unlock processing for that session.
2. JSON parse failure or wrong root type: log warning and disable unlock processing.
3. Invalid goal entries: skip only invalid entries, continue loading valid ones.
4. Duplicate goal IDs: keep first entry, ignore duplicates with warning.
5. Unknown `target_generator_id`: allow config load, but warn when evaluation cannot find/resolve state.
## Data Authoring Rules
1. Configure locked generators with `starts_unlocked = false` and `starts_available = false`.
2. Set `unlock_goal` directly on that generator `.tres` resource.
3. Keep `GoalData.id` unique and stable.
4. Goal data can still be shared across systems (generator unlocks, buff unlocks).
## Save/Load Behavior
1. Unlock persistence remains unchanged because `GameState` stores `unlocked/available`.
2. Re-evaluation after load is safe due to idempotent state writes.
1. Unlock result persists naturally via existing generator state persistence.
2. On load, if a goal was completed previously, no duplicate effect occurs because state is already unlocked.
3. If config thresholds are reduced in future versions, startup evaluation can unlock additional generators from existing balances.
## Performance Considerations
1. v1 can safely evaluate all goals on every currency change (small goal count).
2. If goals scale up, add currency-to-goal index to evaluate only affected goals.
3. BigNumber comparisons are lightweight for this usage profile.
## Implementation Plan
1. Add `GoalData` and `GeneratorUnlockGoalData` resources with initial goals.
2. Implement `generator_unlock_system.gd` loader/validator/evaluator.
3. Attach unlock system to gameplay scene (`generator_museum.tscn` or current active scene).
4. Configure at least one generator as initially locked (`starts_unlocked = false`, `starts_available = false`) in its `.tres` data.
5. Add runtime logs for unlock events and invalid config entries.
6. Run headless project parse smoke check.
## Acceptance Criteria
1. A locked generator becomes usable immediately after all configured currency thresholds are reached.
2. Goals with multiple requirements unlock only when every requirement is satisfied.
3. Unlock state persists after save/load and app restart.
4. No crashes occur when goals file is missing or malformed.
5. Existing generator purchase/production behavior is unchanged for already unlocked generators.
## Manual Test Cases
1. Start with a generator configured as locked; verify buy buttons are disabled.
2. Grant required currency via debug controls; verify automatic unlock and enabled buttons.
3. Save/restart; verify generator remains unlocked.
4. Use a multi-currency goal; verify partial progress does not unlock.
5. Corrupt one goal entry in JSON; verify warning is logged and other valid goals still work.
## Validation
1. Run headless parse: `"$GODOT_BIN" --headless --path . --quit`
2. Manual smoke test in `generator_museum`:
- verify locked generator starts unavailable
- grant required currency
- verify generator unlocks automatically
- verify state persists after restart

11
core/generator-unlock-goals/generator_unlock_goal_data.gd
View File

@@ -1,11 +0,0 @@
class_name GeneratorUnlockGoalData
extends Resource
@export var target_generator_id: StringName = &""
@export var goal: GoalData
func get_goal_data() -> GoalData:
if goal == null:
return null
return goal

1
core/generator-unlock-goals/generator_unlock_goal_data.gd.uid
View File

@@ -1 +0,0 @@
uid://dt4df3gwr6n5m

151
core/generator-unlock-goals/generator_unlock_system.gd
View File

@@ -1,151 +0,0 @@
extends Node
signal goal_achieved(goal_id: StringName, target_generator_id: StringName)
class GeneratorUnlockGoal extends RefCounted:
var target_generator_id: StringName
var goal: GoalData
func _init(target_id: StringName, goal_data: GoalData) -> void:
target_generator_id = target_id
goal = goal_data
@export var goals: Array[GeneratorUnlockGoalData] = []
var _runtime_goals: Array[GeneratorUnlockGoal] = []
var _known_generator_ids: Dictionary = {}
var _warned_unknown_target_ids: Dictionary = {}
var _is_evaluating_goals: bool = false
var _pending_goal_evaluation: bool = false
func _ready() -> void:
_collect_known_generator_ids()
_load_goals()
GameState.currency_changed.connect(_on_currency_changed)
GameState.generator_state_changed.connect(_on_generator_state_changed)
_evaluate_all_goals()
_evaluate_all_goals.call_deferred()
func _on_currency_changed(_changed_currency_id: StringName, _new_amount: BigNumber) -> void:
_evaluate_all_goals()
func _on_generator_state_changed(generator_id: StringName, _state: Dictionary) -> void:
var generator_key: String = String(generator_id)
if not generator_key.is_empty():
_known_generator_ids[generator_key] = true
_evaluate_all_goals()
func _evaluate_all_goals() -> void:
if _runtime_goals.is_empty():
return
if _is_evaluating_goals:
_pending_goal_evaluation = true
return
_is_evaluating_goals = true
for runtime_goal in _runtime_goals:
_evaluate_goal(runtime_goal)
_is_evaluating_goals = false
if _pending_goal_evaluation:
_pending_goal_evaluation = false
_evaluate_all_goals.call_deferred()
func _evaluate_goal(runtime_goal: GeneratorUnlockGoal) -> bool:
if runtime_goal == null:
return false
if runtime_goal.goal == null:
return false
if _is_goal_completed(runtime_goal):
return false
if not _can_resolve_target(runtime_goal.target_generator_id):
return false
if not bool(runtime_goal.goal.is_met()):
return false
var goal_id: StringName = _extract_goal_id(runtime_goal.goal)
GameState.set_generator_unlocked(runtime_goal.target_generator_id, true)
GameState.set_generator_available(runtime_goal.target_generator_id, true)
goal_achieved.emit(goal_id, runtime_goal.target_generator_id)
print("[UnlockSystem] Goal completed: %s -> %s" % [String(goal_id), String(runtime_goal.target_generator_id)])
return true
func _extract_goal_id(goal: GoalData) -> StringName:
if goal == null:
return &""
var goal_id_text: String = String(goal.id).strip_edges()
if goal_id_text.is_empty():
return &""
return StringName(goal_id_text)
func _is_goal_completed(runtime_goal: GeneratorUnlockGoal) -> bool:
return (
GameState.is_generator_unlocked(runtime_goal.target_generator_id)
and GameState.is_generator_available(runtime_goal.target_generator_id)
)
func _can_resolve_target(target_generator_id: StringName) -> bool:
var target_key: String = String(target_generator_id)
if target_key.is_empty():
return false
if _known_generator_ids.has(target_key) or GameState.generator_states.has(target_key):
return true
if not _warned_unknown_target_ids.has(target_key):
_warned_unknown_target_ids[target_key] = true
push_warning("Unlock goal target generator not found in scene/state: '%s'" % target_key)
return false
func _load_goals() -> void:
_runtime_goals.clear()
var seen_goal_ids: Dictionary = {}
for generator_unlock_goal_data in goals:
if generator_unlock_goal_data == null:
continue
var goal_data: GeneratorUnlockGoalData = generator_unlock_goal_data
if goal_data == null:
continue
var target_generator_id: String = String(goal_data.target_generator_id).strip_edges()
if target_generator_id.is_empty():
push_warning("Skipping unlock goal resource: missing target_generator_id")
continue
var resolved_goal: GoalData = generator_unlock_goal_data.get_goal_data()
if resolved_goal == null:
push_warning("Skipping unlock goal for target '%s': goal is null" % target_generator_id)
continue
if not bool(resolved_goal.is_valid()):
push_warning("Skipping unlock goal for target '%s': goal is invalid" % target_generator_id)
continue
var goal_key: String = String(resolved_goal.id)
if seen_goal_ids.has(goal_key):
push_warning("Duplicate unlock goal id skipped: '%s'" % goal_key)
continue
seen_goal_ids[goal_key] = true
_runtime_goals.append(GeneratorUnlockGoal.new(StringName(target_generator_id), resolved_goal))
if _runtime_goals.is_empty():
push_warning("Unlock goals loaded, but no valid entries were found.")
func _collect_known_generator_ids() -> void:
_known_generator_ids.clear()
var scene_root: Node = get_tree().current_scene
var search_root: Node = scene_root if scene_root != null else self
var generator_nodes: Array[Node] = search_root.find_children("*", "CurrencyGenerator", true, false)
for generator_node in generator_nodes:
var generator: CurrencyGenerator = generator_node as CurrencyGenerator
if generator == null:
continue
var generator_key: String = String(generator.get_generator_id())
if generator_key.is_empty():
continue
_known_generator_ids[generator_key] = true

1
core/generator-unlock-goals/generator_unlock_system.gd.uid
View File

@@ -1 +0,0 @@
uid://1sykgtg24a7g

265
core/generator-unlock-goals/goals_debug_ui.gd
View File

@@ -1,265 +0,0 @@
extends PanelContainer
class GoalDefinition extends RefCounted:
var target_generator_id: StringName
var goal: Resource
func _init(target_id: StringName, goal_data: Resource) -> void:
target_generator_id = target_id
goal = goal_data
const GOAL_DATA_SCRIPT: Script = preload("res://core/goals/goal_data.gd")
const GOAL_REQUIREMENT_SCRIPT: Script = preload("res://core/goals/goal_requirement_data.gd")
const GENERATOR_UNLOCK_GOAL_DATA_SCRIPT: Script = preload("res://core/generator-unlock-goals/generator_unlock_goal_data.gd")
class GoalRow extends RefCounted:
var goal: GoalDefinition
var status_label: Label
var requirements_label: Label
var button: Button
func _init(goal_definition: GoalDefinition, status: Label, requirements: Label, unlock_button: Button) -> void:
goal = goal_definition
status_label = status
requirements_label = requirements
button = unlock_button
@export var goals: Array[GeneratorUnlockGoalData] = []
@onready var _summary_label: Label = $MarginContainer/VBoxContainer/SummaryLabel
@onready var _goals_list: VBoxContainer = $MarginContainer/VBoxContainer/ScrollContainer/GoalsList
var _loaded_goals: Array[GoalDefinition] = []
var _rows_by_goal_id: Dictionary = {}
var _known_generator_ids: Dictionary = {}
var _warned_unknown_target_ids: Dictionary = {}
func _ready() -> void:
_collect_known_generator_ids()
_load_goals()
_build_goal_rows()
GameState.currency_changed.connect(_on_currency_changed)
GameState.generator_state_changed.connect(_on_generator_state_changed)
_refresh_ui()
_refresh_ui.call_deferred()
func _on_currency_changed(_currency_id: StringName, _new_amount: BigNumber) -> void:
_refresh_ui()
func _on_generator_state_changed(generator_id: StringName, _state: Dictionary) -> void:
var generator_key: String = String(generator_id)
if not generator_key.is_empty():
_known_generator_ids[generator_key] = true
_refresh_ui()
func _load_goals() -> void:
_loaded_goals.clear()
var seen_goal_ids: Dictionary = {}
for goal_resource in goals:
if goal_resource == null:
continue
if goal_resource.get_script() != GENERATOR_UNLOCK_GOAL_DATA_SCRIPT:
continue
var goal_data: Resource = goal_resource
if goal_data == null:
continue
var target_generator_id: String = String(goal_data.get("target_generator_id")).strip_edges()
if target_generator_id.is_empty():
continue
var resolved_goal: Resource = goal_data.call("get_goal_data")
if resolved_goal == null:
continue
if not bool(resolved_goal.call("is_valid")):
continue
var goal_key: String = String(resolved_goal.get("id"))
if seen_goal_ids.has(goal_key):
push_warning("Goals debug UI: duplicate goal id '%s' skipped" % goal_key)
continue
seen_goal_ids[goal_key] = true
_loaded_goals.append(GoalDefinition.new(StringName(target_generator_id), resolved_goal))
func _build_goal_rows() -> void:
_rows_by_goal_id.clear()
for child in _goals_list.get_children():
child.queue_free()
for goal in _loaded_goals:
if goal.goal == null:
continue
if goal.goal.get_script() != GOAL_DATA_SCRIPT:
continue
var row_container: HBoxContainer = HBoxContainer.new()
row_container.size_flags_horizontal = Control.SIZE_EXPAND_FILL
row_container.add_theme_constant_override("separation", 12)
var title_label: Label = Label.new()
title_label.custom_minimum_size = Vector2(220.0, 0.0)
title_label.text = "%s -> %s" % [String(goal.goal.get("id")), String(goal.target_generator_id)]
var status_label: Label = Label.new()
status_label.custom_minimum_size = Vector2(95.0, 0.0)
var requirements_label: Label = Label.new()
requirements_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
var unlock_button: Button = Button.new()
unlock_button.custom_minimum_size = Vector2(90.0, 0.0)
unlock_button.text = "Unlock"
unlock_button.disabled = true
unlock_button.pressed.connect(_on_unlock_pressed.bind(goal.goal.get("id")))
row_container.add_child(title_label)
row_container.add_child(status_label)
row_container.add_child(requirements_label)
row_container.add_child(unlock_button)
_goals_list.add_child(row_container)
_rows_by_goal_id[String(goal.goal.get("id"))] = GoalRow.new(goal, status_label, requirements_label, unlock_button)
func _refresh_ui() -> void:
if _loaded_goals.is_empty():
_summary_label.text = "No valid goals loaded"
return
var ready_to_unlock: int = 0
var unlocked: int = 0
for goal in _loaded_goals:
if goal.goal == null:
continue
if goal.goal.get_script() != GOAL_DATA_SCRIPT:
continue
var row: GoalRow = _rows_by_goal_id.get(String(goal.goal.get("id")))
if row == null:
continue
_refresh_goal_row(row)
if _is_goal_completed(goal):
unlocked += 1
elif _is_goal_met(goal):
ready_to_unlock += 1
_summary_label.text = "Goals: %d | Ready: %d | Unlocked: %d" % [_loaded_goals.size(), ready_to_unlock, unlocked]
func _refresh_goal_row(row: GoalRow) -> void:
var goal: GoalDefinition = row.goal
var already_unlocked: bool = _is_goal_completed(goal)
var can_resolve_target: bool = _can_resolve_target(goal.target_generator_id)
var met: bool = _is_goal_met(goal)
var can_unlock: bool = can_resolve_target and met and not already_unlocked
row.requirements_label.text = _get_requirements_text(goal)
row.button.disabled = not can_unlock
row.button.text = "Done" if already_unlocked else "Unlock"
if already_unlocked:
row.status_label.text = "Unlocked"
return
if not can_resolve_target:
row.status_label.text = "Missing"
return
if met:
row.status_label.text = "Ready"
return
row.status_label.text = "Locked"
func _is_goal_met(goal: GoalDefinition) -> bool:
if goal == null:
return false
if goal.goal == null:
return false
if goal.goal.get_script() != GOAL_DATA_SCRIPT:
return false
return bool(goal.goal.call("is_met"))
func _is_goal_completed(goal: GoalDefinition) -> bool:
return (
GameState.is_generator_unlocked(goal.target_generator_id)
and GameState.is_generator_available(goal.target_generator_id)
)
func _on_unlock_pressed(goal_id: StringName) -> void:
var row: GoalRow = _rows_by_goal_id.get(String(goal_id))
if row == null:
return
var goal: GoalDefinition = row.goal
if _is_goal_completed(goal):
return
if not _can_resolve_target(goal.target_generator_id):
return
if not _is_goal_met(goal):
return
GameState.set_generator_unlocked(goal.target_generator_id, true)
GameState.set_generator_available(goal.target_generator_id, true)
print("[GoalsDebugUI] Unlocked goal '%s' -> %s" % [String(goal.goal.get("id")), String(goal.target_generator_id)])
_refresh_ui()
func _can_resolve_target(target_generator_id: StringName) -> bool:
var target_key: String = String(target_generator_id)
if target_key.is_empty():
return false
if _known_generator_ids.has(target_key) or GameState.generator_states.has(target_key):
return true
if not _warned_unknown_target_ids.has(target_key):
_warned_unknown_target_ids[target_key] = true
push_warning("Goals debug UI target generator not found in scene/state: '%s'" % target_key)
return false
func _collect_known_generator_ids() -> void:
_known_generator_ids.clear()
var scene_root: Node = get_tree().current_scene
var search_root: Node = scene_root if scene_root != null else self
var generator_nodes: Array[Node] = search_root.find_children("*", "CurrencyGenerator", true, false)
for generator_node in generator_nodes:
var generator: CurrencyGenerator = generator_node as CurrencyGenerator
if generator == null:
continue
var generator_key: String = String(generator.get_generator_id())
if generator_key.is_empty():
continue
_known_generator_ids[generator_key] = true
func _get_requirements_text(goal: GoalDefinition) -> String:
if goal == null:
return ""
if goal.goal == null:
return ""
if goal.goal.get_script() != GOAL_DATA_SCRIPT:
return ""
var parts: Array[String] = []
for requirement_resource in goal.goal.call("get_valid_requirements"):
if requirement_resource == null:
continue
if requirement_resource.get_script() != GOAL_REQUIREMENT_SCRIPT:
continue
var requirement_currency_id: StringName = requirement_resource.call("get_currency_id")
var total_amount: BigNumber = GameState.get_total_currency_acquired_by_id(requirement_currency_id)
var required_amount: BigNumber = requirement_resource.call("get_amount")
parts.append(
"%s %s / %s" % [
_currency_label(requirement_currency_id),
total_amount.to_string_suffix(2),
required_amount.to_string_suffix(2)
]
)
return " | ".join(parts)
func _currency_label(currency_id: StringName) -> String:
return GameState.get_currency_name(currency_id)

1
core/generator-unlock-goals/goals_debug_ui.gd.uid
View File

@@ -1 +0,0 @@
uid://bmrbaulftvvwm

43
core/generator-unlock-goals/goals_debug_ui.tscn
View File

@@ -1,43 +0,0 @@
[gd_scene format=3 uid="uid://dirvi76rkoowf"]
[ext_resource type="Script" uid="uid://bmrbaulftvvwm" path="res://core/generator-unlock-goals/goals_debug_ui.gd" id="1_s7s8v"]
[ext_resource type="Resource" uid="uid://mnuihnwb70ba" path="res://idles/goals/generator_unlock_knowledge.tres" id="2_jyi2u"]
[ext_resource type="Resource" uid="uid://8wrqdjewfdq5" path="res://idles/goals/generator_unlock_wood.tres" id="3_0nfd8"]
[node name="GoalsDebugUI" type="PanelContainer" unique_id=1494700185]
offset_right = 640.0
offset_bottom = 260.0
script = ExtResource("1_s7s8v")
goals = [ExtResource("2_jyi2u"), ExtResource("3_0nfd8")]
[node name="MarginContainer" type="MarginContainer" parent="." unique_id=1582529872]
layout_mode = 2
theme_override_constants/margin_left = 8
theme_override_constants/margin_top = 8
theme_override_constants/margin_right = 8
theme_override_constants/margin_bottom = 8
[node name="VBoxContainer" type="VBoxContainer" parent="MarginContainer" unique_id=1555356181]
layout_mode = 2
size_flags_horizontal = 3
size_flags_vertical = 3
theme_override_constants/separation = 6
[node name="TitleLabel" type="Label" parent="MarginContainer/VBoxContainer" unique_id=811777252]
layout_mode = 2
text = "Goals Debug"
[node name="SummaryLabel" type="Label" parent="MarginContainer/VBoxContainer" unique_id=17196021]
layout_mode = 2
text = "Goals: 0 | Ready: 0 | Unlocked: 0"
[node name="ScrollContainer" type="ScrollContainer" parent="MarginContainer/VBoxContainer" unique_id=1105060075]
custom_minimum_size = Vector2(0, 170)
layout_mode = 2
size_flags_vertical = 3
[node name="GoalsList" type="VBoxContainer" parent="MarginContainer/VBoxContainer/ScrollContainer" unique_id=1684633480]
layout_mode = 2
size_flags_horizontal = 3
size_flags_vertical = 3
theme_override_constants/separation = 6

24
core/generator/currency_generator.gd
View File

@@ -17,6 +17,8 @@ signal production_tick(amount: BigNumber, cycle_count: int, total_owned: int)
signal buff_purchased(buff_id: StringName, new_level: int, cost: BigNumber, cost_currency_id: StringName)
## Emitted when a buff purchase cannot be paid.
signal buff_purchase_failed(buff_id: StringName, required_cost: BigNumber, cost_currency_id: StringName)
## Emitted when this generator unlock goal transitions to completed.
signal goal_achieved(generator_id: StringName, goal_id: StringName)
## Sentinel exponent used when cost math overflows float range.
const HUGE_COST_EXPONENT: int = 1000000
@@ -97,6 +99,7 @@ func _ready() -> void:
GameState.currency_changed.connect(_on_currency_changed)
GameState.generator_state_changed.connect(_on_generated_state_changed)
_evaluate_generator_unlock_goal(false)
## Updates click cooldown/click grants and runs automatic production cycles.
func _process(delta: float) -> void:
@@ -542,8 +545,29 @@ func _try_unlock_buff_from_goal(buff: GeneratorBuffData) -> void:
GameState.set_generator_buff_unlocked(_generator_id, buff_id, true)
func _on_currency_changed(_changed_currency_id: StringName, _new_amount: BigNumber) -> void:
_evaluate_generator_unlock_goal(false)
_evaluate_buff_unlock_goals()
func try_unlock_from_goal() -> bool:
return _evaluate_generator_unlock_goal(true)
func _evaluate_generator_unlock_goal(allow_manual_unlock: bool) -> bool:
if data == null:
return false
if is_available_to_player():
return false
if not data.has_unlock_goal():
return false
if not data.unlocks_automatically_from_goal() and not allow_manual_unlock:
return false
if not data.is_unlock_goal_met():
return false
GameState.set_generator_unlocked(_generator_id, true)
GameState.set_generator_available(_generator_id, true)
goal_achieved.emit(_generator_id, data.get_unlock_goal_id())
return true
## Default unlocked state loaded from generator data.
func _default_unlocked_state() -> bool:
if data == null:

32
core/generator/currency_generator_data.gd
View File

@@ -1,10 +1,17 @@
class_name CurrencyGeneratorData
extends Resource
enum UnlockGoalBehavior {
AUTOMATIC,
MANUAL_BUTTON,
}
@export var id: StringName = &""
@export var name: String = ""
@export var starts_unlocked: bool = true
@export var starts_available: bool = true
@export var unlock_goal: GoalData
@export var unlock_goal_behavior: UnlockGoalBehavior = UnlockGoalBehavior.AUTOMATIC
## Base cost and exponential growth (part I): cost_next = b * r^owned
@export var initial_cost: float = 10.0
@@ -31,6 +38,31 @@ extends Resource
## Data-driven buffs purchasable for this generator.
@export var buffs: Array[GeneratorBuffData] = []
func has_unlock_goal() -> bool:
if unlock_goal == null:
return false
return bool(unlock_goal.is_valid())
func is_unlock_goal_met() -> bool:
if not has_unlock_goal():
return false
return bool(unlock_goal.is_met())
func get_unlock_goal_id() -> StringName:
if not has_unlock_goal():
return &""
var goal_id_text: String = String(unlock_goal.id).strip_edges()
if goal_id_text.is_empty():
return &""
return StringName(goal_id_text)
func unlocks_automatically_from_goal() -> bool:
return unlock_goal_behavior == UnlockGoalBehavior.AUTOMATIC
func find_buff(buff_id: StringName) -> GeneratorBuffData:
var expected_id: String = String(buff_id).strip_edges()
if expected_id.is_empty():