g_spawn.c (24120B)
1 /* 2 Copyright (C) 1997-2001 Id Software, Inc. 3 4 This program is free software; you can redistribute it and/or 5 modify it under the terms of the GNU General Public License 6 as published by the Free Software Foundation; either version 2 7 of the License, or (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 12 13 See the GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 19 */ 20 21 #include "g_local.h" 22 23 typedef struct 24 { 25 char *name; 26 void (*spawn)(edict_t *ent); 27 } spawn_t; 28 29 30 void SP_item_health (edict_t *self); 31 void SP_item_health_small (edict_t *self); 32 void SP_item_health_large (edict_t *self); 33 void SP_item_health_mega (edict_t *self); 34 35 void SP_info_player_start (edict_t *ent); 36 void SP_info_player_deathmatch (edict_t *ent); 37 void SP_info_player_coop (edict_t *ent); 38 void SP_info_player_intermission (edict_t *ent); 39 40 void SP_func_plat (edict_t *ent); 41 void SP_func_rotating (edict_t *ent); 42 void SP_func_button (edict_t *ent); 43 void SP_func_door (edict_t *ent); 44 void SP_func_door_secret (edict_t *ent); 45 void SP_func_door_rotating (edict_t *ent); 46 void SP_func_water (edict_t *ent); 47 void SP_func_train (edict_t *ent); 48 void SP_func_conveyor (edict_t *self); 49 void SP_func_wall (edict_t *self); 50 void SP_func_object (edict_t *self); 51 void SP_func_explosive (edict_t *self); 52 void SP_func_timer (edict_t *self); 53 void SP_func_areaportal (edict_t *ent); 54 void SP_func_clock (edict_t *ent); 55 void SP_func_killbox (edict_t *ent); 56 57 void SP_trigger_always (edict_t *ent); 58 void SP_trigger_once (edict_t *ent); 59 void SP_trigger_multiple (edict_t *ent); 60 void SP_trigger_relay (edict_t *ent); 61 void SP_trigger_push (edict_t *ent); 62 void SP_trigger_hurt (edict_t *ent); 63 void SP_trigger_key (edict_t *ent); 64 void SP_trigger_counter (edict_t *ent); 65 void SP_trigger_elevator (edict_t *ent); 66 void SP_trigger_gravity (edict_t *ent); 67 void SP_trigger_monsterjump (edict_t *ent); 68 69 void SP_target_temp_entity (edict_t *ent); 70 void SP_target_speaker (edict_t *ent); 71 void SP_target_explosion (edict_t *ent); 72 void SP_target_changelevel (edict_t *ent); 73 void SP_target_secret (edict_t *ent); 74 void SP_target_goal (edict_t *ent); 75 void SP_target_splash (edict_t *ent); 76 void SP_target_spawner (edict_t *ent); 77 void SP_target_blaster (edict_t *ent); 78 void SP_target_crosslevel_trigger (edict_t *ent); 79 void SP_target_crosslevel_target (edict_t *ent); 80 void SP_target_laser (edict_t *self); 81 void SP_target_help (edict_t *ent); 82 void SP_target_actor (edict_t *ent); 83 void SP_target_lightramp (edict_t *self); 84 void SP_target_earthquake (edict_t *ent); 85 void SP_target_character (edict_t *ent); 86 void SP_target_string (edict_t *ent); 87 88 void SP_worldspawn (edict_t *ent); 89 void SP_viewthing (edict_t *ent); 90 91 void SP_light (edict_t *self); 92 void SP_light_mine1 (edict_t *ent); 93 void SP_light_mine2 (edict_t *ent); 94 void SP_info_null (edict_t *self); 95 void SP_info_notnull (edict_t *self); 96 void SP_path_corner (edict_t *self); 97 void SP_point_combat (edict_t *self); 98 99 void SP_misc_explobox (edict_t *self); 100 void SP_misc_banner (edict_t *self); 101 void SP_misc_satellite_dish (edict_t *self); 102 void SP_misc_actor (edict_t *self); 103 void SP_misc_gib_arm (edict_t *self); 104 void SP_misc_gib_leg (edict_t *self); 105 void SP_misc_gib_head (edict_t *self); 106 void SP_misc_insane (edict_t *self); 107 void SP_misc_deadsoldier (edict_t *self); 108 void SP_misc_viper (edict_t *self); 109 void SP_misc_viper_bomb (edict_t *self); 110 void SP_misc_bigviper (edict_t *self); 111 void SP_misc_strogg_ship (edict_t *self); 112 void SP_misc_teleporter (edict_t *self); 113 void SP_misc_teleporter_dest (edict_t *self); 114 void SP_misc_blackhole (edict_t *self); 115 void SP_misc_eastertank (edict_t *self); 116 void SP_misc_easterchick (edict_t *self); 117 void SP_misc_easterchick2 (edict_t *self); 118 119 void SP_monster_berserk (edict_t *self); 120 void SP_monster_gladiator (edict_t *self); 121 void SP_monster_gunner (edict_t *self); 122 void SP_monster_infantry (edict_t *self); 123 void SP_monster_soldier_light (edict_t *self); 124 void SP_monster_soldier (edict_t *self); 125 void SP_monster_soldier_ss (edict_t *self); 126 void SP_monster_tank (edict_t *self); 127 void SP_monster_medic (edict_t *self); 128 void SP_monster_flipper (edict_t *self); 129 void SP_monster_chick (edict_t *self); 130 void SP_monster_parasite (edict_t *self); 131 void SP_monster_flyer (edict_t *self); 132 void SP_monster_brain (edict_t *self); 133 void SP_monster_floater (edict_t *self); 134 void SP_monster_hover (edict_t *self); 135 void SP_monster_mutant (edict_t *self); 136 void SP_monster_supertank (edict_t *self); 137 void SP_monster_boss2 (edict_t *self); 138 void SP_monster_jorg (edict_t *self); 139 void SP_monster_boss3_stand (edict_t *self); 140 141 void SP_monster_commander_body (edict_t *self); 142 143 void SP_turret_breach (edict_t *self); 144 void SP_turret_base (edict_t *self); 145 void SP_turret_driver (edict_t *self); 146 147 148 spawn_t spawns[] = { 149 {"item_health", SP_item_health}, 150 {"item_health_small", SP_item_health_small}, 151 {"item_health_large", SP_item_health_large}, 152 {"item_health_mega", SP_item_health_mega}, 153 154 {"info_player_start", SP_info_player_start}, 155 {"info_player_deathmatch", SP_info_player_deathmatch}, 156 {"info_player_coop", SP_info_player_coop}, 157 {"info_player_intermission", SP_info_player_intermission}, 158 //ZOID 159 {"info_player_team1", SP_info_player_team1}, 160 {"info_player_team2", SP_info_player_team2}, 161 //ZOID 162 163 {"func_plat", SP_func_plat}, 164 {"func_button", SP_func_button}, 165 {"func_door", SP_func_door}, 166 {"func_door_secret", SP_func_door_secret}, 167 {"func_door_rotating", SP_func_door_rotating}, 168 {"func_rotating", SP_func_rotating}, 169 {"func_train", SP_func_train}, 170 {"func_water", SP_func_water}, 171 {"func_conveyor", SP_func_conveyor}, 172 {"func_areaportal", SP_func_areaportal}, 173 {"func_clock", SP_func_clock}, 174 {"func_wall", SP_func_wall}, 175 {"func_object", SP_func_object}, 176 {"func_timer", SP_func_timer}, 177 {"func_explosive", SP_func_explosive}, 178 {"func_killbox", SP_func_killbox}, 179 180 {"trigger_always", SP_trigger_always}, 181 {"trigger_once", SP_trigger_once}, 182 {"trigger_multiple", SP_trigger_multiple}, 183 {"trigger_relay", SP_trigger_relay}, 184 {"trigger_push", SP_trigger_push}, 185 {"trigger_hurt", SP_trigger_hurt}, 186 {"trigger_key", SP_trigger_key}, 187 {"trigger_counter", SP_trigger_counter}, 188 {"trigger_elevator", SP_trigger_elevator}, 189 {"trigger_gravity", SP_trigger_gravity}, 190 {"trigger_monsterjump", SP_trigger_monsterjump}, 191 192 {"target_temp_entity", SP_target_temp_entity}, 193 {"target_speaker", SP_target_speaker}, 194 {"target_explosion", SP_target_explosion}, 195 {"target_changelevel", SP_target_changelevel}, 196 {"target_secret", SP_target_secret}, 197 {"target_goal", SP_target_goal}, 198 {"target_splash", SP_target_splash}, 199 {"target_spawner", SP_target_spawner}, 200 {"target_blaster", SP_target_blaster}, 201 {"target_crosslevel_trigger", SP_target_crosslevel_trigger}, 202 {"target_crosslevel_target", SP_target_crosslevel_target}, 203 {"target_laser", SP_target_laser}, 204 {"target_help", SP_target_help}, 205 #if 0 // remove monster code 206 {"target_actor", SP_target_actor}, 207 #endif 208 {"target_lightramp", SP_target_lightramp}, 209 {"target_earthquake", SP_target_earthquake}, 210 {"target_character", SP_target_character}, 211 {"target_string", SP_target_string}, 212 213 {"worldspawn", SP_worldspawn}, 214 {"viewthing", SP_viewthing}, 215 216 {"light", SP_light}, 217 {"light_mine1", SP_light_mine1}, 218 {"light_mine2", SP_light_mine2}, 219 {"info_null", SP_info_null}, 220 {"func_group", SP_info_null}, 221 {"info_notnull", SP_info_notnull}, 222 {"path_corner", SP_path_corner}, 223 {"point_combat", SP_point_combat}, 224 225 {"misc_explobox", SP_misc_explobox}, 226 {"misc_banner", SP_misc_banner}, 227 //ZOID 228 {"misc_ctf_banner", SP_misc_ctf_banner}, 229 {"misc_ctf_small_banner", SP_misc_ctf_small_banner}, 230 //ZOID 231 {"misc_satellite_dish", SP_misc_satellite_dish}, 232 #if 0 // remove monster code 233 {"misc_actor", SP_misc_actor}, 234 #endif 235 {"misc_gib_arm", SP_misc_gib_arm}, 236 {"misc_gib_leg", SP_misc_gib_leg}, 237 {"misc_gib_head", SP_misc_gib_head}, 238 #if 0 // remove monster code 239 {"misc_insane", SP_misc_insane}, 240 #endif 241 {"misc_deadsoldier", SP_misc_deadsoldier}, 242 {"misc_viper", SP_misc_viper}, 243 {"misc_viper_bomb", SP_misc_viper_bomb}, 244 {"misc_bigviper", SP_misc_bigviper}, 245 {"misc_strogg_ship", SP_misc_strogg_ship}, 246 {"misc_teleporter", SP_misc_teleporter}, 247 {"misc_teleporter_dest", SP_misc_teleporter_dest}, 248 //ZOID 249 {"trigger_teleport", SP_trigger_teleport}, 250 {"info_teleport_destination", SP_info_teleport_destination}, 251 //ZOID 252 {"misc_blackhole", SP_misc_blackhole}, 253 {"misc_eastertank", SP_misc_eastertank}, 254 {"misc_easterchick", SP_misc_easterchick}, 255 {"misc_easterchick2", SP_misc_easterchick2}, 256 257 #if 0 // remove monster code 258 {"monster_berserk", SP_monster_berserk}, 259 {"monster_gladiator", SP_monster_gladiator}, 260 {"monster_gunner", SP_monster_gunner}, 261 {"monster_infantry", SP_monster_infantry}, 262 {"monster_soldier_light", SP_monster_soldier_light}, 263 {"monster_soldier", SP_monster_soldier}, 264 {"monster_soldier_ss", SP_monster_soldier_ss}, 265 {"monster_tank", SP_monster_tank}, 266 {"monster_tank_commander", SP_monster_tank}, 267 {"monster_medic", SP_monster_medic}, 268 {"monster_flipper", SP_monster_flipper}, 269 {"monster_chick", SP_monster_chick}, 270 {"monster_parasite", SP_monster_parasite}, 271 {"monster_flyer", SP_monster_flyer}, 272 {"monster_brain", SP_monster_brain}, 273 {"monster_floater", SP_monster_floater}, 274 {"monster_hover", SP_monster_hover}, 275 {"monster_mutant", SP_monster_mutant}, 276 {"monster_supertank", SP_monster_supertank}, 277 {"monster_boss2", SP_monster_boss2}, 278 {"monster_boss3_stand", SP_monster_boss3_stand}, 279 {"monster_jorg", SP_monster_jorg}, 280 281 {"monster_commander_body", SP_monster_commander_body}, 282 283 {"turret_breach", SP_turret_breach}, 284 {"turret_base", SP_turret_base}, 285 {"turret_driver", SP_turret_driver}, 286 #endif 287 288 {NULL, NULL} 289 }; 290 291 /* 292 =============== 293 ED_CallSpawn 294 295 Finds the spawn function for the entity and calls it 296 =============== 297 */ 298 void ED_CallSpawn (edict_t *ent) 299 { 300 spawn_t *s; 301 gitem_t *item; 302 int i; 303 304 if (!ent->classname) 305 { 306 gi.dprintf ("ED_CallSpawn: NULL classname\n"); 307 return; 308 } 309 310 // check item spawn functions 311 for (i=0,item=itemlist ; i<game.num_items ; i++,item++) 312 { 313 if (!item->classname) 314 continue; 315 if (!strcmp(item->classname, ent->classname)) 316 { // found it 317 SpawnItem (ent, item); 318 return; 319 } 320 } 321 322 // check normal spawn functions 323 for (s=spawns ; s->name ; s++) 324 { 325 if (!strcmp(s->name, ent->classname)) 326 { // found it 327 s->spawn (ent); 328 return; 329 } 330 } 331 gi.dprintf ("%s doesn't have a spawn function\n", ent->classname); 332 } 333 334 /* 335 ============= 336 ED_NewString 337 ============= 338 */ 339 char *ED_NewString (char *string) 340 { 341 char *newb, *new_p; 342 int i,l; 343 344 l = strlen(string) + 1; 345 346 newb = gi.TagMalloc (l, TAG_LEVEL); 347 348 new_p = newb; 349 350 for (i=0 ; i< l ; i++) 351 { 352 if (string[i] == '\\' && i < l-1) 353 { 354 i++; 355 if (string[i] == 'n') 356 *new_p++ = '\n'; 357 else 358 *new_p++ = '\\'; 359 } 360 else 361 *new_p++ = string[i]; 362 } 363 364 return newb; 365 } 366 367 368 369 370 /* 371 =============== 372 ED_ParseField 373 374 Takes a key/value pair and sets the binary values 375 in an edict 376 =============== 377 */ 378 void ED_ParseField (char *key, char *value, edict_t *ent) 379 { 380 field_t *f; 381 byte *b; 382 float v; 383 vec3_t vec; 384 385 for (f=fields ; f->name ; f++) 386 { 387 if (!Q_stricmp(f->name, key)) 388 { // found it 389 if (f->flags & FFL_SPAWNTEMP) 390 b = (byte *)&st; 391 else 392 b = (byte *)ent; 393 394 switch (f->type) 395 { 396 case F_LSTRING: 397 *(char **)(b+f->ofs) = ED_NewString (value); 398 break; 399 case F_VECTOR: 400 sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]); 401 ((float *)(b+f->ofs))[0] = vec[0]; 402 ((float *)(b+f->ofs))[1] = vec[1]; 403 ((float *)(b+f->ofs))[2] = vec[2]; 404 break; 405 case F_INT: 406 *(int *)(b+f->ofs) = atoi(value); 407 break; 408 case F_FLOAT: 409 *(float *)(b+f->ofs) = atof(value); 410 break; 411 case F_ANGLEHACK: 412 v = atof(value); 413 ((float *)(b+f->ofs))[0] = 0; 414 ((float *)(b+f->ofs))[1] = v; 415 ((float *)(b+f->ofs))[2] = 0; 416 break; 417 case F_IGNORE: 418 break; 419 } 420 return; 421 } 422 } 423 gi.dprintf ("%s is not a field\n", key); 424 } 425 426 /* 427 ==================== 428 ED_ParseEdict 429 430 Parses an edict out of the given string, returning the new position 431 ed should be a properly initialized empty edict. 432 ==================== 433 */ 434 char *ED_ParseEdict (char *data, edict_t *ent) 435 { 436 qboolean init; 437 char keyname[256]; 438 char *com_token; 439 440 init = false; 441 memset (&st, 0, sizeof(st)); 442 443 // go through all the dictionary pairs 444 while (1) 445 { 446 // parse key 447 com_token = COM_Parse (&data); 448 if (com_token[0] == '}') 449 break; 450 if (!data) 451 gi.error ("ED_ParseEntity: EOF without closing brace"); 452 453 strncpy (keyname, com_token, sizeof(keyname)-1); 454 455 // parse value 456 com_token = COM_Parse (&data); 457 if (!data) 458 gi.error ("ED_ParseEntity: EOF without closing brace"); 459 460 if (com_token[0] == '}') 461 gi.error ("ED_ParseEntity: closing brace without data"); 462 463 init = true; 464 465 // keynames with a leading underscore are used for utility comments, 466 // and are immediately discarded by quake 467 if (keyname[0] == '_') 468 continue; 469 470 ED_ParseField (keyname, com_token, ent); 471 } 472 473 if (!init) 474 memset (ent, 0, sizeof(*ent)); 475 476 return data; 477 } 478 479 480 /* 481 ================ 482 G_FindTeams 483 484 Chain together all entities with a matching team field. 485 486 All but the first will have the FL_TEAMSLAVE flag set. 487 All but the last will have the teamchain field set to the next one 488 ================ 489 */ 490 void G_FindTeams (void) 491 { 492 edict_t *e, *e2, *chain; 493 int i, j; 494 int c, c2; 495 496 c = 0; 497 c2 = 0; 498 for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++) 499 { 500 if (!e->inuse) 501 continue; 502 if (!e->team) 503 continue; 504 if (e->flags & FL_TEAMSLAVE) 505 continue; 506 chain = e; 507 e->teammaster = e; 508 c++; 509 c2++; 510 for (j=i+1, e2=e+1 ; j < globals.num_edicts ; j++,e2++) 511 { 512 if (!e2->inuse) 513 continue; 514 if (!e2->team) 515 continue; 516 if (e2->flags & FL_TEAMSLAVE) 517 continue; 518 if (!strcmp(e->team, e2->team)) 519 { 520 c2++; 521 chain->teamchain = e2; 522 e2->teammaster = e; 523 chain = e2; 524 e2->flags |= FL_TEAMSLAVE; 525 } 526 } 527 } 528 529 gi.dprintf ("%i teams with %i entities\n", c, c2); 530 } 531 532 /* 533 ============== 534 SpawnEntities 535 536 Creates a server's entity / program execution context by 537 parsing textual entity definitions out of an ent file. 538 ============== 539 */ 540 void SpawnEntities (char *mapname, char *entities, char *spawnpoint) 541 { 542 edict_t *ent; 543 int inhibit; 544 char *com_token; 545 int i; 546 float skill_level; 547 548 skill_level = floor (skill->value); 549 if (skill_level < 0) 550 skill_level = 0; 551 if (skill_level > 3) 552 skill_level = 3; 553 if (skill->value != skill_level) 554 gi.cvar_forceset("skill", va("%f", skill_level)); 555 556 SaveClientData (); 557 558 gi.FreeTags (TAG_LEVEL); 559 560 memset (&level, 0, sizeof(level)); 561 memset (g_edicts, 0, game.maxentities * sizeof (g_edicts[0])); 562 563 strncpy (level.mapname, mapname, sizeof(level.mapname)-1); 564 strncpy (game.spawnpoint, spawnpoint, sizeof(game.spawnpoint)-1); 565 566 // set client fields on player ents 567 for (i=0 ; i<game.maxclients ; i++) 568 g_edicts[i+1].client = game.clients + i; 569 570 ent = NULL; 571 inhibit = 0; 572 573 // parse ents 574 while (1) 575 { 576 // parse the opening brace 577 com_token = COM_Parse (&entities); 578 if (!entities) 579 break; 580 if (com_token[0] != '{') 581 gi.error ("ED_LoadFromFile: found %s when expecting {",com_token); 582 583 if (!ent) 584 ent = g_edicts; 585 else 586 ent = G_Spawn (); 587 entities = ED_ParseEdict (entities, ent); 588 589 // yet another map hack 590 if (!stricmp(level.mapname, "command") && !stricmp(ent->classname, "trigger_once") && !stricmp(ent->model, "*27")) 591 ent->spawnflags &= ~SPAWNFLAG_NOT_HARD; 592 593 // remove things (except the world) from different skill levels or deathmatch 594 if (ent != g_edicts) 595 { 596 if (deathmatch->value) 597 { 598 if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH ) 599 { 600 G_FreeEdict (ent); 601 inhibit++; 602 continue; 603 } 604 } 605 else 606 { 607 if ( /* ((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */ 608 ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) || 609 ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) || 610 (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD)) 611 ) 612 { 613 G_FreeEdict (ent); 614 inhibit++; 615 continue; 616 } 617 } 618 619 ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH); 620 } 621 622 ED_CallSpawn (ent); 623 } 624 625 gi.dprintf ("%i entities inhibited\n", inhibit); 626 627 G_FindTeams (); 628 629 PlayerTrail_Init (); 630 631 //ZOID 632 CTFSpawn(); 633 //ZOID 634 } 635 636 637 //=================================================================== 638 639 #if 0 640 // cursor positioning 641 xl <value> 642 xr <value> 643 yb <value> 644 yt <value> 645 xv <value> 646 yv <value> 647 648 // drawing 649 statpic <name> 650 pic <stat> 651 num <fieldwidth> <stat> 652 string <stat> 653 654 // control 655 if <stat> 656 ifeq <stat> <value> 657 ifbit <stat> <value> 658 endif 659 660 #endif 661 662 char *single_statusbar = 663 "yb -24 " 664 665 // health 666 "xv 0 " 667 "hnum " 668 "xv 50 " 669 "pic 0 " 670 671 // ammo 672 "if 2 " 673 " xv 100 " 674 " anum " 675 " xv 150 " 676 " pic 2 " 677 "endif " 678 679 // armor 680 "if 4 " 681 " xv 200 " 682 " rnum " 683 " xv 250 " 684 " pic 4 " 685 "endif " 686 687 // selected item 688 "if 6 " 689 " xv 296 " 690 " pic 6 " 691 "endif " 692 693 "yb -50 " 694 695 // picked up item 696 "if 7 " 697 " xv 0 " 698 " pic 7 " 699 " xv 26 " 700 " yb -42 " 701 " stat_string 8 " 702 " yb -50 " 703 "endif " 704 705 // timer 706 "if 9 " 707 " xv 262 " 708 " num 2 10 " 709 " xv 296 " 710 " pic 9 " 711 "endif " 712 713 // help / weapon icon 714 "if 11 " 715 " xv 148 " 716 " pic 11 " 717 "endif " 718 ; 719 720 char *dm_statusbar = 721 "yb -24 " 722 723 // health 724 "xv 0 " 725 "hnum " 726 "xv 50 " 727 "pic 0 " 728 729 // ammo 730 "if 2 " 731 " xv 100 " 732 " anum " 733 " xv 150 " 734 " pic 2 " 735 "endif " 736 737 // armor 738 "if 4 " 739 " xv 200 " 740 " rnum " 741 " xv 250 " 742 " pic 4 " 743 "endif " 744 745 // selected item 746 "if 6 " 747 " xv 296 " 748 " pic 6 " 749 "endif " 750 751 "yb -50 " 752 753 // picked up item 754 "if 7 " 755 " xv 0 " 756 " pic 7 " 757 " xv 26 " 758 " yb -42 " 759 " stat_string 8 " 760 " yb -50 " 761 "endif " 762 763 // timer 764 "if 9 " 765 " xv 246 " 766 " num 2 10 " 767 " xv 296 " 768 " pic 9 " 769 "endif " 770 771 // help / weapon icon 772 "if 11 " 773 " xv 148 " 774 " pic 11 " 775 "endif " 776 777 // frags 778 "xr -50 " 779 "yt 2 " 780 "num 3 14" 781 ; 782 783 784 /*QUAKED worldspawn (0 0 0) ? 785 786 Only used for the world. 787 "sky" environment map name 788 "skyaxis" vector axis for rotating sky 789 "skyrotate" speed of rotation in degrees/second 790 "sounds" music cd track number 791 "gravity" 800 is default gravity 792 "message" text to print at user logon 793 */ 794 void SP_worldspawn (edict_t *ent) 795 { 796 ent->movetype = MOVETYPE_PUSH; 797 ent->solid = SOLID_BSP; 798 ent->inuse = true; // since the world doesn't use G_Spawn() 799 ent->s.modelindex = 1; // world model is always index 1 800 801 //--------------- 802 803 // reserve some spots for dead player bodies for coop / deathmatch 804 InitBodyQue (); 805 806 // set configstrings for items 807 SetItemNames (); 808 809 if (st.nextmap) 810 strcpy (level.nextmap, st.nextmap); 811 812 // make some data visible to the server 813 814 if (ent->message && ent->message[0]) 815 { 816 gi.configstring (CS_NAME, ent->message); 817 strncpy (level.level_name, ent->message, sizeof(level.level_name)); 818 } 819 else 820 strncpy (level.level_name, level.mapname, sizeof(level.level_name)); 821 822 if (st.sky && st.sky[0]) 823 gi.configstring (CS_SKY, st.sky); 824 else 825 gi.configstring (CS_SKY, "unit1_"); 826 827 gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) ); 828 829 gi.configstring (CS_SKYAXIS, va("%f %f %f", 830 st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) ); 831 832 gi.configstring (CS_CDTRACK, va("%i", ent->sounds) ); 833 834 gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) ); 835 836 // status bar program 837 if (deathmatch->value) 838 //ZOID 839 if (ctf->value) { 840 gi.configstring (CS_STATUSBAR, ctf_statusbar); 841 //precaches 842 gi.imageindex("i_ctf1"); 843 gi.imageindex("i_ctf2"); 844 gi.imageindex("i_ctf1d"); 845 gi.imageindex("i_ctf2d"); 846 gi.imageindex("i_ctf1t"); 847 gi.imageindex("i_ctf2t"); 848 gi.imageindex("i_ctfj"); 849 } else 850 //ZOID 851 gi.configstring (CS_STATUSBAR, dm_statusbar); 852 else 853 gi.configstring (CS_STATUSBAR, single_statusbar); 854 855 //--------------- 856 857 858 // help icon for statusbar 859 gi.imageindex ("i_help"); 860 level.pic_health = gi.imageindex ("i_health"); 861 gi.imageindex ("help"); 862 gi.imageindex ("field_3"); 863 864 if (!st.gravity) 865 gi.cvar_set("sv_gravity", "800"); 866 else 867 gi.cvar_set("sv_gravity", st.gravity); 868 869 snd_fry = gi.soundindex ("player/fry.wav"); // standing in lava / slime 870 871 PrecacheItem (FindItem ("Blaster")); 872 873 gi.soundindex ("player/lava1.wav"); 874 gi.soundindex ("player/lava2.wav"); 875 876 gi.soundindex ("misc/pc_up.wav"); 877 gi.soundindex ("misc/talk1.wav"); 878 879 gi.soundindex ("misc/udeath.wav"); 880 881 // gibs 882 gi.soundindex ("items/respawn1.wav"); 883 884 // sexed sounds 885 gi.soundindex ("*death1.wav"); 886 gi.soundindex ("*death2.wav"); 887 gi.soundindex ("*death3.wav"); 888 gi.soundindex ("*death4.wav"); 889 gi.soundindex ("*fall1.wav"); 890 gi.soundindex ("*fall2.wav"); 891 gi.soundindex ("*gurp1.wav"); // drowning damage 892 gi.soundindex ("*gurp2.wav"); 893 gi.soundindex ("*jump1.wav"); // player jump 894 gi.soundindex ("*pain25_1.wav"); 895 gi.soundindex ("*pain25_2.wav"); 896 gi.soundindex ("*pain50_1.wav"); 897 gi.soundindex ("*pain50_2.wav"); 898 gi.soundindex ("*pain75_1.wav"); 899 gi.soundindex ("*pain75_2.wav"); 900 gi.soundindex ("*pain100_1.wav"); 901 gi.soundindex ("*pain100_2.wav"); 902 903 #if 0 //DISABLED 904 // sexed models 905 // THIS ORDER MUST MATCH THE DEFINES IN g_local.h 906 // you can add more, max 15 907 gi.modelindex ("#w_blaster.md2"); 908 gi.modelindex ("#w_shotgun.md2"); 909 gi.modelindex ("#w_sshotgun.md2"); 910 gi.modelindex ("#w_machinegun.md2"); 911 gi.modelindex ("#w_chaingun.md2"); 912 gi.modelindex ("#a_grenades.md2"); 913 gi.modelindex ("#w_glauncher.md2"); 914 gi.modelindex ("#w_rlauncher.md2"); 915 gi.modelindex ("#w_hyperblaster.md2"); 916 gi.modelindex ("#w_railgun.md2"); 917 gi.modelindex ("#w_bfg.md2"); 918 gi.modelindex ("#w_grapple.md2"); 919 #endif 920 921 //------------------- 922 923 gi.soundindex ("player/gasp1.wav"); // gasping for air 924 gi.soundindex ("player/gasp2.wav"); // head breaking surface, not gasping 925 926 gi.soundindex ("player/watr_in.wav"); // feet hitting water 927 gi.soundindex ("player/watr_out.wav"); // feet leaving water 928 929 gi.soundindex ("player/watr_un.wav"); // head going underwater 930 931 gi.soundindex ("player/u_breath1.wav"); 932 gi.soundindex ("player/u_breath2.wav"); 933 934 gi.soundindex ("items/pkup.wav"); // bonus item pickup 935 gi.soundindex ("world/land.wav"); // landing thud 936 gi.soundindex ("misc/h2ohit1.wav"); // landing splash 937 938 gi.soundindex ("items/damage.wav"); 939 gi.soundindex ("items/protect.wav"); 940 gi.soundindex ("items/protect4.wav"); 941 gi.soundindex ("weapons/noammo.wav"); 942 943 gi.soundindex ("infantry/inflies1.wav"); 944 945 sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2"); 946 gi.modelindex ("models/objects/gibs/arm/tris.md2"); 947 gi.modelindex ("models/objects/gibs/bone/tris.md2"); 948 gi.modelindex ("models/objects/gibs/bone2/tris.md2"); 949 gi.modelindex ("models/objects/gibs/chest/tris.md2"); 950 gi.modelindex ("models/objects/gibs/skull/tris.md2"); 951 gi.modelindex ("models/objects/gibs/head2/tris.md2"); 952 953 // 954 // Setup light animation tables. 'a' is total darkness, 'z' is doublebright. 955 // 956 957 // 0 normal 958 gi.configstring(CS_LIGHTS+0, "m"); 959 960 // 1 FLICKER (first variety) 961 gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo"); 962 963 // 2 SLOW STRONG PULSE 964 gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba"); 965 966 // 3 CANDLE (first variety) 967 gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg"); 968 969 // 4 FAST STROBE 970 gi.configstring(CS_LIGHTS+4, "mamamamamama"); 971 972 // 5 GENTLE PULSE 1 973 gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj"); 974 975 // 6 FLICKER (second variety) 976 gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno"); 977 978 // 7 CANDLE (second variety) 979 gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm"); 980 981 // 8 CANDLE (third variety) 982 gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa"); 983 984 // 9 SLOW STROBE (fourth variety) 985 gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz"); 986 987 // 10 FLUORESCENT FLICKER 988 gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma"); 989 990 // 11 SLOW PULSE NOT FADE TO BLACK 991 gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba"); 992 993 // styles 32-62 are assigned by the light program for switchable lights 994 995 // 63 testing 996 gi.configstring(CS_LIGHTS+63, "a"); 997 } 998