updates ship move logic

Author: TheCodeTherapy

src/gamelogic/ship.odin

@@ -7,8 +7,18 @@ import "core:fmt"
 MAX_PROJECTILES :: 10000
 
 MAX_SHIP_SPEED :: 1000.0
-MAX_WARP_MULTIPLIER :: 3.0
-WARP_SPEED_THRESHOLD :: 997.0
+MAX_WARP_MULTIPLIER :: 70.0
+WARP_SPEED_THRESHOLD :: 997.45
+
+SHIP_ACCELERATION :: 997.5
+SHIP_SCALE :: 30.0
+SHIP_FRICTION :: 0.39346
+SHIP_SHOOT_INTERVAL :: 0.0125
+
+ROTATION_DEGREES_PER_SECOND :: 360.0
+
+MOVEMENT_INERTIA :: 0.021
+WARP_INERTIA :: 0.05
 
 Projectile :: struct {
 	position: rl.Vector2,
@@ -22,40 +32,43 @@ Ship :: struct {
 	position:       rl.Vector2,     // Screen/local position (for rendering and collision)
 	world_position: rl.Vector2,     // World position (for exploration and camera)
 	arena_position: rl.Vector2,     // Position within arena bounds (for wrapping mode)
-	velocity:       rl.Vector2,
+	velocity:       rl.Vector2,     // Current velocity (with inertia)
+	target_velocity: rl.Vector2,    // Target velocity from WASD input
 	rotation:       f32,
 	acceleration:   f32,
 	friction:       f32,
 	shoot_cooldown: f32,
 	shoot_interval: f32,
 	projectiles:    [MAX_PROJECTILES]Projectile,
 	ship_speed:     f32,            // Current speed magnitude
+	warp_speed_target: f32,         // Target warp speed (1.0 to MAX_WARP_MULTIPLIER)
 	warp_speed:     f32,            // Warp speed multiplier (1.0 to MAX_WARP_MULTIPLIER)
 	trail:          Ship_Trail,     // Ship trail system
 }
 
 init_ship :: proc(window_width: f32, window_height: f32) -> Ship {
 	start_pos := rl.Vector2{window_width / 2, window_height / 2}
 	ship := Ship {
-		scale = 30,
+		scale = SHIP_SCALE,
 		position = start_pos,
-		world_position = start_pos, // Start at same position as screen
-		arena_position = start_pos, // Initialize arena position
+		world_position = start_pos,
+		arena_position = start_pos,
 		velocity = rl.Vector2{0.0, 0.0},
+		target_velocity = rl.Vector2{0.0, 0.0},
 		rotation = 0.0,
-		acceleration = 500.0,
-		friction = 0.39346,
+		acceleration = SHIP_ACCELERATION,
+		friction = SHIP_FRICTION,
 		shoot_cooldown = 0.0,
-		shoot_interval = 0.0125,
+		shoot_interval = SHIP_SHOOT_INTERVAL,
 		projectiles = [MAX_PROJECTILES]Projectile{},
 		ship_speed = 0.0,
+		warp_speed_target = 1.0,
 		warp_speed = 1.0,
 		trail = Ship_Trail{},
 	}
 
-	// Initialize the trail system
-	init_ship_trail(&ship.trail, ship.scale * 0.25) // Use half the ship scale as radius
-	reset_ship_trail(&ship.trail, ship.world_position, 0.0) // Initialize with world position
+	init_ship_trail(&ship.trail, ship.scale * 0.25)
+	reset_ship_trail(&ship.trail, ship.world_position, 0.0)
 
 	return ship
 }
@@ -86,19 +99,16 @@ shoot_projectile :: proc(ship: ^Ship) {
 update_projectiles :: proc(ship: ^Ship, delta_time: f32, window_width: f32, window_height: f32) {
 	for &projectile in &ship.projectiles {
 		if projectile.active {
-			// store previous position to calculate distance traveled
 			prev_position := projectile.position
 
 			projectile.position.x += projectile.velocity.x * delta_time
 			projectile.position.y += projectile.velocity.y * delta_time
 
-			// calculate distance traveled this frame
 			dx := projectile.position.x - prev_position.x
 			dy := projectile.position.y - prev_position.y
 			distance_this_frame := math.sqrt(dx * dx + dy * dy)
 			projectile.traveled += distance_this_frame
 
-			// wrap around screen edges
 			if projectile.position.x < 0 {
 				projectile.position.x = window_width
 			} else if projectile.position.x > window_width {
@@ -111,7 +121,6 @@ update_projectiles :: proc(ship: ^Ship, delta_time: f32, window_width: f32, wind
 				projectile.position.y = 0
 			}
 
-			// deactivate projectiles after they've traveled far enough
 			if projectile.traveled > 10000.0 {
 				projectile.active = false
 			}
@@ -128,46 +137,66 @@ draw_projectiles :: proc(ship: ^Ship) {
 }
 
 update_ship :: proc(ship: ^Ship, camera: ^Camera_State, delta_time: f32, window_width: f32, window_height: f32) {
-	// ship rotation
-	if rl.IsKeyDown(rl.KeyboardKey.RIGHT) || rl.IsKeyDown(rl.KeyboardKey.D) {
-		ship.rotation += 180.0 * delta_time
-	}
+	input_direction := rl.Vector2{0, 0}
+
 	if rl.IsKeyDown(rl.KeyboardKey.LEFT) || rl.IsKeyDown(rl.KeyboardKey.A) {
-		ship.rotation -= 180.0 * delta_time
+		input_direction.x -= 1.0
+	}
+	if rl.IsKeyDown(rl.KeyboardKey.RIGHT) || rl.IsKeyDown(rl.KeyboardKey.D) {
+		input_direction.x += 1.0
 	}
-
-	// ship thrust
 	if rl.IsKeyDown(rl.KeyboardKey.UP) || rl.IsKeyDown(rl.KeyboardKey.W) {
-		radians := ship.rotation * rl.DEG2RAD
-		ship.velocity.x += math.cos(radians) * ship.acceleration * delta_time
-		ship.velocity.y += math.sin(radians) * ship.acceleration * delta_time
+		input_direction.y -= 1.0
 	}
+	if rl.IsKeyDown(rl.KeyboardKey.DOWN) || rl.IsKeyDown(rl.KeyboardKey.S) {
+		input_direction.y += 1.0
+	}
+
+	input_direction = rl.Vector2Normalize(input_direction)
+	ship.target_velocity = input_direction * ship.acceleration
+	ship.velocity.x += ease(ship.target_velocity.x, ship.velocity.x, MOVEMENT_INERTIA, delta_time, f32(rl.GetFPS()))
+	ship.velocity.y += ease(ship.target_velocity.y, ship.velocity.y, MOVEMENT_INERTIA, delta_time, f32(rl.GetFPS()))
+
+	if rl.Vector2Length(input_direction) > 0.1 {
+		target_rotation := math.atan2(input_direction.y, input_direction.x) * rl.RAD2DEG
+		rotation_diff := target_rotation - ship.rotation
 
-	// apply friction (exponential decay - frame rate independent)
-	friction_factor := math.pow(1.0 - ship.friction, delta_time)
-	ship.velocity.x *= friction_factor
-	ship.velocity.y *= friction_factor
+		// eliminates gimbal lock
+		if rotation_diff > 180.0 {
+			rotation_diff -= 360.0
+		} else if rotation_diff < -180.0 {
+			rotation_diff += 360.0
+		}
+
+		max_rotation_this_frame := ROTATION_DEGREES_PER_SECOND * delta_time
+
+		if math.abs(rotation_diff) < max_rotation_this_frame {
+			ship.rotation = target_rotation
+		} else {
+			if rotation_diff > 0 {
+				ship.rotation += max_rotation_this_frame
+			} else {
+				ship.rotation -= max_rotation_this_frame
+			}
+		}
+	}
 
-	// calculate ship speed from velocity magnitude
 	ship.ship_speed = math.sqrt(ship.velocity.x * ship.velocity.x + ship.velocity.y * ship.velocity.y)
 
-	// calculate warp speed multiplier based on ship speed
 	if ship.ship_speed >= WARP_SPEED_THRESHOLD && ship.ship_speed <= MAX_SHIP_SPEED {
-		ship.warp_speed = remap(ship.ship_speed, WARP_SPEED_THRESHOLD, MAX_SHIP_SPEED, 1.0, MAX_WARP_MULTIPLIER)
+		ship.warp_speed_target = remap(ship.ship_speed, WARP_SPEED_THRESHOLD, MAX_SHIP_SPEED, 1.0, MAX_WARP_MULTIPLIER)
 	} else if ship.ship_speed > MAX_SHIP_SPEED {
-		ship.warp_speed = MAX_WARP_MULTIPLIER
+		ship.warp_speed_target = MAX_WARP_MULTIPLIER
 	} else {
-		ship.warp_speed = 1.0
+		ship.warp_speed_target = 1.0
 	}
 
-	// ALWAYS update world position accurately - no more freezing!
+	ship.warp_speed += ease(ship.warp_speed_target, ship.warp_speed, WARP_INERTIA, delta_time, f32(rl.GetFPS()))
+
 	ship.world_position.x += ship.velocity.x * ship.warp_speed * delta_time
 	ship.world_position.y += ship.velocity.y * ship.warp_speed * delta_time
-
-	// Keep arena position synced with world position
 	ship.arena_position = ship.world_position
 
-	// update screen/local position based on camera mode
 	switch camera.mode {
 	case .FOLLOW_SHIP:
 		// In exploration mode, ship position relative to camera
@@ -273,24 +302,20 @@ draw_ship_to_texture :: proc(ship: ^Ship) -> rl.Texture2D {
 	return g_state.ship_render_target.texture
 }
 
-// cleanup ship resources
-// Hot reload ship system
 ship_hot_reload :: proc(ship: ^Ship) -> bool {
 	fmt.printf("=== HOT RELOADING SHIP SYSTEM ===\n")
 
-	// Store current state for continuity
-	current_scale := ship.scale
+	// store current runtime state (preserve continuity)
 	current_position := ship.position
 	current_world_position := ship.world_position
 	current_arena_position := ship.arena_position
 	current_velocity := ship.velocity
+	current_target_velocity := ship.target_velocity
 	current_rotation := ship.rotation
-	current_acceleration := ship.acceleration
-	current_friction := ship.friction
 	current_shoot_cooldown := ship.shoot_cooldown
-	current_shoot_interval := ship.shoot_interval
 	current_projectiles := ship.projectiles
 	current_ship_speed := ship.ship_speed
+	current_warp_speed_target := ship.warp_speed_target
 	current_warp_speed := ship.warp_speed
 
 	fmt.printf("Ship state preserved: pos=(%.2f,%.2f), world_pos=(%.2f,%.2f), vel=(%.2f,%.2f), rot=%.2f\n",
@@ -299,7 +324,13 @@ ship_hot_reload :: proc(ship: ^Ship) -> bool {
 		current_velocity.x, current_velocity.y,
 		current_rotation)
 
-	// Hot reload the ship trail
+	// get updated constants directly (pick up code changes on hot reload)
+	new_scale := f32(SHIP_SCALE)
+	new_acceleration := f32(SHIP_ACCELERATION)
+	new_friction := f32(SHIP_FRICTION)
+	new_shoot_interval := f32(SHIP_SHOOT_INTERVAL)
+
+	// hot reload the ship trail
 	if ship.trail.initialized {
 		fmt.printf("Hot reloading ship trail...\n")
 		if !ship_trail_hot_reload(&ship.trail) {
@@ -311,26 +342,33 @@ ship_hot_reload :: proc(ship: ^Ship) -> bool {
 		fmt.printf("Ship trail not initialized, skipping trail hot reload\n")
 	}
 
-	// Restore all state
-	ship.scale = current_scale
+	// restore runtime state (preserve continuity)
 	ship.position = current_position
 	ship.world_position = current_world_position
 	ship.arena_position = current_arena_position
 	ship.velocity = current_velocity
+	ship.target_velocity = current_target_velocity
 	ship.rotation = current_rotation
-	ship.acceleration = current_acceleration
-	ship.friction = current_friction
 	ship.shoot_cooldown = current_shoot_cooldown
-	ship.shoot_interval = current_shoot_interval
 	ship.projectiles = current_projectiles
 	ship.ship_speed = current_ship_speed
+	ship.warp_speed_target = current_warp_speed_target
 	ship.warp_speed = current_warp_speed
 
+	// apply new config values
+	ship.scale = new_scale
+	ship.acceleration = new_acceleration
+	ship.friction = new_friction
+	ship.shoot_interval = new_shoot_interval
+
+	fmt.printf("Hot reload: Updated acceleration: %.2f, friction: %.6f, scale: %.2f, shoot_interval: %.4f\n",
+		ship.acceleration, ship.friction, ship.scale, ship.shoot_interval)
+
 	fmt.printf("Ship state restored successfully\n")
 	fmt.printf("=== SHIP HOT RELOAD COMPLETE ===\n")
 	return true
 }
 
 cleanup_ship :: proc(ship: ^Ship) {
 	destroy_ship_trail(&ship.trail)
-}
+}