![[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 / game|
Return to g_save.c CVS log | Up to [Quake II] / quake2 / game |
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: // change anytime vars ! 157: dmflags = gi.cvar ("dmflags", "0", CVAR_SERVERINFO); ! 158: fraglimit = gi.cvar ("fraglimit", "0", CVAR_SERVERINFO); ! 159: timelimit = gi.cvar ("timelimit", "0", CVAR_SERVERINFO); ! 160: password = gi.cvar ("password", "", CVAR_USERINFO); ! 161: ! 162: g_select_empty = gi.cvar ("g_select_empty", "0", CVAR_ARCHIVE); ! 163: ! 164: run_pitch = gi.cvar ("run_pitch", "0.002", 0); ! 165: run_roll = gi.cvar ("run_roll", "0.005", 0); ! 166: bob_up = gi.cvar ("bob_up", "0.005", 0); ! 167: bob_pitch = gi.cvar ("bob_pitch", "0.002", 0); ! 168: bob_roll = gi.cvar ("bob_roll", "0.002", 0); ! 169: ! 170: // items ! 171: InitItems (); ! 172: ! 173: Com_sprintf (game.helpmessage1, sizeof(game.helpmessage1), ""); ! 174: ! 175: Com_sprintf (game.helpmessage2, sizeof(game.helpmessage2), ""); ! 176: ! 177: // initialize all entities for this game ! 178: game.maxentities = maxentities->value; ! 179: g_edicts = gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME); ! 180: globals.edicts = g_edicts; ! 181: globals.max_edicts = game.maxentities; ! 182: ! 183: // initialize all clients for this game ! 184: game.maxclients = maxclients->value; ! 185: game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME); ! 186: globals.num_edicts = game.maxclients+1; ! 187: } ! 188: ! 189: //========================================================= ! 190: ! 191: void WriteField1 (FILE *f, field_t *field, byte *base) ! 192: { ! 193: void *p; ! 194: int len; ! 195: int index; ! 196: ! 197: p = (void *)(base + field->ofs); ! 198: switch (field->type) ! 199: { ! 200: case F_INT: ! 201: case F_FLOAT: ! 202: case F_ANGLEHACK: ! 203: case F_VECTOR: ! 204: case F_IGNORE: ! 205: break; ! 206: ! 207: case F_LSTRING: ! 208: case F_GSTRING: ! 209: if ( *(char **)p ) ! 210: len = strlen(*(char **)p) + 1; ! 211: else ! 212: len = 0; ! 213: *(int *)p = len; ! 214: break; ! 215: case F_EDICT: ! 216: if ( *(edict_t **)p == NULL) ! 217: index = -1; ! 218: else ! 219: index = *(edict_t **)p - g_edicts; ! 220: *(int *)p = index; ! 221: break; ! 222: case F_CLIENT: ! 223: if ( *(gclient_t **)p == NULL) ! 224: index = -1; ! 225: else ! 226: index = *(gclient_t **)p - game.clients; ! 227: *(int *)p = index; ! 228: break; ! 229: case F_ITEM: ! 230: if ( *(edict_t **)p == NULL) ! 231: index = -1; ! 232: else ! 233: index = *(gitem_t **)p - itemlist; ! 234: *(int *)p = index; ! 235: break; ! 236: ! 237: default: ! 238: gi.error ("WriteEdict: unknown field type"); ! 239: } ! 240: } ! 241: ! 242: void WriteField2 (FILE *f, field_t *field, byte *base) ! 243: { ! 244: int len; ! 245: void *p; ! 246: ! 247: p = (void *)(base + field->ofs); ! 248: switch (field->type) ! 249: { ! 250: case F_LSTRING: ! 251: case F_GSTRING: ! 252: if ( *(char **)p ) ! 253: { ! 254: len = strlen(*(char **)p) + 1; ! 255: fwrite (*(char **)p, len, 1, f); ! 256: } ! 257: break; ! 258: } ! 259: } ! 260: ! 261: void ReadField (FILE *f, field_t *field, byte *base) ! 262: { ! 263: void *p; ! 264: int len; ! 265: int index; ! 266: ! 267: p = (void *)(base + field->ofs); ! 268: switch (field->type) ! 269: { ! 270: case F_INT: ! 271: case F_FLOAT: ! 272: case F_ANGLEHACK: ! 273: case F_VECTOR: ! 274: case F_IGNORE: ! 275: break; ! 276: ! 277: case F_LSTRING: ! 278: len = *(int *)p; ! 279: if (!len) ! 280: *(char **)p = NULL; ! 281: else ! 282: { ! 283: *(char **)p = gi.TagMalloc (len, TAG_LEVEL); ! 284: fread (*(char **)p, len, 1, f); ! 285: } ! 286: break; ! 287: case F_GSTRING: ! 288: len = *(int *)p; ! 289: if (!len) ! 290: *(char **)p = NULL; ! 291: else ! 292: { ! 293: *(char **)p = gi.TagMalloc (len, TAG_GAME); ! 294: fread (*(char **)p, len, 1, f); ! 295: } ! 296: break; ! 297: case F_EDICT: ! 298: index = *(int *)p; ! 299: if ( index == -1 ) ! 300: *(edict_t **)p = NULL; ! 301: else ! 302: *(edict_t **)p = &g_edicts[index]; ! 303: break; ! 304: case F_CLIENT: ! 305: index = *(int *)p; ! 306: if ( index == -1 ) ! 307: *(gclient_t **)p = NULL; ! 308: else ! 309: *(gclient_t **)p = &game.clients[index]; ! 310: break; ! 311: case F_ITEM: ! 312: index = *(int *)p; ! 313: if ( index == -1 ) ! 314: *(gitem_t **)p = NULL; ! 315: else ! 316: *(gitem_t **)p = &itemlist[index]; ! 317: break; ! 318: ! 319: default: ! 320: gi.error ("ReadEdict: unknown field type"); ! 321: } ! 322: } ! 323: ! 324: //========================================================= ! 325: ! 326: /* ! 327: ============== ! 328: WriteClient ! 329: ! 330: All pointer variables (except function pointers) must be handled specially. ! 331: ============== ! 332: */ ! 333: void WriteClient (FILE *f, gclient_t *client) ! 334: { ! 335: field_t *field; ! 336: gclient_t temp; ! 337: ! 338: // all of the ints, floats, and vectors stay as they are ! 339: temp = *client; ! 340: ! 341: // change the pointers to lengths or indexes ! 342: for (field=clientfields ; field->name ; field++) ! 343: { ! 344: WriteField1 (f, field, (byte *)&temp); ! 345: } ! 346: ! 347: // write the block ! 348: fwrite (&temp, sizeof(temp), 1, f); ! 349: ! 350: // now write any allocated data following the edict ! 351: for (field=clientfields ; field->name ; field++) ! 352: { ! 353: WriteField2 (f, field, (byte *)client); ! 354: } ! 355: } ! 356: ! 357: /* ! 358: ============== ! 359: ReadClient ! 360: ! 361: All pointer variables (except function pointers) must be handled specially. ! 362: ============== ! 363: */ ! 364: void ReadClient (FILE *f, gclient_t *client) ! 365: { ! 366: field_t *field; ! 367: ! 368: fread (client, sizeof(*client), 1, f); ! 369: ! 370: for (field=clientfields ; field->name ; field++) ! 371: { ! 372: ReadField (f, field, (byte *)client); ! 373: } ! 374: } ! 375: ! 376: /* ! 377: ============ ! 378: WriteGame ! 379: ! 380: This will be called whenever the game goes to a new level, ! 381: and when the user explicitly saves the game. ! 382: ! 383: Game information include cross level data, like multi level ! 384: triggers, help computer info, and all client states. ! 385: ! 386: A single player death will automatically restore from the ! 387: last save position. ! 388: ============ ! 389: */ ! 390: void WriteGame (char *filename, qboolean autosave) ! 391: { ! 392: FILE *f; ! 393: int i; ! 394: char str[16]; ! 395: ! 396: if (!autosave) ! 397: SaveClientData (); ! 398: ! 399: f = fopen (filename, "wb"); ! 400: if (!f) ! 401: gi.error ("Couldn't open %s", filename); ! 402: ! 403: memset (str, 0, sizeof(str)); ! 404: strcpy (str, __DATE__); ! 405: fwrite (str, sizeof(str), 1, f); ! 406: ! 407: game.autosaved = autosave; ! 408: fwrite (&game, sizeof(game), 1, f); ! 409: game.autosaved = false; ! 410: ! 411: for (i=0 ; i<game.maxclients ; i++) ! 412: WriteClient (f, &game.clients[i]); ! 413: ! 414: fclose (f); ! 415: } ! 416: ! 417: void ReadGame (char *filename) ! 418: { ! 419: FILE *f; ! 420: int i; ! 421: char str[16]; ! 422: ! 423: gi.FreeTags (TAG_GAME); ! 424: ! 425: f = fopen (filename, "rb"); ! 426: if (!f) ! 427: gi.error ("Couldn't open %s", filename); ! 428: ! 429: fread (str, sizeof(str), 1, f); ! 430: if (strcmp (str, __DATE__)) ! 431: { ! 432: fclose (f); ! 433: gi.error ("Savegame from an older version.\n"); ! 434: } ! 435: ! 436: g_edicts = gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME); ! 437: globals.edicts = g_edicts; ! 438: ! 439: fread (&game, sizeof(game), 1, f); ! 440: game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME); ! 441: for (i=0 ; i<game.maxclients ; i++) ! 442: ReadClient (f, &game.clients[i]); ! 443: ! 444: fclose (f); ! 445: } ! 446: ! 447: //========================================================== ! 448: ! 449: ! 450: /* ! 451: ============== ! 452: WriteEdict ! 453: ! 454: All pointer variables (except function pointers) must be handled specially. ! 455: ============== ! 456: */ ! 457: void WriteEdict (FILE *f, edict_t *ent) ! 458: { ! 459: field_t *field; ! 460: edict_t temp; ! 461: ! 462: // all of the ints, floats, and vectors stay as they are ! 463: temp = *ent; ! 464: ! 465: // change the pointers to lengths or indexes ! 466: for (field=savefields ; field->name ; field++) ! 467: { ! 468: WriteField1 (f, field, (byte *)&temp); ! 469: } ! 470: ! 471: // write the block ! 472: fwrite (&temp, sizeof(temp), 1, f); ! 473: ! 474: // now write any allocated data following the edict ! 475: for (field=savefields ; field->name ; field++) ! 476: { ! 477: WriteField2 (f, field, (byte *)ent); ! 478: } ! 479: ! 480: } ! 481: ! 482: /* ! 483: ============== ! 484: WriteLevelLocals ! 485: ! 486: All pointer variables (except function pointers) must be handled specially. ! 487: ============== ! 488: */ ! 489: void WriteLevelLocals (FILE *f) ! 490: { ! 491: field_t *field; ! 492: level_locals_t temp; ! 493: ! 494: // all of the ints, floats, and vectors stay as they are ! 495: temp = level; ! 496: ! 497: // change the pointers to lengths or indexes ! 498: for (field=levelfields ; field->name ; field++) ! 499: { ! 500: WriteField1 (f, field, (byte *)&temp); ! 501: } ! 502: ! 503: // write the block ! 504: fwrite (&temp, sizeof(temp), 1, f); ! 505: ! 506: // now write any allocated data following the edict ! 507: for (field=levelfields ; field->name ; field++) ! 508: { ! 509: WriteField2 (f, field, (byte *)&level); ! 510: } ! 511: } ! 512: ! 513: ! 514: /* ! 515: ============== ! 516: ReadEdict ! 517: ! 518: All pointer variables (except function pointers) must be handled specially. ! 519: ============== ! 520: */ ! 521: void ReadEdict (FILE *f, edict_t *ent) ! 522: { ! 523: field_t *field; ! 524: ! 525: fread (ent, sizeof(*ent), 1, f); ! 526: ! 527: for (field=savefields ; field->name ; field++) ! 528: { ! 529: ReadField (f, field, (byte *)ent); ! 530: } ! 531: } ! 532: ! 533: /* ! 534: ============== ! 535: ReadLevelLocals ! 536: ! 537: All pointer variables (except function pointers) must be handled specially. ! 538: ============== ! 539: */ ! 540: void ReadLevelLocals (FILE *f) ! 541: { ! 542: field_t *field; ! 543: ! 544: fread (&level, sizeof(level), 1, f); ! 545: ! 546: for (field=levelfields ; field->name ; field++) ! 547: { ! 548: ReadField (f, field, (byte *)&level); ! 549: } ! 550: } ! 551: ! 552: /* ! 553: ================= ! 554: WriteLevel ! 555: ! 556: ================= ! 557: */ ! 558: void WriteLevel (char *filename) ! 559: { ! 560: int i; ! 561: edict_t *ent; ! 562: FILE *f; ! 563: void *base; ! 564: ! 565: f = fopen (filename, "wb"); ! 566: if (!f) ! 567: gi.error ("Couldn't open %s", filename); ! 568: ! 569: // write out edict size for checking ! 570: i = sizeof(edict_t); ! 571: fwrite (&i, sizeof(i), 1, f); ! 572: ! 573: // write out a function pointer for checking ! 574: base = (void *)InitGame; ! 575: fwrite (&base, sizeof(base), 1, f); ! 576: ! 577: // write out level_locals_t ! 578: WriteLevelLocals (f); ! 579: ! 580: // write out all the entities ! 581: for (i=0 ; i<globals.num_edicts ; i++) ! 582: { ! 583: ent = &g_edicts[i]; ! 584: if (!ent->inuse) ! 585: continue; ! 586: fwrite (&i, sizeof(i), 1, f); ! 587: WriteEdict (f, ent); ! 588: } ! 589: i = -1; ! 590: fwrite (&i, sizeof(i), 1, f); ! 591: ! 592: fclose (f); ! 593: } ! 594: ! 595: ! 596: /* ! 597: ================= ! 598: ReadLevel ! 599: ! 600: SpawnEntities will already have been called on the ! 601: level the same way it was when the level was saved. ! 602: ! 603: That is necessary to get the baselines ! 604: set up identically. ! 605: ! 606: The server will have cleared all of the world links before ! 607: calling ReadLevel. ! 608: ! 609: No clients are connected yet. ! 610: ================= ! 611: */ ! 612: void ReadLevel (char *filename) ! 613: { ! 614: int entnum; ! 615: FILE *f; ! 616: int i; ! 617: void *base; ! 618: edict_t *ent; ! 619: ! 620: f = fopen (filename, "rb"); ! 621: if (!f) ! 622: gi.error ("Couldn't open %s", filename); ! 623: ! 624: // free any dynamic memory allocated by loading the level ! 625: // base state ! 626: gi.FreeTags (TAG_LEVEL); ! 627: ! 628: // wipe all the entities ! 629: memset (g_edicts, 0, game.maxentities*sizeof(g_edicts[0])); ! 630: globals.num_edicts = maxclients->value+1; ! 631: ! 632: // check edict size ! 633: fread (&i, sizeof(i), 1, f); ! 634: if (i != sizeof(edict_t)) ! 635: { ! 636: fclose (f); ! 637: gi.error ("ReadLevel: mismatched edict size"); ! 638: } ! 639: ! 640: // check function pointer base address ! 641: fread (&base, sizeof(base), 1, f); ! 642: if (base != (void *)InitGame) ! 643: { ! 644: fclose (f); ! 645: gi.error ("ReadLevel: function pointers have moved"); ! 646: } ! 647: ! 648: // load the level locals ! 649: ReadLevelLocals (f); ! 650: ! 651: // load all the entities ! 652: while (1) ! 653: { ! 654: if (fread (&entnum, sizeof(entnum), 1, f) != 1) ! 655: { ! 656: fclose (f); ! 657: gi.error ("ReadLevel: failed to read entnum"); ! 658: } ! 659: if (entnum == -1) ! 660: break; ! 661: if (entnum >= globals.num_edicts) ! 662: globals.num_edicts = entnum+1; ! 663: ! 664: ent = &g_edicts[entnum]; ! 665: ReadEdict (f, ent); ! 666: ! 667: // let the server rebuild world links for this ent ! 668: memset (&ent->area, 0, sizeof(ent->area)); ! 669: gi.linkentity (ent); ! 670: } ! 671: ! 672: fclose (f); ! 673: ! 674: // mark all clients as unconnected ! 675: for (i=0 ; i<maxclients->value ; i++) ! 676: { ! 677: ent = &g_edicts[i+1]; ! 678: ent->client = game.clients + i; ! 679: ent->client->pers.connected = false; ! 680: } ! 681: ! 682: // do any load time things at this point ! 683: for (i=0 ; i<globals.num_edicts ; i++) ! 684: { ! 685: ent = &g_edicts[i]; ! 686: ! 687: if (!ent->inuse) ! 688: continue; ! 689: ! 690: // fire any cross-level triggers ! 691: if (ent->classname) ! 692: if (strcmp(ent->classname, "target_crosslevel_target") == 0) ! 693: ent->nextthink = level.time + ent->delay; ! 694: } ! 695: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.