![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_spawn.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_spawn.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 root 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: //ROGUE
130: void SP_func_plat2 (edict_t *ent);
131: void SP_func_door_secret2(edict_t *ent);
132: void SP_func_force_wall(edict_t *ent);
133: void SP_info_player_coop_lava (edict_t *self);
134: void SP_info_teleport_destination (edict_t *self);
135: void SP_trigger_teleport (edict_t *self);
136: void SP_trigger_disguise (edict_t *self);
137: void SP_monster_stalker (edict_t *self);
138: void SP_monster_turret (edict_t *self);
139: void SP_target_steam (edict_t *self);
140: void SP_target_anger (edict_t *self);
141: void SP_target_killplayers (edict_t *self);
142: // PMM - still experimental!
143: void SP_target_blacklight (edict_t *self);
144: void SP_target_orb (edict_t *self);
145: // pmm
146: //void SP_target_spawn (edict_t *self);
147: void SP_hint_path (edict_t *self);
148: void SP_monster_carrier (edict_t *self);
149: void SP_monster_widow (edict_t *self);
150: void SP_monster_widow2 (edict_t *self);
151: void SP_dm_tag_token (edict_t *self);
152: void SP_dm_dball_goal (edict_t *self);
153: void SP_dm_dball_ball (edict_t *self);
154: void SP_dm_dball_team1_start (edict_t *self);
155: void SP_dm_dball_team2_start (edict_t *self);
156: void SP_dm_dball_ball_start (edict_t *self);
157: void SP_dm_dball_speed_change (edict_t *self);
158: void SP_monster_kamikaze (edict_t *self);
159: //void SP_monster_chick2 (edict_t *self);
160: void SP_turret_invisible_brain (edict_t *self);
161: void SP_xatrix_item (edict_t *self);
162: void SP_misc_nuke_core (edict_t *self);
163: //ROGUE
164: //===========
165:
166: spawn_t spawns[] = {
167: {"item_health", SP_item_health},
168: {"item_health_small", SP_item_health_small},
169: {"item_health_large", SP_item_health_large},
170: {"item_health_mega", SP_item_health_mega},
171:
172: {"info_player_start", SP_info_player_start},
173: {"info_player_deathmatch", SP_info_player_deathmatch},
174: {"info_player_coop", SP_info_player_coop},
175: {"info_player_intermission", SP_info_player_intermission},
176:
177: {"func_plat", SP_func_plat},
178: {"func_button", SP_func_button},
179: {"func_door", SP_func_door},
180: {"func_door_secret", SP_func_door_secret},
181: {"func_door_rotating", SP_func_door_rotating},
182: {"func_rotating", SP_func_rotating},
183: {"func_train", SP_func_train},
184: {"func_water", SP_func_water},
185: {"func_conveyor", SP_func_conveyor},
186: {"func_areaportal", SP_func_areaportal},
187: {"func_clock", SP_func_clock},
188: {"func_wall", SP_func_wall},
189: {"func_object", SP_func_object},
190: {"func_timer", SP_func_timer},
191: {"func_explosive", SP_func_explosive},
192: {"func_killbox", SP_func_killbox},
193:
194: {"trigger_always", SP_trigger_always},
195: {"trigger_once", SP_trigger_once},
196: {"trigger_multiple", SP_trigger_multiple},
197: {"trigger_relay", SP_trigger_relay},
198: {"trigger_push", SP_trigger_push},
199: {"trigger_hurt", SP_trigger_hurt},
200: {"trigger_key", SP_trigger_key},
201: {"trigger_counter", SP_trigger_counter},
202: {"trigger_elevator", SP_trigger_elevator},
203: {"trigger_gravity", SP_trigger_gravity},
204: {"trigger_monsterjump", SP_trigger_monsterjump},
205:
206: {"target_temp_entity", SP_target_temp_entity},
207: {"target_speaker", SP_target_speaker},
208: {"target_explosion", SP_target_explosion},
209: {"target_changelevel", SP_target_changelevel},
210: {"target_secret", SP_target_secret},
211: {"target_goal", SP_target_goal},
212: {"target_splash", SP_target_splash},
213: {"target_spawner", SP_target_spawner},
214: {"target_blaster", SP_target_blaster},
215: {"target_crosslevel_trigger", SP_target_crosslevel_trigger},
216: {"target_crosslevel_target", SP_target_crosslevel_target},
217: {"target_laser", SP_target_laser},
218: {"target_help", SP_target_help},
219: {"target_actor", SP_target_actor},
220: {"target_lightramp", SP_target_lightramp},
221: {"target_earthquake", SP_target_earthquake},
222: {"target_character", SP_target_character},
223: {"target_string", SP_target_string},
224:
225: {"worldspawn", SP_worldspawn},
226: {"viewthing", SP_viewthing},
227:
228: {"light", SP_light},
229: {"light_mine1", SP_light_mine1},
230: {"light_mine2", SP_light_mine2},
231: {"info_null", SP_info_null},
232: {"func_group", SP_info_null},
233: {"info_notnull", SP_info_notnull},
234: {"path_corner", SP_path_corner},
235: {"point_combat", SP_point_combat},
236:
237: {"misc_explobox", SP_misc_explobox},
238: {"misc_banner", SP_misc_banner},
239: {"misc_satellite_dish", SP_misc_satellite_dish},
240: {"misc_actor", SP_misc_actor},
241: {"misc_gib_arm", SP_misc_gib_arm},
242: {"misc_gib_leg", SP_misc_gib_leg},
243: {"misc_gib_head", SP_misc_gib_head},
244: {"misc_insane", SP_misc_insane},
245: {"misc_deadsoldier", SP_misc_deadsoldier},
246: {"misc_viper", SP_misc_viper},
247: {"misc_viper_bomb", SP_misc_viper_bomb},
248: {"misc_bigviper", SP_misc_bigviper},
249: {"misc_strogg_ship", SP_misc_strogg_ship},
250: {"misc_teleporter", SP_misc_teleporter},
251: {"misc_teleporter_dest", SP_misc_teleporter_dest},
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: {"monster_berserk", SP_monster_berserk},
258: {"monster_gladiator", SP_monster_gladiator},
259: {"monster_gunner", SP_monster_gunner},
260: {"monster_infantry", SP_monster_infantry},
261: {"monster_soldier_light", SP_monster_soldier_light},
262: {"monster_soldier", SP_monster_soldier},
263: {"monster_soldier_ss", SP_monster_soldier_ss},
264: {"monster_tank", SP_monster_tank},
265: {"monster_tank_commander", SP_monster_tank},
266: {"monster_medic", SP_monster_medic},
267: {"monster_flipper", SP_monster_flipper},
268: {"monster_chick", SP_monster_chick},
269: {"monster_parasite", SP_monster_parasite},
270: {"monster_flyer", SP_monster_flyer},
271: {"monster_brain", SP_monster_brain},
272: {"monster_floater", SP_monster_floater},
273: {"monster_hover", SP_monster_hover},
274: {"monster_mutant", SP_monster_mutant},
275: {"monster_supertank", SP_monster_supertank},
276: {"monster_boss2", SP_monster_boss2},
277: {"monster_boss3_stand", SP_monster_boss3_stand},
278: {"monster_jorg", SP_monster_jorg},
279:
280: {"monster_commander_body", SP_monster_commander_body},
281:
282: {"turret_breach", SP_turret_breach},
283: {"turret_base", SP_turret_base},
284: {"turret_driver", SP_turret_driver},
285:
286: //==============
287: //ROGUE
288: {"func_plat2", SP_func_plat2},
289: {"func_door_secret2", SP_func_door_secret2},
290: {"func_force_wall", SP_func_force_wall},
291: {"trigger_teleport", SP_trigger_teleport},
292: {"trigger_disguise", SP_trigger_disguise},
293: {"info_teleport_destination", SP_info_teleport_destination},
294: {"info_player_coop_lava", SP_info_player_coop_lava},
295: {"monster_stalker", SP_monster_stalker},
296: {"monster_turret", SP_monster_turret},
297: {"target_steam", SP_target_steam},
298: {"target_anger", SP_target_anger},
299: // {"target_spawn", SP_target_spawn},
300: {"target_killplayers", SP_target_killplayers},
301: // PMM - experiment
302: {"target_blacklight", SP_target_blacklight},
303: {"target_orb", SP_target_orb},
304: // pmm
305: {"monster_daedalus", SP_monster_hover},
306: {"hint_path", SP_hint_path},
307: {"monster_carrier", SP_monster_carrier},
308: {"monster_widow", SP_monster_widow},
309: {"monster_widow2", SP_monster_widow2},
310: {"monster_medic_commander", SP_monster_medic},
311: {"dm_tag_token", SP_dm_tag_token},
312: {"dm_dball_goal", SP_dm_dball_goal},
313: {"dm_dball_ball", SP_dm_dball_ball},
314: {"dm_dball_team1_start", SP_dm_dball_team1_start},
315: {"dm_dball_team2_start", SP_dm_dball_team2_start},
316: {"dm_dball_ball_start", SP_dm_dball_ball_start},
317: {"dm_dball_speed_change", SP_dm_dball_speed_change},
318: {"monster_kamikaze", SP_monster_kamikaze},
319: // {"monster_chick2", SP_monster_chick2},
320: {"turret_invisible_brain", SP_turret_invisible_brain},
321: {"misc_nuke_core", SP_misc_nuke_core},
322:
323: {"ammo_magslug", SP_xatrix_item},
324: {"ammo_trap", SP_xatrix_item},
325: {"item_quadfire", SP_xatrix_item},
326: {"weapon_boomer", SP_xatrix_item},
327: {"weapon_phalanx", SP_xatrix_item},
328: //ROGUE
329: //==============
330:
331: {NULL, NULL}
332: };
333:
334: /*
335: ===============
336: ED_CallSpawn
337:
338: Finds the spawn function for the entity and calls it
339: ===============
340: */
341: void ED_CallSpawn (edict_t *ent)
342: {
343: spawn_t *s;
344: gitem_t *item;
345: int i;
346:
347: if (!ent->classname)
348: {
349: gi.dprintf ("ED_CallSpawn: NULL classname\n");
350: return;
351: }
352:
353: //PGM - do this before calling the spawn function so it can be overridden.
354: #ifdef ROGUE_GRAVITY
355: ent->gravityVector[0] = 0.0;
356: ent->gravityVector[1] = 0.0;
357: ent->gravityVector[2] = -1.0;
358: #endif
359: //PGM
360:
361: // FIXME - PMM nailgun hack
362: if (!strcmp(ent->classname, "weapon_nailgun"))
363: ent->classname = (FindItem("ETF Rifle"))->classname;
364: if (!strcmp(ent->classname, "ammo_nails"))
365: ent->classname = (FindItem("Flechettes"))->classname;
366: if (!strcmp(ent->classname, "weapon_heatbeam"))
367: ent->classname = (FindItem("Plasma Beam"))->classname;
368: // pmm
369:
370: // check item spawn functions
371: for (i=0,item=itemlist ; i<game.num_items ; i++,item++)
372: {
373: if (!item->classname)
374: continue;
375: if (!strcmp(item->classname, ent->classname))
376: { // found it
377: SpawnItem (ent, item);
378: return;
379: }
380: }
381:
382: // check normal spawn functions
383: for (s=spawns ; s->name ; s++)
384: {
385: if (!strcmp(s->name, ent->classname))
386: { // found it
387: s->spawn (ent);
388: return;
389: }
390: }
391: gi.dprintf ("%s doesn't have a spawn function\n", ent->classname);
392: }
393:
394: /*
395: =============
396: ED_NewString
397: =============
398: */
399: char *ED_NewString (char *string)
400: {
401: char *newb, *new_p;
402: int i,l;
403:
404: l = strlen(string) + 1;
405:
406: newb = gi.TagMalloc (l, TAG_LEVEL);
407:
408: new_p = newb;
409:
410: for (i=0 ; i< l ; i++)
411: {
412: if (string[i] == '\\' && i < l-1)
413: {
414: i++;
415: if (string[i] == 'n')
416: *new_p++ = '\n';
417: else
418: *new_p++ = '\\';
419: }
420: else
421: *new_p++ = string[i];
422: }
423:
424: return newb;
425: }
426:
427:
428:
429:
430: /*
431: ===============
432: ED_ParseField
433:
434: Takes a key/value pair and sets the binary values
435: in an edict
436: ===============
437: */
438: void ED_ParseField (char *key, char *value, edict_t *ent)
439: {
440: field_t *f;
441: byte *b;
442: float v;
443: vec3_t vec;
444:
445: for (f=fields ; f->name ; f++)
446: {
447: if (!(f->flags & FFL_NOSPAWN) && !Q_stricmp(f->name, key))
448: { // found it
449: if (f->flags & FFL_SPAWNTEMP)
450: b = (byte *)&st;
451: else
452: b = (byte *)ent;
453:
454: switch (f->type)
455: {
456: case F_LSTRING:
457: *(char **)(b+f->ofs) = ED_NewString (value);
458: break;
459: case F_VECTOR:
460: sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
461: ((float *)(b+f->ofs))[0] = vec[0];
462: ((float *)(b+f->ofs))[1] = vec[1];
463: ((float *)(b+f->ofs))[2] = vec[2];
464: break;
465: case F_INT:
466: *(int *)(b+f->ofs) = atoi(value);
467: break;
468: case F_FLOAT:
469: *(float *)(b+f->ofs) = atof(value);
470: break;
471: case F_ANGLEHACK:
472: v = atof(value);
473: ((float *)(b+f->ofs))[0] = 0;
474: ((float *)(b+f->ofs))[1] = v;
475: ((float *)(b+f->ofs))[2] = 0;
476: break;
477: case F_IGNORE:
478: break;
479: }
480: return;
481: }
482: }
483: gi.dprintf ("%s is not a field\n", key);
484: }
485:
486: /*
487: ====================
488: ED_ParseEdict
489:
490: Parses an edict out of the given string, returning the new position
491: ed should be a properly initialized empty edict.
492: ====================
493: */
494: char *ED_ParseEdict (char *data, edict_t *ent)
495: {
496: qboolean init;
497: char keyname[256];
498: char *com_token;
499:
500: init = false;
501: memset (&st, 0, sizeof(st));
502:
503: // go through all the dictionary pairs
504: while (1)
505: {
506: // parse key
507: com_token = COM_Parse (&data);
508: if (com_token[0] == '}')
509: break;
510: if (!data)
511: gi.error ("ED_ParseEntity: EOF without closing brace");
512:
513: strncpy (keyname, com_token, sizeof(keyname)-1);
514:
515: // parse value
516: com_token = COM_Parse (&data);
517: if (!data)
518: gi.error ("ED_ParseEntity: EOF without closing brace");
519:
520: if (com_token[0] == '}')
521: gi.error ("ED_ParseEntity: closing brace without data");
522:
523: init = true;
524:
525: // keynames with a leading underscore are used for utility comments,
526: // and are immediately discarded by quake
527: if (keyname[0] == '_')
528: continue;
529:
530: ED_ParseField (keyname, com_token, ent);
531: }
532:
533: if (!init)
534: memset (ent, 0, sizeof(*ent));
535:
536: return data;
537: }
538:
539:
540: /*
541: ================
542: G_FindTeams
543:
544: Chain together all entities with a matching team field.
545:
546: All but the first will have the FL_TEAMSLAVE flag set.
547: All but the last will have the teamchain field set to the next one
548: ================
549: */
550: void G_FixTeams (void)
551: {
552: edict_t *e, *e2, *chain;
553: int i, j;
554: int c, c2;
555:
556: c = 0;
557: c2 = 0;
558: for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++)
559: {
560: if (!e->inuse)
561: continue;
562: if (!e->team)
563: continue;
564: if (!strcmp(e->classname, "func_train"))
565: {
566: if(e->flags & FL_TEAMSLAVE)
567: {
568: chain = e;
569: e->teammaster = e;
570: e->teamchain = NULL;
571: e->flags &= ~FL_TEAMSLAVE;
572: c++;
573: c2++;
574: for (j=1, e2=g_edicts+j ; j < globals.num_edicts ; j++,e2++)
575: {
576: if (e2 == e)
577: continue;
578: if (!e2->inuse)
579: continue;
580: if (!e2->team)
581: continue;
582: if (!strcmp(e->team, e2->team))
583: {
584: c2++;
585: chain->teamchain = e2;
586: e2->teammaster = e;
587: e2->teamchain = NULL;
588: chain = e2;
589: e2->flags |= FL_TEAMSLAVE;
590: e2->movetype = MOVETYPE_PUSH;
591: e2->speed = e->speed;
592: }
593: }
594: }
595: }
596: }
597: gi.dprintf ("%i teams repaired\n", c);
598: }
599:
600: void G_FindTeams (void)
601: {
602: edict_t *e, *e2, *chain;
603: int i, j;
604: int c, c2;
605:
606: c = 0;
607: c2 = 0;
608: for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++)
609: {
610: if (!e->inuse)
611: continue;
612: if (!e->team)
613: continue;
614: if (e->flags & FL_TEAMSLAVE)
615: continue;
616: chain = e;
617: e->teammaster = e;
618: c++;
619: c2++;
620: for (j=i+1, e2=e+1 ; j < globals.num_edicts ; j++,e2++)
621: {
622: if (!e2->inuse)
623: continue;
624: if (!e2->team)
625: continue;
626: if (e2->flags & FL_TEAMSLAVE)
627: continue;
628: if (!strcmp(e->team, e2->team))
629: {
630: c2++;
631: chain->teamchain = e2;
632: e2->teammaster = e;
633: chain = e2;
634: e2->flags |= FL_TEAMSLAVE;
635: }
636: }
637: }
638:
639: G_FixTeams();
640:
641: gi.dprintf ("%i teams with %i entities\n", c, c2);
642: }
643:
644: /*
645: ==============
646: SpawnEntities
647:
648: Creates a server's entity / program execution context by
649: parsing textual entity definitions out of an ent file.
650: ==============
651: */
652: void SpawnEntities (char *mapname, char *entities, char *spawnpoint)
653: {
654: edict_t *ent;
655: int inhibit;
656: char *com_token;
657: int i;
658: float skill_level;
659:
660: skill_level = floor (skill->value);
661: if (skill_level < 0)
662: skill_level = 0;
663: if (skill_level > 3)
664: skill_level = 3;
665: if (skill->value != skill_level)
666: gi.cvar_forceset("skill", va("%f", skill_level));
667:
668: SaveClientData ();
669:
670: gi.FreeTags (TAG_LEVEL);
671:
672: memset (&level, 0, sizeof(level));
673: memset (g_edicts, 0, game.maxentities * sizeof (g_edicts[0]));
674:
675: strncpy (level.mapname, mapname, sizeof(level.mapname)-1);
676: strncpy (game.spawnpoint, spawnpoint, sizeof(game.spawnpoint)-1);
677:
678: // set client fields on player ents
679: for (i=0 ; i<game.maxclients ; i++)
680: g_edicts[i+1].client = game.clients + i;
681:
682: ent = NULL;
683: inhibit = 0;
684:
685: // parse ents
686: while (1)
687: {
688: // parse the opening brace
689: com_token = COM_Parse (&entities);
690: if (!entities)
691: break;
692: if (com_token[0] != '{')
693: gi.error ("ED_LoadFromFile: found %s when expecting {",com_token);
694:
695: if (!ent)
696: ent = g_edicts;
697: else
698: ent = G_Spawn ();
699: entities = ED_ParseEdict (entities, ent);
700:
701: // yet another map hack
702: if (!Q_stricmp(level.mapname, "command") && !Q_stricmp(ent->classname, "trigger_once") && !Q_stricmp(ent->model, "*27"))
703: ent->spawnflags &= ~SPAWNFLAG_NOT_HARD;
704:
705: // remove things (except the world) from different skill levels or deathmatch
706: if (ent != g_edicts)
707: {
708: if (deathmatch->value)
709: {
710: if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH )
711: {
712: G_FreeEdict (ent);
713: inhibit++;
714: continue;
715: }
716: }
717: else if(coop->value)
718: {
719: if (ent->spawnflags & SPAWNFLAG_NOT_COOP)
720: {
721: G_FreeEdict (ent);
722: inhibit++;
723: continue;
724: }
725:
726: // stuff marked !easy & !med & !hard are coop only, all levels
727: if(!((ent->spawnflags & SPAWNFLAG_NOT_EASY) &&
728: (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM) &&
729: (ent->spawnflags & SPAWNFLAG_NOT_HARD)) )
730: {
731: if( ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
732: ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
733: (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
734: )
735: {
736: G_FreeEdict (ent);
737: inhibit++;
738: continue;
739: }
740: }
741: }
742: else
743: {
744: if ( /*((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */
745: ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
746: ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
747: (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
748: )
749: {
750: G_FreeEdict (ent);
751: inhibit++;
752: continue;
753: }
754: }
755:
756: ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH);
757: }
758:
759: //PGM - do this before calling the spawn function so it can be overridden.
760: #ifdef ROGUE_GRAVITY
761: ent->gravityVector[0] = 0.0;
762: ent->gravityVector[1] = 0.0;
763: ent->gravityVector[2] = -1.0;
764: #endif
765: //PGM
766: ED_CallSpawn (ent);
767:
768: ent->s.renderfx |= RF_IR_VISIBLE; //PGM
769: }
770:
771: gi.dprintf ("%i entities inhibited\n", inhibit);
772:
773: #ifdef DEBUG
774: i = 1;
775: ent = EDICT_NUM(i);
776: while (i < globals.num_edicts) {
777: if (ent->inuse != 0 || ent->inuse != 1)
778: Com_DPrintf("Invalid entity %d\n", i);
779: i++, ent++;
780: }
781: #endif
782:
783: G_FindTeams ();
784:
785: PlayerTrail_Init ();
786:
787: //ROGUE
788: if(deathmatch->value)
789: {
790: if(randomrespawn && randomrespawn->value)
791: PrecacheForRandomRespawn();
792: }
793: else
794: {
795: InitHintPaths(); // if there aren't hintpaths on this map, enable quick aborts
796: }
797: //ROGUE
798:
799: // ROGUE -- allow dm games to do init stuff right before game starts.
800: if(deathmatch->value && gamerules && gamerules->value)
801: {
802: if(DMGame.PostInitSetup)
803: DMGame.PostInitSetup ();
804: }
805: // ROGUE
806: }
807:
808:
809: //===================================================================
810:
811: #if 0
812: // cursor positioning
813: xl <value>
814: xr <value>
815: yb <value>
816: yt <value>
817: xv <value>
818: yv <value>
819:
820: // drawing
821: statpic <name>
822: pic <stat>
823: num <fieldwidth> <stat>
824: string <stat>
825:
826: // control
827: if <stat>
828: ifeq <stat> <value>
829: ifbit <stat> <value>
830: endif
831:
832: #endif
833:
834: char *single_statusbar =
835: "yb -24 "
836:
837: // health
838: "xv 0 "
839: "hnum "
840: "xv 50 "
841: "pic 0 "
842:
843: // ammo
844: "if 2 "
845: " xv 100 "
846: " anum "
847: " xv 150 "
848: " pic 2 "
849: "endif "
850:
851: // armor
852: "if 4 "
853: " xv 200 "
854: " rnum "
855: " xv 250 "
856: " pic 4 "
857: "endif "
858:
859: // selected item
860: "if 6 "
861: " xv 296 "
862: " pic 6 "
863: "endif "
864:
865: "yb -50 "
866:
867: // picked up item
868: "if 7 "
869: " xv 0 "
870: " pic 7 "
871: " xv 26 "
872: " yb -42 "
873: " stat_string 8 "
874: " yb -50 "
875: "endif "
876:
877: // timer
878: "if 9 "
879: " xv 262 "
880: " num 2 10 "
881: " xv 296 "
882: " pic 9 "
883: "endif "
884:
885: // help / weapon icon
886: "if 11 "
887: " xv 148 "
888: " pic 11 "
889: "endif "
890: ;
891:
892: char *dm_statusbar =
893: "yb -24 "
894:
895: // health
896: "xv 0 "
897: "hnum "
898: "xv 50 "
899: "pic 0 "
900:
901: // ammo
902: "if 2 "
903: " xv 100 "
904: " anum "
905: " xv 150 "
906: " pic 2 "
907: "endif "
908:
909: // armor
910: "if 4 "
911: " xv 200 "
912: " rnum "
913: " xv 250 "
914: " pic 4 "
915: "endif "
916:
917: // selected item
918: "if 6 "
919: " xv 296 "
920: " pic 6 "
921: "endif "
922:
923: "yb -50 "
924:
925: // picked up item
926: "if 7 "
927: " xv 0 "
928: " pic 7 "
929: " xv 26 "
930: " yb -42 "
931: " stat_string 8 "
932: " yb -50 "
933: "endif "
934:
935: // timer
936: "if 9 "
937: " xv 246 "
938: " num 2 10 "
939: " xv 296 "
940: " pic 9 "
941: "endif "
942:
943: // help / weapon icon
944: "if 11 "
945: " xv 148 "
946: " pic 11 "
947: "endif "
948:
949: // frags
950: "xr -50 "
951: "yt 2 "
952: "num 3 14 "
953:
954: // spectator
955: "if 17 "
956: "xv 0 "
957: "yb -58 "
958: "string2 \"SPECTATOR MODE\" "
959: "endif "
960:
961: // chase camera
962: "if 16 "
963: "xv 0 "
964: "yb -68 "
965: "string \"Chasing\" "
966: "xv 64 "
967: "stat_string 16 "
968: "endif "
969: ;
970:
971:
972: /*QUAKED worldspawn (0 0 0) ?
973:
974: Only used for the world.
975: "sky" environment map name
976: "skyaxis" vector axis for rotating sky
977: "skyrotate" speed of rotation in degrees/second
978: "sounds" music cd track number
979: "gravity" 800 is default gravity
980: "message" text to print at user logon
981: */
982: void SP_worldspawn (edict_t *ent)
983: {
984: ent->movetype = MOVETYPE_PUSH;
985: ent->solid = SOLID_BSP;
986: ent->inuse = true; // since the world doesn't use G_Spawn()
987: ent->s.modelindex = 1; // world model is always index 1
988:
989: //---------------
990:
991: // reserve some spots for dead player bodies for coop / deathmatch
992: InitBodyQue ();
993:
994: // set configstrings for items
995: SetItemNames ();
996:
997: if (st.nextmap)
998: strcpy (level.nextmap, st.nextmap);
999:
1000: // make some data visible to the server
1001:
1002: if (ent->message && ent->message[0])
1003: {
1004: gi.configstring (CS_NAME, ent->message);
1005: strncpy (level.level_name, ent->message, sizeof(level.level_name));
1006: }
1007: else
1008: strncpy (level.level_name, level.mapname, sizeof(level.level_name));
1009:
1010: if (st.sky && st.sky[0])
1011: gi.configstring (CS_SKY, st.sky);
1012: else
1013: gi.configstring (CS_SKY, "unit1_");
1014:
1015: gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) );
1016:
1017: gi.configstring (CS_SKYAXIS, va("%f %f %f",
1018: st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) );
1019:
1020: gi.configstring (CS_CDTRACK, va("%i", ent->sounds) );
1021:
1022: gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) );
1023:
1024: // status bar program
1025: if (deathmatch->value)
1026: gi.configstring (CS_STATUSBAR, dm_statusbar);
1027: else
1028: gi.configstring (CS_STATUSBAR, single_statusbar);
1029:
1030: //---------------
1031:
1032:
1033: // help icon for statusbar
1034: gi.imageindex ("i_help");
1035: level.pic_health = gi.imageindex ("i_health");
1036: gi.imageindex ("help");
1037: gi.imageindex ("field_3");
1038:
1039: if (!st.gravity)
1040: gi.cvar_set("sv_gravity", "800");
1041: else
1042: gi.cvar_set("sv_gravity", st.gravity);
1043:
1044: snd_fry = gi.soundindex ("player/fry.wav"); // standing in lava / slime
1045:
1046: PrecacheItem (FindItem ("Blaster"));
1047:
1048: gi.soundindex ("player/lava1.wav");
1049: gi.soundindex ("player/lava2.wav");
1050:
1051: gi.soundindex ("misc/pc_up.wav");
1052: gi.soundindex ("misc/talk1.wav");
1053:
1054: gi.soundindex ("misc/udeath.wav");
1055:
1056: // gibs
1057: gi.soundindex ("items/respawn1.wav");
1058:
1059: // sexed sounds
1060: gi.soundindex ("*death1.wav");
1061: gi.soundindex ("*death2.wav");
1062: gi.soundindex ("*death3.wav");
1063: gi.soundindex ("*death4.wav");
1064: gi.soundindex ("*fall1.wav");
1065: gi.soundindex ("*fall2.wav");
1066: gi.soundindex ("*gurp1.wav"); // drowning damage
1067: gi.soundindex ("*gurp2.wav");
1068: gi.soundindex ("*jump1.wav"); // player jump
1069: gi.soundindex ("*pain25_1.wav");
1070: gi.soundindex ("*pain25_2.wav");
1071: gi.soundindex ("*pain50_1.wav");
1072: gi.soundindex ("*pain50_2.wav");
1073: gi.soundindex ("*pain75_1.wav");
1074: gi.soundindex ("*pain75_2.wav");
1075: gi.soundindex ("*pain100_1.wav");
1076: gi.soundindex ("*pain100_2.wav");
1077:
1078: // sexed models
1079: // THIS ORDER MUST MATCH THE DEFINES IN g_local.h
1080: // you can add more, max 19 (pete change)
1081: // these models are only loaded in coop or deathmatch. not singleplayer.
1082: if (coop->value || deathmatch->value)
1083: {
1084: gi.modelindex ("#w_blaster.md2");
1085: gi.modelindex ("#w_shotgun.md2");
1086: gi.modelindex ("#w_sshotgun.md2");
1087: gi.modelindex ("#w_machinegun.md2");
1088: gi.modelindex ("#w_chaingun.md2");
1089: gi.modelindex ("#a_grenades.md2");
1090: gi.modelindex ("#w_glauncher.md2");
1091: gi.modelindex ("#w_rlauncher.md2");
1092: gi.modelindex ("#w_hyperblaster.md2");
1093: gi.modelindex ("#w_railgun.md2");
1094: gi.modelindex ("#w_bfg.md2");
1095:
1096: gi.modelindex ("#w_disrupt.md2"); // PGM
1097: gi.modelindex ("#w_etfrifle.md2"); // PGM
1098: gi.modelindex ("#w_plasma.md2"); // PGM
1099: gi.modelindex ("#w_plauncher.md2"); // PGM
1100: gi.modelindex ("#w_chainfist.md2"); // PGM
1101: }
1102:
1103: //-------------------
1104:
1105: gi.soundindex ("player/gasp1.wav"); // gasping for air
1106: gi.soundindex ("player/gasp2.wav"); // head breaking surface, not gasping
1107:
1108: gi.soundindex ("player/watr_in.wav"); // feet hitting water
1109: gi.soundindex ("player/watr_out.wav"); // feet leaving water
1110:
1111: gi.soundindex ("player/watr_un.wav"); // head going underwater
1112:
1113: gi.soundindex ("player/u_breath1.wav");
1114: gi.soundindex ("player/u_breath2.wav");
1115:
1116: gi.soundindex ("items/pkup.wav"); // bonus item pickup
1117: gi.soundindex ("world/land.wav"); // landing thud
1118: gi.soundindex ("misc/h2ohit1.wav"); // landing splash
1119:
1120: gi.soundindex ("items/damage.wav");
1121: gi.soundindex ("items/protect.wav");
1122: gi.soundindex ("items/protect4.wav");
1123: gi.soundindex ("weapons/noammo.wav");
1124:
1125: gi.soundindex ("infantry/inflies1.wav");
1126:
1127: sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2");
1128: gi.modelindex ("models/objects/gibs/arm/tris.md2");
1129: gi.modelindex ("models/objects/gibs/bone/tris.md2");
1130: gi.modelindex ("models/objects/gibs/bone2/tris.md2");
1131: gi.modelindex ("models/objects/gibs/chest/tris.md2");
1132: gi.modelindex ("models/objects/gibs/skull/tris.md2");
1133: gi.modelindex ("models/objects/gibs/head2/tris.md2");
1134:
1135: //
1136: // Setup light animation tables. 'a' is total darkness, 'z' is doublebright.
1137: //
1138:
1139: // 0 normal
1140: gi.configstring(CS_LIGHTS+0, "m");
1141:
1142: // 1 FLICKER (first variety)
1143: gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo");
1144:
1145: // 2 SLOW STRONG PULSE
1146: gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba");
1147:
1148: // 3 CANDLE (first variety)
1149: gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg");
1150:
1151: // 4 FAST STROBE
1152: gi.configstring(CS_LIGHTS+4, "mamamamamama");
1153:
1154: // 5 GENTLE PULSE 1
1155: gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj");
1156:
1157: // 6 FLICKER (second variety)
1158: gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno");
1159:
1160: // 7 CANDLE (second variety)
1161: gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm");
1162:
1163: // 8 CANDLE (third variety)
1164: gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa");
1165:
1166: // 9 SLOW STROBE (fourth variety)
1167: gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz");
1168:
1169: // 10 FLUORESCENT FLICKER
1170: gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma");
1171:
1172: // 11 SLOW PULSE NOT FADE TO BLACK
1173: gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba");
1174:
1175: // styles 32-62 are assigned by the light program for switchable lights
1176:
1177: // 63 testing
1178: gi.configstring(CS_LIGHTS+63, "a");
1179: }
1180:
1181: //
1182: //ROGUE
1183: //
1184:
1185: //
1186: // Monster spawning code
1187: //
1188: // Used by the carrier, the medic_commander, and the black widow
1189: //
1190: // The sequence to create a flying monster is:
1191: //
1192: // FindSpawnPoint - tries to find suitable spot to spawn the monster in
1193: // CreateFlyMonster - this verifies the point as good and creates the monster
1194:
1195: // To create a ground walking monster:
1196: //
1197: // FindSpawnPoint - same thing
1198: // CreateGroundMonster - this checks the volume and makes sure the floor under the volume is suitable
1199: //
1200:
1201: // FIXME - for the black widow, if we want the stalkers coming in on the roof, we'll have to tweak some things
1202:
1203: //
1204: // CreateMonster
1205: //
1206: edict_t *CreateMonster(vec3_t origin, vec3_t angles, char *classname)
1207: {
1208: edict_t *newEnt;
1209:
1210: newEnt = G_Spawn();
1211:
1212: VectorCopy(origin, newEnt->s.origin);
1213: VectorCopy(angles, newEnt->s.angles);
1214: newEnt->classname = ED_NewString (classname);
1215: newEnt->monsterinfo.aiflags |= AI_DO_NOT_COUNT;
1216:
1217: VectorSet(newEnt->gravityVector, 0, 0, -1);
1218: ED_CallSpawn(newEnt);
1219: newEnt->s.renderfx |= RF_IR_VISIBLE;
1220:
1221: return newEnt;
1222: }
1223:
1224: edict_t *CreateFlyMonster (vec3_t origin, vec3_t angles, vec3_t mins, vec3_t maxs, char *classname)
1225: {
1226: if (!mins || !maxs || VectorCompare (mins, vec3_origin) || VectorCompare (maxs, vec3_origin))
1227: {
1228: DetermineBBox (classname, mins, maxs);
1229: }
1230:
1231: if (!CheckSpawnPoint(origin, mins, maxs))
1232: return NULL;
1233:
1234: return (CreateMonster (origin, angles, classname));
1235: }
1236:
1237: // This is just a wrapper for CreateMonster that looks down height # of CMUs and sees if there
1238: // are bad things down there or not
1239: //
1240: // this is from m_move.c
1241: #define STEPSIZE 18
1242:
1243: edict_t *CreateGroundMonster (vec3_t origin, vec3_t angles, vec3_t entMins, vec3_t entMaxs, char *classname, int height)
1244: {
1245: // trace_t tr;
1246: edict_t *newEnt;
1247: // vec3_t start, stop;
1248: // int failure = 0;
1249: // vec3_t mins, maxs;
1250: // int x, y;
1251: // float mid, bottom;
1252: vec3_t mins, maxs;
1253:
1254: // if they don't provide us a bounding box, figure it out
1255: if (!entMins || !entMaxs || VectorCompare (entMins, vec3_origin) || VectorCompare (entMaxs, vec3_origin))
1256: {
1257: DetermineBBox (classname, mins, maxs);
1258: }
1259: else
1260: {
1261: VectorCopy (entMins, mins);
1262: VectorCopy (entMaxs, maxs);
1263: }
1264:
1265: // check the ground to make sure it's there, it's relatively flat, and it's not toxic
1266: if (!CheckGroundSpawnPoint(origin, mins, maxs, height, -1))
1267: return NULL;
1268:
1269: newEnt = CreateMonster (origin, angles, classname);
1270: if (!newEnt)
1271: return NULL;
1272:
1273: return newEnt;
1274: }
1275:
1276:
1277: // FindSpawnPoint
1278: // PMM - this is used by the medic commander (possibly by the carrier) to find a good spawn point
1279: // if the startpoint is bad, try above the startpoint for a bit
1280:
1281: qboolean FindSpawnPoint (vec3_t startpoint, vec3_t mins, vec3_t maxs, vec3_t spawnpoint, float maxMoveUp)
1282: {
1283: trace_t tr;
1284: float height;
1285: vec3_t top;
1286:
1287: height = maxs[2] - mins[2];
1288:
1289: tr = gi.trace (startpoint, mins, maxs, startpoint, NULL, MASK_MONSTERSOLID|CONTENTS_PLAYERCLIP);
1290: if((tr.startsolid || tr.allsolid) || (tr.ent != world))
1291: {
1292: // if ( ((tr.ent->svflags & SVF_MONSTER) && (tr.ent->health <= 0)) ||
1293: // (tr.ent->svflags & SVF_DAMAGEABLE) )
1294: // {
1295: // T_Damage (tr.ent, self, self, vec3_origin, self->enemy->s.origin,
1296: // pain_normal, hurt, 0, 0, MOD_UNKNOWN);
1297:
1298: VectorCopy (startpoint, top);
1299: top[2] += maxMoveUp;
1300: /*
1301: gi.WriteByte (svc_temp_entity);
1302: gi.WriteByte (TE_DEBUGTRAIL);
1303: gi.WritePosition (top);
1304: gi.WritePosition (startpoint);
1305: gi.multicast (startpoint, MULTICAST_ALL);
1306: */
1307: tr = gi.trace (top, mins, maxs, startpoint, NULL, MASK_MONSTERSOLID);
1308: if (tr.startsolid || tr.allsolid)
1309: {
1310: if ((g_showlogic) && (g_showlogic->value))
1311: if (tr.ent)
1312: gi.dprintf("FindSpawnPoint: failed to find a point -- blocked by %s\n", tr.ent->classname);
1313: else
1314: gi.dprintf("FindSpawnPoint: failed to find a point\n");
1315:
1316: return false;
1317: }
1318: else
1319: {
1320: // if ((g_showlogic) && (g_showlogic->value))
1321: // gi.dprintf ("FindSpawnPoint: %s -> %s\n", vtos (startpoint), vtos (tr.endpos));
1322: VectorCopy (tr.endpos, spawnpoint);
1323: return true;
1324: }
1325: }
1326: else
1327: {
1328: VectorCopy (startpoint, spawnpoint);
1329: return true;
1330: }
1331: }
1332:
1333: // FIXME - all of this needs to be tweaked to handle the new gravity rules
1334: // if we ever want to spawn stuff on the roof
1335:
1336: //
1337: // CheckSpawnPoint
1338: //
1339: // PMM - checks volume to make sure we can spawn a monster there (is it solid?)
1340: //
1341: // This is all fliers should need
1342:
1343: qboolean CheckSpawnPoint (vec3_t origin, vec3_t mins, vec3_t maxs)
1344: {
1345: trace_t tr;
1346:
1347: if (!mins || !maxs || VectorCompare(mins, vec3_origin) || VectorCompare (maxs, vec3_origin))
1348: {
1349: return false;
1350: }
1351:
1352: tr = gi.trace (origin, mins, maxs, origin, NULL, MASK_MONSTERSOLID);
1353: if(tr.startsolid || tr.allsolid)
1354: {
1355: if ((g_showlogic) && (g_showlogic->value))
1356: gi.dprintf("createmonster in wall. removing\n");
1357: return false;
1358: }
1359: if (tr.ent != world)
1360: {
1361: if ((g_showlogic) && (g_showlogic->value))
1362: gi.dprintf("createmonster in entity %s\n", tr.ent->classname);
1363: return false;
1364: }
1365: return true;
1366: }
1367:
1368: //
1369: // CheckGroundSpawnPoint
1370: //
1371: // PMM - used for walking monsters
1372: // checks:
1373: // 1) is there a ground within the specified height of the origin?
1374: // 2) is the ground non-water?
1375: // 3) is the ground flat enough to walk on?
1376: //
1377:
1378: qboolean CheckGroundSpawnPoint (vec3_t origin, vec3_t entMins, vec3_t entMaxs, float height, float gravity)
1379: {
1380: trace_t tr;
1381: vec3_t start, stop;
1382: int failure = 0;
1383: vec3_t mins, maxs;
1384: int x, y;
1385: float mid, bottom;
1386:
1387: if (!CheckSpawnPoint (origin, entMins, entMaxs))
1388: return false;
1389:
1390: // FIXME - this is too conservative about angled surfaces
1391:
1392: VectorCopy (origin, stop);
1393: // FIXME - gravity vector
1394: stop[2] = origin[2] + entMins[2] - height;
1395:
1396: /*
1397: gi.WriteByte (svc_temp_entity);
1398: gi.WriteByte (TE_DEBUGTRAIL);
1399: gi.WritePosition (origin);
1400: gi.WritePosition (stop);
1401: gi.multicast (start, MULTICAST_ALL);
1402: */
1403:
1404: tr = gi.trace (origin, entMins, entMaxs, stop, NULL, MASK_MONSTERSOLID | MASK_WATER);
1405: // it's not going to be all solid or start solid, since that's checked above
1406:
1407: if ((tr.fraction < 1) && (tr.contents & MASK_MONSTERSOLID))
1408: {
1409: // we found a non-water surface down there somewhere. now we need to check to make sure it's not too sloped
1410: //
1411: // algorithm straight out of m_move.c:M_CheckBottom()
1412: //
1413:
1414: // first, do the midpoint trace
1415:
1416: VectorAdd (tr.endpos, entMins, mins);
1417: VectorAdd (tr.endpos, entMaxs, maxs);
1418:
1419:
1420: // first, do the easy flat check
1421: //
1422: #ifdef ROGUE_GRAVITY
1423: // FIXME - this will only handle 0,0,1 and 0,0,-1 gravity vectors
1424: if(gravity > 0)
1425: start[2] = maxs[2] + 1;
1426: else
1427: start[2] = mins[2] - 1;
1428: #else
1429: start[2] = mins[2] - 1;
1430: #endif
1431: for (x=0 ; x<=1 ; x++)
1432: {
1433: for (y=0 ; y<=1 ; y++)
1434: {
1435: start[0] = x ? maxs[0] : mins[0];
1436: start[1] = y ? maxs[1] : mins[1];
1437: if (gi.pointcontents (start) != CONTENTS_SOLID)
1438: goto realcheck;
1439: }
1440: }
1441:
1442: // if it passed all four above checks, we're done
1443: return true;
1444:
1445: realcheck:
1446:
1447: // check it for real
1448:
1449: start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
1450: start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
1451: start[2] = mins[2];
1452:
1453: tr = gi.trace (start, vec3_origin, vec3_origin, stop, NULL, MASK_MONSTERSOLID);
1454:
1455: if (tr.fraction == 1.0)
1456: return false;
1457: mid = bottom = tr.endpos[2];
1458:
1459: #ifdef ROGUE_GRAVITY
1460: if(gravity < 0)
1461: {
1462: start[2] = mins[2];
1463: stop[2] = start[2] - STEPSIZE - STEPSIZE;
1464: mid = bottom = tr.endpos[2] + entMins[2];
1465: }
1466: else
1467: {
1468: start[2] = maxs[2];
1469: stop[2] = start[2] + STEPSIZE + STEPSIZE;
1470: mid = bottom = tr.endpos[2] - entMaxs[2];
1471: }
1472: #else
1473: stop[2] = start[2] - 2*STEPSIZE;
1474: mid = bottom = tr.endpos[2] + entMins[2];
1475: #endif
1476:
1477: for (x=0 ; x<=1 ; x++)
1478: for (y=0 ; y<=1 ; y++)
1479: {
1480: start[0] = stop[0] = x ? maxs[0] : mins[0];
1481: start[1] = stop[1] = y ? maxs[1] : mins[1];
1482:
1483: /*
1484: gi.WriteByte (svc_temp_entity);
1485: gi.WriteByte (TE_DEBUGTRAIL);
1486: gi.WritePosition (start);
1487: gi.WritePosition (stop);
1488: gi.multicast (start, MULTICAST_ALL);
1489: */
1490: tr = gi.trace (start, vec3_origin, vec3_origin, stop, NULL, MASK_MONSTERSOLID);
1491:
1492: //PGM
1493: #ifdef ROGUE_GRAVITY
1494: // FIXME - this will only handle 0,0,1 and 0,0,-1 gravity vectors
1495: if(gravity > 0)
1496: {
1497: if (tr.fraction != 1.0 && tr.endpos[2] < bottom)
1498: bottom = tr.endpos[2];
1499: if (tr.fraction == 1.0 || tr.endpos[2] - mid > STEPSIZE)
1500: {
1501: if ((g_showlogic) && (g_showlogic->value))
1502: gi.dprintf ("spawn - rejecting due to uneven ground\n");
1503: return false;
1504: }
1505: }
1506: else
1507: {
1508: if (tr.fraction != 1.0 && tr.endpos[2] > bottom)
1509: bottom = tr.endpos[2];
1510: if (tr.fraction == 1.0 || mid - tr.endpos[2] > STEPSIZE)
1511: {
1512: if ((g_showlogic) && (g_showlogic->value))
1513: gi.dprintf ("spawn - rejecting due to uneven ground\n");
1514: return false;
1515: }
1516: }
1517: #else
1518: if (tr.fraction != 1.0 && tr.endpos[2] > bottom)
1519: bottom = tr.endpos[2];
1520: if (tr.fraction == 1.0 || mid - tr.endpos[2] > STEPSIZE)
1521: {
1522: return false;
1523: }
1524: #endif
1525: }
1526:
1527: return true; // we can land on it, it's ok
1528: }
1529:
1530: // otherwise, it's either water (bad) or not there (too far)
1531: // if we're here, it's bad below
1532: if ((g_showlogic) && (g_showlogic->value))
1533: {
1534: if (tr.fraction < 1)
1535: if ((g_showlogic) && (g_showlogic->value))
1536: gi.dprintf("groundmonster would fall into water/slime/lava\n");
1537: else
1538: if ((g_showlogic) && (g_showlogic->value))
1539: gi.dprintf("groundmonster would fall too far\n");
1540: }
1541:
1542: return false;
1543: }
1544:
1545: void DetermineBBox (char *classname, vec3_t mins, vec3_t maxs)
1546: {
1547: // FIXME - cache this stuff
1548: edict_t *newEnt;
1549:
1550: newEnt = G_Spawn();
1551:
1552: VectorCopy(vec3_origin, newEnt->s.origin);
1553: VectorCopy(vec3_origin, newEnt->s.angles);
1554: newEnt->classname = ED_NewString (classname);
1555: newEnt->monsterinfo.aiflags |= AI_DO_NOT_COUNT;
1556:
1557: ED_CallSpawn(newEnt);
1558:
1559: VectorCopy (newEnt->mins, mins);
1560: VectorCopy (newEnt->maxs, maxs);
1561:
1562: G_FreeEdict (newEnt);
1563: }
1564:
1565: // ****************************
1566: // SPAWNGROW stuff
1567: // ****************************
1568:
1569: #define SPAWNGROW_LIFESPAN 0.3
1570:
1571: void spawngrow_think (edict_t *self)
1572: {
1573: int i;
1574:
1575: for (i=0; i<2; i++)
1576: {
1577: self->s.angles[0] = rand()%360;
1578: self->s.angles[1] = rand()%360;
1579: self->s.angles[2] = rand()%360;
1580: }
1581: if ((level.time < self->wait) && (self->s.frame < 2))
1582: self->s.frame++;
1583: if (level.time >= self->wait)
1584: {
1585: if (self->s.effects & EF_SPHERETRANS)
1586: {
1587: G_FreeEdict (self);
1588: return;
1589: }
1590: else if (self->s.frame > 0)
1591: self->s.frame--;
1592: else
1593: {
1594: G_FreeEdict (self);
1595: return;
1596: }
1597: }
1598: self->nextthink += FRAMETIME;
1599: }
1600:
1601: void SpawnGrow_Spawn (vec3_t startpos, int size)
1602: {
1603: edict_t *ent;
1604: int i;
1605: float lifespan;
1606:
1607: ent = G_Spawn();
1608: VectorCopy(startpos, ent->s.origin);
1609: for (i=0; i<2; i++)
1610: {
1611: ent->s.angles[0] = rand()%360;
1612: ent->s.angles[1] = rand()%360;
1613: ent->s.angles[2] = rand()%360;
1614: }
1615: ent->solid = SOLID_NOT;
1616: // ent->s.renderfx = RF_FULLBRIGHT | RF_IR_VISIBLE;
1617: ent->s.renderfx = RF_IR_VISIBLE;
1618: ent->movetype = MOVETYPE_NONE;
1619: ent->classname = "spawngro";
1620:
1621: if (size <= 1)
1622: {
1623: lifespan = SPAWNGROW_LIFESPAN;
1624: ent->s.modelindex = gi.modelindex("models/items/spawngro2/tris.md2");
1625: }
1626: else if (size == 2)
1627: {
1628: ent->s.modelindex = gi.modelindex("models/items/spawngro3/tris.md2");
1629: lifespan = 2;
1630: }
1631: else
1632: {
1633: ent->s.modelindex = gi.modelindex("models/items/spawngro/tris.md2");
1634: lifespan = SPAWNGROW_LIFESPAN;
1635: }
1636:
1637: ent->think = spawngrow_think;
1638:
1639: ent->wait = level.time + lifespan;
1640: ent->nextthink = level.time + FRAMETIME;
1641: if (size != 2)
1642: ent->s.effects |= EF_SPHERETRANS;
1643: gi.linkentity (ent);
1644: }
1645:
1646:
1647: // ****************************
1648: // WidowLeg stuff
1649: // ****************************
1650:
1651: #define MAX_LEGSFRAME 23
1652: #define LEG_WAIT_TIME 1
1653:
1654: void ThrowMoreStuff (edict_t *self, vec3_t point);
1655: void ThrowSmallStuff (edict_t *self, vec3_t point);
1656: void ThrowWidowGibLoc (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, qboolean fade);
1657: void ThrowWidowGibSized (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, int hitsound, qboolean fade);
1658:
1659: void widowlegs_think (edict_t *self)
1660: {
1661: vec3_t offset;
1662: vec3_t point;
1663: vec3_t f,r,u;
1664:
1665: if (self->s.frame == 17)
1666: {
1667: VectorSet (offset, 11.77, -7.24, 23.31);
1668: AngleVectors (self->s.angles, f, r, u);
1669: G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1670: gi.WriteByte (svc_temp_entity);
1671: gi.WriteByte (TE_EXPLOSION1);
1672: gi.WritePosition (point);
1673: gi.multicast (point, MULTICAST_ALL);
1674: ThrowSmallStuff (self, point);
1675: }
1676:
1677: if (self->s.frame < MAX_LEGSFRAME)
1678: {
1679: self->s.frame++;
1680: self->nextthink = level.time + FRAMETIME;
1681: return;
1682: }
1683: else if (self->wait == 0)
1684: {
1685: self->wait = level.time + LEG_WAIT_TIME;
1686: }
1687: if (level.time > self->wait)
1688: {
1689: AngleVectors (self->s.angles, f, r, u);
1690:
1691: VectorSet (offset, -65.6, -8.44, 28.59);
1692: G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1693: gi.WriteByte (svc_temp_entity);
1694: gi.WriteByte (TE_EXPLOSION1);
1695: gi.WritePosition (point);
1696: gi.multicast (point, MULTICAST_ALL);
1697: ThrowMoreStuff (self, point);
1698:
1699: ThrowWidowGibSized (self, "models/monsters/blackwidow/gib1/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1700: ThrowWidowGibSized (self, "models/monsters/blackwidow/gib2/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1701:
1702: VectorSet (offset, -1.04, -51.18, 7.04);
1703: G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1704: gi.WriteByte (svc_temp_entity);
1705: gi.WriteByte (TE_EXPLOSION1);
1706: gi.WritePosition (point);
1707: gi.multicast (point, MULTICAST_ALL);
1708: ThrowMoreStuff (self, point);
1709:
1710: ThrowWidowGibSized (self, "models/monsters/blackwidow/gib1/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1711: ThrowWidowGibSized (self, "models/monsters/blackwidow/gib2/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1712: ThrowWidowGibSized (self, "models/monsters/blackwidow/gib3/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1713:
1714: G_FreeEdict (self);
1715: return;
1716: }
1717: if ((level.time > (self->wait - 0.5)) && (self->count == 0))
1718: {
1719: self->count = 1;
1720: AngleVectors (self->s.angles, f, r, u);
1721:
1722: VectorSet (offset, 31, -88.7, 10.96);
1723: G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1724: gi.WriteByte (svc_temp_entity);
1725: gi.WriteByte (TE_EXPLOSION1);
1726: gi.WritePosition (point);
1727: gi.multicast (point, MULTICAST_ALL);
1728: ThrowSmallStuff (self, point);
1729:
1730: VectorSet (offset, -12.67, -4.39, 15.68);
1731: G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1732: gi.WriteByte (svc_temp_entity);
1733: gi.WriteByte (TE_EXPLOSION1);
1734: gi.WritePosition (point);
1735: gi.multicast (point, MULTICAST_ALL);
1736: ThrowSmallStuff (self, point);
1737:
1738: self->nextthink = level.time + FRAMETIME;
1739: return;
1740: }
1741: self->nextthink = level.time + FRAMETIME;
1742: }
1743:
1744: void Widowlegs_Spawn (vec3_t startpos, vec3_t angles)
1745: {
1746: edict_t *ent;
1747:
1748: ent = G_Spawn();
1749: VectorCopy(startpos, ent->s.origin);
1750: VectorCopy(angles, ent->s.angles);
1751: ent->solid = SOLID_NOT;
1752: ent->s.renderfx = RF_IR_VISIBLE;
1753: ent->movetype = MOVETYPE_NONE;
1754: ent->classname = "widowlegs";
1755:
1756: ent->s.modelindex = gi.modelindex("models/monsters/legs/tris.md2");
1757: ent->think = widowlegs_think;
1758:
1759: ent->nextthink = level.time + FRAMETIME;
1760: gi.linkentity (ent);
1761: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.