ajouts d'objectifs sur la carte, déplacements des icônes et divers changements

stages/terrain/planet/scripts/planet.gd

@@ -8,14 +8,19 @@ signal pass_day_proceeded(planet : Planet)
 signal pass_day_ended(planet : Planet)
 
 const PASS_DAY_ANIMATION_TIME : float = 1.5
-const DAY_LIMIT : int = 10
+const DEFAULT_DAY_LIMIT : int = 10
 const PLANET_TEXTURE_SCALE : float = 5.0
+const OBJECTIVE_MAX_LEVEL : int = 10
+const OBJECTIVE_MIN_ANGLE_DIFF = PI/2
 
 @export_group("Loot")
 @export var first_loot_number : int = 3
 @export var loot_number : Array[int] = [0,1,2]
 @export var loot_item_number : Array[int] = [1,2]
-@export var loot_items : Array[Item] = []
+
+@export_group("Objectives")
+@export var objective_first_distance : int = 200
+@export var objective_between_distance : int = 200
 
 @export_group("Textures")
 @export var background_texture : Texture2D
@@ -23,20 +28,43 @@ const PLANET_TEXTURE_SCALE : float = 5.0
 
 @onready var background_sprite : Polygon2D = generate_background_sprite()
 @onready var contamination_sprite : Polygon2D = generate_contamination_terrain_sprite()
-@onready var decontamination_coverage : float = terrainData.get_decontamination_coverage() :
+@onready var decontamination_surface : float = terrain_data.get_decontamination_surface() :
 	set(v):
-		decontamination_coverage = v
+		print(v)
+		decontamination_surface = v
 		planet_updated.emit(self)
+@onready var objective_scene : PackedScene = preload("res://entities/objectives/objective.tscn")
 
 var contamination_texture : ImageTexture
 var day : int = 1 :
 	set(v):
 		day = v
 		planet_updated.emit(self)
+var day_limit = DEFAULT_DAY_LIMIT :
+	set(v):
+		day_limit = v
+		planet_updated.emit(self)
+var player : Player
 
 func _ready():
 	planet_updated.emit(self)
 	generate_loot(first_loot_number)
+	generate_objectives()
+
+	# queue_redraw()
+
+# func _draw():
+# 	var factor = 10
+# 	for x in range(terrain_data.terrain_size.x / factor):
+# 		for y in range(terrain_data.terrain_size.y / factor):
+# 			var point = Vector2(x, y) * factor
+
+# 			draw_circle(
+# 				point,
+# 				factor/10,
+# 				Color.BLUE if is_there_contamination(point) else Color.RED,
+# 				true
+# 			)
 
 #region ------------------ Generation ------------------
 
@@ -53,12 +81,15 @@ func add_entity(e : Node2D, container : Node2D = entityContainer):
 
 	if "planet" in e:
 		e.planet = self
+	
+	if e is Player:
+		player = e
 
 	container.add_child(e)
 
 func generate_polygon_sprite(order : int = 0) -> Polygon2D:
 	var sprite = Polygon2D.new()
-	var size = terrainData.terrainSize
+	var size = terrain_data.terrain_size
 	sprite.polygon = PackedVector2Array([
 		Vector2(0,0),
 		Vector2(size.x, 0),
@@ -82,15 +113,15 @@ func generate_background_sprite() -> Polygon2D:
 	return sprite
 
 func generate_contamination_terrain_sprite() -> Polygon2D:
-	if not terrainData.contamination:
-		terrainData.generate_default_contamination()
+	if not terrain_data.contamination:
+		terrain_data.generate_default_contamination()
 	
 	var sprite :Polygon2D = generate_polygon_sprite(1)
 
-	contamination_texture = ImageTexture.create_from_image(terrainData.contamination)
+	contamination_texture = ImageTexture.create_from_image(terrain_data.contamination)
 
 	contamination_material.set_shader_parameter("data_texture", contamination_texture)
-	contamination_material.set_shader_parameter("data_texture_size", terrainData.terrainSize)
+	contamination_material.set_shader_parameter("data_texture_size", terrain_data.terrain_size)
 	contamination_material.set_shader_parameter("texture_scale", PLANET_TEXTURE_SCALE)
 
 	sprite.material = contamination_material
@@ -117,15 +148,15 @@ func plant(
 	return true
 
 func impact_contamination(impact_position : Vector2, impact_radius : int, contamination : bool = false):
-	terrainData.impact_contamination(impact_position, impact_radius, 0. if contamination else 1.)
+	terrain_data.impact_contamination(impact_position, impact_radius, 0. if contamination else 1.)
 	if contamination_texture:
-		contamination_texture.update(terrainData.contamination)
+		contamination_texture.update(terrain_data.contamination)
 
 func is_in_zone(point : Vector2) -> bool:
-	return terrainData.is_in_image(terrainData.get_pixel_point(point), terrainData.contamination)
+	return terrain_data.is_in_image(terrain_data.get_pixel_point(point), terrain_data.contamination)
 
 func is_there_contamination(point : Vector2) -> bool:
-	return terrainData.get_contamination(point) < 0.5
+	return terrain_data.get_contamination(point) < 0.5
 
 func pass_day():
 	for e : Node2D in entityContainer.get_children():
@@ -147,23 +178,50 @@ func pass_day():
 		if e.has_method("_end_pass_day"):
 			e._end_pass_day()
 
-	decontamination_coverage = terrainData.get_decontamination_coverage()
-	if day + 1 > DAY_LIMIT:
+	decontamination_surface = terrain_data.get_decontamination_surface()
+	if day + 1 > day_limit:
 		day_limit_exceed.emit(self)
 
 func generate_loot(number : int = loot_number.pick_random()):
 	for i in range(number):
 		var loot = UndergroundLoot.new(self)
 		for j in range(loot_item_number.pick_random()):
-			loot.loot.append(loot_items.pick_random())
+			loot.loot.append(
+				Seed.new(GameInfo.game_data.unlocked_plant_types_path.pick_random())
+			)
 		
 		add_entity(loot)
 
 		var loot_random_range = UndergroundLoot.LOOTED_ITEM_RANDOM_RANGE
 
 		loot.global_position = Vector2(
-			randf_range(loot_random_range, terrainData.terrainSize.x - loot_random_range),
-			randf_range(loot_random_range, terrainData.terrainSize.y - loot_random_range)
+			randf_range(loot_random_range, terrain_data.terrain_size.x - loot_random_range),
+			randf_range(loot_random_range, terrain_data.terrain_size.y - loot_random_range)
 		)
 
+func generate_objectives():
+	var last_objective_angle = 10
+	for i in range(OBJECTIVE_MAX_LEVEL):
+		var objective_rewards : Array[ObjectiveReward] = terrain_data.generate_objective_rewards(i, 2)
+
+		for objective_reward in objective_rewards:
+			var objective_angle = randf_range(0, PI*2)
+			while abs(objective_angle - last_objective_angle)  < OBJECTIVE_MIN_ANGLE_DIFF:
+				objective_angle = randf_range(0, PI*2)
+
+			last_objective_angle = objective_angle
+
+			generate_objective(
+				objective_first_distance + objective_between_distance * i,
+				objective_angle,
+				objective_reward,
+			)
+
+func generate_objective(distance : int, angle : float, reward : ObjectiveReward):
+	var objective : Objective = objective_scene.instantiate() as Objective
+	add_entity(objective)
+	objective.reward = reward
+
+	objective.position = Vector2.ONE.rotated(angle) * distance
+
 #endregion