zero-gravity/xmen
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
xmen/WEAPONS.c
archive 4e9e5692d3 as released 2005-09-22
2005-09-22 00:00:00 +00:00

3169 lines
80 KiB
C
Raw Permalink Blame History

/*
*/
void (entity targ, entity inflictor, entity attacker, float damage) T_Damage;
void () player_run;
void(entity bomb, entity attacker, float rad, entity ignore) T_RadiusDamage;
void(vector org, vector vel, float damage) SpawnBlood;
void() SuperDamageSound;
void() player_stand1;
// entity values for chasecam purposes
.vector last_roll;
.entity chasecam;
.float tracking_speed;
.float chasecam_zoom;
.float last_weapon_channel;
float DEFAULT_TRACKING_SPEED = 0;
vector CHASECAM_CLOSE = '16 0 16';
//vector CHASECAM_FAR = '20 0 48';
float chasecam_alt, chasecam_dist = 16, chasecam_zofs = 6;
// called by worldspawn
void() W_Precache =
{
precache_sound ("weapons/r_exp3.wav"); // new rocket explosion
precache_sound ("weapons/rocket1i.wav"); // spike gun
precache_sound ("weapons/sgun1.wav");
precache_sound ("weapons/guncock.wav"); // player shotgun
precache_sound ("weapons/ric1.wav"); // ricochet (used in c code)
precache_sound ("weapons/ric2.wav"); // ricochet (used in c code)
precache_sound ("weapons/ric3.wav"); // ricochet (used in c code)
precache_sound ("weapons/spike2.wav"); // super spikes
precache_sound ("weapons/tink1.wav"); // spikes tink (used in c code)
precache_sound ("weapons/grenade.wav"); // grenade launcher
precache_sound ("weapons/bounce.wav"); // grenade bounce
precache_sound ("weapons/shotgn2.wav"); // super shotgun
};
float() crandom =
{
return 2*(random() - 0.5);
};
/*
================
W_FireAxe
================
*/
void() W_FireAxe =
{
local vector source;
local vector org;
self.punchangle_y = -8;
self.punchangle_x = -4;
self.punchangle_z = 0;
makevectors (self.v_angle);
source = self.origin + '0 0 16';
traceline (source, source + v_forward*64, FALSE, self);
if (trace_fraction == 1.0)
return;
org = trace_endpos - v_forward*4;
if (trace_ent.takedamage)
{
trace_ent.axhitme = 1;
SpawnBlood (org, '0 0 0', 20);
T_Damage (trace_ent, self, self, 20);
}
else
{ // hit wall
sound (self, CHAN_WEAPON, "player/axhit2.wav", 1, ATTN_NORM);
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_GUNSHOT);
WriteCoord (MSG_BROADCAST, org_x);
WriteCoord (MSG_BROADCAST, org_y);
WriteCoord (MSG_BROADCAST, org_z);
}
};
//============================================================================
vector() wall_velocity =
{
local vector vel;
/*
vel = normalize (self.velocity);
vel = normalize(vel + v_up*(random()- 0.5) + v_right*(random()- 0.5));
vel = vel + 2*trace_plane_normal;
vel = vel * 200;
*/
makevectors(other.angles);
vel = normalize(v_forward*(random() - 0.85) + v_up*(random() - 0.5) + v_right*(random() - 0.5));
vel = vel * 300;
return vel;
};
//float SLIDE_SPEED = 1;
void() BloodWallSlide =
{
local vector pt1;
if (self.attack_finished < time) {
remove(self);
return;
}
pt1 = self.origin + self.v_angle*8;
traceline(pt1, pt1 - '0 0 0.5', TRUE, self);
if (trace_fraction < 1) {
remove(self);
return;
}
pt1 = trace_endpos;
traceline(pt1, pt1 - (self.v_angle*12), TRUE, self);
setorigin(self, trace_endpos);
//bprint("blood wall slide\n");
self.last_blood_think = time;
self.nextthink = time + 0.1;
};
void() BloodTouch =
{
local vector dir;
if (other != world) {
remove(self);
return;
}
//bprint("blood touch\n");
dir = normalize(self.velocity);
makevectors(dir);
traceline(self.origin - dir*4, self.origin + dir*12, TRUE, self);
if ((trace_fraction < 1) && (fabs(trace_plane_normal_z) < 0.2)) {
// start sliding down wall
self.movetype = MOVETYPE_NONE;
self.velocity = '0 0 0';
self.v_angle = trace_plane_normal;
self.last_blood_think = time;
self.frame = self.frame + 1;
self.think = BloodWallSlide;
self.nextthink = time + 0.1;
self.attack_finished = time + 7;
self.angles = vectoangles(trace_plane_normal);
}
};
/*
================
SpawnMeatSpray
================
*/
void(vector org, vector vel) SpawnMeatSpray =
{
local entity missile, mpuff;
local vector org;
missile = spawn ();
missile.owner = self;
missile.movetype = MOVETYPE_BOUNCE;
missile.solid = SOLID_BBOX;
makevectors (self.angles);
missile.velocity = vel;
missile.velocity_z = missile.velocity_z + 150 + 50*random();
missile.avelocity = '300 100 200';
missile.touch = BloodTouch;
// set missile duration
missile.nextthink = time + 5;
missile.think = SUB_Remove;
setmodel (missile, "progs/blood.mdl");
setsize (missile, '0 0 0', '0 0 0');
setorigin (missile, org);
};
/*
================
SpawnBlood
================
*/
void(vector org, vector vel, float damage) SpawnBlood =
{
local vector vrand, vect;
local float num_gibs;
particle (org, vel* -0.1, 73, damage*2);
if (deathmatch) { // preserve bandwidth
return;
}
num_gibs = ceil(damage / 15);
while (num_gibs > 0) {
vrand = '8 0 0' * random() + '0 8 0' * random() + '0 0 4' * random() - '4 4 2';
vect = normalize(vrand + vel);
SpawnMeatSpray(org + vect*24, vect*(100 + random()*400));
num_gibs = num_gibs - 1;
}
};
/*
================
spawn_touchblood
================
*/
void(float damage) spawn_touchblood =
{
local vector vel, vrand;
local float num_gibs;
vel = wall_velocity () * 0.2;
if (deathmatch) {
SpawnBlood (self.origin + vel*0.01, vel, damage);
return;
}
num_gibs = damage / 10;
while (num_gibs > 0) {
vrand = '8 0 0' * random() + '0 8 0' * random() + '0 0 4' * random() - '4 4 2';
SpawnMeatSpray(self.origin + vrand + vel*0.01, vel + vrand*20);
num_gibs = num_gibs - 1;
}
};
/*
================
SpawnChunk
================
*/
void(vector org, vector vel) SpawnChunk =
{
// particle (org, vel*0.02, 0, 10);
SpawnBlood(org, vel*0.02, 5);
};
/*
==============================================================================
MULTI-DAMAGE
Collects multiple small damages into a single damage
==============================================================================
*/
entity multi_ent;
float multi_damage;
void() ClearMultiDamage =
{
multi_ent = world;
multi_damage = 0;
};
void() ApplyMultiDamage =
{
if (!multi_ent)
return;
T_Damage (multi_ent, self, self, multi_damage);
};
void(entity hit, float damage) AddMultiDamage =
{
if (!hit)
return;
if (hit != multi_ent)
{
ApplyMultiDamage ();
multi_damage = damage;
multi_ent = hit;
}
else
multi_damage = multi_damage + damage;
};
/*
==============================================================================
BULLETS
==============================================================================
*/
/*
================
TraceAttack
================
*/
void(entity ent, float num_gibs) IcemanShardGib;
void(float damage, vector dir) TraceAttack =
{
local vector vel, org;
vel = normalize(dir*5 + v_up*random() + v_right*crandom());
// vel = vel + 2*trace_plane_normal;
// vel = normalize(vel);
org = trace_endpos - dir*4;
if (trace_ent.takedamage)
{
org = trace_ent.origin;
if ((trace_ent.classname != "xmen_sinister") || (trace_ent.x_flags & X_MEGA_HIT)) {
if ((trace_ent.classname != "xmen_iceman") && (trace_ent.character != CHAR_ICEMAN)) {
if ((trace_ent.flags & FL_MONSTER) ||
(trace_ent.flags & FL_CLIENT)) {
if (random() < 0.8)
SpawnBlood (org, vel * 12, damage);
else
SpawnBlood (org, vel * -2, damage);
}
}
else {
IcemanShardGib(trace_ent, damage / 6);
}
}
AddMultiDamage (trace_ent, damage);
}
else
{
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_GUNSHOT);
WriteCoord (MSG_BROADCAST, org_x);
WriteCoord (MSG_BROADCAST, org_y);
WriteCoord (MSG_BROADCAST, org_z);
}
};
/*
================
FireBullets
Used by shotgun, super shotgun, and enemy soldier firing
Go to the trouble of combining multiple pellets into a single damage call.
================
*/
void(float shotcount, vector dir, vector spread) FireBullets =
{
local vector direction;
local vector src;
makevectors(self.v_angle);
src = self.origin + v_forward*10 + '0 0 12';
src_z = self.absmin_z + self.size_z * 0.7;
ClearMultiDamage ();
while (shotcount > 0)
{
direction = dir + crandom()*spread_x*v_right + crandom()*spread_y*v_up;
traceline (src, src + direction*2048, FALSE, self);
if (trace_fraction != 1.0)
TraceAttack (4, direction);
shotcount = shotcount - 1;
}
ApplyMultiDamage ();
};
/*
================
W_FireShotgun
================
*/
void() W_FireShotgun =
{
local vector dir;
sound (self, CHAN_WEAPON, "weapons/guncock.wav", 1, ATTN_NORM);
self.punchangle_x = -2;
self.currentammo = self.ammo_shells = self.ammo_shells - 1;
dir = aim (self, 100000);
FireBullets (6, dir, '0.04 0.04 0');
};
/*
================
W_FireSuperShotgun
================
*/
void() W_FireSuperShotgun =
{
local float rnd;
local vector dir;
if (self.currentammo <= 1)
self.currentammo = self.ammo_shells = 0;
else
self.currentammo = self.ammo_shells = self.ammo_shells - 1;
sound (self ,CHAN_WEAPON, "weapons/shotfir6.wav", 1, ATTN_NORM);
self.punchangle_x = -8;
dir = aim (self, 100000);
FireBullets (7, dir, '0.06 0.06 0');
if (vlen(self.velocity) < 10) { // add some bounce if stationery
self.velocity = self.velocity + '0 0 150';
}
v_forward_z = 0;
self.velocity = self.velocity - (v_forward * 40);
};
/*
==============================================================================
ROCKETS
==============================================================================
*/
void() s_explode1 = [0, s_explode2] {};
void() s_explode2 = [1, s_explode3] {self.effects = self.effects | EF_DIMLIGHT;};
void() s_explode3 = [2, s_explode4] {};
void() s_explode4 = [3, s_explode5] {self.effects = self.effects - EF_DIMLIGHT;};
void() s_explode5 = [4, s_explode6] {};
void() s_explode6 = [5, SUB_Remove] {};
void() BecomeExplosion =
{
self.movetype = MOVETYPE_NONE;
self.velocity = '0 0 0';
self.touch = SUB_Null;
setmodel (self, "progs/s_explod.spr");
self.solid = SOLID_NOT;
s_explode1 ();
};
void() T_MissileTouch =
{
local float damg;
if (other == self.owner)
return; // don't explode on owner
if (pointcontents(self.origin) == CONTENT_SKY)
{
remove(self);
return;
}
damg = 100 + random()*20;
if (other.health)
{
if (other.classname == "xmen_storm")
damg = damg * 0.5; // mostly immune
T_Damage (other, self, self.owner, damg );
}
// don't do radius damage to the other, because all the damage
// was done in the impact
T_RadiusDamage (self, self.owner, 120, other);
// sound (self, CHAN_WEAPON, "weapons/r_exp3.wav", 1, ATTN_NORM);
self.origin = self.origin - 8*normalize(self.velocity);
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_EXPLOSION);
WriteCoord (MSG_BROADCAST, self.origin_x);
WriteCoord (MSG_BROADCAST, self.origin_y);
WriteCoord (MSG_BROADCAST, self.origin_z);
BecomeExplosion ();
};
void() cannon_xatta16;
void() T_GuidedMissileTouch =
{
local float damg;
if (other == self.owner)
return; // don't explode on owner
if (pointcontents(self.origin) == CONTENT_SKY)
{
remove(self);
return;
}
if (self.dmg == 0)
damg = 35 + random()*5;
else
damg = self.dmg;
if (self.classname == "dm_phoenix_blast")
damg = damg / 2;
if (self.classname == "phoenix_blast")
damg = damg / 2;
if ((other.classname == "xmen_cannonball") && (other.flags & FL_GODMODE)) {
if (other.last_rocket_hit > (time - 0.5)) {
other.x_flags = other.x_flags | X_CANNONFLYABORT;
// other.think = cannon_xatta16;
}
}
if (other != world)
other.last_rocket_hit = time;
if (other.health)
{
if (!(other.x_flags & X_ANGEL_DEFENSE))
T_Damage (other, self, self.owner, damg );
if ((other.movetype) && (other.flags & FL_ONGROUND) && (other.classname != "apocalypse_small") && (other.classname != "xmen_sinister")) { // give some velocity
other.velocity = other.velocity + normalize(self.velocity) * 180;
if (other.velocity_z < 140)
other.velocity_z = 140;
other.flags = other.flags - (other.flags & FL_ONGROUND);
setorigin(other, other.origin + '0 0 1');
}
}
if (self.classname != "phoenix_blast") {
// don't do radius damage to the other, because all the damage
// was done in the impact
T_RadiusDamage (self, self.owner, 40, other);
}
sound (self, CHAN_WEAPON, "weapons/r_exp3.wav", 0.6, ATTN_NORM);
self.origin = self.origin - 8*normalize(self.velocity);
BecomeExplosion ();
};
/*******************************
FindSightEnemy
Returns an entity that is within "angle_range" of "dir"
use filter_classname to exclude all entitys with the given classname
from being returned (use "world" to for to include all classes)
*******************************/
entity(vector org, vector dir, float dist, float angle_range, string filter_class, entity ignore) FindSightEnemy =
{
local entity trav;
local float trav_yaw, dir_yaw;
dir_yaw = vectoyaw(dir);
trav = findradius(org, dist);
while (trav != world) {
if (((filter_class == "all") || (filter_class == trav.classname)) && (trav != ignore) && ((ignore != world) && (trav != ignore.owner))) {
if ((trav.takedamage == DAMAGE_AIM)
&& (trav.health > 0)) {
// make sure trav is within the angle_range
trav_yaw = vectoyaw(trav.origin - org);
if (fabs(angle_diff(dir_yaw, trav_yaw)) <= angle_range) {
// check there is a clear line of sight
traceline(org, trav.origin, TRUE, world);
if (trace_fraction == 1) {
return trav;
}
}
}
}
trav = trav.chain;
}
return trav;
};
void() T_MissileTouch;
// lower weight, means more accurate
void(vector target_org, float weight) RocketSeek =
{
local float current_speed;
local vector target_vector, vel, unit_velocity;
current_speed = vlen(self.velocity);
target_vector = normalize(target_org - self.origin);
unit_velocity = normalize(self.velocity);
self.velocity = normalize(target_vector + unit_velocity*weight) * current_speed;
vel = normalize(self.velocity);
self.angles = vectoangles(vel);
self.nextthink = time + 0.05;
};
void() GuidedRocketThink =
{
local vector dir, new_targ, reflect, endpos;
local float interdist;
if (self.attack_finished < time) {
remove(self);
return;
}
dir = normalize(self.velocity);
self.angles = vectoangles(dir);
self.angles_x = -1 * self.angles_x;
if (self.classname == "prox_missile")
particle(self.origin, self.velocity * 0.5, 44, 10);
if (self.enemy != world) {
if ((self.enemy.health <= 0) ||
((self.enemy.classname == "xmen_phoenix") &&
(self.enemy.flags & FL_GODMODE))) {
self.enemy = world;
}
else
{
traceline(self.origin, self.enemy.origin, TRUE, self);
if (trace_fraction == 1) { // clear path
if (self.classname == "prox_missile")
RocketSeek(self.enemy.origin, 0.5);
else if (self.classname == "dm_phoenix_blast")
RocketSeek(self.enemy.origin, 8);
else
RocketSeek(self.enemy.origin, 5);
return;
}
}
}
else if ((self.enemy == world) && (self.last_guided_search < (time - 0.2))) // search for a new target every 0.5 seconds
{
makevectors(self.angles);
dir = v_forward;
if (self.classname == "pheonix_blast")
self.enemy = FindSightEnemy(self.origin, dir, 1500, 30, "player", self);
else
self.enemy = FindSightEnemy(self.origin, dir, 1500, 30, "all", self);
self.last_guided_search = time;
}
// avoid walls
dir = normalize(self.velocity);
traceline(self.origin, self.origin + dir*256, TRUE, self);
if ((trace_fraction < 1) && (trace_ent == world)) { // heading for a wall
endpos = trace_endpos;
interdist = 256 * trace_fraction;
// reflect = GetReflectionVect(trace_endpos, dir, trace_plane_normal);
new_targ = endpos + trace_plane_normal * interdist;
RocketSeek(new_targ, 3);
return;
}
self.nextthink = time + 0.05;
};
void() GuidedRocketStart =
{
local entity missile_enemy;
local vector dir;
dir = normalize(self.velocity);
if (self.enemy == world) {
if ((missile_enemy = FindSightEnemy(self.origin, dir, 1500, 30, "all", self.owner)) != world) {
self.enemy = missile_enemy;
if (missile_enemy.th_guard) {
if (missile_enemy.enemy == self.owner) { // alert Enemy
missile_enemy.guard_flag = TRUE;
}
}
}
else {
self.velocity = self.old_velocity + normalize(self.velocity) * 3;
self.velocity = normalize(self.velocity);
self.angles = vectoangles(self.velocity);
self.angles_x = -1 * self.angles_x;
self.velocity = self.velocity * 500;
}
}
self.think = GuidedRocketThink;
self.nextthink = time + 0.05;
};
void(vector origdir, vector ofs) GuidedMissile =
{
local entity missile, missile_enemy;
local vector dir;
missile = spawn ();
missile.classname = "guided_rocket";
missile.attack_finished = time + 3;
missile.owner = self;
missile.movetype = MOVETYPE_FLYMISSILE;
missile.solid = SOLID_BBOX;
// dir = normalize(origdir);
dir = v_forward;
if ((missile_enemy = FindSightEnemy(missile.origin, dir, 1500, 30, "all", self)) != world) {
self.enemy = missile_enemy;
if (missile_enemy.th_guard) {
if (missile_enemy.enemy == self) { // alert Enemy
missile_enemy.guard_flag = TRUE;
}
}
}
missile.think = GuidedRocketStart;
missile.last_guided_search = time;
missile.nextthink = time + 0.3;
missile.old_velocity = normalize(origdir);
// set missile speed
missile.velocity = dir;
missile.velocity = missile.velocity * 500;
missile.angles = vectoangles(missile.velocity);
missile.touch = T_GuidedMissileTouch;
setmodel (missile, "progs/missmall.mdl");
setsize (missile, '0 0 0', '0 0 0');
setorigin (missile, self.origin + origdir + ofs + v_forward * 8 + '0 0 16');
};
void() W_FireGuidedRockets =
{
if (self.ammo_rockets <= 2)
self.currentammo = self.ammo_rockets = 0;
else
self.currentammo = self.ammo_rockets = self.ammo_rockets - 2;
sound (self, CHAN_WEAPON, "weapons/guidfire.wav", 1, ATTN_NORM);
self.punchangle_x = -12;
makevectors (self.v_angle);
/*
GuidedMissile(v_forward*3 + v_up);
GuidedMissile(v_forward*3 + v_right);
GuidedMissile(v_forward*3 - v_right);
*/
// GuidedMissile(v_forward*5 - v_right);
// GuidedMissile(v_forward*5 + v_right);
GuidedMissile(v_right * 2, v_right * 6);
GuidedMissile(v_right * -2, v_right * 6);
};
/*
================
W_FireRocket
================
*/
void() W_FireRocket =
{
local entity missile, mpuff;
// self.currentammo = self.ammo_rockets = self.ammo_rockets - 3;
// sound (self, CHAN_WEAPON, "weapons/sgun1.wav", 1, ATTN_NORM);
self.punchangle_x = -2;
missile = spawn ();
missile.owner = self;
missile.movetype = MOVETYPE_FLYMISSILE;
missile.solid = SOLID_BBOX;
missile.classname = "missile";
// set missile speed
makevectors (self.v_angle);
missile.velocity = aim(self, 1000);
missile.velocity = missile.velocity * 1000;
missile.angles = vectoangles(missile.velocity);
missile.touch = T_MissileTouch;
// set missile duration
missile.nextthink = time + 5;
missile.think = SUB_Remove;
setmodel (missile, "progs/missile.mdl");
setsize (missile, '0 0 0', '0 0 0');
setorigin (missile, self.origin + v_forward*8 + '0 0 16');
W_FireGuidedRockets();
};
/*
===============================================================================
LIGHTNING
===============================================================================
*/
.float remove_time;
void() bolt_think =
{
self.angles_z = random() * 340 - 170;
if (self.remove_time < time)
{
remove(self);
return;
}
self.frame = self.speed;
self.nextthink = time + 0.05;
};
void(vector start, vector end, string modelstr, vector angle_ofs, float bolt_life) FillBetweenPoints =
{
local vector org, dir, dir_angle;
local float dist;
local entity newbolt;
dist = vlen(start - end);
dir = normalize(end - start);
dir_angle = vectoangles(dir);
org = start;
while (vlen(org - start) < dist)
{
//bprint("b");
newbolt = spawn();
setmodel(newbolt, modelstr);
setorigin(newbolt, org);
newbolt.frame = 0; //frame_num;
newbolt.speed = 0; //frame_num;
newbolt.angles = dir_angle + angle_ofs;
newbolt.angles_z = random() * 340 - 170;
newbolt.remove_time = time + bolt_life; //0.07;
newbolt.think = bolt_think;
newbolt.nextthink = time + 0.05;
if (modelstr == "progs/bolt3.mdl")
org = org + dir*128;
else
org = org + dir*32;
}
//bprint("\n");
};
/*
=================
LightningDamage
=================
*/
void(vector p1, vector p2, entity from, float damage) LightningDamage =
{
local entity e1, e2;
local vector f;
f = p2 - p1;
normalize (f);
f_x = 0 - f_y;
f_y = f_x;
f_z = 0;
f = f*16;
e1 = e2 = world;
traceline (p1, p2, FALSE, self);
if (trace_ent.takedamage)
{
particle (trace_endpos, '0 0 100', 225, damage*4);
T_Damage (trace_ent, from, from, damage);
if (self.classname == "player")
{
if (other.classname == "player")
trace_ent.velocity_z = trace_ent.velocity_z + 400;
}
}
e1 = trace_ent;
traceline (p1 + f, p2 + f, FALSE, self);
if (trace_ent != e1 && trace_ent.takedamage)
{
particle (trace_endpos, '0 0 100', 225, damage*4);
T_Damage (trace_ent, from, from, damage);
}
e2 = trace_ent;
traceline (p1 - f, p2 - f, FALSE, self);
if (trace_ent != e1 && trace_ent != e2 && trace_ent.takedamage)
{
particle (trace_endpos, '0 0 100', 225, damage*4);
T_Damage (trace_ent, from, from, damage);
}
};
void(vector org_start, vector dir_start) ReflectLightning =
{
local float reflect_count, NUM_REFLECTIONS, frac, total_dist, MAX_DIST, length;
local vector org, dir, normal, endpos;
local entity ent, junction;
local string str;
NUM_REFLECTIONS = 2;
MAX_DIST = 800;
org = org_start;
dir = dir_start;
reflect_count = 0;
total_dist = 0;
junction = self;
while (reflect_count <= NUM_REFLECTIONS) {
traceline (org, org + dir*600, FALSE, self);
frac = trace_fraction;
ent = trace_ent;
normal = trace_plane_normal;
endpos = trace_endpos;
length = vlen(endpos - org);
if ((total_dist + length) > MAX_DIST) {
endpos = org + dir * (MAX_DIST - total_dist);
reflect_count = NUM_REFLECTIONS;
}
// if (trace_fraction < 0.05)
// return;
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_LIGHTNING2);
WriteEntity (MSG_BROADCAST, junction);
WriteCoord (MSG_BROADCAST, org_x);
WriteCoord (MSG_BROADCAST, org_y);
WriteCoord (MSG_BROADCAST, org_z);
WriteCoord (MSG_BROADCAST, endpos_x);
WriteCoord (MSG_BROADCAST, endpos_y);
WriteCoord (MSG_BROADCAST, endpos_z);
LightningDamage (org, endpos + dir*4, self, 30 * (1 - (total_dist/480))); // lose power over distance
//str = ftos(frac);
//bprint(str);
//bprint("\n");
if ((frac < 1) && (ent == world)) {
org = endpos;
dir = GetReflectionVect(org, dir, normal);
reflect_count = reflect_count + 1;
}
else {
reflect_count = NUM_REFLECTIONS + 1;
total_dist = MAX_DIST;
}
// junction = junction.beam_ent;
}
};
void() W_FireLightning =
{
local vector org;
local float cells;
stuffcmd(self, "bf\n");
self.punchangle = '-10 0 0' + '10 0 0' * random() + '0 10 0' * random() + '0 0 10' * random() - '5 5 5';
// self.currentammo = self.ammo_cells = self.ammo_cells - 1;
org = self.origin + '0 0 16';
makevectors(self.v_angle);
traceline(org, org + v_forward * 1000, FALSE, self);
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_LIGHTNING2);
WriteEntity (MSG_BROADCAST, self);
WriteCoord (MSG_BROADCAST, org_x);
WriteCoord (MSG_BROADCAST, org_y);
WriteCoord (MSG_BROADCAST, org_z);
WriteCoord (MSG_BROADCAST, trace_endpos_x);
WriteCoord (MSG_BROADCAST, trace_endpos_y);
WriteCoord (MSG_BROADCAST, trace_endpos_z);
if ((trace_ent != world) &&
!(trace_ent.x_flags & X_MEGA_HIT) &&
((trace_ent.owner.classname == "xmen_apocalypse") ||
(trace_ent.classname == "xmen_sinister"))) {
T_Damage(trace_ent, self, self, 5000);
}
};
void() ProximityAttack =
{
local vector vect;
local float dist;
local entity ent, oself;
if (other == world) {
remove(self);
return;
}
if (other != self.enemy)
return;
ent = self.enemy;
// oself = self;
// self = self.owner;
vect = normalize(ent.origin - self.oldorigin);
dist = vlen(ent.origin - self.oldorigin);
if (dist > 200)
dist = 200;
if ((ent.classname != "apocalypse_small") && (ent.classname != "xmen_sinister"))
ent.velocity = ent.velocity + vect * (200 - dist) + '0 0 180';
ent.flags = ent.flags - (ent.flags & FL_ONGROUND);
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_EXPLOSION);
WriteCoord (MSG_BROADCAST, ent.origin_x);
WriteCoord (MSG_BROADCAST, ent.origin_y);
WriteCoord (MSG_BROADCAST, ent.origin_z);
SpawnBlood (ent.origin, '0 0 0', 20);
if ((ent.classname == "xmen_sinister") || (ent.classname == "apocalypse_small"))
self.prox_power = self.prox_power / 5;
T_Damage(ent, self, self.owner, ent.start_health * (self.prox_power / 100) + 10);
// self = oself;
remove(self);
};
void() ProximityThink =
{
// remove if player is dead
if ((self.owner.health <= 0) || (self.modelindex == index_skeleton) || (intermission_running)) {
self.owner.prox_ent = world;
remove(self);
return;
}
if (self.owner.last_prox_think < (time - 5)) {
self.owner.prox_ent = world;
remove(self);
return;
}
self.frame = self.frame + 1;
if (self.frame > 5)
self.frame = 0;
if (self.last_flame_sound < (time - 0.75)) {
if (random() < 0.5)
sound(self, CHAN_AUTO, "weapons/prox1.wav", self.owner.prox_power / 100, ATTN_NORM);
else
sound(self, CHAN_AUTO, "weapons/prox2.wav", self.owner.prox_power / 100, ATTN_NORM);
self.last_flame_sound = time;
}
if (self.last_flame < (time - 0.05)) { // increase power
if ((self.owner.currentammo > 0) && (self.owner.prox_power < 100)) {
self.owner.currentammo = self.owner.ammo_cells = self.owner.ammo_cells - 1;
self.owner.prox_power = self.owner.prox_power + 1;
if ((self.owner.currentammo > 0) && (self.owner.prox_power < 100)) {
self.owner.currentammo = self.owner.ammo_cells = self.owner.ammo_cells - 1;
self.owner.prox_power = self.owner.prox_power + 1;
}
if ((self.owner.currentammo > 0) && (self.owner.prox_power < 100)) {
self.owner.currentammo = self.owner.ammo_cells = self.owner.ammo_cells - 1;
self.owner.prox_power = self.owner.prox_power + 1;
}
// faster under rapid fire
if ((self.owner.x_flags & X_RAPID_FIRE) && (self.owner.currentammo > 0) && (self.owner.prox_power < 100)) {
self.owner.currentammo = self.owner.ammo_cells = self.owner.ammo_cells - 1;
self.owner.prox_power = self.owner.prox_power + 1;
}
if ((self.owner.x_flags & X_RAPID_FIRE) && (self.owner.currentammo > 0) && (self.owner.prox_power < 100)) {
self.owner.currentammo = self.owner.ammo_cells = self.owner.ammo_cells - 1;
self.owner.prox_power = self.owner.prox_power + 1;
}
if ((self.model == "progs/atom1.mdl") && (self.owner.prox_power > 40))
setmodel(self, "progs/atom2.mdl");
else if ((self.model == "progs/atom2.mdl") && (self.owner.prox_power > 70))
setmodel(self, "progs/atom3.mdl");
self.last_flame = time;
}
else if ((self.owner.prox_power >= 50) && (self.last_flame < (time - 3))) {
T_Damage(self.owner, world, world, 2);
self.last_flame = time - 2; // next hurt after 1 seconds only
}
}
if (self.movetype != MOVETYPE_BOUNCE) {
// align with owner
makevectors(self.owner.v_angle);
setorigin(self, self.owner.origin + v_forward * 24 + '0 0 22');
}
self.nextthink = time + 0.01;
};
void() StartProximity =
{
local entity prox;
if (self.prox_ent != world) {
remove(self.prox_ent);
self.prox_ent = world;
}
prox = spawn();
self.prox_ent = prox;
prox.classname = "proximity_ball";
prox.owner = self;
prox.spawn_time = time;
prox.movetype = MOVETYPE_FLY;
prox.avelocity = '100 0 0' * random() + '0 100 0' * random() + '0 0 100' * random() - '50 50 50';
setmodel(prox, "progs/atom1.mdl");
self.last_prox_think = time;
prox.think = ProximityThink;
self = prox;
ProximityThink();
self = self.owner;
};
void(entity targ) SpawnProxMissile =
{
local entity missile;
local vector dir, vect;
missile = spawn ();
missile.classname = "prox_missile";
missile.attack_finished = time + 3;
missile.owner = self.owner;
missile.oldorigin = self.origin;
missile.movetype = MOVETYPE_FLYMISSILE;
missile.solid = SOLID_BBOX;
missile.prox_power = self.owner.prox_power;
dir = normalize(targ.origin - self.origin);
dir = normalize('0 0 1' + dir * 5);
missile.enemy = targ;
missile.think = GuidedRocketStart;
missile.nextthink = time + 0.05;
missile.old_velocity = dir;
// set missile speed
missile.velocity = dir;
missile.velocity = missile.velocity * 750;
missile.angles = vectoangles(missile.velocity);
missile.touch = ProximityAttack;
setmodel (missile, "progs/atomshot.mdl");
setsize (missile, '0 0 0', '0 0 0');
vect = normalize(self.velocity);
setorigin (missile, self.origin - vect * 8);
};
void() ProximityTouch =
{
local entity trav, expthink;
local float num;
if (other == self.owner)
return;
sound(self, CHAN_ITEM, "items/damage2.wav", 1, ATTN_NORM);
// sound(self, CHAN_BODY, "weapons/r_exp3.wav", 0.4, ATTN_NORM);
num = rint(6 * (self.prox_power / 100)) + 2;
trav = findradius(self.origin, 800);
while ((trav != world) && (num > 0)) {
if ((trav.takedamage) && (trav != self.owner)) {
// check visibility
traceline(self.origin, trav.origin, TRUE, trav);
if ((trace_fraction == 1) || (trace_ent == trav)) {
if (((trav.classname != "xmen_sinister") || (self.x_flags & X_MEGA_HIT)) &&
(trav.classname != "xmen_apocalypse")) {
SpawnProxMissile(trav);
num = num - 1;
}
/*
expthink = spawn();
expthink.enemy = trav;
expthink.owner = self.owner;
expthink.prox_power = self.prox_power;
expthink.think = ProximityAttack;
expthink.nextthink = time + vlen(trav.origin - self.origin) / 400;
*/
// ProximityAttack(trav);
}
}
trav = trav.chain;
}
if (other.takedamage)
T_Damage(other, self, self, self.owner.prox_power);
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_EXPLOSION);
WriteCoord (MSG_BROADCAST, self.origin_x);
WriteCoord (MSG_BROADCAST, self.origin_y);
WriteCoord (MSG_BROADCAST, self.origin_z);
BecomeExplosion ();
self.owner.prox_ent = world;
};
void() W_FireProximity =
{
local vector org;
local float cells;
local entity trav, expthink;
/*
if (self.ammo_cells < 1)
{
self.weapon = W_BestWeapon ();
W_SetCurrentAmmo ();
return;
}
if (self.ammo_cells > 50) {
cells = 50;
self.currentammo = self.ammo_cells = self.ammo_cells - 50;
}
else {
cells = self.ammo_cells;
self.currentammo = self.ammo_cells = 0;
}
*/
if (self.prox_ent == world) // nothing to throw
return;
// Throw the proxmity ball
self.prox_ent.solid = SOLID_TRIGGER;
self.prox_ent.movetype = MOVETYPE_FLYMISSILE;
setsize(self.prox_ent, '0 0 0', '0 0 0');
self.prox_ent.touch = ProximityTouch;
self.prox_ent.prox_power = self.prox_power;
self.prox_ent.think = SUB_Null;
makevectors(self.v_angle);
// self.prox_ent.velocity = self.velocity + (v_forward*2 + v_up*0.5) * 50 + '0 0 80';
self.prox_ent.velocity = v_forward * 750;
self.attack_finished = time + 2;
// stuffcmd(self, "bf\n");
sound(self, CHAN_ITEM, "cannon/takeoff.wav", 1, ATTN_NORM);
/*
sound(self, CHAN_WEAPON, "items/damage2.wav", 1, ATTN_NORM);
sound(self, CHAN_BODY, "weapons/r_exp3.wav", 0.4, ATTN_NORM);
trav = findradius(self.origin, 800);
while (trav != world) {
if ((trav.takedamage) && (trav != self)) {
// check visibility
traceline(self.origin, trav.origin, TRUE, trav);
if ((trace_fraction == 1) || (trace_ent == trav)) {
expthink = spawn();
expthink.enemy = trav;
expthink.owner = self;
expthink.think = ProximityAttack;
expthink.nextthink = time + vlen(trav.origin - self.origin) / 400;
// ProximityAttack(trav);
}
}
trav = trav.chain;
}
*/
};
//=============================================================================
void() GrenadeExplode =
{
T_RadiusDamage (self, self.owner, 60, world);
/*
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_EXPLOSION);
WriteCoord (MSG_BROADCAST, self.origin_x);
WriteCoord (MSG_BROADCAST, self.origin_y);
WriteCoord (MSG_BROADCAST, self.origin_z);
*/
if ((other.movetype) && (other.flags & FL_ONGROUND) && (other.classname != "xmen_sinister") && (other.classname != "apocalypse_small")) { // give some velocity
other.velocity = other.velocity + normalize(self.velocity) * 100 + '0 0 220';
other.flags = other.flags - (other.flags & FL_ONGROUND);
setorigin(other, other.origin + '0 0 1');
}
sound(self, CHAN_WEAPON, "weapons/r_exp3.wav", 1, ATTN_NORM);
BecomeExplosion ();
};
void() GrenadeTouch =
{
if (other == self.owner)
return; // don't explode on owner
if ((other.classname == "xmen_phoenix") &&
(other.flags & FL_GODMODE))
return;
if ((other.takedamage == DAMAGE_AIM) && !(other.x_flags & X_ANGEL_DEFENSE))
{
GrenadeExplode();
return;
}
sound (self, CHAN_WEAPON, "weapons/bounce.wav", 1, ATTN_NORM); // bounce sound
if (self.velocity == '0 0 0')
self.avelocity = '0 0 0';
};
/*
================
W_FireGrenade
================
*/
void() W_FireGrenade =
{
local entity missile, mpuff, phoenix;
if (self.ammo_rockets > 0)
self.currentammo = self.ammo_rockets = self.ammo_rockets - 1;
sound (self, CHAN_WEAPON, "weapons/grenade.wav", 1, ATTN_NORM);
self.punchangle_x = -2;
missile = spawn ();
missile.owner = self;
missile.movetype = MOVETYPE_BOUNCE;
missile.solid = SOLID_BBOX;
missile.classname = "orb";
// set missile speed
makevectors (self.v_angle);
if (self.v_angle_x)
missile.velocity = v_forward*900 + v_up * 200 + crandom()*v_right*10 + crandom()*v_up*10;
else
{
missile.velocity = aim(self, 10000);
missile.velocity = missile.velocity * 900;
missile.velocity_z = 200;
}
missile.avelocity = '300 300 300';
missile.angles = vectoangles(missile.velocity);
missile.touch = GrenadeTouch;
// set missile duration
missile.nextthink = time + 2.5;
missile.think = GrenadeExplode;
setmodel (missile, "progs/orb1.mdl");
setsize (missile, '0 0 0', '0 0 0');
setorigin (missile, self.origin + v_right * 6 + v_forward * 16);
missile.old_velocity = missile.velocity;
// check for Pheonix defence
phoenix = find(world, classname, "xmen_phoenix");
while (phoenix != world) {
if (phoenix.enemy == self)
phoenix.guard_flag = TRUE;
phoenix = find(phoenix, classname, "xmen_phoenix");
}
};
//=============================================================================
void() spike_touch;
void() superspike_touch;
/*
===============
launch_spike
Used for both the player and the ogre
===============
*/
void(vector org, vector dir) launch_spike =
{
newmis = spawn ();
newmis.owner = self;
newmis.movetype = MOVETYPE_FLYMISSILE;
newmis.solid = SOLID_BBOX;
newmis.angles = vectoangles(dir);
newmis.touch = spike_touch;
newmis.classname = "spike";
newmis.think = SUB_Remove;
newmis.nextthink = time + 6;
setmodel (newmis, "progs/spike.mdl");
setsize (newmis, VEC_ORIGIN, VEC_ORIGIN);
setorigin (newmis, org);
newmis.velocity = dir * 1000;
};
void(float ox) W_FireSuperSpikes =
{
local vector dir;
local entity old;
local string sample;
local float shells;
sample = "weapons/chnfire5.wav";
if (self.last_weapon_channel != CHAN_WEAPON) {
sound (self, CHAN_WEAPON, sample, 1, ATTN_NORM);
self.last_weapon_channel = CHAN_WEAPON;
} else {
sound (self, CHAN_ITEM, sample, 1, ATTN_NORM);
self.last_weapon_channel = CHAN_ITEM;
}
self.attack_finished = time + 0.2;
if (random() < 0.5)
shells = 1;
else
shells = 2;
dir = aim (self, 100000);
if (self.ammo_shells <= shells) {
self.currentammo = self.ammo_shells = 0;
}
else {
self.currentammo = self.ammo_shells = self.ammo_shells - shells;
}
FireBullets (shells, dir, '0.04 0.04 0');
/*
self.currentammo = self.ammo_shells = self.ammo_shells - 1;
dir = aim (self, 1000);
launch_spike (self.origin + '0 0 16' + ox * v_right, dir);
newmis.touch = superspike_touch;
setmodel (newmis, "progs/s_spike.mdl");
setsize (newmis, VEC_ORIGIN, VEC_ORIGIN);
*/
self.punchangle_x = -2;
};
void(float ox) W_FireSpikes =
{
local vector dir;
local entity old;
makevectors (self.v_angle);
if (self.weapon == IT_SHOTGUN)
{
W_FireSuperSpikes ();
return;
}
if (self.ammo_nails < 1)
{
self.weapon = W_BestWeapon ();
W_SetCurrentAmmo ();
return;
}
sound (self, CHAN_WEAPON, "weapons/rocket1i.wav", 1, ATTN_NORM);
self.attack_finished = time + 0.2;
self.currentammo = self.ammo_nails = self.ammo_nails - 1;
dir = aim (self, 1000);
launch_spike (self.origin + '0 0 16' + v_right*ox, dir);
self.punchangle_x = -2;
};
/*
===============
Lazer Gun stuff
===============
*/
void() Flameball_Touch =
{
local vector org;
if (other == self.owner)
return; // don't explode on owner
if (pointcontents(self.origin) == CONTENT_SKY)
{
remove(self);
return;
}
// sound (self, CHAN_WEAPON, "enforcer/enfstop.wav", 1, ATTN_STATIC);
org = self.origin - 8*normalize(self.velocity);
if ((other.health) && (other.classname != "xmen_bishop"))
{
SpawnBlood (org, self.velocity*0.2, 12);
T_Damage (other, self, self.owner, 12);
}
else
{
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_GUNSHOT);
WriteCoord (MSG_BROADCAST, org_x);
WriteCoord (MSG_BROADCAST, org_y);
WriteCoord (MSG_BROADCAST, org_z);
}
self.origin = self.origin - 8*normalize(self.velocity);
BecomeExplosion ();
};
void() FlameballThink =
{
self.angles_z = (random() * 360) - 180;
if (self.spawn_time < (time - 6)) {
remove(self);
return;
}
self.nextthink = time + 0.1;
};
void(vector org, vector dir) Launch_Flameball =
{
newmis = spawn ();
newmis.owner = self;
newmis.movetype = MOVETYPE_FLYMISSILE;
newmis.solid = SOLID_BBOX;
newmis.angles = vectoangles(dir);
newmis.touch = Flameball_Touch;
newmis.classname = "flameball";
newmis.think = FlameballThink;
newmis.nextthink = time + 0.1;
setmodel (newmis, "progs/flamball.mdl");
setsize (newmis, VEC_ORIGIN, VEC_ORIGIN);
setorigin (newmis, org);
newmis.spawn_time = time;
newmis.angles_z = (random() * 360) - 180;
newmis.velocity = dir * 1500;
};
// X-Men: fires a laser projectile
void(float ox) W_FireFlameball =
{
local vector dir;
local entity old;
local string sample;
makevectors (self.v_angle);
sample = "weapons/f_start.wav";
if (self.last_weapon_channel != CHAN_WEAPON) {
sound (self, CHAN_WEAPON, sample, 1, ATTN_NORM);
self.last_weapon_channel = CHAN_WEAPON;
} else {
sound (self, CHAN_ITEM, sample, 1, ATTN_NORM);
self.last_weapon_channel = CHAN_ITEM;
}
if (self.ammo_nails < 1)
{
self.weapon = W_BestWeapon ();
W_SetCurrentAmmo ();
return;
}
// sound (self, CHAN_WEAPON, "enforcer/enfire.wav", 1, ATTN_NORM);
self.attack_finished = time + 0.2;
self.currentammo = self.ammo_nails = self.ammo_nails - 1;
dir = v_forward;
Launch_Flameball (self.origin + '0 0 16' + v_right*4, dir);
self.punchangle_x = -2;
};
.float hit_z;
void() spike_touch =
{
local float rand, damg;
local vector vect;
if ((other == self.owner) || (other.owner == self.owner))
return;
if (other.solid == SOLID_TRIGGER)
return; // trigger field, do nothing
if (pointcontents(self.origin) == CONTENT_SKY)
{
remove(self);
return;
}
// hit something that bleeds
if (other.takedamage)
{
if (!self.dmg)
damg = 9;
else
damg = self.dmg;
spawn_touchblood (damg);
T_Damage (other, self, self.owner, damg);
remove(self);
return;
}
else if (self.classname == "angel_dart") {
vect = normalize(self.velocity);
setorigin(self, self.origin + vect*2);
self.velocity = '0 0 0';
self.solid = SOLID_NOT;
self.movetype = MOVETYPE_NONE;
self.think = SUB_Remove;
self.nextthink = time + 5;
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_SPIKE);
WriteCoord (MSG_BROADCAST, self.origin_x);
WriteCoord (MSG_BROADCAST, self.origin_y);
WriteCoord (MSG_BROADCAST, self.origin_z);
return;
}
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
if (self.classname == "wizspike")
WriteByte (MSG_BROADCAST, TE_WIZSPIKE);
else if (self.classname == "gambit_card")
WriteByte (MSG_BROADCAST, TE_KNIGHTSPIKE);
else
WriteByte (MSG_BROADCAST, TE_SPIKE);
WriteCoord (MSG_BROADCAST, self.origin_x);
WriteCoord (MSG_BROADCAST, self.origin_y);
WriteCoord (MSG_BROADCAST, self.origin_z);
remove(self);
};
void() superspike_touch =
{
local float rand;
if (other == self.owner)
return;
if (other.solid == SOLID_TRIGGER)
return; // trigger field, do nothing
if (pointcontents(self.origin) == CONTENT_SKY)
{
remove(self);
return;
}
// hit something that bleeds
if (other.takedamage)
{
spawn_touchblood (18);
T_Damage (other, self, self.owner, 18);
}
else
{
WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte (MSG_BROADCAST, TE_SUPERSPIKE);
WriteCoord (MSG_BROADCAST, self.origin_x);
WriteCoord (MSG_BROADCAST, self.origin_y);
WriteCoord (MSG_BROADCAST, self.origin_z);
}
remove(self);
};
/*
================
W_FireFlameThrower
================
*/
void(float num_bubbles) DeathBubbles;
void() W_FireFlameThrower =
{
local string sample;
if (self.classname == "player") {
if (self.ammo_nails < 1)
{
self.weapon = W_BestWeapon ();
W_SetCurrentAmmo ();
return;
}
if (self.ammo_nails < 4)
self.ammo_nails = 0;
else
self.ammo_nails = self.ammo_nails - 4;
self.currentammo = self.ammo_nails;
if (self.waterlevel >= 3) { // can't fire while underwater
self.flags = self.flags - (self.flags & FL_FLAMEON);
self.water_flame_flag = TRUE;
DeathBubbles(1);
return;
}
}
sample = "weapons/flame.wav";
if (self.last_flame_sound < (time - SNDLEN_FLAME)) {
if (self.last_weapon_channel != CHAN_WEAPON) {
sound (self, CHAN_WEAPON, sample, 1, ATTN_NORM);
self.last_weapon_channel = CHAN_WEAPON;
} else {
sound (self, CHAN_ITEM, sample, 1, ATTN_NORM);
self.last_weapon_channel = CHAN_ITEM;
}
self.last_flame_sound = time + (random() * 0.2) - 0.05;
}
if (!(self.flags & FL_FLAMEON))
{
//bprint("starting flame..\n");
setorigin(self.flame_ent1, self.origin + v_forward * 16);
setorigin(self.flame_ent2, self.origin + v_forward * 16);
setorigin(self.flame_ent3, self.origin + v_forward * 96);
self.flame_ent1.nextthink = time + 0.05;
self.flame_ent1.speed = 0;
self.flame_ent2.speed = 0;
self.flame_ent3.speed = 0;
setmodel(self.flame_ent1, "progs/fl_th1.mdl");
setmodel(self.flame_ent2, "progs/null.spr");
setmodel(self.flame_ent3, "progs/fl_th5.mdl");
}
if (self.water_flame_flag) {
self.flags = self.flags | FL_FLAMEON;
self.water_flame_flag = FALSE;
}
self.last_flame = time;
};
void(entity ent, vector pos, float dist) movetopos =
{
local vector vect;
if (vlen(ent.origin - pos) > dist) {
vect = normalize(pos - ent.origin);
setorigin(ent, ent.origin + vect * dist);
}
else
{
setorigin(ent, pos);
}
};
void(vector p1, vector p2) FlameParticles =
{
local float rcol, rnd;
local vector vect, avect, rvect, org, vel;
// random color between 228 - 233
rnd = random();
rcol = 228 + floor(rnd * 2);
// do vector stuff
vect = normalize(p2 - p1);
avect = vectoangles(vect);
avect_x = -1 * vect_x;
makevectors(avect);
rvect = ('1 0 0' * random()) + ('0 1 0' * random()) + ('0 0 1' * random()) - '0.5 0.5 0.5';
org = p1 +
v_forward * 32 +
v_forward * rnd * FLAME_DIST * 0.5;
vel = normalize(v_forward + (rvect * 0.3) + '0 0 0.2') * 20;
particle( org, v_forward * 10, 235, 20);
particle( org, vel, rcol, 50);
// flame_ent_think() requires the following line..
makevectors(self.owner.v_angle);
};
void() flame_ent_think =
{
local entity ent, ent_parent;
local vector vect, ideal_pnt, ofs, oldangles;
local float this_dist, this_speed, dist_from, dist1, dist2, short_flag;
local entity ent_burn;
short_flag = FALSE;
// set flame distance
if (!(self.owner.flags & FL_FLAMEON)) {
//bprint("stopping flame..\n");
// if ((vlen(self.origin - self.owner.origin) < 32) ||
// (self.owner.last_flame < (time - 1))) { // flame has run out
setmodel(self.owner.flame_ent1, string_null);
setmodel(self.owner.flame_ent2, string_null);
setmodel(self.owner.flame_ent3, string_null);
self.owner.flame_ent1.effects = 0;
self.owner.flame_ent2.effects = 0;
self.owner.flame_ent3.effects = 0;
self.nextthink = -1;
return;
// }
this_dist = -2 * FLAME_DIST;
self.speed = self.speed - (FLAME_ENT_SPEED * frametime * 0.5);
if (self.speed < 0)
self.speed = 0;
}
else {
this_dist = FLAME_DIST;
}
self.nextthink = time + 0.05;
ent_burn = world;
makevectors(self.owner.v_angle);
ofs = v_forward * 32 + v_right * 10 + '0 0 36' - v_up * 28;
if (self.owner.character == CHAR_STORM)
ofs_z = ofs_z + STORM_VOFS_Z;
// move 1st junction to ideal position ****************************************************
ent = self;
ent_parent = self.owner;
traceline(ent_parent.origin + ofs - v_forward * 32, ent_parent.origin + ofs + v_forward * this_dist * 0.5, FALSE, self.owner);
dist_from = vlen(ent.origin - trace_endpos);
// ent.angles = vectoangles(v_forward);
// ent.angles_z = (360 * random()) - 180;
ent.angles = self.owner.v_angle;
ent.angles_x = -1 * ent.angles_x;
ent.angles_z = random() * 360 - 180;
movetopos(ent, trace_endpos, FLAME_ENT_SPEED * frametime);
/*
FlameParticles(ent.owner.origin + ofs * 2 - '0 0 4', ent.origin);
FlameParticles(ent.owner.origin + ofs * 2 - '0 0 4', ent.origin);
FlameParticles(ent.owner.origin + ofs * 2 - '0 0 4', ent.origin);
*/
// fill with flame bits
// FillBetweenPoints(ent_parent.origin + ofs, ent.origin, "progs/fl_th1.mdl", '0 0 0', 0.07);
// ent.effects = ent.effects | EF_MUZZLEFLASH;
if (ent.speed < FLAME_DIST) {
ent.speed = ent.speed + (FLAME_ENT_SPEED * frametime * 0.5);
if (ent.speed > FLAME_DIST)
ent.speed = FLAME_DIST;
}
if (trace_fraction < 1) {
setorigin(self.owner.flame_ent2, ent.origin);
self.owner.flame_ent2.speed = 0;
setorigin(self.owner.flame_ent3, ent.origin);
self.owner.flame_ent3.speed = 0;
if ((trace_ent != world) && (trace_ent.takedamage)) {
ent_burn = trace_ent;
}
short_flag = TRUE;
}
// T_RadiusDamage(ent, self.owner, 10, self.owner);
// move 2nd junction to ideal position ****************************************************
ent_parent = self.owner.flame_ent1;
ent = self.owner.flame_ent2;
traceline(ent_parent.origin - v_forward * 2, ent_parent.origin + v_forward * this_dist, FALSE, self.owner);
dist_from = vlen(ent.origin - trace_endpos);
if (dist_from < 4)
ent.angles = vectoangles('0 0 1');
else {
vect = normalize(ent.origin - trace_endpos);
ent.angles = vectoangles(vect);
}
ent.angles_z = (360 * random()) - 180;
this_speed = FLAME_ENT_SPEED * (dist_from / 64);
if (this_speed > (FLAME_ENT_SPEED * 2))
this_speed = FLAME_ENT_SPEED*2;
movetopos(ent, trace_endpos, dist_from / 2); //this_speed * frametime);
// movetopos(ent, trace_endpos, this_speed * frametime);
if (trace_fraction == 1) {
vect = normalize(ent.origin - ent_parent.origin);
setorigin(ent, ent_parent.origin + (vect * ent.speed));
}
// FlameParticles(ent.owner.origin, ent.origin);
// fill with flame bits
dist_from = vlen(ent.origin - ent_parent.origin);
if (dist_from > 32)
FillBetweenPoints(ent_parent.origin, ent.origin - v_forward * 30, "progs/fl_th2.mdl", '0 0 0', 0.07);
ent.effects = ent.effects | EF_DIMLIGHT;
if (ent.speed < FLAME_DIST) {
ent.speed = ent.speed + (FLAME_ENT_SPEED * frametime * 0.5);
if (ent.speed > FLAME_DIST * 0.75)
ent.speed = FLAME_DIST * 0.75;
}
if (trace_fraction < 1) {
setorigin(self.owner.flame_ent3, ent.origin);
self.owner.flame_ent3.speed = 0;
if ((trace_ent != world) && (trace_ent.takedamage)) {
ent_burn = trace_ent;
}
short_flag = TRUE;
}
if (deathmatch)
T_RadiusDamage(ent, self.owner, 15, self.owner);
else
T_RadiusDamage(ent, self.owner, 10, self.owner);
// move 3rd junction to ideal position ****************************************************
v_forward = vect;
ent_parent = self.owner.flame_ent2;
ent = self.owner.flame_ent3;
ideal_pnt = ent_parent.origin + v_forward * this_dist * 0.75;
traceline(ent_parent.origin - v_forward * 2, ideal_pnt, FALSE, self.owner);
dist_from = vlen(ent.origin - trace_endpos);
// if (dist_from < 4)
// ent.angles = vectoangles('0 0 1');
// else {
// vect = normalize(ent.origin - trace_endpos);
// ent.angles = vectoangles(vect);
// }
// ent.angles_z = (360 * random()) - 180;
ent.frame = random() * 5.9;
ent.frame = floor(ent.frame);
dist_from = vlen(ent.origin - ideal_pnt); //trace_endpos);
this_speed = FLAME_ENT_SPEED * (dist_from / 256);
if (this_speed > (FLAME_ENT_SPEED * 2))
this_speed = FLAME_ENT_SPEED*2;
this_speed = this_speed * 3;
ent.oldorigin = ent.origin;
movetopos(ent, trace_endpos, dist_from / 3); //this_speed * frametime);
if (vlen(ent.origin - ent_parent.origin) > this_dist * 0.75) {
vect = normalize(ent.origin - ent_parent.origin);
setorigin(ent, ent_parent.origin + (vect * this_dist * 0.75));
}
oldangles = ent.angles;
if ((trace_fraction == 1) && (!short_flag)) {
vect = normalize(ent.origin - ent_parent.origin);
ent.angles = vectoangles(vect);
if (ent.model != "progs/fl_th5.mdl")
setmodel(ent, "progs/fl_th5.mdl");
}
else {
vect = normalize(ent.origin - self.owner.origin);
ent.angles = vectoangles(vect);
// ent.angles_x = ent.angles_x + 45;
if (ent.model != "progs/fl_th6.mdl")
setmodel(ent, "progs/fl_th6.mdl");
}
// ent.angles_x = -1 * ent.angles_x;
// calculate Z rotation to match "sway" movement
makevectors(ent.angles);
vect = ent.origin - ent.oldorigin;
dist1 = vlen(vect + v_right);
dist2 = vlen(vect - v_right);
if ((!short_flag) && (vlen(vect) > 4)) {
if ((dist1 - dist2) > 0) { // moving towards RIGHT
ent.angles_z = MoveToAngle(oldangles_z, 320, 500);
}
else if ((dist1 - dist2) < 0) { // moving towards LEFT
ent.angles_z = MoveToAngle(oldangles_z, 40, 500);
}
}
else { // move towards 0
ent.angles_z = MoveToAngle(oldangles_z, 0, 500);
}
vect = normalize(ent.origin - ent.owner.origin);
dist_from = vlen(vect);
/*
if ((vlen(ent.origin - self.owner.origin) > FLAME_DIST) || (trace_fraction < 1)) {
// if (trace_fraction == 1) {
// vect = normalize(ent.origin - ent_parent.origin);
// setorigin(ent, ent_parent.origin + (vect * ent.speed));
// }
if (ent.model != "progs/fl_th3.mdl")
setmodel(ent, "progs/fl_th3.mdl");
}
else {
if (ent.model != "progs/fl_th2.mdl")
setmodel(ent, "progs/fl_th2.mdl");
}
*/
// FlameParticles(ent.owner.origin, ent.origin);
// fill with flame bits
// FillBetweenPoints(ent_parent.origin + vect * (dist_from / 2), ent.origin, "progs/fl_th3.mdl", '45 0 0', 0.07);
ent.effects = ent.effects | EF_DIMLIGHT;
if (ent.speed < FLAME_DIST) {
ent.speed = ent.speed + (FLAME_ENT_SPEED * frametime * 0.5);
if (ent.speed > FLAME_DIST * 0.5)
ent.speed = FLAME_DIST * 0.5;
}
if ((trace_ent != world) && (trace_ent.takedamage)) {
ent_burn = trace_ent;
}
if (deathmatch)
T_RadiusDamage(ent, self.owner, 20, self.owner);
else
T_RadiusDamage(ent, self.owner, 13, self.owner);
if (ent_burn != world && deathmatch) {
T_Damage(trace_ent, self.owner, self.owner, 8);
}
};
void() SetSpecialWeaponModel =
{
if (self.character == CHAR_WOLVERINE) {
self.weaponmodel = "progs/v_wol.mdl";
}
else if (self.character == CHAR_STORM) {
self.weaponmodel = "progs/v_sto.mdl";
}
else if (self.character == CHAR_CYCLOPS) {
self.weaponmodel = "progs/v_cyc.mdl";
}
else if (self.character == CHAR_PSYLOCKE) {
self.weaponmodel = "progs/v_psy.mdl";
}
else if (self.character == CHAR_ANGEL) {
self.weaponmodel = "progs/v_ang.mdl";
}
else if (self.character == CHAR_BEAST) {
self.weaponmodel = "progs/v_bea.mdl";
}
else if (self.character == CHAR_GAMBIT) {
self.weaponmodel = "progs/v_gam.mdl";
}
else if (self.character == CHAR_ICEMAN) {
self.weaponmodel = "progs/v_ice.mdl";
}
else if (self.character == CHAR_BISHOP) {
self.weaponmodel = "progs/v_bis.mdl";
}
else if (self.character == CHAR_ROGUE) {
self.weaponmodel = "progs/v_rog.mdl";
}
else if (self.character == CHAR_CANNONBALL) {
self.weaponmodel = "progs/v_can.mdl";
}
else if (self.character == CHAR_PHOENIX) {
self.weaponmodel = "progs/v_pho.mdl";
}
else {
self.weaponmodel = "";
sprint(self, "ERROR: Unknown character setting\n");
}
};
/*
===============================================================================
PLAYER WEAPON USE
===============================================================================
*/
void() SpecialWeaponChange;
void() W_SetCurrentAmmo =
{
// player_run (); // get out of any weapon firing states
if (self.modelindex == index_skeleton)
return;
self.items = self.items - ( self.items & (IT_SHELLS | IT_NAILS | IT_ROCKETS | IT_CELLS) );
if (self.weapon == IT_AXE)
{
self.currentammo = 0;
if (deathmatch || coop) {
SetSpecialWeaponModel();
}
else {
self.weaponmodel = "progs/v_xfist.mdl";
}
}
else if (self.weapon == IT_SHOTGUN)
{
self.currentammo = self.ammo_shells;
self.weaponmodel = "progs/v_xshot1.mdl";
self.items = self.items | IT_SHELLS;
}
else if (self.weapon == IT_SUPER_SHOTGUN)
{
self.currentammo = self.ammo_shells;
self.weaponmodel = "progs/v_xchain.mdl";
self.items = self.items | IT_SHELLS;
}
else if (self.weapon == IT_NAILGUN)
{
self.currentammo = self.ammo_nails;
self.weaponmodel = "progs/v_xfire1.mdl";
self.items = self.items | IT_NAILS;
}
else if (self.weapon == IT_SUPER_NAILGUN)
{
self.currentammo = self.ammo_nails;
self.weaponmodel = "progs/v_xflame.mdl";
self.items = self.items | IT_NAILS;
}
else if (self.weapon == IT_GRENADE_LAUNCHER)
{
self.currentammo = self.ammo_rockets;
self.weaponmodel = "progs/v_xorb.mdl";
self.items = self.items | IT_ROCKETS;
}
else if (self.weapon == IT_ROCKET_LAUNCHER)
{
self.currentammo = self.ammo_rockets;
self.weaponmodel = "progs/v_xrock.mdl";
self.items = self.items | IT_ROCKETS;
}
else if (self.weapon == IT_LIGHTNING)
{
self.currentammo = self.ammo_cells;
self.weaponmodel = "progs/v_xshock.mdl";
self.items = self.items | IT_CELLS;
}
else if (self.weapon == IT_SPECIAL_WEAPON)
{
self.currentammo = self.ammo_special;
self.weaponmodel = "progs/v_xmega.mdl";
self.items = self.items | IT_CELLS;
}
else
{
self.currentammo = 0;
self.weaponmodel = "";
}
};
float() W_BestWeapon =
{
local float it;
it = self.items;
if(self.ammo_cells >= 1 && (it & IT_LIGHTNING) )
return IT_LIGHTNING;
else if(self.ammo_rockets >= 1 && (it & IT_ROCKET_LAUNCHER) )
return IT_ROCKET_LAUNCHER;
else if(self.ammo_rockets >= 1 && (it & IT_GRENADE_LAUNCHER) )
return IT_GRENADE_LAUNCHER;
else if (self.ammo_nails >= 2 && (it & IT_SUPER_NAILGUN) )
return IT_SUPER_NAILGUN;
else if(self.ammo_shells >= 2 && (it & IT_SUPER_SHOTGUN) )
return IT_SUPER_SHOTGUN;
else if(self.ammo_nails >= 1 && (it & IT_NAILGUN) )
return IT_NAILGUN;
else if(self.ammo_shells >= 1 && (it & IT_SHOTGUN) )
return IT_SHOTGUN;
return IT_AXE;
};
float() W_CheckNoAmmo =
{
local float best;
if (self.currentammo > 0)
return TRUE;
if (self.weapon == IT_AXE)
return TRUE;
// self.nextweapon = W_BestWeapon ();
// best = W_BestWeapon ();
// SetNewWeapon(best);
// W_SetCurrentAmmo ();
// drop the weapon down
return FALSE;
};
/*
============
W_Attack
An attack impulse can be triggered now
============
*/
void() player_att1;
void() player_laser1;
void() player_flame1;
void() player_prox1;
void() player_orb;
void() player_rocket1;
void() player_shotgun1;
void() player_chain1;
void() player_fist;
void() player_mega;
void() W_Attack =
{
local float r, best;
if (self.modelindex == index_skeleton)
return;
if (self.change_weapon_status) { // no firing during fading
// sprint(self, "can't fire, changing weapons\n");
return;
}
if (self.weapon_flags & W_RELOADING) {
// sprint(self, "can't fire, reloading\n");
return;
}
if (!W_CheckNoAmmo ()) {
best = W_BestWeapon ();
SetNewWeapon(best);
return;
}
/*
if ((self.weapon == IT_NAILGUN) && (self.num_lasers >= 5))
return;
else if ((self.num_lasers > 0) && (self.weapon != IT_NAILGUN))
self.num_lasers = 0;
*/
makevectors (self.v_angle); // calculate forward angle for velocity
self.show_hostile = time + 1; // wake monsters up
if (self.weapon == IT_AXE)
{
if (deathmatch || coop) {
if ((!(self.weapon_flags & W_RELOADING)) &&
((self.character != CHAR_CANNONBALL) || (self.last_special2 < (time - 1.5)))) {
player_att1 ();
}
}
else {
player_fist();
}
// self.attack_finished = time + 0.5;
}
else if (self.weapon == IT_SHOTGUN)
{
if (self.think != player_shotgun1) {
self.weaponframe = 5;
player_shotgun1 ();
}
self.attack_finished = time + 0.3;
}
else if (self.weapon == IT_SUPER_SHOTGUN)
{
if (self.weaponframe > 11)
self.weaponframe = 6;
if (time > self.w_pausetime)
self.last_pausetime = 0;
player_chain1 ();
}
else if (self.weapon == IT_NAILGUN)
{
// self.weaponmodel = "progs/v_xlas2.mdl";
// player_nail1 ();
self.fire_reload_frames = 0;
player_laser1 ();
}
else if (self.weapon == IT_SUPER_NAILGUN)
{
player_flame1();
self.attack_finished = time + 0.1;
if (self.waterlevel < 3) { // can't fire while underwater
if (!(self.flags & FL_FLAMEON))
sound(self, CHAN_BODY, "weapons/f_start.wav", 1, ATTN_NORM);
self.flags = self.flags | FL_FLAMEON;
}
}
else if (self.weapon == IT_GRENADE_LAUNCHER)
{
player_orb();
// W_FireGrenade();
}
else if (self.weapon == IT_ROCKET_LAUNCHER)
{
player_rocket1();
// W_FireRocket();
W_FireGuidedRockets();
self.attack_finished = time + 1.6;
}
else if (self.weapon == IT_LIGHTNING)
{
// if (self.prox_ent != world)
// return;
player_prox1();
self.attack_finished = time + 0.2;
// sound (self, CHAN_AUTO, "weapons/lstart.wav", 1, ATTN_NORM);
}
else if (self.weapon == IT_SPECIAL_WEAPON)
{
player_mega();
self.attack_finished = time + 0.2;
sound (self, CHAN_ITEM, "weapons/m_start.wav", 1, ATTN_NORM);
sound (self, CHAN_WEAPON, "weapons/mega.wav", 1, ATTN_NONE);
}
};
float(float wpn) GetLastMoveFrame =
{
if (wpn == IT_SHOTGUN) return 25;
if (wpn == IT_SUPER_SHOTGUN) return 12;
if (wpn == IT_NAILGUN) return 15;
if (wpn == IT_SUPER_NAILGUN) return 9;
if (wpn == IT_GRENADE_LAUNCHER) return 18;
if (wpn == IT_LIGHTNING) return 0;
if (wpn == IT_ROCKET_LAUNCHER) return 17;
if (wpn == IT_AXE)
if (deathmatch || coop)
return 0;
else
return 16;
return 0;
};
float(float wpn) GetFirstMoveFrame =
{
if (wpn == IT_SHOTGUN) return 30; // NOTE: frame 31 = frame 1
if (wpn == IT_SUPER_SHOTGUN) return 17;
if (wpn == IT_NAILGUN) return 20;
if (wpn == IT_SUPER_NAILGUN) return 15;
if (wpn == IT_GRENADE_LAUNCHER) return 23;
if (wpn == IT_LIGHTNING) return 4;
if (wpn == IT_ROCKET_LAUNCHER) return 23;
if (wpn == IT_AXE)
if (deathmatch || coop)
return 5;
else
return 22;
return 0;
};
// Return true if next weapon is on a different hand to the current weapon
float() ChangingHands =
{
if ((deathmatch || coop) && (self.nextweapon == IT_AXE) && (self.weapon != IT_AXE))
return TRUE;
if (self.nextweapon == IT_LIGHTNING)
return TRUE;
if (self.nextweapon == IT_SPECIAL_WEAPON)
return TRUE;
if ((self.nextweapon & (IT_SHOTGUN | IT_SUPER_SHOTGUN | IT_AXE)) &&
(self.weapon & (IT_NAILGUN | IT_SUPER_NAILGUN | IT_ROCKET_LAUNCHER | IT_GRENADE_LAUNCHER))) {
return TRUE;
}
if ((self.nextweapon & (IT_NAILGUN | IT_SUPER_NAILGUN | IT_ROCKET_LAUNCHER | IT_GRENADE_LAUNCHER)) &&
(self.weapon & (IT_SHOTGUN | IT_SUPER_SHOTGUN | IT_AXE))) {
return TRUE;
}
};
/*
=================
FADE WEAPON OUT
=================
*/
void() FadeWeaponOut =
{
local float newframe;
local string str;
if (self.weapon_flags & W_RELOADING)
return;
if (self.chasecam != world) { // change immediately
self.weapon = self.nextweapon;
if (self.weapon == IT_AXE)
SpecialWeaponChange();
W_SetCurrentAmmo ();
self.weaponframe = newframe;
self.change_weapon_status = CW_FADEIN;
}
self.last_fade = time;
//bprint("fade out\n");
if (self.weapon & (IT_NAILGUN | IT_SUPER_NAILGUN | IT_ROCKET_LAUNCHER | IT_SHOTGUN | IT_SUPER_SHOTGUN | IT_AXE | IT_GRENADE_LAUNCHER)) {
self.weaponframe = self.weaponframe - 1;
if (self.weaponframe <= self.fadeout_endframe) {
if ((self.fadeout_endframe == 0) && (ChangingHands()) && (GetLastMoveFrame(self.weapon) > 0)) {
self.fadeout_endframe = GetLastMoveFrame(self.weapon);
self.weaponframe = GetFirstMoveFrame(self.weapon);
return;
}
// if we're still here then weapon must have completed fading out
if (ChangingHands()) {
newframe = GetLastMoveFrame(self.nextweapon);
self.fadein_endframe = GetFirstMoveFrame(self.nextweapon);
}
else {
newframe = 0;
self.fadein_endframe = 5; // all morphing animations end at frame 5
}
self.weapon = self.nextweapon;
if (self.weapon == IT_AXE)
SpecialWeaponChange();
W_SetCurrentAmmo ();
self.weaponframe = newframe;
self.change_weapon_status = CW_FADEIN;
}
}
else {
self.weaponframe = 0;
self.weapon = self.nextweapon;
if (self.weapon == IT_AXE)
SpecialWeaponChange();
W_SetCurrentAmmo ();
self.change_weapon_status = CW_FADEIN;
}
};
/*
=================
FADE WEAPON IN
=================
*/
void() FadeWeaponIn =
{
local string str;
if (self.chasecam != world) { // change immediately
self.weaponframe = self.weapon_idleframe;
self.change_weapon_status = CW_DONE;
return;
}
self.last_fade = time;
if (self.weapon & (IT_SHOTGUN | IT_SUPER_SHOTGUN | IT_NAILGUN | IT_SUPER_NAILGUN | IT_AXE | IT_GRENADE_LAUNCHER | IT_ROCKET_LAUNCHER)) {
self.weaponframe = self.weaponframe + 1;
if (self.weaponframe >= self.fadein_endframe) {
if (self.fadein_endframe >= 10) { // weapon has entered the screen
self.fadein_endframe = self.weapon_idleframe;
self.weaponframe = 0;
}
else {
self.change_weapon_status = CW_DONE;
}
}
}
else if (self.weapon == IT_SPECIAL_WEAPON) {
self.weaponframe = self.weaponframe + 1;
if (self.weaponframe == 11) {
self.change_weapon_status = CW_DONE;
}
}
else {
self.weaponframe = self.weapon_idleframe;
self.change_weapon_status = CW_DONE;
}
};
// Starts the morphing towards the new weapon
void(float wpn) SetNewWeapon =
{
// if (wpn & IT_LIGHTNING) {
// return;
// }
if (deathmatch == DM_SPECIAL_POWERS) {
self.weapon_idleframe = 6;
return;
}
if ((self.think != player_run) && (self.think != player_stand1)) // only change if idle
return;
if (wpn == self.weapon)
return;
if ((self.weapon == IT_LIGHTNING) &&
(self.prox_ent != world))
return;
// make sure we start at the idle frame
self.weaponframe = self.weapon_idleframe;
if ((deathmatch || coop) && (wpn == IT_AXE)) {
self.weapon_idleframe = 6;
}
else {
self.weapon_idleframe = 5;
}
self.nextweapon = wpn;
self.change_weapon_status = CW_FADEOUT;
self.fadeout_endframe = 0;
FadeWeaponOut();
};
/*
============
W_ChangeWeapon
============
*/
void() W_ChangeWeapon =
{
local float it, am, fl, new_idle;
if (self.modelindex == index_skeleton)
return;
if ((deathmatch == DM_SPECIAL_POWERS) && (self.impulse != 1))
return;
it = self.items;
am = 0;
if (self.impulse == 1)
{
fl = IT_AXE;
new_idle = 6;
if ((deathmatch || coop) && (self.weapon == IT_AXE)) {
self.special_weapon = !self.special_weapon;
}
}
else if (self.impulse == 2)
{
fl = IT_SHOTGUN;
new_idle = 5;
if (self.ammo_shells < 2)
am = 1;
}
else if (self.impulse == 3)
{
fl = IT_SUPER_SHOTGUN;
new_idle = 5;
if (self.ammo_shells < 1)
am = 1;
}
else if (self.impulse == 4)
{
fl = IT_NAILGUN;
new_idle = 5;
if (self.ammo_nails < 1)
am = 1;
}
else if (self.impulse == 5)
{
fl = IT_SUPER_NAILGUN;
if (self.ammo_nails < 2)
am = 1;
}
else if (self.impulse == 6)
{
fl = IT_GRENADE_LAUNCHER;
new_idle = 5;
if (self.ammo_rockets < 1)
am = 1; // not available yet
}
else if (self.impulse == 7)
{
fl = IT_ROCKET_LAUNCHER;
new_idle = 5;
if (self.ammo_rockets < 1)
am = 1;
}
else if (self.impulse == 8)
{
fl = IT_LIGHTNING;
new_idle = 2;
if (self.ammo_cells < 1)
am = 1;
}
else if (self.impulse == 13) // mega-weapon
{
fl = IT_SPECIAL_WEAPON;
new_idle = 11;
if (self.ammo_special < 1)
am = 1;
}
self.impulse = 0;
if ((!(self.items & fl)) && (deathmatch || coop)) // X-Men: in singleplayer, weapons are already present
{ // don't have the weapon or the ammo
sprint (self, "no weapon.\n");
return;
}
if (am)
{ // don't have the ammo
sprint (self, "not enough ammo.\n");
return;
}
//
// set weapon, set ammo
//
// self.weapon_idleframe = new_idle;
if (self.weapon != fl)
SetNewWeapon(fl);
else if (self.weapon == IT_AXE) {
self.weapon = fl;
SpecialWeaponChange();
W_SetCurrentAmmo ();
}
};
/*
============
CheatCommand
============
*/
void() CheatCommand = // cheats disabled
{
if (deathmatch)// || coop)
return;
self.ammo_rockets = 100;
self.ammo_nails = 200;
self.ammo_shells = 150;
self.items = self.items |
IT_AXE |
IT_SHOTGUN |
IT_SUPER_SHOTGUN |
IT_NAILGUN |
IT_SUPER_NAILGUN |
IT_GRENADE_LAUNCHER |
IT_ROCKET_LAUNCHER |
IT_KEY1 | IT_KEY2;
self.ammo_cells = 200;
self.items = self.items | IT_LIGHTNING;
// SetNewWeapon(IT_ROCKET_LAUNCHER);
// self.weapon = IT_ROCKET_LAUNCHER;
self.impulse = 0;
// W_SetCurrentAmmo ();
};
/*
============
CycleWeaponCommand
Go to the next weapon with ammo
============
*/
void() CycleWeaponCommand =
{
local float it, am, fl;
if (self.modelindex == index_skeleton)
return;
it = self.items;
self.impulse = 0;
fl = self.weapon;
if (deathmatch == DM_SPECIAL_POWERS) {
self.special_weapon = !self.special_weapon;
self.weapon = fl;
SpecialWeaponChange();
W_SetCurrentAmmo ();
return;
}
while (1)
{
am = 0;
if (fl == IT_LIGHTNING)
{
fl = IT_AXE;
}
else if (fl == IT_AXE)
{
fl = IT_SHOTGUN;
if (self.ammo_shells < 1)
am = 1;
}
else if (fl == IT_SHOTGUN)
{
fl = IT_SUPER_SHOTGUN;
if (self.ammo_shells < 2)
am = 1;
}
else if (fl == IT_SUPER_SHOTGUN)
{
fl = IT_NAILGUN;
if (self.ammo_nails < 1)
am = 1;
}
else if (fl == IT_NAILGUN)
{
fl = IT_SUPER_NAILGUN;
if (self.ammo_nails < 2)
am = 1;
}
else if (fl == IT_SUPER_NAILGUN)
{
fl = IT_GRENADE_LAUNCHER;
if (self.ammo_rockets < 1)
am = 1;
}
else if (fl == IT_GRENADE_LAUNCHER)
{
fl = IT_ROCKET_LAUNCHER;
if (self.ammo_rockets < 1)
am = 1;
}
else if (fl == IT_ROCKET_LAUNCHER)
{
fl = IT_LIGHTNING;
if (self.ammo_cells < 1)
am = 1;
}
if (am == 0)
{
SetNewWeapon(fl);
// W_SetCurrentAmmo ();
return;
}
}
};
/*
============
CycleWeaponReverseCommand
Go to the prev weapon with ammo
============
*/
void() CycleWeaponReverseCommand =
{
local float it, am, fl;
if (self.modelindex == index_skeleton)
return;
it = self.items;
self.impulse = 0;
fl = self.weapon;
if (deathmatch == DM_SPECIAL_POWERS) {
self.special_weapon = !self.special_weapon;
self.weapon = fl;
SpecialWeaponChange();
W_SetCurrentAmmo ();
return;
}
while (1)
{
am = 0;
if (fl == IT_LIGHTNING)
{
fl = IT_ROCKET_LAUNCHER;
if (self.ammo_rockets < 1)
am = 1;
}
else if (fl == IT_ROCKET_LAUNCHER)
{
fl = IT_GRENADE_LAUNCHER;
if (self.ammo_rockets < 1)
am = 1;
}
else if (fl == IT_GRENADE_LAUNCHER)
{
fl = IT_SUPER_NAILGUN;
if (self.ammo_nails < 2)
am = 1;
}
else if (fl == IT_SUPER_NAILGUN)
{
fl = IT_NAILGUN;
if (self.ammo_nails < 1)
am = 1;
}
else if (fl == IT_NAILGUN)
{
fl = IT_SUPER_SHOTGUN;
if (self.ammo_shells < 2)
am = 1;
}
else if (fl == IT_SUPER_SHOTGUN)
{
fl = IT_SHOTGUN;
if (self.ammo_shells < 1)
am = 1;
}
else if (fl == IT_SHOTGUN)
{
fl = IT_AXE;
}
else if (fl == IT_AXE)
{
fl = IT_LIGHTNING;
if (self.ammo_cells < 1)
am = 1;
}
if (am == 0)
{
SetNewWeapon(fl);
// W_SetCurrentAmmo ();
return;
}
}
};
/*
============
ServerflagsCommand
Just for development
============
*/
void() ServerflagsCommand =
{
serverflags = serverflags * 2 + 1;
};
void() QuadCheat =
{
if (deathmatch || coop)
return;
self.super_time = 1;
self.super_damage_finished = time + 30;
self.items = self.items | IT_QUAD;
dprint ("quad cheat\n");
};
/*
============
Impulse Commands
============
*/
float capture, last_capture, capture_count, capture_index;
void() ImpulseCommands =
{
local float ftemp;
local string str;
if (self.impulse == 248) {
capture = !capture;
capture_index = 0;
}
if (!((self.change_weapon_status) || (self.weapon_flags & W_RELOADING) || ((self.think != player_run) && (self.think != player_stand1)))) {
// weapon is ready for changing
if (self.remember_impulse && (self.remember_impulse != 13)) { // prevent from changing while waiting for mega-weapon to come up
self.impulse = self.remember_impulse;
self.remember_impulse = 0;
}
if ((self.impulse >= 1 && self.impulse <= 8) || (self.impulse == 13))
W_ChangeWeapon ();
else if (self.impulse == 10)
CycleWeaponCommand ();
else if (self.impulse == 12)
CycleWeaponReverseCommand ();
}
else {
if ((self.impulse <= 13) && (!self.remember_impulse))
self.remember_impulse = self.impulse;
}
if (!self.impulse)
return;
else if (self.impulse == 11)
ServerflagsCommand ();
else if (self.impulse == 20) // re-print last trigger_multiple/single message
centerprint(self, self.last_centerprint);
else if (self.impulse == 40) // toggle chasecam
{
if (self.chasecam == world)
InitCam(self);
else
DisableCam(self);
}
// any impulses > 200 are debuggin only
if (deathmatch) {
self.impulse = 0;
return;
}
else if (self.impulse == 99)
CheatCommand ();
else if (self.impulse == 200)
show_damage = !show_damage;
else if (self.impulse == 202) { // give all weapon parts
self.weapon_parts = 4;
serverflags = serverflags | 15;
}
else if (self.impulse == 250) {
ftemp = cvar("coop") - 1;
if (ftemp < 1) ftemp = 12;
str = ftos(ftemp);
cvar_set("coop", str);
stuffcmd(self, "restart\n");
}
else if (self.impulse == 251) {
ftemp = cvar("coop") + 1;
if (ftemp > 12) ftemp = 1;
str = ftos(ftemp);
cvar_set("coop", str);
stuffcmd(self, "restart\n");
}
else if (self.impulse == 222) {
if (self.x_flags & X_GODCHEAT) {
self.x_flags = self.x_flags - X_GODCHEAT;
self.flags = self.flags - (self.flags & FL_GODMODE);
stuffcmd(self, "bf\n");
sprint(self, "Invincibility disabled\n");
}
else {
self.x_flags = self.x_flags | X_GODCHEAT;
self.flags = self.flags | FL_GODMODE;
sprint(self, "Invincibility enabled\n");
}
}
// else if (self.impulse == 255)
// QuadCheat ();
self.impulse = 0;
};
/*
============
W_WeaponFrame
Called every frame so impulse events can be handled as well as possible
============
*/
void() W_WeaponFrame =
{
if ((self.change_weapon_status) && (self.last_fade < (time - 0.07))) {
if (self.change_weapon_status == CW_FADEOUT)
FadeWeaponOut();
else
FadeWeaponIn();
}
ImpulseCommands ();
if (time < self.attack_finished)
return;
if (self.change_weapon_status)
return;
// check for attack
if ((self.button0) && (self.modelindex != index_skeleton))
{
SuperDamageSound ();
W_Attack ();
if ((self.flags & FL_FLAMEON) &&
(self.weapon != IT_SUPER_NAILGUN)) {
self.flags = self.flags - FL_FLAMEON;
}
}
else {
self.flags = self.flags - (self.flags & FL_FLAMEON);
}
};
/*
========
SuperDamageSound
Plays sound if needed
========
*/
void() SuperDamageSound =
{
if (self.super_damage_finished > time)
{
if (self.super_sound < time)
{
self.super_sound = time + 1;
sound (self, CHAN_BODY, "items/damage3.wav", 1, ATTN_NORM);
}
}
return;
};
Reference in a new issue View git blame Copy permalink