![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to server.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quakeworld / server|
Return to server.h CVS log | Up to [Quake] / quakeworld / server |
1.1 root 1: /*
2: Copyright (C) 1996-1997 Id Software, Inc.
3:
4: This program is free software; you can redistribute it and/or
5: modify it under the terms of the GNU General Public License
6: as published by the Free Software Foundation; either version 2
7: of the License, or (at your option) any later version.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12:
13: See the GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; if not, write to the Free Software
17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18:
19: */
20: // server.h
21:
22: #define QW_SERVER
23:
24: #define MAX_MASTERS 8 // max recipients for heartbeat packets
25:
26: #define MAX_SIGNON_BUFFERS 8
27:
28: typedef enum {
29: ss_dead, // no map loaded
30: ss_loading, // spawning level edicts
31: ss_active // actively running
32: } server_state_t;
33: // some qc commands are only valid before the server has finished
34: // initializing (precache commands, static sounds / objects, etc)
35:
36: typedef struct
37: {
38: qboolean active; // false when server is going down
39: server_state_t state; // precache commands are only valid during load
40:
41: double time;
42:
43: int lastcheck; // used by PF_checkclient
44: double lastchecktime; // for monster ai
45:
46: qboolean paused; // are we paused?
47:
48: //check player/eyes models for hacks
49: unsigned model_player_checksum;
50: unsigned eyes_player_checksum;
51:
52: char name[64]; // map name
53: char modelname[MAX_QPATH]; // maps/<name>.bsp, for model_precache[0]
54: struct model_s *worldmodel;
55: char *model_precache[MAX_MODELS]; // NULL terminated
56: char *sound_precache[MAX_SOUNDS]; // NULL terminated
57: char *lightstyles[MAX_LIGHTSTYLES];
58: struct model_s *models[MAX_MODELS];
59:
60: int num_edicts; // increases towards MAX_EDICTS
61: edict_t *edicts; // can NOT be array indexed, because
62: // edict_t is variable sized, but can
63: // be used to reference the world ent
64:
65: byte *pvs, *phs; // fully expanded and decompressed
66:
67: // added to every client's unreliable buffer each frame, then cleared
68: sizebuf_t datagram;
69: byte datagram_buf[MAX_DATAGRAM];
70:
71: // added to every client's reliable buffer each frame, then cleared
72: sizebuf_t reliable_datagram;
73: byte reliable_datagram_buf[MAX_MSGLEN];
74:
75: // the multicast buffer is used to send a message to a set of clients
76: sizebuf_t multicast;
77: byte multicast_buf[MAX_MSGLEN];
78:
79: // the master buffer is used for building log packets
80: sizebuf_t master;
81: byte master_buf[MAX_DATAGRAM];
82:
83: // the signon buffer will be sent to each client as they connect
84: // includes the entity baselines, the static entities, etc
85: // large levels will have >MAX_DATAGRAM sized signons, so
86: // multiple signon messages are kept
87: sizebuf_t signon;
88: int num_signon_buffers;
89: int signon_buffer_size[MAX_SIGNON_BUFFERS];
90: byte signon_buffers[MAX_SIGNON_BUFFERS][MAX_DATAGRAM];
91: } server_t;
92:
93:
94: #define NUM_SPAWN_PARMS 16
95:
96: typedef enum
97: {
98: cs_free, // can be reused for a new connection
99: cs_zombie, // client has been disconnected, but don't reuse
100: // connection for a couple seconds
101: cs_connected, // has been assigned to a client_t, but not in game yet
102: cs_spawned // client is fully in game
103: } client_state_t;
104:
105: typedef struct
106: {
107: // received from client
108:
109: // reply
110: double senttime;
111: float ping_time;
112: packet_entities_t entities;
113: } client_frame_t;
114:
115: #define MAX_BACK_BUFFERS 4
116:
117: typedef struct client_s
118: {
119: client_state_t state;
120:
121: int spectator; // non-interactive
122:
123: qboolean sendinfo; // at end of frame, send info to all
124: // this prevents malicious multiple broadcasts
125: float lastnametime; // time of last name change
126: int lastnamecount; // time of last name change
127: unsigned checksum; // checksum for calcs
128: qboolean drop; // lose this guy next opportunity
129: int lossage; // loss percentage
130:
131: int userid; // identifying number
132: char userinfo[MAX_INFO_STRING]; // infostring
133:
134: usercmd_t lastcmd; // for filling in big drops and partial predictions
135: double localtime; // of last message
136: int oldbuttons;
137:
138: float maxspeed; // localized maxspeed
139: float entgravity; // localized ent gravity
140:
141: edict_t *edict; // EDICT_NUM(clientnum+1)
142: char name[32]; // for printing to other people
143: // extracted from userinfo
144: int messagelevel; // for filtering printed messages
145:
146: // the datagram is written to after every frame, but only cleared
147: // when it is sent out to the client. overflow is tolerated.
148: sizebuf_t datagram;
149: byte datagram_buf[MAX_DATAGRAM];
150:
151: // back buffers for client reliable data
152: sizebuf_t backbuf;
153: int num_backbuf;
154: int backbuf_size[MAX_BACK_BUFFERS];
155: byte backbuf_data[MAX_BACK_BUFFERS][MAX_MSGLEN];
156:
157: double connection_started; // or time of disconnect for zombies
158: qboolean send_message; // set on frames a datagram arived on
159:
160: // spawn parms are carried from level to level
161: float spawn_parms[NUM_SPAWN_PARMS];
162:
163: // client known data for deltas
164: int old_frags;
165:
166: int stats[MAX_CL_STATS];
167:
168:
169: client_frame_t frames[UPDATE_BACKUP]; // updates can be deltad from here
170:
171: FILE *download; // file being downloaded
172: int downloadsize; // total bytes
173: int downloadcount; // bytes sent
174:
175: int spec_track; // entnum of player tracking
176:
177: double whensaid[10]; // JACK: For floodprots
178: int whensaidhead; // Head value for floodprots
179: double lockedtill;
180:
181: qboolean upgradewarn; // did we warn him?
182:
183: FILE *upload;
184: char uploadfn[MAX_QPATH];
185: netadr_t snap_from;
186: qboolean remote_snap;
187:
188: //===== NETWORK ============
189: int chokecount;
190: int delta_sequence; // -1 = no compression
191: netchan_t netchan;
192: } client_t;
193:
194: // a client can leave the server in one of four ways:
195: // dropping properly by quiting or disconnecting
196: // timing out if no valid messages are received for timeout.value seconds
197: // getting kicked off by the server operator
198: // a program error, like an overflowed reliable buffer
199:
200: //=============================================================================
201:
202:
203: #define STATFRAMES 100
204: typedef struct
205: {
206: double active;
207: double idle;
208: int count;
209: int packets;
210:
211: double latched_active;
212: double latched_idle;
213: int latched_packets;
214: } svstats_t;
215:
216: // MAX_CHALLENGES is made large to prevent a denial
217: // of service attack that could cycle all of them
218: // out before legitimate users connected
219: #define MAX_CHALLENGES 1024
220:
221: typedef struct
222: {
223: netadr_t adr;
224: int challenge;
225: int time;
226: } challenge_t;
227:
228: typedef struct
229: {
230: int spawncount; // number of servers spawned since start,
231: // used to check late spawns
232: client_t clients[MAX_CLIENTS];
233: int serverflags; // episode completion information
234:
235: double last_heartbeat;
236: int heartbeat_sequence;
237: svstats_t stats;
238:
239: char info[MAX_SERVERINFO_STRING];
240:
241: // log messages are used so that fraglog processes can get stats
242: int logsequence; // the message currently being filled
243: double logtime; // time of last swap
244: sizebuf_t log[2];
245: byte log_buf[2][MAX_DATAGRAM];
246:
247: challenge_t challenges[MAX_CHALLENGES]; // to prevent invalid IPs from connecting
248: } server_static_t;
249:
250: //=============================================================================
251:
252: // edict->movetype values
253: #define MOVETYPE_NONE 0 // never moves
254: #define MOVETYPE_ANGLENOCLIP 1
255: #define MOVETYPE_ANGLECLIP 2
256: #define MOVETYPE_WALK 3 // gravity
257: #define MOVETYPE_STEP 4 // gravity, special edge handling
258: #define MOVETYPE_FLY 5
259: #define MOVETYPE_TOSS 6 // gravity
260: #define MOVETYPE_PUSH 7 // no clip to world, push and crush
261: #define MOVETYPE_NOCLIP 8
262: #define MOVETYPE_FLYMISSILE 9 // extra size to monsters
263: #define MOVETYPE_BOUNCE 10
264:
265: // edict->solid values
266: #define SOLID_NOT 0 // no interaction with other objects
267: #define SOLID_TRIGGER 1 // touch on edge, but not blocking
268: #define SOLID_BBOX 2 // touch on edge, block
269: #define SOLID_SLIDEBOX 3 // touch on edge, but not an onground
270: #define SOLID_BSP 4 // bsp clip, touch on edge, block
271:
272: // edict->deadflag values
273: #define DEAD_NO 0
274: #define DEAD_DYING 1
275: #define DEAD_DEAD 2
276:
277: #define DAMAGE_NO 0
278: #define DAMAGE_YES 1
279: #define DAMAGE_AIM 2
280:
281: // edict->flags
282: #define FL_FLY 1
283: #define FL_SWIM 2
284: #define FL_GLIMPSE 4
285: #define FL_CLIENT 8
286: #define FL_INWATER 16
287: #define FL_MONSTER 32
288: #define FL_GODMODE 64
289: #define FL_NOTARGET 128
290: #define FL_ITEM 256
291: #define FL_ONGROUND 512
292: #define FL_PARTIALGROUND 1024 // not all corners are valid
293: #define FL_WATERJUMP 2048 // player jumping out of water
294:
295: // entity effects
296:
297: //define EF_BRIGHTFIELD 1
298: //define EF_MUZZLEFLASH 2
299: #define EF_BRIGHTLIGHT 4
300: #define EF_DIMLIGHT 8
301:
302:
303: #define SPAWNFLAG_NOT_EASY 256
304: #define SPAWNFLAG_NOT_MEDIUM 512
305: #define SPAWNFLAG_NOT_HARD 1024
306: #define SPAWNFLAG_NOT_DEATHMATCH 2048
307:
308: #define MULTICAST_ALL 0
309: #define MULTICAST_PHS 1
310: #define MULTICAST_PVS 2
311:
312: #define MULTICAST_ALL_R 3
313: #define MULTICAST_PHS_R 4
314: #define MULTICAST_PVS_R 5
315:
316: //============================================================================
317:
318: extern cvar_t sv_mintic, sv_maxtic;
319: extern cvar_t sv_maxspeed;
320:
321: extern netadr_t master_adr[MAX_MASTERS]; // address of the master server
322:
323: extern cvar_t spawn;
324: extern cvar_t teamplay;
325: extern cvar_t deathmatch;
326: extern cvar_t fraglimit;
327: extern cvar_t timelimit;
328:
329: extern server_static_t svs; // persistant server info
330: extern server_t sv; // local server
331:
332: extern client_t *host_client;
333:
334: extern edict_t *sv_player;
335:
336: extern char localmodels[MAX_MODELS][5]; // inline model names for precache
337:
338: extern char localinfo[MAX_LOCALINFO_STRING+1];
339:
340: extern int host_hunklevel;
341: extern FILE *sv_logfile;
342: extern FILE *sv_fraglogfile;
343:
344: //===========================================================
345:
346: //
347: // sv_main.c
348: //
349: void SV_Shutdown (void);
350: void SV_Frame (float time);
351: void SV_FinalMessage (char *message);
352: void SV_DropClient (client_t *drop);
353:
354: int SV_CalcPing (client_t *cl);
355: void SV_FullClientUpdate (client_t *client, sizebuf_t *buf);
356:
357: int SV_ModelIndex (char *name);
358:
359: qboolean SV_CheckBottom (edict_t *ent);
360: qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink);
361:
362: void SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg);
363:
364: void SV_MoveToGoal (void);
365:
366: void SV_SaveSpawnparms (void);
367:
368: void SV_Physics_Client (edict_t *ent);
369:
370: void SV_ExecuteUserCommand (char *s);
371: void SV_InitOperatorCommands (void);
372:
373: void SV_SendServerinfo (client_t *client);
374: void SV_ExtractFromUserinfo (client_t *cl);
375:
376:
377: void Master_Heartbeat (void);
378: void Master_Packet (void);
379:
380: //
381: // sv_init.c
382: //
383: void SV_SpawnServer (char *server);
384: void SV_FlushSignon (void);
385:
386:
387: //
388: // sv_phys.c
389: //
390: void SV_ProgStartFrame (void);
391: void SV_Physics (void);
392: void SV_CheckVelocity (edict_t *ent);
393: void SV_AddGravity (edict_t *ent, float scale);
394: qboolean SV_RunThink (edict_t *ent);
395: void SV_Physics_Toss (edict_t *ent);
396: void SV_RunNewmis (void);
397: void SV_Impact (edict_t *e1, edict_t *e2);
398: void SV_SetMoveVars(void);
399:
400: //
401: // sv_send.c
402: //
403: void SV_SendClientMessages (void);
404:
405: void SV_Multicast (vec3_t origin, int to);
406: void SV_StartSound (edict_t *entity, int channel, char *sample, int volume,
407: float attenuation);
408: void SV_ClientPrintf (client_t *cl, int level, char *fmt, ...);
409: void SV_BroadcastPrintf (int level, char *fmt, ...);
410: void SV_BroadcastCommand (char *fmt, ...);
411: void SV_SendMessagesToAll (void);
412: void SV_FindModelNumbers (void);
413:
414: //
415: // sv_user.c
416: //
417: void SV_ExecuteClientMessage (client_t *cl);
418: void SV_UserInit (void);
419: void SV_TogglePause (const char *msg);
420:
421:
422: //
423: // svonly.c
424: //
425: typedef enum {RD_NONE, RD_CLIENT, RD_PACKET} redirect_t;
426: void SV_BeginRedirect (redirect_t rd);
427: void SV_EndRedirect (void);
428:
429: //
430: // sv_ccmds.c
431: //
432: void SV_Status_f (void);
433:
434: //
435: // sv_ents.c
436: //
437: void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg);
438:
439: //
440: // sv_nchan.c
441: //
442:
443: void ClientReliableCheckBlock(client_t *cl, int maxsize);
444: void ClientReliable_FinishWrite(client_t *cl);
445: void ClientReliableWrite_Begin(client_t *cl, int c, int maxsize);
446: void ClientReliableWrite_Angle(client_t *cl, float f);
447: void ClientReliableWrite_Angle16(client_t *cl, float f);
448: void ClientReliableWrite_Byte(client_t *cl, int c);
449: void ClientReliableWrite_Char(client_t *cl, int c);
450: void ClientReliableWrite_Float(client_t *cl, float f);
451: void ClientReliableWrite_Coord(client_t *cl, float f);
452: void ClientReliableWrite_Long(client_t *cl, int c);
453: void ClientReliableWrite_Short(client_t *cl, int c);
454: void ClientReliableWrite_String(client_t *cl, char *s);
455: void ClientReliableWrite_SZ(client_t *cl, void *data, int len);
456:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.