X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fserver%2Fvehicles%2Fbumblebee.qc;h=e97993ba9dd2ebca9d25e826ee71f9859b978fe9;hb=69bc67603b84c0febbb98d5fcfad7d94e245edbc;hp=80aa8bd4a97f8bd4b489c32631fbcdb728189eda;hpb=8efe68106722fd143f10c172c71be6e869ff5b21;p=xonotic%2Fxonotic-data.pk3dir.git diff --git a/qcsrc/server/vehicles/bumblebee.qc b/qcsrc/server/vehicles/bumblebee.qc index 80aa8bd4a..e97993ba9 100644 --- a/qcsrc/server/vehicles/bumblebee.qc +++ b/qcsrc/server/vehicles/bumblebee.qc @@ -35,6 +35,11 @@ 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_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_respawntime; float autocvar_g_vehicle_bumblebee_blowup_radius; @@ -42,98 +47,298 @@ float autocvar_g_vehicle_bumblebee_blowup_coredamage; float autocvar_g_vehicle_bumblebee_blowup_edgedamage; float autocvar_g_vehicle_bumblebee_blowup_forceintensity; -#define BUMB_MIN '-120 -120 -40' -#define BUMB_MAX '120 120 40' +float autocvar_g_vehicle_bumblebee; + +#define BUMB_MIN '-120 -120 -120' +#define BUMB_MAX '120 120 120' + +void bumb_fire_cannon(entity _gun, string _tagname, entity _owner) +{ + vector v; + entity bolt; + + v = gettaginfo(_gun, gettagindex(_gun, _tagname)); + bolt = vehicles_projectile("bigplasma_muzzleflash", "weapons/flacexp3.wav", + v, normalize(v_forward + randomvec() * autocvar_g_vehicle_bumblebee_cannon_spread) * autocvar_g_vehicle_bumblebee_cannon_speed, + autocvar_g_vehicle_bumblebee_cannon_damage, autocvar_g_vehicle_bumblebee_cannon_radius, autocvar_g_vehicle_bumblebee_cannon_force, 0, + DEATH_BUMB_GUN, PROJECTILE_BUMBLE_GUN, 0, TRUE, TRUE, _owner); + + + //bolt.velocity = v_forward * autocvar_g_vehicle_bumblebee_cannon_speed; +} -.entity gunner1; -//.entity gunner2; -.vector lastaim; float bumb_gunner_frame() { entity vehic, gun, gunner; - float ftmp, ftmp2; - vector vtmp; - vehic = self.vehicle; - gun = self.vehicle.gun1; + vehic = self.vehicle.owner; + gun = self.vehicle; gunner = self; - self = vehic; + vehic.solid = SOLID_NOT; + setorigin(gunner, vehic.origin); + gunner.velocity = vehic.velocity; crosshair_trace(gunner); - - //vtmp = gettaginfo(vehic, gettagindexvehic, "tag_hardpoint01")); - vtmp = gettaginfo(gun, gettagindex(gun, "muzzle")); - vtmp = vectoangles(normalize(trace_endpos - vtmp)); // Find the direction & angle - vtmp = shortangle_vxy(vtmp - (vehic.angles + gun.angles), vehic.angles + gun.angles); // Find aim offset - - // Bind to aimspeed - ftmp2 = autocvar_g_vehicle_bumblebee_cannon_turnspeed * frametime; ftmp = -ftmp2; - vtmp_x = bound(ftmp, vtmp_x, ftmp2); - vtmp_y = bound(ftmp, vtmp_y, ftmp2); - // Bind to limts - gun.angles_x = bound(-autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down, vtmp_x + gun.angles_x, autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up); - gun.angles_y = bound(-autocvar_g_vehicle_bumblebee_cannon_turnlimit_in, vtmp_y + gun.angles_y, autocvar_g_vehicle_bumblebee_cannon_turnlimit_out); - - if(gunner.BUTTON_ATCK && gun.cnt <= time) + vector _ct = trace_endpos; + vector ad; + float _in, _out; + _in = ((gun == vehic.gun1) ? autocvar_g_vehicle_bumblebee_cannon_turnlimit_in : autocvar_g_vehicle_bumblebee_cannon_turnlimit_out); + _out = ((gun == vehic.gun1) ? autocvar_g_vehicle_bumblebee_cannon_turnlimit_out : autocvar_g_vehicle_bumblebee_cannon_turnlimit_in); + + if(gun.lock_time < time) + gun.enemy = world; + + if(trace_ent) + if(trace_ent.movetype) + if(trace_ent.takedamage) + if(!trace_ent.deadflag) + { + if(teamplay) + { + if(trace_ent.team != gunner.team) + { + gun.enemy = trace_ent; + gun.lock_time = time + 5; + } + } + else + { + gun.enemy = trace_ent; + gun.lock_time = time + 5; + } + } + + if(gun.enemy) { - vtmp = gettaginfo(gun, gettagindex(gun, "muzzle")); - v_forward = normalize(v_forward); - vtmp += v_forward * 50; + float i, distance, impact_time; + + vector vf = real_origin(gun.enemy); + vector _vel = gun.enemy.velocity; + if(gun.enemy.movetype == MOVETYPE_WALK) + _vel_z *= 0.1; + + + ad = vf; + for(i = 0; i < 4; ++i) + { + distance = vlen(ad - gunner.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); + 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); - fireBullet (vtmp, v_forward, autocvar_g_vehicle_spiderbot_minigun_spread, autocvar_g_vehicle_spiderbot_minigun_damage, - autocvar_g_vehicle_spiderbot_minigun_spread, DEATH_SBMINIGUN, 0); + } + else + vehicle_aimturret(vehic, _ct, 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); - gun.cnt = time + 0.1; + if(gunner.BUTTON_ATCK) + if(time > gun.attack_finished_single) + if(vehic.vehicle_energy >= autocvar_g_vehicle_bumblebee_cannon_cost) + { + vehic.vehicle_energy -= autocvar_g_vehicle_bumblebee_cannon_cost; + vehic.wait = time; + bumb_fire_cannon(gun, "fire", gunner); + gun.attack_finished_single = time + autocvar_g_vehicle_bumblebee_cannon_refire; } + + VEHICLE_UPDATE_PLAYER(gunner, health, bumblebee); + VEHICLE_UPDATE_PLAYER(gunner, energy, bumblebee); - setorigin(gunner, vehic.origin); - gunner.velocity = vehic.velocity; + if(vehic.vehicle_flags & VHF_HASSHIELD) + VEHICLE_UPDATE_PLAYER(gunner, 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); + vehic.solid = SOLID_BBOX; gunner.BUTTON_ATCK = gunner.BUTTON_ATCK2 = gunner.BUTTON_CROUCH = 0; self = gunner; return 1; } -void bumb_gunner_enter() +.entity gunner1; +.entity gunner2; + +void bumb_gunner_exit(float _exitflag) { - if(self.gunner1 != world) - return; + dprint("^2Gunner1 exits\n"); + + if (clienttype(self) == CLIENTTYPE_REAL) + { + msg_entity = self; + WriteByte (MSG_ONE, SVC_SETVIEWPORT); + WriteEntity( MSG_ONE, self); + + WriteByte (MSG_ONE, SVC_SETVIEWANGLES); + WriteAngle(MSG_ONE, 0); + WriteAngle(MSG_ONE, self.vehicle.angles_y); + WriteAngle(MSG_ONE, 0); + } + + setsize(self, PL_MIN,PL_MAX); + + self.takedamage = DAMAGE_AIM; + self.solid = SOLID_SLIDEBOX; + self.movetype = MOVETYPE_WALK; + self.effects &~= EF_NODRAW; + self.alpha = 1; + self.PlayerPhysplug = SUB_Null; + self.view_ofs = PL_VIEW_OFS; + self.event_damage = PlayerDamage; + self.hud = HUD_NORMAL; + self.switchweapon = self.vehicle.switchweapon; + + if(self.flagcarried) + { + self.flagcarried.scale = 0.6; + setattachment(self.flagcarried, self, ""); + setorigin(self.flagcarried, FLAG_CARRY_POS); + } - self.gunner1 = other; - self.gunner1.vehicle = self; + CSQCVehicleSetup(self, HUD_NORMAL); + self.vehicle.vehicle_hudmodel.viewmodelforclient = self.vehicle; + + if(self == self.vehicle.owner.gunner1) + self.vehicle.owner.gunner1 = world; + else if(self == self.vehicle.owner.gunner2) + self.vehicle.owner.gunner2 = world; + else + dprint("^1self != gunner1 or gunner2, this is a BIG PROBLEM, tell tZork this happend.\n"); + + self.vehicle.phase = time + 1; + self.vehicle = world; +} +float bumb_gunner_enter() +{ + RemoveGrapplingHook(other); + entity _gun, _gunner; + if(!self.gunner1) + { + _gun = self.gun1; + _gunner = self.gunner1; + self.gunner1 = other; + } + else + { + _gun = self.gun2; + _gunner = self.gunner2; + self.gunner2 = other; + } + + _gun.vehicle_pilot = other; + _gunner = other; + //_gun.owner = other; + _gunner.vehicle = _gun; + _gun.switchweapon = other.switchweapon; + _gun.vehicle_exit = bumb_gunner_exit; + + + other.angles = self.angles; + other.takedamage = DAMAGE_NO; + other.solid = SOLID_NOT; + other.movetype = MOVETYPE_NOCLIP; + other.alpha = -1; + other.event_damage = SUB_Null; + other.view_ofs = '0 0 0'; + other.hud = _gun.hud; + other.PlayerPhysplug = _gun.PlayerPhysplug; + other.vehicle_ammo1 = self.vehicle_ammo1; + other.vehicle_ammo2 = self.vehicle_ammo2; + other.vehicle_reload1 = self.vehicle_reload1; + other.vehicle_reload2 = self.vehicle_reload2; + other.vehicle_energy = self.vehicle_energy; + other.PlayerPhysplug = bumb_gunner_frame; + other.flags &~= FL_ONGROUND; + msg_entity = other; WriteByte (MSG_ONE, SVC_SETVIEWPORT); - WriteEntity(MSG_ONE, self.gun1); + WriteEntity(MSG_ONE, _gun.vehicle_viewport); WriteByte (MSG_ONE, SVC_SETVIEWANGLES); - if(self.tur_head) + WriteAngle(MSG_ONE, _gun.angles_x + self.angles_x); // tilt + WriteAngle(MSG_ONE, _gun.angles_y + self.angles_y); // yaw + WriteAngle(MSG_ONE, 0); // roll + _gun.vehicle_hudmodel.viewmodelforclient = other; + + if(!self.gunner1) + { + self.gun1 = other; + _gunner = self.gunner1; + } + else + { + _gun = self.gun2; + _gunner = self.gunner2; + } + + return TRUE; +} + +float vehicles_valid_pilot() +{ + if(other.classname != "player") + return FALSE; + + if(other.deadflag != DEAD_NO) + return FALSE; + + if(other.vehicle != world) + return FALSE; + + // Remove this when bots know how to use vehicles. + if (clienttype(other) != CLIENTTYPE_REAL) + return FALSE; + + if(teamplay && other.team != self.team) + return FALSE; + + return TRUE; +} + +void bumb_touch() +{ + + if(self.gunner1 != world && self.gunner2 != world) + { + vehicles_touch(); + return; + } + + if (vehicles_valid_pilot()) { - WriteAngle(MSG_ONE, self.gun1.angles_x + self.angles_x); // tilt - WriteAngle(MSG_ONE, self.gun1.angles_y + self.angles_y); // yaw - WriteAngle(MSG_ONE, 0); // roll + if(self.gun1.phase <= time) + if (bumb_gunner_enter()) + return; + + if(self.gun2.phase <= time) + if (bumb_gunner_enter()) + return; + } - other.PlayerPhysplug = bumb_gunner_frame; + + vehicles_touch(); } float bumb_pilot_frame() { - entity pilot, gunner, vehic; + entity pilot, vehic; vector newvel; pilot = self; vehic = self.vehicle; self = vehic; - if(pilot.BUTTON_USE && vehic.deadflag == DEAD_NO) - { - self = vehic; - vehicles_exit(VHEF_NORMAL); - self = pilot; - return 0; - } - if(vehic.deadflag != DEAD_NO) { self = pilot; @@ -209,20 +414,58 @@ float bumb_pilot_frame() pilot.velocity = pilot.movement = vehic.velocity; setorigin(pilot,vehic.origin + '0 0 32'); - + vehicle_aimturret(vehic, trace_endpos, self.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(!vehic.gunner1) + vehicle_aimturret(vehic, trace_endpos, self.gun1, "fire", + autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1, autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up, + autocvar_g_vehicle_bumblebee_cannon_turnlimit_out * -1, autocvar_g_vehicle_bumblebee_cannon_turnlimit_in, autocvar_g_vehicle_bumblebee_cannon_turnspeed); + //if(!vehic.gunner2) + vehicle_aimturret(vehic, trace_endpos, self.gun2, "fire", + autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1, autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up, + autocvar_g_vehicle_bumblebee_cannon_turnlimit_in * -1, autocvar_g_vehicle_bumblebee_cannon_turnlimit_out, autocvar_g_vehicle_bumblebee_cannon_turnspeed); + + + + if(pilot.BUTTON_ATCK) + if(time > vehic.attack_finished_single) + if(vehic.vehicle_energy >= autocvar_g_vehicle_bumblebee_cannon_cost) + { + vehic.vehicle_energy -= autocvar_g_vehicle_bumblebee_cannon_cost; + vehic.wait = time; + + if(vehic.cnt) + { + bumb_fire_cannon(vehic.gun1, "fire", pilot); + vehic.cnt = 0; + } + else + { + bumb_fire_cannon(vehic.gun2, "fire", pilot); + vehic.cnt = 1; + } + vehic.attack_finished_single = time + autocvar_g_vehicle_bumblebee_cannon_refire; + } + */ + if(vehic.vehicle_flags & VHF_SHIELDREGEN) - vehicles_regen(dmg_time, vehicle_shield, autocvar_g_vehicle_bumblebee_shield, autocvar_g_vehicle_bumblebee_shield_regen_pause, autocvar_g_vehicle_bumblebee_shield_regen, frametime); + vehicles_regen(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(vehic.vehicle_flags & VHF_HEALTHREGEN) - vehicles_regen(dmg_time, vehicle_health, autocvar_g_vehicle_bumblebee_health, autocvar_g_vehicle_bumblebee_health_regen_pause, autocvar_g_vehicle_bumblebee_health_regen, frametime); + vehicles_regen(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(vehic.vehicle_flags & VHF_ENERGYREGEN) - vehicles_regen(cnt, vehicle_energy, autocvar_g_vehicle_bumblebee_energy, autocvar_g_vehicle_bumblebee_energy_regen_pause, autocvar_g_vehicle_bumblebee_energy_regen, frametime); + vehicles_regen(wait, vehicle_energy, autocvar_g_vehicle_bumblebee_energy, autocvar_g_vehicle_bumblebee_energy_regen_pause, autocvar_g_vehicle_bumblebee_energy_regen, frametime, FALSE); + + VEHICLE_UPDATE_PLAYER(pilot, health, bumblebee); + VEHICLE_UPDATE_PLAYER(pilot, energy, bumblebee); - VEHICLE_UPDATE_PLAYER(health, bumblebee); - VEHICLE_UPDATE_PLAYER(energy, bumblebee); if(vehic.vehicle_flags & VHF_HASSHIELD) - VEHICLE_UPDATE_PLAYER(shield, bumblebee); + VEHICLE_UPDATE_PLAYER(pilot, shield, bumblebee); + pilot.BUTTON_ATCK = pilot.BUTTON_ATCK2 = pilot.BUTTON_CROUCH = 0; self = pilot; @@ -238,7 +481,7 @@ void bumb_think() void bumb_enter() { - self.touch = bumb_gunner_enter; + self.touch = bumb_touch; } void bumb_exit(float eject) @@ -247,89 +490,105 @@ void bumb_exit(float eject) self.touch = vehicles_touch; } -void bumb_spawn() -{ - self.vehicle_health = autocvar_g_vehicle_bumblebee_health; - self.vehicle_shield = autocvar_g_vehicle_bumblebee_shield; - self.movetype = MOVETYPE_TOSS; - self.solid = SOLID_BBOX; - //self.vehicle_energy = 1; - self.movetype = MOVETYPE_FLY; - setorigin(self, self.origin + '0 0 25'); -} - void bumb_die() { + self.deadflag = DEAD_DEAD; + self.vehicle_exit(VHEF_NORMAL); + self.health = 0; self.event_damage = SUB_Null; - self.iscreature = FALSE; self.solid = SOLID_CORPSE; self.takedamage = DAMAGE_NO; self.deadflag = DEAD_DYING; self.movetype = MOVETYPE_BOUNCE; + + RadiusDamage (self, self.enemy, autocvar_g_vehicle_bumblebee_blowup_coredamage, + autocvar_g_vehicle_bumblebee_blowup_edgedamage, + autocvar_g_vehicle_bumblebee_blowup_radius, world, + autocvar_g_vehicle_bumblebee_blowup_forceintensity, + DEATH_WAKIBLOWUP, world); pointparticles(particleeffectnum("rocket_explode"), findbetterlocation (self.origin, 16), '0 0 0', 1); } -void bumb_dinit() + +void bumb_spawn(float _f) { - if not (vehicle_initialize( - "Bumblebee", - "models/vehicles/bumblebee_body.dpm", - "", - "models/vehicles/spiderbot_cockpit.dpm", - "", "", "tag_viewport", - HUD_BUMBLEBEE, - BUMB_MIN, BUMB_MAX, - FALSE, - bumb_spawn, autocvar_g_vehicle_bumblebee_respawntime, - bumb_pilot_frame, - bumb_enter, bumb_exit, - bumb_die, bumb_think, - FALSE)) + /* + float i; + for(i=1; gettaginfo(self.gun1, i), gettaginfo_name; ++i) { - remove(self); - return; + + dprint(" ------- ^1gettaginfo_name^2(",ftos(i),") ^3=", gettaginfo_name, "\n"); } - self.gun1 = spawn(); - setmodel(self.gun1, "models/vehicles/bumblebee_ray.dpm"); - setattachment(self.gun1, self, "tag_hardpoint03"); - - self.gun1 = spawn(); - self.gun2 = spawn(); - - self.gun1.owner = self; - self.gun2.owner = self; - - setmodel(self.gun1, "models/vehicles/bumblebee_plasma_right.dpm"); - setmodel(self.gun2, "models/vehicles/bumblebee_plasma_left.dpm"); - - setattachment(self.gun1, self, "tag_hardpoint01"); - setattachment(self.gun2, self, "tag_hardpoint02"); - - vector ofs; - ofs = gettaginfo(self, gettagindex(self, "tag_hardpoint01")); - ofs -= self.origin; - setattachment(self.gun1, self, ""); - setorigin(self.gun1, ofs); - - ofs = gettaginfo(self, gettagindex(self, "tag_hardpoint02")); - ofs -= self.origin; - setattachment(self.gun2, self, ""); - setorigin(self.gun2, ofs); - - + */ + + if(!self.gun1) + { + // for some reason, autosizing of the shiled 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, "models/vhshield.md3"); + 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; + + setmodel(self.gun1, "models/vehicles/bumblebee_plasma_right.dpm"); + setmodel(self.gun2, "models/vehicles/bumblebee_plasma_left.dpm"); + setmodel(self.gun3, "models/vehicles/bumblebee_ray.dpm"); + + setattachment(self.gun1, self, "cannon_right"); + setattachment(self.gun2, self, "cannon_left"); + setattachment(self.gun3, self, "raygun"); + + vehicle_addplayerslot(self, self.gun1, HUD_RAPTOR, "models/vehicles/wakizashi_cockpit.dpm", bumb_gunner_frame, bumb_gunner_exit); + vehicle_addplayerslot(self, self.gun2, HUD_RAPTOR, "models/vehicles/wakizashi_cockpit.dpm", bumb_gunner_frame, bumb_gunner_exit); + + //fixme-model + setorigin(self.gun1.vehicle_hudmodel, '90 -27 -23'); + setorigin(self.gun1.vehicle_viewport, '-85 0 50'); + + setorigin(self.gun2.vehicle_hudmodel, '90 27 -23'); + setorigin(self.gun2.vehicle_viewport, '-85 0 50'); + self.scale = 1.5; + } + + self.vehicle_health = autocvar_g_vehicle_bumblebee_health; + self.vehicle_shield = autocvar_g_vehicle_bumblebee_shield; + self.movetype = MOVETYPE_TOSS; + self.solid = SOLID_BBOX; + self.movetype = MOVETYPE_FLY; + setorigin(self, self.origin + '0 0 25'); } void spawnfunc_vehicle_bumblebee() { - + if(!autocvar_g_vehicle_bumblebee) + { + remove(self); + return; + } + precache_model ("models/vehicles/bumblebee_body.dpm"); precache_model ("models/vehicles/bumblebee_plasma_left.dpm"); precache_model ("models/vehicles/bumblebee_plasma_right.dpm"); precache_model ("models/vehicles/bumblebee_ray.dpm"); - - //vehicles_configcheck("vehicle_bumblebee.cfg", autocvar_g_vehicle_bumblebee_health); + precache_model ("models/vehicles/wakizashi_cockpit.dpm"); + precache_model ("models/vehicles/spiderbot_cockpit.dpm"); + precache_model ("models/vehicles/raptor_cockpit.dpm"); if(autocvar_g_vehicle_bumblebee_energy) if(autocvar_g_vehicle_bumblebee_energy_regen) @@ -344,8 +603,17 @@ void spawnfunc_vehicle_bumblebee() if(autocvar_g_vehicle_bumblebee_health_regen) self.vehicle_flags |= VHF_HEALTHREGEN; - self.think = bumb_dinit; - self.nextthink = time + 1; + if not (vehicle_initialize( + "Bumblebee", "models/vehicles/bumblebee_body.dpm", + "", "models/vehicles/spiderbot_cockpit.dpm", "", "", "tag_viewport", + HUD_BUMBLEBEE, BUMB_MIN, BUMB_MAX, FALSE, + bumb_spawn, autocvar_g_vehicle_bumblebee_respawntime, + bumb_pilot_frame, bumb_enter, bumb_exit, + bumb_die, bumb_think, FALSE, autocvar_g_vehicle_bumblebee_health)) + { + remove(self); + return; + } } #endif // SVQC @@ -370,3 +638,26 @@ void vehicle_bumblebee_assemble() } #endif //CSQC + +/* +vector predict_target(entity _targ, vector _from, float _shot_speed) +{ + float i; // loop + float _distance; // How far to target + float _impact_time; // How long untill projectile impacts + vector _predict_pos; // Predicted enemy location + vector _original_origin;// Where target is before predicted + + _original_origin = real_origin(_targ); // Typicaly center of target BBOX + + _predict_pos = _original_origin; + for(i = 0; i < 4; ++i) // Loop a few times to increase prediction accuracy (increase loop count if accuracy is to low) + { + _distance = vlen(_predict_pos - _from); // Get distance to previos predicted location + _impact_time = _distance / _shot_speed; // Calculate impact time + _predict_pos = _original_origin + _targ.velocity * _impact_time; // Calculate new predicted location + } + + return _predict_pos; +} +*/ \ No newline at end of file