Skip to main content
Nyuron incorporates progression mechanics that motivate repeated play while adapting challenge levels to player skill. The system balances immediate rewards with long-term advancement.

​
Progression Philosophy

The progression system transforms Nyuron from isolated minigames into a cohesive ecosystem:
  • Per-minigame scores with tracked maximums
  • Coin rewards earned through gameplay
  • Difficulty progression that scales with player skill
  • Persistent progress saved across sessions
Playing any minigame contributes to overall progress—it’s not just “playing for fun,” but building toward tangible rewards.

​
Difficulty Scaling

Difficulty increases dynamically based on player performance, keeping gameplay challenging without becoming frustrating.

​
Round-Based Progression

Counting Animals uses discrete difficulty levels unlocked after completing multiple rounds: 
# counting_animals/scripts/main.gd:32
var difficulty_level := 1
var correct_streak := 0
var rounds_completed := 0
1

Level 1: Foundation

Players count 1 type of animal. Complete 3 rounds to advance.
2

Level 2: Intermediate

Count 2 different animal types simultaneously. Complete 5 rounds to advance.
3

Level 3: Advanced

Count 3 different animal types. Maximum difficulty—game continues until failure.

​
Speed Multipliers

Food Catch increases game speed over time to continuously challenge players: 
# food_catch/main.gd:33
@export var difficulty_interval: float = 30.0
@export var speed_multiplier: float = 1.2
@export var spawn_multiplier: float = 0.85
var difficulty_stage: int = 0
How it works:
  • Every 30 seconds, difficulty_stage increments
  • Falling items move 1.2× faster (compounding: 1.2, 1.44, 1.73…)
  • Spawn rate increases by 15% (wait time × 0.85)
Compounding multipliers can create exponential difficulty curves. Test extensively to ensure the game remains playable at higher stages.

​
Spawn Rate Adjustments

Many minigames control difficulty by modifying object spawn rates:
food_catch/main.gd:96
$SpawnTimer.wait_time = spawn_every  # Initially 0.8 seconds
$SpawnTimer.timeout.connect(_on_spawn_timer_timeout)
$SpawnTimer.start()
As difficulty increases, the spawn timer’s wait_time decreases, creating more obstacles and requiring faster reactions.

​
Scoring Systems

​
Difficulty-Weighted Scoring

Counting Animals awards more points for higher difficulty levels:
counting_animals/scripts/main.gd:309
func add_score():
    var points := 0
    match difficulty_level:
        1: points = 10 + ((rounds_completed - 1) * 5)
        2: points = 40 + ((rounds_completed - 1) * 20)
        3: points = 150 + ((rounds_completed - 1) * 30)
    
    score += points
    score_label.text = "Puntaje: %d" % score
Scoring breakdown:
  • Base: 10 points
  • Increment: +5 per subsequent round
  • Example: Round 1 = 10, Round 2 = 15, Round 3 = 20
This exponential scoring structure rewards players who reach and sustain higher difficulty levels, encouraging skill development.

​
Action-Based Scoring

Food Catch awards points per collected item:
food_catch/main.gd:174
else:  # Collected food
    score += 10
    _play_varied(sfx_eat, 1.0, 1.15)
    _hud_pop_flash()
    _spawn_floating_text("+10", Color(1, 1, 0.5))
Bonus items provide larger point gains:
food_catch/main.gd:184
func _on_bonus_resolved(points: int) -> void:
    score += points
    _play_varied(sfx_bonus, 1.05, 1.2)
    _spawn_floating_text("+%d" % points, Color(0.414, 0.993, 1.0, 1.0))

​
Coin Rewards

Coins are earned at game over based on final score, creating incentive for high-score attempts.

​
Conversion Rates

Different minigames use different score-to-coin multipliers: 
# counting_animals/scripts/main.gd:377
var coins_earned = int(final_score * 2.0)
if coins_earned > 0 and score_manager:
    score_manager.add_coins(coins_earned)
    print("Ganaste: ", coins_earned, " monedas")
Multiplier comparison:
MinigameMultiplierScore 100 =Score 500 =
Counting Animals2.0×200 coins1,000 coins
Food Catch0.1×10 coins50 coins
Multipliers should be balanced based on typical score ranges. A game with lower average scores needs a higher multiplier to provide comparable coin rewards.

​
Coin Management

Coins are added through the ScoreManager autoload:
ScoreManager.gd.gd:31
func add_coins(amount: int):
    coins += amount
    save_to_file()
    print("Monedas actuales:", coins)
Coins persist across sessions and can be spent in the shop system (inventory/equipment).

​
High Score Tracking

​
Saving High Scores

High scores are saved when they exceed the previous record: 
# counting_animals/scripts/main.gd:373
var final_score = int(score)
if final_score > 0:
    var score_manager = get_node("/root/ScoreManager")
    if score_manager:
        score_manager.save_high_score("counting_animals", final_score)
Key behaviors:
  • Only scores greater than the current high score are saved (ties don’t update)
  • Returns true if a new record was set
  • Automatically persists to disk via save_to_file()

​
Retrieving High Scores

Get the current high score for any registered minigame:
ScoreManager.gd.gd:79
func get_high_score(game_name: String) -> int:
    return high_scores.get(game_name, 0)
Retrieve all high scores at once:
ScoreManager.gd.gd:123
func get_all_scores() -> Dictionary:
    return high_scores.duplicate()

​
Persistent Storage

​
Save File Structure

All progression data is stored in user://high_scores.cfg using Godot’s ConfigFile format: 
[high_scores]
memorize=250
turtle_runner=1200
worm_catch=800
food_catch=450
counting_animals=500
nyuron_color=300

[player_data]
coins=1500
equipped_items={"caparazon": "default", "accesorio": "none"}

[inventory]
items=["item_hat_1", "item_shell_2"]

​
Load on Startup

ScoreManager loads saved data automatically:
ScoreManager.gd.gd:82
func load_high_scores():
    var config = ConfigFile.new()
    var error = config.load(SAVE_PATH)
    
    if error != OK:
        print("Creando archivo de progreso...")
        save_to_file()
        return
    
    for game in high_scores.keys():
        high_scores[game] = config.get_value("high_scores", game, 0)
    
    coins = config.get_value("player_data", "coins", 0)
    inventory = config.get_value("inventory", "items", [])
    equipped_items = config.get_value("player_data", "equipped_items", equipped_items)
If no save file exists, load_high_scores() creates a new one with default values (all scores = 0, no coins, empty inventory).

​
Progression Flow

Putting it all together, here’s how progression works in a typical play session:
1

Start Game

Player selects a minigame from the main menu. ScoreManager has already loaded saved progress.
2

Play and Score

Player completes rounds/actions, earning points according to the minigame’s scoring system. Difficulty scales dynamically.
3

Game Over

When the game ends, final score is calculated and sent to ScoreManager.
4

Check High Score

ScoreManager compares final score to saved high score. If higher, it updates and saves to disk.
5

Award Coins

Coins are calculated (score × multiplier) and added to the player’s total.
6

Display Results

Game Over panel shows final score, coins earned, and provides retry/back options.
7

Return to Menu

Player returns to main menu. All progress (high scores, coins, inventory) is saved and ready for next session.

​
Balancing Considerations

Test that difficulty increases feel fair. Exponential multipliers can quickly become impossible—consider caps or diminishing returns.
Ensure score-to-coin multipliers produce meaningful rewards. Players should feel progression without earning coins too easily or too slowly.
Since only better scores are saved, players have reason to replay for records. Consider leaderboards or achievements for additional motivation.
Balance whether difficulty scales with time played (speed multipliers) or performance (round progression). Mix both for variety.

​
Future Expansion

The current progression system provides foundation for additional features:
  • Shop/Items: Coins can purchase cosmetics or power-ups (inventory system already in ScoreManager)
  • Character customization: Equipment system (equipped_items) supports visual customization
  • Achievements: Track specific accomplishments beyond high scores
  • Daily challenges: Time-limited goals with bonus rewards
  • Leaderboards: Compare high scores with other players
The modular architecture makes adding these features straightforward—they can integrate with existing ScoreManager methods without modifying minigame code.

Build docs developers (and LLMs) love

Get started for freeTalk to us