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