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