Add server-side hitscan, firing and respawn

Implements server-authoritative combat: adds health, firing, respawn and hit tracking to player state and logic. net_common.h: introduce IS_DEAD flag, expand NetPlayerState with health, hitByPlayerId and fireCounter and update static_assert sizes. game_server.h: add combat fields, firing/ raycast APIs and weapon constants. game_server.cpp: initialize health/fire/respawn on connect, skip actions for dead players, run per-tick respawn logic, integrate ProcessFiring (RPM/damage, fire timing, fireCounter) and RaycastPlayers (ray->capsule hits against enemies), prevent friendly fire and mark kills; skip dead players during physics; sync combat data into snapshots. Added server_raycast.h: standalone ray-capsule intersection and direction helpers used for server hitscan. These changes enable server-side hitscan, damage application, death/respawn and hit markers.

Author: PiscesTrio

Network/game_server.cpp

@@ -107,8 +107,15 @@ void GameServer::OnPlayerConnected(uint8_t playerId)
     data.state.yaw = 0.0f;
     data.state.pitch = 0.0f;
     data.state.stateFlags = NetStateFlags::IS_GROUNDED;
+    data.state.health = MAX_HEALTH;
+    data.state.hitByPlayerId = 0xFF;
+    data.state.fireCounter = 0;
     data.lastInput = {};
     data.reloadTimer = 0.0;
+    data.health = MAX_HEALTH;
+    data.respawnTimer = 0.0;
+    data.fireTimer = 0.0;
+    data.fireCounter = 0;
 
     m_Players[playerId] = data;
     printf("[GameServer] Player %u (Team %s) spawned at (%.1f, %.1f, %.1f)\n",
@@ -162,13 +169,45 @@ void GameServer::Tick()
     // 3. Simulate physics for all players
     SimulatePhysics();
 
-    // 4. Update tick ID in all player states
+    // 4. Process firing and combat for all players
+    for (auto& [id, player] : m_Players)
+    {
+        // Clear hit marker each tick
+        player.state.hitByPlayerId = 0xFF;
+
+        // Respawn timer
+        if (player.state.stateFlags & NetStateFlags::IS_DEAD)
+        {
+            player.respawnTimer -= TICK_DURATION;
+            if (player.respawnTimer <= 0.0)
+            {
+                // Respawn
+                player.health = MAX_HEALTH;
+                player.state.stateFlags &= ~NetStateFlags::IS_DEAD;
+                player.state.stateFlags |= NetStateFlags::IS_GROUNDED;
+                player.state.position = GetSpawnPosition(id, player.teamId);
+                player.state.velocity = { 0.0f, 0.0f, 0.0f };
+                player.respawnTimer = 0.0;
+                printf("[GameServer] Player %u respawned\n", id);
+            }
+        }
+        else
+        {
+            ProcessFiring(player, id);
+        }
+
+        // Sync combat data to state
+        player.state.health = player.health;
+        player.state.fireCounter = player.fireCounter;
+    }
+
+    // 5. Update tick ID in all player states
     for (auto& [id, player] : m_Players)
     {
         player.state.tickId = m_CurrentTick;
     }
 
-    // 5. Broadcast per-player snapshots
+    // 6. Broadcast per-player snapshots
     BroadcastSnapshots();
 }
 
@@ -198,6 +237,14 @@ void GameServer::ProcessInputCmd(const InputCmd& cmd, uint8_t playerId)
     PlayerData& player = it->second;
     player.lastInput = cmd;
 
+    // Dead players: only update camera, skip all actions
+    if (player.state.stateFlags & NetStateFlags::IS_DEAD)
+    {
+        player.state.yaw = cmd.yaw;
+        player.state.pitch = cmd.pitch;
+        return;
+    }
+
     player.state.yaw = cmd.yaw;
     player.state.pitch = cmd.pitch;
 
@@ -244,6 +291,9 @@ void GameServer::SimulatePhysics()
 {
     for (auto& [id, player] : m_Players)
     {
+        // Skip dead players
+        if (player.state.stateFlags & NetStateFlags::IS_DEAD)
+            continue;
         SimulatePlayerPhysics(player);
     }
 }
@@ -410,3 +460,123 @@ void GameServer::BroadcastSnapshots()
         m_pNetwork->SendSnapshotToPlayer(myId, snapshot);
     }
 }
+
+//-----------------------------------------------------------------------------
+// ProcessFiring - Handle fire rate and hitscan for a player
+//-----------------------------------------------------------------------------
+void GameServer::ProcessFiring(PlayerData& shooter, uint8_t shooterId)
+{
+    bool isFiring = (shooter.lastInput.buttons & InputButtons::FIRE) != 0;
+
+    if (!isFiring)
+    {
+        shooter.fireTimer = 0.0;
+        return;
+    }
+
+    // Determine RPM and damage based on team
+    double rpm = (shooter.teamId == PlayerTeam::RED) ? RED_RPM : BLUE_RPM;
+    uint8_t damage = (shooter.teamId == PlayerTeam::RED) ? RED_DAMAGE : BLUE_DAMAGE;
+    double fireInterval = 60.0 / rpm;
+
+    // First shot fires immediately; subsequent shots at RPM interval
+    bool shouldFire = false;
+    if (shooter.fireTimer <= 0.0)
+    {
+        // First press — fire immediately
+        shouldFire = true;
+        shooter.fireTimer = fireInterval;
+    }
+    else
+    {
+        shooter.fireTimer -= TICK_DURATION;
+        if (shooter.fireTimer <= 0.0)
+        {
+            shouldFire = true;
+            shooter.fireTimer += fireInterval;
+        }
+    }
+
+    if (!shouldFire) return;
+
+    // Increment fire counter
+    shooter.fireCounter++;
+
+    // Cast ray from eye position
+    Float3 eyePos = {
+        shooter.state.position.x,
+        shooter.state.position.y + PLAYER_HEIGHT - 0.1f,
+        shooter.state.position.z
+    };
+    Float3 rayDir = ServerRaycast::DirectionFromYawPitch(
+        shooter.state.yaw, shooter.state.pitch);
+
+    // Test against all other alive players (no friendly fire)
+    uint8_t hitId = 0xFF;
+    float hitDist = 0.0f;
+    if (RaycastPlayers(eyePos, rayDir, shooterId, shooter.teamId, hitId, hitDist))
+    {
+        // Apply damage
+        auto hitIt = m_Players.find(hitId);
+        if (hitIt != m_Players.end())
+        {
+            PlayerData& target = hitIt->second;
+            if (target.health > damage)
+            {
+                target.health -= damage;
+            }
+            else
+            {
+                target.health = 0;
+                target.state.stateFlags |= NetStateFlags::IS_DEAD;
+                target.respawnTimer = RESPAWN_TIME;
+                target.state.velocity = { 0.0f, 0.0f, 0.0f };
+                printf("[GameServer] Player %u killed Player %u\n", shooterId, hitId);
+            }
+
+            // Record hit for attacker's hit marker
+            shooter.state.hitByPlayerId = hitId;
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// RaycastPlayers - Test ray against all alive enemy players
+//
+// Returns true if any enemy player is hit. outHitId/outDist are set to the
+// closest hit. Players on excludeTeam are skipped (no friendly fire).
+//-----------------------------------------------------------------------------
+bool GameServer::RaycastPlayers(const Float3& origin, const Float3& dir,
+                                 uint8_t excludeId, uint8_t excludeTeam,
+                                 uint8_t& outHitId, float& outDist)
+{
+    bool anyHit = false;
+    float closestT = 9999.0f;
+
+    for (const auto& [id, player] : m_Players)
+    {
+        // Skip self
+        if (id == excludeId) continue;
+        // Skip same team (no friendly fire)
+        if (player.teamId == excludeTeam) continue;
+        // Skip dead
+        if (player.state.stateFlags & NetStateFlags::IS_DEAD) continue;
+
+        float t = 0.0f;
+        if (ServerRaycast::RayCapsule(origin, dir,
+            player.state.position, PLAYER_HEIGHT, CAPSULE_RADIUS, t))
+        {
+            if (t < closestT)
+            {
+                closestT = t;
+                outHitId = id;
+                anyHit = true;
+            }
+        }
+    }
+
+    if (anyHit)
+        outDist = closestT;
+
+    return anyHit;
+}

Network/game_server.h

@@ -14,6 +14,7 @@
 
 #include "net_common.h"
 #include "server_collision.h"
+#include "server_raycast.h"
 #include <unordered_map>
 #include <cstddef>
 
@@ -56,11 +57,20 @@ class GameServer
         InputCmd lastInput{};
         double reloadTimer = 0.0;
         uint8_t teamId = PlayerTeam::RED;
+        // Combat
+        uint8_t health = 200;
+        double respawnTimer = 0.0;
+        double fireTimer = 0.0;
+        uint16_t fireCounter = 0;
     };
 
     void Tick();
     void ProcessPlayerEvents();
     void ProcessInputCmd(const InputCmd& cmd, uint8_t playerId);
+    void ProcessFiring(PlayerData& shooter, uint8_t shooterId);
+    bool RaycastPlayers(const Float3& origin, const Float3& dir,
+                        uint8_t excludeId, uint8_t excludeTeam,
+                        uint8_t& outHitId, float& outDist);
     void SimulatePlayerPhysics(PlayerData& player);
     void SimulatePhysics();
     void BroadcastSnapshots();
@@ -88,4 +98,12 @@ class GameServer
     // Player collision parameters (must match client)
     static constexpr float PLAYER_HEIGHT = 2.0f;
     static constexpr float CAPSULE_RADIUS = 0.5f;
+
+    // Weapon parameters per team
+    static constexpr double RED_RPM = 600.0;
+    static constexpr uint8_t RED_DAMAGE = 34;
+    static constexpr double BLUE_RPM = 800.0;
+    static constexpr uint8_t BLUE_DAMAGE = 25;
+    static constexpr uint8_t MAX_HEALTH = 200;
+    static constexpr double RESPAWN_TIME = 2.0;
 };

Network/net_common.h

@@ -64,6 +64,7 @@ constexpr uint32_t IS_FIRING = 1 << 2;
 constexpr uint32_t IS_ADS = 1 << 3;
 constexpr uint32_t IS_RELOADING = 1 << 4;
 constexpr uint32_t IS_RELOAD_EMPTY = 1 << 5;
+constexpr uint32_t IS_DEAD = 1 << 6;
 } // namespace NetStateFlags
 
 //-----------------------------------------------------------------------------
@@ -76,6 +77,9 @@ struct NetPlayerState {
   float yaw;                  // Camera yaw
   float pitch;                // Camera pitch
   uint32_t stateFlags;        // Bitfield of StateFlags
+  uint8_t  health;            // 0-200, server authoritative
+  uint8_t  hitByPlayerId;     // 0xFF = no hit, else attacker ID
+  uint16_t fireCounter;       // Server-tracked fire count
 };
 
 //-----------------------------------------------------------------------------
@@ -125,7 +129,7 @@ struct Snapshot {
 //-----------------------------------------------------------------------------
 static_assert(sizeof(InputCmd) == 24,
               "InputCmd size changed - update network serialization");
-static_assert(sizeof(NetPlayerState) == 40,
+static_assert(sizeof(NetPlayerState) == 44,
               "NetPlayerState size changed - update network serialization");
-static_assert(sizeof(RemotePlayerEntry) == 44,
+static_assert(sizeof(RemotePlayerEntry) == 48,
               "RemotePlayerEntry size changed - update network serialization");