mirror of
https://github.com/blendogames/thirtyflightsofloving.git
synced 2024-11-15 00:41:21 +00:00
e872299cbd
Added close-range safety check for gunners with contact grenades in default Lazarus and missionpack DLLs.
2998 lines
No EOL
81 KiB
C
2998 lines
No EOL
81 KiB
C
|
|
#include "./g_local.h"
|
|
#include "pak.h"
|
|
|
|
/*typedef struct
|
|
{
|
|
char *name;
|
|
void (*spawn)(edict_t *ent);
|
|
} spawn_t;*/
|
|
|
|
|
|
void SP_item_health (edict_t *self);
|
|
void SP_item_health_small (edict_t *self);
|
|
void SP_item_health_large (edict_t *self);
|
|
void SP_item_health_mega (edict_t *self);
|
|
|
|
void SP_info_player_start (edict_t *ent);
|
|
void SP_info_player_deathmatch (edict_t *ent);
|
|
void SP_info_player_coop (edict_t *ent);
|
|
void SP_info_player_intermission (edict_t *ent);
|
|
|
|
void SP_func_plat (edict_t *ent);
|
|
void SP_func_rotating (edict_t *ent);
|
|
void SP_func_button (edict_t *ent);
|
|
void SP_func_door (edict_t *ent);
|
|
void SP_func_door_secret (edict_t *ent);
|
|
void SP_func_door_rotating (edict_t *ent);
|
|
void SP_func_water (edict_t *ent);
|
|
void SP_func_bobbingwater(edict_t *self); //Knightmare added
|
|
void SP_func_train (edict_t *ent);
|
|
void SP_func_conveyor (edict_t *self);
|
|
void SP_func_wall (edict_t *self);
|
|
void SP_func_object (edict_t *self);
|
|
void SP_func_explosive (edict_t *self);
|
|
void SP_func_timer (edict_t *self);
|
|
void SP_func_areaportal (edict_t *ent);
|
|
void SP_func_clock (edict_t *ent);
|
|
void SP_func_killbox (edict_t *ent);
|
|
|
|
void SP_trigger_always (edict_t *ent);
|
|
void SP_trigger_once (edict_t *ent);
|
|
void SP_trigger_multiple (edict_t *ent);
|
|
void SP_trigger_bbox (edict_t *self);
|
|
void SP_trigger_relay (edict_t *ent);
|
|
void SP_trigger_push (edict_t *ent);
|
|
void SP_trigger_push_bbox (edict_t *ent);
|
|
|
|
void SP_trigger_hurt (edict_t *ent);
|
|
void SP_trigger_hurt_bbox (edict_t *ent);
|
|
void SP_trigger_key (edict_t *ent);
|
|
void SP_trigger_counter (edict_t *ent);
|
|
void SP_trigger_elevator (edict_t *ent);
|
|
void SP_trigger_gravity (edict_t *ent);
|
|
void SP_trigger_gravity_bbox (edict_t *ent);
|
|
void SP_trigger_monsterjump (edict_t *ent);
|
|
void SP_trigger_monsterjump_bbox (edict_t *ent);
|
|
|
|
void SP_target_temp_entity (edict_t *ent);
|
|
void SP_target_speaker (edict_t *ent);
|
|
void SP_target_explosion (edict_t *ent);
|
|
void SP_target_changelevel (edict_t *ent);
|
|
void SP_target_secret (edict_t *ent);
|
|
void SP_target_goal (edict_t *ent);
|
|
void SP_target_splash (edict_t *ent);
|
|
void SP_target_spawner (edict_t *ent);
|
|
void SP_target_blaster (edict_t *ent);
|
|
void SP_target_crosslevel_trigger (edict_t *ent);
|
|
void SP_target_crosslevel_target (edict_t *ent);
|
|
void SP_target_laser (edict_t *self);
|
|
void SP_target_help (edict_t *ent);
|
|
void SP_target_actor (edict_t *ent);
|
|
void SP_target_lightramp (edict_t *self);
|
|
void SP_target_earthquake (edict_t *ent);
|
|
void SP_target_character (edict_t *ent);
|
|
void SP_target_string (edict_t *ent);
|
|
//Knightmare
|
|
void SP_target_monitor (edict_t *ent);
|
|
void SP_target_monsterbattle (edict_t *self);
|
|
void SP_target_movewith (edict_t *self);
|
|
void SP_target_change (edict_t *self);
|
|
void SP_target_rotation (edict_t *self);
|
|
void SP_target_attractor (edict_t *self);
|
|
void SP_target_cd (edict_t *self);
|
|
void SP_target_skill (edict_t *self);
|
|
void SP_target_sky (edict_t *self);
|
|
void SP_target_playback (edict_t *self);
|
|
void SP_target_rocks (edict_t *self);
|
|
void SP_target_clone (edict_t *self);
|
|
void SP_target_text (edict_t *self);
|
|
void SP_thing (edict_t *self);
|
|
|
|
void SP_worldspawn (edict_t *ent);
|
|
void SP_viewthing (edict_t *ent);
|
|
|
|
void SP_light (edict_t *self);
|
|
void SP_light_mine1 (edict_t *ent);
|
|
void SP_light_mine2 (edict_t *ent);
|
|
void SP_info_null (edict_t *self);
|
|
void SP_info_notnull (edict_t *self);
|
|
void SP_path_corner (edict_t *self);
|
|
void SP_point_combat (edict_t *self);
|
|
|
|
void SP_misc_explobox (edict_t *self);
|
|
void SP_misc_banner (edict_t *self);
|
|
void SP_misc_satellite_dish (edict_t *self);
|
|
void SP_misc_actor (edict_t *self);
|
|
void SP_misc_gib_arm (edict_t *self);
|
|
void SP_misc_gib_leg (edict_t *self);
|
|
void SP_misc_gib_head (edict_t *self);
|
|
void SP_misc_insane (edict_t *self);
|
|
void SP_misc_deadsoldier (edict_t *self);
|
|
void SP_misc_viper (edict_t *self);
|
|
void SP_misc_viper_bomb (edict_t *self);
|
|
void SP_misc_bigviper (edict_t *self);
|
|
void SP_misc_strogg_ship (edict_t *self);
|
|
void SP_misc_teleporter (edict_t *self);
|
|
void SP_misc_teleporter_dest (edict_t *self);
|
|
void SP_misc_blackhole (edict_t *self);
|
|
void SP_misc_eastertank (edict_t *self);
|
|
void SP_misc_easterchick (edict_t *self);
|
|
void SP_misc_easterchick2 (edict_t *self);
|
|
//Knightmare- patient for the infirmary
|
|
void SP_misc_sick_guard (edict_t *self);
|
|
//Knightmare- experiment gekk
|
|
void SP_misc_gekk_writhe (edict_t *self);
|
|
|
|
//Knightmare- Coconut Monkey 3 Flame entities
|
|
void SP_light_flame1 (edict_t *self);
|
|
void SP_light_flame1s (edict_t *self);
|
|
void SP_light_flame2 (edict_t *self);
|
|
void SP_light_flame2s (edict_t *self);
|
|
//Knightmare- Coconut Monkey
|
|
void SP_monster_coco_monkey (edict_t *self);
|
|
|
|
void SP_monster_berserk (edict_t *self);
|
|
void SP_monster_gladiator (edict_t *self);
|
|
void SP_monster_gunner (edict_t *self);
|
|
void SP_monster_infantry (edict_t *self);
|
|
void SP_monster_soldier_light (edict_t *self);
|
|
void SP_monster_soldier (edict_t *self);
|
|
void SP_monster_soldier_ss (edict_t *self);
|
|
void SP_monster_tank (edict_t *self);
|
|
void SP_monster_medic (edict_t *self);
|
|
void SP_monster_flipper (edict_t *self);
|
|
void SP_monster_chick (edict_t *self);
|
|
void SP_monster_parasite (edict_t *self);
|
|
void SP_monster_flyer (edict_t *self);
|
|
void SP_monster_gekk (edict_t *self);
|
|
void SP_monster_brain (edict_t *self);
|
|
void SP_monster_brain_beta (edict_t *self);
|
|
void SP_monster_floater (edict_t *self);
|
|
void SP_monster_hover (edict_t *self);
|
|
void SP_monster_mutant (edict_t *self);
|
|
void SP_monster_supertank (edict_t *self);
|
|
void SP_monster_boss2 (edict_t *self);
|
|
void SP_monster_jorg (edict_t *self);
|
|
//Knightmare- added spawn function for monster_makron
|
|
void SP_monster_makron (edict_t *self);
|
|
void SP_monster_boss3_stand (edict_t *self);
|
|
|
|
void SP_monster_commander_body (edict_t *self);
|
|
|
|
void SP_turret_breach (edict_t *self);
|
|
void SP_turret_base (edict_t *self);
|
|
void SP_turret_driver (edict_t *self);
|
|
|
|
// RAFAEL 14-APR-98
|
|
void SP_monster_soldier_hypergun (edict_t *self);
|
|
void SP_monster_soldier_lasergun (edict_t *self);
|
|
void SP_monster_soldier_ripper (edict_t *self);
|
|
void SP_monster_fixbot (edict_t *self);
|
|
void SP_monster_gekk (edict_t *self);
|
|
void SP_monster_chick_heat (edict_t *self);
|
|
void SP_monster_gladb (edict_t *self);
|
|
void SP_monster_boss5 (edict_t *self);
|
|
|
|
// Knightmare- LM Escape soldiers
|
|
void SP_monster_soldier_plasma_re (edict_t *self);
|
|
void SP_monster_soldier_plasma_sp (edict_t *self);
|
|
|
|
// Zaero
|
|
void SP_monster_autocannon (edict_t *self);
|
|
void SP_monster_autocannon_floor (edict_t *self);
|
|
void SP_monster_hound (edict_t *self);
|
|
void SP_monster_handler (edict_t *self);
|
|
void SP_monster_sentien(edict_t *self);
|
|
void SP_monster_zboss (edict_t *self);
|
|
void SP_target_zboss_target (edict_t *self);
|
|
void SP_func_barrier (edict_t *self);
|
|
void SP_trigger_laser (edict_t *self);
|
|
void SP_misc_securitycamera (edict_t *self);
|
|
void SP_misc_commdish (edict_t *self);
|
|
void SP_misc_crate (edict_t *self);
|
|
void SP_misc_crate_medium (edict_t *self);
|
|
void SP_misc_crate_small (edict_t *self);
|
|
void SP_misc_seat (edict_t *self);
|
|
// end Zaero
|
|
|
|
// Knightmare- the dog from Coconut Monkey 3
|
|
void SP_monster_dog (edict_t *self);
|
|
// Knightmare- the vulture from Coconut Monkey 2
|
|
void SP_monster_vulture (edict_t *self);
|
|
|
|
void SP_rotating_light (edict_t *self);
|
|
void SP_object_repair (edict_t *self);
|
|
void SP_misc_crashviper (edict_t *ent);
|
|
void SP_misc_viper_missile (edict_t *self);
|
|
void SP_misc_amb4 (edict_t *ent);
|
|
void SP_target_mal_laser (edict_t *ent);
|
|
void SP_misc_transport (edict_t *ent);
|
|
// END 14-APR-98
|
|
void SP_misc_nuke (edict_t *ent);
|
|
|
|
//===========
|
|
//ROGUE
|
|
void SP_func_plat2 (edict_t *ent);
|
|
void SP_func_door_secret2(edict_t *ent);
|
|
void SP_func_force_wall(edict_t *ent);
|
|
|
|
//Knightmare
|
|
void SP_func_breakaway (edict_t *self);
|
|
void SP_func_monitor (edict_t *self);
|
|
void SP_func_pendulum (edict_t *self);
|
|
void SP_func_pivot (edict_t *self);
|
|
void SP_func_pushable (edict_t *self);
|
|
void SP_func_reflect (edict_t *self);
|
|
void SP_func_rotating_dh (edict_t *self);
|
|
void SP_func_door_rot_dh (edict_t *self);
|
|
void SP_func_door_swinging (edict_t *self);
|
|
void SP_func_trackchange (edict_t *self);
|
|
void SP_func_tracktrain (edict_t *self);
|
|
void SP_path_track (edict_t *self);
|
|
void SP_info_train_start (edict_t *self);
|
|
void SP_func_trainbutton (edict_t *self);
|
|
void SP_func_vehicle (edict_t *self);
|
|
void SP_info_train_start (edict_t *self);
|
|
void SP_crane_beam (edict_t *self);
|
|
void SP_crane_hoist (edict_t *self);
|
|
void SP_crane_hook (edict_t *self);
|
|
void SP_crane_control (edict_t *self);
|
|
void SP_crane_reset (edict_t *self);
|
|
void SP_info_player_coop_lava (edict_t *self);
|
|
void SP_info_teleport_destination (edict_t *self);
|
|
void SP_trigger_teleport (edict_t *self);
|
|
void SP_trigger_teleporter (edict_t *self);
|
|
void SP_trigger_teleporter_bbox (edict_t *self);
|
|
void SP_trigger_disguise (edict_t *self);
|
|
void SP_trigger_inside (edict_t *self);
|
|
void SP_trigger_inside_bbox (edict_t *self);
|
|
void SP_trigger_mass (edict_t *self);
|
|
void SP_trigger_mass_bbox (edict_t *self);
|
|
void SP_trigger_scales (edict_t *self);
|
|
void SP_trigger_scales_bbox (edict_t *self);
|
|
void SP_trigger_switch (edict_t *self);
|
|
void SP_trigger_look (edict_t *self);
|
|
void SP_trigger_speaker (edict_t *self);
|
|
|
|
void SP_monster_stalker (edict_t *self);
|
|
void SP_monster_turret (edict_t *self);
|
|
void SP_target_steam (edict_t *self);
|
|
void SP_target_anger (edict_t *self);
|
|
void SP_target_killplayers (edict_t *self);
|
|
// PMM - still experimental!
|
|
void SP_target_blacklight (edict_t *self);
|
|
void SP_target_orb (edict_t *self);
|
|
// pmm
|
|
//void SP_target_spawn (edict_t *self);
|
|
void SP_hint_path (edict_t *self);
|
|
void SP_monster_carrier (edict_t *self);
|
|
void SP_monster_widow (edict_t *self);
|
|
void SP_monster_widow2 (edict_t *self);
|
|
void SP_dm_tag_token (edict_t *self);
|
|
void SP_dm_dball_goal (edict_t *self);
|
|
void SP_dm_dball_ball (edict_t *self);
|
|
void SP_dm_dball_team1_start (edict_t *self);
|
|
void SP_dm_dball_team2_start (edict_t *self);
|
|
void SP_dm_dball_ball_start (edict_t *self);
|
|
void SP_dm_dball_speed_change (edict_t *self);
|
|
void SP_monster_kamikaze (edict_t *self);
|
|
//void SP_monster_chick2 (edict_t *self);
|
|
void SP_turret_invisible_brain (edict_t *self);
|
|
void SP_xatrix_item (edict_t *self);
|
|
void SP_misc_nuke_core (edict_t *self);
|
|
//ROGUE
|
|
//===========
|
|
|
|
void SP_target_command (edict_t *self);
|
|
void SP_target_set_effect (edict_t *self);
|
|
void SP_target_effect (edict_t *self);
|
|
void SP_target_fade (edict_t *self);
|
|
void SP_target_failure (edict_t *self);
|
|
void SP_target_fog (edict_t *self);
|
|
void SP_trigger_fog (edict_t *self);
|
|
void SP_trigger_fog_bbox (edict_t *self);
|
|
void SP_target_precipitation (edict_t *self);
|
|
void SP_target_fountain (edict_t *self);
|
|
void SP_target_lightswitch (edict_t *self);
|
|
void SP_target_locator (edict_t *self);
|
|
void SP_target_lock (edict_t *self);
|
|
void SP_target_lock_clue (edict_t *self);
|
|
void SP_target_lock_code (edict_t *self);
|
|
void SP_target_lock_digit (edict_t *self);
|
|
//void SP_target_ignore_player (edict_t *self);
|
|
void SP_target_global_text (edict_t *self);
|
|
void SP_light_torch (edict_t *self);
|
|
void SP_light_flame (edict_t *self);
|
|
void SP_model_spawn (edict_t *self);
|
|
void SP_model_train (edict_t *self);
|
|
void SP_model_turret (edict_t *self);
|
|
void SP_func_dm_wall (edict_t *self);
|
|
void SP_trigger_transition (edict_t *self);
|
|
void SP_trigger_transition_bbox (edict_t *self);
|
|
|
|
// Knightmare- entities that use origin-based train pathing
|
|
void SP_func_train_origin (edict_t *self);
|
|
void SP_model_train_origin (edict_t *self);
|
|
void SP_misc_viper_origin (edict_t *ent);
|
|
void SP_misc_crashviper_origin (edict_t *ent);
|
|
void SP_misc_strogg_ship_origin (edict_t *ent);
|
|
void SP_misc_transport_origin (edict_t *ent);
|
|
|
|
// Knightmare- Q1 monsters/entities
|
|
void SP_monster_q1_chthon (edict_t *self);
|
|
void SP_monster_q1_dog (edict_t *self);
|
|
void SP_monster_q1_enforcer (edict_t *self);
|
|
void SP_monster_q1_fiend (edict_t *self);
|
|
void SP_monster_q1_grunt (edict_t *self);
|
|
void SP_monster_q1_hknight (edict_t *self);
|
|
void SP_monster_q1_knight (edict_t *self);
|
|
void SP_monster_q1_ogre (edict_t *self);
|
|
void SP_monster_q1_rotfish (edict_t *self);
|
|
void SP_monster_q1_scrag (edict_t *self);
|
|
void SP_monster_q1_shalrath (edict_t *self);
|
|
void SP_monster_q1_shambler (edict_t *self);
|
|
void SP_monster_q1_tarbaby (edict_t *self);
|
|
void SP_monster_q1_zombie (edict_t *self);
|
|
void SP_monster_q1_freddie (edict_t *self);
|
|
|
|
void SP_misc_q1_zombie_crucified (edict_t *self);
|
|
void SP_misc_q1_air_bubbles (edict_t *self);
|
|
void SP_misc_q1_large_flame(edict_t *self);
|
|
void SP_misc_q1_small_flame (edict_t *self);
|
|
void SP_misc_q1_torch(edict_t *self);
|
|
void SP_target_q1_trap(edict_t *self);
|
|
void SP_misc_q1_explobox(edict_t *self);
|
|
void SP_misc_q1_fireball(edict_t *self);
|
|
void SP_misc_q1_globe(edict_t *self);
|
|
// end Knightmare
|
|
|
|
// transition entities
|
|
void SP_bolt (edict_t *self);
|
|
void SP_bolt2 (edict_t *self);
|
|
void SP_gekk_loogie (edict_t *self);
|
|
void SP_flechette (edict_t *self);
|
|
void SP_tracker (edict_t *self);
|
|
void SP_ion (edict_t *self);
|
|
void SP_phalanx_plasma (edict_t *self);
|
|
void SP_debris (edict_t *self);
|
|
void SP_gib (edict_t *self);
|
|
void SP_gibhead (edict_t *self);
|
|
void SP_grenade (edict_t *self);
|
|
void SP_handgrenade (edict_t *self);
|
|
void SP_shocksphere (edict_t *self);
|
|
void SP_prox (edict_t *self);
|
|
void SP_tesla (edict_t *self);
|
|
void SP_trap (edict_t *self);
|
|
void SP_rocket (edict_t *self);
|
|
void SP_missile (edict_t *self);
|
|
void SP_goop (edict_t *self); // SKWiD MOD
|
|
//
|
|
// end Lazarus
|
|
|
|
|
|
spawn_t spawns[] = {
|
|
{"item_health", SP_item_health},
|
|
{"item_health_small", SP_item_health_small},
|
|
{"item_health_large", SP_item_health_large},
|
|
{"item_health_mega", SP_item_health_mega},
|
|
|
|
{"info_player_start", SP_info_player_start},
|
|
{"info_player_deathmatch", SP_info_player_deathmatch},
|
|
{"info_player_coop", SP_info_player_coop},
|
|
{"info_player_intermission", SP_info_player_intermission},
|
|
|
|
{"func_plat", SP_func_plat},
|
|
{"func_button", SP_func_button},
|
|
{"func_door", SP_func_door},
|
|
{"func_door_secret", SP_func_door_secret},
|
|
{"func_door_rotating", SP_func_door_rotating},
|
|
{"func_rotating", SP_func_rotating},
|
|
{"func_train", SP_func_train},
|
|
{"func_water", SP_func_water},
|
|
{"func_bobbingwater", SP_func_bobbingwater},
|
|
{"func_conveyor", SP_func_conveyor},
|
|
{"func_areaportal", SP_func_areaportal},
|
|
{"func_clock", SP_func_clock},
|
|
{"func_reflect", SP_func_reflect},
|
|
{"func_wall", SP_func_wall},
|
|
{"func_object", SP_func_object},
|
|
{"func_timer", SP_func_timer},
|
|
{"func_explosive", SP_func_explosive},
|
|
{"func_killbox", SP_func_killbox},
|
|
|
|
// RAFAEL
|
|
{"func_object_repair", SP_object_repair},
|
|
{"rotating_light", SP_rotating_light},
|
|
|
|
{"trigger_always", SP_trigger_always},
|
|
{"trigger_once", SP_trigger_once},
|
|
{"trigger_multiple", SP_trigger_multiple},
|
|
{"trigger_bbox", SP_trigger_bbox},
|
|
{"trigger_relay", SP_trigger_relay},
|
|
{"trigger_push", SP_trigger_push},
|
|
{"trigger_push_bbox", SP_trigger_push_bbox},
|
|
{"trigger_hurt", SP_trigger_hurt},
|
|
{"trigger_hurt_bbox", SP_trigger_hurt_bbox},
|
|
{"trigger_key", SP_trigger_key},
|
|
{"trigger_counter", SP_trigger_counter},
|
|
{"trigger_elevator", SP_trigger_elevator},
|
|
{"trigger_gravity", SP_trigger_gravity},
|
|
{"trigger_gravity_bbox", SP_trigger_gravity_bbox},
|
|
{"trigger_monsterjump", SP_trigger_monsterjump},
|
|
{"trigger_monsterjump_bbox", SP_trigger_monsterjump_bbox},
|
|
|
|
{"target_temp_entity", SP_target_temp_entity},
|
|
{"target_speaker", SP_target_speaker},
|
|
{"target_explosion", SP_target_explosion},
|
|
{"target_changelevel", SP_target_changelevel},
|
|
{"target_secret", SP_target_secret},
|
|
{"target_goal", SP_target_goal},
|
|
{"target_splash", SP_target_splash},
|
|
{"target_spawner", SP_target_spawner},
|
|
{"target_blaster", SP_target_blaster},
|
|
{"target_crosslevel_trigger", SP_target_crosslevel_trigger},
|
|
{"target_crosslevel_target", SP_target_crosslevel_target},
|
|
{"target_laser", SP_target_laser},
|
|
{"target_help", SP_target_help},
|
|
{"target_actor", SP_target_actor},
|
|
{"target_lightramp", SP_target_lightramp},
|
|
{"target_earthquake", SP_target_earthquake},
|
|
{"target_character", SP_target_character},
|
|
{"target_string", SP_target_string},
|
|
//Knightmare
|
|
{"target_monitor", SP_target_monitor},
|
|
{"target_monsterbattle", SP_target_monsterbattle},
|
|
{"target_movewith", SP_target_movewith},
|
|
{"target_change", SP_target_change},
|
|
{"target_rotation", SP_target_rotation},
|
|
{"target_attractor", SP_target_attractor},
|
|
{"target_cd", SP_target_cd},
|
|
{"target_skill", SP_target_skill},
|
|
{"target_sky", SP_target_sky},
|
|
{"target_playback", SP_target_playback},
|
|
{"target_rocks", SP_target_rocks},
|
|
{"target_bmodel_spawner", SP_target_clone},
|
|
{"target_clone", SP_target_clone},
|
|
{"target_text", SP_target_text},
|
|
{"thing", SP_thing},
|
|
|
|
// RAFAEL 15-APR-98
|
|
{"target_mal_laser", SP_target_mal_laser},
|
|
|
|
{"worldspawn", SP_worldspawn},
|
|
{"viewthing", SP_viewthing},
|
|
|
|
{"light", SP_light},
|
|
{"light_mine1", SP_light_mine1},
|
|
{"light_mine2", SP_light_mine2},
|
|
{"info_null", SP_info_null},
|
|
{"func_group", SP_info_null},
|
|
{"info_notnull", SP_info_notnull},
|
|
{"path_corner", SP_path_corner},
|
|
{"point_combat", SP_point_combat},
|
|
|
|
{"misc_explobox", SP_misc_explobox},
|
|
{"misc_banner", SP_misc_banner},
|
|
{"misc_satellite_dish", SP_misc_satellite_dish},
|
|
{"misc_actor", SP_misc_actor},
|
|
{"misc_gib_arm", SP_misc_gib_arm},
|
|
{"misc_gib_leg", SP_misc_gib_leg},
|
|
{"misc_gib_head", SP_misc_gib_head},
|
|
{"misc_insane", SP_misc_insane},
|
|
{"misc_deadsoldier", SP_misc_deadsoldier},
|
|
{"misc_viper", SP_misc_viper},
|
|
{"misc_viper_bomb", SP_misc_viper_bomb},
|
|
{"misc_bigviper", SP_misc_bigviper},
|
|
{"misc_strogg_ship", SP_misc_strogg_ship},
|
|
{"misc_teleporter", SP_misc_teleporter},
|
|
{"misc_teleporter_dest", SP_misc_teleporter_dest},
|
|
{"misc_blackhole", SP_misc_blackhole},
|
|
{"misc_eastertank", SP_misc_eastertank},
|
|
{"misc_easterchick", SP_misc_easterchick},
|
|
{"misc_easterchick2", SP_misc_easterchick2},
|
|
// Knightmare- patients for the infirmary
|
|
{"misc_sick_guard", SP_misc_sick_guard},
|
|
// Knightmare- experiment gekks
|
|
{"misc_gekk_writhe", SP_misc_gekk_writhe},
|
|
|
|
// Knightmare- Coconut Monkey 3 Flame entities
|
|
{"light_flame1", SP_light_flame1},
|
|
{"light_flame1s", SP_light_flame1s},
|
|
{"light_flame2", SP_light_flame2},
|
|
{"light_flame2s", SP_light_flame2s},
|
|
//Knightmare- Coconut Monkey
|
|
{"monster_coco_monkey", SP_monster_coco_monkey},
|
|
|
|
// RAFAEL
|
|
{"misc_crashviper", SP_misc_crashviper},
|
|
{"misc_viper_missile", SP_misc_viper_missile},
|
|
{"misc_amb4", SP_misc_amb4},
|
|
// RAFAEL 17-APR-98
|
|
{"misc_transport", SP_misc_transport},
|
|
// END 17-APR-98
|
|
// RAFAEL 12-MAY-98
|
|
{"misc_nuke", SP_misc_nuke},
|
|
|
|
{"monster_berserk", SP_monster_berserk},
|
|
{"monster_gladiator", SP_monster_gladiator},
|
|
{"monster_gunner", SP_monster_gunner},
|
|
{"monster_infantry", SP_monster_infantry},
|
|
{"monster_soldier_light", SP_monster_soldier_light},
|
|
{"monster_soldier", SP_monster_soldier},
|
|
{"monster_soldier_ss", SP_monster_soldier_ss},
|
|
{"monster_tank", SP_monster_tank},
|
|
{"monster_tank_commander", SP_monster_tank},
|
|
{"monster_medic", SP_monster_medic},
|
|
{"monster_flipper", SP_monster_flipper},
|
|
{"monster_chick", SP_monster_chick},
|
|
{"monster_parasite", SP_monster_parasite},
|
|
{"monster_flyer", SP_monster_flyer},
|
|
{"monster_brain", SP_monster_brain},
|
|
{"monster_brain_beta", SP_monster_brain_beta},
|
|
{"monster_floater", SP_monster_floater},
|
|
{"monster_hover", SP_monster_hover},
|
|
{"monster_mutant", SP_monster_mutant},
|
|
{"monster_supertank", SP_monster_supertank},
|
|
{"monster_boss2", SP_monster_boss2},
|
|
{"monster_boss3_stand", SP_monster_boss3_stand},
|
|
{"monster_jorg", SP_monster_jorg},
|
|
//Knightmare- added spawn function for monster_makron
|
|
{"monster_makron", SP_monster_makron},
|
|
|
|
{"monster_commander_body", SP_monster_commander_body},
|
|
|
|
// RAFAEL 14-APR-98
|
|
{"monster_soldier_hypergun", SP_monster_soldier_hypergun},
|
|
{"monster_soldier_lasergun", SP_monster_soldier_lasergun},
|
|
{"monster_soldier_ripper", SP_monster_soldier_ripper},
|
|
{"monster_fixbot", SP_monster_fixbot},
|
|
{"monster_gekk", SP_monster_gekk},
|
|
{"monster_chick_heat", SP_monster_chick_heat},
|
|
{"monster_gladb", SP_monster_gladb},
|
|
{"monster_boss5", SP_monster_boss5},
|
|
// END 14-APR-98
|
|
// RAFAEL 12-MAY-98
|
|
|
|
// Rogue monsters
|
|
{"monster_daedalus", SP_monster_hover},
|
|
{"monster_medic_commander", SP_monster_medic},
|
|
{"monster_stalker", SP_monster_stalker},
|
|
{"monster_turret", SP_monster_turret},
|
|
{"monster_carrier", SP_monster_carrier},
|
|
{"monster_kamikaze", SP_monster_kamikaze},
|
|
{"monster_widow", SP_monster_widow},
|
|
{"monster_widow2", SP_monster_widow2},
|
|
|
|
// Knightmare- LM Escape soldiers
|
|
{"monster_soldier_plasma_re", SP_monster_soldier_plasma_re},
|
|
{"monster_soldier_plasma_sp", SP_monster_soldier_plasma_sp},
|
|
|
|
// Zaero
|
|
{"monster_autocannon", SP_monster_autocannon},
|
|
{"monster_autocannon_floor", SP_monster_autocannon_floor},
|
|
{"monster_hound", SP_monster_hound},
|
|
{"monster_handler", SP_monster_handler},
|
|
{"monster_sentien", SP_monster_sentien},
|
|
{"monster_zboss", SP_monster_zboss},
|
|
{"target_zboss_target", SP_target_zboss_target},
|
|
{"func_barrier", SP_func_barrier},
|
|
{"trigger_laser", SP_trigger_laser},
|
|
{"misc_securitycamera", SP_misc_securitycamera},
|
|
{"misc_commdish", SP_misc_commdish},
|
|
{"misc_crate", SP_misc_crate},
|
|
{"misc_crate_medium", SP_misc_crate_medium},
|
|
{"misc_crate_small", SP_misc_crate_small},
|
|
{"misc_seat", SP_misc_seat},
|
|
// end Zaero
|
|
|
|
// Knightmare- added Tactician Gunner
|
|
{"monster_gunner_tactician", SP_monster_gunner},
|
|
|
|
// Knightmare- the dog from Coconut Monkey 3
|
|
{"monster_dog", SP_monster_dog},
|
|
// Knightmare- the vulture from Coconut Monkey 2
|
|
{"monster_vulture", SP_monster_vulture},
|
|
|
|
{"misc_nuke", SP_misc_nuke},
|
|
|
|
{"turret_breach", SP_turret_breach},
|
|
{"turret_base", SP_turret_base},
|
|
{"turret_driver", SP_turret_driver},
|
|
|
|
//==============
|
|
//ROGUE
|
|
{"func_plat2", SP_func_plat2},
|
|
{"func_door_secret2", SP_func_door_secret2},
|
|
{"func_force_wall", SP_func_force_wall},
|
|
{"func_monitor", SP_func_monitor},
|
|
{"func_pendulum", SP_func_pendulum},
|
|
{"func_pivot", SP_func_pivot},
|
|
{"func_pushable", SP_func_pushable},
|
|
{"func_rotating_dh", SP_func_rotating_dh},
|
|
{"func_door_rot_dh", SP_func_door_rot_dh},
|
|
{"func_door_swinging", SP_func_door_swinging},
|
|
{"func_trackchange", SP_func_trackchange},
|
|
{"func_tracktrain", SP_func_tracktrain},
|
|
{"path_track", SP_path_track},
|
|
{"info_train_start", SP_info_train_start},
|
|
{"func_trainbutton", SP_func_trainbutton},
|
|
{"func_vehicle", SP_func_vehicle},
|
|
//Knightmare
|
|
{"func_breakaway", SP_func_breakaway},
|
|
// Lazarus
|
|
{"crane_beam", SP_crane_beam},
|
|
{"crane_hoist", SP_crane_hoist},
|
|
{"crane_hook", SP_crane_hook},
|
|
{"crane_control",SP_crane_control},
|
|
{"crane_reset",SP_crane_reset},
|
|
{"trigger_teleport", SP_trigger_teleport},
|
|
{"trigger_teleporter", SP_trigger_teleporter},
|
|
{"trigger_teleporter_bbox", SP_trigger_teleporter_bbox},
|
|
{"trigger_disguise", SP_trigger_disguise},
|
|
{"trigger_inside", SP_trigger_inside},
|
|
{"trigger_inside_bbox", SP_trigger_inside_bbox},
|
|
{"trigger_mass", SP_trigger_mass},
|
|
{"trigger_mass_bbox", SP_trigger_mass_bbox},
|
|
{"trigger_scales", SP_trigger_scales},
|
|
{"trigger_scales_bbox", SP_trigger_scales_bbox},
|
|
{"trigger_look", SP_trigger_look},
|
|
{"trigger_speaker", SP_trigger_speaker},
|
|
{"trigger_switch", SP_trigger_switch},
|
|
{"info_teleport_destination", SP_info_teleport_destination},
|
|
{"info_player_coop_lava", SP_info_player_coop_lava},
|
|
{"target_steam", SP_target_steam},
|
|
{"target_anger", SP_target_anger},
|
|
// {"target_spawn", SP_target_spawn},
|
|
{"target_killplayers", SP_target_killplayers},
|
|
// PMM - experiment
|
|
{"target_blacklight", SP_target_blacklight},
|
|
{"target_orb", SP_target_orb},
|
|
// pmm
|
|
{"hint_path", SP_hint_path},
|
|
{"dm_tag_token", SP_dm_tag_token},
|
|
{"dm_dball_goal", SP_dm_dball_goal},
|
|
{"dm_dball_ball", SP_dm_dball_ball},
|
|
{"dm_dball_team1_start", SP_dm_dball_team1_start},
|
|
{"dm_dball_team2_start", SP_dm_dball_team2_start},
|
|
{"dm_dball_ball_start", SP_dm_dball_ball_start},
|
|
{"dm_dball_speed_change", SP_dm_dball_speed_change},
|
|
// {"monster_chick2", SP_monster_chick2},
|
|
{"turret_invisible_brain", SP_turret_invisible_brain},
|
|
{"misc_nuke_core", SP_misc_nuke_core},
|
|
//ROGUE
|
|
//==============
|
|
|
|
{"target_command", SP_target_command},
|
|
{"target_effect", SP_target_effect},
|
|
{"target_set_effect", SP_target_set_effect},
|
|
{"target_fade", SP_target_fade},
|
|
{"target_failure", SP_target_failure},
|
|
{"target_fog", SP_target_fog},
|
|
{"trigger_fog", SP_trigger_fog},
|
|
{"trigger_fog_bbox", SP_trigger_fog_bbox},
|
|
{"target_precipitation", SP_target_precipitation},
|
|
{"target_fountain", SP_target_fountain},
|
|
{"target_lightswitch", SP_target_lightswitch},
|
|
{"target_locator", SP_target_locator},
|
|
{"target_lock", SP_target_lock},
|
|
{"target_lock_clue", SP_target_lock_clue},
|
|
{"target_lock_code", SP_target_lock_code},
|
|
{"target_lock_digit", SP_target_lock_digit},
|
|
// {"target_ignore_player", SP_target_ignore_player},
|
|
{"target_global_text", SP_target_global_text},
|
|
{"light_torch", SP_light_torch},
|
|
{"light_flame", SP_light_flame},
|
|
{"model_spawn", SP_model_spawn},
|
|
{"model_train", SP_model_train},
|
|
{"model_turret", SP_model_turret},
|
|
{"func_dm_wall", SP_func_dm_wall},
|
|
{"trigger_transition", SP_trigger_transition},
|
|
{"trigger_transition_bbox", SP_trigger_transition_bbox},
|
|
|
|
// Knightmare- entities that use origin-based train pathing
|
|
{"func_train_origin", SP_func_train_origin},
|
|
{"model_train_origin", SP_model_train_origin},
|
|
{"misc_viper_origin", SP_misc_viper_origin},
|
|
{"misc_crashviper_origin", SP_misc_crashviper_origin},
|
|
{"misc_strogg_ship_origin", SP_misc_strogg_ship_origin},
|
|
{"misc_transport_origin", SP_misc_transport_origin},
|
|
|
|
// Knightmare- Q1 monsters/entities
|
|
// Generations spawn names
|
|
// {"q1_monster_chton", SP_monster_q1_chthon},
|
|
{"q1_monster_dog", SP_monster_q1_dog},
|
|
{"q1_monster_enforcer", SP_monster_q1_enforcer},
|
|
{"q1_monster_fiend", SP_monster_q1_fiend},
|
|
{"q1_monster_soldier", SP_monster_q1_grunt},
|
|
{"q1_monster_hknight", SP_monster_q1_hknight},
|
|
{"q1_monster_knight", SP_monster_q1_knight},
|
|
{"q1_monster_ogre", SP_monster_q1_ogre},
|
|
{"q1_monster_fish", SP_monster_q1_rotfish},
|
|
{"q1_monster_scrag", SP_monster_q1_scrag},
|
|
{"q1_monster_shambler", SP_monster_q1_shambler},
|
|
{"q1_monster_shalrath", SP_monster_q1_shalrath},
|
|
{"q1_monster_tarbaby", SP_monster_q1_tarbaby},
|
|
{"q1_monster_zombie", SP_monster_q1_zombie},
|
|
{"q1_monster_freddie", SP_monster_q1_freddie},
|
|
|
|
// Q2Infighter spawn names
|
|
// {"monster_q1_chthon", SP_monster_q1_chthon},
|
|
{"monster_q1_dog", SP_monster_q1_dog},
|
|
{"monster_q1_enforcer", SP_monster_q1_enforcer},
|
|
{"monster_q1_demon", SP_monster_q1_fiend},
|
|
{"monster_q1_army", SP_monster_q1_grunt},
|
|
{"monster_q1_hknight", SP_monster_q1_hknight},
|
|
{"monster_q1_knight", SP_monster_q1_knight},
|
|
{"monster_q1_ogre", SP_monster_q1_ogre},
|
|
{"monster_q1_fish", SP_monster_q1_rotfish},
|
|
{"monster_q1_wizard", SP_monster_q1_scrag},
|
|
{"monster_q1_shambler", SP_monster_q1_shambler},
|
|
{"monster_q1_shalrath", SP_monster_q1_shalrath},
|
|
{"monster_q1_tarbaby", SP_monster_q1_tarbaby},
|
|
{"monster_q1_zombie", SP_monster_q1_zombie},
|
|
{"monster_q1_freddie", SP_monster_q1_freddie},
|
|
|
|
// misc Q1 entities
|
|
{"misc_q1_zombie_crucified", SP_misc_q1_zombie_crucified},
|
|
{"misc_q1_air_bubbles", SP_misc_q1_air_bubbles},
|
|
{"misc_q1_large_flame", SP_misc_q1_large_flame},
|
|
{"misc_q1_small_flame", SP_misc_q1_small_flame},
|
|
{"misc_q1_torch", SP_misc_q1_torch},
|
|
{"target_q1_trap", SP_target_q1_trap},
|
|
{"misc_q1_light_globe", SP_misc_q1_globe},
|
|
{"misc_q1_explobox", SP_misc_q1_explobox},
|
|
{"misc_q1_fireball",SP_misc_q1_fireball},
|
|
// end Knightmare
|
|
|
|
// transition entities
|
|
{"bolt", SP_bolt},
|
|
{"bolt2", SP_bolt2},
|
|
{"gekk_loogie", SP_gekk_loogie},
|
|
{"flechette", SP_flechette},
|
|
{"tracker", SP_tracker},
|
|
{"ion", SP_ion},
|
|
{"phalanx_plasma", SP_phalanx_plasma},
|
|
{"debris", SP_debris},
|
|
{"gib", SP_gib},
|
|
{"gibhead", SP_gibhead},
|
|
{"grenade", SP_grenade},
|
|
{"hgrenade", SP_handgrenade},
|
|
{"shocksphere", SP_shocksphere},
|
|
{"prox", SP_prox},
|
|
{"tesla", SP_tesla},
|
|
{"trap", SP_trap},
|
|
{"rocket", SP_rocket},
|
|
{"homing rocket", SP_rocket},
|
|
{"missile", SP_missile},
|
|
{"homing rocket", SP_missile},
|
|
{"goop", SP_goop}, // SKWiD MOD
|
|
// end Lazarus
|
|
|
|
{NULL, NULL}
|
|
};
|
|
|
|
// Knightmare- global pointer for the entity alias script
|
|
// The file should be loaded into memory, because we can't
|
|
// re-open and read it for every entity we parse
|
|
char *alias_data;
|
|
int alias_data_size;
|
|
#ifndef KMQUAKE2_ENGINE_MOD
|
|
qboolean alias_from_pak;
|
|
#endif
|
|
|
|
/*
|
|
===============
|
|
ED_CallSpawn
|
|
|
|
Finds the spawn function for the entity and calls it
|
|
===============
|
|
*/
|
|
void ED_CallSpawn (edict_t *ent)
|
|
{
|
|
spawn_t *s;
|
|
gitem_t *item;
|
|
int i;
|
|
cvar_t *gamedir;
|
|
|
|
if (!ent->classname)
|
|
{
|
|
gi.dprintf ("ED_CallSpawn: NULL classname\n");
|
|
return;
|
|
}
|
|
//PGM - do this before calling the spawn function so it can be overridden.
|
|
#ifdef ROGUE_GRAVITY
|
|
ent->gravityVector[0] = 0.0;
|
|
ent->gravityVector[1] = 0.0;
|
|
ent->gravityVector[2] = -1.0;
|
|
#endif
|
|
//PGM
|
|
|
|
// FIXME - PMM classnames hack
|
|
if (!strcmp(ent->classname, "weapon_nailgun"))
|
|
ent->classname = (FindItem("ETF Rifle"))->classname;
|
|
if (!strcmp(ent->classname, "ammo_nails"))
|
|
ent->classname = (FindItem("Flechettes"))->classname;
|
|
if (!strcmp(ent->classname, "weapon_heatbeam"))
|
|
ent->classname = (FindItem("Plasma Beam"))->classname;
|
|
// PMM
|
|
|
|
// replace brains in Reckoning
|
|
gamedir = gi.cvar("game", "", 0);
|
|
if (gamedir->string && !Q_stricmp(gamedir->string, "xatrix")
|
|
&& (level.maptype == MAPTYPE_XATRIX) && !strcmp(ent->classname, "monster_brain"))
|
|
ent->classname = "monster_brain_beta";
|
|
|
|
// Knightmare- mission pack monster replacement
|
|
if (mp_monster_replace->value)
|
|
{ // gladiator
|
|
if (!strcmp(ent->classname, "monster_gladiator"))
|
|
{
|
|
ent->classname = "monster_gladb";
|
|
if (st.item && mp_monster_ammo_replace->value)
|
|
if (!strcmp(st.item, "ammo_slugs")) //replace ammo
|
|
{
|
|
ent->item = FindItemByClassname ("ammo_magslug");
|
|
st.item = NULL;
|
|
}
|
|
}
|
|
// brain
|
|
if (!strcmp(ent->classname, "monster_brain"))
|
|
ent->classname = "monster_brain_beta";
|
|
// soldiers
|
|
if (!strcmp(ent->classname, "monster_soldier_light"))
|
|
{
|
|
ent->classname = "monster_soldier_ripper";
|
|
if (st.item && mp_monster_ammo_replace->value)
|
|
if ( !strcmp(st.item, "ammo_shells") || !strcmp(st.item, "ammo_bullets"))
|
|
{
|
|
ent->item = FindItemByClassname ("ammo_cells");
|
|
st.item = NULL;
|
|
}
|
|
}
|
|
if (!strcmp(ent->classname, "monster_soldier"))
|
|
{
|
|
ent->classname = "monster_soldier_hypergun";
|
|
if (st.item && mp_monster_ammo_replace->value)
|
|
if ( !strcmp(st.item, "ammo_shells") || !strcmp(st.item, "ammo_bullets"))
|
|
{
|
|
ent->item = FindItemByClassname ("ammo_cells");
|
|
st.item = NULL;
|
|
}
|
|
}
|
|
if (!strcmp(ent->classname, "monster_soldier_ss"))
|
|
{
|
|
ent->classname = "monster_soldier_lasergun";
|
|
if (st.item && mp_monster_ammo_replace->value)
|
|
if ( !strcmp(st.item, "ammo_shells") || !strcmp(st.item, "ammo_bullets"))
|
|
{
|
|
ent->item = FindItemByClassname ("ammo_cells");
|
|
st.item = NULL;
|
|
}
|
|
}
|
|
// icarus
|
|
if (!strcmp(ent->classname, "monster_hover"))
|
|
ent->classname = "monster_daedalus";
|
|
// supertank
|
|
if (!strcmp(ent->classname, "monster_supertank"))
|
|
ent->classname = "monster_boss5";
|
|
// chick
|
|
if (!strcmp(ent->classname, "monster_chick"))
|
|
ent->classname = "monster_chick_heat";
|
|
// medic
|
|
if (!strcmp(ent->classname, "monster_medic")
|
|
// don't spawn another medic commander from medic commander
|
|
&& !(ent->monsterinfo.monsterflags & MFL_DO_NOT_COUNT))
|
|
ent->classname = "monster_medic_commander";
|
|
// gunner
|
|
if ( !strcmp(ent->classname, "monster_gunner") ) {
|
|
if (random() < ((skill->value + 1.0f) * 0.15f))
|
|
ent->classname = "monster_gunner_tactician";
|
|
else
|
|
ent->spawnflags |= SF_MONSTER_SPECIAL;
|
|
}
|
|
}
|
|
|
|
// LM Escape monster replacement
|
|
/* if (!strcmp(ent->classname, "monster_soldier_plasma_re"))
|
|
ent->classname = "monster_soldier_ripper";
|
|
if (!strcmp(ent->classname, "monster_soldier_plasma_sp"))
|
|
ent->classname = "monster_soldier_hypergun";
|
|
// LM Escape Plasma gun
|
|
if (!strcmp(ent->classname, "weapon_plasma"))
|
|
ent->classname = "weapon_boomer";
|
|
*/
|
|
// Zaero item replacement
|
|
if (!strcmp(ent->classname, "weapon_sniperrifle"))
|
|
ent->classname = "weapon_railgun";
|
|
if (!strcmp(ent->classname, "weapon_soniccannon"))
|
|
ent->classname = "weapon_plasmabeam";
|
|
if (!strcmp(ent->classname, "ammo_a2k"))
|
|
ent->classname = "ammo_nbomb";
|
|
|
|
// Knightmare- replace Pierre in Coconut Monkey 3 with Daedalus
|
|
if (!strcmp(ent->classname, "monster_pierre_monkey"))
|
|
{
|
|
ent->classname = "monster_daedalus";
|
|
ent->s.origin[2] += 8;
|
|
ent->dmg = 4;
|
|
ent->health = 1200;
|
|
ent->powerarmor = 500;
|
|
}
|
|
|
|
// Knightmare- backup entity's original angles
|
|
VectorCopy (ent->s.angles, ent->org_angles);
|
|
|
|
// check item spawn functions
|
|
for (i=0, item=itemlist; i < game.num_items; i++, item++)
|
|
{
|
|
if (!item->classname)
|
|
continue;
|
|
if (!strcmp(item->classname, ent->classname))
|
|
{ // found it
|
|
SpawnItem (ent, item);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// check normal spawn functions
|
|
for (s=spawns; s->name; s++)
|
|
{
|
|
if (!strcmp(s->name, ent->classname))
|
|
{ // found it
|
|
s->spawn (ent);
|
|
return;
|
|
}
|
|
}
|
|
gi.dprintf ("%s doesn't have a spawn function\n", ent->classname);
|
|
}
|
|
|
|
void ReInitialize_Entity (edict_t *ent)
|
|
{
|
|
spawn_t *s;
|
|
|
|
// check normal spawn functions
|
|
for (s=spawns; s->name; s++)
|
|
{
|
|
if (!strcmp(s->name, ent->classname))
|
|
{ // found it
|
|
s->spawn (ent);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
ED_NewString
|
|
=============
|
|
*/
|
|
char *ED_NewString (char *string)
|
|
{
|
|
char *newb, *new_p;
|
|
int i,l;
|
|
|
|
l = (int)strlen(string) + 1;
|
|
|
|
newb = gi.TagMalloc (l, TAG_LEVEL);
|
|
|
|
new_p = newb;
|
|
|
|
for (i=0 ; i< l ; i++)
|
|
{
|
|
if (string[i] == '\\' && i < l-1)
|
|
{
|
|
i++;
|
|
if (string[i] == 'n')
|
|
*new_p++ = '\n';
|
|
else
|
|
*new_p++ = '\\';
|
|
}
|
|
else
|
|
*new_p++ = string[i];
|
|
}
|
|
|
|
return newb;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
===============
|
|
ED_ParseField
|
|
|
|
Takes a key/value pair and sets the binary values
|
|
in an edict
|
|
===============
|
|
*/
|
|
void ED_ParseField (char *key, char *value, edict_t *ent)
|
|
{
|
|
field_t *f;
|
|
byte *b;
|
|
float v;
|
|
vec3_t vec = { 0.0f, 0.0f, 0.0f };
|
|
|
|
for (f=fields ; f->name ; f++)
|
|
{
|
|
if (!(f->flags & FFL_NOSPAWN) && !Q_stricmp(f->name, key))
|
|
{ // found it
|
|
if (f->flags & FFL_SPAWNTEMP)
|
|
b = (byte *)&st;
|
|
else
|
|
b = (byte *)ent;
|
|
|
|
switch (f->type)
|
|
{
|
|
case F_LSTRING:
|
|
*(char **)(b+f->ofs) = ED_NewString (value);
|
|
break;
|
|
case F_VECTOR:
|
|
// sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
|
|
if (sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]) != 3) {
|
|
gi.dprintf ("ED_ParseField: map '%s' has invalid vector '%s' for key '%s'.\n", level.mapname, value, key);
|
|
}
|
|
((float *)(b+f->ofs))[0] = vec[0];
|
|
((float *)(b+f->ofs))[1] = vec[1];
|
|
((float *)(b+f->ofs))[2] = vec[2];
|
|
break;
|
|
case F_INT:
|
|
*(int *)(b+f->ofs) = atoi(value);
|
|
break;
|
|
case F_FLOAT:
|
|
*(float *)(b+f->ofs) = atof(value);
|
|
break;
|
|
case F_ANGLEHACK:
|
|
v = atof(value);
|
|
((float *)(b+f->ofs))[0] = 0;
|
|
((float *)(b+f->ofs))[1] = v;
|
|
((float *)(b+f->ofs))[2] = 0;
|
|
break;
|
|
case F_IGNORE:
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
gi.dprintf ("%s is not a field\n", key);
|
|
}
|
|
|
|
/*
|
|
==============================================================================
|
|
|
|
ALIAS SCRIPT LOADING
|
|
|
|
==============================================================================
|
|
*/
|
|
|
|
|
|
#ifndef KMQUAKE2_ENGINE_MOD
|
|
/*
|
|
====================
|
|
ReadTextFile
|
|
|
|
Called from LoadAliasData to try
|
|
loading script file from disk.
|
|
====================
|
|
*/
|
|
char *ReadTextFile (char *filename, int *size)
|
|
{
|
|
FILE *fp;
|
|
char *filestring = NULL;
|
|
int len;
|
|
|
|
fp = fopen(filename, "r");
|
|
if (!fp)
|
|
return NULL;
|
|
|
|
fseek(fp, 0, SEEK_END);
|
|
len = ftell(fp);
|
|
fseek(fp, 0, SEEK_SET);
|
|
|
|
filestring = gi.TagMalloc(len + 1, TAG_LEVEL);
|
|
if (!filestring)
|
|
{
|
|
fclose(fp);
|
|
return NULL;
|
|
}
|
|
|
|
len = fread(filestring, 1, len, fp);
|
|
*size = len;
|
|
filestring[len] = 0;
|
|
|
|
fclose(fp);
|
|
|
|
return filestring;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
LoadAliasFile
|
|
|
|
Tries to load script file from
|
|
disk, and then from a pak file.
|
|
====================
|
|
*/
|
|
qboolean LoadAliasFile (char *name)
|
|
{
|
|
char aliasfilename[MAX_OSPATH] = "";
|
|
|
|
alias_from_pak = false;
|
|
|
|
GameDirRelativePath (name, aliasfilename, sizeof(aliasfilename));
|
|
alias_data = ReadTextFile(aliasfilename, &alias_data_size);
|
|
|
|
// If file doesn't exist on hard disk, it must be in a pak file
|
|
if (!alias_data)
|
|
{
|
|
cvar_t *basedir, *gamedir;
|
|
char gamepath[256];
|
|
char pakfile[256];
|
|
char textname[128];
|
|
int i, k, num, numitems;
|
|
qboolean in_pak = false;
|
|
FILE *fpak;
|
|
pak_header_t pakheader;
|
|
pak_item_t pakitem;
|
|
|
|
basedir = gi.cvar("basedir", "", 0);
|
|
gamedir = gi.cvar("gamedir", "", 0);
|
|
Com_sprintf(textname, sizeof(textname), name);
|
|
|
|
if (strlen(gamedir->string))
|
|
Com_sprintf(gamepath, sizeof(gamepath), "%s/%s", basedir->string, gamedir->string);
|
|
else
|
|
Com_sprintf(gamepath, sizeof(gamepath), "%s/baseq2", basedir->string);
|
|
|
|
// check all pakfiles in current gamedir
|
|
for (i=0; i<10; i++)
|
|
{
|
|
Com_sprintf(pakfile, sizeof(pakfile), "%s/pak%d.pak", gamepath, i);
|
|
if (NULL != (fpak = fopen(pakfile, "rb")))
|
|
{
|
|
num = fread(&pakheader, 1, sizeof(pak_header_t), fpak);
|
|
if (num >= sizeof(pak_header_t))
|
|
{
|
|
if (pakheader.id[0] == 'P' &&
|
|
pakheader.id[1] == 'A' &&
|
|
pakheader.id[2] == 'C' &&
|
|
pakheader.id[3] == 'K' )
|
|
{
|
|
numitems = pakheader.dsize / sizeof(pak_item_t);
|
|
fseek(fpak, pakheader.dstart, SEEK_SET);
|
|
for (k=0; k<numitems && !in_pak; k++)
|
|
{
|
|
fread(&pakitem, 1, sizeof(pak_item_t), fpak);
|
|
if (!Q_stricmp(pakitem.name,textname))
|
|
{
|
|
in_pak = true;
|
|
fseek(fpak, pakitem.start, SEEK_SET);
|
|
alias_data = gi.TagMalloc(pakitem.size + 1, TAG_LEVEL);
|
|
if (!alias_data) {
|
|
fclose(fpak);
|
|
gi.dprintf("LoadAliasData: Memory allocation failure for entalias.dat\n");
|
|
return false;
|
|
}
|
|
alias_data_size = fread(alias_data, 1, pakitem.size, fpak);
|
|
alias_data[pakitem.size] = 0; // put end marker
|
|
alias_from_pak = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fclose(fpak);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!alias_data)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
#else
|
|
// Gotta have these for extractfuncs...
|
|
char *ReadTextFile (char *filename, int *size)
|
|
{
|
|
return NULL;
|
|
}
|
|
qboolean LoadAliasFile (char *name)
|
|
{
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
====================
|
|
LoadAliasData
|
|
|
|
Loads entity alias file either on disk
|
|
or from a pak file in the game dir.
|
|
====================
|
|
*/
|
|
void LoadAliasData (void)
|
|
{
|
|
#ifdef KMQUAKE2_ENGINE_MOD // use new engine file loading function instead
|
|
// try per-level script file
|
|
alias_data_size = gi.LoadFile(va("ext_data/entalias/%s.alias", level.mapname), (void **)&alias_data);
|
|
if (alias_data_size < 2) // file not found, try global file
|
|
alias_data_size = gi.LoadFile("ext_data/entalias.def", (void **)&alias_data);
|
|
if (alias_data_size < 2) // file still not found, try old filename
|
|
alias_data_size = gi.LoadFile("scripts/entalias.dat", (void **)&alias_data);
|
|
#else
|
|
if (!LoadAliasFile(va("ext_data/entalias/%s.alias", level.mapname)))
|
|
if (!LoadAliasFile("ext_data/entalias.def"))
|
|
LoadAliasFile("scripts/entalias.dat");
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
====================
|
|
ED_ParseEntityAlias
|
|
|
|
Parses an edict, looking for its classname, and then
|
|
looks in the entity alias file for an alias, and
|
|
loads that if found.
|
|
Returns true if an aliws was loaded for the given entity.
|
|
====================
|
|
*/
|
|
qboolean ED_ParseEntityAlias (char *data, edict_t *ent)
|
|
{
|
|
qboolean classname_found, alias_found, alias_loaded;
|
|
char *search_data;
|
|
char *search_token;
|
|
char entclassname[256];
|
|
char keyname[256];
|
|
int braceLevel;
|
|
|
|
classname_found = false;
|
|
alias_found = false;
|
|
alias_loaded = false;
|
|
braceLevel = 0;
|
|
|
|
if (!alias_data) // If no alias file was loaded, don't bother
|
|
return false;
|
|
|
|
search_data = data; // copy entity data postion
|
|
// go through all the dictionary pairs looking for the classname
|
|
while (1)
|
|
{ //parse keyname
|
|
search_token = COM_Parse (&search_data);
|
|
if (!search_data)
|
|
gi.error ("ED_ParseEntityAlias: end of entity data without closing brace");
|
|
if (search_token[0] == '}')
|
|
break;
|
|
if (!strcmp(search_token, "classname"))
|
|
classname_found = true;
|
|
|
|
// parse value
|
|
search_token = COM_Parse (&search_data);
|
|
if (!search_data)
|
|
gi.error ("ED_ParseEntityAlias: end of entity data without closing brace");
|
|
if (search_token[0] == '}')
|
|
gi.error ("ED_ParseEntityAlias: closing brace without entity data");
|
|
// if we've found the classname, exit loop
|
|
if (classname_found) {
|
|
Com_strcpy (entclassname, sizeof(entclassname), search_token);
|
|
break;
|
|
}
|
|
}
|
|
// then search the entalias.def file for that classname
|
|
if (classname_found)
|
|
{
|
|
search_data = alias_data; // copy alias data postion
|
|
while (search_data < (alias_data + alias_data_size))
|
|
{
|
|
search_token = COM_Parse (&search_data);
|
|
if (!search_data)
|
|
return false;
|
|
if (!search_token)
|
|
break;
|
|
// see if we're inside the braces of an alias definition
|
|
if (search_token[0] == '{') braceLevel++;
|
|
else if (search_token[0] == '}') braceLevel--;
|
|
if (braceLevel < 0) {
|
|
gi.dprintf ("ED_ParseEntityAlias: closing brace without matching opening brace\n");
|
|
return false;
|
|
}
|
|
// matching classname must be outside braces
|
|
if (!strcmp(search_token, entclassname) && (braceLevel == 0)) {
|
|
//gi.dprintf ("Alias for %s found in alias script file.\n", search_token);
|
|
alias_found = true;
|
|
break;
|
|
}
|
|
}
|
|
// then if that classname is found, load the fields from that alias
|
|
if (alias_found)
|
|
{ // get the opening curly brace
|
|
search_token = COM_Parse (&search_data);
|
|
if (!search_data) {
|
|
gi.dprintf ("ED_ParseEntityAlias: unexpected EOF\n");
|
|
return false;
|
|
}
|
|
if (search_token[0] != '{') {
|
|
gi.dprintf ("ED_ParseEntityAlias: found %s when expecting {\n", search_token);
|
|
return false;
|
|
}
|
|
// go through all the dictionary pairs
|
|
while (search_data < (alias_data + alias_data_size))
|
|
{
|
|
// parse key
|
|
search_token = COM_Parse (&search_data);
|
|
if (!search_data) {
|
|
gi.dprintf ("ED_ParseEntityAlias: EOF without closing brace\n");
|
|
return false;
|
|
}
|
|
if (search_token[0] == '}')
|
|
break;
|
|
Com_strcpy (keyname, sizeof(keyname), search_token);
|
|
|
|
// parse value
|
|
search_token = COM_Parse (&search_data);
|
|
if (!search_data) {
|
|
gi.dprintf ("ED_ParseEntityAlias: EOF without closing brace\n");
|
|
return false;
|
|
}
|
|
if (search_token[0] == '}') {
|
|
gi.dprintf ("ED_ParseEntityAlias: closing brace without data\n");
|
|
return false;
|
|
}
|
|
ED_ParseField (keyname, search_token, ent);
|
|
alias_loaded = true;
|
|
}
|
|
}
|
|
}
|
|
return alias_loaded;
|
|
}
|
|
|
|
/*
|
|
==============================================================================
|
|
END ALIAS SCRIPT LOADING
|
|
==============================================================================
|
|
*/
|
|
|
|
/*
|
|
====================
|
|
ED_ParseEdict
|
|
|
|
Parses an edict out of the given string, returning the new position
|
|
ed should be a properly initialized empty edict.
|
|
====================
|
|
*/
|
|
char *ED_ParseEdict (char *data, edict_t *ent)
|
|
{
|
|
qboolean init;
|
|
char keyname[256];
|
|
char *com_token;
|
|
// Knightmare added
|
|
qboolean alias_loaded = false;
|
|
|
|
init = false;
|
|
memset (&st, 0, sizeof(st));
|
|
|
|
// Knightmare- look for and load an alias for this ent
|
|
alias_loaded = ED_ParseEntityAlias (data, ent);
|
|
|
|
// go through all the dictionary pairs
|
|
while (1)
|
|
{
|
|
// parse key
|
|
com_token = COM_Parse (&data);
|
|
if (com_token[0] == '}')
|
|
break;
|
|
if (!data)
|
|
gi.error ("ED_ParseEntity: EOF without closing brace");
|
|
|
|
Com_strcpy (keyname, sizeof(keyname), com_token);
|
|
|
|
// parse value
|
|
com_token = COM_Parse (&data);
|
|
if (!data)
|
|
gi.error ("ED_ParseEntity: EOF without closing brace");
|
|
|
|
if (com_token[0] == '}')
|
|
gi.error ("ED_ParseEntity: closing brace without data");
|
|
|
|
init = true;
|
|
|
|
// keynames with a leading underscore are used for utility comments,
|
|
// and are immediately discarded by quake
|
|
if (keyname[0] == '_')
|
|
continue;
|
|
|
|
// Knightmare- if the classname was replaced by an alias, don't load it back
|
|
if (alias_loaded && !strcmp(keyname, "classname"))
|
|
continue;
|
|
|
|
ED_ParseField (keyname, com_token, ent);
|
|
}
|
|
|
|
if (!init)
|
|
memset (ent, 0, sizeof(*ent));
|
|
|
|
return data;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
G_FindTeams
|
|
|
|
Chain together all entities with a matching team field.
|
|
|
|
All but the first will have the FL_TEAMSLAVE flag set.
|
|
All but the last will have the teamchain field set to the next one
|
|
================
|
|
*/
|
|
void G_FixTeams (void)
|
|
{
|
|
edict_t *e, *e2, *chain;
|
|
int i, j;
|
|
int c, c2;
|
|
|
|
c = 0;
|
|
c2 = 0;
|
|
for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++)
|
|
{
|
|
if (!e->inuse)
|
|
continue;
|
|
if (!e->team)
|
|
continue;
|
|
//Lazarus- ignore bmodel spawner (its team isn't used)
|
|
if (e->classname && !Q_stricmp(e->classname,"target_bmodel_spawner"))
|
|
continue;
|
|
if (!strcmp(e->classname, "func_train"))
|
|
{
|
|
if (e->flags & FL_TEAMSLAVE)
|
|
{
|
|
chain = e;
|
|
e->teammaster = e;
|
|
e->teamchain = NULL;
|
|
e->flags &= ~FL_TEAMSLAVE;
|
|
c++;
|
|
c2++;
|
|
for (j=1, e2=g_edicts+j ; j < globals.num_edicts ; j++,e2++)
|
|
{
|
|
if (e2 == e)
|
|
continue;
|
|
if (!e2->inuse)
|
|
continue;
|
|
if (!e2->team)
|
|
continue;
|
|
if (!strcmp(e->team, e2->team))
|
|
{
|
|
c2++;
|
|
chain->teamchain = e2;
|
|
e2->teammaster = e;
|
|
e2->teamchain = NULL;
|
|
chain = e2;
|
|
e2->flags |= FL_TEAMSLAVE;
|
|
e2->movetype = MOVETYPE_PUSH;
|
|
e2->speed = e->speed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
gi.dprintf ("%i teams repaired\n", c);
|
|
}
|
|
|
|
void G_FindTeams (void)
|
|
{
|
|
edict_t *e, *e2, *chain;
|
|
int i, j;
|
|
int c, c2;
|
|
|
|
c = 0;
|
|
c2 = 0;
|
|
for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++)
|
|
{
|
|
if (!e->inuse)
|
|
continue;
|
|
if (!e->team)
|
|
continue;
|
|
if (e->flags & FL_TEAMSLAVE)
|
|
continue;
|
|
chain = e;
|
|
e->teammaster = e;
|
|
c++;
|
|
c2++;
|
|
for (j=i+1, e2=e+1 ; j < globals.num_edicts ; j++,e2++)
|
|
{
|
|
if (!e2->inuse)
|
|
continue;
|
|
if (!e2->team)
|
|
continue;
|
|
if (e2->flags & FL_TEAMSLAVE)
|
|
continue;
|
|
if (!strcmp(e->team, e2->team))
|
|
{
|
|
c2++;
|
|
chain->teamchain = e2;
|
|
e2->teammaster = e;
|
|
chain = e2;
|
|
e2->flags |= FL_TEAMSLAVE;
|
|
}
|
|
}
|
|
}
|
|
|
|
G_FixTeams();
|
|
|
|
gi.dprintf ("%i teams with %i entities\n", c, c2);
|
|
}
|
|
|
|
void trans_ent_filename (char *filename, size_t filenameSize);
|
|
void ReadEdict (FILE *f, edict_t *ent);
|
|
void LoadTransitionEnts (void)
|
|
{
|
|
if (developer->value)
|
|
gi.dprintf("==== LoadTransitionEnts ====\n");
|
|
if (game.transition_ents)
|
|
{
|
|
char t_file[MAX_OSPATH];
|
|
int i, j;
|
|
FILE *f;
|
|
vec3_t v_spawn;
|
|
edict_t *ent;
|
|
edict_t *spawn;
|
|
|
|
VectorClear(v_spawn);
|
|
if (strlen(game.spawnpoint))
|
|
{
|
|
spawn = G_Find(NULL,FOFS(targetname), game.spawnpoint);
|
|
while (spawn)
|
|
{
|
|
if (!Q_stricmp(spawn->classname, "info_player_start"))
|
|
{
|
|
VectorCopy(spawn->s.origin,v_spawn);
|
|
break;
|
|
}
|
|
spawn = G_Find(spawn,FOFS(targetname),game.spawnpoint);
|
|
}
|
|
}
|
|
trans_ent_filename (t_file, sizeof(t_file));
|
|
f = fopen(t_file,"rb");
|
|
if (!f)
|
|
gi.error("LoadTransitionEnts: Cannot open %s\n", t_file);
|
|
else
|
|
{
|
|
for (i=0; i<game.transition_ents; i++)
|
|
{
|
|
ent = G_Spawn();
|
|
ReadEdict(f,ent);
|
|
// Correction for monsters with health EXACTLY 0
|
|
// If we don't do this, spawn function will bring
|
|
// 'em back to life
|
|
if (ent->svflags & SVF_MONSTER)
|
|
{
|
|
if (!ent->health)
|
|
{
|
|
ent->health = -1;
|
|
ent->deadflag = DEAD_DEAD;
|
|
}
|
|
else if (ent->deadflag == DEAD_DEAD)
|
|
{
|
|
ent->health = min(ent->health,-1);
|
|
}
|
|
}
|
|
VectorAdd(ent->s.origin,v_spawn,ent->s.origin);
|
|
VectorCopy(ent->s.origin,ent->s.old_origin);
|
|
ED_CallSpawn (ent);
|
|
if (ent->owner_id)
|
|
{
|
|
if (ent->owner_id < 0)
|
|
{
|
|
ent->owner = &g_edicts[-ent->owner_id];
|
|
}
|
|
else
|
|
{
|
|
// We KNOW owners precede owned ents in the
|
|
// list because of the way it was constructed
|
|
ent->owner = NULL;
|
|
for (j=game.maxclients+1; j<globals.num_edicts && !ent->owner; j++)
|
|
{
|
|
if (ent->owner_id == g_edicts[j].id)
|
|
ent->owner = &g_edicts[j];
|
|
}
|
|
}
|
|
ent->owner_id = 0;
|
|
}
|
|
//Knightmare- is this necessary? Entity state flags should be saved.
|
|
// ent->s.renderfx |= RF_IR_VISIBLE;
|
|
}
|
|
fclose(f);
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
==============
|
|
SpawnEntities
|
|
|
|
Creates a server's entity / program execution context by
|
|
parsing textual entity definitions out of an ent file.
|
|
==============
|
|
*/
|
|
void SpawnEntities (char *mapname, char *entities, char *spawnpoint)
|
|
{
|
|
edict_t *ent;
|
|
int inhibit;
|
|
char *com_token;
|
|
int i;
|
|
float skill_level;
|
|
extern int max_modelindex;
|
|
extern int max_soundindex;
|
|
extern int lastgibframe;
|
|
|
|
skill_level = floor (skill->value);
|
|
if (skill_level < 0)
|
|
skill_level = 0;
|
|
if (skill_level > 3)
|
|
skill_level = 3;
|
|
if (skill->value != skill_level)
|
|
gi.cvar_forceset("skill", va("%f", skill_level));
|
|
|
|
SaveClientData ();
|
|
|
|
gi.FreeTags (TAG_LEVEL);
|
|
|
|
memset (&level, 0, sizeof(level));
|
|
memset (g_edicts, 0, game.maxentities * sizeof (g_edicts[0]));
|
|
|
|
// Lazarus: these are used to track model and sound indices
|
|
// in g_main.c:
|
|
max_modelindex = 0;
|
|
max_soundindex = 0;
|
|
|
|
// Lazarus: last frame a gib was spawned in
|
|
lastgibframe = 0;
|
|
|
|
Com_strcpy (level.mapname, sizeof(level.mapname), mapname);
|
|
Com_strcpy (game.spawnpoint, sizeof(game.spawnpoint), spawnpoint);
|
|
|
|
// set client fields on player ents
|
|
for (i=0 ; i<game.maxclients ; i++)
|
|
g_edicts[i+1].client = game.clients + i;
|
|
|
|
ent = NULL;
|
|
inhibit = 0;
|
|
|
|
// Knightmare- set maptype for pack-specific changes
|
|
if ( IsIdMap() ) {
|
|
level.maptype = MAPTYPE_ID;
|
|
// gi.dprintf ("Maptype is Id.\n");
|
|
}
|
|
else if ( IsXatrixMap() ) {
|
|
level.maptype = MAPTYPE_XATRIX;
|
|
// gi.dprintf ("Maptype is Xatrix.\n");
|
|
}
|
|
else if ( IsRogueMap() ) {
|
|
level.maptype = MAPTYPE_ROGUE;
|
|
// gi.dprintf ("Maptype is Rogue.\n");
|
|
}
|
|
else if ( IsZaeroMap() ) {
|
|
level.maptype = MAPTYPE_ZAERO;
|
|
// gi.dprintf ("Maptype is Zaero.\n");
|
|
}
|
|
else {
|
|
level.maptype = MAPTYPE_CUSTOM;
|
|
// gi.dprintf ("Maptype is Custom.\n");
|
|
}
|
|
|
|
// Also set railgun thru window hack for zdef4
|
|
level.isZaeroRailgunHackMap = IsZaeroRailgunHackMap();
|
|
// end Knightmare
|
|
|
|
// Knightmare- load the entity alias script file
|
|
LoadAliasData();
|
|
// gi.dprintf ("Size of alias data: %i\n", alias_data_size);
|
|
|
|
// parse ents
|
|
while (1)
|
|
{
|
|
// parse the opening brace
|
|
com_token = COM_Parse (&entities);
|
|
if (!entities)
|
|
break;
|
|
if (com_token[0] != '{')
|
|
gi.error ("ED_LoadFromFile: found %s when expecting {",com_token);
|
|
|
|
if (!ent)
|
|
ent = g_edicts;
|
|
else
|
|
ent = G_Spawn ();
|
|
ent->spawnflags2 = 0; // Zaero added
|
|
entities = ED_ParseEdict (entities, ent);
|
|
|
|
// yet another map hack
|
|
if (!Q_stricmp(level.mapname, "command") && !Q_stricmp(ent->classname, "trigger_once") && !Q_stricmp(ent->model, "*27"))
|
|
ent->spawnflags &= ~SPAWNFLAG_NOT_HARD;
|
|
|
|
// ROGUE
|
|
//ahh, the joys of map hacks ..
|
|
if (!Q_stricmp(level.mapname, "rhangar2") && !Q_stricmp(ent->classname, "func_door_rotating") && ent->targetname && !Q_stricmp(ent->targetname, "t265"))
|
|
ent->spawnflags &= ~SPAWNFLAG_NOT_COOP;
|
|
if (!Q_stricmp(level.mapname, "rhangar2") && !Q_stricmp(ent->classname, "trigger_always") && ent->target && !Q_stricmp(ent->target, "t265"))
|
|
ent->spawnflags |= SPAWNFLAG_NOT_COOP;
|
|
if (!Q_stricmp(level.mapname, "rhangar2") && !Q_stricmp(ent->classname, "func_wall") && !Q_stricmp(ent->model, "*15"))
|
|
ent->spawnflags |= SPAWNFLAG_NOT_COOP;
|
|
// rogue
|
|
|
|
// remove things (except the world) from different skill levels or deathmatch
|
|
if (ent != g_edicts)
|
|
{
|
|
if (deathmatch->value)
|
|
{
|
|
if (ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH)
|
|
{
|
|
G_FreeEdict (ent);
|
|
inhibit++;
|
|
continue;
|
|
}
|
|
}
|
|
else if ( coop->value )
|
|
{
|
|
if (level.maptype == MAPTYPE_ROGUE) // Knightmare- this breaks non-Rogue maps in coop
|
|
{
|
|
if (ent->spawnflags & SPAWNFLAG_NOT_COOP)
|
|
{
|
|
G_FreeEdict (ent);
|
|
inhibit++;
|
|
continue;
|
|
}
|
|
|
|
// stuff marked !easy & !med & !hard are coop only, all levels
|
|
if (!((ent->spawnflags & SPAWNFLAG_NOT_EASY) &&
|
|
(ent->spawnflags & SPAWNFLAG_NOT_MEDIUM) &&
|
|
(ent->spawnflags & SPAWNFLAG_NOT_HARD)) )
|
|
{
|
|
if ( ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
|
|
((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
|
|
((skill->value >= 2) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
|
|
)
|
|
{
|
|
G_FreeEdict (ent);
|
|
inhibit++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else // generic coop
|
|
{
|
|
if ( CheckCoop_MapHacks(ent) ) // FS: Coop: Check if we have to modify some stuff for coop so we don't have to rely on distributing ent files
|
|
{
|
|
G_FreeEdict (ent);
|
|
inhibit++;
|
|
continue;
|
|
}
|
|
if ( ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
|
|
((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
|
|
((skill->value >= 2) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
|
|
)
|
|
{
|
|
G_FreeEdict (ent);
|
|
inhibit++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( /*((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */
|
|
((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
|
|
((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
|
|
((skill->value >= 2) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
|
|
)
|
|
{
|
|
G_FreeEdict (ent);
|
|
inhibit++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH);
|
|
}
|
|
|
|
//PGM - do this before calling the spawn function so it can be overridden.
|
|
#ifdef ROGUE_GRAVITY
|
|
ent->gravityVector[0] = 0.0;
|
|
ent->gravityVector[1] = 0.0;
|
|
ent->gravityVector[2] = -1.0;
|
|
#endif
|
|
//PGM
|
|
ED_CallSpawn (ent);
|
|
|
|
//Knightmare- remove IR visible attrib from mine lights and banners
|
|
if ( !strcmp(ent->classname, "light_mine1") || !strcmp(ent->classname, "light_mine2")
|
|
|| !strcmp(ent->classname, "misc_banner") )
|
|
ent->s.renderfx &= ~RF_IR_VISIBLE;
|
|
|
|
// David Hyde's code for the origin offset
|
|
VectorAdd(ent->absmin, ent->absmax, ent->origin_offset);
|
|
VectorScale(ent->origin_offset, 0.5, ent->origin_offset);
|
|
VectorSubtract(ent->origin_offset, ent->s.origin, ent->origin_offset);
|
|
}
|
|
|
|
// Knightmare- unload the alias script file
|
|
if (alias_data) { // If no alias file was loaded, don't bother
|
|
#ifdef KMQUAKE2_ENGINE_MOD // use new engine function instead
|
|
gi.FreeFile(alias_data);
|
|
#else
|
|
// if (alias_from_pak)
|
|
gi.TagFree(alias_data);
|
|
// else
|
|
// free(&alias_data);
|
|
#endif
|
|
}
|
|
|
|
gi.dprintf ("%i entities inhibited\n", inhibit);
|
|
|
|
#ifdef DEBUG
|
|
i = 1;
|
|
ent = EDICT_NUM(i);
|
|
while (i < globals.num_edicts)
|
|
{
|
|
if (ent->inuse != 0 || ent->inuse != 1)
|
|
Com_DPrintf("Invalid entity %d\n", i);
|
|
i++, ent++;
|
|
}
|
|
#endif
|
|
|
|
G_FindTeams ();
|
|
|
|
// DWH
|
|
G_FindCraneParts();
|
|
|
|
PlayerTrail_Init ();
|
|
|
|
// ROGUE
|
|
if (deathmatch->value)
|
|
{
|
|
if (randomrespawn && randomrespawn->value)
|
|
PrecacheForRandomRespawn();
|
|
}
|
|
else
|
|
{
|
|
InitHintPaths(); // if there aren't hintpaths on this map, enable quick aborts
|
|
}
|
|
// ROGUE
|
|
|
|
// ROGUE -- allow dm games to do init stuff right before game starts.
|
|
if (deathmatch->value && gamerules && gamerules->value)
|
|
{
|
|
if (DMGame.PostInitSetup)
|
|
DMGame.PostInitSetup ();
|
|
}
|
|
// ROGUE
|
|
|
|
// Lazarus movewith init
|
|
/* for (i=1, ent=g_edicts+i; i < globals.num_edicts; i++, ent++)
|
|
{
|
|
if (!ent->movewith)
|
|
continue;
|
|
if (ent->movewith_ent)
|
|
continue;
|
|
ent->movewith_ent = G_Find(NULL, FOFS(targetname), ent->movewith);
|
|
// Make sure that we can really "movewith" this guy. This check
|
|
// allows us to have movewith parent with same targetname as
|
|
// other entities
|
|
while (ent->movewith_ent &&
|
|
(Q_stricmp(ent->movewith_ent->classname, "func_train") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "model_train") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_door") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_door_rotating") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_plat") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_plat2") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_rotating") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_button") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_door_secret") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_door_secret2") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_door_swinging") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_breakaway") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_trackchange") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_vehicle") &&
|
|
Q_stricmp(ent->movewith_ent->classname, "func_tracktrain") ))
|
|
ent->movewith_ent = G_Find (ent->movewith_ent, FOFS(targetname), ent->movewith);
|
|
if (ent->movewith_ent)
|
|
movewith_init (ent->movewith_ent);
|
|
}
|
|
*/
|
|
/* for(i=1, ent=g_edicts+i; i < globals.num_edicts; i++, ent++)
|
|
{
|
|
gi.dprintf("%s:%s - movewith=%s, movewith_ent=%s:%s, movewith_next=%s:%s\n====================\n",
|
|
ent->classname, (ent->targetname ? ent->targetname : "noname"),
|
|
(ent->movewith ? ent->movewith : "N/A"),
|
|
(ent->movewith_ent ? ent->movewith_ent->classname : "N/A"),
|
|
(ent->movewith_ent ? (ent->movewith_ent->targetname ? ent->movewith_ent->targetname : "noname") : "N/A"),
|
|
(ent->movewith_next ? ent->movewith_next->classname : "N/A"),
|
|
(ent->movewith_next ? (ent->movewith_next->targetname ? ent->movewith_next->targetname : "noname") : "N/A"));
|
|
|
|
} */
|
|
|
|
// Knightmare added
|
|
if (game.transition_ents)
|
|
{
|
|
LoadTransitionEnts();
|
|
}
|
|
|
|
actor_files ();
|
|
}
|
|
|
|
|
|
//===================================================================
|
|
|
|
#if 0
|
|
// cursor positioning
|
|
xl <value>
|
|
xr <value>
|
|
yb <value>
|
|
yt <value>
|
|
xv <value>
|
|
yv <value>
|
|
|
|
// drawing
|
|
statpic <name>
|
|
pic <stat>
|
|
num <fieldwidth> <stat>
|
|
string <stat>
|
|
|
|
// control
|
|
if <stat>
|
|
ifeq <stat> <value>
|
|
ifbit <stat> <value>
|
|
endif
|
|
|
|
#endif
|
|
|
|
char *single_statusbar =
|
|
"yb -24 "
|
|
|
|
// health
|
|
"xv 0 "
|
|
"hnum "
|
|
"xv 50 "
|
|
"pic 0 "
|
|
|
|
// ammo
|
|
"if 2 "
|
|
" xv 100 "
|
|
" anum "
|
|
" xv 150 "
|
|
" pic 2 "
|
|
"endif "
|
|
|
|
// armor
|
|
"if 4 "
|
|
" xv 200 "
|
|
" rnum "
|
|
" xv 250 "
|
|
" pic 4 "
|
|
"endif "
|
|
|
|
// selected item
|
|
"if 6 "
|
|
" xv 296 "
|
|
" pic 6 "
|
|
"endif "
|
|
|
|
"yb -50 "
|
|
|
|
// picked up item
|
|
"if 7 "
|
|
" xv 0 "
|
|
" pic 7 "
|
|
" xv 26 "
|
|
" yb -42 "
|
|
" stat_string 8 "
|
|
" yb -50 "
|
|
"endif "
|
|
|
|
// timer
|
|
"if 9 "
|
|
" xv 230 " //was xv 262
|
|
" num 4 10 "
|
|
" xv 296 "
|
|
" pic 9 "
|
|
"endif "
|
|
|
|
// help / weapon icon
|
|
"if 11 "
|
|
" xv 148 "
|
|
" pic 11 "
|
|
"endif "
|
|
|
|
// vehicle speed
|
|
"if 22 "
|
|
" yb -90 "
|
|
" xv 128 "
|
|
" pic 22 "
|
|
"endif "
|
|
|
|
// zoom
|
|
"if 23 "
|
|
" yv 0 "
|
|
" xv 0 "
|
|
" pic 23 "
|
|
"endif "
|
|
;
|
|
|
|
char *dm_statusbar =
|
|
"yb -24 "
|
|
|
|
// health
|
|
"xv 0 "
|
|
"hnum "
|
|
"xv 50 "
|
|
"pic 0 "
|
|
|
|
// ammo
|
|
"if 2 "
|
|
" xv 100 "
|
|
" anum "
|
|
" xv 150 "
|
|
" pic 2 "
|
|
"endif "
|
|
|
|
// armor
|
|
"if 4 "
|
|
" xv 200 "
|
|
" rnum "
|
|
" xv 250 "
|
|
" pic 4 "
|
|
"endif "
|
|
|
|
// selected item
|
|
"if 6 "
|
|
" xv 296 "
|
|
" pic 6 "
|
|
"endif "
|
|
|
|
"yb -50 "
|
|
|
|
// picked up item
|
|
"if 7 "
|
|
" xv 0 "
|
|
" pic 7 "
|
|
" xv 26 "
|
|
" yb -42 "
|
|
" stat_string 8 "
|
|
" yb -50 "
|
|
"endif "
|
|
|
|
// timer
|
|
"if 9 "
|
|
" xv 230 " //was 246
|
|
" num 4 10 "
|
|
" xv 296 "
|
|
" pic 9 "
|
|
"endif "
|
|
|
|
// help / weapon icon
|
|
"if 11 "
|
|
" xv 148 "
|
|
" pic 11 "
|
|
"endif "
|
|
|
|
// frags
|
|
"xr -50 "
|
|
"yt 2 "
|
|
"num 3 14 "
|
|
|
|
// spectator
|
|
"if 17 "
|
|
"xv 0 "
|
|
"yb -58 "
|
|
"string2 \"SPECTATOR MODE\" "
|
|
"endif "
|
|
|
|
// chase camera
|
|
"if 16 "
|
|
"xv 0 "
|
|
"yb -68 "
|
|
"string \"Chasing\" "
|
|
"xv 64 "
|
|
"stat_string 16 "
|
|
"endif "
|
|
|
|
// vehicle speed
|
|
"if 22 "
|
|
" yb -90 "
|
|
" xv 128 "
|
|
" pic 22 "
|
|
"endif "
|
|
;
|
|
|
|
|
|
/*QUAKED worldspawn (0 0 0) ?
|
|
|
|
Only used for the world.
|
|
"sky" environment map name
|
|
"skyaxis" vector axis for rotating sky
|
|
"skyrotate" speed of rotation in degrees/second
|
|
"sounds" music cd track number
|
|
"gravity" 800 is default gravity
|
|
"message" text to print at user logon
|
|
*/
|
|
void SP_worldspawn (edict_t *ent)
|
|
{
|
|
ent->movetype = MOVETYPE_PUSH;
|
|
ent->solid = SOLID_BSP;
|
|
ent->inuse = true; // since the world doesn't use G_Spawn()
|
|
ent->s.modelindex = 1; // world model is always index 1
|
|
ent->spawnflags2 = 0; // Zaero added
|
|
|
|
//---------------
|
|
|
|
// reserve some spots for dead player bodies for coop / deathmatch
|
|
InitBodyQue ();
|
|
|
|
// set configstrings for items
|
|
SetItemNames ();
|
|
|
|
if (st.nextmap)
|
|
Com_strcpy (level.nextmap, sizeof(level.nextmap), st.nextmap);
|
|
|
|
// make some data visible to the server
|
|
|
|
if (ent->message && ent->message[0])
|
|
{
|
|
gi.configstring (CS_NAME, ent->message);
|
|
Com_strcpy (level.level_name, sizeof(level.level_name), ent->message);
|
|
}
|
|
else
|
|
Com_strcpy (level.level_name, sizeof(level.level_name), level.mapname);
|
|
|
|
if (st.sky && st.sky[0])
|
|
gi.configstring (CS_SKY, st.sky);
|
|
else
|
|
gi.configstring (CS_SKY, "unit1_");
|
|
|
|
gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) );
|
|
|
|
gi.configstring (CS_SKYAXIS, va("%f %f %f",
|
|
st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) );
|
|
|
|
// Knightmare- if a named soundtrack is specified, play it instead of from CD
|
|
if (ent->musictrack && strlen(ent->musictrack))
|
|
gi.configstring (CS_CDTRACK, ent->musictrack);
|
|
else
|
|
gi.configstring (CS_CDTRACK, va("%i", ent->sounds) );
|
|
|
|
gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) );
|
|
|
|
// status bar program
|
|
if (deathmatch->value)
|
|
gi.configstring (CS_STATUSBAR, dm_statusbar);
|
|
else
|
|
gi.configstring (CS_STATUSBAR, single_statusbar);
|
|
|
|
//---------------
|
|
|
|
|
|
// help icon for statusbar
|
|
gi.imageindex ("i_help");
|
|
level.pic_health = gi.imageindex ("i_health");
|
|
gi.imageindex ("help");
|
|
gi.imageindex ("field_3");
|
|
|
|
if (!st.gravity)
|
|
gi.cvar_set("sv_gravity", "800");
|
|
else
|
|
gi.cvar_set("sv_gravity", st.gravity);
|
|
|
|
snd_fry = gi.soundindex ("player/fry.wav"); // standing in lava / slime
|
|
|
|
PrecacheItem (FindItem ("Blaster"));
|
|
|
|
gi.soundindex ("player/lava1.wav");
|
|
gi.soundindex ("player/lava2.wav");
|
|
|
|
gi.soundindex ("misc/pc_up.wav");
|
|
gi.soundindex ("misc/talk1.wav");
|
|
|
|
// gibs
|
|
gi.soundindex ("misc/udeath.wav");
|
|
|
|
gi.soundindex ("items/respawn1.wav");
|
|
|
|
// sexed sounds
|
|
gi.soundindex ("*death1.wav");
|
|
gi.soundindex ("*death2.wav");
|
|
gi.soundindex ("*death3.wav");
|
|
gi.soundindex ("*death4.wav");
|
|
gi.soundindex ("*fall1.wav");
|
|
gi.soundindex ("*fall2.wav");
|
|
gi.soundindex ("*gurp1.wav"); // drowning damage
|
|
gi.soundindex ("*gurp2.wav");
|
|
gi.soundindex ("*jump1.wav"); // player jump
|
|
gi.soundindex ("*pain25_1.wav");
|
|
gi.soundindex ("*pain25_2.wav");
|
|
gi.soundindex ("*pain50_1.wav");
|
|
gi.soundindex ("*pain50_2.wav");
|
|
gi.soundindex ("*pain75_1.wav");
|
|
gi.soundindex ("*pain75_2.wav");
|
|
gi.soundindex ("*pain100_1.wav");
|
|
gi.soundindex ("*pain100_2.wav");
|
|
|
|
// sexed models
|
|
// THIS ORDER MUST MATCH THE DEFINES IN g_local.h
|
|
// you can add more, max 64
|
|
// Knightmare- load these in single player, too
|
|
if (use_vwep->value || deathmatch->value)
|
|
{
|
|
gi.modelindex ("#w_blaster.md2");
|
|
gi.modelindex ("#w_shotgun.md2");
|
|
gi.modelindex ("#w_sshotgun.md2");
|
|
gi.modelindex ("#w_machinegun.md2");
|
|
gi.modelindex ("#w_chaingun.md2");
|
|
gi.modelindex ("#a_grenades.md2");
|
|
gi.modelindex ("#w_glauncher.md2");
|
|
gi.modelindex ("#w_rlauncher.md2");
|
|
gi.modelindex ("#w_hyperblaster.md2");
|
|
gi.modelindex ("#w_railgun.md2");
|
|
gi.modelindex ("#w_bfg.md2");
|
|
|
|
#ifdef KMQUAKE2_ENGINE_MOD // only allow missionpack vweps for KMQ2 builds
|
|
gi.modelindex ("#w_disrupt.md2"); // PGM
|
|
gi.modelindex ("#w_etfrifle.md2"); // PGM
|
|
gi.modelindex ("#w_plasma.md2"); // PGM
|
|
gi.modelindex ("#w_plauncher.md2"); // PGM
|
|
gi.modelindex ("#w_chainfist.md2"); // PGM
|
|
gi.modelindex ("#w_phalanx.md2"); // Knightmare added
|
|
gi.modelindex ("#w_ripper.md2"); // Knightmare added
|
|
gi.modelindex ("#w_shockwave.md2"); // Knightmare added
|
|
gi.modelindex ("#w_plasmarifle.md2"); // SKWiD MOD
|
|
|
|
// gi.modelindex ("#a_trap.md2"); // Knightmare added
|
|
// gi.modelindex ("#a_tesla.md2"); // Knightmare added
|
|
// gi.modelindex ("#w_grapple.md2");
|
|
#endif // KMQUAKE2_ENGINE_MOD
|
|
}
|
|
//-------------------
|
|
|
|
gi.soundindex ("player/gasp1.wav"); // gasping for air
|
|
gi.soundindex ("player/gasp2.wav"); // head breaking surface, not gasping
|
|
|
|
gi.soundindex ("player/watr_in.wav"); // feet hitting water
|
|
gi.soundindex ("player/watr_out.wav"); // feet leaving water
|
|
|
|
gi.soundindex ("player/watr_un.wav"); // head going underwater
|
|
|
|
gi.soundindex ("mud/mud_in2.wav"); // feet hitting mud
|
|
gi.soundindex ("mud/mud_out1.wav"); // feet leaving mud
|
|
gi.soundindex ("mud/mud_un1.wav"); // head going under mud
|
|
// gi.soundindex ("mud/wade_mud1.wav");
|
|
// gi.soundindex ("mud/wade_mud2.wav");
|
|
|
|
// Knightmare- moved these precaches to item data blocks
|
|
// gi.soundindex ("player/u_breath1.wav");
|
|
// gi.soundindex ("player/u_breath2.wav");
|
|
|
|
gi.soundindex ("items/pkup.wav"); // bonus item pickup
|
|
gi.soundindex ("world/land.wav"); // landing thud
|
|
gi.soundindex ("misc/h2ohit1.wav"); // landing splash
|
|
|
|
// gi.soundindex ("items/damage.wav");
|
|
// ROGUE - double damage
|
|
// gi.soundindex ("misc/ddamage1.wav");
|
|
// rogue
|
|
|
|
// gi.soundindex ("items/protect.wav");
|
|
// gi.soundindex ("items/protect4.wav");
|
|
gi.soundindex ("weapons/noammo.wav");
|
|
|
|
// Knightmare- does this even get used in deathmatch?
|
|
if (!deathmatch->value)
|
|
gi.soundindex ("infantry/inflies1.wav");
|
|
|
|
sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2");
|
|
gi.modelindex ("models/objects/gibs/arm/tris.md2");
|
|
gi.modelindex ("models/objects/gibs/leg/tris.md2");
|
|
gi.modelindex ("models/objects/gibs/bone/tris.md2");
|
|
gi.modelindex ("models/objects/gibs/bone2/tris.md2");
|
|
gi.modelindex ("models/objects/gibs/chest/tris.md2");
|
|
gi.modelindex ("models/objects/gibs/skull/tris.md2");
|
|
gi.modelindex ("models/objects/gibs/head2/tris.md2");
|
|
|
|
// Fog clipping - if "fogclip" is non-zero, force gl_clear to a good
|
|
// value for obscuring HOM with fog... "good" is driver-dependent
|
|
if (ent->fogclip)
|
|
{
|
|
if ( gl_driver && !Q_stricmp(gl_driver->string, "3dfxgl") )
|
|
gi.cvar_forceset("gl_clear", "0");
|
|
else
|
|
gi.cvar_forceset("gl_clear", "1");
|
|
}
|
|
|
|
// FMOD 3D sound attenuation:
|
|
if (ent->attenuation <= 0.)
|
|
ent->attenuation = 1.0;
|
|
|
|
// FMOD 3D sound Doppler shift:
|
|
if (st.shift > 0)
|
|
ent->moveinfo.distance = st.shift;
|
|
else if (st.shift < 0)
|
|
ent->moveinfo.distance = 0.0;
|
|
else
|
|
ent->moveinfo.distance = 1.0;
|
|
|
|
// cvar overrides for effects flags:
|
|
if (alert_sounds->value)
|
|
world->effects |= FX_WORLDSPAWN_ALERTSOUNDS;
|
|
if (corpse_fade->value)
|
|
world->effects |= FX_WORLDSPAWN_CORPSEFADE;
|
|
if (jump_kick->value)
|
|
world->effects |= FX_WORLDSPAWN_JUMPKICK;
|
|
if (footstep_sounds->value)
|
|
world->effects |= FX_WORLDSPAWN_STEPSOUNDS;
|
|
|
|
//Knightmare- this is now handled client-side
|
|
#ifdef FMOD_FOOTSTEPS
|
|
|
|
if (deathmatch->value || coop->value)
|
|
qFMOD_Footsteps = false;
|
|
else if (world->effects & FX_WORLDSPAWN_STEPSOUNDS)
|
|
{
|
|
qFMOD_Footsteps = true;
|
|
FMOD_Init();
|
|
}
|
|
else
|
|
qFMOD_Footsteps = false;
|
|
#endif
|
|
//
|
|
// Setup light animation tables. 'a' is total darkness, 'z' is doublebright.
|
|
//
|
|
|
|
// 0 normal
|
|
gi.configstring(CS_LIGHTS+0, "m");
|
|
|
|
// 1 FLICKER (first variety)
|
|
gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo");
|
|
|
|
// 2 SLOW STRONG PULSE
|
|
gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba");
|
|
|
|
// 3 CANDLE (first variety)
|
|
gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg");
|
|
|
|
// 4 FAST STROBE
|
|
gi.configstring(CS_LIGHTS+4, "mamamamamama");
|
|
|
|
// 5 GENTLE PULSE 1
|
|
gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj");
|
|
|
|
// 6 FLICKER (second variety)
|
|
gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno");
|
|
|
|
// 7 CANDLE (second variety)
|
|
gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm");
|
|
|
|
// 8 CANDLE (third variety)
|
|
gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa");
|
|
|
|
// 9 SLOW STROBE (fourth variety)
|
|
gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz");
|
|
|
|
// 10 FLUORESCENT FLICKER
|
|
gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma");
|
|
|
|
// 11 SLOW PULSE NOT FADE TO BLACK
|
|
gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba");
|
|
|
|
// styles 32-62 are assigned by the light program for switchable lights
|
|
|
|
// 63 testing
|
|
gi.configstring(CS_LIGHTS+63, "a");
|
|
}
|
|
|
|
//
|
|
//ROGUE
|
|
//
|
|
|
|
//
|
|
// Monster spawning code
|
|
//
|
|
// Used by the carrier, the medic_commander, and the black widow
|
|
//
|
|
// The sequence to create a flying monster is:
|
|
//
|
|
// FindSpawnPoint - tries to find suitable spot to spawn the monster in
|
|
// CreateFlyMonster - this verifies the point as good and creates the monster
|
|
|
|
// To create a ground walking monster:
|
|
//
|
|
// FindSpawnPoint - same thing
|
|
// CreateGroundMonster - this checks the volume and makes sure the floor under the volume is suitable
|
|
//
|
|
|
|
// FIXME - for the black widow, if we want the stalkers coming in on the roof, we'll have to tweak some things
|
|
|
|
//
|
|
// CreateMonster
|
|
//
|
|
edict_t *CreateMonster(vec3_t origin, vec3_t angles, char *classname)
|
|
{
|
|
edict_t *newEnt;
|
|
|
|
newEnt = G_Spawn();
|
|
|
|
VectorCopy(origin, newEnt->s.origin);
|
|
VectorCopy(angles, newEnt->s.angles);
|
|
newEnt->classname = ED_NewString (classname);
|
|
//newEnt->monsterinfo.aiflags |= AI_DO_NOT_COUNT;
|
|
newEnt->monsterinfo.monsterflags |= MFL_DO_NOT_COUNT;
|
|
|
|
VectorSet(newEnt->gravityVector, 0, 0, -1);
|
|
ED_CallSpawn(newEnt);
|
|
newEnt->s.renderfx |= RF_IR_VISIBLE;
|
|
|
|
return newEnt;
|
|
}
|
|
|
|
edict_t *CreateFlyMonster (vec3_t origin, vec3_t angles, vec3_t mins, vec3_t maxs, char *classname)
|
|
{
|
|
if (!mins || !maxs || VectorCompare (mins, vec3_origin) || VectorCompare (maxs, vec3_origin))
|
|
{
|
|
DetermineBBox (classname, mins, maxs);
|
|
}
|
|
|
|
if (!CheckSpawnPoint(origin, mins, maxs))
|
|
return NULL;
|
|
|
|
return (CreateMonster (origin, angles, classname));
|
|
}
|
|
|
|
// This is just a wrapper for CreateMonster that looks down height # of CMUs and sees if there
|
|
// are bad things down there or not
|
|
//
|
|
// this is from m_move.c
|
|
#define STEPSIZE 18
|
|
|
|
edict_t *CreateGroundMonster (vec3_t origin, vec3_t angles, vec3_t entMins, vec3_t entMaxs, char *classname, int height)
|
|
{
|
|
// trace_t tr;
|
|
edict_t *newEnt;
|
|
// vec3_t start, stop;
|
|
// int failure = 0;
|
|
// vec3_t mins, maxs;
|
|
// int x, y;
|
|
// float mid, bottom;
|
|
vec3_t mins, maxs;
|
|
|
|
// if they don't provide us a bounding box, figure it out
|
|
if (!entMins || !entMaxs || VectorCompare (entMins, vec3_origin) || VectorCompare (entMaxs, vec3_origin))
|
|
{
|
|
DetermineBBox (classname, mins, maxs);
|
|
}
|
|
else
|
|
{
|
|
VectorCopy (entMins, mins);
|
|
VectorCopy (entMaxs, maxs);
|
|
}
|
|
|
|
// check the ground to make sure it's there, it's relatively flat, and it's not toxic
|
|
if (!CheckGroundSpawnPoint(origin, mins, maxs, height, -1))
|
|
return NULL;
|
|
|
|
newEnt = CreateMonster (origin, angles, classname);
|
|
if (!newEnt)
|
|
return NULL;
|
|
|
|
return newEnt;
|
|
}
|
|
|
|
|
|
// FindSpawnPoint
|
|
// PMM - this is used by the medic commander (possibly by the carrier) to find a good spawn point
|
|
// if the startpoint is bad, try above the startpoint for a bit
|
|
|
|
qboolean FindSpawnPoint (vec3_t startpoint, vec3_t mins, vec3_t maxs, vec3_t spawnpoint, float maxMoveUp)
|
|
{
|
|
trace_t tr;
|
|
float height;
|
|
vec3_t top;
|
|
|
|
height = maxs[2] - mins[2];
|
|
|
|
tr = gi.trace (startpoint, mins, maxs, startpoint, NULL, MASK_MONSTERSOLID|CONTENTS_PLAYERCLIP);
|
|
if ((tr.startsolid || tr.allsolid) || (tr.ent != world))
|
|
{
|
|
// if ( ((tr.ent->svflags & SVF_MONSTER) && (tr.ent->health <= 0)) ||
|
|
// (tr.ent->svflags & SVF_DAMAGEABLE) )
|
|
// {
|
|
// T_Damage (tr.ent, self, self, vec3_origin, self->enemy->s.origin,
|
|
// pain_normal, hurt, 0, 0, MOD_UNKNOWN);
|
|
|
|
VectorCopy (startpoint, top);
|
|
top[2] += maxMoveUp;
|
|
/*
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_DEBUGTRAIL);
|
|
gi.WritePosition (top);
|
|
gi.WritePosition (startpoint);
|
|
gi.multicast (startpoint, MULTICAST_ALL);
|
|
*/
|
|
tr = gi.trace (top, mins, maxs, startpoint, NULL, MASK_MONSTERSOLID);
|
|
if (tr.startsolid || tr.allsolid)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// if (tr.ent)
|
|
// gi.dprintf("FindSpawnPoint: failed to find a point -- blocked by %s\n", tr.ent->classname);
|
|
// else
|
|
// gi.dprintf("FindSpawnPoint: failed to find a point\n");
|
|
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf ("FindSpawnPoint: %s -> %s\n", vtos (startpoint), vtos (tr.endpos));
|
|
VectorCopy (tr.endpos, spawnpoint);
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VectorCopy (startpoint, spawnpoint);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// FIXME - all of this needs to be tweaked to handle the new gravity rules
|
|
// if we ever want to spawn stuff on the roof
|
|
|
|
//
|
|
// CheckSpawnPoint
|
|
//
|
|
// PMM - checks volume to make sure we can spawn a monster there (is it solid?)
|
|
//
|
|
// This is all fliers should need
|
|
|
|
qboolean CheckSpawnPoint (vec3_t origin, vec3_t mins, vec3_t maxs)
|
|
{
|
|
trace_t tr;
|
|
|
|
if (!mins || !maxs || VectorCompare(mins, vec3_origin) || VectorCompare (maxs, vec3_origin))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
tr = gi.trace (origin, mins, maxs, origin, NULL, MASK_MONSTERSOLID);
|
|
if (tr.startsolid || tr.allsolid)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf("createmonster in wall. removing\n");
|
|
return false;
|
|
}
|
|
if (tr.ent != world)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf("createmonster in entity %s\n", tr.ent->classname);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// CheckGroundSpawnPoint
|
|
//
|
|
// PMM - used for walking monsters
|
|
// checks:
|
|
// 1) is there a ground within the specified height of the origin?
|
|
// 2) is the ground non-water?
|
|
// 3) is the ground flat enough to walk on?
|
|
//
|
|
|
|
qboolean CheckGroundSpawnPoint (vec3_t origin, vec3_t entMins, vec3_t entMaxs, float height, float gravity)
|
|
{
|
|
trace_t tr;
|
|
vec3_t start, stop;
|
|
int failure = 0;
|
|
vec3_t mins, maxs;
|
|
int x, y;
|
|
float mid, bottom;
|
|
|
|
if (!CheckSpawnPoint (origin, entMins, entMaxs))
|
|
return false;
|
|
|
|
// FIXME - this is too conservative about angled surfaces
|
|
|
|
VectorCopy (origin, stop);
|
|
// FIXME - gravity vector
|
|
stop[2] = origin[2] + entMins[2] - height;
|
|
|
|
/*
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_DEBUGTRAIL);
|
|
gi.WritePosition (origin);
|
|
gi.WritePosition (stop);
|
|
gi.multicast (start, MULTICAST_ALL);
|
|
*/
|
|
|
|
tr = gi.trace (origin, entMins, entMaxs, stop, NULL, MASK_MONSTERSOLID | MASK_WATER);
|
|
// it's not going to be all solid or start solid, since that's checked above
|
|
|
|
if ((tr.fraction < 1) && (tr.contents & MASK_MONSTERSOLID))
|
|
{
|
|
// we found a non-water surface down there somewhere. now we need to check to make sure it's not too sloped
|
|
//
|
|
// algorithm straight out of m_move.c:M_CheckBottom()
|
|
//
|
|
|
|
// first, do the midpoint trace
|
|
|
|
VectorAdd (tr.endpos, entMins, mins);
|
|
VectorAdd (tr.endpos, entMaxs, maxs);
|
|
|
|
|
|
// first, do the easy flat check
|
|
//
|
|
#ifdef ROGUE_GRAVITY
|
|
// FIXME - this will only handle 0,0,1 and 0,0,-1 gravity vectors
|
|
if (gravity > 0)
|
|
start[2] = maxs[2] + 1;
|
|
else
|
|
start[2] = mins[2] - 1;
|
|
#else
|
|
start[2] = mins[2] - 1;
|
|
#endif
|
|
for (x=0 ; x<=1 ; x++)
|
|
{
|
|
for (y=0 ; y<=1 ; y++)
|
|
{
|
|
start[0] = x ? maxs[0] : mins[0];
|
|
start[1] = y ? maxs[1] : mins[1];
|
|
if (gi.pointcontents (start) != CONTENTS_SOLID)
|
|
goto realcheck;
|
|
}
|
|
}
|
|
|
|
// if it passed all four above checks, we're done
|
|
return true;
|
|
|
|
realcheck:
|
|
|
|
// check it for real
|
|
|
|
start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
|
|
start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
|
|
start[2] = mins[2];
|
|
|
|
tr = gi.trace (start, vec3_origin, vec3_origin, stop, NULL, MASK_MONSTERSOLID);
|
|
|
|
if (tr.fraction == 1.0)
|
|
return false;
|
|
mid = bottom = tr.endpos[2];
|
|
|
|
#ifdef ROGUE_GRAVITY
|
|
if (gravity < 0)
|
|
{
|
|
start[2] = mins[2];
|
|
stop[2] = start[2] - STEPSIZE - STEPSIZE;
|
|
mid = bottom = tr.endpos[2] + entMins[2];
|
|
}
|
|
else
|
|
{
|
|
start[2] = maxs[2];
|
|
stop[2] = start[2] + STEPSIZE + STEPSIZE;
|
|
mid = bottom = tr.endpos[2] - entMaxs[2];
|
|
}
|
|
#else
|
|
stop[2] = start[2] - 2*STEPSIZE;
|
|
mid = bottom = tr.endpos[2] + entMins[2];
|
|
#endif
|
|
|
|
for (x=0 ; x<=1 ; x++)
|
|
for (y=0 ; y<=1 ; y++)
|
|
{
|
|
start[0] = stop[0] = x ? maxs[0] : mins[0];
|
|
start[1] = stop[1] = y ? maxs[1] : mins[1];
|
|
|
|
/*
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_DEBUGTRAIL);
|
|
gi.WritePosition (start);
|
|
gi.WritePosition (stop);
|
|
gi.multicast (start, MULTICAST_ALL);
|
|
*/
|
|
tr = gi.trace (start, vec3_origin, vec3_origin, stop, NULL, MASK_MONSTERSOLID);
|
|
|
|
//PGM
|
|
#ifdef ROGUE_GRAVITY
|
|
// FIXME - this will only handle 0,0,1 and 0,0,-1 gravity vectors
|
|
if (gravity > 0)
|
|
{
|
|
if (tr.fraction != 1.0 && tr.endpos[2] < bottom)
|
|
bottom = tr.endpos[2];
|
|
if (tr.fraction == 1.0 || tr.endpos[2] - mid > STEPSIZE)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf ("spawn - rejecting due to uneven ground\n");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (tr.fraction != 1.0 && tr.endpos[2] > bottom)
|
|
bottom = tr.endpos[2];
|
|
if (tr.fraction == 1.0 || mid - tr.endpos[2] > STEPSIZE)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf ("spawn - rejecting due to uneven ground\n");
|
|
return false;
|
|
}
|
|
}
|
|
#else
|
|
if (tr.fraction != 1.0 && tr.endpos[2] > bottom)
|
|
bottom = tr.endpos[2];
|
|
if (tr.fraction == 1.0 || mid - tr.endpos[2] > STEPSIZE)
|
|
{
|
|
return false;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return true; // we can land on it, it's ok
|
|
}
|
|
|
|
// otherwise, it's either water (bad) or not there (too far)
|
|
// if we're here, it's bad below
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// {
|
|
// if (tr.fraction < 1)
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf("groundmonster would fall into water/slime/lava\n");
|
|
// else
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf("groundmonster would fall too far\n");
|
|
// }
|
|
|
|
return false;
|
|
}
|
|
|
|
void DetermineBBox (char *classname, vec3_t mins, vec3_t maxs)
|
|
{
|
|
// FIXME - cache this stuff
|
|
edict_t *newEnt;
|
|
|
|
newEnt = G_Spawn();
|
|
|
|
VectorCopy(vec3_origin, newEnt->s.origin);
|
|
VectorCopy(vec3_origin, newEnt->s.angles);
|
|
newEnt->classname = ED_NewString (classname);
|
|
//newEnt->monsterinfo.aiflags |= AI_DO_NOT_COUNT;
|
|
newEnt->monsterinfo.monsterflags |= MFL_DO_NOT_COUNT;
|
|
|
|
ED_CallSpawn(newEnt);
|
|
|
|
VectorCopy (newEnt->mins, mins);
|
|
VectorCopy (newEnt->maxs, maxs);
|
|
|
|
G_FreeEdict (newEnt);
|
|
}
|
|
|
|
// ****************************
|
|
// SPAWNGROW stuff
|
|
// ****************************
|
|
|
|
#define SPAWNGROW_LIFESPAN 0.3
|
|
|
|
void spawngrow_think (edict_t *self)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<2; i++)
|
|
{
|
|
self->s.angles[0] = rand()%360;
|
|
self->s.angles[1] = rand()%360;
|
|
self->s.angles[2] = rand()%360;
|
|
}
|
|
if ((level.time < self->wait) && (self->s.frame < 2))
|
|
self->s.frame++;
|
|
if (level.time >= self->wait)
|
|
{
|
|
if (self->s.effects & EF_SPHERETRANS)
|
|
{
|
|
G_FreeEdict (self);
|
|
return;
|
|
}
|
|
else if (self->s.frame > 0)
|
|
self->s.frame--;
|
|
else
|
|
{
|
|
G_FreeEdict (self);
|
|
return;
|
|
}
|
|
}
|
|
self->nextthink += FRAMETIME;
|
|
}
|
|
|
|
void SpawnGrow_Spawn (vec3_t startpos, int size)
|
|
{
|
|
edict_t *ent;
|
|
int i;
|
|
float lifespan;
|
|
|
|
ent = G_Spawn();
|
|
VectorCopy(startpos, ent->s.origin);
|
|
for (i=0; i<2; i++)
|
|
{
|
|
ent->s.angles[0] = rand()%360;
|
|
ent->s.angles[1] = rand()%360;
|
|
ent->s.angles[2] = rand()%360;
|
|
}
|
|
ent->solid = SOLID_NOT;
|
|
// ent->s.renderfx = RF_FULLBRIGHT | RF_IR_VISIBLE;
|
|
ent->s.renderfx = RF_IR_VISIBLE;
|
|
ent->movetype = MOVETYPE_NONE;
|
|
ent->classname = "spawngro";
|
|
|
|
if (size <= 1)
|
|
{
|
|
lifespan = SPAWNGROW_LIFESPAN;
|
|
ent->s.modelindex = gi.modelindex("models/items/spawngro2/tris.md2");
|
|
}
|
|
else if (size == 2)
|
|
{
|
|
ent->s.modelindex = gi.modelindex("models/items/spawngro3/tris.md2");
|
|
lifespan = 2;
|
|
}
|
|
else
|
|
{
|
|
ent->s.modelindex = gi.modelindex("models/items/spawngro/tris.md2");
|
|
lifespan = SPAWNGROW_LIFESPAN;
|
|
}
|
|
|
|
ent->think = spawngrow_think;
|
|
|
|
ent->wait = level.time + lifespan;
|
|
ent->nextthink = level.time + FRAMETIME;
|
|
if (size != 2)
|
|
ent->s.effects |= EF_SPHERETRANS;
|
|
gi.linkentity (ent);
|
|
}
|
|
|
|
|
|
// ****************************
|
|
// WidowLeg stuff
|
|
// ****************************
|
|
|
|
#define MAX_LEGSFRAME 23
|
|
#define LEG_WAIT_TIME 1
|
|
|
|
void ThrowMoreStuff (edict_t *self, vec3_t point);
|
|
void ThrowSmallStuff (edict_t *self, vec3_t point);
|
|
void ThrowWidowGibLoc (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, qboolean fade);
|
|
void ThrowWidowGibSized (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, int hitsound, qboolean fade);
|
|
|
|
void widowlegs_think (edict_t *self)
|
|
{
|
|
vec3_t offset;
|
|
vec3_t point;
|
|
vec3_t f,r,u;
|
|
|
|
if (self->s.frame == 17)
|
|
{
|
|
VectorSet (offset, 11.77, -7.24, 23.31);
|
|
AngleVectors (self->s.angles, f, r, u);
|
|
G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_EXPLOSION1);
|
|
gi.WritePosition (point);
|
|
gi.multicast (point, MULTICAST_ALL);
|
|
ThrowSmallStuff (self, point);
|
|
}
|
|
|
|
if (self->s.frame < MAX_LEGSFRAME)
|
|
{
|
|
self->s.frame++;
|
|
self->nextthink = level.time + FRAMETIME;
|
|
return;
|
|
}
|
|
else if (self->wait == 0)
|
|
{
|
|
self->wait = level.time + LEG_WAIT_TIME;
|
|
}
|
|
if (level.time > self->wait)
|
|
{
|
|
AngleVectors (self->s.angles, f, r, u);
|
|
|
|
VectorSet (offset, -65.6, -8.44, 28.59);
|
|
G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_EXPLOSION1);
|
|
gi.WritePosition (point);
|
|
gi.multicast (point, MULTICAST_ALL);
|
|
ThrowSmallStuff (self, point);
|
|
|
|
ThrowWidowGibSized (self, "models/monsters/blackwidow/gib1/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
|
|
ThrowWidowGibSized (self, "models/monsters/blackwidow/gib2/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
|
|
|
|
VectorSet (offset, -1.04, -51.18, 7.04);
|
|
G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_EXPLOSION1);
|
|
gi.WritePosition (point);
|
|
gi.multicast (point, MULTICAST_ALL);
|
|
ThrowSmallStuff (self, point);
|
|
|
|
ThrowWidowGibSized (self, "models/monsters/blackwidow/gib1/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
|
|
ThrowWidowGibSized (self, "models/monsters/blackwidow/gib2/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
|
|
ThrowWidowGibSized (self, "models/monsters/blackwidow/gib3/tris.md2", 80 + (int)(random()*20.0), GIB_METALLIC, point, 0, true);
|
|
|
|
G_FreeEdict (self);
|
|
return;
|
|
}
|
|
if ((level.time > (self->wait - 0.5)) && (self->count == 0))
|
|
{
|
|
self->count = 1;
|
|
AngleVectors (self->s.angles, f, r, u);
|
|
|
|
VectorSet (offset, 31, -88.7, 10.96);
|
|
G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_EXPLOSION1);
|
|
gi.WritePosition (point);
|
|
gi.multicast (point, MULTICAST_ALL);
|
|
// ThrowSmallStuff (self, point);
|
|
|
|
VectorSet (offset, -12.67, -4.39, 15.68);
|
|
G_ProjectSource2 (self->s.origin, offset, f, r, u, point);
|
|
gi.WriteByte (svc_temp_entity);
|
|
gi.WriteByte (TE_EXPLOSION1);
|
|
gi.WritePosition (point);
|
|
gi.multicast (point, MULTICAST_ALL);
|
|
// ThrowSmallStuff (self, point);
|
|
|
|
self->nextthink = level.time + FRAMETIME;
|
|
return;
|
|
}
|
|
self->nextthink = level.time + FRAMETIME;
|
|
}
|
|
|
|
void Widowlegs_Spawn (vec3_t startpos, vec3_t angles)
|
|
{
|
|
edict_t *ent;
|
|
|
|
ent = G_Spawn();
|
|
VectorCopy(startpos, ent->s.origin);
|
|
VectorCopy(angles, ent->s.angles);
|
|
ent->solid = SOLID_NOT;
|
|
ent->s.renderfx = RF_IR_VISIBLE;
|
|
ent->movetype = MOVETYPE_NONE;
|
|
ent->classname = "widowlegs";
|
|
|
|
ent->s.modelindex = gi.modelindex("models/monsters/legs/tris.md2");
|
|
ent->think = widowlegs_think;
|
|
|
|
ent->nextthink = level.time + FRAMETIME;
|
|
gi.linkentity (ent);
|
|
}
|
|
|
|
// Hud toggle ripped from TPP source
|
|
|
|
int nohud = 0;
|
|
|
|
void Hud_On()
|
|
{
|
|
if (deathmatch->value)
|
|
gi.configstring (CS_STATUSBAR, dm_statusbar);
|
|
else
|
|
gi.configstring (CS_STATUSBAR, single_statusbar);
|
|
nohud = 0;
|
|
}
|
|
|
|
void Hud_Off()
|
|
{
|
|
gi.configstring (CS_STATUSBAR, NULL);
|
|
nohud = 1;
|
|
}
|
|
|
|
void Cmd_ToggleHud ()
|
|
{
|
|
if (deathmatch->value)
|
|
return;
|
|
if (nohud)
|
|
Hud_On();
|
|
else
|
|
Hud_Off();
|
|
} |