![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to common.c.org CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / qcommon|
Return to common.c.org CVS log | Up to [Quake II] / quake2 / qcommon |
1.1 root 1: // common.c -- misc functions used in client and server
2: #include "qcommon.h"
3: #include <setjmp.h>
4:
5: #define MAXPRINTMSG 4096
6:
7: #define MAX_NUM_ARGVS 50
8:
9:
10: int com_argc;
11: char *com_argv[MAX_NUM_ARGVS+1];
12:
13: int realtime;
14:
15: jmp_buf abortframe; // an ERR_DROP occured, exit the entire frame
16:
17:
18: FILE *log_stats_file;
19:
20: cvar_t *host_speeds;
21: cvar_t *log_stats;
22: cvar_t *developer;
23: cvar_t *timescale;
24: cvar_t *fixedtime;
25: cvar_t *logfile_active; // 1 = buffer log, 2 = flush after each print
26: cvar_t *showtrace;
27: cvar_t *dedicated;
28:
29: FILE *logfile;
30:
31: int server_state;
32:
33: // host_speeds times
34: int time_before_game;
35: int time_after_game;
36: int time_before_ref;
37: int time_after_ref;
38:
39: /*
40: ============================================================================
41:
42: CLIENT / SERVER interactions
43:
44: ============================================================================
45: */
46:
47: static int rd_target;
48: static char *rd_buffer;
49: static int rd_buffersize;
50: static void (*rd_flush)(int target, char *buffer);
51:
52: void Com_BeginRedirect (int target, char *buffer, int buffersize, void (*flush))
53: {
54: if (!target || !buffer || !buffersize || !flush)
55: return;
56: rd_target = target;
57: rd_buffer = buffer;
58: rd_buffersize = buffersize;
59: rd_flush = flush;
60:
61: *rd_buffer = 0;
62: }
63:
64: void Com_EndRedirect (void)
65: {
66: rd_flush(rd_target, rd_buffer);
67:
68: rd_target = 0;
69: rd_buffer = NULL;
70: rd_buffersize = 0;
71: rd_flush = NULL;
72: }
73:
74: /*
75: =============
76: Com_Printf
77:
78: Both client and server can use this, and it will output
79: to the apropriate place.
80: =============
81: */
82: void Com_Printf (char *fmt, ...)
83: {
84: va_list argptr;
85: char msg[MAXPRINTMSG];
86:
87: va_start (argptr,fmt);
88: vsprintf (msg,fmt,argptr);
89: va_end (argptr);
90:
91: if (rd_target)
92: {
93: if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1))
94: {
95: rd_flush(rd_target, rd_buffer);
96: *rd_buffer = 0;
97: }
98: strcat (rd_buffer, msg);
99: return;
100: }
101:
102: Con_Print (msg);
103:
104: // also echo to debugging console
105: Sys_ConsoleOutput (msg);
106:
107: // logfile
108: if (logfile_active && logfile_active->value)
109: {
110: char name[MAX_QPATH];
111:
112: if (!logfile)
113: {
114: Com_sprintf (name, sizeof(name), "%s/qconsole.log", FS_Gamedir ());
115: logfile = fopen (name, "w");
116: }
117: if (logfile)
118: fprintf (logfile, "%s", msg);
119: if (logfile_active->value > 1)
120: fflush (logfile); // force it to save every time
121: }
122: }
123:
124:
125: /*
126: ================
127: Com_DPrintf
128:
129: A Com_Printf that only shows up if the "developer" cvar is set
130: ================
131: */
132: void Com_DPrintf (char *fmt, ...)
133: {
134: va_list argptr;
135: char msg[MAXPRINTMSG];
136:
137: if (!developer || !developer->value)
138: return; // don't confuse non-developers with techie stuff...
139:
140: va_start (argptr,fmt);
141: vsprintf (msg,fmt,argptr);
142: va_end (argptr);
143:
144: Com_Printf ("%s", msg);
145: }
146:
147:
148: /*
149: =============
150: Com_Error
151:
152: Both client and server can use this, and it will
153: do the apropriate things.
154: =============
155: */
156: void Com_Error (int code, char *fmt, ...)
157: {
158: va_list argptr;
159: static char msg[MAXPRINTMSG];
160: static qboolean recursive;
161:
162: if (recursive)
163: Sys_Error ("recursive error after: %s", msg);
164: recursive = true;
165:
166: va_start (argptr,fmt);
167: vsprintf (msg,fmt,argptr);
168: va_end (argptr);
169:
170: if (code == ERR_DISCONNECT)
171: {
172: CL_Drop ();
173: recursive = false;
174: longjmp (abortframe, -1);
175: }
176: else if (code == ERR_DROP)
177: {
178: Com_Printf ("********************\nERROR: %s\n********************\n", msg);
179: SV_Shutdown (va("Server crashed: %s\n", msg), false);
180: CL_Drop ();
181: recursive = false;
182: longjmp (abortframe, -1);
183: }
184: else
185: {
186: SV_Shutdown (va("Server fatal crashed: %s\n", msg), false);
187: CL_Shutdown ();
188: }
189:
190: if (logfile)
191: {
192: fclose (logfile);
193: logfile = NULL;
194: }
195:
196: Sys_Error ("%s", msg);
197: }
198:
199:
200: /*
201: =============
202: Com_Quit
203:
204: Both client and server can use this, and it will
205: do the apropriate things.
206: =============
207: */
208: void Com_Quit (void)
209: {
210: SV_Shutdown ("Server quit\n", false);
211: CL_Shutdown ();
212:
213: if (logfile)
214: {
215: fclose (logfile);
216: logfile = NULL;
217: }
218:
219: Sys_Quit ();
220: }
221:
222:
223: /*
224: ==================
225: Com_ServerState
226: ==================
227: */
228: int Com_ServerState (void)
229: {
230: return server_state;
231: }
232:
233: /*
234: ==================
235: Com_SetServerState
236: ==================
237: */
238: void Com_SetServerState (int state)
239: {
240: server_state = state;
241: }
242:
243:
244: /*
245: ==============================================================================
246:
247: MESSAGE IO FUNCTIONS
248:
249: Handles byte ordering and avoids alignment errors
250: ==============================================================================
251: */
252:
253: vec3_t bytedirs[NUMVERTEXNORMALS] =
254: {
255: #include "../client/anorms.h"
256: };
257:
258: //
259: // writing functions
260: //
261:
262: void MSG_WriteChar (sizebuf_t *sb, int c)
263: {
264: byte *buf;
265:
266: #ifdef PARANOID
267: if (c < -128 || c > 127)
268: Com_Error (ERR_FATAL, "MSG_WriteChar: range error");
269: #endif
270:
271: buf = SZ_GetSpace (sb, 1);
272: buf[0] = c;
273: }
274:
275: void MSG_WriteByte (sizebuf_t *sb, int c)
276: {
277: byte *buf;
278:
279: #ifdef PARANOID
280: if (c < 0 || c > 255)
281: Com_Error (ERR_FATAL, "MSG_WriteByte: range error");
282: #endif
283:
284: buf = SZ_GetSpace (sb, 1);
285: buf[0] = c;
286: }
287:
288: void MSG_WriteShort (sizebuf_t *sb, int c)
289: {
290: byte *buf;
291:
292: #ifdef PARANOID
293: if (c < ((short)0x8000) || c > (short)0x7fff)
294: Com_Error (ERR_FATAL, "MSG_WriteShort: range error");
295: #endif
296:
297: buf = SZ_GetSpace (sb, 2);
298: buf[0] = c&0xff;
299: buf[1] = c>>8;
300: }
301:
302: void MSG_WriteLong (sizebuf_t *sb, int c)
303: {
304: byte *buf;
305:
306: buf = SZ_GetSpace (sb, 4);
307: buf[0] = c&0xff;
308: buf[1] = (c>>8)&0xff;
309: buf[2] = (c>>16)&0xff;
310: buf[3] = c>>24;
311: }
312:
313: void MSG_WriteFloat (sizebuf_t *sb, float f)
314: {
315: union
316: {
317: float f;
318: int l;
319: } dat;
320:
321:
322: dat.f = f;
323: dat.l = LittleLong (dat.l);
324:
325: SZ_Write (sb, &dat.l, 4);
326: }
327:
328: void MSG_WriteString (sizebuf_t *sb, char *s)
329: {
330: if (!s)
331: SZ_Write (sb, "", 1);
332: else
333: SZ_Write (sb, s, strlen(s)+1);
334: }
335:
336: void MSG_WriteCoord (sizebuf_t *sb, float f)
337: {
338: MSG_WriteShort (sb, (int)(f*8));
339: }
340:
341: void MSG_WritePos (sizebuf_t *sb, vec3_t pos)
342: {
343: MSG_WriteShort (sb, (int)(pos[0]*8));
344: MSG_WriteShort (sb, (int)(pos[1]*8));
345: MSG_WriteShort (sb, (int)(pos[2]*8));
346: }
347:
348: void MSG_WriteAngle (sizebuf_t *sb, float f)
349: {
350: MSG_WriteByte (sb, (int)(f*256/360) & 255);
351: }
352:
353: void MSG_WriteAngle16 (sizebuf_t *sb, float f)
354: {
355: MSG_WriteShort (sb, ANGLE2SHORT(f));
356: }
357:
358:
359: void MSG_WriteDeltaUsercmd (sizebuf_t *buf, usercmd_t *from, usercmd_t *cmd)
360: {
361: int bits;
362:
363: //
364: // send the movement message
365: //
366: bits = 0;
367: if (cmd->angles[0] != from->angles[0])
368: bits |= CM_ANGLE1;
369: if (cmd->angles[1] != from->angles[1])
370: bits |= CM_ANGLE2;
371: if (cmd->angles[2] != from->angles[2])
372: bits |= CM_ANGLE3;
373: if (cmd->forwardmove != from->forwardmove)
374: bits |= CM_FORWARD;
375: if (cmd->sidemove != from->sidemove)
376: bits |= CM_SIDE;
377: if (cmd->upmove != from->upmove)
378: bits |= CM_UP;
379: if (cmd->buttons != from->buttons)
380: bits |= CM_BUTTONS;
381: if (cmd->impulse != from->impulse)
382: bits |= CM_IMPULSE;
383:
384: MSG_WriteByte (buf, bits);
385:
386: if (bits & CM_ANGLE1)
387: MSG_WriteShort (buf, cmd->angles[0]);
388: if (bits & CM_ANGLE2)
389: MSG_WriteShort (buf, cmd->angles[1]);
390: if (bits & CM_ANGLE3)
391: MSG_WriteShort (buf, cmd->angles[2]);
392:
393: if (bits & CM_FORWARD)
394: MSG_WriteShort (buf, cmd->forwardmove);
395: if (bits & CM_SIDE)
396: MSG_WriteShort (buf, cmd->sidemove);
397: if (bits & CM_UP)
398: MSG_WriteShort (buf, cmd->upmove);
399:
400: if (bits & CM_BUTTONS)
401: MSG_WriteByte (buf, cmd->buttons);
402: if (bits & CM_IMPULSE)
403: MSG_WriteByte (buf, cmd->impulse);
404:
405: MSG_WriteByte (buf, cmd->msec);
406: MSG_WriteByte (buf, cmd->lightlevel);
407: }
408:
409:
410: void MSG_WriteDir (sizebuf_t *sb, vec3_t dir)
411: {
412: int i, best;
413: float d, bestd;
414:
415: if (!dir)
416: {
417: MSG_WriteByte (sb, 0);
418: return;
419: }
420:
421: bestd = 0;
422: best = 0;
423: for (i=0 ; i<NUMVERTEXNORMALS ; i++)
424: {
425: d = DotProduct (dir, bytedirs[i]);
426: if (d > bestd)
427: {
428: bestd = d;
429: best = i;
430: }
431: }
432: MSG_WriteByte (sb, best);
433: }
434:
435:
436: void MSG_ReadDir (sizebuf_t *sb, vec3_t dir)
437: {
438: int b;
439:
440: b = MSG_ReadByte (sb);
441: if (b >= NUMVERTEXNORMALS)
442: Com_Error (ERR_DROP, "MSF_ReadDir: out of range");
443: VectorCopy (bytedirs[b], dir);
444: }
445:
446:
447: /*
448: ==================
449: MSG_WriteDeltaEntity
450:
451: Writes part of a packetentities message.
452: Can delta from either a baseline or a previous packet_entity
453: ==================
454: */
455: void MSG_WriteDeltaEntity (entity_state_t *from, entity_state_t *to, sizebuf_t *msg, qboolean force)
456: {
457: int bits;
458:
459: if (!to->number)
460: Com_Error (ERR_FATAL, "Unset entity number");
461: if (to->number >= MAX_EDICTS)
462: Com_Error (ERR_FATAL, "Entity number >= MAX_EDICTS");
463:
464: // send an update
465: bits = 0;
466:
467: if (to->number >= 256)
468: bits |= U_NUMBER16; // number8 is implicit otherwise
469:
470: if (to->origin[0] != from->origin[0])
471: bits |= U_ORIGIN1;
472: if (to->origin[1] != from->origin[1])
473: bits |= U_ORIGIN2;
474: if (to->origin[2] != from->origin[2])
475: bits |= U_ORIGIN3;
476:
477: if ( to->angles[0] != from->angles[0] )
478: bits |= U_ANGLE1;
479: if ( to->angles[1] != from->angles[1] )
480: bits |= U_ANGLE2;
481: if ( to->angles[2] != from->angles[2] )
482: bits |= U_ANGLE3;
483:
484: if ( to->skinnum != from->skinnum )
485: {
486: if ((unsigned)to->skinnum < 256)
487: bits |= U_SKIN8;
488: else if ((unsigned)to->skinnum < 0x10000)
489: bits |= U_SKIN16;
490: else
491: bits |= (U_SKIN8|U_SKIN16);
492: }
493:
494: if ( to->frame != from->frame )
495: {
496: if (to->frame < 256)
497: bits |= U_FRAME8;
498: else
499: bits |= U_FRAME16;
500: }
501:
502: if ( to->effects != from->effects )
503: {
504: if (to->effects < 256)
505: bits |= U_EFFECTS8;
506: else if (to->effects < 0x8000)
507: bits |= U_EFFECTS16;
508: else
509: bits |= U_EFFECTS8|U_EFFECTS16;
510: }
511:
512: if ( to->renderfx != from->renderfx )
513: {
514: if (to->renderfx < 256)
515: bits |= U_RENDERFX8;
516: else if (to->renderfx < 0x8000)
517: bits |= U_RENDERFX16;
518: else
519: bits |= U_RENDERFX8|U_RENDERFX16;
520: }
521:
522: if ( to->solid != from->solid )
523: bits |= U_SOLID;
524:
525: // event is not delta compressed, just 0 compressed
526: if ( to->event )
527: bits |= U_EVENT;
528:
529: if ( to->modelindex != from->modelindex )
530: bits |= U_MODEL;
531: if ( to->modelindex2 != from->modelindex2 )
532: bits |= U_MODEL2;
533: if ( to->modelindex3 != from->modelindex3 )
534: bits |= U_MODEL3;
535: if ( to->modelindex4 != from->modelindex4 )
536: bits |= U_MODEL4;
537:
538: if ( to->sound != from->sound )
539: bits |= U_SOUND;
540:
541: if (to->old_origin[0] != from->old_origin[0]
542: || to->old_origin[1] != from->old_origin[1]
543: || to->old_origin[2] != from->old_origin[2] )
544: bits |= U_OLDORIGIN; // FIXME: only when newly seen!!!
545:
546: //
547: // write the message
548: //
549: if (!bits && !force)
550: return; // nothing to send!
551:
552: //----------
553:
554: if (bits & 0xff000000)
555: bits |= U_MOREBITS3 | U_MOREBITS2 | U_MOREBITS1;
556: else if (bits & 0x00ff0000)
557: bits |= U_MOREBITS2 | U_MOREBITS1;
558: else if (bits & 0x0000ff00)
559: bits |= U_MOREBITS1;
560:
561: MSG_WriteByte (msg, bits&255 );
562:
563: if (bits & 0xff000000)
564: {
565: MSG_WriteByte (msg, (bits>>8)&255 );
566: MSG_WriteByte (msg, (bits>>16)&255 );
567: MSG_WriteByte (msg, (bits>>24)&255 );
568: }
569: else if (bits & 0x00ff0000)
570: {
571: MSG_WriteByte (msg, (bits>>8)&255 );
572: MSG_WriteByte (msg, (bits>>16)&255 );
573: }
574: else if (bits & 0x0000ff00)
575: {
576: MSG_WriteByte (msg, (bits>>8)&255 );
577: }
578:
579: //----------
580:
581: if (bits & U_NUMBER16)
582: MSG_WriteShort (msg, to->number);
583: else
584: MSG_WriteByte (msg, to->number);
585:
586: if (bits & U_MODEL)
587: MSG_WriteByte (msg, to->modelindex);
588: if (bits & U_MODEL2)
589: MSG_WriteByte (msg, to->modelindex2);
590: if (bits & U_MODEL3)
591: MSG_WriteByte (msg, to->modelindex3);
592: if (bits & U_MODEL4)
593: MSG_WriteByte (msg, to->modelindex4);
594:
595: if (bits & U_FRAME8)
596: MSG_WriteByte (msg, to->frame);
597: if (bits & U_FRAME16)
598: MSG_WriteShort (msg, to->frame);
599:
600: if ((bits & U_SKIN8) && (bits & U_SKIN16)) //used for laser colors
601: MSG_WriteLong (msg, to->skinnum);
602: else if (bits & U_SKIN8)
603: MSG_WriteByte (msg, to->skinnum);
604: else if (bits & U_SKIN16)
605: MSG_WriteShort (msg, to->skinnum);
606:
607:
608: if ( (bits & (U_EFFECTS8|U_EFFECTS16)) == (U_EFFECTS8|U_EFFECTS16) )
609: MSG_WriteLong (msg, to->effects);
610: else if (bits & U_EFFECTS8)
611: MSG_WriteByte (msg, to->effects);
612: else if (bits & U_EFFECTS16)
613: MSG_WriteShort (msg, to->effects);
614:
615: if ( (bits & (U_RENDERFX8|U_RENDERFX16)) == (U_RENDERFX8|U_RENDERFX16) )
616: MSG_WriteLong (msg, to->renderfx);
617: else if (bits & U_RENDERFX8)
618: MSG_WriteByte (msg, to->renderfx);
619: else if (bits & U_RENDERFX16)
620: MSG_WriteShort (msg, to->renderfx);
621:
622: if (bits & U_ORIGIN1)
623: MSG_WriteCoord (msg, to->origin[0]);
624: if (bits & U_ORIGIN2)
625: MSG_WriteCoord (msg, to->origin[1]);
626: if (bits & U_ORIGIN3)
627: MSG_WriteCoord (msg, to->origin[2]);
628:
629: if (bits & U_ANGLE1)
630: MSG_WriteAngle(msg, to->angles[0]);
631: if (bits & U_ANGLE2)
632: MSG_WriteAngle(msg, to->angles[1]);
633: if (bits & U_ANGLE3)
634: MSG_WriteAngle(msg, to->angles[2]);
635:
636: if (bits & U_OLDORIGIN)
637: {
638: MSG_WriteCoord (msg, to->old_origin[0]);
639: MSG_WriteCoord (msg, to->old_origin[1]);
640: MSG_WriteCoord (msg, to->old_origin[2]);
641: }
642:
643: if (bits & U_SOUND)
644: MSG_WriteByte (msg, to->sound);
645: if (bits & U_EVENT)
646: MSG_WriteByte (msg, to->event);
647: if (bits & U_SOLID)
648: MSG_WriteShort (msg, to->solid);
649: }
650:
651:
652: //============================================================
653:
654: //
655: // reading functions
656: //
657:
658: void MSG_BeginReading (sizebuf_t *msg)
659: {
660: msg->readcount = 0;
661: }
662:
663: // returns -1 if no more characters are available
664: int MSG_ReadChar (sizebuf_t *msg_read)
665: {
666: int c;
667:
668: if (msg_read->readcount+1 > msg_read->cursize)
669: c = -1;
670: else
671: c = (signed char)msg_read->data[msg_read->readcount];
672: msg_read->readcount++;
673:
674: return c;
675: }
676:
677: int MSG_ReadByte (sizebuf_t *msg_read)
678: {
679: int c;
680:
681: if (msg_read->readcount+1 > msg_read->cursize)
682: c = -1;
683: else
684: c = (unsigned char)msg_read->data[msg_read->readcount];
685: msg_read->readcount++;
686:
687: return c;
688: }
689:
690: int MSG_ReadShort (sizebuf_t *msg_read)
691: {
692: int c;
693:
694: if (msg_read->readcount+2 > msg_read->cursize)
695: c = -1;
696: else
697: c = (short)(msg_read->data[msg_read->readcount]
698: + (msg_read->data[msg_read->readcount+1]<<8));
699:
700: msg_read->readcount += 2;
701:
702: return c;
703: }
704:
705: int MSG_ReadLong (sizebuf_t *msg_read)
706: {
707: int c;
708:
709: if (msg_read->readcount+4 > msg_read->cursize)
710: c = -1;
711: else
712: c = msg_read->data[msg_read->readcount]
713: + (msg_read->data[msg_read->readcount+1]<<8)
714: + (msg_read->data[msg_read->readcount+2]<<16)
715: + (msg_read->data[msg_read->readcount+3]<<24);
716:
717: msg_read->readcount += 4;
718:
719: return c;
720: }
721:
722: float MSG_ReadFloat (sizebuf_t *msg_read)
723: {
724: union
725: {
726: byte b[4];
727: float f;
728: int l;
729: } dat;
730:
731: if (msg_read->readcount+4 > msg_read->cursize)
732: dat.f = -1;
733: else
734: {
735: dat.b[0] = msg_read->data[msg_read->readcount];
736: dat.b[1] = msg_read->data[msg_read->readcount+1];
737: dat.b[2] = msg_read->data[msg_read->readcount+2];
738: dat.b[3] = msg_read->data[msg_read->readcount+3];
739: }
740: msg_read->readcount += 4;
741:
742: dat.l = LittleLong (dat.l);
743:
744: return dat.f;
745: }
746:
747: char *MSG_ReadString (sizebuf_t *msg_read)
748: {
749: static char string[2048];
750: int l,c;
751:
752: l = 0;
753: do
754: {
755: c = MSG_ReadChar (msg_read);
756: if (c == -1 || c == 0)
757: break;
758: string[l] = c;
759: l++;
760: } while (l < sizeof(string)-1);
761:
762: string[l] = 0;
763:
764: return string;
765: }
766:
767: char *MSG_ReadStringLine (sizebuf_t *msg_read)
768: {
769: static char string[2048];
770: int l,c;
771:
772: l = 0;
773: do
774: {
775: c = MSG_ReadChar (msg_read);
776: if (c == -1 || c == 0 || c == '\n')
777: break;
778: string[l] = c;
779: l++;
780: } while (l < sizeof(string)-1);
781:
782: string[l] = 0;
783:
784: return string;
785: }
786:
787: float MSG_ReadCoord (sizebuf_t *msg_read)
788: {
789: return MSG_ReadShort(msg_read) * (1.0/8);
790: }
791:
792: void MSG_ReadPos (sizebuf_t *msg_read, vec3_t pos)
793: {
794: pos[0] = MSG_ReadShort(msg_read) * (1.0/8);
795: pos[1] = MSG_ReadShort(msg_read) * (1.0/8);
796: pos[2] = MSG_ReadShort(msg_read) * (1.0/8);
797: }
798:
799: float MSG_ReadAngle (sizebuf_t *msg_read)
800: {
801: return MSG_ReadChar(msg_read) * (360.0/256);
802: }
803:
804: float MSG_ReadAngle16 (sizebuf_t *msg_read)
805: {
806: return SHORT2ANGLE(MSG_ReadShort(msg_read));
807: }
808:
809: void MSG_ReadDeltaUsercmd (sizebuf_t *msg_read, usercmd_t *from, usercmd_t *move)
810: {
811: int bits;
812:
813: memcpy (move, from, sizeof(*move));
814:
815: bits = MSG_ReadByte (msg_read);
816:
817: // read current angles
818: if (bits & CM_ANGLE1)
819: move->angles[0] = MSG_ReadShort (msg_read);
820: if (bits & CM_ANGLE2)
821: move->angles[1] = MSG_ReadShort (msg_read);
822: if (bits & CM_ANGLE3)
823: move->angles[2] = MSG_ReadShort (msg_read);
824:
825: // read movement
826: if (bits & CM_FORWARD)
827: move->forwardmove = MSG_ReadShort (msg_read);
828: if (bits & CM_SIDE)
829: move->sidemove = MSG_ReadShort (msg_read);
830: if (bits & CM_UP)
831: move->upmove = MSG_ReadShort (msg_read);
832:
833: // read buttons
834: if (bits & CM_BUTTONS)
835: move->buttons = MSG_ReadByte (msg_read);
836:
837: if (bits & CM_IMPULSE)
838: move->impulse = MSG_ReadByte (msg_read);
839:
840: // read time to run command
841: move->msec = MSG_ReadByte (msg_read);
842:
843: // read the light level
844: move->lightlevel = MSG_ReadByte (msg_read);
845: }
846:
847:
848: void MSG_ReadData (sizebuf_t *msg_read, void *data, int len)
849: {
850: int i;
851:
852: for (i=0 ; i<len ; i++)
853: ((byte *)data)[i] = MSG_ReadByte (msg_read);
854: }
855:
856:
857: //===========================================================================
858:
859: void SZ_Init (sizebuf_t *buf, byte *data, int length)
860: {
861: memset (buf, 0, sizeof(*buf));
862: buf->data = data;
863: buf->maxsize = length;
864: }
865:
866: void SZ_Clear (sizebuf_t *buf)
867: {
868: buf->cursize = 0;
869: buf->overflowed = false;
870: }
871:
872: void *SZ_GetSpace (sizebuf_t *buf, int length)
873: {
874: void *data;
875:
876: if (buf->cursize + length > buf->maxsize)
877: {
878: if (!buf->allowoverflow)
879: Com_Error (ERR_FATAL, "SZ_GetSpace: overflow without allowoverflow set");
880:
881: if (length > buf->maxsize)
882: Com_Error (ERR_FATAL, "SZ_GetSpace: %i is > full buffer size", length);
883:
884: Com_Printf ("SZ_GetSpace: overflow\n");
885: SZ_Clear (buf);
886: buf->overflowed = true;
887: }
888:
889: data = buf->data + buf->cursize;
890: buf->cursize += length;
891:
892: return data;
893: }
894:
895: void SZ_Write (sizebuf_t *buf, void *data, int length)
896: {
897: memcpy (SZ_GetSpace(buf,length),data,length);
898: }
899:
900: void SZ_Print (sizebuf_t *buf, char *data)
901: {
902: int len;
903:
904: len = strlen(data)+1;
905:
906: if (buf->cursize)
907: {
908: if (buf->data[buf->cursize-1])
909: memcpy ((byte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
910: else
911: memcpy ((byte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
912: }
913: else
914: memcpy ((byte *)SZ_GetSpace(buf, len),data,len);
915: }
916:
917:
918: //============================================================================
919:
920:
921: /*
922: ================
923: COM_CheckParm
924:
925: Returns the position (1 to argc-1) in the program's argument list
926: where the given parameter apears, or 0 if not present
927: ================
928: */
929: int COM_CheckParm (char *parm)
930: {
931: int i;
932:
933: for (i=1 ; i<com_argc ; i++)
934: {
935: if (!strcmp (parm,com_argv[i]))
936: return i;
937: }
938:
939: return 0;
940: }
941:
942: int COM_Argc (void)
943: {
944: return com_argc;
945: }
946:
947: char *COM_Argv (int arg)
948: {
949: if (arg < 0 || arg >= com_argc || !com_argv[arg])
950: return "";
951: return com_argv[arg];
952: }
953:
954: void COM_ClearArgv (int arg)
955: {
956: if (arg < 0 || arg >= com_argc || !com_argv[arg])
957: return;
958: com_argv[arg] = "";
959: }
960:
961:
962: /*
963: ================
964: COM_InitArgv
965: ================
966: */
967: void COM_InitArgv (int argc, char **argv)
968: {
969: int i;
970:
971: if (argc > MAX_NUM_ARGVS)
972: Com_Error (ERR_FATAL, "argc > MAX_NUM_ARGVS");
973: com_argc = argc;
974: for (i=0 ; i<argc ; i++)
975: {
976: if (!argv[i] || strlen(argv[i]) >= MAX_TOKEN_CHARS )
977: com_argv[i] = "";
978: else
979: com_argv[i] = argv[i];
980: }
981: }
982:
983: /*
984: ================
985: COM_AddParm
986:
987: Adds the given string at the end of the current argument list
988: ================
989: */
990: void COM_AddParm (char *parm)
991: {
992: if (com_argc == MAX_NUM_ARGVS)
993: Com_Error (ERR_FATAL, "COM_AddParm: MAX_NUM)ARGS");
994: com_argv[com_argc++] = parm;
995: }
996:
997:
998:
999:
1000: /// just for debugging
1001: int memsearch (byte *start, int count, int search)
1002: {
1003: int i;
1004:
1005: for (i=0 ; i<count ; i++)
1006: if (start[i] == search)
1007: return i;
1008: return -1;
1009: }
1010:
1011:
1012: char *CopyString (char *in)
1013: {
1014: char *out;
1015:
1016: out = Z_Malloc (strlen(in)+1);
1017: strcpy (out, in);
1018: return out;
1019: }
1020:
1021:
1022:
1023: void Info_Print (char *s)
1024: {
1025: char key[512];
1026: char value[512];
1027: char *o;
1028: int l;
1029:
1030: if (*s == '\\')
1031: s++;
1032: while (*s)
1033: {
1034: o = key;
1035: while (*s && *s != '\\')
1036: *o++ = *s++;
1037:
1038: l = o - key;
1039: if (l < 20)
1040: {
1041: memset (o, ' ', 20-l);
1042: key[20] = 0;
1043: }
1044: else
1045: *o = 0;
1046: Com_Printf ("%s", key);
1047:
1048: if (!*s)
1049: {
1050: Com_Printf ("MISSING VALUE\n");
1051: return;
1052: }
1053:
1054: o = value;
1055: s++;
1056: while (*s && *s != '\\')
1057: *o++ = *s++;
1058: *o = 0;
1059:
1060: if (*s)
1061: s++;
1062: Com_Printf ("%s\n", value);
1063: }
1064: }
1065:
1066:
1067: /*
1068: ==============================================================================
1069:
1070: ZONE MEMORY ALLOCATION
1071:
1072: just cleared malloc with counters now...
1073:
1074: ==============================================================================
1075: */
1076:
1077: #define Z_MAGIC 0x1d1d
1078:
1079:
1080: typedef struct zhead_s
1081: {
1082: struct zhead_s *prev, *next;
1083: short magic;
1084: short tag; // for group free
1085: int size;
1086: } zhead_t;
1087:
1088: zhead_t z_chain;
1089: int z_count, z_bytes;
1090:
1091: /*
1092: ========================
1093: Z_Free
1094: ========================
1095: */
1096: void Z_Free (void *ptr)
1097: {
1098: zhead_t *z;
1099:
1100: z = ((zhead_t *)ptr) - 1;
1101:
1102: if (z->magic != Z_MAGIC)
1103: Com_Error (ERR_FATAL, "Z_Free: bad magic");
1104:
1105: z->prev->next = z->next;
1106: z->next->prev = z->prev;
1107:
1108: z_count--;
1109: z_bytes -= z->size;
1110: free (z);
1111: }
1112:
1113:
1114: /*
1115: ========================
1116: Z_Stats_f
1117: ========================
1118: */
1119: void Z_Stats_f (void)
1120: {
1121: Com_Printf ("%i bytes in %i blocks\n", z_bytes, z_count);
1122: }
1123:
1124: /*
1125: ========================
1126: Z_FreeTags
1127: ========================
1128: */
1129: void Z_FreeTags (int tag)
1130: {
1131: zhead_t *z, *next;
1132:
1133: for (z=z_chain.next ; z != &z_chain ; z=next)
1134: {
1135: next = z->next;
1136: if (z->tag == tag)
1137: Z_Free ((void *)(z+1));
1138: }
1139: }
1140:
1141: /*
1142: ========================
1143: Z_TagMalloc
1144: ========================
1145: */
1146: void *Z_TagMalloc (int size, int tag)
1147: {
1148: zhead_t *z;
1149:
1150: size = size + sizeof(zhead_t);
1151: z = malloc(size);
1152: if (!z)
1153: Com_Error (ERR_FATAL, "Z_Malloc: failed on allocation of %i bytes",size);
1154: memset (z, 0, size);
1155: z_count++;
1156: z_bytes += size;
1157: z->magic = Z_MAGIC;
1158: z->tag = tag;
1159: z->size = size;
1160:
1161: z->next = z_chain.next;
1162: z->prev = &z_chain;
1163: z_chain.next->prev = z;
1164: z_chain.next = z;
1165:
1166: return (void *)(z+1);
1167: }
1168:
1169: /*
1170: ========================
1171: Z_Malloc
1172: ========================
1173: */
1174: void *Z_Malloc (int size)
1175: {
1176: return Z_TagMalloc (size, 0);
1177: }
1178:
1179:
1180: //============================================================================
1181:
1182:
1183: /*
1184: ====================
1185: COM_BlockSequenceCheckByte
1186:
1187: For proxy protecting
1188: ====================
1189: */
1190: byte COM_BlockSequenceCheckByte (byte *base, int length, int sequence)
1191: {
1192: int checksum;
1193: byte buf[64];
1194: int n;
1195: byte *p;
1196:
1197: n = sequence % (NUMVERTEXNORMALS * sizeof(vec3_t));
1198: p = ((byte *)bytedirs)+n;
1199: if (length > 60)
1200: length = 60;
1201: memcpy (buf, base, length);
1202: Com_DPrintf("sum: seq=%d, [%02x %02x %02x %02x/%02x %02x] ", sequence,
1203: p[0], p[1], p[2], p[3], (sequence & 0xff), ((sequence>>8) & 0xff));
1204:
1205: buf[length] = (sequence & 0xff) ^ *p++;
1206: buf[length+1] = *p++;
1207: buf[length+2] = ((sequence>>8) & 0xff) ^ *p++;
1208: buf[length+3] = *p;
1209:
1210: Com_DPrintf("%02x %02x %02x %02x\n", sequence,
1211: buf[length], buf[length+1], buf[length+2], buf[length+3]);
1212:
1213: length += 4;
1214:
1215: checksum = Com_BlockChecksum (buf, length);
1216:
1217: checksum &= 0xff;
1218:
1219: return checksum;
1220: }
1221:
1222: //========================================================
1223:
1224: float frand(void)
1225: {
1226: return (rand()&32767)* (1.0/32767);
1227: }
1228:
1229: float crand(void)
1230: {
1231: return (rand()&32767)* (2.0/32767) - 1;
1232: }
1233:
1234: void Key_Init (void);
1235: void SCR_EndLoadingPlaque (void);
1236:
1237: /*
1238: =============
1239: Com_Error_f
1240:
1241: Just throw a fatal error to
1242: test error shutdown procedures
1243: =============
1244: */
1245: void Com_Error_f (void)
1246: {
1247: Com_Error (ERR_FATAL, "%s", Cmd_Argv(1));
1248: }
1249:
1250:
1251: /*
1252: =================
1253: Qcommon_Init
1254: =================
1255: */
1256: void Qcommon_Init (int argc, char **argv)
1257: {
1258: char *s;
1259:
1260: if (setjmp (abortframe) )
1261: Sys_Error ("Error during initialization");
1262:
1263: z_chain.next = z_chain.prev = &z_chain;
1264:
1265: // prepare enough of the subsystems to handle
1266: // cvar and command buffer management
1267: COM_InitArgv (argc, argv);
1268:
1269: Swap_Init ();
1270: Cbuf_Init ();
1271:
1272: Cmd_Init ();
1273: Cvar_Init ();
1274:
1275: Key_Init ();
1276:
1277: // we need to add the early commands twice, because
1278: // a basedir or cddir needs to be set before execing
1279: // config files, but we want other parms to override
1280: // the settings of the config files
1281: Cbuf_AddEarlyCommands (false);
1282: Cbuf_Execute ();
1283:
1284: FS_InitFilesystem ();
1285:
1286: Cbuf_AddText ("exec default.cfg\n");
1287: Cbuf_AddText ("exec config.cfg\n");
1288:
1289: Cbuf_AddEarlyCommands (true);
1290: Cbuf_Execute ();
1291:
1292: //
1293: // init commands and vars
1294: //
1295: Cmd_AddCommand ("z_stats", Z_Stats_f);
1296: Cmd_AddCommand ("error", Com_Error_f);
1297:
1298: host_speeds = Cvar_Get ("host_speeds", "0", 0);
1299: log_stats = Cvar_Get ("log_stats", "0", 0);
1300: developer = Cvar_Get ("developer", "0", 0);
1301: timescale = Cvar_Get ("timescale", "1", 0);
1302: fixedtime = Cvar_Get ("fixedtime", "0", 0);
1303: logfile_active = Cvar_Get ("logfile", "0", 0);
1304: showtrace = Cvar_Get ("showtrace", "0", 0);
1305: dedicated = Cvar_Get ("dedicated", "0", CVAR_NOSET);
1306:
1307: s = va("%4.2f %s %s %s", VERSION, CPUSTRING, __DATE__, BUILDSTRING);
1308: Cvar_Get ("version", s, CVAR_SERVERINFO|CVAR_NOSET);
1309:
1310:
1311: if (dedicated->value)
1312: Cmd_AddCommand ("quit", Com_Quit);
1313:
1314: Sys_Init ();
1315:
1316: NET_Init ();
1317: Netchan_Init ();
1318:
1319: SV_Init ();
1320: CL_Init ();
1321:
1322: // add + commands from command line
1323: if (!Cbuf_AddLateCommands ())
1324: { // if the user didn't give any commands, run default action
1325: if (!dedicated->value)
1326: Cbuf_AddText ("d1\n");
1327: else
1328: Cbuf_AddText ("dedicated_start\n");
1329: Cbuf_Execute ();
1330: }
1331: else
1332: { // the user asked for something explicit
1333: // so drop the loading plaque
1334: SCR_EndLoadingPlaque ();
1335: }
1336:
1337: Com_Printf ("====== Quake2 Initialized ======\n\n");
1338: }
1339:
1340: /*
1341: =================
1342: Qcommon_Frame
1343: =================
1344: */
1345: void Qcommon_Frame (int msec)
1346: {
1347: char *s;
1348: int time_before, time_between, time_after;
1349:
1350: if (setjmp (abortframe) )
1351: return; // an ERR_DROP was thrown
1352:
1353: if ( log_stats->modified )
1354: {
1355: log_stats->modified = false;
1356: if ( log_stats->value )
1357: {
1358: if ( log_stats_file )
1359: {
1360: fclose( log_stats_file );
1361: log_stats_file = 0;
1362: }
1363: log_stats_file = fopen( "stats.log", "w" );
1364: if ( log_stats_file )
1365: fprintf( log_stats_file, "entities,dlights,parts,frame time\n" );
1366: }
1367: else
1368: {
1369: if ( log_stats_file )
1370: {
1371: fclose( log_stats_file );
1372: log_stats_file = 0;
1373: }
1374: }
1375: }
1376:
1377: if (fixedtime->value)
1378: msec = fixedtime->value;
1379: else if (timescale->value)
1380: {
1381: msec *= timescale->value;
1382: if (msec < 1)
1383: msec = 1;
1384: }
1385:
1386: if (showtrace->value)
1387: {
1388: extern int c_traces, c_brush_traces;
1389: extern int c_pointcontents;
1390:
1391: Com_Printf ("%4i traces %4i points\n", c_traces, c_pointcontents);
1392: c_traces = 0;
1393: c_brush_traces = 0;
1394: c_pointcontents = 0;
1395: }
1396:
1397: do
1398: {
1399: s = Sys_ConsoleInput ();
1400: if (s)
1401: Cbuf_AddText (va("%s\n",s));
1402: } while (s);
1403: Cbuf_Execute ();
1404:
1405: if (host_speeds->value)
1406: time_before = Sys_Milliseconds ();
1407:
1408: SV_Frame (msec);
1409:
1410: if (host_speeds->value)
1411: time_between = Sys_Milliseconds ();
1412:
1413: CL_Frame (msec);
1414:
1415: if (host_speeds->value)
1416: time_after = Sys_Milliseconds ();
1417:
1418:
1419: if (host_speeds->value)
1420: {
1421: int all, sv, gm, cl, rf;
1422:
1423: all = time_after - time_before;
1424: sv = time_between - time_before;
1425: cl = time_after - time_between;
1426: gm = time_after_game - time_before_game;
1427: rf = time_after_ref - time_before_ref;
1428: sv -= gm;
1429: cl -= rf;
1430: Com_Printf ("all:%3i sv:%3i gm:%3i cl:%3i rf:%3i\n",
1431: all, sv, gm, cl, rf);
1432: }
1433: }
1434:
1435: /*
1436: =================
1437: Qcommon_Shutdown
1438: =================
1439: */
1440: void Qcommon_Shutdown (void)
1441: {
1442: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.