Nearl implemented: bullet rotation isn't working correctly.

Scratch

@@ -0,0 +1,83 @@
+@export_category("Stagger")
+@export var horizontal_offset: float = 6.5  # Horizontal distance between projectiles
+@export var stagger_offset: float = 5  # Time delay per projectile index
+@export var firing_angle: float = 0.0  # Angle in degrees (0 = straight up, positive = angled right)
+@export var num_groups: int = 1  # Number of symmetrical groups to fire (1 = single direction, 2 = left/right, 3 = left/center/right)
+
+
+---
+
+func shoot():
+    var weapon_data = weapon_component.data  # WeaponShot resource configuration
+    var current_time = Time.get_ticks_msec() / 1000.0
+    var total_projectiles = weapon_data.projectiles
+
+    if player.travel > weapon_data.spacing:
+
+        # Calculate center index for symmetrical staggering
+        var center_index = (total_projectiles - 1) / 2.0
+
+        if total_projectiles > 0:
+            for group in range(num_groups):
+                # Calculate projectile indices for this group
+                # For 1 group: 0..N-1
+                # For 2 groups: 0..N/2-1 and N/2..N-1
+                # For 3 groups: 0..N/3-1 and N/3..2N/3-1 and 2N/3..N-1
+                var group_start: int
+                var group_end: int
+                
+                if num_groups == 1:
+                    group_start = 0
+                    group_end = total_projectiles
+                elif num_groups == 2:
+                    group_start = 0
+                    group_end = total_projectiles / 2 if total_projectiles % 2 == 0 else (total_projectiles - 1) / 2
+                elif num_groups == 3:
+                    var third = total_projectiles / 3
+                    group_start = 0
+                    group_end = third if third > 0 else 1
+                else:
+                    continue  # Skip if num_groups > 3
+
+                for b in range(group_start, group_end):
+                    var bullet_scene = weapon_data.bullet_scene
+                    var bullet := bullet_scene.instantiate() as Node
+                    get_tree().root.add_child(bullet)
+
+                    # Calculate index relative to group center for staggering
+                    var group_center: float = (group_start + group_end - 1) / 2.0
+                    var index_from_center: float = b - group_center
+
+                    # Calculate timing offset for staggered firing
+                    var time_offset: float = abs(index_from_center) * stagger_offset
+
+                    # Calculate horizontal offset for this bullet (symmetrical within group)
+                    var bullet_horizontal_offset: float = index_from_center * weapon_data.horizontal_offset
+
+                    # Calculate vertical offset from center point (symmetrical vertical spread within group)
+                    var distance_from_center: float = abs(index_from_center)
+                    var vertical_offset: float = (distance_from_center * weapon_data.origin * -1) / 2
+
+                    # Calculate final position based on firing angle using polar coordinates
+                    var angle_rad: float = weapon_data.firing_angle * 0.0174533  # Convert degrees to radians
+                    var spread_angle: float = -firing_angle * 0.0174533  # Spread opposite to firing angle
+                    
+                    # Calculate position using polar coordinates from player origin
+                    var origin_x: float = weapon_data.origin * 0.5  # Distribute origin horizontally
+                    var origin_y: float = weapon_data.origin
+                    
+                    var pos_x: float = player.position.x + origin_x + bullet_horizontal_offset
+                    var pos_y: float = player.position.y + origin_y + vertical_offset
+                    
+                    # Apply angular offset
+                    var angle_offset_x: float = -weapon_data.origin * sin(spread_angle)
+                    var angle_offset_y: float = -weapon_data.origin * cos(spread_angle)
+                    
+                    bullet.position = Vector2(pos_x + angle_offset_x, pos_y + angle_offset_y)
+
+                    # Set timing properties on the bullet
+                    bullet.time_offset = time_offset
+                    bullet.fire_time = current_time + time_offset
+
+            # Subtract projectile spacing from current Player travel for next shot
+            player.travel -= weapon_data.spacing

resources/player_weapon_resources/weapon_shot_stock.tres

@@ -1,16 +1,17 @@
 [gd_resource type="Resource" script_class="WeaponShot" format=3 uid="uid://b75ae840k03dy"]
 
-[ext_resource type="PackedScene" uid="uid://ddpclu2vdy2ve" path="res://scenes/weapon_stock.tscn" id="1_by0nb"]
-[ext_resource type="Script" uid="uid://7n1itonn35fm" path="res://resources/player_weapons/weapon_shot.gd" id="2_by0nb"]
+[ext_resource type="PackedScene" uid="uid://ddpclu2vdy2ve" path="res://scenes/player_weapons/weapon_stock.tscn" id="1_by0nb"]
+[ext_resource type="Script" uid="uid://7n1itonn35fm" path="res://resources/weapon_shot.gd" id="2_by0nb"]
 
 [resource]
 script = ExtResource("2_by0nb")
 shot_name = "Stock Shot"
 bullet_scene = ExtResource("1_by0nb")
 speed = 500
-projectiles = 3
-spacing = 25.0
-origin = -12
-horizontal_offset = 8.0
-stagger_offset = 0.35
+projectiles = 5
+spacing = 20.0
+origin = -25
+horizontal_offset = 6.0
+stagger_offset = 5.5
+rotate_to_velocity = false
 metadata/_custom_type_script = "uid://7n1itonn35fm"

resources/player_weapons/weapon_shot.gd

@@ -1,17 +0,0 @@
-class_name WeaponShot
-extends Resource
-
-@export_category("Info")
-@export var shot_name: String
-@export var bullet_scene: PackedScene = null
-
-@export_category("Shot Data")
-@export var damage: int = 1
-@export var speed: int = 135
-@export var projectiles: int = 2
-@export var spacing: float = 35
-@export var origin: int = -23
-
-@export_category("Stagger")
-@export var horizontal_offset: float = 6.5  # Horizontal distance between projectiles
-@export var stagger_offset: float = 5  # Time delay per projectile index

resources/weapon_shot.gd

@@ -0,0 +1,20 @@
+class_name WeaponShot extends Resource
+
+@export_category("Info")
+@export var shot_name: String
+@export var bullet_scene: PackedScene = null
+
+@export_category("Shot Data")
+@export var damage: int = 1
+@export var speed: int = 135
+@export var projectiles: int = 2
+@export var spacing: float = 35
+@export var origin: int = -23
+
+@export_category("Stagger")
+@export var horizontal_offset: float = 6.5 # Horizontal distance between projectiles
+@export var stagger_offset: float = 5 # Time delay per projectile index
+
+# Angle in degrees, default is 0
+@export var angle: float = 0.0 # Angle at which the bullet should be fired
+@export var rotate_to_velocity: bool = true

scenes/player_weapons/weapon_stock.gd

@@ -0,0 +1,54 @@
+extends Area2D
+
+@onready var shot_data = load("res://resources/player_weapon_resources/weapon_shot_stock.tres")
+
+# Time offset when this bullet was fired (relative to other bullets in the same shot)
+var time_offset: float = 0.5
+
+# When this bullet should fire (absolute time)
+var fire_time: float = 0.0
+
+# Track if this bullet is currently active in the shot
+var is_active: bool = false
+
+# Angle at which this bullet should fire (in degrees)
+var angle: float = 0.0
+
+# Whether to rotate bullet to face its movement direction
+var rotate_to_velocity: bool = true
+
+func _process(delta):
+    var current_time = Time.get_ticks_msec() / 1000.0
+
+    # Fire if it's time and bullet isn't already active
+    if !is_active and current_time >= fire_time:
+        activate()
+
+    # Calculate the movement vector based on speed, angle, and delta
+    var angle_rad = deg_to_rad(angle)
+    var move_x = cos(angle_rad) * shot_data.speed * delta
+    var move_y = sin(angle_rad) * shot_data.speed * delta
+
+    # Move the bullet
+    position.x += move_x
+    position.y += move_y
+
+    # Rotate to face movement direction - ensure proper rotation calculation
+    if rotate_to_velocity:
+        var velocity = Vector2(cos(angle_rad) * shot_data.speed, sin(angle_rad) * shot_data.speed)
+        rotation = velocity.angle()
+
+        # Debug output - this will show you what's really happening
+        print("Bullet angle: ", angle, "Velocity angle:", velocity.angle(), "Rotation set to:", rotation)
+
+
+func activate():
+    is_active = true
+    visible = true
+
+func _on_visible_on_screen_notifier_2d_screen_exited():
+    queue_free()
+
+    # Set fire_time for the next shot (staggered firing)
+    var current_time = Time.get_ticks_msec() / 1000.0
+    fire_time = current_time + shot_data.stagger_offset

scenes/player_weapons/weapon_stock.tscn

@@ -1,6 +1,6 @@
 [gd_scene format=3 uid="uid://ddpclu2vdy2ve"]
 
-[ext_resource type="Script" uid="uid://c5blhfopjpfny" path="res://scenes/weapon_stock.gd" id="1_u1d5o"]
+[ext_resource type="Script" uid="uid://c5blhfopjpfny" path="res://scenes/player_weapons/weapon_stock.gd" id="1_u1d5o"]
 [ext_resource type="Texture2D" uid="uid://bnpm8b62n1pr5" path="res://graphics/shot_stock_og.png" id="2_u1d5o"]
 
 [sub_resource type="AtlasTexture" id="AtlasTexture_5bykt"]

scenes/player_weapons/weapon_stock_fixed.gd

@@ -0,0 +1,54 @@
+extends Area2D
+
+@onready var shot_data = load("res://resources/player_weapon_resources/weapon_shot_stock.tres")
+
+# Time offset when this bullet was fired (relative to other bullets in the same shot)
+var time_offset: float = 0.5
+
+# When this bullet should fire (absolute time)
+var fire_time: float = 0.0
+
+# Track if this bullet is currently active in the shot
+var is_active: bool = false
+
+# Angle at which this bullet should fire (in degrees)
+var angle: float = 0.0
+
+# Whether to rotate bullet to face its movement direction
+var rotate_to_velocity: bool = true
+
+func _process(delta):
+	var current_time = Time.get_ticks_msec() / 1000.0
+
+	# Fire if it's time and bullet isn't already active
+	if !is_active and current_time >= fire_time:
+		activate()
+
+	# Calculate the movement vector based on speed, angle, and delta
+	var angle_rad = deg_to_rad(angle)
+	var move_x = cos(angle_rad) * shot_data.speed * delta
+	var move_y = sin(angle_rad) * shot_data.speed * delta
+
+	# Move the bullet
+	position.x += move_x
+	position.y += move_y
+
+	# Rotate to face movement direction - ensure proper rotation calculation
+	if rotate_to_velocity:
+		var velocity = Vector2(cos(angle_rad) * shot_data.speed, sin(angle_rad) * shot_data.speed)
+		rotation = velocity.angle()
+
+		# Debug output - this will show you what's really happening
+		print("Bullet angle: ", angle, "Velocity angle:", velocity.angle(), "Rotation set to:", rotation)
+
+
+func activate():
+	is_active = true
+	visible = true
+
+func _on_visible_on_screen_notifier_2d_screen_exited():
+	queue_free()
+
+	# Set fire_time for the next shot (staggered firing)
+	var current_time = Time.get_ticks_msec() / 1000.0
+	fire_time = current_time + shot_data.stagger_offset

scenes/player_weapons/weapon_stock_fixed.gd.uid

@@ -0,0 +1 @@
+uid://7wuopfptd3qe

scenes/player_weapons/weapon_stock_fixed2.gd

@@ -0,0 +1,54 @@
+extends Area2D
+
+@onready var shot_data = load("res://resources/player_weapon_resources/weapon_shot_stock.tres")
+
+# Time offset when this bullet was fired (relative to other bullets in the same shot)
+var time_offset: float = 0.5
+
+# When this bullet should fire (absolute time)
+var fire_time: float = 0.0
+
+# Track if this bullet is currently active in the shot
+var is_active: bool = false
+
+# Angle at which this bullet should fire (in degrees)
+var angle: float = 0.0
+
+# Whether to rotate bullet to face its movement direction
+var rotate_to_velocity: bool = true
+
+func _process(delta):
+	var current_time = Time.get_ticks_msec() / 1000.0
+
+	# Fire if it's time and bullet isn't already active
+	if !is_active and current_time >= fire_time:
+		activate()
+
+	# Calculate the movement vector based on speed, angle, and delta
+	var angle_rad = deg_to_rad(angle)
+	var move_x = cos(angle_rad) * shot_data.speed * delta
+	var move_y = sin(angle_rad) * shot_data.speed * delta
+
+	# Move the bullet
+	position.x += move_x
+	position.y += move_y
+
+	# Rotate to face movement direction - ensure proper rotation calculation
+	if rotate_to_velocity:
+		var velocity = Vector2(cos(angle_rad) * shot_data.speed, sin(angle_rad) * shot_data.speed)
+		rotation = velocity.angle()
+
+		# Debug output - this will show you what's really happening
+		print("Bullet angle: ", angle, "Velocity angle:", velocity.angle(), "Rotation set to:", rotation)
+
+
+func activate():
+	is_active = true
+	visible = true
+
+func _on_visible_on_screen_notifier_2d_screen_exited():
+	queue_free()
+
+	# Set fire_time for the next shot (staggered firing)
+	var current_time = Time.get_ticks_msec() / 1000.0
+	fire_time = current_time + shot_data.stagger_offset

scenes/player_weapons/weapon_stock_fixed2.gd.uid

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

scenes/weapon_stock.gd

@@ -1,40 +0,0 @@
-extends Area2D
-
-
-@onready var bullet: PackedScene = load("res://scenes/weapon_stock.tscn")
-@onready var shot_data: = load("res://resources/player_weapons/weapon_shot_stock.tres")
-
-
-
-# Time offset when this bullet was fired (relative to other bullets in the same shot)
-var time_offset: float = 0.5
-
-# When this bullet should fire (absolute time)
-var fire_time: float = 0.0
-
-# Track if this bullet is currently active in the shot
-var is_active: bool = false
-
-func _process(delta):
-    var current_time = Time.get_ticks_msec() / 1000.0
-
-    # Fire if it's time and bullet isn't already active
-    if !is_active and current_time >= fire_time:
-        activate()
-
-    # Move the bullet
-    position.y -= shot_data.speed * delta
-
-func activate():
-    is_active = true
-    visible = true
-
-    # # Emit signal for hit detection
-    # emit_signal("activate")
-
-func _on_visible_on_screen_notifier_2d_screen_exited():
-    queue_free()
-
-    # Set fire_time for the next shot (staggered firing)
-    var current_time = Time.get_ticks_msec() / 1000.0
-    fire_time = current_time + shot_data.stagger_offset

scripts/shoot_component.gd

@@ -1,13 +1,13 @@
 class_name ShootComponent extends Node
 
-@export var stagger_offset: float = 0.5  # Time delay per projectile index (seconds)
-@export var horizontal_offset: float = 1.0  # Horizontal distance per projectile index
+@export var stagger_offset: float = 0.5 # Time delay per projectile index (seconds)
+@export var horizontal_offset: float = 1.0 # Horizontal distance per projectile index
 
 @onready var weapon_component: Node = %WeaponComponent
 @onready var player = $".."
 
 func shoot():
-    var weapon_data = weapon_component.data  # WeaponShot resource configuration
+    var weapon_data = weapon_component.data # WeaponShot resource configuration
     var current_time = Time.get_ticks_msec() / 1000.0
     var total_projectiles = weapon_data.projectiles
 
@@ -19,14 +19,14 @@ func shoot():
         if total_projectiles > 0:
             for b in range(total_projectiles):
                 var bullet_scene = weapon_data.bullet_scene
-                var bullet := bullet_scene.instantiate() as Node
+                var bullet := bullet_scene.instantiate() as Node2D
                 get_tree().root.add_child(bullet)
 
                 # Calculate index relative to center (0 = center, -1/+1 = first from center)
                 var index_from_center: float = b - center_index
 
                 # Calculate timing offset for staggered firing
-                var time_offset: float = index_from_center * stagger_offset
+                var time_offset: float = index_from_center * weapon_data.stagger_offset
 
                 # Calculate horizontal offset for this bullet (symmetrical: left=-ve, right=+ve)
                 var bullet_horizontal_offset: float = index_from_center * weapon_data.horizontal_offset
@@ -35,12 +35,33 @@ func shoot():
                 var distance_from_center: float = abs(index_from_center)
                 var vertical_offset: float = (distance_from_center * weapon_data.origin * -1) / 2
 
-                # Final position combines symmetrical horizontal spread with symmetrical vertical spacing
-                bullet.position = player.position + Vector2(bullet_horizontal_offset, weapon_data.origin + (vertical_offset + weapon_data.origin - total_projectiles))
+                # Final position combines symmetrical horizontal spread with fixed vertical offset from weapon origin
+                bullet.position = player.position + Vector2(bullet_horizontal_offset, weapon_data.origin)
 
                 # Set timing properties on the bullet
                 bullet.time_offset = time_offset
                 bullet.fire_time = current_time + time_offset
 
+                # Set bullet rotation properties
+                bullet.rotate_to_velocity = weapon_data.rotate_to_velocity  # This should be true if you want rotation
+  
+
+                # Set the angle for bullets - symmetrical spread around vertical (straight up = -90°)
+                if weapon_data.angle == 0:
+                    # If angle is 0, all projectiles fire straight up
+                    bullet.angle = -90.0
+                else:
+                    # Set angle for bullets - symmetrical spread around vertical (straight up = -90°)
+                    if index_from_center == 0:
+                        # Center projectile fires straight up
+                        bullet.angle = -90.0
+                    else:
+                        # Left projectiles: positive angle (up and to the left), Right projectiles: negative angle (up and to the right)
+                        bullet.angle = -90.0 + weapon_data.angle * sign(index_from_center)
+
+
+
+
+
             # Subtract projectile spacing from current Player travel for next shot
             player.travel -= weapon_data.spacing

scripts/weapon_component.gd

@@ -1,7 +1,7 @@
 class_name WeaponComponent extends Node
 
-@export var loaded_weapon: PackedScene = load("res://scenes/weapon_stock.tscn")
-var data : WeaponShot = load("res://resources/player_weapons/weapon_shot_stock.tres")
+@export var loaded_weapon: PackedScene = load("res://scenes/player_weapons/weapon_stock.tscn")
+var data : WeaponShot = load("res://resources/player_weapon_resources/weapon_shot_stock.tres")
 
 
 

test_rotation.gd

@@ -0,0 +1,25 @@
+extends Area2D
+
+# Simple test to verify rotation behavior
+var test_angle: float = 0.0
+var rotate_to_velocity: bool = true
+
+func _process(delta):
+    # Move in a straight line at 100 pixels per second
+    var move_x = cos(deg_to_rad(test_angle)) * 100 * delta
+    var move_y = sin(deg_to_rad(test_angle)) * 100 * delta
+
+    position.x += move_x
+    position.y += move_y
+
+    # Rotate to face movement direction (this is the key fix)
+    if rotate_to_velocity:
+        var velocity = Vector2(cos(deg_to_rad(test_angle)) * 100, sin(deg_to_rad(test_angle)) * 100)
+        rotation = velocity.angle()
+
+        # Debug output
+        print("Test angle: ", test_angle, "Velocity angle:", velocity.angle(), "Rotation set to:", rotation)
+
+func _ready():
+    # Set initial rotation for testing
+    test_angle = 0.0

test_rotation.gd.uid

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

test_rotation.tscn

@@ -0,0 +1,6 @@
+[gd_scene format=3 uid="uid://d4ls4srw6qyap"]
+
+[ext_resource type="Script" uid="uid://d1rwqotmrag1r" path="res://test_rotation.gd" id="1_kx6bj"]
+
+[node name="TestRotation" type="Area2D" unique_id=1832200900]
+script = ExtResource("1_kx6bj")