fishsoup/suicmez
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
suicmez/game/server.c
Masashi 7f6a704dac gam
2025-12-18 03:29:26 +05:30

971 lines
25 KiB
C
Raw Blame History

// server.c - UDP authoritative server + ODE physics + ODE raycast bullets (C99)
// Adds: true spray, inventory capacity (6 slots), world pickups, drop/pick/use,
// armor+medkits. Build (Linux example): gcc server.c -O2 -o server -lode -lm
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <ode/ode.h>
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")
typedef int socklen_t;
#define CLOSESOCK closesocket
#else
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <unistd.h>
#define CLOSESOCK close
#endif
#define PROTOCOL_VERSION 4
#define SERVER_PORT 27015
#define MAX_PLAYERS 16
#define USERNAME_MAX 16
#define TICK_HZ 60
#define DT (1.0f / (float)TICK_HZ)
#define WEAPON_PISTOL 0
#define WEAPON_RIFLE 1
#define WEAPON_COUNT 2
#define INV_SLOTS 6
#define MAX_ITEMS 64
// inventory item types
#define ITEM_NONE 0
#define ITEM_MEDKIT 1
#define ITEM_ARMORPLATE 2
#define ITEM_AMMO_PISTOL 3
#define ITEM_AMMO_RIFLE 4
// MsgInput.buttons bits
#define BTN_RELOAD (1u << 0)
#define BTN_WPN1 (1u << 1)
#define BTN_WPN2 (1u << 2)
#define BTN_PICK (1u << 3)
#define BTN_DROP (1u << 4)
#define BTN_USE (1u << 5)
// Collision categories
#define CAT_WORLD (1u << 0)
#define CAT_PLAYER (1u << 1)
#define CAT_ITEM (1u << 2)
static double now_seconds(void) {
#ifdef _WIN32
static LARGE_INTEGER freq;
static int init = 0;
LARGE_INTEGER t;
if (!init) {
QueryPerformanceFrequency(&freq);
init = 1;
}
QueryPerformanceCounter(&t);
return (double)t.QuadPart / (double)freq.QuadPart;
#else
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec + (double)ts.tv_nsec / 1e9;
#endif
}
static void set_nonblocking(int sock) {
#ifdef _WIN32
u_long mode = 1;
ioctlsocket(sock, FIONBIO, &mode);
#else
int flags = fcntl(sock, F_GETFL, 0);
fcntl(sock, F_SETFL, flags | O_NONBLOCK);
#endif
}
#pragma pack(push, 1)
typedef enum MsgType : uint8_t {
MSG_HELLO = 1,
MSG_WELCOME = 2,
MSG_INPUT = 3,
MSG_SNAPSHOT = 4,
MSG_SHOOT = 5,
MSG_HIT = 6,
MSG_ITEMS = 7
} MsgType;
typedef struct MsgHello {
uint8_t type;
uint32_t protocol;
char username[USERNAME_MAX];
} MsgHello;
typedef struct MsgWelcome {
uint8_t type;
uint8_t playerId;
uint32_t serverTick;
} MsgWelcome;
typedef struct MsgInput {
uint8_t type;
uint8_t playerId;
uint32_t clientTick;
float moveX;
float moveZ;
float yaw;
float pitch;
uint8_t buttons;
uint8_t slotIndex;
} MsgInput;
typedef struct MsgShoot {
uint8_t type;
uint8_t playerId;
uint32_t clientTick;
} MsgShoot;
typedef struct PlayerStateNet {
uint8_t id;
uint8_t alive;
int16_t hp;
int16_t armor;
float x, y, z;
float yaw, pitch;
uint8_t weapon;
int16_t ammoMag[WEAPON_COUNT];
int16_t ammoRes[WEAPON_COUNT];
uint8_t invType[INV_SLOTS];
int16_t invQty[INV_SLOTS];
char username[USERNAME_MAX];
} PlayerStateNet;
typedef struct MsgSnapshot {
uint8_t type;
uint32_t serverTick;
uint8_t count;
PlayerStateNet p[MAX_PLAYERS];
} MsgSnapshot;
typedef struct MsgHit {
uint8_t type;
uint8_t shooterId;
uint8_t victimId;
int16_t victimHp;
} MsgHit;
typedef struct ItemNet {
uint16_t id;
uint8_t type;
int16_t qty;
float x, y, z;
} ItemNet;
typedef struct MsgItems {
uint8_t type;
uint32_t serverTick;
uint8_t count;
ItemNet items[MAX_ITEMS];
} MsgItems;
#pragma pack(pop)
typedef struct Item {
int active;
uint16_t id;
uint8_t type;
int qty;
float x, y, z;
dGeomID geom; // static pickup geom (no body)
} Item;
typedef struct Player {
int inUse;
struct sockaddr_in addr;
double lastHeard;
char username[USERNAME_MAX];
float moveX, moveZ;
float yaw, pitch;
int alive;
int hp;
int armor;
int weapon;
int ammoMag[WEAPON_COUNT];
int ammoRes[WEAPON_COUNT];
uint8_t invType[INV_SLOTS];
int invQty[INV_SLOTS];
double lastShotTime;
int shotsInBurst;
uint32_t rng;
dBodyID body;
dGeomID geom;
} Player;
static int addr_equal(const struct sockaddr_in *a,
const struct sockaddr_in *b) {
return (a->sin_family == b->sin_family) && (a->sin_port == b->sin_port) &&
(a->sin_addr.s_addr == b->sin_addr.s_addr);
}
static float clampf(float v, float lo, float hi) {
if (v < lo)
return lo;
if (v > hi)
return hi;
return v;
}
static void sendto_player(int sock, const Player *pl, const void *data,
int len) {
sendto(sock, (const char *)data, len, 0, (const struct sockaddr *)&pl->addr,
sizeof(pl->addr));
}
static void broadcast(int sock, const Player players[MAX_PLAYERS],
const void *data, int len) {
for (int i = 0; i < MAX_PLAYERS; i++)
if (players[i].inUse)
sendto_player(sock, &players[i], data, len);
}
// ----- ODE globals -----
static dWorldID gWorld;
static dSpaceID gSpace;
static dJointGroupID gContactGroup;
// items
static Item gItems[MAX_ITEMS];
static uint16_t gNextItemId = 1;
static void item_destroy(Item *it) {
if (it->geom) {
dGeomDestroy(it->geom);
it->geom = 0;
}
memset(it, 0, sizeof(*it));
}
static int item_spawn(uint8_t type, int qty, float x, float y, float z) {
for (int i = 0; i < MAX_ITEMS; i++) {
if (!gItems[i].active) {
Item *it = &gItems[i];
it->active = 1;
it->id = gNextItemId++;
it->type = type;
it->qty = qty;
it->x = x;
it->y = y;
it->z = z;
it->geom = dCreateSphere(gSpace, 0.30);
dGeomSetPosition(it->geom, x, y + 0.3f, z);
// Mark as item and avoid physical contacts; also make raycasts ignore it.
dGeomSetCategoryBits(it->geom, CAT_ITEM);
dGeomSetCollideBits(it->geom, 0);
// Attach "user data" pointing to Item for identification if needed.
dGeomSetData(it->geom, it);
return i;
}
}
return -1;
}
static int inv_add(Player *p, uint8_t type, int qty) {
// stacking limits
int maxStack = 99;
if (type == ITEM_MEDKIT)
maxStack = 3;
if (type == ITEM_ARMORPLATE)
maxStack = 5;
// try stack
for (int i = 0; i < INV_SLOTS; i++) {
if (p->invType[i] == type && p->invQty[i] < maxStack) {
int can = maxStack - p->invQty[i];
int take = (qty < can) ? qty : can;
p->invQty[i] += take;
qty -= take;
if (qty <= 0)
return 1;
}
}
// place into empty slots
for (int i = 0; i < INV_SLOTS; i++) {
if (p->invType[i] == ITEM_NONE) {
int take = (qty < maxStack) ? qty : maxStack;
p->invType[i] = type;
p->invQty[i] = take;
qty -= take;
if (qty <= 0)
return 1;
}
}
// no space
return 0;
}
static int inv_remove_one(Player *p, int slot) {
if (slot < 0 || slot >= INV_SLOTS)
return 0;
if (p->invType[slot] == ITEM_NONE || p->invQty[slot] <= 0)
return 0;
p->invQty[slot]--;
if (p->invQty[slot] <= 0) {
p->invQty[slot] = 0;
p->invType[slot] = ITEM_NONE;
}
return 1;
}
static void nearCallback(void *user, dGeomID o1, dGeomID o2) {
(void)user;
if (dGeomIsSpace(o1) || dGeomIsSpace(o2)) {
dSpaceCollide2(o1, o2, user, &nearCallback);
return;
}
// Do not create contact joints involving item pickups
unsigned long c1 = dGeomGetCategoryBits(o1);
unsigned long c2 = dGeomGetCategoryBits(o2);
if ((c1 & CAT_ITEM) || (c2 & CAT_ITEM))
return;
const int MAXC = 8;
dContact c[MAXC];
int n = dCollide(o1, o2, MAXC, &c[0].geom, sizeof(dContact));
if (n <= 0)
return;
for (int i = 0; i < n; i++) {
c[i].surface.mode = dContactApprox1;
c[i].surface.mu = 1.0;
c[i].surface.bounce = 0.0;
c[i].surface.bounce_vel = 0.0;
dJointID j = dJointCreateContact(gWorld, gContactGroup, &c[i]);
dBodyID b1 = dGeomGetBody(o1);
dBodyID b2 = dGeomGetBody(o2);
dJointAttach(j, b1, b2);
}
}
static void ode_init_world(void) {
dInitODE();
gWorld = dWorldCreate();
gSpace = dHashSpaceCreate(0);
gContactGroup = dJointGroupCreate(0);
dWorldSetGravity(gWorld, 0, -9.81, 0);
dWorldSetERP(gWorld, 0.2);
dWorldSetCFM(gWorld, 1e-5);
dGeomID ground = dCreatePlane(gSpace, 0, 1, 0, 0);
dGeomSetCategoryBits(ground, CAT_WORLD);
dGeomSetCollideBits(ground, CAT_PLAYER);
const struct {
float x, y, z, sx, sy, sz;
} blocks[] = {
{2, 0.5f, 2, 1, 1, 1},
{2, 1.5f, 2, 1, 1, 1},
{-3, 0.5f, -1, 1, 1, 1},
{0, 0.5f, 4, 2, 1, 2},
};
for (int i = 0; i < (int)(sizeof(blocks) / sizeof(blocks[0])); i++) {
dGeomID b = dCreateBox(gSpace, blocks[i].sx, blocks[i].sy, blocks[i].sz);
dGeomSetPosition(b, blocks[i].x, blocks[i].y, blocks[i].z);
dGeomSetCategoryBits(b, CAT_WORLD);
dGeomSetCollideBits(b, CAT_PLAYER);
}
// spawn some test pickups
item_spawn(ITEM_MEDKIT, 1, 1.0f, 0.0f, 1.0f);
item_spawn(ITEM_MEDKIT, 1, -2.0f, 0.0f, 3.0f);
item_spawn(ITEM_ARMORPLATE, 1, 3.0f, 0.0f, -1.0f);
item_spawn(ITEM_AMMO_RIFLE, 30, 0.0f, 0.0f, 2.0f);
item_spawn(ITEM_AMMO_PISTOL, 12, -1.0f, 0.0f, -2.0f);
}
static void ode_shutdown_world(void) {
dJointGroupDestroy(gContactGroup);
dSpaceDestroy(gSpace);
dWorldDestroy(gWorld);
dCloseODE();
}
static void player_ode_create(Player *p, int spawnIndex) {
const dReal radius = 0.35;
const dReal length = 1.0;
p->body = dBodyCreate(gWorld);
dMass m;
dMassSetCapsuleTotal(&m, 80.0, 3, radius, length);
dBodySetMass(p->body, &m);
dBodySetLinearDamping(p->body, 0.05);
dBodySetAngularDamping(p->body, 0.99);
dBodySetPosition(p->body, (dReal)(spawnIndex * 2), 2.0, 0.0);
dBodySetAngularVel(p->body, 0, 0, 0);
p->geom = dCreateCapsule(gSpace, radius, length);
dGeomSetBody(p->geom, p->body);
dGeomSetCategoryBits(p->geom, CAT_PLAYER);
dGeomSetCollideBits(p->geom, CAT_WORLD | CAT_PLAYER);
}
static void player_ode_destroy(Player *p) {
if (p->geom) {
dGeomDestroy(p->geom);
p->geom = 0;
}
if (p->body) {
dBodyDestroy(p->body);
p->body = 0;
}
}
// ---- ODE raycast ----
typedef struct RaycastCtx {
dGeomID ray;
dGeomID hitGeom;
dContactGeom hit;
int hasHit;
} RaycastCtx;
static void rayCallback(void *data, dGeomID o1, dGeomID o2) {
RaycastCtx *rc = (RaycastCtx *)data;
dGeomID ray = rc->ray;
dGeomID other = (o1 == ray) ? o2 : o1;
if (other == ray)
return;
dContact c[4];
int n = dCollide(ray, other, 4, &c[0].geom, sizeof(dContact));
for (int i = 0; i < n; i++) {
if (!rc->hasHit || c[i].geom.depth < rc->hit.depth) {
rc->hasHit = 1;
rc->hit = c[i].geom;
rc->hitGeom = other;
}
}
}
static int raycast_space(float ox, float oy, float oz, float dx, float dy,
float dz, float maxDist, dContactGeom *outHit,
dGeomID *outGeom) {
dGeomID ray = dCreateRay(0, maxDist);
dGeomRaySet(ray, ox, oy, oz, dx, dy, dz);
dGeomSetCategoryBits(ray, 0xFFFFFFFFu);
dGeomSetCollideBits(ray, CAT_WORLD | CAT_PLAYER);
RaycastCtx rc = {0};
rc.ray = ray;
dSpaceCollide2(ray, (dGeomID)gSpace, &rc, &rayCallback);
dGeomDestroy(ray);
if (!rc.hasHit)
return 0;
if (outHit)
*outHit = rc.hit;
if (outGeom)
*outGeom = rc.hitGeom;
return 1;
}
// ---- spray math helpers ----
static uint32_t xorshift32(uint32_t *s) {
uint32_t x = *s;
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
*s = x;
return x;
}
static float frand_signed(uint32_t *s) {
return ((xorshift32(s) & 0xFFFFFF) / (float)0x7FFFFF) - 1.0f;
}
static void dir_from_yaw_pitch(float yaw, float pitch, float *dx, float *dy,
float *dz) {
*dx = sinf(yaw) * cosf(pitch);
*dy = sinf(pitch);
*dz = cosf(yaw) * cosf(pitch);
}
static void v3_cross(float ax, float ay, float az, float bx, float by, float bz,
float *ox, float *oy, float *oz) {
*ox = ay * bz - az * by;
*oy = az * bx - ax * bz;
*oz = ax * by - ay * bx;
}
static void v3_normf(float *x, float *y, float *z) {
float l = sqrtf((*x) * (*x) + (*y) * (*y) + (*z) * (*z));
if (l < 1e-6f) {
*x = 0;
*y = 0;
*z = 1;
return;
}
*x /= l;
*y /= l;
*z /= l;
}
static int find_nearest_item(float x, float y, float z, float maxDist) {
int best = -1;
float bestD2 = maxDist * maxDist;
for (int i = 0; i < MAX_ITEMS; i++) {
if (!gItems[i].active)
continue;
float dx = gItems[i].x - x;
float dy = (gItems[i].y + 0.3f) - y;
float dz = gItems[i].z - z;
float d2 = dx * dx + dy * dy + dz * dz;
if (d2 < bestD2) {
bestD2 = d2;
best = i;
}
}
return best;
}
int main(void) {
#ifdef _WIN32
WSADATA wsa;
WSAStartup(MAKEWORD(2, 2), &wsa);
#endif
ode_init_world();
int sock = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0) {
perror("socket");
return 1;
}
set_nonblocking(sock);
struct sockaddr_in srv = {0};
srv.sin_family = AF_INET;
srv.sin_addr.s_addr = htonl(INADDR_ANY);
srv.sin_port = htons(SERVER_PORT);
if (bind(sock, (struct sockaddr *)&srv, sizeof(srv)) < 0) {
perror("bind");
CLOSESOCK(sock);
return 1;
}
Player players[MAX_PLAYERS] = {0};
uint32_t serverTick = 0;
uint32_t itemsTickDiv = 0;
printf("Server listening UDP %d\n", SERVER_PORT);
double nextTick = now_seconds();
for (;;) {
// receive
for (;;) {
uint8_t buf[1400];
struct sockaddr_in from = {0};
socklen_t fromLen = sizeof(from);
int n = (int)recvfrom(sock, (char *)buf, (int)sizeof(buf), 0,
(struct sockaddr *)&from, &fromLen);
if (n <= 0) {
#ifdef _WIN32
if (WSAGetLastError() == WSAEWOULDBLOCK)
break;
#else
if (errno == EWOULDBLOCK || errno == EAGAIN)
break;
#endif
break;
}
uint8_t type = buf[0];
int pid = -1;
for (int i = 0; i < MAX_PLAYERS; i++) {
if (players[i].inUse && addr_equal(&players[i].addr, &from)) {
pid = i;
break;
}
}
if (type == MSG_HELLO && n >= (int)sizeof(MsgHello)) {
const MsgHello *m = (const MsgHello *)buf;
if (m->protocol != PROTOCOL_VERSION)
continue;
if (pid < 0) {
for (int i = 0; i < MAX_PLAYERS; i++)
if (!players[i].inUse) {
pid = i;
Player *p = &players[i];
memset(p, 0, sizeof(*p));
p->inUse = 1;
p->addr = from;
p->lastHeard = now_seconds();
strncpy(p->username, m->username, USERNAME_MAX - 1);
p->alive = 1;
p->hp = 100;
p->armor = 0;
p->weapon = WEAPON_RIFLE;
p->ammoMag[WEAPON_PISTOL] = 12;
p->ammoRes[WEAPON_PISTOL] = 48;
p->ammoMag[WEAPON_RIFLE] = 30;
p->ammoRes[WEAPON_RIFLE] = 90;
for (int sidx = 0; sidx < INV_SLOTS; sidx++) {
p->invType[sidx] = ITEM_NONE;
p->invQty[sidx] = 0;
}
p->lastShotTime = 0.0;
p->shotsInBurst = 0;
p->rng = 0xA341316Cu ^ (uint32_t)(i * 2654435761u);
player_ode_create(p, i);
printf("Player %d joined as '%s'\n", pid, p->username);
break;
}
} else {
players[pid].lastHeard = now_seconds();
}
if (pid >= 0) {
MsgWelcome w = {0};
w.type = MSG_WELCOME;
w.playerId = (uint8_t)pid;
w.serverTick = serverTick;
sendto(sock, (const char *)&w, (int)sizeof(w), 0,
(struct sockaddr *)&from, sizeof(from));
}
} else if (type == MSG_INPUT && n >= (int)sizeof(MsgInput)) {
const MsgInput *m = (const MsgInput *)buf;
if (pid >= 0 && m->playerId == (uint8_t)pid) {
Player *p = &players[pid];
p->lastHeard = now_seconds();
p->moveX = clampf(m->moveX, -1.0f, 1.0f);
p->moveZ = clampf(m->moveZ, -1.0f, 1.0f);
p->yaw = m->yaw;
p->pitch = clampf(m->pitch, -1.5f, 1.5f);
if (m->buttons & BTN_WPN1)
p->weapon = WEAPON_PISTOL;
if (m->buttons & BTN_WPN2)
p->weapon = WEAPON_RIFLE;
// reload
if (m->buttons & BTN_RELOAD) {
int wpn = p->weapon;
int magSize = (wpn == WEAPON_PISTOL) ? 12 : 30;
int need = magSize - p->ammoMag[wpn];
if (need > 0 && p->ammoRes[wpn] > 0) {
int take = (p->ammoRes[wpn] < need) ? p->ammoRes[wpn] : need;
p->ammoRes[wpn] -= take;
p->ammoMag[wpn] += take;
}
}
// pick
if (m->buttons & BTN_PICK) {
const dReal *pos = dBodyGetPosition(p->body);
int itIdx = find_nearest_item((float)pos[0], (float)pos[1] + 0.7f,
(float)pos[2], 1.6f);
if (itIdx >= 0) {
Item *it = &gItems[itIdx];
int taken = 0;
if (it->type == ITEM_AMMO_PISTOL) {
p->ammoRes[WEAPON_PISTOL] += it->qty;
taken = 1;
} else if (it->type == ITEM_AMMO_RIFLE) {
p->ammoRes[WEAPON_RIFLE] += it->qty;
taken = 1;
} else {
taken = inv_add(p, it->type, it->qty);
}
if (taken)
item_destroy(it);
}
}
// drop selected slot
if (m->buttons & BTN_DROP) {
int slot = (m->slotIndex < INV_SLOTS) ? (int)m->slotIndex : 0;
uint8_t t = p->invType[slot];
if (t != ITEM_NONE && p->invQty[slot] > 0) {
const dReal *pos = dBodyGetPosition(p->body);
float ox = (float)pos[0];
float oy = (float)pos[1];
float oz = (float)pos[2];
// drop 1 unit
if (inv_remove_one(p, slot)) {
item_spawn(t, 1, ox, oy, oz);
}
}
}
// use selected slot (medkit/armor plate)
if (m->buttons & BTN_USE) {
int slot = (m->slotIndex < INV_SLOTS) ? (int)m->slotIndex : 0;
uint8_t t = p->invType[slot];
if (t == ITEM_MEDKIT && p->hp < 100 && p->invQty[slot] > 0) {
inv_remove_one(p, slot);
p->hp += 25;
if (p->hp > 100)
p->hp = 100;
} else if (t == ITEM_ARMORPLATE && p->armor < 100 &&
p->invQty[slot] > 0) {
inv_remove_one(p, slot);
p->armor += 25;
if (p->armor > 100)
p->armor = 100;
}
}
}
} else if (type == MSG_SHOOT && n >= (int)sizeof(MsgShoot)) {
const MsgShoot *m = (const MsgShoot *)buf;
if (pid >= 0 && m->playerId == (uint8_t)pid && players[pid].inUse &&
players[pid].alive) {
Player *sh = &players[pid];
const double now = now_seconds();
double fireInterval =
(sh->weapon == WEAPON_PISTOL) ? (1.0 / 4.0) : (1.0 / 12.0);
if (now - sh->lastShotTime < fireInterval)
continue;
if (now - sh->lastShotTime > 0.18)
sh->shotsInBurst = 0;
int wpn = sh->weapon;
if (sh->ammoMag[wpn] <= 0)
continue;
sh->ammoMag[wpn]--;
sh->shotsInBurst++;
sh->lastShotTime = now;
const dReal *pos = dBodyGetPosition(sh->body);
float ox = (float)pos[0];
float oy = (float)pos[1] + 0.7f;
float oz = (float)pos[2];
float fx, fy, fz;
dir_from_yaw_pitch(sh->yaw, sh->pitch, &fx, &fy, &fz);
v3_normf(&fx, &fy, &fz);
float base = (wpn == WEAPON_PISTOL) ? 0.0035f : 0.0080f;
float grow = (wpn == WEAPON_PISTOL) ? 0.0010f : 0.0025f;
float spread = base + grow * (float)sh->shotsInBurst;
if (spread > 0.08f)
spread = 0.08f;
float upx = 0, upy = 1, upz = 0;
float rx, ry, rz;
v3_cross(fx, fy, fz, upx, upy, upz, &rx, &ry, &rz);
v3_normf(&rx, &ry, &rz);
float ux, uy, uz;
v3_cross(rx, ry, rz, fx, fy, fz, &ux, &uy, &uz);
v3_normf(&ux, &uy, &uz);
float ax = frand_signed(&sh->rng) * spread;
float ay = frand_signed(&sh->rng) * spread;
float dx = fx + rx * ax + ux * ay;
float dy = fy + ry * ax + uy * ay;
float dz = fz + rz * ax + uz * ay;
v3_normf(&dx, &dy, &dz);
dContactGeom hit;
dGeomID hitGeom = 0;
if (raycast_space(ox, oy, oz, dx, dy, dz, 80.0f, &hit, &hitGeom)) {
int victim = -1;
for (int i = 0; i < MAX_PLAYERS; i++) {
if (!players[i].inUse)
continue;
if (players[i].geom == hitGeom) {
victim = i;
break;
}
}
if (victim >= 0 && victim != pid && players[victim].alive) {
int dmg = 25;
// armor absorbs first (simple model)
int absorb =
(players[victim].armor < dmg) ? players[victim].armor : dmg;
players[victim].armor -= absorb;
dmg -= absorb;
players[victim].hp -= dmg;
if (players[victim].hp <= 0) {
players[victim].hp = 0;
players[victim].alive = 0;
}
MsgHit ev = {0};
ev.type = MSG_HIT;
ev.shooterId = (uint8_t)pid;
ev.victimId = (uint8_t)victim;
ev.victimHp = (int16_t)players[victim].hp;
broadcast(sock, players, &ev, (int)sizeof(ev));
}
}
}
}
}
// fixed tick
double t = now_seconds();
if (t < nextTick) {
#ifdef _WIN32
Sleep(1);
#else
struct timespec ts = {0, 1000000};
nanosleep(&ts, NULL);
#endif
continue;
}
nextTick += (1.0 / (double)TICK_HZ);
serverTick++;
// timeouts + movement
const float speed = 6.0f;
for (int i = 0; i < MAX_PLAYERS; i++) {
Player *p = &players[i];
if (!p->inUse)
continue;
if (now_seconds() - p->lastHeard > 10.0) {
printf("Player %d timed out\n", i);
player_ode_destroy(p);
memset(p, 0, sizeof(*p));
continue;
}
if (!p->alive) {
dBodySetLinearVel(p->body, 0, 0, 0);
continue;
}
float cy = cosf(p->yaw), sy = sinf(p->yaw);
float fwdx = sy, fwdz = cy;
float rgtx = cy, rgtz = -sy;
float vx = (fwdx * p->moveZ + rgtx * p->moveX) * speed;
float vz = (fwdz * p->moveZ + rgtz * p->moveX) * speed;
const dReal *vcur = dBodyGetLinearVel(p->body);
dBodySetLinearVel(p->body, vx, vcur[1], vz);
dQuaternion q;
dQFromAxisAndAngle(q, 0, 1, 0, p->yaw);
dBodySetQuaternion(p->body, q);
dBodySetAngularVel(p->body, 0, 0, 0);
}
// step ODE
dJointGroupEmpty(gContactGroup);
dSpaceCollide(gSpace, 0, &nearCallback);
dWorldQuickStep(gWorld, DT);
// snapshot players
MsgSnapshot snap = {0};
snap.type = MSG_SNAPSHOT;
snap.serverTick = serverTick;
snap.count = 0;
for (int i = 0; i < MAX_PLAYERS; i++) {
if (!players[i].inUse)
continue;
const dReal *pos = dBodyGetPosition(players[i].body);
PlayerStateNet *ps = &snap.p[snap.count++];
ps->id = (uint8_t)i;
ps->alive = (uint8_t)players[i].alive;
ps->hp = (int16_t)players[i].hp;
ps->armor = (int16_t)players[i].armor;
ps->x = (float)pos[0];
ps->y = (float)pos[1];
ps->z = (float)pos[2];
ps->yaw = players[i].yaw;
ps->pitch = players[i].pitch;
ps->weapon = (uint8_t)players[i].weapon;
for (int w = 0; w < WEAPON_COUNT; w++) {
ps->ammoMag[w] = (int16_t)players[i].ammoMag[w];
ps->ammoRes[w] = (int16_t)players[i].ammoRes[w];
}
for (int sidx = 0; sidx < INV_SLOTS; sidx++) {
ps->invType[sidx] = players[i].invType[sidx];
ps->invQty[sidx] = (int16_t)players[i].invQty[sidx];
}
memset(ps->username, 0, USERNAME_MAX);
strncpy(ps->username, players[i].username, USERNAME_MAX - 1);
}
broadcast(sock, players, &snap, (int)sizeof(MsgSnapshot));
// broadcast items at ~10Hz
itemsTickDiv++;
if (itemsTickDiv >= 6) {
itemsTickDiv = 0;
MsgItems im = {0};
im.type = MSG_ITEMS;
im.serverTick = serverTick;
im.count = 0;
for (int i = 0; i < MAX_ITEMS && im.count < MAX_ITEMS; i++) {
if (!gItems[i].active)
continue;
ItemNet *on = &im.items[im.count++];
on->id = gItems[i].id;
on->type = gItems[i].type;
on->qty = (int16_t)gItems[i].qty;
on->x = gItems[i].x;
on->y = gItems[i].y;
on->z = gItems[i].z;
}
broadcast(sock, players, &im, (int)sizeof(MsgItems));
}
}
CLOSESOCK(sock);
ode_shutdown_world();
#ifdef _WIN32
WSACleanup();
#endif
return 0;
}
Reference in a new issue View git blame Copy permalink