Fix bug from MvM Jam

addons/godot_projectile_engine/GodotProjectileEngine.gd

@@ -123,7 +123,7 @@ var projectile_wrapper_2d_nodes : Dictionary[String, Array]
 var projectile_composer_nodes : Dictionary[String, PatternComposer2D]
 
 var projectile_updater_2d_nodes : Dictionary[RID, ProjectileUpdater2D]
-var projectile_node_manager_2d_nodes : Dictionary[StringName, ProjectileNodeManager2D]
+var projectile_node_manager_2d_nodes : Dictionary[ProjectileTemplate2D, ProjectileNodeManager2D]
 
 
 var _projectile_count_temp : int
@@ -374,10 +374,35 @@ func get_valid_target_group_nodes(_group_name: String) -> Array[Node2D]:
 	return _valid_nodes
 
 
-#endregion 
-
+func get_collider_collision_layer(_collider: Node) -> int:
+	if !_collider: return 0
+	if _collider is CollisionObject2D:
+		return _collider.collision_layer
+	elif _collider is TileMapLayer:
+		if !_collider.tile_set:
+			return 0
+		var _tile_set : TileSet = _collider.tile_set
+		if _tile_set.get_physics_layers_count() <= 0 :
+			return 0
+		for i in range(_tile_set.get_physics_layers_count()):
+			return _tile_set.get_physics_layer_collision_layer(i)
+	return 0
+
+func get_collider_collision_mask(_collider: Node) -> int:
+	if _collider is CollisionObject2D:
+		return _collider.collision_mask
+	elif _collider is TileMapLayer:
+		if !_collider.tile_set:
+			return 0
+		var _tile_set : TileSet = _collider.tile_set
+		if _tile_set.get_physics_layers_count() <= 0 :
+			return 0
+		for i in range(_tile_set.get_physics_layers_count()):
+			return _tile_set.get_physics_layer_collision_mask(i)
+	return 0
 
 
+#endregion 
 
 
 #endregion

addons/godot_projectile_engine/core/pattern_composer/component/PCCSingle2D.gd

@@ -67,7 +67,7 @@ func process_pattern(
 	_pattern_composer_context: PatternComposerContext
 	) -> Array:
 
-	_new_pattern_composer_pack.clear()
+	_new_pattern_composer_pack = []
 	for _pattern_composer_data: PatternComposerData in _pattern_composer_pack:
 		_new_pattern_composer_data = _pattern_composer_data.duplicate()
 		_final_rotation = _pattern_composer_data.direction_rotation
@@ -106,7 +106,7 @@ func process_pattern(
 				continue
 
 			DirectionType.MOUSE:
-				_pattern_composer_data.direction = _pattern_composer_data.position.direction_to(get_mouse_position())
+				_new_pattern_composer_data.direction = _new_pattern_composer_data.position.direction_to(get_mouse_position())
 				_new_pattern_composer_pack.append(_new_pattern_composer_data)
 				continue
 

addons/godot_projectile_engine/core/pattern_composer/component/PCCSpread2D.gd

@@ -35,7 +35,7 @@ func process_pattern(
 	if spread_angle_random != Vector3.ZERO:
 		spread_angle = ProjectileEngine.get_random_float_value(spread_angle_random)
 
-	_new_pattern_composer_pack.clear()
+	_new_pattern_composer_pack = []
 	match spread_type:
 		SpreadType.STRAIGHT:
 			for _pattern_composer_data: PatternComposerData in _pattern_composer_pack:
@@ -58,41 +58,35 @@ var _point_position: Vector2
 var _point_direction: Vector2
 
 func _add_projectile_straight_spread(_pattern_composer_data: PatternComposerData) -> Array[PatternComposerData]:
-	_new_sub_pattern_composer_data.clear()
+	_new_sub_pattern_composer_data = []
 	_half_total_width = (spread_amount - 1) * spread_distance / 2.0
 	for i in range(spread_amount):
 		_new_pattern_composer_data = _pattern_composer_data.duplicate()
 		_offset_distance = (i * spread_distance) - _half_total_width
-		_new_pattern_composer_data.position += (
-			_pattern_composer_data.direction.rotated(deg_to_rad(90) + _pattern_composer_data.direction_rotation)
-			* _offset_distance
-			)
+		_new_pattern_composer_data.position += (_new_pattern_composer_data.direction * _offset_distance)
 		_new_sub_pattern_composer_data.append(_new_pattern_composer_data)
 	return _new_sub_pattern_composer_data
 
 func _add_projectile_angle_spread(_pattern_composer_data: PatternComposerData) -> Array[PatternComposerData]:
-	_new_sub_pattern_composer_data.clear()
+	_new_sub_pattern_composer_data = []
 	_half_total_deg = (spread_amount - 1) * spread_angle / 2.0
 	for i in range(spread_amount):
 		_new_pattern_composer_data = _pattern_composer_data.duplicate()
 		_offset_angle = (i * spread_angle) - _half_total_deg
-		_new_pattern_composer_data.direction_rotation += _pattern_composer_data.direction.angle() - deg_to_rad(_offset_angle)
+		_new_pattern_composer_data.direction = _pattern_composer_data.direction.rotated(deg_to_rad(_offset_angle)).normalized()
 		_new_sub_pattern_composer_data.append(_new_pattern_composer_data)
 	return _new_sub_pattern_composer_data
 
 func _add_projectile_hybrid_spread(_pattern_composer_data: PatternComposerData) -> Array[PatternComposerData]:
-	_new_sub_pattern_composer_data.clear()
+	_new_sub_pattern_composer_data = []
 	_half_total_width = (spread_amount - 1) * spread_distance / 2.0
 	_half_total_deg = (spread_amount - 1) * spread_angle / 2.0
 	for i in range(spread_amount):
 		_new_pattern_composer_data = _pattern_composer_data.duplicate()
 		_offset_distance = (i * spread_distance) - _half_total_width
 		_offset_angle = (i * spread_angle) - _half_total_deg
-		_new_pattern_composer_data.position += (
-			_pattern_composer_data.direction.rotated(deg_to_rad(90) + _pattern_composer_data.direction_rotation)
-			* _offset_distance
-			)
-		_new_pattern_composer_data.direction_rotation += _pattern_composer_data.direction.angle() - deg_to_rad(_offset_angle)
+		_new_pattern_composer_data.direction = _pattern_composer_data.direction.rotated(deg_to_rad(_offset_angle)).normalized()
+		_new_pattern_composer_data.position += (_new_pattern_composer_data.direction * _offset_distance)
 		_new_sub_pattern_composer_data.append(_new_pattern_composer_data)
 	return _new_sub_pattern_composer_data
 

addons/godot_projectile_engine/core/pattern_composer/pattern_composer.gd

@@ -51,9 +51,6 @@ func _physics_process(delta: float) -> void:
 ## Take a request pattern to process thorugh Pattern Composer Component to
 ## return a new Array[PatternComposerData]
 func request_pattern(_pattern_composer_context : PatternComposerContext) -> Array:
-	## Init pattern composer pack
-	# _init_pattern_composer_data = PatternComposerData.new()
-	## Check if can using ProjectileSpawnMarker2Ds
 	_use_projectile_spawn_marker = false
 	if _pattern_composer_context.use_spawn_markers and _pattern_composer_context.projectile_spawn_markers.size() > 0:
 		for _projectile_spawn_marker in _pattern_composer_context.projectile_spawn_markers:
@@ -77,13 +74,15 @@ func request_pattern(_pattern_composer_context : PatternComposerContext) -> Arra
 					continue
 				_new_composer_data = PatternComposerData.new()
 				_new_composer_data.projectile_spawn_marker = _projectile_spawn_marker
+				_new_composer_data.direction =  _projectile_spawn_marker.init_direction
 				if _projectile_spawn_marker.use_global_position:
 					_new_composer_data.position =  _projectile_spawn_marker.global_position
 				else:
 					_new_composer_data.position =  _projectile_spawn_marker.position
 				_pattern_composer_spawner.append(_new_composer_data)
 		else:
 			for _composer_data in _pattern_composer_spawner:
+				_composer_data.direction =  _composer_data.projectile_spawn_marker.init_direction
 				if _composer_data.projectile_spawn_marker.use_global_position:
 					_composer_data.position =  _composer_data.projectile_spawn_marker.global_position
 				else:

addons/godot_projectile_engine/core/projectile_spawner/projectile_spawner.gd

@@ -4,6 +4,7 @@ class_name ProjectileSpawner2D
 
 signal spawn_timed
 signal scheduler_completed
+signal projectile_spawned(_projectile_template: ProjectileTemplate2D)
 
 @export var active : bool = true:
 	set(value):
@@ -18,6 +19,8 @@ signal scheduler_completed
 @export var timing_scheduler : TimingScheduler
 @export var use_spawn_markers : bool = false
 @export var audio_stream: AudioStreamPlayer
+@export var audio_stream_2d: AudioStreamPlayer2D
+
 
 var projectile_area : RID
 
@@ -36,6 +39,7 @@ var _pattern_composer_pack : Array
 
 
 func _ready() -> void:
+	setup_spawn_marker()
 	if active:
 		activate_projectile_spawner()
 	pass
@@ -93,12 +97,12 @@ func setup_projectile_spawner() -> void:
 		ProjectileTemplateNode2D:
 			if !is_instance_valid(
 				ProjectileEngine.projectile_node_manager_2d_nodes.get(
-					projectile_template_2d.projectile_2d_path
+					projectile_template_2d
 					)
 			):
 				create_projectile_node_manager_2d()
 			projectile_node_manager_2d = ProjectileEngine.projectile_node_manager_2d_nodes.get(
-				projectile_template_2d.projectile_2d_path
+				projectile_template_2d
 				)
 		_:
 			return
@@ -119,26 +123,34 @@ func spawn_pattern() -> void:
 	pattern_composer_context.position = global_position
 	pattern_composer_context.projectile_template_2d = projectile_template_2d
 	if use_spawn_markers:
-		setup_spawn_marker()
 		pattern_composer_context.projectile_spawn_markers = projectile_spawn_markers
 	else:
 		pattern_composer_context.projectile_spawn_markers.clear()
 
 	if typeof(projectile_template_2d) != TYPE_OBJECT:
 		return
+	if !projectile_composer:
+		setup_projectile_spawner()
+	play_audio()
 	match projectile_template_2d.get_script():
 		ProjectileTemplateNode2D:
 			_pattern_composer_pack = projectile_composer.request_pattern(pattern_composer_context)
 			projectile_node_manager_2d.spawn_projectile_pattern(_pattern_composer_pack)
+			projectile_spawned.emit(projectile_template_2d)
 		ProjectileTemplateAdvanced2D:
 			_pattern_composer_pack = projectile_composer.request_pattern(pattern_composer_context)
 			projectile_updater_2d.spawn_projectile_pattern(_pattern_composer_pack)
+			projectile_spawned.emit(projectile_template_2d)
+
 		_:
 			_pattern_composer_pack = projectile_composer.request_pattern(pattern_composer_context)
 			projectile_updater_2d.spawn_projectile_pattern(_pattern_composer_pack)
+			projectile_spawned.emit(projectile_template_2d)
+
 		## built-in classes don't have a script
 		null:
 			return
+
 	pass
 
 
@@ -220,7 +232,7 @@ func create_projectile_node_manager_2d() -> void:
 	ProjectileEngine.projectile_environment.add_child(_projectile_node_manager, true)
 	_projectile_node_manager.owner = ProjectileEngine.projectile_environment
 	ProjectileEngine.projectile_node_manager_2d_nodes.get_or_add(
-		projectile_template_2d.projectile_2d_path, _projectile_node_manager
+		projectile_template_2d, _projectile_node_manager
 		)
 	_projectile_node_manager.setup_projectile_manager()
 	pass
@@ -254,36 +266,49 @@ func _spawn_projectile_template_node_2d() -> void:
 
 func connect_timing_scheduler() -> void:
 	if !timing_scheduler: return
+	timing_scheduler.active = true
 	if !timing_scheduler.scheduler_timed.is_connected(spawn_pattern):
 		timing_scheduler.scheduler_timed.connect(spawn_pattern)
-	timing_scheduler.start_scheduler()
 	pass
 
 
 func disconnect_timing_scheduler() -> void:
 	if !timing_scheduler: return
+	timing_scheduler.active = false
 	if timing_scheduler.scheduler_timed.is_connected(spawn_pattern):
 		timing_scheduler.scheduler_timed.disconnect(spawn_pattern)
-	timing_scheduler.stop_scheduler()
+	# timing_scheduler.stop_scheduler()
 	pass
 
 
 func play_audio() -> void:
-	if !audio_stream: return
-	audio_stream.playing = true
+	# audio_stream.playing = true
+	if audio_stream_2d:
+		print("play aduio")
+		audio_stream_2d.playing = true
 	pass
 
 
 func connect_audio() -> void:
-	if !audio_stream: return
-	if !timing_scheduler.scheduler_timed.is_connected(play_audio):
-		timing_scheduler.scheduler_timed.connect(play_audio)
+	# if audio_stream_2d:
+	# 	projectile_spawned.connect(play_audio)
+	# if !timing_scheduler.scheduler_timed.is_connected(play_audio):
+
+	# if !audio_stream: return
+	# if !timing_scheduler.scheduler_timed.is_connected(play_audio):
+	# 	timing_scheduler.scheduler_timed.connect(play_audio)
+	# if !audio_stream_2d: return
+	# if !timing_scheduler.scheduler_timed.is_connected(play_audio):
+	# 	timing_scheduler.scheduler_timed.connect(play_audio)
 	pass
 
 func disconnect_audio() -> void:
-	if !audio_stream: return
-	if timing_scheduler.scheduler_timed.is_connected(play_audio):
-		timing_scheduler.scheduler_timed.disconnect(play_audio)
+	# if !audio_stream: return
+	# if timing_scheduler.scheduler_timed.is_connected(play_audio):
+	# 	timing_scheduler.scheduler_timed.disconnect(play_audio)
+	# if !audio_stream_2d: return
+	# if !timing_scheduler.scheduler_timed.is_connected(play_audio):
+	# 	timing_scheduler.scheduler_timed.disconnect(play_audio)
 	pass
 
 

addons/godot_projectile_engine/core/projectile_template/base/projectile_behaviors/destroy/behaviors/projectile_destroy_collision.gd

@@ -88,7 +88,8 @@ func process_behavior(_value, _context: Dictionary) -> bool:
 		if destroy_on_body_collide:
 			if _behavior_owner.has_overlapping_bodies():
 				for _overlap_body in _behavior_owner.get_overlapping_bodies():
-					if not _overlap_body.collision_layer & _behavior_owner.collision_mask:
+					var _overlap_body_collision_layer : int = ProjectileEngine.get_collider_collision_layer(_overlap_body)
+					if not _overlap_body_collision_layer & _behavior_owner.collision_mask:
 						continue
 
 					if wait_projectile_piercing:
@@ -128,8 +129,16 @@ func process_behavior(_value, _context: Dictionary) -> bool:
 		var _projectile_updater : ProjectileUpdater2D = _behavior_owner.projectile_updater
 		if destroy_on_area_collide:
 			if _projectile_updater.has_overlapping_areas(_behavior_owner.area_index):
+				# print("ProjectileEngine ProjectileEngine: ", ProjectileEngine)
 				for _overlap_area in _projectile_updater.get_overlapping_areas(_behavior_owner.area_index):
-					if not _overlap_area.collision_layer & _projectile_updater.projectile_collision_mask:
+					if !_overlap_area:
+						_projectile_updater.get_overlapping_areas(_behavior_owner.area_index).erase(_overlap_area)
+						return true
+					# print("ProjectileEngine ProjectileEngine: ", ProjectileEngine)
+
+					var _overlap_area_collision_layer : int = ProjectileEngine.get_collider_collision_layer(_overlap_area)
+
+					if not _overlap_area_collision_layer & _projectile_updater.projectile_collision_mask:
 						continue
 
 					if wait_projectile_piercing:
@@ -168,7 +177,8 @@ func process_behavior(_value, _context: Dictionary) -> bool:
 		if destroy_on_body_collide:
 			if _projectile_updater.has_overlapping_bodies(_behavior_owner.area_index):
 				for _overlap_body in _projectile_updater.get_overlapping_bodies(_behavior_owner.area_index):
-					if not _overlap_body.collision_layer & _projectile_updater.projectile_collision_mask:
+					var _overlap_body_collision_layer : int = ProjectileEngine.get_collider_collision_layer(_overlap_body)
+					if not _overlap_body_collision_layer & _projectile_updater.projectile_collision_mask:
 						continue
 
 					if wait_projectile_piercing:

addons/godot_projectile_engine/core/projectile_template/base/projectile_behaviors/rotation/behaviors/projectile_rotation_follow_direction.gd

@@ -19,5 +19,4 @@ func process_behavior(_value: float, _context: Dictionary) -> Dictionary:
 	var _direction := _context.get(ProjectileEngine.BehaviorContext.DIRECTION)
 	var _direction_rotation := _context.get(ProjectileEngine.BehaviorContext.DIRECTION_ROTATION)
 	var _rotation_final : float = _direction.rotated(_direction_rotation).angle()
-
 	return {ProjectileEngine.RotationModify.ROTATION_OVERWRITE : _rotation_final}

addons/godot_projectile_engine/core/projectile_template/base/projectile_updater/projectile_updater_2d.gd

@@ -118,7 +118,6 @@ func _area_monitor_callback(status: int, area_rid : RID, instance_id: int, area_
 		return
 	match status:
 		PS.AREA_BODY_ADDED:
-
 			ProjectileEngine.projectile_instance_area_shape_entered.emit(
 				projectile_instance_array[self_shape_idx],
 				area_rid, _instance_node, area_shape_idx,
@@ -153,7 +152,7 @@ func _area_monitor_callback(status: int, area_rid : RID, instance_id: int, area_
 	pass
 
 func _body_monitor_callback(status: int, body_rid : RID, instance_id: int, body_shape_idx: int, self_shape_idx: int) -> void:
-	var _instance_node : PhysicsBody2D = instance_from_id(instance_id)
+	var _instance_node : Node = instance_from_id(instance_id)
 	if !is_instance_valid(_instance_node):
 		return
 	match status:
@@ -224,7 +223,6 @@ func draw_projectile_texture() -> void:
 	projectile_texture = projectile_template_2d.texture
 	projectile_texture_modulate = projectile_template_2d.texture_modulate
 	projectile_texture_draw_offset = Vector2.ZERO - projectile_template_2d.texture.get_size() * 0.5
-
 	for index : int in projectile_active_index:
 		draw_set_transform_matrix(projectile_instance_array[index].transform)
 		draw_texture(projectile_texture, projectile_texture_draw_offset, projectile_texture_modulate)
@@ -246,7 +244,8 @@ func get_active_projectile_count() -> int:
 ## Clear all ProjectileInstances in this ProjectileUpdater
 func clear_projectiles() -> void:
 	for _index in range(projectile_max_pooling):
-		projectile_active_index.erase(_index)
+		if projectile_active_index.has(_index):
+			projectile_active_index.erase(_index)
 		PS.area_set_shape_disabled(projectile_area_rid, _index, true)
 	projectile_active_index.clear()
 	pass