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

Change project organization

Browse Source
This commit is contained in:
Michele Rossi
2026-03-19 22:18:34 +01:00
parent 278b073501
commit 3c8709c834
39 changed files with 74 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
core/generator-unlock-goals/TECH_SPEC.md Normal file
View File

@@ -0,0 +1,197 @@
# Goal-Based Generator Unlocks - 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`.
## 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.
## 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.
## Functional Requirements
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.
## Data Model
## New Config File
Add a root JSON file:
- `res://generator_unlock_goals.json`
Schema (v1):
```json
{
"version": 1,
"goals": [
{
"id": "unlock_gems_generator",
"target_generator_id": "Gems",
"requirements": [
{
"currency": "gold",
"amount": { "m": 1.0, "e": 3 }
}
]
}
]
}
```
Notes:
1. `amount` uses existing `BigNumber` serialization (`m`, `e`) to avoid float precision/overflow issues.
2. `id` must be unique and stable.
3. `requirements` must contain at least one entry.
## Runtime Structures (GDScript)
Recommended internal structs/classes:
1. `UnlockGoalRequirement`
- `currency: GameState.CurrencyType`
- `amount: BigNumber`
2. `UnlockGoal`
- `id: StringName`
- `target_generator_id: StringName`
- `requirements: Array[UnlockGoalRequirement]`
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 `generator_unlock_goals.json`.
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.
## Save/Load Behavior
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 `generator_unlock_goals.json` 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.

208
core/generator-unlock-goals/generator_unlock_system.gd Normal file
View File

@@ -0,0 +1,208 @@
extends Node
class UnlockGoalRequirement extends RefCounted:
var currency_id: StringName
var amount: BigNumber
func _init(req_currency_id: StringName, req_amount: BigNumber) -> void:
currency_id = req_currency_id
amount = req_amount
class UnlockGoal extends RefCounted:
var id: StringName
var target_generator_id: StringName
var requirements: Array[UnlockGoalRequirement]
func _init(goal_id: StringName, target_id: StringName, goal_requirements: Array[UnlockGoalRequirement]) -> void:
id = goal_id
target_generator_id = target_id
requirements = goal_requirements
const GOALS_FILE_PATH: String = "res://idles/generator_unlock_goals.json"
const SCHEMA_VERSION: int = 1
var _goals: Array[UnlockGoal] = []
var _known_generator_ids: Dictionary = {}
var _warned_unknown_target_ids: Dictionary = {}
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 _goals.is_empty():
return
for goal in _goals:
_evaluate_goal(goal)
func _evaluate_goal(goal: UnlockGoal) -> bool:
if _is_goal_completed(goal):
return false
if not _can_resolve_target(goal.target_generator_id):
return false
for requirement in goal.requirements:
var total_amount: BigNumber = _get_total_currency_amount(requirement.currency_id)
if total_amount.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)
print("[UnlockSystem] Goal completed: %s -> %s" % [String(goal.id), String(goal.target_generator_id)])
return true
func _is_goal_completed(goal: UnlockGoal) -> bool:
return (
GameState.is_generator_unlocked(goal.target_generator_id)
and GameState.is_generator_available(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:
_goals.clear()
if not FileAccess.file_exists(GOALS_FILE_PATH):
push_warning("Unlock goals file not found: %s" % GOALS_FILE_PATH)
return
var file: FileAccess = FileAccess.open(GOALS_FILE_PATH, FileAccess.READ)
if file == null:
push_warning("Unable to open unlock goals file: %s" % GOALS_FILE_PATH)
return
var parsed: Variant = JSON.parse_string(file.get_as_text())
if not (parsed is Dictionary):
push_warning("Unlock goals root must be a Dictionary: %s" % GOALS_FILE_PATH)
return
var root: Dictionary = parsed
var version: int = int(root.get("version", SCHEMA_VERSION))
if version != SCHEMA_VERSION:
push_warning("Unlock goals schema version %d is different from expected %d" % [version, SCHEMA_VERSION])
var raw_goals: Variant = root.get("goals", [])
if not (raw_goals is Array):
push_warning("Unlock goals file has invalid 'goals' field (expected Array)")
return
var seen_goal_ids: Dictionary = {}
for raw_goal in raw_goals:
var goal: UnlockGoal = _parse_goal(raw_goal)
if goal == null:
continue
var goal_key: String = String(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
_goals.append(goal)
if _goals.is_empty():
push_warning("Unlock goals loaded, but no valid entries were found.")
func _parse_goal(raw_goal: Variant) -> UnlockGoal:
if not (raw_goal is Dictionary):
push_warning("Skipping unlock goal: entry is not a Dictionary")
return null
var goal_dict: Dictionary = raw_goal
var goal_id: String = String(goal_dict.get("id", "")).strip_edges()
var target_id: String = String(goal_dict.get("target_generator_id", "")).strip_edges()
if goal_id.is_empty():
push_warning("Skipping unlock goal: missing 'id'")
return null
if target_id.is_empty():
push_warning("Skipping unlock goal '%s': missing 'target_generator_id'" % goal_id)
return null
var raw_requirements: Variant = goal_dict.get("requirements", [])
if not (raw_requirements is Array):
push_warning("Skipping unlock goal '%s': 'requirements' must be an Array" % goal_id)
return null
var parsed_requirements: Array[UnlockGoalRequirement] = []
for raw_requirement in raw_requirements:
var requirement: UnlockGoalRequirement = _parse_requirement(raw_requirement, goal_id)
if requirement != null:
parsed_requirements.append(requirement)
if parsed_requirements.is_empty():
push_warning("Skipping unlock goal '%s': no valid requirements" % goal_id)
return null
return UnlockGoal.new(StringName(goal_id), StringName(target_id), parsed_requirements)
func _parse_requirement(raw_requirement: Variant, goal_id: String) -> UnlockGoalRequirement:
if not (raw_requirement is Dictionary):
push_warning("Skipping requirement in goal '%s': entry is not a Dictionary" % goal_id)
return null
var requirement_dict: Dictionary = raw_requirement
var currency_id: StringName = _parse_currency(requirement_dict.get("currency", ""))
if currency_id == &"" or not GameState.is_known_currency_id(currency_id):
push_warning("Skipping requirement in goal '%s': unknown currency '%s'" % [goal_id, String(requirement_dict.get("currency", ""))])
return null
var raw_amount: Variant = requirement_dict.get("amount", {})
if not (raw_amount is Dictionary):
push_warning("Skipping requirement in goal '%s': 'amount' must be a Dictionary" % goal_id)
return null
var amount: BigNumber = BigNumber.deserialize(raw_amount)
if amount.mantissa < 0.0:
push_warning("Skipping requirement in goal '%s': amount must be non-negative" % goal_id)
return null
return UnlockGoalRequirement.new(currency_id, amount)
func _parse_currency(raw_currency: Variant) -> StringName:
return GameState.parse_currency_id(raw_currency)
func _get_total_currency_amount(currency_id: StringName) -> BigNumber:
return GameState.get_total_currency_acquired_by_id(currency_id)
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 Normal file
View File

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

298
core/generator-unlock-goals/goals_debug_ui.gd Normal file
View File

@@ -0,0 +1,298 @@
extends PanelContainer
class GoalRequirement extends RefCounted:
var currency_id: StringName
var amount: BigNumber
func _init(req_currency_id: StringName, req_amount: BigNumber) -> void:
currency_id = req_currency_id
amount = req_amount
class GoalDefinition extends RefCounted:
var id: StringName
var target_generator_id: StringName
var requirements: Array[GoalRequirement]
func _init(goal_id: StringName, target_id: StringName, goal_requirements: Array[GoalRequirement]) -> void:
id = goal_id
target_generator_id = target_id
requirements = goal_requirements
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
const GOALS_FILE_PATH: String = "res://idles/generator_unlock_goals.json"
@onready var _summary_label: Label = $MarginContainer/VBoxContainer/SummaryLabel
@onready var _goals_list: VBoxContainer = $MarginContainer/VBoxContainer/ScrollContainer/GoalsList
var _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:
_goals.clear()
if not FileAccess.file_exists(GOALS_FILE_PATH):
push_warning("Goals debug UI: goals file not found at %s" % GOALS_FILE_PATH)
return
var file: FileAccess = FileAccess.open(GOALS_FILE_PATH, FileAccess.READ)
if file == null:
push_warning("Goals debug UI: could not open goals file at %s" % GOALS_FILE_PATH)
return
var parsed: Variant = JSON.parse_string(file.get_as_text())
if not (parsed is Dictionary):
push_warning("Goals debug UI: goals root must be a Dictionary")
return
var goals_raw: Variant = parsed.get("goals", [])
if not (goals_raw is Array):
push_warning("Goals debug UI: goals must be an Array")
return
var seen_goal_ids: Dictionary = {}
for raw_goal in goals_raw:
var goal: GoalDefinition = _parse_goal(raw_goal)
if goal == null:
continue
var goal_key: String = String(goal.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
_goals.append(goal)
func _parse_goal(raw_goal: Variant) -> GoalDefinition:
if not (raw_goal is Dictionary):
return null
var goal_dict: Dictionary = raw_goal
var goal_id: String = String(goal_dict.get("id", "")).strip_edges()
var target_id: String = String(goal_dict.get("target_generator_id", "")).strip_edges()
if goal_id.is_empty() or target_id.is_empty():
return null
var raw_requirements: Variant = goal_dict.get("requirements", [])
if not (raw_requirements is Array):
return null
var requirements: Array[GoalRequirement] = []
for raw_requirement in raw_requirements:
var requirement: GoalRequirement = _parse_requirement(raw_requirement)
if requirement != null:
requirements.append(requirement)
if requirements.is_empty():
return null
return GoalDefinition.new(StringName(goal_id), StringName(target_id), requirements)
func _parse_requirement(raw_requirement: Variant) -> GoalRequirement:
if not (raw_requirement is Dictionary):
return null
var requirement_dict: Dictionary = raw_requirement
var currency_id: StringName = _parse_currency(requirement_dict.get("currency", ""))
if currency_id == &"" or not GameState.is_known_currency_id(currency_id):
return null
var raw_amount: Variant = requirement_dict.get("amount", {})
if not (raw_amount is Dictionary):
return null
var amount: BigNumber = BigNumber.deserialize(raw_amount)
if amount.mantissa < 0.0:
return null
return GoalRequirement.new(currency_id, amount)
func _parse_currency(raw_currency: Variant) -> StringName:
return GameState.parse_currency_id(raw_currency)
func _build_goal_rows() -> void:
_rows_by_goal_id.clear()
for child in _goals_list.get_children():
child.queue_free()
for goal in _goals:
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.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.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.id)] = GoalRow.new(goal, status_label, requirements_label, unlock_button)
func _refresh_ui() -> void:
if _goals.is_empty():
_summary_label.text = "No valid goals loaded"
return
var ready_to_unlock: int = 0
var unlocked: int = 0
for goal in _goals:
var row: GoalRow = _rows_by_goal_id.get(String(goal.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" % [_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:
for requirement in goal.requirements:
var total_amount: BigNumber = GameState.get_total_currency_acquired_by_id(requirement.currency_id)
if total_amount.is_less_than(requirement.amount):
return false
return true
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.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:
var parts: Array[String] = []
for requirement in goal.requirements:
var total_amount: BigNumber = GameState.get_total_currency_acquired_by_id(requirement.currency_id)
parts.append(
"%s %s / %s" % [
_currency_label(requirement.currency_id),
total_amount.to_string_suffix(2),
requirement.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 Normal file
View File

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

40
core/generator-unlock-goals/goals_debug_ui.tscn Normal file
View File

@@ -0,0 +1,40 @@
[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"]
[node name="GoalsDebugUI" type="PanelContainer" unique_id=1494700185]
offset_right = 640.0
offset_bottom = 260.0
script = ExtResource("1_s7s8v")
[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