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 */
ED_CallSpawn(edict_t * ent)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 classnames 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 */
ED_NewString(char * string)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 */
ED_ParseField(char * key,char * value,edict_t * ent)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 */
ED_ParseEdict(char * data,edict_t * ent)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 */
G_FixTeams(void)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
G_FindTeams(void)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 */
SpawnEntities(char * mapname,char * entities,char * spawnpoint)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 // ROGUE
706 //ahh, the joys of map hacks ..
707 if (!Q_stricmp(level.mapname, "rhangar2") && !Q_stricmp(ent->classname, "func_door_rotating") && ent->targetname && !Q_stricmp(ent->targetname, "t265"))
708 ent->spawnflags &= ~SPAWNFLAG_NOT_COOP;
709 if (!Q_stricmp(level.mapname, "rhangar2") && !Q_stricmp(ent->classname, "trigger_always") && ent->target && !Q_stricmp(ent->target, "t265"))
710 ent->spawnflags |= SPAWNFLAG_NOT_COOP;
711 if (!Q_stricmp(level.mapname, "rhangar2") && !Q_stricmp(ent->classname, "func_wall") && !Q_stricmp(ent->model, "*15"))
712 ent->spawnflags |= SPAWNFLAG_NOT_COOP;
713 // rogue
714
715 // remove things (except the world) from different skill levels or deathmatch
716 if (ent != g_edicts)
717 {
718 if (deathmatch->value)
719 {
720 if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH )
721 {
722 G_FreeEdict (ent);
723 inhibit++;
724 continue;
725 }
726 }
727 else if(coop->value)
728 {
729 if (ent->spawnflags & SPAWNFLAG_NOT_COOP)
730 {
731 G_FreeEdict (ent);
732 inhibit++;
733 continue;
734 }
735
736 // stuff marked !easy & !med & !hard are coop only, all levels
737 if(!((ent->spawnflags & SPAWNFLAG_NOT_EASY) &&
738 (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM) &&
739 (ent->spawnflags & SPAWNFLAG_NOT_HARD)) )
740 {
741 if( ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
742 ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
743 (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
744 )
745 {
746 G_FreeEdict (ent);
747 inhibit++;
748 continue;
749 }
750 }
751 }
752 else
753 {
754 if ( /*((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */
755 ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
756 ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
757 (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
758 )
759 {
760 G_FreeEdict (ent);
761 inhibit++;
762 continue;
763 }
764 }
765
766 ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH);
767 }
768
769 //PGM - do this before calling the spawn function so it can be overridden.
770 #ifdef ROGUE_GRAVITY
771 ent->gravityVector[0] = 0.0;
772 ent->gravityVector[1] = 0.0;
773 ent->gravityVector[2] = -1.0;
774 #endif
775 //PGM
776 ED_CallSpawn (ent);
777
778 ent->s.renderfx |= RF_IR_VISIBLE; //PGM
779 }
780
781 gi.dprintf ("%i entities inhibited\n", inhibit);
782
783 #ifdef DEBUG
784 i = 1;
785 ent = EDICT_NUM(i);
786 while (i < globals.num_edicts) {
787 if (ent->inuse != 0 || ent->inuse != 1)
788 Com_DPrintf("Invalid entity %d\n", i);
789 i++, ent++;
790 }
791 #endif
792
793 G_FindTeams ();
794
795 PlayerTrail_Init ();
796 #ifdef GAME_MOD
797 if (coop->value) {
798 Blinky_SpawnEntities();
799 }
800 #endif
801
802 //ROGUE
803 if(deathmatch->value)
804 {
805 if(randomrespawn && randomrespawn->value)
806 PrecacheForRandomRespawn();
807 }
808 else
809 {
810 InitHintPaths(); // if there aren't hintpaths on this map, enable quick aborts
811 }
812 //ROGUE
813
814 // ROGUE -- allow dm games to do init stuff right before game starts.
815 if(deathmatch->value && gamerules && gamerules->value)
816 {
817 if(DMGame.PostInitSetup)
818 DMGame.PostInitSetup ();
819 }
820 // ROGUE
821 }
822
823
824 //===================================================================
825
826 #if 0
827 // cursor positioning
828 xl <value>
829 xr <value>
830 yb <value>
831 yt <value>
832 xv <value>
833 yv <value>
834
835 // drawing
836 statpic <name>
837 pic <stat>
838 num <fieldwidth> <stat>
839 string <stat>
840
841 // control
842 if <stat>
843 ifeq <stat> <value>
844 ifbit <stat> <value>
845 endif
846
847 #endif
848
849 char *single_statusbar =
850 "yb -24 "
851
852 // health
853 "xv 0 "
854 "hnum "
855 "xv 50 "
856 "pic 0 "
857
858 // ammo
859 "if 2 "
860 " xv 100 "
861 " anum "
862 " xv 150 "
863 " pic 2 "
864 "endif "
865
866 // armor
867 "if 4 "
868 " xv 200 "
869 " rnum "
870 " xv 250 "
871 " pic 4 "
872 "endif "
873
874 // selected item
875 "if 6 "
876 " xv 296 "
877 " pic 6 "
878 "endif "
879
880 "yb -50 "
881
882 // picked up item
883 "if 7 "
884 " xv 0 "
885 " pic 7 "
886 " xv 26 "
887 " yb -42 "
888 " stat_string 8 "
889 " yb -50 "
890 "endif "
891
892 // timer
893 "if 9 "
894 " xv 262 "
895 " num 2 10 "
896 " xv 296 "
897 " pic 9 "
898 "endif "
899
900 // help / weapon icon
901 "if 11 "
902 " xv 148 "
903 " pic 11 "
904 "endif "
905 ;
906
907 char *dm_statusbar =
908 "yb -24 "
909
910 // health
911 "xv 0 "
912 "hnum "
913 "xv 50 "
914 "pic 0 "
915
916 // ammo
917 "if 2 "
918 " xv 100 "
919 " anum "
920 " xv 150 "
921 " pic 2 "
922 "endif "
923
924 // armor
925 "if 4 "
926 " xv 200 "
927 " rnum "
928 " xv 250 "
929 " pic 4 "
930 "endif "
931
932 // selected item
933 "if 6 "
934 " xv 296 "
935 " pic 6 "
936 "endif "
937
938 "yb -50 "
939
940 // picked up item
941 "if 7 "
942 " xv 0 "
943 " pic 7 "
944 " xv 26 "
945 " yb -42 "
946 " stat_string 8 "
947 " yb -50 "
948 "endif "
949
950 // timer
951 "if 9 "
952 " xv 246 "
953 " num 2 10 "
954 " xv 296 "
955 " pic 9 "
956 "endif "
957
958 // help / weapon icon
959 "if 11 "
960 " xv 148 "
961 " pic 11 "
962 "endif "
963
964 // frags
965 "xr -50 "
966 "yt 2 "
967 "num 3 14 "
968
969 // spectator
970 "if 17 "
971 "xv 0 "
972 "yb -58 "
973 "string2 \"SPECTATOR MODE\" "
974 "endif "
975
976 // chase camera
977 "if 16 "
978 "xv 0 "
979 "yb -68 "
980 "string \"Chasing\" "
981 "xv 64 "
982 "stat_string 16 "
983 "endif "
984 ;
985
986
987 /*QUAKED worldspawn (0 0 0) ?
988
989 Only used for the world.
990 "sky" environment map name
991 "skyaxis" vector axis for rotating sky
992 "skyrotate" speed of rotation in degrees/second
993 "sounds" music cd track number
994 "gravity" 800 is default gravity
995 "message" text to print at user logon
996 */
SP_worldspawn(edict_t * ent)997 void SP_worldspawn (edict_t *ent)
998 {
999 ent->movetype = MOVETYPE_PUSH;
1000 ent->solid = SOLID_BSP;
1001 ent->inuse = true; // since the world doesn't use G_Spawn()
1002 ent->s.modelindex = 1; // world model is always index 1
1003
1004 //---------------
1005
1006 // reserve some spots for dead player bodies for coop / deathmatch
1007 InitBodyQue ();
1008
1009 // set configstrings for items
1010 SetItemNames ();
1011
1012 if (st.nextmap)
1013 strcpy (level.nextmap, st.nextmap);
1014
1015 // make some data visible to the server
1016
1017 if (ent->message && ent->message[0])
1018 {
1019 gi.configstring (CS_NAME, ent->message);
1020 strncpy (level.level_name, ent->message, sizeof(level.level_name));
1021 }
1022 else
1023 strncpy (level.level_name, level.mapname, sizeof(level.level_name));
1024
1025 if (st.sky && st.sky[0])
1026 gi.configstring (CS_SKY, st.sky);
1027 else
1028 gi.configstring (CS_SKY, "unit1_");
1029
1030 gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) );
1031
1032 gi.configstring (CS_SKYAXIS, va("%f %f %f",
1033 st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) );
1034
1035 gi.configstring (CS_CDTRACK, va("%i", ent->sounds) );
1036
1037 gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) );
1038
1039 // status bar program
1040 if (deathmatch->value)
1041 gi.configstring (CS_STATUSBAR, dm_statusbar);
1042 else
1043 gi.configstring (CS_STATUSBAR, single_statusbar);
1044
1045 //---------------
1046
1047
1048 // help icon for statusbar
1049 gi.imageindex ("i_help");
1050 level.pic_health = gi.imageindex ("i_health");
1051 gi.imageindex ("help");
1052 gi.imageindex ("field_3");
1053
1054 if (!st.gravity)
1055 gi.cvar_set("sv_gravity", "800");
1056 else
1057 gi.cvar_set("sv_gravity", st.gravity);
1058
1059 snd_fry = gi.soundindex ("player/fry.wav"); // standing in lava / slime
1060
1061 PrecacheItem (FindItem ("Blaster"));
1062
1063 gi.soundindex ("player/lava1.wav");
1064 gi.soundindex ("player/lava2.wav");
1065
1066 gi.soundindex ("misc/pc_up.wav");
1067 gi.soundindex ("misc/talk1.wav");
1068
1069 gi.soundindex ("misc/udeath.wav");
1070
1071 // gibs
1072 gi.soundindex ("items/respawn1.wav");
1073
1074 // sexed sounds
1075 gi.soundindex ("*death1.wav");
1076 gi.soundindex ("*death2.wav");
1077 gi.soundindex ("*death3.wav");
1078 gi.soundindex ("*death4.wav");
1079 gi.soundindex ("*fall1.wav");
1080 gi.soundindex ("*fall2.wav");
1081 gi.soundindex ("*gurp1.wav"); // drowning damage
1082 gi.soundindex ("*gurp2.wav");
1083 gi.soundindex ("*jump1.wav"); // player jump
1084 gi.soundindex ("*pain25_1.wav");
1085 gi.soundindex ("*pain25_2.wav");
1086 gi.soundindex ("*pain50_1.wav");
1087 gi.soundindex ("*pain50_2.wav");
1088 gi.soundindex ("*pain75_1.wav");
1089 gi.soundindex ("*pain75_2.wav");
1090 gi.soundindex ("*pain100_1.wav");
1091 gi.soundindex ("*pain100_2.wav");
1092
1093 // sexed models
1094 // THIS ORDER MUST MATCH THE DEFINES IN g_local.h
1095 // you can add more, max 19 (pete change)
1096 // these models are only loaded in coop or deathmatch. not singleplayer.
1097 if (coop->value || deathmatch->value)
1098 {
1099 gi.modelindex ("#w_blaster.md2");
1100 gi.modelindex ("#w_shotgun.md2");
1101 gi.modelindex ("#w_sshotgun.md2");
1102 gi.modelindex ("#w_machinegun.md2");
1103 gi.modelindex ("#w_chaingun.md2");
1104 gi.modelindex ("#a_grenades.md2");
1105 gi.modelindex ("#w_glauncher.md2");
1106 gi.modelindex ("#w_rlauncher.md2");
1107 gi.modelindex ("#w_hyperblaster.md2");
1108 gi.modelindex ("#w_railgun.md2");
1109 gi.modelindex ("#w_bfg.md2");
1110
1111 gi.modelindex ("#w_disrupt.md2"); // PGM
1112 gi.modelindex ("#w_etfrifle.md2"); // PGM
1113 gi.modelindex ("#w_plasma.md2"); // PGM
1114 gi.modelindex ("#w_plauncher.md2"); // PGM
1115 gi.modelindex ("#w_chainfist.md2"); // PGM
1116 }
1117
1118 //-------------------
1119
1120 gi.soundindex ("player/gasp1.wav"); // gasping for air
1121 gi.soundindex ("player/gasp2.wav"); // head breaking surface, not gasping
1122
1123 gi.soundindex ("player/watr_in.wav"); // feet hitting water
1124 gi.soundindex ("player/watr_out.wav"); // feet leaving water
1125
1126 gi.soundindex ("player/watr_un.wav"); // head going underwater
1127
1128 gi.soundindex ("player/u_breath1.wav");
1129 gi.soundindex ("player/u_breath2.wav");
1130
1131 gi.soundindex ("items/pkup.wav"); // bonus item pickup
1132 gi.soundindex ("world/land.wav"); // landing thud
1133 gi.soundindex ("misc/h2ohit1.wav"); // landing splash
1134
1135 gi.soundindex ("items/damage.wav");
1136 // ROGUE - double damage
1137 gi.soundindex ("misc/ddamage1.wav");
1138 // rogue
1139 gi.soundindex ("items/protect.wav");
1140 gi.soundindex ("items/protect4.wav");
1141 gi.soundindex ("weapons/noammo.wav");
1142
1143 gi.soundindex ("infantry/inflies1.wav");
1144
1145 sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2");
1146 gi.modelindex ("models/objects/gibs/arm/tris.md2");
1147 gi.modelindex ("models/objects/gibs/bone/tris.md2");
1148 gi.modelindex ("models/objects/gibs/bone2/tris.md2");
1149 gi.modelindex ("models/objects/gibs/chest/tris.md2");
1150 gi.modelindex ("models/objects/gibs/skull/tris.md2");
1151 gi.modelindex ("models/objects/gibs/head2/tris.md2");
1152
1153 //
1154 // Setup light animation tables. 'a' is total darkness, 'z' is doublebright.
1155 //
1156
1157 // 0 normal
1158 gi.configstring(CS_LIGHTS+0, "m");
1159
1160 // 1 FLICKER (first variety)
1161 gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo");
1162
1163 // 2 SLOW STRONG PULSE
1164 gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba");
1165
1166 // 3 CANDLE (first variety)
1167 gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg");
1168
1169 // 4 FAST STROBE
1170 gi.configstring(CS_LIGHTS+4, "mamamamamama");
1171
1172 // 5 GENTLE PULSE 1
1173 gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj");
1174
1175 // 6 FLICKER (second variety)
1176 gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno");
1177
1178 // 7 CANDLE (second variety)
1179 gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm");
1180
1181 // 8 CANDLE (third variety)
1182 gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa");
1183
1184 // 9 SLOW STROBE (fourth variety)
1185 gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz");
1186
1187 // 10 FLUORESCENT FLICKER
1188 gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma");
1189
1190 // 11 SLOW PULSE NOT FADE TO BLACK
1191 gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba");
1192
1193 // styles 32-62 are assigned by the light program for switchable lights
1194
1195 // 63 testing
1196 gi.configstring(CS_LIGHTS+63, "a");
1197 }
1198
1199 //
1200 //ROGUE
1201 //
1202
1203 //
1204 // Monster spawning code
1205 //
1206 // Used by the carrier, the medic_commander, and the black widow
1207 //
1208 // The sequence to create a flying monster is:
1209 //
1210 // FindSpawnPoint - tries to find suitable spot to spawn the monster in
1211 // CreateFlyMonster - this verifies the point as good and creates the monster
1212
1213 // To create a ground walking monster:
1214 //
1215 // FindSpawnPoint - same thing
1216 // CreateGroundMonster - this checks the volume and makes sure the floor under the volume is suitable
1217 //
1218
1219 // FIXME - for the black widow, if we want the stalkers coming in on the roof, we'll have to tweak some things
1220
1221 //
1222 // CreateMonster
1223 //
CreateMonster(vec3_t origin,vec3_t angles,char * classname)1224 edict_t *CreateMonster(vec3_t origin, vec3_t angles, char *classname)
1225 {
1226 edict_t *newEnt;
1227
1228 newEnt = G_Spawn();
1229
1230 VectorCopy(origin, newEnt->s.origin);
1231 VectorCopy(angles, newEnt->s.angles);
1232 newEnt->classname = ED_NewString (classname);
1233 newEnt->monsterinfo.aiflags |= AI_DO_NOT_COUNT;
1234
1235 VectorSet(newEnt->gravityVector, 0, 0, -1);
1236 ED_CallSpawn(newEnt);
1237 newEnt->s.renderfx |= RF_IR_VISIBLE;
1238
1239 return newEnt;
1240 }
1241
CreateFlyMonster(vec3_t origin,vec3_t angles,vec3_t mins,vec3_t maxs,char * classname)1242 edict_t *CreateFlyMonster (vec3_t origin, vec3_t angles, vec3_t mins, vec3_t maxs, char *classname)
1243 {
1244 if (!mins || !maxs || VectorCompare (mins, vec3_origin) || VectorCompare (maxs, vec3_origin))
1245 {
1246 DetermineBBox (classname, mins, maxs);
1247 }
1248
1249 if (!CheckSpawnPoint(origin, mins, maxs))
1250 return NULL;
1251
1252 return (CreateMonster (origin, angles, classname));
1253 }
1254
1255 // This is just a wrapper for CreateMonster that looks down height # of CMUs and sees if there
1256 // are bad things down there or not
1257 //
1258 // this is from m_move.c
1259 #define STEPSIZE 18
1260
CreateGroundMonster(vec3_t origin,vec3_t angles,vec3_t entMins,vec3_t entMaxs,char * classname,int height)1261 edict_t *CreateGroundMonster (vec3_t origin, vec3_t angles, vec3_t entMins, vec3_t entMaxs, char *classname, int height)
1262 {
1263 // trace_t tr;
1264 edict_t *newEnt;
1265 // vec3_t start, stop;
1266 // int failure = 0;
1267 // vec3_t mins, maxs;
1268 // int x, y;
1269 // float mid, bottom;
1270 vec3_t mins, maxs;
1271
1272 // if they don't provide us a bounding box, figure it out
1273 if (!entMins || !entMaxs || VectorCompare (entMins, vec3_origin) || VectorCompare (entMaxs, vec3_origin))
1274 {
1275 DetermineBBox (classname, mins, maxs);
1276 }
1277 else
1278 {
1279 VectorCopy (entMins, mins);
1280 VectorCopy (entMaxs, maxs);
1281 }
1282
1283 // check the ground to make sure it's there, it's relatively flat, and it's not toxic
1284 if (!CheckGroundSpawnPoint(origin, mins, maxs, height, -1))
1285 return NULL;
1286
1287 newEnt = CreateMonster (origin, angles, classname);
1288 if (!newEnt)
1289 return NULL;
1290
1291 return newEnt;
1292 }
1293
1294
1295 // FindSpawnPoint
1296 // PMM - this is used by the medic commander (possibly by the carrier) to find a good spawn point
1297 // if the startpoint is bad, try above the startpoint for a bit
1298
FindSpawnPoint(vec3_t startpoint,vec3_t mins,vec3_t maxs,vec3_t spawnpoint,float maxMoveUp)1299 qboolean FindSpawnPoint (vec3_t startpoint, vec3_t mins, vec3_t maxs, vec3_t spawnpoint, float maxMoveUp)
1300 {
1301 trace_t tr;
1302 float height;
1303 vec3_t top;
1304
1305 height = maxs[2] - mins[2];
1306
1307 tr = gi.trace (startpoint, mins, maxs, startpoint, NULL, MASK_MONSTERSOLID|CONTENTS_PLAYERCLIP);
1308 if((tr.startsolid || tr.allsolid) || (tr.ent != world))
1309 {
1310 // if ( ((tr.ent->svflags & SVF_MONSTER) && (tr.ent->health <= 0)) ||
1311 // (tr.ent->svflags & SVF_DAMAGEABLE) )
1312 // {
1313 // T_Damage (tr.ent, self, self, vec3_origin, self->enemy->s.origin,
1314 // pain_normal, hurt, 0, 0, MOD_UNKNOWN);
1315
1316 VectorCopy (startpoint, top);
1317 top[2] += maxMoveUp;
1318 /*
1319 gi.WriteByte (svc_temp_entity);
1320 gi.WriteByte (TE_DEBUGTRAIL);
1321 gi.WritePosition (top);
1322 gi.WritePosition (startpoint);
1323 gi.multicast (startpoint, MULTICAST_ALL);
1324 */
1325 tr = gi.trace (top, mins, maxs, startpoint, NULL, MASK_MONSTERSOLID);
1326 if (tr.startsolid || tr.allsolid)
1327 {
1328 // if ((g_showlogic) && (g_showlogic->value))
1329 // if (tr.ent)
1330 // gi.dprintf("FindSpawnPoint: failed to find a point -- blocked by %s\n", tr.ent->classname);
1331 // else
1332 // gi.dprintf("FindSpawnPoint: failed to find a point\n");
1333
1334 return false;
1335 }
1336 else
1337 {
1338 // if ((g_showlogic) && (g_showlogic->value))
1339 // gi.dprintf ("FindSpawnPoint: %s -> %s\n", vtos (startpoint), vtos (tr.endpos));
1340 VectorCopy (tr.endpos, spawnpoint);
1341 return true;
1342 }
1343 }
1344 else
1345 {
1346 VectorCopy (startpoint, spawnpoint);
1347 return true;
1348 }
1349 }
1350
1351 // FIXME - all of this needs to be tweaked to handle the new gravity rules
1352 // if we ever want to spawn stuff on the roof
1353
1354 //
1355 // CheckSpawnPoint
1356 //
1357 // PMM - checks volume to make sure we can spawn a monster there (is it solid?)
1358 //
1359 // This is all fliers should need
1360
CheckSpawnPoint(vec3_t origin,vec3_t mins,vec3_t maxs)1361 qboolean CheckSpawnPoint (vec3_t origin, vec3_t mins, vec3_t maxs)
1362 {
1363 trace_t tr;
1364
1365 if (!mins || !maxs || VectorCompare(mins, vec3_origin) || VectorCompare (maxs, vec3_origin))
1366 {
1367 return false;
1368 }
1369
1370 tr = gi.trace (origin, mins, maxs, origin, NULL, MASK_MONSTERSOLID);
1371 if(tr.startsolid || tr.allsolid)
1372 {
1373 // if ((g_showlogic) && (g_showlogic->value))
1374 // gi.dprintf("createmonster in wall. removing\n");
1375 return false;
1376 }
1377 if (tr.ent != world)
1378 {
1379 // if ((g_showlogic) && (g_showlogic->value))
1380 // gi.dprintf("createmonster in entity %s\n", tr.ent->classname);
1381 return false;
1382 }
1383 return true;
1384 }
1385
1386 //
1387 // CheckGroundSpawnPoint
1388 //
1389 // PMM - used for walking monsters
1390 // checks:
1391 // 1) is there a ground within the specified height of the origin?
1392 // 2) is the ground non-water?
1393 // 3) is the ground flat enough to walk on?
1394 //
1395
CheckGroundSpawnPoint(vec3_t origin,vec3_t entMins,vec3_t entMaxs,float height,float gravity)1396 qboolean CheckGroundSpawnPoint (vec3_t origin, vec3_t entMins, vec3_t entMaxs, float height, float gravity)
1397 {
1398 trace_t tr;
1399 vec3_t start, stop;
1400 int failure = 0;
1401 vec3_t mins, maxs;
1402 int x, y;
1403 float mid, bottom;
1404
1405 if (!CheckSpawnPoint (origin, entMins, entMaxs))
1406 return false;
1407
1408 // FIXME - this is too conservative about angled surfaces
1409
1410 VectorCopy (origin, stop);
1411 // FIXME - gravity vector
1412 stop[2] = origin[2] + entMins[2] - height;
1413
1414 /*
1415 gi.WriteByte (svc_temp_entity);
1416 gi.WriteByte (TE_DEBUGTRAIL);
1417 gi.WritePosition (origin);
1418 gi.WritePosition (stop);
1419 gi.multicast (start, MULTICAST_ALL);
1420 */
1421
1422 tr = gi.trace (origin, entMins, entMaxs, stop, NULL, MASK_MONSTERSOLID | MASK_WATER);
1423 // it's not going to be all solid or start solid, since that's checked above
1424
1425 if ((tr.fraction < 1) && (tr.contents & MASK_MONSTERSOLID))
1426 {
1427 // we found a non-water surface down there somewhere. now we need to check to make sure it's not too sloped
1428 //
1429 // algorithm straight out of m_move.c:M_CheckBottom()
1430 //
1431
1432 // first, do the midpoint trace
1433
1434 VectorAdd (tr.endpos, entMins, mins);
1435 VectorAdd (tr.endpos, entMaxs, maxs);
1436
1437
1438 // first, do the easy flat check
1439 //
1440 #ifdef ROGUE_GRAVITY
1441 // FIXME - this will only handle 0,0,1 and 0,0,-1 gravity vectors
1442 if(gravity > 0)
1443 start[2] = maxs[2] + 1;
1444 else
1445 start[2] = mins[2] - 1;
1446 #else
1447 start[2] = mins[2] - 1;
1448 #endif
1449 for (x=0 ; x<=1 ; x++)
1450 {
1451 for (y=0 ; y<=1 ; y++)
1452 {
1453 start[0] = x ? maxs[0] : mins[0];
1454 start[1] = y ? maxs[1] : mins[1];
1455 if (gi.pointcontents (start) != CONTENTS_SOLID)
1456 goto realcheck;
1457 }
1458 }
1459
1460 // if it passed all four above checks, we're done
1461 return true;
1462
1463 realcheck:
1464
1465 // check it for real
1466
1467 start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
1468 start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
1469 start[2] = mins[2];
1470
1471 tr = gi.trace (start, vec3_origin, vec3_origin, stop, NULL, MASK_MONSTERSOLID);
1472
1473 if (tr.fraction == 1.0)
1474 return false;
1475 mid = bottom = tr.endpos[2];
1476
1477 #ifdef ROGUE_GRAVITY
1478 if(gravity < 0)
1479 {
1480 start[2] = mins[2];
1481 stop[2] = start[2] - STEPSIZE - STEPSIZE;
1482 mid = bottom = tr.endpos[2] + entMins[2];
1483 }
1484 else
1485 {
1486 start[2] = maxs[2];
1487 stop[2] = start[2] + STEPSIZE + STEPSIZE;
1488 mid = bottom = tr.endpos[2] - entMaxs[2];
1489 }
1490 #else
1491 stop[2] = start[2] - 2*STEPSIZE;
1492 mid = bottom = tr.endpos[2] + entMins[2];
1493 #endif
1494
1495 for (x=0 ; x<=1 ; x++)
1496 for (y=0 ; y<=1 ; y++)
1497 {
1498 start[0] = stop[0] = x ? maxs[0] : mins[0];
1499 start[1] = stop[1] = y ? maxs[1] : mins[1];
1500
1501 /*
1502 gi.WriteByte (svc_temp_entity);
1503 gi.WriteByte (TE_DEBUGTRAIL);
1504 gi.WritePosition (start);
1505 gi.WritePosition (stop);
1506 gi.multicast (start, MULTICAST_ALL);
1507 */
1508 tr = gi.trace (start, vec3_origin, vec3_origin, stop, NULL, MASK_MONSTERSOLID);
1509
1510 //PGM
1511 #ifdef ROGUE_GRAVITY
1512 // FIXME - this will only handle 0,0,1 and 0,0,-1 gravity vectors
1513 if(gravity > 0)
1514 {
1515 if (tr.fraction != 1.0 && tr.endpos[2] < bottom)
1516 bottom = tr.endpos[2];
1517 if (tr.fraction == 1.0 || tr.endpos[2] - mid > STEPSIZE)
1518 {
1519 // if ((g_showlogic) && (g_showlogic->value))
1520 // gi.dprintf ("spawn - rejecting due to uneven ground\n");
1521 return false;
1522 }
1523 }
1524 else
1525 {
1526 if (tr.fraction != 1.0 && tr.endpos[2] > bottom)
1527 bottom = tr.endpos[2];
1528 if (tr.fraction == 1.0 || mid - tr.endpos[2] > STEPSIZE)
1529 {
1530 // if ((g_showlogic) && (g_showlogic->value))
1531 // gi.dprintf ("spawn - rejecting due to uneven ground\n");
1532 return false;
1533 }
1534 }
1535 #else
1536 if (tr.fraction != 1.0 && tr.endpos[2] > bottom)
1537 bottom = tr.endpos[2];
1538 if (tr.fraction == 1.0 || mid - tr.endpos[2] > STEPSIZE)
1539 {
1540 return false;
1541 }
1542 #endif
1543 }
1544
1545 return true; // we can land on it, it's ok
1546 }
1547
1548 // otherwise, it's either water (bad) or not there (too far)
1549 // if we're here, it's bad below
1550 // if ((g_showlogic) && (g_showlogic->value))
1551 // {
1552 // if (tr.fraction < 1)
1553 // if ((g_showlogic) && (g_showlogic->value))
1554 // gi.dprintf("groundmonster would fall into water/slime/lava\n");
1555 // else
1556 // if ((g_showlogic) && (g_showlogic->value))
1557 // gi.dprintf("groundmonster would fall too far\n");
1558 // }
1559
1560 return false;
1561 }
1562
DetermineBBox(char * classname,vec3_t mins,vec3_t maxs)1563 void DetermineBBox (char *classname, vec3_t mins, vec3_t maxs)
1564 {
1565 // FIXME - cache this stuff
1566 edict_t *newEnt;
1567
1568 newEnt = G_Spawn();
1569
1570 VectorCopy(vec3_origin, newEnt->s.origin);
1571 VectorCopy(vec3_origin, newEnt->s.angles);
1572 newEnt->classname = ED_NewString (classname);
1573 newEnt->monsterinfo.aiflags |= AI_DO_NOT_COUNT;
1574
1575 ED_CallSpawn(newEnt);
1576
1577 VectorCopy (newEnt->mins, mins);
1578 VectorCopy (newEnt->maxs, maxs);
1579
1580 G_FreeEdict (newEnt);
1581 }
1582
1583 // ****************************
1584 // SPAWNGROW stuff
1585 // ****************************
1586
1587 #define SPAWNGROW_LIFESPAN 0.3
1588
spawngrow_think(edict_t * self)1589 void spawngrow_think (edict_t *self)
1590 {
1591 int i;
1592
1593 for (i=0; i<2; i++)
1594 {
1595 self->s.angles[0] = rand()%360;
1596 self->s.angles[1] = rand()%360;
1597 self->s.angles[2] = rand()%360;
1598 }
1599 if ((level.time < self->wait) && (self->s.frame < 2))
1600 self->s.frame++;
1601 if (level.time >= self->wait)
1602 {
1603 if (self->s.effects & EF_SPHERETRANS)
1604 {
1605 G_FreeEdict (self);
1606 return;
1607 }
1608 else if (self->s.frame > 0)
1609 self->s.frame--;
1610 else
1611 {
1612 G_FreeEdict (self);
1613 return;
1614 }
1615 }
1616 self->nextthink += FRAMETIME;
1617 }
1618
SpawnGrow_Spawn(vec3_t startpos,int size)1619 void SpawnGrow_Spawn (vec3_t startpos, int size)
1620 {
1621 edict_t *ent;
1622 int i;
1623 float lifespan;
1624
1625 ent = G_Spawn();
1626 VectorCopy(startpos, ent->s.origin);
1627 for (i=0; i<2; i++)
1628 {
1629 ent->s.angles[0] = rand()%360;
1630 ent->s.angles[1] = rand()%360;
1631 ent->s.angles[2] = rand()%360;
1632 }
1633 ent->solid = SOLID_NOT;
1634 // ent->s.renderfx = RF_FULLBRIGHT | RF_IR_VISIBLE;
1635 ent->s.renderfx = RF_IR_VISIBLE;
1636 ent->movetype = MOVETYPE_NONE;
1637 ent->classname = "spawngro";
1638
1639 if (size <= 1)
1640 {
1641 lifespan = SPAWNGROW_LIFESPAN;
1642 ent->s.modelindex = gi.modelindex("models/items/spawngro2/tris.md2");
1643 }
1644 else if (size == 2)
1645 {
1646 ent->s.modelindex = gi.modelindex("models/items/spawngro3/tris.md2");
1647 lifespan = 2;
1648 }
1649 else
1650 {
1651 ent->s.modelindex = gi.modelindex("models/items/spawngro/tris.md2");
1652 lifespan = SPAWNGROW_LIFESPAN;
1653 }
1654
1655 ent->think = spawngrow_think;
1656
1657 ent->wait = level.time + lifespan;
1658 ent->nextthink = level.time + FRAMETIME;
1659 if (size != 2)
1660 ent->s.effects |= EF_SPHERETRANS;
1661 gi.linkentity (ent);
1662 }
1663
1664
1665 // ****************************
1666 // WidowLeg stuff
1667 // ****************************
1668
1669 #define MAX_LEGSFRAME 23
1670 #define LEG_WAIT_TIME 1
1671
1672 void ThrowMoreStuff (edict_t *self, vec3_t point);
1673 void ThrowSmallStuff (edict_t *self, vec3_t point);
1674 void ThrowWidowGibLoc (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, qboolean fade);
1675 void ThrowWidowGibSized (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, int hitsound, qboolean fade);
1676
widowlegs_think(edict_t * self)1677 void widowlegs_think (edict_t *self)
1678 {
1679 vec3_t offset;
1680 vec3_t point;
1681 vec3_t f,r,u;
1682
1683 if (self->s.frame == 17)
1684 {
1685 VectorSet (offset, 11.77, -7.24, 23.31);
1686 AngleVectors (self->s.angles, f, r, u);
1687 G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1688 gi.WriteByte (svc_temp_entity);
1689 gi.WriteByte (TE_EXPLOSION1);
1690 gi.WritePosition (point);
1691 gi.multicast (point, MULTICAST_ALL);
1692 ThrowSmallStuff (self, point);
1693 }
1694
1695 if (self->s.frame < MAX_LEGSFRAME)
1696 {
1697 self->s.frame++;
1698 self->nextthink = level.time + FRAMETIME;
1699 return;
1700 }
1701 else if (self->wait == 0)
1702 {
1703 self->wait = level.time + LEG_WAIT_TIME;
1704 }
1705 if (level.time > self->wait)
1706 {
1707 AngleVectors (self->s.angles, f, r, u);
1708
1709 VectorSet (offset, -65.6, -8.44, 28.59);
1710 G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1711 gi.WriteByte (svc_temp_entity);
1712 gi.WriteByte (TE_EXPLOSION1);
1713 gi.WritePosition (point);
1714 gi.multicast (point, MULTICAST_ALL);
1715 ThrowSmallStuff (self, point);
1716
1717 ThrowWidowGibSized (self, "models/monsters/blackwidow/gib1/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1718 ThrowWidowGibSized (self, "models/monsters/blackwidow/gib2/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1719
1720 VectorSet (offset, -1.04, -51.18, 7.04);
1721 G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1722 gi.WriteByte (svc_temp_entity);
1723 gi.WriteByte (TE_EXPLOSION1);
1724 gi.WritePosition (point);
1725 gi.multicast (point, MULTICAST_ALL);
1726 ThrowSmallStuff (self, point);
1727
1728 ThrowWidowGibSized (self, "models/monsters/blackwidow/gib1/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1729 ThrowWidowGibSized (self, "models/monsters/blackwidow/gib2/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1730 ThrowWidowGibSized (self, "models/monsters/blackwidow/gib3/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
1731
1732 G_FreeEdict (self);
1733 return;
1734 }
1735 if ((level.time > (self->wait - 0.5)) && (self->count == 0))
1736 {
1737 self->count = 1;
1738 AngleVectors (self->s.angles, f, r, u);
1739
1740 VectorSet (offset, 31, -88.7, 10.96);
1741 G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1742 gi.WriteByte (svc_temp_entity);
1743 gi.WriteByte (TE_EXPLOSION1);
1744 gi.WritePosition (point);
1745 gi.multicast (point, MULTICAST_ALL);
1746 // ThrowSmallStuff (self, point);
1747
1748 VectorSet (offset, -12.67, -4.39, 15.68);
1749 G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
1750 gi.WriteByte (svc_temp_entity);
1751 gi.WriteByte (TE_EXPLOSION1);
1752 gi.WritePosition (point);
1753 gi.multicast (point, MULTICAST_ALL);
1754 // ThrowSmallStuff (self, point);
1755
1756 self->nextthink = level.time + FRAMETIME;
1757 return;
1758 }
1759 self->nextthink = level.time + FRAMETIME;
1760 }
1761
Widowlegs_Spawn(vec3_t startpos,vec3_t angles)1762 void Widowlegs_Spawn (vec3_t startpos, vec3_t angles)
1763 {
1764 edict_t *ent;
1765
1766 ent = G_Spawn();
1767 VectorCopy(startpos, ent->s.origin);
1768 VectorCopy(angles, ent->s.angles);
1769 ent->solid = SOLID_NOT;
1770 ent->s.renderfx = RF_IR_VISIBLE;
1771 ent->movetype = MOVETYPE_NONE;
1772 ent->classname = "widowlegs";
1773
1774 ent->s.modelindex = gi.modelindex("models/monsters/legs/tris.md2");
1775 ent->think = widowlegs_think;
1776
1777 ent->nextthink = level.time + FRAMETIME;
1778 gi.linkentity (ent);
1779 }
1780