X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fvehicles%2Fvehicle%2Fbumblebee.qc;h=7bc10b4ecd2b31bb0a1bcae4e75c905fa309688d;hb=9755de88ca66529c0efa49b24c50de94e6a013f5;hp=fd6b19bf30aed777f43aa1844d485e50e8a3e0cf;hpb=3525ea6680ae54755122430b2e618d60079b575c;p=xonotic%2Fxonotic-data.pk3dir.git diff --git a/qcsrc/common/vehicles/vehicle/bumblebee.qc b/qcsrc/common/vehicles/vehicle/bumblebee.qc index fd6b19bf3..7bc10b4ec 100644 --- a/qcsrc/common/vehicles/vehicle/bumblebee.qc +++ b/qcsrc/common/vehicles/vehicle/bumblebee.qc @@ -1,30 +1,5 @@ -#ifndef VEHICLE_BUMBLEBEE -#define VEHICLE_BUMBLEBEE #include "bumblebee.qh" -#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, ""); -/* hud_model */ ATTRIB(Bumblebee, hud_model, string, "models/vehicles/spiderbot_cockpit.dpm"); -/* tags */ ATTRIB(Bumblebee, tag_head, string, ""); -/* tags */ ATTRIB(Bumblebee, tag_hud, string, ""); -/* tags */ ATTRIB(Bumblebee, tag_view, string, "tag_viewport"); -/* netname */ ATTRIB(Bumblebee, netname, string, "bumblebee"); -/* fullname */ ATTRIB(Bumblebee, vehicle_name, string, _("Bumblebee")); -/* icon */ ATTRIB(Bumblebee, m_icon, string, "vehicle_bumble"); -ENDCLASS(Bumblebee) -REGISTER_VEHICLE(BUMBLEBEE, NEW(Bumblebee)); - -#endif - #ifdef IMPLEMENTATION const float BRG_SETUP = 2; @@ -42,6 +17,7 @@ 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; +bool autocvar_g_vehicle_bumblebee_swim = false; float autocvar_g_vehicle_bumblebee_energy = 500; float autocvar_g_vehicle_bumblebee_energy_regen = 50; @@ -94,7 +70,7 @@ vector autocvar_g_vehicle_bumblebee_bouncepain = '1 100 200'; bool autocvar_g_vehicle_bumblebee = true; -bool bumblebee_gunner_frame(entity this) +bool bumblebee_gunner_frame(entity this, float dt) { entity vehic = this.vehicle.owner; entity gun = this.vehicle; @@ -131,10 +107,10 @@ bool bumblebee_gunner_frame(entity this) 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.move_movetype) if(trace_ent.takedamage) if(!IS_DEAD(trace_ent) && !STAT(FROZEN, trace_ent)) { @@ -152,7 +128,7 @@ bool bumblebee_gunner_frame(entity this) vector vf = real_origin(gun.enemy); vector _vel = gun.enemy.velocity; - if(gun.enemy.movetype == MOVETYPE_WALK) + if(gun.enemy.move_movetype == MOVETYPE_WALK) _vel.z *= 0.1; @@ -229,10 +205,10 @@ vector bumblebee_gunner_findgoodexit(vector prefer_spot, entity gunner, entity p 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)) @@ -252,7 +228,7 @@ void bumblebee_gunner_exit(int _exitflag) player.takedamage = DAMAGE_AIM; player.solid = SOLID_SLIDEBOX; - player.movetype = MOVETYPE_WALK; + set_movetype(player, MOVETYPE_WALK); player.effects &= ~EF_NODRAW; player.alpha = 1; player.PlayerPhysplug = func_null; @@ -260,13 +236,18 @@ void bumblebee_gunner_exit(int _exitflag) player.event_damage = PlayerDamage; player.hud = HUD_NORMAL; player.teleportable = TELEPORT_NORMAL; - PS(player).m_switchweapon = gunner.m_switchweapon; + for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot) + { + .entity weaponentity = weaponentities[slot]; + player.(weaponentity).m_switchweapon = gunner.(weaponentity).m_switchweapon; + delete(gunner.(weaponentity)); + } 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; @@ -282,39 +263,40 @@ void bumblebee_gunner_exit(int _exitflag) 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(vlen2(real_origin(vehic.gun2) - player.origin) < vlen2(real_origin(vehic.gun1) - player.origin)) + vector v1 = gettaginfo(vehic, gettagindex(vehic, "cannon_right")); + vector v2 = gettaginfo(vehic, gettagindex(vehic, "cannon_left")); + if(vlen2(player.origin - v1) < vlen2(player.origin - v2)) { - gunner = vehic.gun2; - vehic.gunner2 = player; + gunner = vehic.gun1; + vehic.gunner1 = player; } else { - gunner = vehic.gun1; - vehic.gunner1 = player; + gunner = vehic.gun2; + vehic.gunner2 = player; } } else if(!vehic.gunner1 && time >= vehic.gun1.phase) { gunner = vehic.gun1; vehic.gunner1 = player; } else if(!vehic.gunner2 && time >= vehic.gun2.phase) { gunner = vehic.gun2; vehic.gunner2 = player; } - else { LOG_TRACE("Vehicle is full, fail\n"); return false; } + else { LOG_TRACE("Vehicle is full, fail"); return false; } player.vehicle = gunner; player.angles = vehic.angles; player.takedamage = DAMAGE_NO; player.solid = SOLID_NOT; player.alpha = -1; - player.movetype = MOVETYPE_NOCLIP; + set_movetype(player, MOVETYPE_NOCLIP); player.event_damage = func_null; player.view_ofs = '0 0 0'; player.hud = gunner.hud; @@ -325,11 +307,17 @@ bool bumblebee_gunner_enter() player.vehicle_reload1 = vehic.vehicle_reload1; player.vehicle_reload2 = vehic.vehicle_reload2; player.vehicle_energy = vehic.vehicle_energy; - player.flags &= ~FL_ONGROUND; + UNSET_ONGROUND(player); - RemoveGrapplingHook(player); + RemoveGrapplingHooks(player); - gunner.m_switchweapon = PS(player).m_switchweapon; + for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot) + { + .entity weaponentity = weaponentities[slot]; + + gunner.(weaponentity) = new(temp_wepent); + gunner.(weaponentity).m_switchweapon = player.(weaponentity).m_switchweapon; + } gunner.vehicle_exit = bumblebee_gunner_exit; gunner.vehicle_hudmodel.viewmodelforclient = player; @@ -352,72 +340,73 @@ bool bumblebee_gunner_enter() 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)) - || (IS_DEAD(other)) - || (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, entity toucher) +{ 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, toucher); return; } - if(vehicles_valid_pilot()) + if(vehicles_valid_pilot(this, toucher)) { - 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(time >= toucher.vehicle_enter_delay && phase_time) + if(bumblebee_gunner_enter(this, toucher)) return; } - vehicles_touch(); + vehicles_touch(this, toucher); } -void bumblebee_regen(entity this) +void bumblebee_regen(entity this, float dt) { 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); + this.gun1.vehicle_energy + autocvar_g_vehicle_bumblebee_cannon_ammo_regen * dt); 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); + this.gun2.vehicle_energy + autocvar_g_vehicle_bumblebee_cannon_ammo_regen * dt); 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); + 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, dt, true); 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); + 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, dt, 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); + 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, dt, false); } -bool bumblebee_pilot_frame(entity this) +bool bumblebee_pilot_frame(entity this, float dt) { entity vehic = this.vehicle; return = true; if(intermission_running) { - vehic.velocity = '0 0 0'; - vehic.avelocity = '0 0 0'; + vehic.solid = SOLID_NOT; + vehic.takedamage = DAMAGE_NO; + set_movetype(vehic, MOVETYPE_NONE); return; } @@ -429,7 +418,7 @@ bool bumblebee_pilot_frame(entity this) return; } - bumblebee_regen(vehic); + bumblebee_regen(vehic, dt); crosshair_trace(this); @@ -480,7 +469,7 @@ bool bumblebee_pilot_frame(entity this) else if(this.movement.y > 0) newvel += v_right * autocvar_g_vehicle_bumblebee_speed_strafe; ftmp = newvel * v_right; - ftmp *= frametime * 0.1; + ftmp *= dt * 0.1; vehic.angles_z = bound(-15, vehic.angles.z + ftmp, 15); } else @@ -495,17 +484,17 @@ bool bumblebee_pilot_frame(entity this) else if(PHYS_INPUT_BUTTON_JUMP(this)) newvel += v_up * autocvar_g_vehicle_bumblebee_speed_up; - vehic.velocity += newvel * frametime; + vehic.velocity += newvel * dt; this.velocity = this.movement = vehic.velocity; if(autocvar_g_vehicle_bumblebee_healgun_locktime) { if(vehic.tur_head.lock_time < time || IS_DEAD(vehic.tur_head.enemy) || STAT(FROZEN, vehic.tur_head.enemy)) - vehic.tur_head.enemy = world; + vehic.tur_head.enemy = NULL; if(trace_ent) - if(trace_ent.movetype) + if(trace_ent.move_movetype) if(trace_ent.takedamage) if(!IS_DEAD(trace_ent) && !STAT(FROZEN, trace_ent)) { @@ -536,7 +525,7 @@ bool bumblebee_pilot_frame(entity this) autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides * -1, autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides, autocvar_g_vehicle_bumblebee_raygun_turnspeed); 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)) + if((PHYS_INPUT_BUTTON_ATCK(this) || PHYS_INPUT_BUTTON_ATCK2(this)) && (vehic.vehicle_energy > autocvar_g_vehicle_bumblebee_raygun_dps * PHYS_INPUT_FRAMETIME || autocvar_g_vehicle_bumblebee_raygun == 0)) { vehic.gun3.enemy.realowner = this; vehic.gun3.enemy.effects &= ~EF_NODRAW; @@ -550,8 +539,8 @@ bool bumblebee_pilot_frame(entity this) { if(autocvar_g_vehicle_bumblebee_raygun) { - 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; + Damage(trace_ent, vehic, this, autocvar_g_vehicle_bumblebee_raygun_dps * PHYS_INPUT_FRAMETIME, DEATH_GENERIC.m_id, trace_endpos, v_forward * autocvar_g_vehicle_bumblebee_raygun_fps * PHYS_INPUT_FRAMETIME); + vehic.vehicle_energy -= autocvar_g_vehicle_bumblebee_raygun_aps * PHYS_INPUT_FRAMETIME; } else { @@ -559,28 +548,28 @@ bool bumblebee_pilot_frame(entity this) 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); + trace_ent.vehicle_shield = min(trace_ent.vehicle_shield + autocvar_g_vehicle_bumblebee_healgun_sps * dt, trace_ent.tur_head.max_health); if(autocvar_g_vehicle_bumblebee_healgun_hps) - trace_ent.vehicle_health = min(trace_ent.vehicle_health + autocvar_g_vehicle_bumblebee_healgun_hps * frametime, trace_ent.max_health); + trace_ent.vehicle_health = min(trace_ent.vehicle_health + autocvar_g_vehicle_bumblebee_healgun_hps * dt, trace_ent.max_health); } else if(IS_CLIENT(trace_ent)) { if(trace_ent.health <= autocvar_g_vehicle_bumblebee_healgun_hmax && autocvar_g_vehicle_bumblebee_healgun_hps) - trace_ent.health = min(trace_ent.health + autocvar_g_vehicle_bumblebee_healgun_hps * frametime, autocvar_g_vehicle_bumblebee_healgun_hmax); + trace_ent.health = min(trace_ent.health + autocvar_g_vehicle_bumblebee_healgun_hps * dt, autocvar_g_vehicle_bumblebee_healgun_hmax); if(trace_ent.armorvalue <= autocvar_g_vehicle_bumblebee_healgun_amax && autocvar_g_vehicle_bumblebee_healgun_aps) - trace_ent.armorvalue = min(trace_ent.armorvalue + autocvar_g_vehicle_bumblebee_healgun_aps * frametime, autocvar_g_vehicle_bumblebee_healgun_amax); + trace_ent.armorvalue = min(trace_ent.armorvalue + autocvar_g_vehicle_bumblebee_healgun_aps * dt, autocvar_g_vehicle_bumblebee_healgun_amax); - trace_ent.health = min(trace_ent.health + autocvar_g_vehicle_bumblebee_healgun_hps * frametime, autocvar_g_vehicle_bumblebee_healgun_hmax); + trace_ent.health = min(trace_ent.health + autocvar_g_vehicle_bumblebee_healgun_hps * dt, autocvar_g_vehicle_bumblebee_healgun_hmax); } else if(IS_TURRET(trace_ent)) { if(trace_ent.health <= trace_ent.max_health && autocvar_g_vehicle_bumblebee_healgun_hps) - trace_ent.health = min(trace_ent.health + autocvar_g_vehicle_bumblebee_healgun_hps * frametime, trace_ent.max_health); + trace_ent.health = min(trace_ent.health + autocvar_g_vehicle_bumblebee_healgun_hps * dt, trace_ent.max_health); //else ..hmmm what? ammo? trace_ent.SendFlags |= TNSF_STATUS; @@ -601,7 +590,7 @@ bool bumblebee_pilot_frame(entity this) if(vehic.gun3.enemy) remove(vehic.gun3.enemy); - vehic.gun3.enemy = world; + vehic.gun3.enemy = NULL; } */ @@ -622,319 +611,313 @@ bool bumblebee_pilot_frame(entity this) 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) * PHYS_INPUT_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(!IS_DEAD(self)) + if(!IS_DEAD(this)) { - self.think = bumblebee_land; - self.nextthink = time; + setthink(this, bumblebee_land); + this.nextthink = time; } - self.movetype = MOVETYPE_TOSS; + set_movetype(this, MOVETYPE_TOSS); - if(!self.owner) + if(!this.owner) return; - fixedmakevectors(self.angles); + fixedmakevectors(this.angles); vector spot; - if(vdist(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, CS(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(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); - 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); + if(this.owner.deadflag == DEAD_DYING) + this.owner.deadflag = DEAD_DEAD; - if(self.owner.deadflag == DEAD_DYING) - self.owner.deadflag = DEAD_DEAD; + delete(this); +} - remove(self); +void bumblebee_dead_touch(entity this, entity toucher) +{ + bumblebee_blowup(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) { delete(this); return; } + if(!vehicle_initialize(this, VEH_BUMBLEBEE, false)) { delete(this); return; } } METHOD(Bumblebee, vr_impact, void(Bumblebee thisveh, entity instance)) { 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); + 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)) { - SELFPARAM(); - self.touch = bumblebee_touch; - self.nextthink = 0; - self.movetype = MOVETYPE_BOUNCEMISSILE; + settouch(instance, bumblebee_touch); + instance.nextthink = 0; + set_movetype(instance, MOVETYPE_BOUNCEMISSILE); +} +METHOD(Bumblebee, vr_gunner_enter, void(Bumblebee thisveh, entity instance, entity actor)) +{ + if(!instance.gunner1) + if(time >= instance.gun1.phase) + if(instance.gun1.vehicle_enter) + if(instance.gun1.vehicle_enter(instance, actor)) + return; + + if(!instance.gunner2) + if(time >= instance.gun2.phase) + if(instance.gun2.vehicle_enter) + if(instance.gun2.vehicle_enter(instance, actor)) + return; } METHOD(Bumblebee, vr_think, void(Bumblebee thisveh, entity instance)) { - SELFPARAM(); - self.angles_z *= 0.8; - self.angles_x *= 0.8; + instance.angles_z *= 0.8; + instance.angles_x *= 0.8; - self.nextthink = time; + instance.nextthink = time; - if(!self.owner) + if(!instance.owner) { - entity oldself = self; - if(self.gunner1) + if(instance.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; + entity e = instance.gunner1; + instance.gun1.vehicle_exit(instance.gun1, VHEF_EJECT); + instance.phase = 0; + gettouch(instance)(instance, e); + return; } - if(self.gunner2) + if(instance.gunner2) { - setself(self.gunner2); - oldself.gun2.vehicle_exit(VHEF_EJECT); - entity oldother = other; - other = self; - setself(oldself); - self.phase = 0; - self.touch(); - other = oldother; + entity e = instance.gunner2; + instance.gun2.vehicle_exit(instance.gun2, VHEF_EJECT); + instance.phase = 0; + gettouch(instance)(instance, e); return; } } } METHOD(Bumblebee, vr_death, void(Bumblebee thisveh, entity instance)) { - SELFPARAM(); - entity oldself = self; - setself(instance); - - CSQCModel_UnlinkEntity(self); + CSQCModel_UnlinkEntity(instance); - // Hide beam - if(self.gun3.enemy || !wasfreed(self.gun3.enemy)) - self.gun3.enemy.effects |= EF_NODRAW; + // hide beam + if(instance.gun3.enemy || !wasfreed(instance.gun3.enemy)) + instance.gun3.enemy.effects |= EF_NODRAW; - if(self.gunner1) - { - setself(self.gunner1); - oldself.gun1.vehicle_exit(VHEF_EJECT); - setself(oldself); - } + if(instance.gunner1) + instance.gun1.vehicle_exit(instance.gun1, VHEF_EJECT); - if(self.gunner2) - { - setself(self.gunner2); - oldself.gun2.vehicle_exit(VHEF_EJECT); - setself(oldself); - } + if(instance.gunner2) + instance.gun2.vehicle_exit(instance.gun2, VHEF_EJECT); - self.vehicle_exit(VHEF_EJECT); + instance.vehicle_exit(instance, 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); + 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(self, self.velocity + randomvec() * 200, "", rint(random()), rint(random()), 6, randomvec() * 100); + entity _body = vehicle_tossgib(instance, instance, instance.velocity + randomvec() * 200, "", rint(random()), rint(random()), 6, randomvec() * 100); if(random() > 0.5) - _body.touch = bumblebee_blowup; + settouch(_body, bumblebee_dead_touch); else - _body.touch = func_null; + settouch(_body, func_null); - _body.think = bumblebee_diethink; + setthink(_body, bumblebee_diethink); _body.nextthink = time; _body.wait = time + 2 + (random() * 8); - _body.owner = self; - _body.enemy = self.enemy; + _body.owner = instance; + _body.enemy = instance.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); - - setself(oldself); + _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; + set_movetype(instance, 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)) { - SELFPARAM(); - if(!self.gun1) + if(!instance.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; + 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; - self.gun1 = new(vehicle_playerslot); - self.gun2 = new(vehicle_playerslot); - self.gun3 = new(bumblebee_raygun); + instance.gun1 = new(vehicle_playerslot); + instance.gun2 = new(vehicle_playerslot); + instance.gun3 = new(bumblebee_raygun); - self.vehicle_flags |= VHF_MULTISLOT; + instance.vehicle_flags |= VHF_MULTISLOT; - self.gun1.owner = self; - self.gun2.owner = self; - self.gun3.owner = self; + instance.gun1.owner = instance; + instance.gun2.owner = instance; + instance.gun3.owner = instance; - setmodel(self.gun1, MDL_VEH_BUMBLEBEE_CANNON_RIGHT); - setmodel(self.gun2, MDL_VEH_BUMBLEBEE_CANNON_LEFT); - setmodel(self.gun3, MDL_VEH_BUMBLEBEE_CANNON_CENTER); + 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(self.gun1, self, "cannon_right"); - setattachment(self.gun2, self, "cannon_left"); + 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. - 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; + 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(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); + 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(self.vehicle_hudmodel, '50 0 -5'); // Move cockpit forward - down. - setorigin(self.vehicle_viewport, '5 0 2'); // Move camera forward up + 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(self.gun1.vehicle_hudmodel, '90 -27 -23'); - setorigin(self.gun1.vehicle_viewport, '-85 0 50'); + setorigin(instance.gun1.vehicle_hudmodel, '90 -27 -23'); + setorigin(instance.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'); + setorigin(instance.gun2.vehicle_hudmodel, '90 27 -23'); + setorigin(instance.gun2.vehicle_viewport, '-85 0 50'); - self.scale = 1.5; + instance.scale = 1.5; // Raygun beam - if(self.gun3.enemy == world) + if(instance.gun3.enemy == NULL) { - 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; + 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; } } - 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; + if(!autocvar_g_vehicle_bumblebee_swim) + instance.dphitcontentsmask |= DPCONTENTS_LIQUIDSMASK; + + instance.vehicle_health = autocvar_g_vehicle_bumblebee_health; + instance.vehicle_shield = autocvar_g_vehicle_bumblebee_shield; + instance.solid = SOLID_BBOX; + set_movetype(instance, MOVETYPE_TOSS); + instance.damageforcescale = 0.025; - self.PlayerPhysplug = bumblebee_pilot_frame; + instance.PlayerPhysplug = bumblebee_pilot_frame; - setorigin(self, self.origin + '0 0 25'); + setorigin(instance, instance.origin + '0 0 25'); } METHOD(Bumblebee, vr_setup, void(Bumblebee thisveh, entity instance)) { - SELFPARAM(); if(autocvar_g_vehicle_bumblebee_energy) if(autocvar_g_vehicle_bumblebee_energy_regen) - self.vehicle_flags |= VHF_ENERGYREGEN; + instance.vehicle_flags |= VHF_ENERGYREGEN; if(autocvar_g_vehicle_bumblebee_shield) - self.vehicle_flags |= VHF_HASSHIELD; + instance.vehicle_flags |= VHF_HASSHIELD; if(autocvar_g_vehicle_bumblebee_shield_regen) - self.vehicle_flags |= VHF_SHIELDREGEN; + instance.vehicle_flags |= VHF_SHIELDREGEN; if(autocvar_g_vehicle_bumblebee_health_regen) - self.vehicle_flags |= VHF_HEALTHREGEN; + 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 @@ -971,7 +954,7 @@ METHOD(Bumblebee, vr_hud, void(Bumblebee thisveh)) drawstring(tmpPos, _("No left gunner!"), tmpSize, '1 1 1', hudAlpha * blinkValue, DRAWFLAG_NORMAL); } } -METHOD(Bumblebee, vr_crosshair, void(Bumblebee thisveh)) +METHOD(Bumblebee, vr_crosshair, void(Bumblebee thisveh, entity player)) { Vehicles_drawCrosshair(vCROSS_HEAL); }