![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_save.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / ctf|
Return to g_save.c CVS log | Up to [Quake II] / quake2 / ctf |
1.1 root 1:
2: #include "g_local.h"
3:
4: field_t fields[] = {
5: {"classname", FOFS(classname), F_LSTRING},
6: {"origin", FOFS(s.origin), F_VECTOR},
7: {"model", FOFS(model), F_LSTRING},
8: {"spawnflags", FOFS(spawnflags), F_INT},
9: {"speed", FOFS(speed), F_FLOAT},
10: {"accel", FOFS(accel), F_FLOAT},
11: {"decel", FOFS(decel), F_FLOAT},
12: {"target", FOFS(target), F_LSTRING},
13: {"targetname", FOFS(targetname), F_LSTRING},
14: {"pathtarget", FOFS(pathtarget), F_LSTRING},
15: {"deathtarget", FOFS(deathtarget), F_LSTRING},
16: {"killtarget", FOFS(killtarget), F_LSTRING},
17: {"combattarget", FOFS(combattarget), F_LSTRING},
18: {"message", FOFS(message), F_LSTRING},
19: {"team", FOFS(team), F_LSTRING},
20: {"wait", FOFS(wait), F_FLOAT},
21: {"delay", FOFS(delay), F_FLOAT},
22: {"random", FOFS(random), F_FLOAT},
23: {"move_origin", FOFS(move_origin), F_VECTOR},
24: {"move_angles", FOFS(move_angles), F_VECTOR},
25: {"style", FOFS(style), F_INT},
26: {"count", FOFS(count), F_INT},
27: {"health", FOFS(health), F_INT},
28: {"sounds", FOFS(sounds), F_INT},
29: {"light", 0, F_IGNORE},
30: {"dmg", FOFS(dmg), F_INT},
31: {"angles", FOFS(s.angles), F_VECTOR},
32: {"angle", FOFS(s.angles), F_ANGLEHACK},
33: {"mass", FOFS(mass), F_INT},
34: {"volume", FOFS(volume), F_FLOAT},
35: {"attenuation", FOFS(attenuation), F_FLOAT},
36: {"map", FOFS(map), F_LSTRING},
37:
38: // temp spawn vars -- only valid when the spawn function is called
39: {"lip", STOFS(lip), F_INT, FFL_SPAWNTEMP},
40: {"distance", STOFS(distance), F_INT, FFL_SPAWNTEMP},
41: {"height", STOFS(height), F_INT, FFL_SPAWNTEMP},
42: {"noise", STOFS(noise), F_LSTRING, FFL_SPAWNTEMP},
43: {"pausetime", STOFS(pausetime), F_FLOAT, FFL_SPAWNTEMP},
44: {"item", STOFS(item), F_LSTRING, FFL_SPAWNTEMP},
45: {"gravity", STOFS(gravity), F_LSTRING, FFL_SPAWNTEMP},
46: {"sky", STOFS(sky), F_LSTRING, FFL_SPAWNTEMP},
47: {"skyrotate", STOFS(skyrotate), F_FLOAT, FFL_SPAWNTEMP},
48: {"skyaxis", STOFS(skyaxis), F_VECTOR, FFL_SPAWNTEMP},
49: {"minyaw", STOFS(minyaw), F_FLOAT, FFL_SPAWNTEMP},
50: {"maxyaw", STOFS(maxyaw), F_FLOAT, FFL_SPAWNTEMP},
51: {"minpitch", STOFS(minpitch), F_FLOAT, FFL_SPAWNTEMP},
52: {"maxpitch", STOFS(maxpitch), F_FLOAT, FFL_SPAWNTEMP},
53: {"nextmap", STOFS(nextmap), F_LSTRING, FFL_SPAWNTEMP}
54: };
55:
56: // -------- just for savegames ----------
57: // all pointer fields should be listed here, or savegames
58: // won't work properly (they will crash and burn).
59: // this wasn't just tacked on to the fields array, because
60: // these don't need names, we wouldn't want map fields using
61: // some of these, and if one were accidentally present twice
62: // it would double swizzle (fuck) the pointer.
63:
64: field_t savefields[] =
65: {
66: {"", FOFS(classname), F_LSTRING},
67: {"", FOFS(target), F_LSTRING},
68: {"", FOFS(targetname), F_LSTRING},
69: {"", FOFS(killtarget), F_LSTRING},
70: {"", FOFS(team), F_LSTRING},
71: {"", FOFS(pathtarget), F_LSTRING},
72: {"", FOFS(deathtarget), F_LSTRING},
73: {"", FOFS(combattarget), F_LSTRING},
74: {"", FOFS(model), F_LSTRING},
75: {"", FOFS(map), F_LSTRING},
76: {"", FOFS(message), F_LSTRING},
77:
78: {"", FOFS(client), F_CLIENT},
79: {"", FOFS(item), F_ITEM},
80:
81: {"", FOFS(goalentity), F_EDICT},
82: {"", FOFS(movetarget), F_EDICT},
83: {"", FOFS(enemy), F_EDICT},
84: {"", FOFS(oldenemy), F_EDICT},
85: {"", FOFS(activator), F_EDICT},
86: {"", FOFS(groundentity), F_EDICT},
87: {"", FOFS(teamchain), F_EDICT},
88: {"", FOFS(teammaster), F_EDICT},
89: {"", FOFS(owner), F_EDICT},
90: {"", FOFS(mynoise), F_EDICT},
91: {"", FOFS(mynoise2), F_EDICT},
92: {"", FOFS(target_ent), F_EDICT},
93: {"", FOFS(chain), F_EDICT},
94:
95: {NULL, 0, F_INT}
96: };
97:
98: field_t levelfields[] =
99: {
100: {"", LLOFS(changemap), F_LSTRING},
101:
102: {"", LLOFS(sight_client), F_EDICT},
103: {"", LLOFS(sight_entity), F_EDICT},
104: {"", LLOFS(sound_entity), F_EDICT},
105: {"", LLOFS(sound2_entity), F_EDICT},
106:
107: {NULL, 0, F_INT}
108: };
109:
110: field_t clientfields[] =
111: {
112: {"", CLOFS(pers.weapon), F_ITEM},
113: {"", CLOFS(pers.lastweapon), F_ITEM},
114: {"", CLOFS(newweapon), F_ITEM},
115:
116: {NULL, 0, F_INT}
117: };
118:
119: /*
120: ============
121: InitGame
122:
123: This will be called when the dll is first loaded, which
124: only happens when a new game is started or a save game
125: is loaded.
126: ============
127: */
128: void InitGame (void)
129: {
130: gi.dprintf ("==== InitGame ====\n");
131:
132: gun_x = gi.cvar ("gun_x", "0", 0);
133: gun_y = gi.cvar ("gun_y", "0", 0);
134: gun_z = gi.cvar ("gun_z", "0", 0);
135:
136: //FIXME: sv_ prefix is wrong for these
137: sv_rollspeed = gi.cvar ("sv_rollspeed", "200", 0);
138: sv_rollangle = gi.cvar ("sv_rollangle", "2", 0);
139: sv_maxvelocity = gi.cvar ("sv_maxvelocity", "2000", 0);
140: sv_gravity = gi.cvar ("sv_gravity", "800", 0);
141:
142: // noset vars
143: dedicated = gi.cvar ("dedicated", "0", CVAR_NOSET);
144:
145: // latched vars
146: sv_cheats = gi.cvar ("cheats", "0", CVAR_SERVERINFO|CVAR_LATCH);
147: gi.cvar ("gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_LATCH);
148: gi.cvar ("gamedate", __DATE__ , CVAR_SERVERINFO | CVAR_LATCH);
149:
150: maxclients = gi.cvar ("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH);
151: deathmatch = gi.cvar ("deathmatch", "0", CVAR_LATCH);
152: coop = gi.cvar ("coop", "0", CVAR_LATCH);
153: skill = gi.cvar ("skill", "1", CVAR_LATCH);
154: maxentities = gi.cvar ("maxentities", "1024", CVAR_LATCH);
155:
156: //ZOID
157: //This game.dll only supports deathmatch
158: if (!deathmatch->value) {
159: gi.dprintf("Forcing deathmatch.");
160: gi.cvar_set("deathmatch", "1");
161: }
162: //force coop off
163: if (coop->value)
164: gi.cvar_set("coop", "0");
165: //ZOID
166:
167:
168: // change anytime vars
169: dmflags = gi.cvar ("dmflags", "0", CVAR_SERVERINFO);
170: fraglimit = gi.cvar ("fraglimit", "0", CVAR_SERVERINFO);
171: timelimit = gi.cvar ("timelimit", "0", CVAR_SERVERINFO);
172: //ZOID
173: capturelimit = gi.cvar ("capturelimit", "0", CVAR_SERVERINFO);
174: instantweap = gi.cvar ("instantweap", "0", CVAR_SERVERINFO);
175: //ZOID
176: password = gi.cvar ("password", "", CVAR_USERINFO);
177:
178: g_select_empty = gi.cvar ("g_select_empty", "0", CVAR_ARCHIVE);
179:
180: run_pitch = gi.cvar ("run_pitch", "0.002", 0);
181: run_roll = gi.cvar ("run_roll", "0.005", 0);
182: bob_up = gi.cvar ("bob_up", "0.005", 0);
183: bob_pitch = gi.cvar ("bob_pitch", "0.002", 0);
184: bob_roll = gi.cvar ("bob_roll", "0.002", 0);
185:
186: // flood control
187: flood_msgs = gi.cvar ("flood_msgs", "4", 0);
188: flood_persecond = gi.cvar ("flood_persecond", "4", 0);
189: flood_waitdelay = gi.cvar ("flood_waitdelay", "10", 0);
190:
191: // dm map list
192: sv_maplist = gi.cvar ("sv_maplist", "", 0);
193:
194: // items
195: InitItems ();
196:
197: Com_sprintf (game.helpmessage1, sizeof(game.helpmessage1), "");
198:
199: Com_sprintf (game.helpmessage2, sizeof(game.helpmessage2), "");
200:
201: // initialize all entities for this game
202: game.maxentities = maxentities->value;
203: g_edicts = gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
204: globals.edicts = g_edicts;
205: globals.max_edicts = game.maxentities;
206:
207: // initialize all clients for this game
208: game.maxclients = maxclients->value;
209: game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME);
210: globals.num_edicts = game.maxclients+1;
211:
212: //ZOID
213: CTFInit();
214: //ZOID
215: }
216:
217: //=========================================================
218:
219: void WriteField1 (FILE *f, field_t *field, byte *base)
220: {
221: void *p;
222: int len;
223: int index;
224:
225: p = (void *)(base + field->ofs);
226: switch (field->type)
227: {
228: case F_INT:
229: case F_FLOAT:
230: case F_ANGLEHACK:
231: case F_VECTOR:
232: case F_IGNORE:
233: break;
234:
235: case F_LSTRING:
236: case F_GSTRING:
237: if ( *(char **)p )
238: len = strlen(*(char **)p) + 1;
239: else
240: len = 0;
241: *(int *)p = len;
242: break;
243: case F_EDICT:
244: if ( *(edict_t **)p == NULL)
245: index = -1;
246: else
247: index = *(edict_t **)p - g_edicts;
248: *(int *)p = index;
249: break;
250: case F_CLIENT:
251: if ( *(gclient_t **)p == NULL)
252: index = -1;
253: else
254: index = *(gclient_t **)p - game.clients;
255: *(int *)p = index;
256: break;
257: case F_ITEM:
258: if ( *(edict_t **)p == NULL)
259: index = -1;
260: else
261: index = *(gitem_t **)p - itemlist;
262: *(int *)p = index;
263: break;
264:
265: default:
266: gi.error ("WriteEdict: unknown field type");
267: }
268: }
269:
270: void WriteField2 (FILE *f, field_t *field, byte *base)
271: {
272: int len;
273: void *p;
274:
275: p = (void *)(base + field->ofs);
276: switch (field->type)
277: {
278: case F_LSTRING:
279: case F_GSTRING:
280: if ( *(char **)p )
281: {
282: len = strlen(*(char **)p) + 1;
283: fwrite (*(char **)p, len, 1, f);
284: }
285: break;
286: }
287: }
288:
289: void ReadField (FILE *f, field_t *field, byte *base)
290: {
291: void *p;
292: int len;
293: int index;
294:
295: p = (void *)(base + field->ofs);
296: switch (field->type)
297: {
298: case F_INT:
299: case F_FLOAT:
300: case F_ANGLEHACK:
301: case F_VECTOR:
302: case F_IGNORE:
303: break;
304:
305: case F_LSTRING:
306: len = *(int *)p;
307: if (!len)
308: *(char **)p = NULL;
309: else
310: {
311: *(char **)p = gi.TagMalloc (len, TAG_LEVEL);
312: fread (*(char **)p, len, 1, f);
313: }
314: break;
315: case F_GSTRING:
316: len = *(int *)p;
317: if (!len)
318: *(char **)p = NULL;
319: else
320: {
321: *(char **)p = gi.TagMalloc (len, TAG_GAME);
322: fread (*(char **)p, len, 1, f);
323: }
324: break;
325: case F_EDICT:
326: index = *(int *)p;
327: if ( index == -1 )
328: *(edict_t **)p = NULL;
329: else
330: *(edict_t **)p = &g_edicts[index];
331: break;
332: case F_CLIENT:
333: index = *(int *)p;
334: if ( index == -1 )
335: *(gclient_t **)p = NULL;
336: else
337: *(gclient_t **)p = &game.clients[index];
338: break;
339: case F_ITEM:
340: index = *(int *)p;
341: if ( index == -1 )
342: *(gitem_t **)p = NULL;
343: else
344: *(gitem_t **)p = &itemlist[index];
345: break;
346:
347: default:
348: gi.error ("ReadEdict: unknown field type");
349: }
350: }
351:
352: //=========================================================
353:
354: /*
355: ==============
356: WriteClient
357:
358: All pointer variables (except function pointers) must be handled specially.
359: ==============
360: */
361: void WriteClient (FILE *f, gclient_t *client)
362: {
363: field_t *field;
364: gclient_t temp;
365:
366: // all of the ints, floats, and vectors stay as they are
367: temp = *client;
368:
369: // change the pointers to lengths or indexes
370: for (field=clientfields ; field->name ; field++)
371: {
372: WriteField1 (f, field, (byte *)&temp);
373: }
374:
375: // write the block
376: fwrite (&temp, sizeof(temp), 1, f);
377:
378: // now write any allocated data following the edict
379: for (field=clientfields ; field->name ; field++)
380: {
381: WriteField2 (f, field, (byte *)client);
382: }
383: }
384:
385: /*
386: ==============
387: ReadClient
388:
389: All pointer variables (except function pointers) must be handled specially.
390: ==============
391: */
392: void ReadClient (FILE *f, gclient_t *client)
393: {
394: field_t *field;
395:
396: fread (client, sizeof(*client), 1, f);
397:
398: for (field=clientfields ; field->name ; field++)
399: {
400: ReadField (f, field, (byte *)client);
401: }
402: }
403:
404: /*
405: ============
406: WriteGame
407:
408: This will be called whenever the game goes to a new level,
409: and when the user explicitly saves the game.
410:
411: Game information include cross level data, like multi level
412: triggers, help computer info, and all client states.
413:
414: A single player death will automatically restore from the
415: last save position.
416: ============
417: */
418: void WriteGame (char *filename, qboolean autosave)
419: {
420: FILE *f;
421: int i;
422: char str[16];
423:
424: if (!autosave)
425: SaveClientData ();
426:
427: f = fopen (filename, "wb");
428: if (!f)
429: gi.error ("Couldn't open %s", filename);
430:
431: memset (str, 0, sizeof(str));
432: strcpy (str, __DATE__);
433: fwrite (str, sizeof(str), 1, f);
434:
435: game.autosaved = autosave;
436: fwrite (&game, sizeof(game), 1, f);
437: game.autosaved = false;
438:
439: for (i=0 ; i<game.maxclients ; i++)
440: WriteClient (f, &game.clients[i]);
441:
442: fclose (f);
443: }
444:
445: void ReadGame (char *filename)
446: {
447: FILE *f;
448: int i;
449: char str[16];
450:
451: gi.FreeTags (TAG_GAME);
452:
453: f = fopen (filename, "rb");
454: if (!f)
455: gi.error ("Couldn't open %s", filename);
456:
457: fread (str, sizeof(str), 1, f);
458: if (strcmp (str, __DATE__))
459: {
460: fclose (f);
461: gi.error ("Savegame from an older version.\n");
462: }
463:
464: g_edicts = gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
465: globals.edicts = g_edicts;
466:
467: fread (&game, sizeof(game), 1, f);
468: game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME);
469: for (i=0 ; i<game.maxclients ; i++)
470: ReadClient (f, &game.clients[i]);
471:
472: fclose (f);
473: }
474:
475: //==========================================================
476:
477:
478: /*
479: ==============
480: WriteEdict
481:
482: All pointer variables (except function pointers) must be handled specially.
483: ==============
484: */
485: void WriteEdict (FILE *f, edict_t *ent)
486: {
487: field_t *field;
488: edict_t temp;
489:
490: // all of the ints, floats, and vectors stay as they are
491: temp = *ent;
492:
493: // change the pointers to lengths or indexes
494: for (field=savefields ; field->name ; field++)
495: {
496: WriteField1 (f, field, (byte *)&temp);
497: }
498:
499: // write the block
500: fwrite (&temp, sizeof(temp), 1, f);
501:
502: // now write any allocated data following the edict
503: for (field=savefields ; field->name ; field++)
504: {
505: WriteField2 (f, field, (byte *)ent);
506: }
507:
508: }
509:
510: /*
511: ==============
512: WriteLevelLocals
513:
514: All pointer variables (except function pointers) must be handled specially.
515: ==============
516: */
517: void WriteLevelLocals (FILE *f)
518: {
519: field_t *field;
520: level_locals_t temp;
521:
522: // all of the ints, floats, and vectors stay as they are
523: temp = level;
524:
525: // change the pointers to lengths or indexes
526: for (field=levelfields ; field->name ; field++)
527: {
528: WriteField1 (f, field, (byte *)&temp);
529: }
530:
531: // write the block
532: fwrite (&temp, sizeof(temp), 1, f);
533:
534: // now write any allocated data following the edict
535: for (field=levelfields ; field->name ; field++)
536: {
537: WriteField2 (f, field, (byte *)&level);
538: }
539: }
540:
541:
542: /*
543: ==============
544: ReadEdict
545:
546: All pointer variables (except function pointers) must be handled specially.
547: ==============
548: */
549: void ReadEdict (FILE *f, edict_t *ent)
550: {
551: field_t *field;
552:
553: fread (ent, sizeof(*ent), 1, f);
554:
555: for (field=savefields ; field->name ; field++)
556: {
557: ReadField (f, field, (byte *)ent);
558: }
559: }
560:
561: /*
562: ==============
563: ReadLevelLocals
564:
565: All pointer variables (except function pointers) must be handled specially.
566: ==============
567: */
568: void ReadLevelLocals (FILE *f)
569: {
570: field_t *field;
571:
572: fread (&level, sizeof(level), 1, f);
573:
574: for (field=levelfields ; field->name ; field++)
575: {
576: ReadField (f, field, (byte *)&level);
577: }
578: }
579:
580: /*
581: =================
582: WriteLevel
583:
584: =================
585: */
586: void WriteLevel (char *filename)
587: {
588: int i;
589: edict_t *ent;
590: FILE *f;
591: void *base;
592:
593: f = fopen (filename, "wb");
594: if (!f)
595: gi.error ("Couldn't open %s", filename);
596:
597: // write out edict size for checking
598: i = sizeof(edict_t);
599: fwrite (&i, sizeof(i), 1, f);
600:
601: // write out a function pointer for checking
602: base = (void *)InitGame;
603: fwrite (&base, sizeof(base), 1, f);
604:
605: // write out level_locals_t
606: WriteLevelLocals (f);
607:
608: // write out all the entities
609: for (i=0 ; i<globals.num_edicts ; i++)
610: {
611: ent = &g_edicts[i];
612: if (!ent->inuse)
613: continue;
614: fwrite (&i, sizeof(i), 1, f);
615: WriteEdict (f, ent);
616: }
617: i = -1;
618: fwrite (&i, sizeof(i), 1, f);
619:
620: fclose (f);
621: }
622:
623:
624: /*
625: =================
626: ReadLevel
627:
628: SpawnEntities will allready have been called on the
629: level the same way it was when the level was saved.
630:
631: That is necessary to get the baselines
632: set up identically.
633:
634: The server will have cleared all of the world links before
635: calling ReadLevel.
636:
637: No clients are connected yet.
638: =================
639: */
640: void ReadLevel (char *filename)
641: {
642: int entnum;
643: FILE *f;
644: int i;
645: void *base;
646: edict_t *ent;
647:
648: f = fopen (filename, "rb");
649: if (!f)
650: gi.error ("Couldn't open %s", filename);
651:
652: // free any dynamic memory allocated by loading the level
653: // base state
654: gi.FreeTags (TAG_LEVEL);
655:
656: // wipe all the entities
657: memset (g_edicts, 0, game.maxentities*sizeof(g_edicts[0]));
658: globals.num_edicts = maxclients->value+1;
659:
660: // check edict size
661: fread (&i, sizeof(i), 1, f);
662: if (i != sizeof(edict_t))
663: {
664: fclose (f);
665: gi.error ("ReadLevel: mismatched edict size");
666: }
667:
668: // check function pointer base address
669: fread (&base, sizeof(base), 1, f);
670: if (base != (void *)InitGame)
671: {
672: fclose (f);
673: gi.error ("ReadLevel: function pointers have moved");
674: }
675:
676: // load the level locals
677: ReadLevelLocals (f);
678:
679: // load all the entities
680: while (1)
681: {
682: if (fread (&entnum, sizeof(entnum), 1, f) != 1)
683: {
684: fclose (f);
685: gi.error ("ReadLevel: failed to read entnum");
686: }
687: if (entnum == -1)
688: break;
689: if (entnum >= globals.num_edicts)
690: globals.num_edicts = entnum+1;
691:
692: ent = &g_edicts[entnum];
693: ReadEdict (f, ent);
694:
695: // let the server rebuild world links for this ent
696: memset (&ent->area, 0, sizeof(ent->area));
697: gi.linkentity (ent);
698: }
699:
700: fclose (f);
701:
702: // mark all clients as unconnected
703: for (i=0 ; i<maxclients->value ; i++)
704: {
705: ent = &g_edicts[i+1];
706: ent->client = game.clients + i;
707: ent->client->pers.connected = false;
708: }
709:
710: // do any load time things at this point
711: for (i=0 ; i<globals.num_edicts ; i++)
712: {
713: ent = &g_edicts[i];
714:
715: if (!ent->inuse)
716: continue;
717:
718: // fire any cross-level triggers
719: if (ent->classname)
720: if (strcmp(ent->classname, "target_crosslevel_target") == 0)
721: ent->nextthink = level.time + ent->delay;
722: }
723: }
724:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.