{
self.event_damage = func_null;
- sound(self, CH_SHOTS, "weapons/grenade_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("grenade_impact"), VOL_BASE, ATTEN_NORM);
self.realowner.mage_spike = world;
void mage_push()
{
- sound(self, CH_SHOTS, "weapons/tagexp1.wav", 1, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("tagexp1"), 1, ATTEN_NORM);
RadiusDamage (self, self, (autocvar_g_monster_mage_attack_push_damage), (autocvar_g_monster_mage_attack_push_damage), (autocvar_g_monster_mage_attack_push_radius), world, world, (autocvar_g_monster_mage_attack_push_force), DEATH_MONSTER_MAGE, self.enemy);
Send_Effect("TE_EXPLOSION", self.origin, '0 0 0', 1);
case MR_PRECACHE:
{
precache_model("models/monsters/mage.dpm");
- precache_sound ("weapons/grenade_impact.wav");
+ precache_sound (W_Sound("grenade_impact"));
precache_sound ("weapons/tagexp1.wav");
return true;
}
{
makevectors(self.angles);
Send_Effect("explosion_medium", (self.origin + (v_forward * 150)) - ('0 0 1' * self.maxs.z), '0 0 0', 1);
- sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
tracebox(self.origin + v_forward * 50, self.mins * 0.5, self.maxs * 0.5, self.origin + v_forward * 500, MOVE_NORMAL, self);
{
entity head;
- sound(self, CH_SHOTS, "weapons/electro_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("electro_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("electro_impact", '0 0 0', '0 0 0', 1);
self.event_damage = func_null;
{
monster_makevectors(self.enemy);
- sound(self, CH_SHOTS, "weapons/electro_fire2.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("electro_fire2"), VOL_BASE, ATTEN_NORM);
entity proj = spawn ();
proj.classname = "plasma";
case MR_PRECACHE:
{
precache_model("models/monsters/spider.dpm");
- precache_sound ("weapons/electro_fire2.wav");
+ precache_sound (W_Sound("electro_fire2"));
return true;
}
}
precache_model ("models/turrets/c512.md3");
precache_model ("models/marker.md3");
+#ifdef SVQC
+ precache_sound(W_Sound("rocket_impact"));
+#endif
+
#ifdef TURRET_DEBUG
precache_model ("models/turrets/c512.md3");
precache_model ("models/pathlib/goodsquare.md3");
{
turret_do_updates(self);
- _mis = turret_projectile("weapons/lasergun_fire.wav", 1, 0, DEATH_TURRET_EWHEEL, PROJECTILE_BLASTER, TRUE, TRUE);
+ _mis = turret_projectile(W_Sound("lasergun_fire"), 1, 0, DEATH_TURRET_EWHEEL, PROJECTILE_BLASTER, TRUE, TRUE);
_mis.missile_flags = MIF_SPLASH;
Send_Effect("laser_muzzleflash", self.tur_shotorg, self.tur_shotdir_updated * 1000, 1);
turret_tag_fire_update();
- proj = turret_projectile("weapons/hagar_fire.wav", 5, 0, DEATH_TURRET_FLAC, PROJECTILE_HAGAR, TRUE, TRUE);
+ proj = turret_projectile(W_Sound("hagar_fire"), 5, 0, DEATH_TURRET_FLAC, PROJECTILE_HAGAR, TRUE, TRUE);
Send_Effect("laser_muzzleflash", self.tur_shotorg, self.tur_shotdir_updated * 1000, 1);
proj.think = turret_flac_projectile_think_explode;
proj.nextthink = time + self.tur_impacttime + (random() * 0.01 - random() * 0.01);
else
self.tur_shotorg = gettaginfo(self.tur_head, gettagindex(self.tur_head, "tag_fire2"));
- missile = turret_projectile("weapons/rocket_fire.wav", 6, 10, DEATH_TURRET_HELLION, PROJECTILE_ROCKET, FALSE, FALSE);
+ missile = turret_projectile(W_Sound("rocket_fire"), 6, 10, DEATH_TURRET_HELLION, PROJECTILE_ROCKET, FALSE, FALSE);
te_explosion (missile.origin);
missile.think = turret_hellion_missile_think;
missile.nextthink = time;
{
entity missile;
- missile = turret_projectile("weapons/rocket_fire.wav", 6, 10, DEATH_TURRET_HK, PROJECTILE_ROCKET, FALSE, FALSE);
+ missile = turret_projectile(W_Sound("rocket_fire"), 6, 10, DEATH_TURRET_HK, PROJECTILE_ROCKET, FALSE, FALSE);
te_explosion (missile.origin);
missile.think = turret_hk_missile_think;
{
precache_model ("models/turrets/base.md3");
precache_model ("models/turrets/machinegun.md3");
- precache_sound ("weapons/uzi_fire.wav");
+ precache_sound (W_Sound("uzi_fire"));
return true;
}
}
entity missile;
turret_tag_fire_update();
- missile = turret_projectile("weapons/rocket_fire.wav", 6, 10, DEATH_TURRET_MLRS, PROJECTILE_ROCKET, TRUE, TRUE);
+ missile = turret_projectile(W_Sound("rocket_fire"), 6, 10, DEATH_TURRET_MLRS, PROJECTILE_ROCKET, TRUE, TRUE);
missile.nextthink = time + max(self.tur_impacttime,(self.shot_radius * 2) / self.shot_speed);
missile.missile_flags = MIF_SPLASH;
te_explosion (missile.origin);
setattachment(beam,self.tur_head,"tag_fire");
- soundat (self, trace_endpos, CH_SHOTS, "weapons/neximpact.wav", VOL_BASE, ATTEN_NORM);
+ soundat (self, trace_endpos, CH_SHOTS, W_Sound("neximpact"), VOL_BASE, ATTEN_NORM);
if (self.tur_head.frame == 0)
self.tur_head.frame = 1;
}
else
{
- entity missile = turret_projectile("weapons/hagar_fire.wav", 1, 0, DEATH_TURRET_PLASMA, PROJECTILE_ELECTRO_BEAM, TRUE, TRUE);
+ entity missile = turret_projectile(W_Sound("hagar_fire"), 1, 0, DEATH_TURRET_PLASMA, PROJECTILE_ELECTRO_BEAM, TRUE, TRUE);
missile.missile_flags = MIF_SPLASH;
Send_Effect("laser_muzzleflash", self.tur_shotorg, self.tur_shotdir_updated * 1000, 1);
}
else
{
- entity missile = turret_projectile("weapons/hagar_fire.wav", 1, 0, DEATH_TURRET_PLASMA, PROJECTILE_ELECTRO_BEAM, TRUE, TRUE);
+ entity missile = turret_projectile(W_Sound("hagar_fire"), 1, 0, DEATH_TURRET_PLASMA, PROJECTILE_ELECTRO_BEAM, TRUE, TRUE);
missile.missile_flags = MIF_SPLASH;
Send_Effect("laser_muzzleflash", self.tur_shotorg, self.tur_shotdir_updated * 1000, 1);
self.tur_head.frame += 1;
rocket = spawn ();
setorigin(rocket, org);
- sound (self, CH_WEAPON_A, "weapons/hagar_fire.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_WEAPON_A, W_Sound("hagar_fire"), VOL_BASE, ATTEN_NORM);
setsize (rocket, '-3 -3 -3', '3 3 3'); // give it some size so it can be shot
rocket.classname = "walker_rocket";
{
case TR_ATTACK:
{
- sound (self, CH_WEAPON_A, "weapons/uzi_fire.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_WEAPON_A, W_Sound("uzi_fire"), VOL_BASE, ATTEN_NORM);
fireBullet (self.tur_shotorg, self.tur_shotdir_updated, self.shot_spread, 0, self.shot_dmg, self.shot_force, DEATH_TURRET_WALK_GUN, 0);
Send_Effect("laser_muzzleflash", self.tur_shotorg, self.tur_shotdir_updated * 1000, 1);
precache_model ("models/turrets/walker_body.md3");
precache_model ("models/turrets/walker_head_minigun.md3");
precache_model ("models/turrets/rocket.md3");
- precache_sound ("weapons/rocket_impact.wav");
+ precache_sound (W_Sound("rocket_impact"));
return true;
}
}
void vehicles_gib_explode()
{
- sound (self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("explosion_small", randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
Send_Effect("explosion_small", self.wp00.origin + '0 0 64', '0 0 0', 1);
remove(self);
void bumblebee_fire_cannon(entity _gun, string _tagname, entity _owner)
{
vector v = gettaginfo(_gun, gettagindex(_gun, _tagname));
- vehicles_projectile("bigplasma_muzzleflash", "weapons/flacexp3.wav",
+ vehicles_projectile("bigplasma_muzzleflash", W_Sound("flacexp3"),
v, normalize(v_forward + randomvec() * autocvar_g_vehicle_bumblebee_cannon_spread) * autocvar_g_vehicle_bumblebee_cannon_speed,
autocvar_g_vehicle_bumblebee_cannon_damage, autocvar_g_vehicle_bumblebee_cannon_radius, autocvar_g_vehicle_bumblebee_cannon_force, 0,
DEATH_VH_BUMB_GUN, PROJECTILE_BUMBLE_GUN, 0, true, true, _owner);
autocvar_g_vehicle_bumblebee_blowup_forceintensity,
DEATH_VH_BUMB_DEATH, world);
- sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("explosion_big", (self.origin + '0 0 100') + (randomvec() * 80), '0 0 0', 1);
if(self.owner.deadflag == DEAD_DYING)
if(random() < 0.1)
{
- sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("explosion_small", randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
}
entity bolt;
v = gettaginfo(self, gettagindex(self, tagname));
- bolt = vehicles_projectile("wakizashi_gun_muzzleflash", "weapons/lasergun_fire.wav",
+ bolt = vehicles_projectile("wakizashi_gun_muzzleflash", W_Sound("lasergun_fire"),
v, normalize(v_forward + randomvec() * autocvar_g_vehicle_racer_cannon_spread) * autocvar_g_vehicle_racer_cannon_speed,
autocvar_g_vehicle_racer_cannon_damage, autocvar_g_vehicle_racer_cannon_radius, autocvar_g_vehicle_racer_cannon_force, 0,
DEATH_VH_WAKI_GUN, PROJECTILE_WAKICANNON, 0, true, true, self.owner);
void racer_fire_rocket(string tagname, entity trg)
{
vector v = gettaginfo(self, gettagindex(self, tagname));
- entity rocket = vehicles_projectile("wakizashi_rocket_launch", "weapons/rocket_fire.wav",
+ entity rocket = vehicles_projectile("wakizashi_rocket_launch", W_Sound("rocket_fire"),
v, v_forward * autocvar_g_vehicle_racer_rocket_speed,
autocvar_g_vehicle_racer_rocket_damage, autocvar_g_vehicle_racer_rocket_radius, autocvar_g_vehicle_racer_rocket_force, 3,
DEATH_VH_WAKI_ROCKET, PROJECTILE_WAKIROCKET, 20, false, false, self.owner);
case VR_PRECACHE:
{
#ifdef SVQC
- precache_sound ("weapons/lasergun_fire.wav");
- precache_sound ("weapons/rocket_fire.wav");
+ precache_sound (W_Sound("lasergun_fire"));
+ precache_sound (W_Sound("rocket_fire"));
precache_sound ("vehicles/racer_idle.wav");
precache_sound ("vehicles/racer_move.wav");
void raptor_fire_cannon(entity gun, string tagname)
{
- vehicles_projectile("raptor_cannon_muzzleflash", "weapons/lasergun_fire.wav",
+ vehicles_projectile("raptor_cannon_muzzleflash", W_Sound("lasergun_fire"),
gettaginfo(gun, gettagindex(gun, tagname)), normalize(v_forward + randomvec() * autocvar_g_vehicle_raptor_cannon_spread) * autocvar_g_vehicle_raptor_cannon_speed,
autocvar_g_vehicle_raptor_cannon_damage, autocvar_g_vehicle_raptor_cannon_radius, autocvar_g_vehicle_raptor_cannon_force, 0,
DEATH_VH_RAPT_CANNON, PROJECTILE_RAPTORCANNON, 0, true, true, self.owner);
if(random() < 0.05)
{
- sound (self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("explosion_small", randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
}
self.nextthink = time;
switch(self.vehicle_weapon2mode)
{
case SBRM_VOLLY:
- rocket = vehicles_projectile("spiderbot_rocket_launch", "weapons/rocket_fire.wav",
+ rocket = vehicles_projectile("spiderbot_rocket_launch", W_Sound("rocket_fire"),
v, normalize(randomvec() * autocvar_g_vehicle_spiderbot_rocket_spread + v_forward) * autocvar_g_vehicle_spiderbot_rocket_speed,
autocvar_g_vehicle_spiderbot_rocket_damage, autocvar_g_vehicle_spiderbot_rocket_radius, autocvar_g_vehicle_spiderbot_rocket_force, 1,
DEATH_VH_SPID_ROCKET, PROJECTILE_SPIDERROCKET, autocvar_g_vehicle_spiderbot_rocket_health, false, true, self.owner);
self.wait = -10;
break;
case SBRM_GUIDE:
- rocket = vehicles_projectile("spiderbot_rocket_launch", "weapons/rocket_fire.wav",
+ rocket = vehicles_projectile("spiderbot_rocket_launch", W_Sound("rocket_fire"),
v, normalize(v_forward) * autocvar_g_vehicle_spiderbot_rocket_speed,
autocvar_g_vehicle_spiderbot_rocket_damage, autocvar_g_vehicle_spiderbot_rocket_radius, autocvar_g_vehicle_spiderbot_rocket_force, 1,
DEATH_VH_SPID_ROCKET, PROJECTILE_SPIDERROCKET, autocvar_g_vehicle_spiderbot_rocket_health, false, false, self.owner);
break;
case SBRM_ARTILLERY:
- rocket = vehicles_projectile("spiderbot_rocket_launch", "weapons/rocket_fire.wav",
+ rocket = vehicles_projectile("spiderbot_rocket_launch", W_Sound("rocket_fire"),
v, normalize(v_forward) * autocvar_g_vehicle_spiderbot_rocket_speed,
autocvar_g_vehicle_spiderbot_rocket_damage, autocvar_g_vehicle_spiderbot_rocket_radius, autocvar_g_vehicle_spiderbot_rocket_force, 1,
DEATH_VH_SPID_ROCKET, PROJECTILE_SPIDERROCKET, autocvar_g_vehicle_spiderbot_rocket_health, false, true, self.owner);
fireBullet(v, v_forward, autocvar_g_vehicle_spiderbot_minigun_spread, autocvar_g_vehicle_spiderbot_minigun_solidpenetration,
autocvar_g_vehicle_spiderbot_minigun_damage, autocvar_g_vehicle_spiderbot_minigun_force, DEATH_VH_SPID_MINIGUN, 0);
- sound (gun, CH_WEAPON_A, "weapons/uzi_fire.wav", VOL_BASE, ATTEN_NORM);
+ sound (gun, CH_WEAPON_A, W_Sound("uzi_fire"), VOL_BASE, ATTEN_NORM);
//trailparticles(self, particleeffectnum("spiderbot_minigun_trail"), v, trace_endpos);
pointparticles(particleeffectnum("spiderbot_minigun_muzzleflash"), v, v_forward * 2500, 1);
{
if(self.alpha > 0.1)
{
- sound (self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("explosion_big", self.origin + '0 0 100', '0 0 0', 1);
}
remove(self);
{
if(random() < 0.1)
{
- sound (self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("explosion_small", randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
}
self.nextthink = time + 0.1;
precache_model ("models/vehicles/spiderbot_cockpit.dpm");
precache_model ( "models/uziflash.md3");
- precache_sound ("weapons/uzi_fire.wav" );
- precache_sound ("weapons/rocket_impact.wav");
+ precache_sound (W_Sound("uzi_fire") );
+ precache_sound (W_Sound("rocket_impact"));
precache_sound ("vehicles/spiderbot_die.wav");
precache_sound ("vehicles/spiderbot_idle.wav");
}
}
#endif
+
+#ifdef SVQC
+string W_Sound(string w_snd)
+{
+ string output = strcat("weapons/", w_snd, ".wav");
+ MUTATOR_CALLHOOK(WeaponSound, w_snd, output);
+ return output;
+}
+
+string W_Model(string w_mdl)
+{
+ string output = strcat("models/weapons/", w_mdl);
+ MUTATOR_CALLHOOK(WeaponModel, w_mdl, output);
+ return output;
+}
+#endif
+
#endif
int GetAmmoStat(.int ammotype);
#endif
+#ifdef SVQC
+string W_Sound(string w_snd);
+string W_Model(string w_mdl);
+#endif
+
// ammo types
.int ammo_shells;
.int ammo_nails;
{
Send_Effect("arc_overheat",
self.beam_start, self.beam_wantdir, 1 );
- sound(self, CH_WEAPON_A, "weapons/arc_stop.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_A, W_Sound("arc_stop"), VOL_BASE, ATTN_NORM);
}
}
// only play fire sound if 1 sec has passed since player let go the fire button
if(time - self.beam_prev > 1)
- {
- sound(self, CH_WEAPON_A, "weapons/arc_fire.wav", VOL_BASE, ATTN_NORM);
- }
+ sound(self, CH_WEAPON_A, W_Sound("arc_fire"), VOL_BASE, ATTN_NORM);
entity beam = self.arc_beam = spawn();
beam.classname = "W_Arc_Beam";
if ( !self.arc_smoke_sound )
{
self.arc_smoke_sound = 1;
- sound(self, CH_SHOTS_SINGLE, "weapons/arc_loop_overheat.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_SHOTS_SINGLE, W_Sound("arc_loop_overheat"), VOL_BASE, ATTN_NORM);
}
}
}
if(self.arc_BUTTON_ATCK_prev != 0)
{
- sound(self, CH_WEAPON_A, "weapons/arc_stop.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_A, W_Sound("arc_stop"), VOL_BASE, ATTN_NORM);
weapon_thinkf(WFRAME_FIRE1, WEP_CVAR(arc, beam_animtime), w_ready);
ATTACK_FINISHED(self) = time + WEP_CVAR(arc, beam_refire) * W_WeaponRateFactor();
}
}
case WR_INIT:
{
- precache_model("models/weapons/g_arc.md3");
- precache_model("models/weapons/v_arc.md3");
- precache_model("models/weapons/h_arc.iqm");
- precache_sound("weapons/arc_fire.wav");
- precache_sound("weapons/arc_loop.wav");
- precache_sound("weapons/arc_stop.wav");
- precache_sound("weapons/arc_loop_overheat.wav");
+ precache_model(W_Model("g_arc.md3"));
+ precache_model(W_Model("v_arc.md3"));
+ precache_model(W_Model("h_arc.iqm"));
+ precache_sound(W_Sound("arc_fire"));
+ precache_sound(W_Sound("arc_loop"));
+ precache_sound(W_Sound("arc_stop"));
+ precache_sound(W_Sound("arc_loop_overheat"));
if(!arc_shotorigin[0])
{
arc_shotorigin[0] = shotorg_adjust_values(CL_Weapon_GetShotOrg(WEP_ARC.m_id), false, false, 1);
{
vector s_forward = v_forward * cos(atk_shotangle * DEG2RAD) + v_up * sin(atk_shotangle * DEG2RAD);
- W_SetupShot_Dir(self, s_forward, false, 3, "weapons/lasergun_fire.wav", CH_WEAPON_B, atk_damage);
+ W_SetupShot_Dir(self, s_forward, false, 3, W_Sound("lasergun_fire"), CH_WEAPON_B, atk_damage);
Send_Effect("laser_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
entity missile = spawn();
case WR_INIT:
{
- precache_model("models/weapons/g_laser.md3");
- precache_model("models/weapons/v_laser.md3");
- precache_model("models/weapons/h_laser.iqm");
- precache_sound("weapons/lasergun_fire.wav");
+ precache_model(W_Model("g_laser.md3"));
+ precache_model(W_Model("v_laser.md3"));
+ precache_model(W_Model("h_laser.iqm"));
+ precache_sound(W_Sound("lasergun_fire"));
BLASTER_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
if(WEP_CVAR_PRI(crylink, joinexplode))
maxdmg += WEP_CVAR_PRI(crylink, joinexplode_damage);
- W_SetupShot(self, false, 2, "weapons/crylink_fire.wav", CH_WEAPON_A, maxdmg);
+ W_SetupShot(self, false, 2, W_Sound("crylink_fire"), CH_WEAPON_A, maxdmg);
forward = v_forward;
right = v_right;
up = v_up;
if(WEP_CVAR_SEC(crylink, joinexplode))
maxdmg += WEP_CVAR_SEC(crylink, joinexplode_damage);
- W_SetupShot(self, false, 2, "weapons/crylink_fire2.wav", CH_WEAPON_A, maxdmg);
+ W_SetupShot(self, false, 2, W_Sound("crylink_fire2"), CH_WEAPON_A, maxdmg);
forward = v_forward;
right = v_right;
up = v_up;
}
case WR_INIT:
{
- precache_model("models/weapons/g_crylink.md3");
- precache_model("models/weapons/v_crylink.md3");
- precache_model("models/weapons/h_crylink.iqm");
- precache_sound("weapons/crylink_fire.wav");
- precache_sound("weapons/crylink_fire2.wav");
- precache_sound("weapons/crylink_linkjoin.wav");
+ precache_model(W_Model("g_crylink.md3"));
+ precache_model(W_Model("v_crylink.md3"));
+ precache_model(W_Model("h_crylink.iqm"));
+ precache_sound(W_Sound("crylink_fire"));
+ precache_sound(W_Sound("crylink_fire2"));
+ precache_sound(W_Sound("crylink_linkjoin"));
CRYLINK_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(min(WEP_CVAR_PRI(crylink, ammo), WEP_CVAR_SEC(crylink, ammo)), "weapons/reload.wav");
+ W_Reload(min(WEP_CVAR_PRI(crylink, ammo), WEP_CVAR_SEC(crylink, ammo)), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
{
Send_Effect("rocket_guide", self.origin, self.velocity, 1);
// TODO add a better sound here
- sound(self.realowner, CH_WEAPON_B, "weapons/rocket_mode.wav", VOL_BASE, ATTN_NORM);
+ sound(self.realowner, CH_WEAPON_B, W_Sound("rocket_mode"), VOL_BASE, ATTN_NORM);
self.count = 1;
}
}
W_DecreaseAmmo(WEP_CVAR(devastator, ammo));
- W_SetupShot_ProjectileSize(self, '-3 -3 -3', '3 3 3', false, 5, "weapons/rocket_fire.wav", CH_WEAPON_A, WEP_CVAR(devastator, damage));
+ W_SetupShot_ProjectileSize(self, '-3 -3 -3', '3 3 3', false, 5, W_Sound("rocket_fire"), CH_WEAPON_A, WEP_CVAR(devastator, damage));
Send_Effect("rocketlauncher_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
missile = WarpZone_RefSys_SpawnSameRefSys(self);
}
}
if(rockfound)
- sound(self, CH_WEAPON_B, "weapons/rocket_det.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_B, W_Sound("rocket_det"), VOL_BASE, ATTN_NORM);
}
}
//if(autocvar_sv_precacheweapons)
//{
precache_model("models/flash.md3");
- precache_model("models/weapons/g_rl.md3");
- precache_model("models/weapons/v_rl.md3");
- precache_model("models/weapons/h_rl.iqm");
- precache_sound("weapons/rocket_det.wav");
- precache_sound("weapons/rocket_fire.wav");
- precache_sound("weapons/rocket_mode.wav");
+ precache_model(W_Model("g_rl.md3"));
+ precache_model(W_Model("v_rl.md3"));
+ precache_model(W_Model("h_rl.iqm"));
+ precache_sound(W_Sound("rocket_det"));
+ precache_sound(W_Sound("rocket_fire"));
+ precache_sound(W_Sound("rocket_mode"));
//}
DEVASTATOR_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
case WR_RELOAD:
{
- W_Reload(WEP_CVAR(devastator, ammo), "weapons/reload.wav");
+ W_Reload(WEP_CVAR(devastator, ammo), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
'0 0 -3',
false,
2,
- "weapons/electro_fire.wav",
+ W_Sound("electro_fire"),
CH_WEAPON_A,
WEP_CVAR_PRI(electro, damage)
);
else
{
//UpdateCSQCProjectile(self);
- spamsound(self, CH_SHOTS, "weapons/electro_bounce.wav", VOL_BASE, ATTEN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("electro_bounce"), VOL_BASE, ATTEN_NORM);
self.projectiledeathtype |= HITTYPE_BOUNCE;
}
}
'0 0 -4',
false,
2,
- "weapons/electro_fire2.wav",
+ W_Sound("electro_fire2"),
CH_WEAPON_A,
WEP_CVAR_SEC(electro, damage)
);
}
case WR_INIT:
{
- precache_model("models/weapons/g_electro.md3");
- precache_model("models/weapons/v_electro.md3");
- precache_model("models/weapons/h_electro.iqm");
- precache_sound("weapons/electro_bounce.wav");
- precache_sound("weapons/electro_fire.wav");
- precache_sound("weapons/electro_fire2.wav");
- precache_sound("weapons/electro_impact.wav");
- precache_sound("weapons/electro_impact_combo.wav");
+ precache_model(W_Model("g_electro.md3"));
+ precache_model(W_Model("v_electro.md3"));
+ precache_model(W_Model("h_electro.iqm"));
+ precache_sound(W_Sound("electro_bounce"));
+ precache_sound(W_Sound("electro_fire"));
+ precache_sound(W_Sound("electro_fire2"));
+ precache_sound(W_Sound("electro_impact"));
+ precache_sound(W_Sound("electro_impact_combo"));
ELECTRO_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(min(WEP_CVAR_PRI(electro, ammo), WEP_CVAR_SEC(electro, ammo)), "weapons/reload.wav");
+ W_Reload(min(WEP_CVAR_PRI(electro, ammo), WEP_CVAR_SEC(electro, ammo)), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
{
entity proj;
- W_SetupShot_ProjectileSize(self, '-16 -16 -16', '16 16 16', false, 2, "weapons/fireball_fire2.wav", CH_WEAPON_A, WEP_CVAR_PRI(fireball, damage) + WEP_CVAR_PRI(fireball, bfgdamage));
+ W_SetupShot_ProjectileSize(self, '-16 -16 -16', '16 16 16', false, 2, W_Sound("fireball_fire2"), CH_WEAPON_A, WEP_CVAR_PRI(fireball, damage) + WEP_CVAR_PRI(fireball, bfgdamage));
Send_Effect("fireball_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
void W_Fireball_Attack1_Frame0(void)
{
W_Fireball_AttackEffect(0, '-1.25 -3.75 0');
- sound(self, CH_WEAPON_SINGLE, "weapons/fireball_prefire2.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_WEAPON_SINGLE, W_Sound("fireball_prefire2"), VOL_BASE, ATTEN_NORM);
weapon_thinkf(WFRAME_FIRE1, WEP_CVAR_PRI(fireball, animtime), W_Fireball_Attack1_Frame1);
}
f_diff = '+1.25 +3.75 0';
break;
}
- W_SetupShot_ProjectileSize(self, '-4 -4 -4', '4 4 4', false, 2, "weapons/fireball_fire.wav", CH_WEAPON_A, WEP_CVAR_SEC(fireball, damage));
- traceline(w_shotorg, w_shotorg + f_diff.x * v_up + f_diff.y * v_right, MOVE_NORMAL, self);
+ W_SetupShot_ProjectileSize(self, '-4 -4 -4', '4 4 4', false, 2, W_Sound("fireball_fire"), CH_WEAPON_A, WEP_CVAR_SEC(fireball, damage));
+ traceline(w_shotorg, w_shotorg + f_diff_x * v_up + f_diff_y * v_right, MOVE_NORMAL, self);
w_shotorg = trace_endpos;
Send_Effect("fireball_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
}
case WR_INIT:
{
- precache_model("models/weapons/g_fireball.md3");
- precache_model("models/weapons/v_fireball.md3");
- precache_model("models/weapons/h_fireball.iqm");
+ precache_model(W_Model("g_fireball.md3"));
+ precache_model(W_Model("v_fireball.md3"));
+ precache_model(W_Model("h_fireball.iqm"));
precache_model("models/sphere/sphere.md3");
- precache_sound("weapons/fireball_fire.wav");
- precache_sound("weapons/fireball_fire2.wav");
- precache_sound("weapons/fireball_prefire2.wav");
+ precache_sound(W_Sound("fireball_fire"));
+ precache_sound(W_Sound("fireball_fire2"));
+ precache_sound(W_Sound("fireball_prefire2"));
FIREBALL_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
W_DecreaseAmmo(WEP_CVAR_PRI(hagar, ammo));
- W_SetupShot(self, false, 2, "weapons/hagar_fire.wav", CH_WEAPON_A, WEP_CVAR_PRI(hagar, damage));
+ W_SetupShot(self, false, 2, W_Sound("hagar_fire"), CH_WEAPON_A, WEP_CVAR_PRI(hagar, damage));
Send_Effect("hagar_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
W_DecreaseAmmo(WEP_CVAR_SEC(hagar, ammo));
- W_SetupShot(self, false, 2, "weapons/hagar_fire.wav", CH_WEAPON_A, WEP_CVAR_SEC(hagar, damage));
+ W_SetupShot(self, false, 2, W_Sound("hagar_fire"), CH_WEAPON_A, WEP_CVAR_SEC(hagar, damage));
Send_Effect("hagar_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
weapon_prepareattack_do(1, WEP_CVAR_SEC(hagar, refire));
- W_SetupShot(self, false, 2, "weapons/hagar_fire.wav", CH_WEAPON_A, WEP_CVAR_SEC(hagar, damage));
+ W_SetupShot(self, false, 2, W_Sound("hagar_fire"), CH_WEAPON_A, WEP_CVAR_SEC(hagar, damage));
Send_Effect("hagar_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
forward = v_forward;
self.weaponentity.state = WS_READY;
W_DecreaseAmmo(WEP_CVAR_SEC(hagar, ammo) * self.hagar_load * -1); // give back ammo
self.hagar_load = 0;
- sound(self, CH_WEAPON_A, "weapons/hagar_beep.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_A, W_Sound("hagar_beep"), VOL_BASE, ATTN_NORM);
// pause until we can load rockets again, once we re-press the alt fire button
self.hagar_loadstep = time + WEP_CVAR_SEC(hagar, load_speed) * W_WeaponRateFactor();
W_DecreaseAmmo(WEP_CVAR_SEC(hagar, ammo));
self.weaponentity.state = WS_INUSE;
self.hagar_load += 1;
- sound(self, CH_WEAPON_B, "weapons/hagar_load.wav", VOL_BASE * 0.8, ATTN_NORM); // sound is too loud according to most
+ sound(self, CH_WEAPON_B, W_Sound("hagar_load"), VOL_BASE * 0.8, ATTN_NORM); // sound is too loud according to most
if(self.hagar_load >= WEP_CVAR_SEC(hagar, load_max))
self.hagar_loadstep = time + WEP_CVAR_SEC(hagar, load_hold) * W_WeaponRateFactor();
else if(!self.hagar_loadbeep && self.hagar_load) // prevents the beep from playing each frame
{
// if this is the last rocket we can load, play a beep sound to notify the player
- sound(self, CH_WEAPON_A, "weapons/hagar_beep.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_A, W_Sound("hagar_beep"), VOL_BASE, ATTN_NORM);
self.hagar_loadbeep = true;
}
}
if(!self.hagar_warning && self.hagar_load) // prevents the beep from playing each frame
{
// we're about to automatically release after holding time, play a beep sound to notify the player
- sound(self, CH_WEAPON_A, "weapons/hagar_beep.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_A, W_Sound("hagar_beep"), VOL_BASE, ATTN_NORM);
self.hagar_warning = true;
}
}
}
case WR_INIT:
{
- precache_model("models/weapons/g_hagar.md3");
- precache_model("models/weapons/v_hagar.md3");
- precache_model("models/weapons/h_hagar.iqm");
- precache_sound("weapons/hagar_fire.wav");
- precache_sound("weapons/hagar_load.wav");
- precache_sound("weapons/hagar_beep.wav");
+ precache_model(W_Model("g_hagar.md3"));
+ precache_model(W_Model("v_hagar.md3"));
+ precache_model(W_Model("h_hagar.iqm"));
+ precache_sound(W_Sound("hagar_fire"));
+ precache_sound(W_Sound("hagar_load"));
+ precache_sound(W_Sound("hagar_beep"));
HAGAR_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
case WR_RELOAD:
{
if(!self.hagar_load) // require releasing loaded rockets first
- W_Reload(min(WEP_CVAR_PRI(hagar, ammo), WEP_CVAR_SEC(hagar, ammo)), "weapons/reload.wav");
+ W_Reload(min(WEP_CVAR_PRI(hagar, ammo), WEP_CVAR_SEC(hagar, ammo)), W_Sound("reload"));
return true;
}
if(self.crouch)
spread = spread * WEP_CVAR_PRI(hlac, spread_crouchmod);
- W_SetupShot(self, false, 3, "weapons/lasergun_fire.wav", CH_WEAPON_A, WEP_CVAR_PRI(hlac, damage));
+ W_SetupShot(self, false, 3, W_Sound("lasergun_fire"), CH_WEAPON_A, WEP_CVAR_PRI(hlac, damage));
Send_Effect("laser_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
if(!autocvar_g_norecoil)
{
if(self.crouch)
spread = spread * WEP_CVAR_SEC(hlac, spread_crouchmod);
- W_SetupShot(self, false, 3, "weapons/lasergun_fire.wav", CH_WEAPON_A, WEP_CVAR_SEC(hlac, damage));
+ W_SetupShot(self, false, 3, W_Sound("lasergun_fire"), CH_WEAPON_A, WEP_CVAR_SEC(hlac, damage));
Send_Effect("laser_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
missile = spawn();
}
case WR_INIT:
{
- precache_model("models/weapons/g_hlac.md3");
- precache_model("models/weapons/v_hlac.md3");
- precache_model("models/weapons/h_hlac.iqm");
- precache_sound("weapons/lasergun_fire.wav");
+ precache_model(W_Model("g_hlac.md3"));
+ precache_model(W_Model("v_hlac.md3"));
+ precache_model(W_Model("h_hlac.iqm"));
+ precache_sound(W_Sound("lasergun_fire"));
HLAC_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(min(WEP_CVAR_PRI(hlac, ammo), WEP_CVAR_SEC(hlac, ammo)), "weapons/reload.wav");
+ W_Reload(min(WEP_CVAR_PRI(hlac, ammo), WEP_CVAR_SEC(hlac, ammo)), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
W_DecreaseAmmo(WEP_CVAR(hmg, ammo));
- W_SetupShot (self, true, 0, "weapons/uzi_fire.wav", CH_WEAPON_A, WEP_CVAR(hmg, damage));
+ W_SetupShot (self, true, 0, W_Sound("uzi_fire"), CH_WEAPON_A, WEP_CVAR(hmg, damage));
if(!autocvar_g_norecoil)
{
case WR_INIT:
{
precache_model ("models/uziflash.md3");
- precache_model ("models/weapons/g_ok_hmg.md3");
- precache_model ("models/weapons/v_ok_hmg.md3");
- precache_model ("models/weapons/h_ok_hmg.iqm");
- precache_sound ("weapons/uzi_fire.wav");
+ precache_model(W_Model("g_ok_hmg.md3"));
+ precache_model(W_Model("v_ok_hmg.md3"));
+ precache_model(W_Model("h_ok_hmg.iqm"));
+ precache_sound (W_Sound("uzi_fire"));
HMG_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(WEP_CVAR(hmg, ammo), "weapons/reload.wav");
+ W_Reload(WEP_CVAR(hmg, ammo), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
entity gren;
//W_DecreaseAmmo(WEP_CVAR_SEC(hook, ammo)); // WEAPONTODO: Figure out how to handle ammo with hook secondary (gravitybomb)
- W_SetupShot(self, false, 4, "weapons/hookbomb_fire.wav", CH_WEAPON_A, WEP_CVAR_SEC(hook, damage));
+ W_SetupShot(self, false, 4, W_Sound("hookbomb_fire"), CH_WEAPON_A, WEP_CVAR_SEC(hook, damage));
gren = spawn();
gren.owner = gren.realowner = self;
}
case WR_INIT:
{
- precache_model("models/weapons/g_hookgun.md3");
- precache_model("models/weapons/v_hookgun.md3");
- precache_model("models/weapons/h_hookgun.iqm");
- precache_sound("weapons/hook_impact.wav"); // done by g_hook.qc
- precache_sound("weapons/hook_fire.wav");
- precache_sound("weapons/hookbomb_fire.wav");
+ precache_model(W_Model("g_hookgun.md3"));
+ precache_model(W_Model("v_hookgun.md3"));
+ precache_model(W_Model("h_hookgun.iqm"));
+ precache_sound(W_Sound("hook_impact")); // done by g_hook.qc
+ precache_sound(W_Sound("hook_fire"));
+ precache_sound(W_Sound("hookbomb_fire"));
HOOK_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
void W_MachineGun_Attack(int deathtype)
{
- W_SetupShot(self, true, 0, "weapons/uzi_fire.wav", CH_WEAPON_A, ((self.misc_bulletcounter == 1) ? WEP_CVAR(machinegun, first_damage) : WEP_CVAR(machinegun, sustained_damage)));
+ W_SetupShot(self, true, 0, W_Sound("uzi_fire"), CH_WEAPON_A, ((self.misc_bulletcounter == 1) ? WEP_CVAR(machinegun, first_damage) : WEP_CVAR(machinegun, sustained_damage)));
if(!autocvar_g_norecoil)
{
self.punchangle_x = random() - 0.5;
W_DecreaseAmmo(WEP_CVAR(machinegun, sustained_ammo));
- W_SetupShot(self, true, 0, "weapons/uzi_fire.wav", CH_WEAPON_A, WEP_CVAR(machinegun, sustained_damage));
+ W_SetupShot(self, true, 0, W_Sound("uzi_fire"), CH_WEAPON_A, WEP_CVAR(machinegun, sustained_damage));
if(!autocvar_g_norecoil)
{
self.punchangle_x = random() - 0.5;
void W_MachineGun_Attack_Burst(void)
{
- W_SetupShot(self, true, 0, "weapons/uzi_fire.wav", CH_WEAPON_A, WEP_CVAR(machinegun, sustained_damage));
+ W_SetupShot(self, true, 0, W_Sound("uzi_fire"), CH_WEAPON_A, WEP_CVAR(machinegun, sustained_damage));
if(!autocvar_g_norecoil)
{
self.punchangle_x = random() - 0.5;
case WR_INIT:
{
precache_model("models/uziflash.md3");
- precache_model("models/weapons/g_uzi.md3");
- precache_model("models/weapons/v_uzi.md3");
- precache_model("models/weapons/h_uzi.iqm");
- precache_sound("weapons/uzi_fire.wav");
+ precache_model(W_Model("g_uzi.md3"));
+ precache_model(W_Model("v_uzi.md3"));
+ precache_model(W_Model("h_uzi.iqm"));
+ precache_sound(W_Sound("uzi_fire"));
MACHINEGUN_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
void W_MineLayer_Stick(entity to)
{
- spamsound(self, CH_SHOTS, "weapons/mine_stick.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("mine_stick"), VOL_BASE, ATTN_NORM);
// in order for mines to face properly when sticking to the ground, they must be a server side entity rather than a csqc projectile
if((time > self.cnt) && (!self.mine_time) && (self.cnt > 0))
{
if(WEP_CVAR(minelayer, lifetime_countdown) > 0)
- spamsound(self, CH_SHOTS, "weapons/mine_trigger.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("mine_trigger"), VOL_BASE, ATTN_NORM);
self.mine_time = time + WEP_CVAR(minelayer, lifetime_countdown);
self.mine_explodeanyway = 1; // make the mine super aggressive -- Samual: Rather, make it not care if a team mate is near.
}
if(head != self.realowner && DIFF_TEAM(head, self.realowner)) // don't trigger for team mates
if(!self.mine_time)
{
- spamsound(self, CH_SHOTS, "weapons/mine_trigger.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("mine_trigger"), VOL_BASE, ATTN_NORM);
self.mine_time = time + WEP_CVAR(minelayer, time);
}
head = head.chain;
{
// the refire delay keeps this message from being spammed
Send_Notification(NOTIF_ONE, self, MSG_MULTI, WEAPON_MINELAYER_LIMIT, WEP_CVAR(minelayer, limit));
- play2(self, "weapons/unavailable.wav");
+ play2(self, W_Sound("unavailable"));
return;
}
}
W_DecreaseAmmo(WEP_CVAR(minelayer, ammo));
- W_SetupShot_ProjectileSize(self, '-4 -4 -4', '4 4 4', false, 5, "weapons/mine_fire.wav", CH_WEAPON_A, WEP_CVAR(minelayer, damage));
+ W_SetupShot_ProjectileSize(self, '-4 -4 -4', '4 4 4', false, 5, W_Sound("mine_fire"), CH_WEAPON_A, WEP_CVAR(minelayer, damage));
Send_Effect("rocketlauncher_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
mine = WarpZone_RefSys_SpawnSameRefSys(self);
if(self.BUTTON_ATCK2)
{
if(W_MineLayer_PlacedMines(true))
- sound(self, CH_WEAPON_B, "weapons/mine_det.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_B, W_Sound("mine_det"), VOL_BASE, ATTN_NORM);
}
return true;
{
precache_model("models/flash.md3");
precache_model("models/mine.md3");
- precache_model("models/weapons/g_minelayer.md3");
- precache_model("models/weapons/v_minelayer.md3");
- precache_model("models/weapons/h_minelayer.iqm");
- precache_sound("weapons/mine_det.wav");
- precache_sound("weapons/mine_fire.wav");
- precache_sound("weapons/mine_stick.wav");
- precache_sound("weapons/mine_trigger.wav");
+ precache_model(W_Model("g_minelayer.md3"));
+ precache_model(W_Model("v_minelayer.md3"));
+ precache_model(W_Model("h_minelayer.iqm"));
+ precache_sound(W_Sound("mine_det"));
+ precache_sound(W_Sound("mine_fire"));
+ precache_sound(W_Sound("mine_stick"));
+ precache_sound(W_Sound("mine_trigger"));
MINELAYER_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(WEP_CVAR(minelayer, ammo), "weapons/reload.wav");
+ W_Reload(WEP_CVAR(minelayer, ammo), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
float r;
r = random() * 6;
if(r < 1)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce1.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce1"), VOL_BASE, ATTN_NORM);
else if(r < 2)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce2.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce2"), VOL_BASE, ATTN_NORM);
else if(r < 3)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce3.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce3"), VOL_BASE, ATTN_NORM);
else if(r < 4)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce4.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce4"), VOL_BASE, ATTN_NORM);
else if(r < 5)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce5.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce5"), VOL_BASE, ATTN_NORM);
else
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce6.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce6"), VOL_BASE, ATTN_NORM);
Send_Effect("hagar_bounce", self.origin, self.velocity, 1);
self.projectiledeathtype |= HITTYPE_BOUNCE;
self.gl_bouncecnt += 1;
}
else if(WEP_CVAR_PRI(mortar, type) == 2 && (!other || (other.takedamage != DAMAGE_AIM && other.movetype == MOVETYPE_NONE))) // stick
{
- spamsound(self, CH_SHOTS, "weapons/grenade_stick.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_stick"), VOL_BASE, ATTN_NORM);
// let it stick whereever it is
self.oldvelocity = self.velocity;
float r;
r = random() * 6;
if(r < 1)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce1.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce1"), VOL_BASE, ATTN_NORM);
else if(r < 2)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce2.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce2"), VOL_BASE, ATTN_NORM);
else if(r < 3)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce3.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce3"), VOL_BASE, ATTN_NORM);
else if(r < 4)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce4.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce4"), VOL_BASE, ATTN_NORM);
else if(r < 5)
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce5.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce5"), VOL_BASE, ATTN_NORM);
else
- spamsound(self, CH_SHOTS, "weapons/grenade_bounce6.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_bounce6"), VOL_BASE, ATTN_NORM);
Send_Effect("hagar_bounce", self.origin, self.velocity, 1);
self.projectiledeathtype |= HITTYPE_BOUNCE;
self.gl_bouncecnt += 1;
}
else if(WEP_CVAR_SEC(mortar, type) == 2 && (!other || (other.takedamage != DAMAGE_AIM && other.movetype == MOVETYPE_NONE))) // stick
{
- spamsound(self, CH_SHOTS, "weapons/grenade_stick.wav", VOL_BASE, ATTN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("grenade_stick"), VOL_BASE, ATTN_NORM);
// let it stick whereever it is
self.oldvelocity = self.velocity;
W_DecreaseAmmo(WEP_CVAR_PRI(mortar, ammo));
- W_SetupShot_ProjectileSize(self, '-3 -3 -3', '3 3 3', false, 4, "weapons/grenade_fire.wav", CH_WEAPON_A, WEP_CVAR_PRI(mortar, damage));
+ W_SetupShot_ProjectileSize(self, '-3 -3 -3', '3 3 3', false, 4, W_Sound("grenade_fire"), CH_WEAPON_A, WEP_CVAR_PRI(mortar, damage));
w_shotdir = v_forward; // no TrueAim for grenades please
Send_Effect("grenadelauncher_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
W_DecreaseAmmo(WEP_CVAR_SEC(mortar, ammo));
- W_SetupShot_ProjectileSize(self, '-3 -3 -3', '3 3 3', false, 4, "weapons/grenade_fire.wav", CH_WEAPON_A, WEP_CVAR_SEC(mortar, damage));
+ W_SetupShot_ProjectileSize(self, '-3 -3 -3', '3 3 3', false, 4, W_Sound("grenade_fire"), CH_WEAPON_A, WEP_CVAR_SEC(mortar, damage));
w_shotdir = v_forward; // no TrueAim for grenades please
Send_Effect("grenadelauncher_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
}
}
if(nadefound)
- sound(self, CH_WEAPON_B, "weapons/rocket_det.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_B, W_Sound("rocket_det"), VOL_BASE, ATTN_NORM);
}
else if(weapon_prepareattack(1, WEP_CVAR_SEC(mortar, refire)))
{
}
case WR_INIT:
{
- precache_model("models/weapons/g_gl.md3");
- precache_model("models/weapons/v_gl.md3");
- precache_model("models/weapons/h_gl.iqm");
- precache_sound("weapons/grenade_bounce1.wav");
- precache_sound("weapons/grenade_bounce2.wav");
- precache_sound("weapons/grenade_bounce3.wav");
- precache_sound("weapons/grenade_bounce4.wav");
- precache_sound("weapons/grenade_bounce5.wav");
- precache_sound("weapons/grenade_bounce6.wav");
- precache_sound("weapons/grenade_stick.wav");
- precache_sound("weapons/grenade_fire.wav");
+ precache_model(W_Model("g_gl.md3"));
+ precache_model(W_Model("v_gl.md3"));
+ precache_model(W_Model("h_gl.iqm"));
+ precache_sound(W_Sound("grenade_bounce1"));
+ precache_sound(W_Sound("grenade_bounce2"));
+ precache_sound(W_Sound("grenade_bounce3"));
+ precache_sound(W_Sound("grenade_bounce4"));
+ precache_sound(W_Sound("grenade_bounce5"));
+ precache_sound(W_Sound("grenade_bounce6"));
+ precache_sound(W_Sound("grenade_stick"));
+ precache_sound(W_Sound("grenade_fire"));
MORTAR_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(min(WEP_CVAR_PRI(mortar, ammo), WEP_CVAR_SEC(mortar, ammo)), "weapons/reload.wav"); // WEAPONTODO
+ W_Reload(min(WEP_CVAR_PRI(mortar, ammo), WEP_CVAR_SEC(mortar, ammo)), W_Sound("reload")); // WEAPONTODO
return true;
}
case WR_SUICIDEMESSAGE:
return true;
}
+ case WR_CHECKAMMO1:
+ case WR_CHECKAMMO2:
+ {
+ // always allow infinite ammo
+ return true;
+ }
case WR_INIT:
{
- precache_model("models/weapons/g_porto.md3");
- precache_model("models/weapons/v_porto.md3");
- precache_model("models/weapons/h_porto.iqm");
+ precache_model(W_Model("g_porto.md3"));
+ precache_model(W_Model("v_porto.md3"));
+ precache_model(W_Model("h_porto.iqm"));
precache_model("models/portal.md3");
precache_sound("porto/bounce.wav");
precache_sound("porto/create.wav");
void W_Rifle_Attack(void)
{
- W_Rifle_FireBullet(WEP_CVAR_PRI(rifle, spread), WEP_CVAR_PRI(rifle, damage), WEP_CVAR_PRI(rifle, force), WEP_CVAR_PRI(rifle, solidpenetration), WEP_CVAR_PRI(rifle, ammo), WEP_RIFLE.m_id, WEP_CVAR_PRI(rifle, tracer), WEP_CVAR_PRI(rifle, shots), "weapons/campingrifle_fire.wav");
+ W_Rifle_FireBullet(WEP_CVAR_PRI(rifle, spread), WEP_CVAR_PRI(rifle, damage), WEP_CVAR_PRI(rifle, force), WEP_CVAR_PRI(rifle, solidpenetration), WEP_CVAR_PRI(rifle, ammo), WEP_RIFLE.m_id, WEP_CVAR_PRI(rifle, tracer), WEP_CVAR_PRI(rifle, shots), W_Sound("campingrifle_fire"));
}
void W_Rifle_Attack2(void)
{
- W_Rifle_FireBullet(WEP_CVAR_SEC(rifle, spread), WEP_CVAR_SEC(rifle, damage), WEP_CVAR_SEC(rifle, force), WEP_CVAR_SEC(rifle, solidpenetration), WEP_CVAR_SEC(rifle, ammo), WEP_RIFLE.m_id | HITTYPE_SECONDARY, WEP_CVAR_SEC(rifle, tracer), WEP_CVAR_SEC(rifle, shots), "weapons/campingrifle_fire2.wav");
+ W_Rifle_FireBullet(WEP_CVAR_SEC(rifle, spread), WEP_CVAR_SEC(rifle, damage), WEP_CVAR_SEC(rifle, force), WEP_CVAR_SEC(rifle, solidpenetration), WEP_CVAR_SEC(rifle, ammo), WEP_RIFLE.m_id | HITTYPE_SECONDARY, WEP_CVAR_SEC(rifle, tracer), WEP_CVAR_SEC(rifle, shots), W_Sound("campingrifle_fire2"));
}
.void(void) rifle_bullethail_attackfunc;
}
case WR_INIT:
{
- precache_model("models/weapons/g_campingrifle.md3");
- precache_model("models/weapons/v_campingrifle.md3");
- precache_model("models/weapons/h_campingrifle.iqm");
- precache_sound("weapons/campingrifle_fire.wav");
- precache_sound("weapons/campingrifle_fire2.wav");
+ precache_model(W_Model("g_sniperrifle.md3"));
+ precache_model(W_Model("v_sniperrifle.md3"));
+ precache_model(W_Model("h_sniperrifle.iqm"));
+ precache_sound(W_Sound("campingrifle_fire"));
+ precache_sound(W_Sound("campingrifle_fire2"));
RIFLE_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(min(WEP_CVAR_PRI(rifle, ammo), WEP_CVAR_SEC(rifle, ammo)), "weapons/reload.wav");
+ W_Reload(min(WEP_CVAR_PRI(rifle, ammo), WEP_CVAR_SEC(rifle, ammo)), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
entity flash = spawn ();
W_DecreaseAmmo(WEP_CVAR(rpc, ammo));
- W_SetupShot_ProjectileSize (self, '-3 -3 -3', '3 3 3', false, 5, "weapons/rocket_fire.wav", CH_WEAPON_A, WEP_CVAR(rpc, damage));
+ W_SetupShot_ProjectileSize (self, '-3 -3 -3', '3 3 3', false, 5, W_Sound("rocket_fire"), CH_WEAPON_A, WEP_CVAR(rpc, damage));
Send_Effect("rocketlauncher_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
PROJECTILE_MAKETRIGGER(missile);
case WR_INIT:
{
precache_model ("models/flash.md3");
- precache_model("models/weapons/h_ok_rl.iqm");
- precache_model("models/weapons/v_ok_rl.md3");
- precache_model("models/weapons/g_ok_rl.md3");
- precache_sound ("weapons/rocket_fire.wav");
+ precache_model(W_Model("g_ok_rl.md3"));
+ precache_model(W_Model("v_ok_rl.md3"));
+ precache_model(W_Model("h_ok_rl.iqm"));
+ precache_sound (W_Sound("rocket_fire"));
RPC_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(WEP_CVAR(rpc, ammo), "weapons/reload.wav");
+ W_Reload(WEP_CVAR(rpc, ammo), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
W_DecreaseAmmo(WEP_CVAR(seeker, missile_ammo));
makevectors(self.v_angle);
- W_SetupShot_ProjectileSize(self, '-2 -2 -2', '2 2 2', false, 2, "weapons/seeker_fire.wav", CH_WEAPON_A, 0);
+ W_SetupShot_ProjectileSize(self, '-2 -2 -2', '2 2 2', false, 2, W_Sound("seeker_fire.wav"), CH_WEAPON_A, 0);
w_shotorg += f_diff;
Send_Effect("seeker_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
f_diff = '+1.25 +3.75 0';
break;
}
- W_SetupShot_ProjectileSize(self, '-2 -2 -2', '2 2 2', false, 2, "weapons/flac_fire.wav", CH_WEAPON_A, WEP_CVAR(seeker, flac_damage));
+ W_SetupShot_ProjectileSize(self, '-2 -2 -2', '2 2 2', false, 2, W_Sound("flac_fire"), CH_WEAPON_A, WEP_CVAR(seeker, flac_damage));
w_shotorg += f_diff;
Send_Effect("hagar_muzzleflash", w_shotorg, w_shotdir * 1000, 1);
entity missile;
W_DecreaseAmmo(WEP_CVAR(seeker, tag_ammo));
- W_SetupShot_ProjectileSize(self, '-2 -2 -2', '2 2 2', false, 2, "weapons/tag_fire.wav", CH_WEAPON_A, WEP_CVAR(seeker, missile_damage) * WEP_CVAR(seeker, missile_count));
+ W_SetupShot_ProjectileSize(self, '-2 -2 -2', '2 2 2', false, 2, W_Sound("tag_fire"), CH_WEAPON_A, WEP_CVAR(seeker, missile_damage) * WEP_CVAR(seeker, missile_count));
missile = spawn();
missile.owner = missile.realowner = self;
}
case WR_INIT:
{
- precache_model("models/weapons/g_seeker.md3");
- precache_model("models/weapons/v_seeker.md3");
- precache_model("models/weapons/h_seeker.iqm");
- precache_sound("weapons/tag_fire.wav");
- precache_sound("weapons/flac_fire.wav");
- precache_sound("weapons/seeker_fire.wav");
+ precache_model(W_Model("g_seeker.md3"));
+ precache_model(W_Model("v_seeker.md3"));
+ precache_model(W_Model("h_seeker.iqm"));
+ precache_sound(W_Sound("tag_fire"));
+ precache_sound(W_Sound("flac_fire"));
+ precache_sound(W_Sound("seeker_fire"));
SEEKER_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(min(WEP_CVAR(seeker, missile_ammo), WEP_CVAR(seeker, tag_ammo)), "weapons/reload.wav");
+ W_Reload(min(WEP_CVAR(seeker, missile_ammo), WEP_CVAR(seeker, tag_ammo)), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
void W_Shockwave_Melee(void)
{
- sound(self, CH_WEAPON_A, "weapons/shotgun_melee.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_A, W_Sound("shotgun_melee"), VOL_BASE, ATTN_NORM);
weapon_thinkf(WFRAME_FIRE2, WEP_CVAR(shockwave, melee_animtime), w_ready);
entity meleetemp;
float i, queue = 0;
// set up the shot direction
- W_SetupShot(self, false, 3, "weapons/lasergun_fire.wav", CH_WEAPON_B, WEP_CVAR(shockwave, blast_damage));
+ W_SetupShot(self, false, 3, W_Sound("lasergun_fire"), CH_WEAPON_B, WEP_CVAR(shockwave, blast_damage));
vector attack_endpos = (w_shotorg + (w_shotdir * WEP_CVAR(shockwave, blast_distance)));
WarpZone_TraceLine(w_shotorg, attack_endpos, MOVE_NOMONSTERS, self);
vector attack_hitpos = trace_endpos;
case WR_INIT:
{
precache_model("models/uziflash.md3");
- precache_model("models/weapons/g_shotgun.md3");
- precache_model("models/weapons/v_shotgun.md3");
- precache_model("models/weapons/h_shotgun.iqm");
+ precache_model(W_Model("g_shotgun.md3"));
+ precache_model(W_Model("v_shotgun.md3"));
+ precache_model(W_Model("h_shotgun.iqm"));
precache_sound("misc/itempickup.wav");
- precache_sound("weapons/lasergun_fire.wav");
- precache_sound("weapons/shotgun_melee.wav");
+ precache_sound(W_Sound("lasergun_fire"));
+ precache_sound(W_Sound("shotgun_melee"));
SHOCKWAVE_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
W_DecreaseAmmo(WEP_CVAR_PRI(shotgun, ammo));
- W_SetupShot(self, true, 5, "weapons/shotgun_fire.wav", ((isprimary) ? CH_WEAPON_A : CH_WEAPON_SINGLE), WEP_CVAR_PRI(shotgun, damage) * WEP_CVAR_PRI(shotgun, bullets));
+ W_SetupShot(self, true, 5, W_Sound("shotgun_fire"), ((isprimary) ? CH_WEAPON_A : CH_WEAPON_SINGLE), WEP_CVAR_PRI(shotgun, damage) * WEP_CVAR_PRI(shotgun, bullets));
for(sc = 0;sc < WEP_CVAR_PRI(shotgun, bullets);sc = sc + 1)
fireBullet(w_shotorg, w_shotdir, WEP_CVAR_PRI(shotgun, spread), WEP_CVAR_PRI(shotgun, solidpenetration), WEP_CVAR_PRI(shotgun, damage), WEP_CVAR_PRI(shotgun, force), WEP_SHOTGUN.m_id, 0);
void W_Shotgun_Attack2(void)
{
- sound(self, CH_WEAPON_A, "weapons/shotgun_melee.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_WEAPON_A, W_Sound("shotgun_melee"), VOL_BASE, ATTEN_NORM);
weapon_thinkf(WFRAME_FIRE2, WEP_CVAR_SEC(shotgun, animtime), w_ready);
entity meleetemp;
case WR_INIT:
{
precache_model("models/uziflash.md3");
- precache_model("models/weapons/g_shotgun.md3");
- precache_model("models/weapons/v_shotgun.md3");
- precache_model("models/weapons/h_shotgun.iqm");
+ precache_model(W_Model("g_shotgun.md3"));
+ precache_model(W_Model("v_shotgun.md3"));
+ precache_model(W_Model("h_shotgun.iqm"));
precache_sound("misc/itempickup.wav");
- precache_sound("weapons/shotgun_fire.wav");
- precache_sound("weapons/shotgun_melee.wav");
+ precache_sound(W_Sound("shotgun_fire"));
+ precache_sound(W_Sound("shotgun_melee"));
SHOTGUN_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(WEP_CVAR_PRI(shotgun, ammo), "weapons/reload.wav"); // WEAPONTODO
+ W_Reload(WEP_CVAR_PRI(shotgun, ammo), W_Sound("reload")); // WEAPONTODO
return true;
}
case WR_SUICIDEMESSAGE:
}
case WR_INIT:
{
- precache_model("models/weapons/g_tuba.md3");
- precache_model("models/weapons/v_tuba.md3");
- precache_model("models/weapons/h_tuba.iqm");
- precache_model("models/weapons/v_akordeon.md3");
- precache_model("models/weapons/h_akordeon.iqm");
- precache_model("models/weapons/v_kleinbottle.md3");
- precache_model("models/weapons/h_kleinbottle.iqm");
+ precache_model(W_Model("g_tuba.md3"));
+ precache_model(W_Model("v_tuba.md3"));
+ precache_model(W_Model("h_tuba.iqm"));
+ precache_model(W_Model("v_akordeon.md3"));
+ precache_model(W_Model("h_akordeon.iqm"));
+ precache_model(W_Model("v_kleinbottle.md3"));
+ precache_model(W_Model("h_kleinbottle.iqm"));
TUBA_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
W_SetupShot(self, true, 0, "", CH_WEAPON_A, 10000);
// handle sound separately so we can change the volume
// added bonus: no longer plays the strength sound (strength gives no bonus to instakill anyway)
- sound (self, CH_WEAPON_A, "weapons/minstanexfire.wav", VOL_BASE * 0.8, ATTEN_NORM);
+ sound (self, CH_WEAPON_A, W_Sound("minstanexfire"), VOL_BASE * 0.8, ATTEN_NORM);
yoda = 0;
damage_goodhits = 0;
case WR_INIT:
{
precache_model("models/nexflash.md3");
- precache_model("models/weapons/g_minstanex.md3");
- precache_model("models/weapons/v_minstanex.md3");
- precache_model("models/weapons/h_minstanex.iqm");
- precache_sound("weapons/minstanexfire.wav");
- precache_sound("weapons/nexwhoosh1.wav");
- precache_sound("weapons/nexwhoosh2.wav");
- precache_sound("weapons/nexwhoosh3.wav");
+ precache_model(W_Model("g_minstanex.md3"));
+ precache_model(W_Model("v_minstanex.md3"));
+ precache_model(W_Model("h_minstanex.iqm"));
+ precache_sound(W_Sound("minstanexfire"));
+ precache_sound(W_Sound("nexwhoosh1"));
+ precache_sound(W_Sound("nexwhoosh2"));
+ precache_sound(W_Sound("nexwhoosh3"));
//W_Blaster(WR_INIT); // Samual: Is this really the proper thing to do? Didn't we already run this previously?
VAPORIZER_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
else
used_ammo = vaporizer_ammo;
- W_Reload(used_ammo, "weapons/reload.wav");
+ W_Reload(used_ammo, W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
mydmg *= charge;
myforce *= charge;
- W_SetupShot(self, true, 5, "weapons/nexfire.wav", CH_WEAPON_A, mydmg);
+ W_SetupShot(self, true, 5, W_Sound("nexfire"), CH_WEAPON_A, mydmg);
if(charge > WEP_CVAR(vortex, charge_animlimit) && WEP_CVAR(vortex, charge_animlimit)) // if the Vortex is overcharged, we play an extra sound
{
- sound(self, CH_WEAPON_B, "weapons/nexcharge.wav", VOL_BASE * (charge - 0.5 * WEP_CVAR(vortex, charge_animlimit)) / (1 - 0.5 * WEP_CVAR(vortex, charge_animlimit)), ATTN_NORM);
+ sound(self, CH_WEAPON_B, W_Sound("nexcharge"), VOL_BASE * (charge - 0.5 * WEP_CVAR(vortex, charge_animlimit)) / (1 - 0.5 * WEP_CVAR(vortex, charge_animlimit)), ATTN_NORM);
}
yoda = 0;
case WR_INIT:
{
precache_model("models/nexflash.md3");
- precache_model("models/weapons/g_nex.md3");
- precache_model("models/weapons/v_nex.md3");
- precache_model("models/weapons/h_nex.iqm");
- precache_sound("weapons/nexfire.wav");
- precache_sound("weapons/nexcharge.wav");
- precache_sound("weapons/nexwhoosh1.wav");
- precache_sound("weapons/nexwhoosh2.wav");
- precache_sound("weapons/nexwhoosh3.wav");
+ precache_model(W_Model("g_nex.md3"));
+ precache_model(W_Model("v_nex.md3"));
+ precache_model(W_Model("h_nex.iqm"));
+ precache_sound(W_Sound("nexfire"));
+ precache_sound(W_Sound("nexcharge"));
+ precache_sound(W_Sound("nexwhoosh1"));
+ precache_sound(W_Sound("nexwhoosh2"));
+ precache_sound(W_Sound("nexwhoosh3"));
VORTEX_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
}
case WR_RELOAD:
{
- W_Reload(min(WEP_CVAR_PRI(vortex, ammo), WEP_CVAR_SEC(vortex, ammo)), "weapons/reload.wav");
+ W_Reload(min(WEP_CVAR_PRI(vortex, ammo), WEP_CVAR_SEC(vortex, ammo)), W_Sound("reload"));
return true;
}
case WR_SUICIDEMESSAGE:
e = self;
Send_Effect("rocket_explode", e.origin, '0 0 0', 1);
- sound(e, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(e, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
e2 = spawn();
setorigin(e2, e.origin);
void GrapplingHook_Stop()
{
Send_Effect("grapple_impact", self.origin, '0 0 0', 1);
- sound (self, CH_SHOTS, "weapons/hook_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_SHOTS, W_Sound("hook_impact"), VOL_BASE, ATTEN_NORM);
self.state = 1;
self.think = GrapplingHookThink;
vs = hook_shotorigin[s];
// UGLY WORKAROUND: play this on CH_WEAPON_B so it can't cut off fire sounds
- sound (self, CH_WEAPON_B, "weapons/hook_fire.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_WEAPON_B, W_Sound("hook_fire"), VOL_BASE, ATTEN_NORM);
org = self.origin + self.view_ofs + v_forward * vs.x + v_right * -vs.y + v_up * vs.z;
tracebox(self.origin + self.view_ofs, '-3 -3 -3', '3 3 3', org, MOVE_NORMAL, self);
precache_model ("models/sprites/10.spr32");
// common weapon precaches
- precache_sound ("weapons/reload.wav"); // until weapons have individual reload sounds, precache the reload sound here
- precache_sound ("weapons/weapon_switch.wav");
- precache_sound ("weapons/weaponpickup.wav");
- precache_sound ("weapons/unavailable.wav");
- precache_sound ("weapons/dryfire.wav");
+ precache_sound (W_Sound("reload")); // until weapons have individual reload sounds, precache the reload sound here
+ precache_sound (W_Sound("weapon_switch"));
+ precache_sound (W_Sound("weaponpickup"));
+ precache_sound (W_Sound("unavailable"));
+ precache_sound (W_Sound("dryfire"));
if (g_grappling_hook)
{
- precache_sound ("weapons/hook_fire.wav"); // hook
- precache_sound ("weapons/hook_impact.wav"); // hook
+ precache_sound (W_Sound("hook_fire")); // hook
+ precache_sound (W_Sound("hook_impact")); // hook
}
precache_model("models/elaser.mdl");
int frag_deathtype;
MUTATOR_HOOKABLE(PlayerDies, EV_PlayerDies);
-/** called when a player dies to e.g. remove stuff he was carrying. */
+/** called when a player dies to e.g. remove stuff he was carrying */
#define EV_PlayHitsound(i, o) \
/**/ i(entity, frag_victim) \
/**/
entity frag_victim;
MUTATOR_HOOKABLE(PlayHitsound, EV_PlayHitsound);
+/** called when a weapon sound is about to be played, allows custom paths etc. */
+#define EV_WeaponSound(i, o) \
+ /**/ i(string, weapon_sound) \
+ /**/ i(string, weapon_sound_output) \
+ /**/ o(string, weapon_sound_output) \
+ /**/
+string weapon_sound;
+string weapon_sound_output;
+MUTATOR_HOOKABLE(WeaponSound, EV_WeaponSound);
+
+/** called when a weapon model is about to be set, allows custom paths etc. */
+#define EV_WeaponModel(i, o) \
+ /**/ i(string, weapon_model) \
+ /**/ i(string, weapon_model_output) \
+ /**/ o(string, weapon_model_output) \
+ /**/
+string weapon_model;
+string weapon_model_output;
+MUTATOR_HOOKABLE(WeaponModel, EV_WeaponModel);
+
/** called when a player presses the jump key */
#define EV_PlayerJump(i, o) \
/**/ i(float, player_multijump) \
if (self.health < 0)
{
- sound(self, CH_TRIGGER, "weapons/grenade_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_TRIGGER, W_Sound("grenade_impact"), VOL_BASE, ATTEN_NORM);
pointparticles(particleeffectnum("rocket_explode"), self.origin, '0 0 0', 1);
Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_NUM_4(self.team, INFO_ONSLAUGHT_CPDESTROYED_), self.owner.message, attacker.netname);
precache_model("models/onslaught/controlpoint_icon_gib4.md3");
precache_sound("onslaught/controlpoint_build.wav");
precache_sound("onslaught/controlpoint_built.wav");
- precache_sound("weapons/grenade_impact.wav");
+ precache_sound(W_Sound("grenade_impact"));
precache_sound("onslaught/damageblockedbyshield.wav");
precache_sound("onslaught/controlpoint_underattack.wav");
precache_sound("onslaught/ons_spark1.wav");
// Throw some flaming gibs on damage, more damage = more chance for gib
if(random() < damage/220)
{
- sound(self, CH_TRIGGER, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_TRIGGER, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
}
else
{
precache_model("models/onslaught/gen_gib2.md3");
precache_model("models/onslaught/gen_gib3.md3");
precache_sound("onslaught/generator_decay.wav");
- precache_sound("weapons/grenade_impact.wav");
- precache_sound("weapons/rocket_impact.wav");
+ precache_sound(W_Sound("grenade_impact"));
+ precache_sound(W_Sound("rocket_impact"));
precache_sound("onslaught/generator_underattack.wav");
precache_sound("onslaught/shockwave.wav");
precache_sound("onslaught/ons_hit1.wav");
precache_sound("misc/strength_respawn.wav");
precache_sound("misc/shield_respawn.wav");
precache_sound("relics/relic_effect.wav");
- precache_sound("weapons/rocket_impact.wav");
+ precache_sound(W_Sound("rocket_impact"));
precache_sound("keepaway/respawn.wav");
addstat(STAT_BUFFS, AS_INT, buffs);
entity proj;
vector kick;
- spamsound(self, CH_SHOTS, "weapons/fireball_fire.wav", VOL_BASE, ATTEN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound("fireball_fire"), VOL_BASE, ATTEN_NORM);
proj = spawn ();
proj.owner = self.owner;
default: expef = "nade_neutral_explode"; break;
}
Send_Effect(expef, self.origin + '0 0 1', '0 0 0', 1);
- sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
RadiusDamage(self, self.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage,
autocvar_g_nades_nade_radius, self, world, autocvar_g_nades_nade_force, self.projectiledeathtype, self.enemy);
Send_Effect(expef, findbetterlocation(self.origin, 8), '0 0 0', 1);
sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, ATTEN_NORM);
- sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_SHOTS, W_Sound("rocket_impact"), VOL_BASE, ATTEN_NORM);
self.event_damage = func_null; // prevent somehow calling damage in the next call
//UpdateCSQCProjectile(self);
if(self.health == self.max_health)
{
- spamsound(self, CH_SHOTS, strcat("weapons/grenade_bounce", ftos(1 + rint(random() * 5)), ".wav"), VOL_BASE, ATTEN_NORM);
+ spamsound(self, CH_SHOTS, W_Sound(strcat("grenade_bounce", ftos(1 + rint(random() * 5)))), VOL_BASE, ATTEN_NORM);
return;
}
precache_model("models/weapons/v_ok_grenade.md3");
precache_model("models/ctf/shield.md3");
- precache_sound("weapons/rocket_impact.wav");
- precache_sound("weapons/grenade_bounce1.wav");
- precache_sound("weapons/grenade_bounce2.wav");
- precache_sound("weapons/grenade_bounce3.wav");
- precache_sound("weapons/grenade_bounce4.wav");
- precache_sound("weapons/grenade_bounce5.wav");
- precache_sound("weapons/grenade_bounce6.wav");
+ precache_sound(W_Sound("rocket_impact"));
+ precache_sound(W_Sound("grenade_bounce1"));
+ precache_sound(W_Sound("grenade_bounce2"));
+ precache_sound(W_Sound("grenade_bounce3"));
+ precache_sound(W_Sound("grenade_bounce4"));
+ precache_sound(W_Sound("grenade_bounce5"));
+ precache_sound(W_Sound("grenade_bounce6"));
precache_sound("overkill/grenadebip.ogg");
}
MUTATOR_HOOKFUNCTION(nt_FilterItem)
{
if(nt_IsNewToy(self.weapon))
- self.item_pickupsound = "weapons/weaponpickup_new_toys.wav";
+ self.item_pickupsound = W_Sound("weaponpickup_new_toys");
return 0;
}
if(time > 1) // game loads at time 1
error("This cannot be added at runtime\n");
- precache_sound("weapons/weaponpickup_new_toys.wav");
+ precache_sound(W_Sound("weaponpickup_new_toys"));
// mark the guns as ok to use by e.g. impulse 99
float i;
{
//Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_OVERKILL_CHARGE);
self.ok_notice_time = time + 2;
- play2(self, "weapons/dryfire.wav");
+ play2(self, W_Sound("dryfire"));
}
if(self.weaponentity.state != WS_CLEAR)
w_ready();
precache_model("models/weapons/v_ok_sniper.md3");
precache_model("models/weapons/g_ok_sniper.md3");
- precache_sound("weapons/dryfire.wav");
+ precache_sound(W_Sound("dryfire"));
addstat(STAT_OK_AMMO_CHARGE, AS_FLOAT, ok_use_ammocharge);
addstat(STAT_OK_AMMO_CHARGEPOOL, AS_FLOAT, ok_ammo_charge);
org = (p1.origin + p2.origin) * 0.5;
org.z += (p1.mins.z + p2.mins.z) * 0.5;
- sound(self, CH_TRIGGER, "weapons/grenade_impact.wav", VOL_BASE, ATTEN_NORM);
+ sound(self, CH_TRIGGER, W_Sound("grenade_impact"), VOL_BASE, ATTEN_NORM);
Send_Effect("explosion_small", org, '0 0 0', 1);
entity e;
void spawnfunc_item_health100() { spawnfunc_item_health_mega(); }
void spawnfunc_item_strength (void) {
- precache_sound("weapons/strength_fire.wav");
+ precache_sound(W_Sound("strength_fire"));
if(!self.strength_finished)
self.strength_finished = autocvar_g_balance_powerup_strength_time;
StartItemA (ITEM_Strength);
precache_sound("misc/armor25.wav");
precache_sound("misc/powerup.wav");
precache_sound("misc/poweroff.wav");
- precache_sound("weapons/weaponpickup.wav");
+ precache_sound(W_Sound("weaponpickup"));
n = tokenize_console(self.netname);
if(argv(0) == "give")
wi = get_weaponinfo(j);
if(wi.weapon)
{
- POSTGIVE_WEAPON(e, j, "weapons/weaponpickup.wav", string_null);
+ POSTGIVE_WEAPON(e, j, W_Sound("weaponpickup"), string_null);
if (!(save_weapons & WepSet_FromWeapon(j)))
if(e.weapons & WepSet_FromWeapon(j))
WEP_ACTION(wi.weapon, WR_INIT);
&& ((time > player.prevstrengthsound + autocvar_sv_strengthsound_antispam_time) // prevent insane sound spam
|| (time > player.prevstrengthsoundattempt + autocvar_sv_strengthsound_antispam_refire_threshold)))
{
- sound(player, CH_TRIGGER, "weapons/strength_fire.wav", VOL_BASE, ATTEN_NORM);
+ sound(player, CH_TRIGGER, W_Sound("strength_fire"), VOL_BASE, ATTEN_NORM);
player.prevstrengthsound = time;
}
player.prevstrengthsoundattempt = time;
if (complain)
if(IS_REAL_CLIENT(cl))
{
- play2(cl, "weapons/unavailable.wav");
+ play2(cl, W_Sound("unavailable"));
Send_WeaponComplain (cl, wpn, 0);
}
return false;
Send_WeaponComplain (cl, wpn, 2);
}
- play2(cl, "weapons/unavailable.wav");
+ play2(cl, W_Sound("unavailable"));
}
return false;
}
if(self.team)
f |= FL_NO_WEAPON_STAY;
- StartItem(e.model, "weapons/weaponpickup.wav", self.respawntime, self.respawntimejitter, e.message, 0, e.weapon, f, weapon_pickupevalfunc, e.bot_pickupbasevalue);
+ StartItem(e.model, W_Sound("weaponpickup"), self.respawntime, self.respawntimejitter, e.message, 0, e.weapon, f, weapon_pickupevalfunc, e.bot_pickupbasevalue);
#if 0 // WEAPONTODO
if (self.modelindex) // don't precache if self was removed
WEP_ACTION(e.weapon, WR_INIT);
if(f <= 0)
continue;
- snd = strcat("weapons/nexwhoosh", ftos(floor(random() * 3) + 1), ".wav");
+ snd = W_Sound(strcat("nexwhoosh", ftos(floor(random() * 3) + 1)));
if(!pseudoprojectile)
pseudoprojectile = spawn(); // we need this so the sound uses the "entchannel4" volume
if(self.weapon == self.switchweapon && time - self.prevdryfire > 1) // only play once BEFORE starting to switch weapons
{
- sound (self, CH_WEAPON_A, "weapons/dryfire.wav", VOL_BASE, ATTEN_NORM);
+ sound (self, CH_WEAPON_A, W_Sound("dryfire"), VOL_BASE, ATTEN_NORM);
self.prevdryfire = time;
}
if(ATTACK_FINISHED(self) <= time + self.weapon_frametime * 0.5)
{
#endif
- sound(self, CH_WEAPON_SINGLE, "weapons/weapon_switch.wav", VOL_BASE, ATTN_NORM);
+ sound(self, CH_WEAPON_SINGLE, W_Sound("weapon_switch"), VOL_BASE, ATTN_NORM);
self.weaponentity.state = WS_DROP;
weapon_thinkf(WFRAME_DONTCHANGE, oldwep.switchdelay_drop, w_clear);
#ifndef INDEPENDENT_ATTACK_FINISHED
{
if(IS_REAL_CLIENT(self) && self.reload_complain < time)
{
- play2(self, "weapons/unavailable.wav");
+ play2(self, W_Sound("unavailable"));
sprint(self, strcat("You don't have enough ammo to reload the ^2", WEP_NAME(self.weapon), "\n"));
self.reload_complain = time + 1;
}
projects / xonotic / xonotic-data.pk3dir.git / commitdiff