#define VEHICLE_BUMBLEBEE
#include "bumblebee.qh"
-#include "bumblebee_weapons.qc"
+#include "bumblebee_weapons.qh"
CLASS(Bumblebee, Vehicle)
/* spawnflags */ ATTRIB(Bumblebee, spawnflags, int, VHF_DMGSHAKE);
/* mins */ ATTRIB(Bumblebee, mins, vector, '-245 -130 -130');
/* maxs */ ATTRIB(Bumblebee, maxs, vector, '230 130 130');
+/* view offset*/ ATTRIB(Bumblebee, view_ofs, vector, '0 0 300');
+/* view dist */ ATTRIB(Bumblebee, height, float, 450);
/* model */ ATTRIB(Bumblebee, mdl, string, "models/vehicles/bumblebee_body.dpm");
/* model */ ATTRIB(Bumblebee, model, string, "models/vehicles/bumblebee_body.dpm");
/* head_model */ ATTRIB(Bumblebee, head_model, string, "");
ENDCLASS(Bumblebee)
REGISTER_VEHICLE(BUMBLEBEE, NEW(Bumblebee));
+#ifndef MENUQC
+ MODEL(VEH_BUMBLEBEE_GUNCOCKPIT, "models/vehicles/wakizashi_cockpit.dpm");
+#endif
+
#endif
#ifdef IMPLEMENTATION
const float BRG_START = 4;
const float BRG_END = 8;
-#include "bumblebee_weapons.qc"
-
#ifdef SVQC
-float autocvar_g_vehicle_bumblebee_speed_forward;
-float autocvar_g_vehicle_bumblebee_speed_strafe;
-float autocvar_g_vehicle_bumblebee_speed_up;
-float autocvar_g_vehicle_bumblebee_speed_down;
-float autocvar_g_vehicle_bumblebee_turnspeed;
-float autocvar_g_vehicle_bumblebee_pitchspeed;
-float autocvar_g_vehicle_bumblebee_pitchlimit;
-float autocvar_g_vehicle_bumblebee_friction;
-
-float autocvar_g_vehicle_bumblebee_energy;
-float autocvar_g_vehicle_bumblebee_energy_regen;
-float autocvar_g_vehicle_bumblebee_energy_regen_pause;
-
-float autocvar_g_vehicle_bumblebee_health;
-float autocvar_g_vehicle_bumblebee_health_regen;
-float autocvar_g_vehicle_bumblebee_health_regen_pause;
-
-float autocvar_g_vehicle_bumblebee_shield;
-float autocvar_g_vehicle_bumblebee_shield_regen;
-float autocvar_g_vehicle_bumblebee_shield_regen_pause;
-
-float autocvar_g_vehicle_bumblebee_cannon_ammo;
-float autocvar_g_vehicle_bumblebee_cannon_ammo_regen;
-float autocvar_g_vehicle_bumblebee_cannon_ammo_regen_pause;
+float autocvar_g_vehicle_bumblebee_respawntime = 60;
+
+float autocvar_g_vehicle_bumblebee_speed_forward = 350;
+float autocvar_g_vehicle_bumblebee_speed_strafe = 350;
+float autocvar_g_vehicle_bumblebee_speed_up = 350;
+float autocvar_g_vehicle_bumblebee_speed_down = 350;
+float autocvar_g_vehicle_bumblebee_turnspeed = 120;
+float autocvar_g_vehicle_bumblebee_pitchspeed = 60;
+float autocvar_g_vehicle_bumblebee_pitchlimit = 60;
+float autocvar_g_vehicle_bumblebee_friction = 0.5;
+
+float autocvar_g_vehicle_bumblebee_energy = 500;
+float autocvar_g_vehicle_bumblebee_energy_regen = 50;
+float autocvar_g_vehicle_bumblebee_energy_regen_pause = 1;
+
+float autocvar_g_vehicle_bumblebee_health = 1000;
+float autocvar_g_vehicle_bumblebee_health_regen = 65;
+float autocvar_g_vehicle_bumblebee_health_regen_pause = 10;
+
+float autocvar_g_vehicle_bumblebee_shield = 400;
+float autocvar_g_vehicle_bumblebee_shield_regen = 150;
+float autocvar_g_vehicle_bumblebee_shield_regen_pause = 0.75;
+
+float autocvar_g_vehicle_bumblebee_cannon_ammo = 100;
+float autocvar_g_vehicle_bumblebee_cannon_ammo_regen = 100;
+float autocvar_g_vehicle_bumblebee_cannon_ammo_regen_pause = 1;
float autocvar_g_vehicle_bumblebee_cannon_lock = 0;
-float autocvar_g_vehicle_bumblebee_cannon_turnspeed;
-float autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down;
-float autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up;
-float autocvar_g_vehicle_bumblebee_cannon_turnlimit_in;
-float autocvar_g_vehicle_bumblebee_cannon_turnlimit_out;
+float autocvar_g_vehicle_bumblebee_cannon_turnspeed = 160;
+float autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down = 60;
+float autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up = 60;
+float autocvar_g_vehicle_bumblebee_cannon_turnlimit_in = 20;
+float autocvar_g_vehicle_bumblebee_cannon_turnlimit_out = 80;
-float autocvar_g_vehicle_bumblebee_raygun_turnspeed;
-float autocvar_g_vehicle_bumblebee_raygun_pitchlimit_down;
-float autocvar_g_vehicle_bumblebee_raygun_pitchlimit_up;
-float autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides;
+float autocvar_g_vehicle_bumblebee_raygun_turnspeed = 180;
+float autocvar_g_vehicle_bumblebee_raygun_pitchlimit_down = 20;
+float autocvar_g_vehicle_bumblebee_raygun_pitchlimit_up = 5;
+float autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides = 35;
-float autocvar_g_vehicle_bumblebee_raygun_range;
-float autocvar_g_vehicle_bumblebee_raygun_dps;
-float autocvar_g_vehicle_bumblebee_raygun_aps;
-float autocvar_g_vehicle_bumblebee_raygun_fps;
+bool autocvar_g_vehicle_bumblebee_raygun = false;
+float autocvar_g_vehicle_bumblebee_raygun_range = 2048;
+float autocvar_g_vehicle_bumblebee_raygun_dps = 250;
+float autocvar_g_vehicle_bumblebee_raygun_aps = 100;
+float autocvar_g_vehicle_bumblebee_raygun_fps = 100;
-float autocvar_g_vehicle_bumblebee_raygun;
-float autocvar_g_vehicle_bumblebee_healgun_hps;
-float autocvar_g_vehicle_bumblebee_healgun_hmax;
-float autocvar_g_vehicle_bumblebee_healgun_aps;
-float autocvar_g_vehicle_bumblebee_healgun_amax;
-float autocvar_g_vehicle_bumblebee_healgun_sps;
-float autocvar_g_vehicle_bumblebee_healgun_locktime;
+float autocvar_g_vehicle_bumblebee_healgun_hps = 150;
+float autocvar_g_vehicle_bumblebee_healgun_hmax = 100;
+float autocvar_g_vehicle_bumblebee_healgun_aps = 75;
+float autocvar_g_vehicle_bumblebee_healgun_amax = 100;
+float autocvar_g_vehicle_bumblebee_healgun_sps = 100;
+float autocvar_g_vehicle_bumblebee_healgun_locktime = 2.5;
-float autocvar_g_vehicle_bumblebee_respawntime;
+float autocvar_g_vehicle_bumblebee_blowup_radius = 500;
+float autocvar_g_vehicle_bumblebee_blowup_coredamage = 500;
+float autocvar_g_vehicle_bumblebee_blowup_edgedamage = 100;
+float autocvar_g_vehicle_bumblebee_blowup_forceintensity = 600;
+vector autocvar_g_vehicle_bumblebee_bouncepain = '1 100 200';
-float autocvar_g_vehicle_bumblebee_blowup_radius;
-float autocvar_g_vehicle_bumblebee_blowup_coredamage;
-float autocvar_g_vehicle_bumblebee_blowup_edgedamage;
-float autocvar_g_vehicle_bumblebee_blowup_forceintensity;
-vector autocvar_g_vehicle_bumblebee_bouncepain;
+bool autocvar_g_vehicle_bumblebee = true;
-bool autocvar_g_vehicle_bumblebee = 0;
+bool bumblebee_gunner_frame(entity this)
+{
+ entity vehic = this.vehicle.owner;
+ entity gun = this.vehicle;
+ return = true;
-float bumblebee_gunner_frame()
-{SELFPARAM();
- entity vehic = self.vehicle.owner;
- entity gun = self.vehicle;
- entity gunner = self;
- setself(vehic);
+ // this isn't technically a vehicle (yet), let's not do frame functions on it (yet)
+ //vehicles_frame(gun, player);
vehic.solid = SOLID_NOT;
- //setorigin(gunner, vehic.origin);
- gunner.velocity = vehic.velocity;
+ //setorigin(this, vehic.origin);
+ this.velocity = vehic.velocity;
float _in, _out;
vehic.angles_x *= -1;
{
_in = autocvar_g_vehicle_bumblebee_cannon_turnlimit_in;
_out = autocvar_g_vehicle_bumblebee_cannon_turnlimit_out;
- setorigin(gunner, vehic.origin + v_up * -16 + v_forward * -16 + v_right * 128);
+ setorigin(this, vehic.origin + v_up * -16 + v_forward * -16 + v_right * 128);
}
else
{
_in = autocvar_g_vehicle_bumblebee_cannon_turnlimit_out;
_out = autocvar_g_vehicle_bumblebee_cannon_turnlimit_in;
- setorigin(gunner, vehic.origin + v_up * -16 + v_forward * -16 + v_right * -128);
+ setorigin(this, vehic.origin + v_up * -16 + v_forward * -16 + v_right * -128);
}
- crosshair_trace(gunner);
+ crosshair_trace(this);
vector _ct = trace_endpos;
vector ad;
if(autocvar_g_vehicle_bumblebee_cannon_lock)
{
if(gun.lock_time < time)
- gun.enemy = world;
+ gun.enemy = NULL;
if(trace_ent)
if(trace_ent.movetype)
if(trace_ent.takedamage)
- if(!trace_ent.deadflag)
+ if(!IS_DEAD(trace_ent) && !STAT(FROZEN, trace_ent))
{
- if(DIFF_TEAM(trace_ent, gunner))
+ if(DIFF_TEAM(trace_ent, this))
{
gun.enemy = trace_ent;
gun.lock_time = time + 5;
ad = vf;
- distance = vlen(ad - gunner.origin);
+ distance = vlen(ad - this.origin);
impact_time = distance / autocvar_g_vehicle_bumblebee_cannon_speed;
ad = vf + _vel * impact_time;
trace_endpos = ad;
- UpdateAuxiliaryXhair(gunner, ad, '1 0 1', 1);
+ UpdateAuxiliaryXhair(this, ad, '1 0 1', 1);
vehicle_aimturret(vehic, trace_endpos, gun, "fire",
autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1, autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up,
_out * -1, _in, autocvar_g_vehicle_bumblebee_cannon_turnspeed);
autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1, autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up,
_out * -1, _in, autocvar_g_vehicle_bumblebee_cannon_turnspeed);
- if(!forbidWeaponUse(gunner))
- if(gunner.BUTTON_ATCK)
+ if(!forbidWeaponUse(this))
+ if(PHYS_INPUT_BUTTON_ATCK(this))
if(time > gun.attack_finished_single[0])
if(gun.vehicle_energy >= autocvar_g_vehicle_bumblebee_cannon_cost)
{
gun.vehicle_energy -= autocvar_g_vehicle_bumblebee_cannon_cost;
- bumblebee_fire_cannon(gun, "fire", gunner);
+ bumblebee_fire_cannon(vehic, gun, "fire", this);
gun.delay = time;
gun.attack_finished_single[0] = time + autocvar_g_vehicle_bumblebee_cannon_refire;
}
- VEHICLE_UPDATE_PLAYER(gunner, health, bumblebee);
+ VEHICLE_UPDATE_PLAYER(this, vehic, health, bumblebee);
if(vehic.vehicle_flags & VHF_HASSHIELD)
- VEHICLE_UPDATE_PLAYER(gunner, shield, bumblebee);
+ VEHICLE_UPDATE_PLAYER(this, vehic, shield, bumblebee);
ad = gettaginfo(gun, gettagindex(gun, "fire"));
traceline(ad, ad + v_forward * MAX_SHOT_DISTANCE, MOVE_NORMAL, gun);
- UpdateAuxiliaryXhair(gunner, trace_endpos, ('1 0 0' * gunner.vehicle_reload1) + ('0 1 0' *(1 - gunner.vehicle_reload1)), 0);
+ UpdateAuxiliaryXhair(this, trace_endpos, ('1 0 0' * this.vehicle_reload1) + ('0 1 0' *(1 - this.vehicle_reload1)), 0);
if(vehic.owner)
- UpdateAuxiliaryXhair(vehic.owner, trace_endpos, ('1 0 0' * gunner.vehicle_reload1) + ('0 1 0' *(1 - gunner.vehicle_reload1)), ((gunner == vehic.gunner1) ? 1 : 2));
+ UpdateAuxiliaryXhair(vehic.owner, trace_endpos, ('1 0 0' * this.vehicle_reload1) + ('0 1 0' *(1 - this.vehicle_reload1)), ((this == vehic.gunner1) ? 1 : 2));
vehic.solid = SOLID_BBOX;
- gunner.BUTTON_ATCK = gunner.BUTTON_ATCK2 = gunner.BUTTON_CROUCH = 0;
- gunner.vehicle_energy = (gun.vehicle_energy / autocvar_g_vehicle_bumblebee_cannon_ammo) * 100;
-
- setself(gunner);
- return 1;
+ PHYS_INPUT_BUTTON_ATCK(this) = PHYS_INPUT_BUTTON_ATCK2(this) = PHYS_INPUT_BUTTON_CROUCH(this) = false;
+ this.vehicle_energy = (gun.vehicle_energy / autocvar_g_vehicle_bumblebee_cannon_ammo) * 100;
}
vector bumblebee_gunner_findgoodexit(vector prefer_spot, entity gunner, entity player)
//vector exitspot;
float mysize;
- tracebox(gunner.origin + '0 0 32', PL_MIN, PL_MAX, prefer_spot, MOVE_NORMAL, player);
+ tracebox(gunner.origin + '0 0 32', STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), prefer_spot, MOVE_NORMAL, player);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return prefer_spot;
- mysize = 1.5 * vlen(PL_MAX - PL_MIN); // can't use gunner's size, as they don't have a size
+ mysize = 1.5 * vlen(STAT(PL_MAX, NULL) - STAT(PL_MIN, NULL)); // can't use gunner's size, as they don't have a size
float i;
vector v, v2;
v2 = 0.5 * (gunner.absmin + gunner.absmax);
v = randomvec();
v_z = 0;
v = v2 + normalize(v) * mysize;
- tracebox(v2, PL_MIN, PL_MAX, v, MOVE_NORMAL, player);
+ tracebox(v2, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), v, MOVE_NORMAL, player);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return v;
}
return prefer_spot; // this should be considered a fallback?!
}
-void bumblebee_gunner_exit(int _exitflag)
-{SELFPARAM();
- entity player = self;
- entity gunner = player.vehicle;
+void bumblebee_gunner_exit(entity this, int _exitflag)
+{
+ entity player = ((this.owner.gun1 == this) ? this.owner.gunner1 : this.owner.gunner2);
+ entity gunner = this;
entity vehic = gunner.owner;
if(IS_REAL_CLIENT(player))
}
CSQCVehicleSetup(player, HUD_NORMAL);
- setsize(player, PL_MIN, PL_MAX);
+ setsize(player, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL));
player.takedamage = DAMAGE_AIM;
player.solid = SOLID_SLIDEBOX;
player.effects &= ~EF_NODRAW;
player.alpha = 1;
player.PlayerPhysplug = func_null;
- player.view_ofs = PL_VIEW_OFS;
+ player.view_ofs = STAT(PL_VIEW_OFS, NULL);
player.event_damage = PlayerDamage;
player.hud = HUD_NORMAL;
player.teleportable = TELEPORT_NORMAL;
- player.switchweapon = gunner.switchweapon;
+ PS(player).m_switchweapon = gunner.m_switchweapon;
player.vehicle_enter_delay = time + 2;
fixedmakevectors(vehic.angles);
- if(player == vehic.gunner1) { vehic.gunner1 = world; }
- if(player == vehic.gunner2) { vehic.gunner2 = world; v_right *= -1; }
+ if(player == vehic.gunner1) { vehic.gunner1 = NULL; }
+ if(player == vehic.gunner2) { vehic.gunner2 = NULL; v_right *= -1; }
vector spot = real_origin(gunner);
spot = spot + v_up * 128 + v_forward * 300 + v_right * 150;
MUTATOR_CALLHOOK(VehicleExit, player, gunner);
- player.vehicle = world;
+ player.vehicle = NULL;
}
-bool bumblebee_gunner_enter()
-{SELFPARAM();
- entity vehic = self;
- entity player = other;
- entity gunner = world;
+bool bumblebee_gunner_enter(entity this, entity player)
+{
+ entity vehic = this;
+ entity gunner = NULL;
if(!vehic.gunner1 && !vehic.gunner2 && ((time >= vehic.gun1.phase) + (time >= vehic.gun2.phase)) == 2)
{
// we can have some fun
- if(vlen(real_origin(vehic.gun2) - player.origin) < vlen(real_origin(vehic.gun1) - player.origin))
+ if(vlen2(real_origin(vehic.gun2) - player.origin) < vlen2(real_origin(vehic.gun1) - player.origin))
{
gunner = vehic.gun2;
vehic.gunner2 = player;
RemoveGrapplingHook(player);
- gunner.switchweapon = player.switchweapon;
+ gunner.m_switchweapon = PS(player).m_switchweapon;
gunner.vehicle_exit = bumblebee_gunner_exit;
gunner.vehicle_hudmodel.viewmodelforclient = player;
return true;
}
-bool vehicles_valid_pilot()
-{SELFPARAM();
- if(IS_BOT_CLIENT(other) && !autocvar_g_vehicles_allow_bots)
+bool vehicles_valid_pilot(entity this, entity toucher)
+{
+ if(IS_BOT_CLIENT(toucher) && !autocvar_g_vehicles_allow_bots)
return false;
- if((!IS_PLAYER(other))
- || (other.deadflag != DEAD_NO)
- || (other.vehicle)
- || (DIFF_TEAM(other, self))
+ if((!IS_PLAYER(toucher))
+ || (IS_DEAD(toucher))
+ || (toucher.vehicle)
+ || (DIFF_TEAM(toucher, this))
) { return false; }
return true;
}
-void bumblebee_touch()
-{SELFPARAM();
+void bumblebee_touch(entity this)
+{
if(autocvar_g_vehicles_enter) { return; }
- if(self.gunner1 != world && self.gunner2 != world)
+ if(this.gunner1 != NULL && this.gunner2 != NULL)
{
- vehicles_touch();
+ vehicles_touch(this);
return;
}
- if(vehicles_valid_pilot())
+ if(vehicles_valid_pilot(this, other))
{
- float phase_time = (time >= self.gun1.phase) + (time >= self.gun2.phase);
+ float phase_time = (time >= this.gun1.phase) + (time >= this.gun2.phase);
if(time >= other.vehicle_enter_delay && phase_time)
- if(bumblebee_gunner_enter())
+ if(bumblebee_gunner_enter(this, other))
return;
}
- vehicles_touch();
+ vehicles_touch(this);
}
-void bumblebee_regen()
-{SELFPARAM();
- if(self.gun1.delay + autocvar_g_vehicle_bumblebee_cannon_ammo_regen_pause < time)
- self.gun1.vehicle_energy = min(autocvar_g_vehicle_bumblebee_cannon_ammo,
- self.gun1.vehicle_energy + autocvar_g_vehicle_bumblebee_cannon_ammo_regen * frametime);
+void bumblebee_regen(entity this)
+{
+ if(this.gun1.delay + autocvar_g_vehicle_bumblebee_cannon_ammo_regen_pause < time)
+ this.gun1.vehicle_energy = min(autocvar_g_vehicle_bumblebee_cannon_ammo,
+ this.gun1.vehicle_energy + autocvar_g_vehicle_bumblebee_cannon_ammo_regen * frametime);
- if(self.gun2.delay + autocvar_g_vehicle_bumblebee_cannon_ammo_regen_pause < time)
- self.gun2.vehicle_energy = min(autocvar_g_vehicle_bumblebee_cannon_ammo,
- self.gun2.vehicle_energy + autocvar_g_vehicle_bumblebee_cannon_ammo_regen * frametime);
+ if(this.gun2.delay + autocvar_g_vehicle_bumblebee_cannon_ammo_regen_pause < time)
+ this.gun2.vehicle_energy = min(autocvar_g_vehicle_bumblebee_cannon_ammo,
+ this.gun2.vehicle_energy + autocvar_g_vehicle_bumblebee_cannon_ammo_regen * frametime);
- if(self.vehicle_flags & VHF_SHIELDREGEN)
- vehicles_regen(self.dmg_time, vehicle_shield, autocvar_g_vehicle_bumblebee_shield, autocvar_g_vehicle_bumblebee_shield_regen_pause, autocvar_g_vehicle_bumblebee_shield_regen, frametime, true);
+ if(this.vehicle_flags & VHF_SHIELDREGEN)
+ vehicles_regen(this, this.dmg_time, vehicle_shield, autocvar_g_vehicle_bumblebee_shield, autocvar_g_vehicle_bumblebee_shield_regen_pause, autocvar_g_vehicle_bumblebee_shield_regen, frametime, true);
- if(self.vehicle_flags & VHF_HEALTHREGEN)
- vehicles_regen(self.dmg_time, vehicle_health, autocvar_g_vehicle_bumblebee_health, autocvar_g_vehicle_bumblebee_health_regen_pause, autocvar_g_vehicle_bumblebee_health_regen, frametime, false);
+ if(this.vehicle_flags & VHF_HEALTHREGEN)
+ vehicles_regen(this, this.dmg_time, vehicle_health, autocvar_g_vehicle_bumblebee_health, autocvar_g_vehicle_bumblebee_health_regen_pause, autocvar_g_vehicle_bumblebee_health_regen, frametime, false);
- if(self.vehicle_flags & VHF_ENERGYREGEN)
- vehicles_regen(self.wait, vehicle_energy, autocvar_g_vehicle_bumblebee_energy, autocvar_g_vehicle_bumblebee_energy_regen_pause, autocvar_g_vehicle_bumblebee_energy_regen, frametime, false);
+ if(this.vehicle_flags & VHF_ENERGYREGEN)
+ vehicles_regen(this, this.wait, vehicle_energy, autocvar_g_vehicle_bumblebee_energy, autocvar_g_vehicle_bumblebee_energy_regen_pause, autocvar_g_vehicle_bumblebee_energy_regen, frametime, false);
}
-float bumblebee_pilot_frame()
-{SELFPARAM();
- entity pilot, vehic;
- vector newvel;
+bool bumblebee_pilot_frame(entity this)
+{
+ entity vehic = this.vehicle;
+ return = true;
if(intermission_running)
{
- self.vehicle.velocity = '0 0 0';
- self.vehicle.avelocity = '0 0 0';
- return 1;
+ vehic.velocity = '0 0 0';
+ vehic.avelocity = '0 0 0';
+ return;
}
- pilot = self;
- vehic = self.vehicle;
- setself(vehic);
+ vehicles_frame(vehic, this);
- if(vehic.deadflag != DEAD_NO)
+ if(IS_DEAD(vehic))
{
- setself(pilot);
- pilot.BUTTON_ATCK = pilot.BUTTON_ATCK2 = 0;
- return 1;
+ PHYS_INPUT_BUTTON_ATCK(this) = PHYS_INPUT_BUTTON_ATCK2(this) = false;
+ return;
}
- bumblebee_regen();
-
- crosshair_trace(pilot);
+ bumblebee_regen(vehic);
- vector vang;
- float ftmp;
+ crosshair_trace(this);
- vang = vehic.angles;
- newvel = vectoangles(normalize(trace_endpos - self.origin + '0 0 32'));
+ vector vang = vehic.angles;
+ vector newvel = vectoangles(normalize(trace_endpos - vehic.origin + '0 0 32'));
vang.x *= -1;
newvel.x *= -1;
if(newvel.x > 180) newvel.x -= 360;
if(newvel.y > 180) newvel.y -= 360;
if(newvel.y < -180) newvel.y += 360;
- ftmp = shortangle_f(pilot.v_angle.y - vang.y, vang.y);
+ float ftmp = shortangle_f(this.v_angle.y - vang.y, vang.y);
if(ftmp > 180) ftmp -= 360;
if(ftmp < -180) ftmp += 360;
vehic.avelocity_y = bound(-autocvar_g_vehicle_bumblebee_turnspeed, ftmp + vehic.avelocity.y * 0.9, autocvar_g_vehicle_bumblebee_turnspeed);
// Pitch
ftmp = 0;
- if(pilot.movement.x > 0 && vang.x < autocvar_g_vehicle_bumblebee_pitchlimit)
+ if(this.movement.x > 0 && vang.x < autocvar_g_vehicle_bumblebee_pitchlimit)
ftmp = 4;
- else if(pilot.movement.x < 0 && vang.x > -autocvar_g_vehicle_bumblebee_pitchlimit)
+ else if(this.movement.x < 0 && vang.x > -autocvar_g_vehicle_bumblebee_pitchlimit)
ftmp = -8;
newvel.x = bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel.x , autocvar_g_vehicle_bumblebee_pitchlimit);
makevectors('0 1 0' * vehic.angles.y);
newvel = vehic.velocity * -autocvar_g_vehicle_bumblebee_friction;
- if(pilot.movement.x != 0)
+ if(this.movement.x != 0)
{
- if(pilot.movement.x > 0)
+ if(this.movement.x > 0)
newvel += v_forward * autocvar_g_vehicle_bumblebee_speed_forward;
- else if(pilot.movement.x < 0)
+ else if(this.movement.x < 0)
newvel -= v_forward * autocvar_g_vehicle_bumblebee_speed_forward;
}
- if(pilot.movement.y != 0)
+ if(this.movement.y != 0)
{
- if(pilot.movement.y < 0)
+ if(this.movement.y < 0)
newvel -= v_right * autocvar_g_vehicle_bumblebee_speed_strafe;
- else if(pilot.movement.y > 0)
+ else if(this.movement.y > 0)
newvel += v_right * autocvar_g_vehicle_bumblebee_speed_strafe;
ftmp = newvel * v_right;
ftmp *= frametime * 0.1;
vehic.angles_z = 0;
}
- if(pilot.BUTTON_CROUCH)
+ if(PHYS_INPUT_BUTTON_CROUCH(this))
newvel -= v_up * autocvar_g_vehicle_bumblebee_speed_down;
- else if(pilot.BUTTON_JUMP)
+ else if(PHYS_INPUT_BUTTON_JUMP(this))
newvel += v_up * autocvar_g_vehicle_bumblebee_speed_up;
vehic.velocity += newvel * frametime;
- pilot.velocity = pilot.movement = vehic.velocity;
+ this.velocity = this.movement = vehic.velocity;
if(autocvar_g_vehicle_bumblebee_healgun_locktime)
{
- if(vehic.tur_head.lock_time < time || vehic.tur_head.enemy.deadflag)
- vehic.tur_head.enemy = world;
+ if(vehic.tur_head.lock_time < time || IS_DEAD(vehic.tur_head.enemy) || STAT(FROZEN, vehic.tur_head.enemy))
+ vehic.tur_head.enemy = NULL;
if(trace_ent)
if(trace_ent.movetype)
if(trace_ent.takedamage)
- if(!trace_ent.deadflag)
+ if(!IS_DEAD(trace_ent) && !STAT(FROZEN, trace_ent))
{
if(teamplay)
{
- if(trace_ent.team == pilot.team)
+ if(trace_ent.team == this.team)
{
vehic.tur_head.enemy = trace_ent;
vehic.tur_head.lock_time = time + autocvar_g_vehicle_bumblebee_healgun_locktime;
if(vehic.tur_head.enemy)
{
trace_endpos = real_origin(vehic.tur_head.enemy);
- UpdateAuxiliaryXhair(pilot, trace_endpos, '0 0.75 0', 0);
+ UpdateAuxiliaryXhair(this, trace_endpos, '0 0.75 0', 0);
}
}
- vang = vehicle_aimturret(vehic, trace_endpos, self.gun3, "fire",
+ vang = vehicle_aimturret(vehic, trace_endpos, vehic.gun3, "fire",
autocvar_g_vehicle_bumblebee_raygun_pitchlimit_down * -1, autocvar_g_vehicle_bumblebee_raygun_pitchlimit_up,
autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides * -1, autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides, autocvar_g_vehicle_bumblebee_raygun_turnspeed);
- if(!forbidWeaponUse(pilot))
- if((pilot.BUTTON_ATCK || pilot.BUTTON_ATCK2) && (vehic.vehicle_energy > autocvar_g_vehicle_bumblebee_raygun_dps * sys_frametime || autocvar_g_vehicle_bumblebee_raygun == 0))
+ if(!forbidWeaponUse(this))
+ if((PHYS_INPUT_BUTTON_ATCK(this) || PHYS_INPUT_BUTTON_ATCK2(this)) && (vehic.vehicle_energy > autocvar_g_vehicle_bumblebee_raygun_dps * sys_frametime || autocvar_g_vehicle_bumblebee_raygun == 0))
{
- vehic.gun3.enemy.realowner = pilot;
+ vehic.gun3.enemy.realowner = this;
vehic.gun3.enemy.effects &= ~EF_NODRAW;
vehic.gun3.enemy.hook_start = gettaginfo(vehic.gun3, gettagindex(vehic.gun3, "fire"));
{
if(autocvar_g_vehicle_bumblebee_raygun)
{
- Damage(trace_ent, vehic, pilot, autocvar_g_vehicle_bumblebee_raygun_dps * sys_frametime, DEATH_GENERIC.m_id, trace_endpos, v_forward * autocvar_g_vehicle_bumblebee_raygun_fps * sys_frametime);
+ Damage(trace_ent, vehic, this, autocvar_g_vehicle_bumblebee_raygun_dps * sys_frametime, DEATH_GENERIC.m_id, trace_endpos, v_forward * autocvar_g_vehicle_bumblebee_raygun_fps * sys_frametime);
vehic.vehicle_energy -= autocvar_g_vehicle_bumblebee_raygun_aps * sys_frametime;
}
else
{
- if(trace_ent.deadflag == DEAD_NO)
- if((teamplay && trace_ent.team == pilot.team) || !teamplay)
+ if(!IS_DEAD(trace_ent))
+ if((teamplay && trace_ent.team == this.team) || !teamplay)
{
- if(trace_ent.vehicle_flags & VHF_ISVEHICLE)
+ if(IS_VEHICLE(trace_ent))
{
if(autocvar_g_vehicle_bumblebee_healgun_sps && trace_ent.vehicle_health <= trace_ent.max_health)
trace_ent.vehicle_shield = min(trace_ent.vehicle_shield + autocvar_g_vehicle_bumblebee_healgun_sps * frametime, trace_ent.tur_head.max_health);
if(vehic.gun3.enemy)
remove(vehic.gun3.enemy);
- vehic.gun3.enemy = world;
+ vehic.gun3.enemy = NULL;
}
*/
- VEHICLE_UPDATE_PLAYER(pilot, health, bumblebee);
- VEHICLE_UPDATE_PLAYER(pilot, energy, bumblebee);
+ VEHICLE_UPDATE_PLAYER(this, vehic, health, bumblebee);
+ VEHICLE_UPDATE_PLAYER(this, vehic, energy, bumblebee);
- pilot.vehicle_ammo1 = (vehic.gun1.vehicle_energy / autocvar_g_vehicle_bumblebee_cannon_ammo) * 100;
- pilot.vehicle_ammo2 = (vehic.gun2.vehicle_energy / autocvar_g_vehicle_bumblebee_cannon_ammo) * 100;
+ this.vehicle_ammo1 = (vehic.gun1.vehicle_energy / autocvar_g_vehicle_bumblebee_cannon_ammo) * 100;
+ this.vehicle_ammo2 = (vehic.gun2.vehicle_energy / autocvar_g_vehicle_bumblebee_cannon_ammo) * 100;
if(vehic.vehicle_flags & VHF_HASSHIELD)
- VEHICLE_UPDATE_PLAYER(pilot, shield, bumblebee);
+ VEHICLE_UPDATE_PLAYER(this, vehic, shield, bumblebee);
vehic.angles_x *= -1;
makevectors(vehic.angles);
vehic.angles_x *= -1;
- setorigin(pilot, vehic.origin + v_up * 48 + v_forward * 160);
+ setorigin(this, vehic.origin + v_up * 48 + v_forward * 160);
- pilot.BUTTON_ATCK = pilot.BUTTON_ATCK2 = pilot.BUTTON_CROUCH = 0;
- setself(pilot);
-
- return 1;
+ PHYS_INPUT_BUTTON_ATCK(this) = PHYS_INPUT_BUTTON_ATCK2(this) = PHYS_INPUT_BUTTON_CROUCH(this) = false;
}
-void bumblebee_land()
-{SELFPARAM();
+void bumblebee_land(entity this)
+{
float hgt;
- hgt = raptor_altitude(512);
- self.velocity = (self.velocity * 0.9) + ('0 0 -1800' * (hgt / 256) * sys_frametime);
- self.angles_x *= 0.95;
- self.angles_z *= 0.95;
+ hgt = vehicle_altitude(this, 512);
+ this.velocity = (this.velocity * 0.9) + ('0 0 -1800' * (hgt / 256) * sys_frametime);
+ this.angles_x *= 0.95;
+ this.angles_z *= 0.95;
if(hgt < 16)
- self.think = vehicles_think;
+ setthink(this, vehicles_think);
- self.nextthink = time;
+ this.nextthink = time;
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
}
-void bumblebee_exit(float eject)
-{SELFPARAM();
- if(self.owner.vehicleid == VEH_BUMBLEBEE.vehicleid)
+void bumblebee_exit(entity this, int eject)
+{
+ if(this.owner.vehicleid == VEH_BUMBLEBEE.vehicleid)
{
- bumblebee_gunner_exit(eject);
+ bumblebee_gunner_exit(this, eject);
return;
}
- self.touch = vehicles_touch;
+ settouch(this, vehicles_touch);
- if(self.deadflag == DEAD_NO)
+ if(!IS_DEAD(this))
{
- self.think = bumblebee_land;
- self.nextthink = time;
+ setthink(this, bumblebee_land);
+ this.nextthink = time;
}
- self.movetype = MOVETYPE_TOSS;
+ this.movetype = MOVETYPE_TOSS;
- if(!self.owner)
+ if(!this.owner)
return;
- fixedmakevectors(self.angles);
+ fixedmakevectors(this.angles);
vector spot;
- if(vlen(self.velocity) > autocvar_g_vehicle_bumblebee_speed_forward * 0.5)
- spot = self.origin + v_up * 128 + v_forward * 300;
+ if(vdist(this.velocity, >, autocvar_g_vehicle_bumblebee_speed_forward * 0.5))
+ spot = this.origin + v_up * 128 + v_forward * 300;
else
- spot = self.origin + v_up * 128 - v_forward * 300;
+ spot = this.origin + v_up * 128 - v_forward * 300;
- spot = vehicles_findgoodexit(spot);
+ spot = vehicles_findgoodexit(this, spot);
// Hide beam
- if(self.gun3.enemy || !wasfreed(self.gun3.enemy)) {
- self.gun3.enemy.effects |= EF_NODRAW;
- }
+ if(this.gun3.enemy || !wasfreed(this.gun3.enemy))
+ this.gun3.enemy.effects |= EF_NODRAW;
- self.owner.velocity = 0.75 * self.vehicle.velocity + normalize(spot - self.vehicle.origin) * 200;
- self.owner.velocity_z += 10;
- setorigin(self.owner, spot);
+ this.owner.velocity = 0.75 * this.vehicle.velocity + normalize(spot - this.vehicle.origin) * 200;
+ this.owner.velocity_z += 10;
+ setorigin(this.owner, spot);
- antilag_clear(self.owner);
- self.owner = world;
+ antilag_clear(this.owner, CS(this.owner));
+ this.owner = NULL;
}
-void bumblebee_blowup()
-{SELFPARAM();
- RadiusDamage(self, self.enemy, autocvar_g_vehicle_bumblebee_blowup_coredamage,
+void bumblebee_blowup(entity this)
+{
+ RadiusDamage(this, this.enemy, autocvar_g_vehicle_bumblebee_blowup_coredamage,
autocvar_g_vehicle_bumblebee_blowup_edgedamage,
- autocvar_g_vehicle_bumblebee_blowup_radius, self, world,
+ autocvar_g_vehicle_bumblebee_blowup_radius, this, NULL,
autocvar_g_vehicle_bumblebee_blowup_forceintensity,
- DEATH_VH_BUMB_DEATH.m_id, world);
+ DEATH_VH_BUMB_DEATH.m_id, NULL);
- sound(self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
- Send_Effect(EFFECT_EXPLOSION_BIG, (self.origin + '0 0 100') + (randomvec() * 80), '0 0 0', 1);
+ sound(this, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
+ Send_Effect(EFFECT_EXPLOSION_BIG, (this.origin + '0 0 100') + (randomvec() * 80), '0 0 0', 1);
- if(self.owner.deadflag == DEAD_DYING)
- self.owner.deadflag = DEAD_DEAD;
+ if(this.owner.deadflag == DEAD_DYING)
+ this.owner.deadflag = DEAD_DEAD;
- remove(self);
+ remove(this);
}
-void bumblebee_diethink()
-{SELFPARAM();
- if(time >= self.wait)
- self.think = bumblebee_blowup;
+void bumblebee_diethink(entity this)
+{
+ if(time >= this.wait)
+ setthink(this, bumblebee_blowup);
if(random() < 0.1)
{
- sound(self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
- Send_Effect(EFFECT_EXPLOSION_SMALL, randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
+ sound(this, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
+ Send_Effect(EFFECT_EXPLOSION_SMALL, randomvec() * 80 + (this.origin + '0 0 100'), '0 0 0', 1);
}
- self.nextthink = time + 0.1;
+ this.nextthink = time + 0.1;
}
spawnfunc(vehicle_bumblebee)
{
- if(!autocvar_g_vehicle_bumblebee) { remove(self); return; }
- if(!vehicle_initialize(VEH_BUMBLEBEE, false)) { remove(self); return; }
+ if(!autocvar_g_vehicle_bumblebee) { remove(this); return; }
+ if(!vehicle_initialize(this, VEH_BUMBLEBEE, false)) { remove(this); return; }
}
- METHOD(Bumblebee, vr_impact, void(Bumblebee thisveh))
- {
- if(autocvar_g_vehicle_bumblebee_bouncepain)
- vehicles_impact(autocvar_g_vehicle_bumblebee_bouncepain_x, autocvar_g_vehicle_bumblebee_bouncepain_y, autocvar_g_vehicle_bumblebee_bouncepain_z);
- }
- METHOD(Bumblebee, vr_enter, void(Bumblebee thisveh))
- {
- SELFPARAM();
- self.touch = bumblebee_touch;
- self.nextthink = 0;
- self.movetype = MOVETYPE_BOUNCEMISSILE;
- }
- METHOD(Bumblebee, vr_think, void(Bumblebee thisveh))
- {
- SELFPARAM();
- self.angles_z *= 0.8;
- self.angles_x *= 0.8;
-
- self.nextthink = time;
-
- if(!self.owner)
- {
- entity oldself = self;
- if(self.gunner1)
- {
- setself(self.gunner1);
- oldself.gun1.vehicle_exit(VHEF_EJECT);
- entity oldother = other;
- other = self;
- setself(oldself);
- self.phase = 0;
- self.touch();
- other = oldother;
- return;
- }
-
- if(self.gunner2)
- {
- setself(self.gunner2);
- oldself.gun2.vehicle_exit(VHEF_EJECT);
- entity oldother = other;
- other = self;
- setself(oldself);
- self.phase = 0;
- self.touch();
- other = oldother;
- return;
- }
- }
- }
- METHOD(Bumblebee, vr_death, void(Bumblebee thisveh))
- {
- SELFPARAM();
- entity oldself = self;
-
- CSQCModel_UnlinkEntity(self);
-
- // Hide beam
- if(self.gun3.enemy || !wasfreed(self.gun3.enemy))
- self.gun3.enemy.effects |= EF_NODRAW;
-
- if(self.gunner1)
- {
- setself(self.gunner1);
- oldself.gun1.vehicle_exit(VHEF_EJECT);
- setself(oldself);
- }
-
- if(self.gunner2)
- {
- setself(self.gunner2);
- oldself.gun2.vehicle_exit(VHEF_EJECT);
- setself(oldself);
- }
-
- self.vehicle_exit(VHEF_EJECT);
-
- fixedmakevectors(self.angles);
- vehicle_tossgib(self.gun1, self.velocity + v_right * 300 + v_up * 100 + randomvec() * 200, "cannon_right", rint(random()), rint(random()), 6, randomvec() * 200);
- vehicle_tossgib(self.gun2, self.velocity + v_right * -300 + v_up * 100 + randomvec() * 200, "cannon_left", rint(random()), rint(random()), 6, randomvec() * 200);
- vehicle_tossgib(self.gun3, self.velocity + v_forward * 300 + v_up * -100 + randomvec() * 200, "raygun", rint(random()), rint(random()), 6, randomvec() * 300);
-
- entity _body = vehicle_tossgib(self, self.velocity + randomvec() * 200, "", rint(random()), rint(random()), 6, randomvec() * 100);
-
- if(random() > 0.5)
- _body.touch = bumblebee_blowup;
- else
- _body.touch = func_null;
-
- _body.think = bumblebee_diethink;
- _body.nextthink = time;
- _body.wait = time + 2 + (random() * 8);
- _body.owner = self;
- _body.enemy = self.enemy;
- _body.scale = 1.5;
- _body.angles = self.angles;
-
- Send_Effect(EFFECT_EXPLOSION_MEDIUM, findbetterlocation(self.origin, 16), '0 0 0', 1);
-
- self.health = 0;
- self.event_damage = func_null;
- self.solid = SOLID_NOT;
- self.takedamage = DAMAGE_NO;
- self.deadflag = DEAD_DYING;
- self.movetype = MOVETYPE_NONE;
- self.effects = EF_NODRAW;
- self.colormod = '0 0 0';
- self.avelocity = '0 0 0';
- self.velocity = '0 0 0';
- self.touch = func_null;
- self.nextthink = 0;
-
- setorigin(self, self.pos1);
- }
- METHOD(Bumblebee, vr_spawn, void(Bumblebee thisveh))
- {
- SELFPARAM();
- if(!self.gun1)
- {
- // for some reason, autosizing of the shield entity refuses to work for this one so set it up in advance.
- self.vehicle_shieldent = spawn();
- self.vehicle_shieldent.effects = EF_LOWPRECISION;
- setmodel(self.vehicle_shieldent, MDL_VEH_BUMBLEBEE_SHIELD);
- setattachment(self.vehicle_shieldent, self, "");
- setorigin(self.vehicle_shieldent, real_origin(self) - self.origin);
- self.vehicle_shieldent.scale = 512 / vlen(self.maxs - self.mins);
- self.vehicle_shieldent.think = shieldhit_think;
- self.vehicle_shieldent.alpha = -1;
- self.vehicle_shieldent.effects = EF_LOWPRECISION | EF_NODRAW;
-
- self.gun1 = spawn();
- self.gun2 = spawn();
- self.gun3 = spawn();
-
- self.vehicle_flags |= VHF_MULTISLOT;
-
- self.gun1.owner = self;
- self.gun2.owner = self;
- self.gun3.owner = self;
-
- self.gun1.classname = self.gun2.classname = "vehicle_playerslot";
-
- setmodel(self.gun1, MDL_VEH_BUMBLEBEE_CANNON_RIGHT);
- setmodel(self.gun2, MDL_VEH_BUMBLEBEE_CANNON_LEFT);
- setmodel(self.gun3, MDL_VEH_BUMBLEBEE_CANNON_CENTER);
-
- setattachment(self.gun1, self, "cannon_right");
- setattachment(self.gun2, self, "cannon_left");
-
- // Angled bones are no fun, messes up gun-aim; so work arround it.
- self.gun3.pos1 = self.angles;
- self.angles = '0 0 0';
- vector ofs = gettaginfo(self, gettagindex(self, "raygun"));
- ofs -= self.origin;
- setattachment(self.gun3, self, "");
- setorigin(self.gun3, ofs);
- self.angles = self.gun3.pos1;
-
- vehicle_addplayerslot(self, self.gun1, HUD_BUMBLEBEE_GUN, "models/vehicles/wakizashi_cockpit.dpm", bumblebee_gunner_frame, bumblebee_gunner_exit, bumblebee_gunner_enter);
- vehicle_addplayerslot(self, self.gun2, HUD_BUMBLEBEE_GUN, "models/vehicles/wakizashi_cockpit.dpm", bumblebee_gunner_frame, bumblebee_gunner_exit, bumblebee_gunner_enter);
-
- setorigin(self.vehicle_hudmodel, '50 0 -5'); // Move cockpit forward - down.
- setorigin(self.vehicle_viewport, '5 0 2'); // Move camera forward up
-
- //fixme-model-bones
- setorigin(self.gun1.vehicle_hudmodel, '90 -27 -23');
- setorigin(self.gun1.vehicle_viewport, '-85 0 50');
- //fixme-model-bones
- setorigin(self.gun2.vehicle_hudmodel, '90 27 -23');
- setorigin(self.gun2.vehicle_viewport, '-85 0 50');
-
- self.scale = 1.5;
-
- // Raygun beam
- if(self.gun3.enemy == world)
- {
- self.gun3.enemy = spawn();
- Net_LinkEntity(self.gun3.enemy, true, 0, bumble_raygun_send);
- self.gun3.enemy.SendFlags = BRG_SETUP;
- self.gun3.enemy.cnt = autocvar_g_vehicle_bumblebee_raygun;
- self.gun3.enemy.effects = EF_NODRAW | EF_LOWPRECISION;
- }
- }
-
- self.vehicle_health = autocvar_g_vehicle_bumblebee_health;
- self.vehicle_shield = autocvar_g_vehicle_bumblebee_shield;
- self.solid = SOLID_BBOX;
- self.movetype = MOVETYPE_TOSS;
- self.damageforcescale = 0.025;
-
- self.PlayerPhysplug = bumblebee_pilot_frame;
-
- setorigin(self, self.origin + '0 0 25');
- }
- METHOD(Bumblebee, vr_setup, void(Bumblebee thisveh))
- {
- SELFPARAM();
- if(autocvar_g_vehicle_bumblebee_energy)
- if(autocvar_g_vehicle_bumblebee_energy_regen)
- self.vehicle_flags |= VHF_ENERGYREGEN;
+METHOD(Bumblebee, vr_impact, void(Bumblebee thisveh, entity instance))
+{
+ if(autocvar_g_vehicle_bumblebee_bouncepain)
+ vehicles_impact(instance, autocvar_g_vehicle_bumblebee_bouncepain_x, autocvar_g_vehicle_bumblebee_bouncepain_y, autocvar_g_vehicle_bumblebee_bouncepain_z);
+}
+METHOD(Bumblebee, vr_enter, void(Bumblebee thisveh, entity instance))
+{
+ settouch(instance, bumblebee_touch);
+ instance.nextthink = 0;
+ instance.movetype = MOVETYPE_BOUNCEMISSILE;
+}
+METHOD(Bumblebee, vr_think, void(Bumblebee thisveh, entity instance))
+{
+ instance.angles_z *= 0.8;
+ instance.angles_x *= 0.8;
+
+ instance.nextthink = time;
+
+ if(!instance.owner)
+ {
+ if(instance.gunner1)
+ {
+ entity e = instance.gunner1;
+ instance.gun1.vehicle_exit(instance.gun1, VHEF_EJECT);
+ entity oldother = other;
+ other = e;
+ instance.phase = 0;
+ gettouch(instance)(instance);
+ other = oldother;
+ return;
+ }
+
+ if(instance.gunner2)
+ {
+ entity e = instance.gunner2;
+ instance.gun2.vehicle_exit(instance.gun2, VHEF_EJECT);
+ entity oldother = other;
+ other = e;
+ instance.phase = 0;
+ gettouch(instance)(instance);
+ other = oldother;
+ return;
+ }
+ }
+}
+METHOD(Bumblebee, vr_death, void(Bumblebee thisveh, entity instance))
+{
+ CSQCModel_UnlinkEntity(instance);
+
+ // hide beam
+ if(instance.gun3.enemy || !wasfreed(instance.gun3.enemy))
+ instance.gun3.enemy.effects |= EF_NODRAW;
+
+ if(instance.gunner1)
+ instance.gun1.vehicle_exit(instance.gun1, VHEF_EJECT);
+
+ if(instance.gunner2)
+ instance.gun2.vehicle_exit(instance.gun2, VHEF_EJECT);
+
+ instance.vehicle_exit(instance, VHEF_EJECT);
+
+ fixedmakevectors(instance.angles);
+ vehicle_tossgib(instance, instance.gun1, instance.velocity + v_right * 300 + v_up * 100 + randomvec() * 200, "cannon_right", rint(random()), rint(random()), 6, randomvec() * 200);
+ vehicle_tossgib(instance, instance.gun2, instance.velocity + v_right * -300 + v_up * 100 + randomvec() * 200, "cannon_left", rint(random()), rint(random()), 6, randomvec() * 200);
+ vehicle_tossgib(instance, instance.gun3, instance.velocity + v_forward * 300 + v_up * -100 + randomvec() * 200, "raygun", rint(random()), rint(random()), 6, randomvec() * 300);
+
+ entity _body = vehicle_tossgib(instance, instance, instance.velocity + randomvec() * 200, "", rint(random()), rint(random()), 6, randomvec() * 100);
+
+ if(random() > 0.5)
+ settouch(_body, bumblebee_blowup);
+ else
+ settouch(_body, func_null);
+
+ setthink(_body, bumblebee_diethink);
+ _body.nextthink = time;
+ _body.wait = time + 2 + (random() * 8);
+ _body.owner = instance;
+ _body.enemy = instance.enemy;
+ _body.scale = 1.5;
+ _body.angles = instance.angles;
+
+ Send_Effect(EFFECT_EXPLOSION_MEDIUM, findbetterlocation(instance.origin, 16), '0 0 0', 1);
+
+ instance.health = 0;
+ instance.event_damage = func_null;
+ instance.solid = SOLID_NOT;
+ instance.takedamage = DAMAGE_NO;
+ instance.deadflag = DEAD_DYING;
+ instance.movetype = MOVETYPE_NONE;
+ instance.effects = EF_NODRAW;
+ instance.colormod = '0 0 0';
+ instance.avelocity = '0 0 0';
+ instance.velocity = '0 0 0';
+ settouch(instance, func_null);
+ instance.nextthink = 0;
+
+ setorigin(instance, instance.pos1);
+}
+METHOD(Bumblebee, vr_spawn, void(Bumblebee thisveh, entity instance))
+{
+ if(!instance.gun1)
+ {
+ // for some reason, autosizing of the shield entity refuses to work for this one so set it up in advance.
+ instance.vehicle_shieldent = spawn();
+ instance.vehicle_shieldent.effects = EF_LOWPRECISION;
+ setmodel(instance.vehicle_shieldent, MDL_VEH_BUMBLEBEE_SHIELD);
+ setattachment(instance.vehicle_shieldent, instance, "");
+ setorigin(instance.vehicle_shieldent, real_origin(instance) - instance.origin);
+ instance.vehicle_shieldent.scale = 512 / vlen(instance.maxs - instance.mins);
+ setthink(instance.vehicle_shieldent, shieldhit_think);
+ instance.vehicle_shieldent.alpha = -1;
+ instance.vehicle_shieldent.effects = EF_LOWPRECISION | EF_NODRAW;
+
+ instance.gun1 = new(vehicle_playerslot);
+ instance.gun2 = new(vehicle_playerslot);
+ instance.gun3 = new(bumblebee_raygun);
+
+ instance.vehicle_flags |= VHF_MULTISLOT;
+
+ instance.gun1.owner = instance;
+ instance.gun2.owner = instance;
+ instance.gun3.owner = instance;
+
+ setmodel(instance.gun1, MDL_VEH_BUMBLEBEE_CANNON_RIGHT);
+ setmodel(instance.gun2, MDL_VEH_BUMBLEBEE_CANNON_LEFT);
+ setmodel(instance.gun3, MDL_VEH_BUMBLEBEE_CANNON_CENTER);
+
+ setattachment(instance.gun1, instance, "cannon_right");
+ setattachment(instance.gun2, instance, "cannon_left");
+
+ // Angled bones are no fun, messes up gun-aim; so work arround it.
+ instance.gun3.pos1 = instance.angles;
+ instance.angles = '0 0 0';
+ vector ofs = gettaginfo(instance, gettagindex(instance, "raygun"));
+ ofs -= instance.origin;
+ setattachment(instance.gun3, instance, "");
+ setorigin(instance.gun3, ofs);
+ instance.angles = instance.gun3.pos1;
+
+ vehicle_addplayerslot(instance, instance.gun1, HUD_BUMBLEBEE_GUN, MDL_VEH_BUMBLEBEE_GUNCOCKPIT, bumblebee_gunner_frame, bumblebee_gunner_exit, bumblebee_gunner_enter);
+ vehicle_addplayerslot(instance, instance.gun2, HUD_BUMBLEBEE_GUN, MDL_VEH_BUMBLEBEE_GUNCOCKPIT, bumblebee_gunner_frame, bumblebee_gunner_exit, bumblebee_gunner_enter);
+
+ setorigin(instance.vehicle_hudmodel, '50 0 -5'); // Move cockpit forward - down.
+ setorigin(instance.vehicle_viewport, '5 0 2'); // Move camera forward up
+
+ //fixme-model-bones
+ setorigin(instance.gun1.vehicle_hudmodel, '90 -27 -23');
+ setorigin(instance.gun1.vehicle_viewport, '-85 0 50');
+ //fixme-model-bones
+ setorigin(instance.gun2.vehicle_hudmodel, '90 27 -23');
+ setorigin(instance.gun2.vehicle_viewport, '-85 0 50');
+
+ instance.scale = 1.5;
+
+ // Raygun beam
+ if(instance.gun3.enemy == NULL)
+ {
+ instance.gun3.enemy = spawn();
+ Net_LinkEntity(instance.gun3.enemy, true, 0, bumble_raygun_send);
+ instance.gun3.enemy.SendFlags = BRG_SETUP;
+ instance.gun3.enemy.cnt = autocvar_g_vehicle_bumblebee_raygun;
+ instance.gun3.enemy.effects = EF_NODRAW | EF_LOWPRECISION;
+ }
+ }
+
+ instance.vehicle_health = autocvar_g_vehicle_bumblebee_health;
+ instance.vehicle_shield = autocvar_g_vehicle_bumblebee_shield;
+ instance.solid = SOLID_BBOX;
+ instance.movetype = MOVETYPE_TOSS;
+ instance.damageforcescale = 0.025;
+
+ instance.PlayerPhysplug = bumblebee_pilot_frame;
+
+ setorigin(instance, instance.origin + '0 0 25');
+}
+METHOD(Bumblebee, vr_setup, void(Bumblebee thisveh, entity instance))
+{
+ if(autocvar_g_vehicle_bumblebee_energy)
+ if(autocvar_g_vehicle_bumblebee_energy_regen)
+ instance.vehicle_flags |= VHF_ENERGYREGEN;
- if(autocvar_g_vehicle_bumblebee_shield)
- self.vehicle_flags |= VHF_HASSHIELD;
+ if(autocvar_g_vehicle_bumblebee_shield)
+ instance.vehicle_flags |= VHF_HASSHIELD;
- if(autocvar_g_vehicle_bumblebee_shield_regen)
- self.vehicle_flags |= VHF_SHIELDREGEN;
+ if(autocvar_g_vehicle_bumblebee_shield_regen)
+ instance.vehicle_flags |= VHF_SHIELDREGEN;
- if(autocvar_g_vehicle_bumblebee_health_regen)
- self.vehicle_flags |= VHF_HEALTHREGEN;
+ if(autocvar_g_vehicle_bumblebee_health_regen)
+ instance.vehicle_flags |= VHF_HEALTHREGEN;
- self.vehicle_exit = bumblebee_exit;
- self.respawntime = autocvar_g_vehicle_bumblebee_respawntime;
- self.vehicle_health = autocvar_g_vehicle_bumblebee_health;
- self.max_health = self.vehicle_health;
- self.vehicle_shield = autocvar_g_vehicle_bumblebee_shield;
- }
+ instance.vehicle_exit = bumblebee_exit;
+ instance.respawntime = autocvar_g_vehicle_bumblebee_respawntime;
+ instance.vehicle_health = autocvar_g_vehicle_bumblebee_health;
+ instance.max_health = instance.vehicle_health;
+ instance.vehicle_shield = autocvar_g_vehicle_bumblebee_shield;
+}
#endif // SVQC
#ifdef CSQC
string_null, '0 0 0');
}
- METHOD(Bumblebee, vr_hud, void(Bumblebee thisveh))
- {
- Vehicles_drawHUD(VEH_BUMBLEBEE.m_icon, "vehicle_bumble_weapon1", "vehicle_bumble_weapon2",
- "vehicle_icon_ammo1", autocvar_hud_progressbar_vehicles_ammo1_color,
- "vehicle_icon_ammo1", autocvar_hud_progressbar_vehicles_ammo1_color);
-
- float hudAlpha = autocvar_hud_panel_fg_alpha;
- float blinkValue = 0.55 + sin(time * 7) * 0.45;
- vector tmpPos = '0 0 0';
- vector tmpSize = '1 1 1' * hud_fontsize;
- tmpPos.x = vehicleHud_Pos.x + vehicleHud_Size.x * (520/768);
-
- if(!AuxiliaryXhair[1].draw2d)
- {
- tmpPos.y = vehicleHud_Pos.y + vehicleHud_Size.y * (96/256) - tmpSize.y;
- drawstring(tmpPos, _("No right gunner!"), tmpSize, '1 1 1', hudAlpha * blinkValue, DRAWFLAG_NORMAL);
- }
-
- if(!AuxiliaryXhair[2].draw2d)
- {
- tmpPos.y = vehicleHud_Pos.y + vehicleHud_Size.y * (160/256);
- drawstring(tmpPos, _("No left gunner!"), tmpSize, '1 1 1', hudAlpha * blinkValue, DRAWFLAG_NORMAL);
- }
- }
- METHOD(Bumblebee, vr_crosshair, void(Bumblebee thisveh))
- {
- Vehicles_drawCrosshair(vCROSS_HEAL);
- }
- METHOD(Bumblebee, vr_setup, void(Bumblebee thisveh))
- {
- AuxiliaryXhair[0].axh_image = vCROSS_LOCK; // Raygun-locked
- AuxiliaryXhair[1].axh_image = vCROSS_BURST; // Gunner1
- AuxiliaryXhair[2].axh_image = vCROSS_BURST; // Gunner2
- }
+METHOD(Bumblebee, vr_hud, void(Bumblebee thisveh))
+{
+ Vehicles_drawHUD(VEH_BUMBLEBEE.m_icon, "vehicle_bumble_weapon1", "vehicle_bumble_weapon2",
+ "vehicle_icon_ammo1", autocvar_hud_progressbar_vehicles_ammo1_color,
+ "vehicle_icon_ammo1", autocvar_hud_progressbar_vehicles_ammo1_color);
+
+ float hudAlpha = autocvar_hud_panel_fg_alpha;
+ float blinkValue = 0.55 + sin(time * 7) * 0.45;
+ vector tmpPos = '0 0 0';
+ vector tmpSize = '1 1 1' * hud_fontsize;
+ tmpPos.x = vehicleHud_Pos.x + vehicleHud_Size.x * (520/768);
+
+ if(!AuxiliaryXhair[1].draw2d)
+ {
+ tmpPos.y = vehicleHud_Pos.y + vehicleHud_Size.y * (96/256) - tmpSize.y;
+ drawstring(tmpPos, _("No right gunner!"), tmpSize, '1 1 1', hudAlpha * blinkValue, DRAWFLAG_NORMAL);
+ }
+
+ if(!AuxiliaryXhair[2].draw2d)
+ {
+ tmpPos.y = vehicleHud_Pos.y + vehicleHud_Size.y * (160/256);
+ drawstring(tmpPos, _("No left gunner!"), tmpSize, '1 1 1', hudAlpha * blinkValue, DRAWFLAG_NORMAL);
+ }
+}
+METHOD(Bumblebee, vr_crosshair, void(Bumblebee thisveh, entity player))
+{
+ Vehicles_drawCrosshair(vCROSS_HEAL);
+}
+METHOD(Bumblebee, vr_setup, void(Bumblebee thisveh, entity instance))
+{
+ AuxiliaryXhair[0].axh_image = vCROSS_LOCK; // Raygun-locked
+ AuxiliaryXhair[1].axh_image = vCROSS_BURST; // Gunner1
+ AuxiliaryXhair[2].axh_image = vCROSS_BURST; // Gunner2
+}
#endif
#endif