developpement d'écran de chargement et d'écran de sélection de niveau

* modification de certains assets
* optimisation de chunks
* ajout d'un SceneManager
* ajout d'un premier dialogue avec Demeter
* changement des jour en charge
* mise en place d'un système de run
* etc...

common/game_data/scripts/game_data.gd

@@ -10,10 +10,10 @@ func _init():
 
 @export var settings : SettingsData = SettingsData.new()
 
-@export var current_planet_data : PlanetData = PlanetData.new() :
-	set(v):
-		current_planet_data = v
-		current_planet_data_updated.emit(v)
+@export var current_run : RunData = RunData.new()
+
+@export var current_planet_data : PlanetData : get = get_current_planet_data
+		
 @export var player_data : PlayerData = PlayerData.new()
 
 @export var unlocked_plant_types : Array[PlantType] = []
@@ -22,12 +22,19 @@ func _init():
 
 @export var truck_data : TruckData = TruckData.new()
 
+func _ready():
+	current_run.run_point_changed.connect(
+		func(): current_planet_data_updated.emit(get_current_planet_data)
+	)
+
 func set_default_unlocked():
+	unlocked_plant_types = all_plant_types()
 	unlocked_plant_mutations = all_plant_mutations()
 	unlocked_machines = all_machines()
 
-func reset_planet():
-	current_planet_data = PlanetData.new()
+func reset_run():
+	current_run = RunData.new()
+	current_planet_data_updated.emit()
 
 func reset_player():
 	player_data = PlayerData.new()
@@ -36,7 +43,7 @@ func reset_truck():
 	truck_data = TruckData.new()
 
 func reset_all():
-	reset_planet()
+	reset_run()
 	reset_player()
 	reset_truck()
 
@@ -55,6 +62,9 @@ func get_locked_plant_types() -> Array[PlantType]:
 
 	return locked_plant_type
 
+func get_current_planet_data():
+	return current_run.get_current_planet_data()
+
 func is_plant_type_unlocked(new_plant_type : PlantType):
 	return unlocked_plant_types.find_custom(
 			func (upt : PlantType): return new_plant_type.name == upt.name

common/game_data/scripts/run/run_data.gd

@@ -0,0 +1,108 @@
+extends Resource
+class_name RunData
+
+const RUN_POINT_POSITION_DERIVATION = 70
+const DIFFICULTY_INCREASE_BY_LEVEL = 1
+const RUN_POINTS_NEXT_NUMBER :Array[int] = [2,3]
+const RUN_POINT_MAX_LEVEL = 10
+
+signal run_point_changed
+
+var run_seed = randi()
+@export var next_run_points : Array[RunPoint] = [generate_first_run_point()]
+@export var current_run_point : RunPoint = null
+@export var visited_run_points : Array[RunPoint] = []
+
+#region ------------------ Generation ------------------
+
+func generate_first_run_point() -> RunPoint:
+    return RunPoint.new(0, PlanetParameter.new())
+
+func generate_next_run_points(run_point : RunPoint) -> Array[RunPoint]:
+    var nb_next_run_points = RUN_POINTS_NEXT_NUMBER.pick_random()
+    if run_point.level == RUN_POINT_MAX_LEVEL - 1 or run_point.level == -1:
+        nb_next_run_points = 1
+    elif run_point.level == RUN_POINT_MAX_LEVEL:
+        nb_next_run_points = 0
+    
+    next_run_points = []
+
+    for i in range(nb_next_run_points):
+        next_run_points.append(
+            generate_next_run_point(run_point)
+        )
+    
+    return next_run_points
+        
+
+func generate_next_run_point(run_point : RunPoint) -> RunPoint:
+    return RunPoint.new(
+        run_point.level + 1,
+        generate_difficulty_increased_planet_parameter(run_point.planet_parameter, DIFFICULTY_INCREASE_BY_LEVEL),
+        (run_point.position + randi_range(-RUN_POINT_POSITION_DERIVATION, RUN_POINT_POSITION_DERIVATION)) % 360
+    )
+
+func generate_difficulty_increased_planet_parameter(
+    planet_parameter : PlanetParameter,
+    difficulty : int = 1
+) -> PlanetParameter:
+    var i_diff := difficulty
+    var new_planet_parameter = PlanetParameter.new(
+        planet_parameter.charges,
+        planet_parameter.objective
+    )
+    while i_diff > 0:
+
+        var available_difficulty_modifier = [
+            DifficultyDecreaseCharge.new(),
+            DifficultyIncreaseObjective.new()
+        ].filter(
+            func (mod : DifficultyModifier):
+                return mod.get_difficulty_cost() <= i_diff and mod.can_modifiy(new_planet_parameter)
+        )
+
+        var selected_difficulty_modifier = available_difficulty_modifier.pick_random()
+        
+        selected_difficulty_modifier.modify(new_planet_parameter)
+
+        i_diff -= max(1,selected_difficulty_modifier.get_difficulty_cost())
+    return new_planet_parameter
+
+#endregion
+
+func get_next_run_points() -> Array[RunPoint]:
+    return next_run_points
+
+func get_current_planet_data() -> PlanetData:
+    if current_run_point:
+        return current_run_point.planet_data
+    else:
+        return null
+
+func choose_next_run_point(run_point : RunPoint) -> RunPoint:
+    if current_run_point:
+        visited_run_points.append(current_run_point)
+    current_run_point = run_point
+    next_run_points = generate_next_run_points(current_run_point)
+    return current_run_point
+
+class DifficultyModifier:
+    func modify(_planet_parameter : PlanetParameter):
+        pass
+    
+    func can_modifiy(_planet_parameter : PlanetParameter) -> bool:
+        return true
+
+    func get_difficulty_cost() -> int:
+        return 1
+
+class DifficultyIncreaseObjective extends DifficultyModifier:
+    func modify(planet_parameter : PlanetParameter):
+        planet_parameter.objective += 1
+
+class DifficultyDecreaseCharge extends DifficultyModifier:
+    func modify(planet_parameter : PlanetParameter):
+        planet_parameter.charges -= 1
+
+    func can_modifiy(planet_parameter : PlanetParameter) -> bool:
+        return planet_parameter.charges >= 3

common/game_data/scripts/run/run_data.gd.uid

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

common/game_data/scripts/run/run_point.gd

@@ -0,0 +1,60 @@
+@tool
+extends Resource
+class_name RunPoint
+
+const DANGER_ICON = preload("res://common/icons/skull.svg")
+const TYPE_ICON = preload("res://common/icons/map-pin.svg")
+const OBJECTIVE_ICON = preload("res://common/icons/dna.svg")
+const CHARGE_ICON = preload("res://common/icons/bolt.svg")
+
+@export var level : int = 0 # X pos along the planet, and difficulty
+@export var planet_parameter : PlanetParameter = PlanetParameter.new() :
+    set(v):
+        planet_parameter = v
+        planet_data = PlanetData.new(planet_parameter)
+@export var region_name : String = generate_region_name()
+@export var position : int = 0 # Y pos along the planet, 0 to 360
+var planet_data : PlanetData
+
+func _init(
+    _level : int = 0,
+    _planet_parameter : PlanetParameter = PlanetParameter.new(),
+    _position : int = randi_range(0,360),
+    _region_name : String = generate_region_name()
+):
+    level = _level
+    planet_parameter = _planet_parameter
+    position = _position
+    region_name = _region_name
+    planet_data = PlanetData.new(planet_parameter)
+
+func card_info() -> CardInfo:
+    var info = CardInfo.new(region_name)
+    info.important_stat_icon = DANGER_ICON
+    info.important_stat_text = "%d" % level
+
+    info.type_icon = TYPE_ICON
+
+    info.stats.append_array([
+        CardStatInfo.new(tr("%d_GARDEN_POINTS") % planet_parameter.objective, OBJECTIVE_ICON),
+        CardStatInfo.new(tr("%d_CHARGES_AVAILABLE") % planet_parameter.charges, CHARGE_ICON),
+    ])
+
+    return info
+
+func generate_region_name() -> String:
+    var vowel = ["a","e","i","o","u","y"]
+    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "z", "'"]
+    
+    var word_len = randf_range(4,8)
+    var word = ''
+    var last_letter_is_vowel = false
+
+    for i in range(word_len):
+        if last_letter_is_vowel:
+            word += consonants.pick_random()
+        else:
+            word += vowel.pick_random()
+        
+        last_letter_is_vowel = not last_letter_is_vowel
+    return word.capitalize()

common/game_data/scripts/run/run_point.gd.uid

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