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_respawntime;
float autocvar_g_vehicle_bumblebee_blowup_coredamage;
float autocvar_g_vehicle_bumblebee_blowup_edgedamage;
float autocvar_g_vehicle_bumblebee_blowup_forceintensity;
+var vector autocvar_g_vehicle_bumblebee_bouncepain;
var float autocvar_g_vehicle_bumblebee = 0;
float bumble_raygun_send(entity to, float sf);
-#define BUMB_MIN '-120 -120 -120'
-#define BUMB_MAX '120 120 120'
+#define BUMB_MIN '-130 -130 -130'
+#define BUMB_MAX '130 130 130'
void bumb_fire_cannon(entity _gun, string _tagname, entity _owner)
{
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);
+ DEATH_VH_BUMB_GUN, PROJECTILE_BUMBLE_GUN, 0, TRUE, TRUE, _owner);
}
float bumb_gunner_frame()
entity gunner = self;
self = vehic;
+
+
+
vehic.solid = SOLID_NOT;
- setorigin(gunner, vehic.origin);
+ //setorigin(gunner, vehic.origin);
gunner.velocity = vehic.velocity;
+
+ float _in, _out;
+ vehic.angles_x *= -1;
+ makevectors(vehic.angles);
+ vehic.angles_x *= -1;
+ if((gun == vehic.gun1))
+ {
+ _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);
+ }
+ 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);
+ }
+
crosshair_trace(gunner);
vector _ct = trace_endpos;
vector ad;
- float _in = ((gun == vehic.gun1) ? autocvar_g_vehicle_bumblebee_cannon_turnlimit_in : autocvar_g_vehicle_bumblebee_cannon_turnlimit_out);
- float _out = ((gun == vehic.gun1) ? autocvar_g_vehicle_bumblebee_cannon_turnlimit_out : autocvar_g_vehicle_bumblebee_cannon_turnlimit_in);
-
if(autocvar_g_vehicle_bumblebee_cannon_lock)
{
if(gun.lock_time < time)
void bumb_gunner_exit(float _exitflag)
{
- if(clienttype(self) == CLIENTTYPE_REAL)
+ if(IS_REAL_CLIENT(self))
{
msg_entity = self;
WriteByte(MSG_ONE, SVC_SETVIEWPORT);
self.movetype = MOVETYPE_WALK;
self.effects &~= EF_NODRAW;
self.alpha = 1;
- self.PlayerPhysplug = SUB_Null;
+ self.PlayerPhysplug = func_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);
- }
+ vh_player = self;
+ vh_vehicle = self.vehicle;
+ MUTATOR_CALLHOOK(VehicleExit);
+ self = vh_player;
+ self.vehicle = vh_vehicle;
self.vehicle.vehicle_hudmodel.viewmodelforclient = self.vehicle;
+ fixedmakevectors(self.vehicle.owner.angles);
+
if(self == self.vehicle.owner.gunner1)
- self.vehicle.owner.gunner1 = world;
+ {
+ self.vehicle.owner.gunner1 = world;
+ }
else if(self == self.vehicle.owner.gunner2)
- self.vehicle.owner.gunner2 = world;
+ {
+ self.vehicle.owner.gunner2 = world;
+ v_right *= -1;
+ }
else
dprint("^1self != gunner1 or gunner2, this is a BIG PROBLEM, tell tZork this happend.\n");
+
+ vector spot = self.vehicle.owner.origin + + v_up * 128 + v_right * 300;
+ spot = vehicles_findgoodexit(spot);
+ //setorigin(self , spot);
+
+ self.velocity = 0.75 * self.vehicle.owner.velocity + normalize(spot - self.vehicle.owner.origin) * 200;
+ self.velocity_z += 10;
self.vehicle.phase = time + 5;
self.vehicle = world;
other.solid = SOLID_NOT;
other.movetype = MOVETYPE_NOCLIP;
other.alpha = -1;
- other.event_damage = SUB_Null;
+ other.event_damage = func_null;
other.view_ofs = '0 0 0';
other.hud = _gun.hud;
other.PlayerPhysplug = _gun.PlayerPhysplug;
CSQCVehicleSetup(other, other.hud);
- if(other.flagcarried)
- {
- if(!autocvar_g_vehicles_allow_flagcarry)
- DropFlag(other.flagcarried, world, world);
- else
- {
- other.flagcarried.scale = 1;
- setattachment(other.flagcarried, self, "");
- setorigin(other.flagcarried, '0 0 1' * self.maxs_z);
- }
- }
+ vh_player = other;
+ vh_vehicle = _gun;
+ MUTATOR_CALLHOOK(VehicleEnter);
+ other = vh_player;
+ _gun = vh_vehicle;
return TRUE;
}
float vehicles_valid_pilot()
{
- if(other.classname != "player")
+ if not(IS_PLAYER(other))
return FALSE;
if(other.deadflag != DEAD_NO)
if(other.vehicle != world)
return FALSE;
- if(clienttype(other) != CLIENTTYPE_REAL)
+ if not(IS_REAL_CLIENT(other))
if(!autocvar_g_vehicles_allow_bots)
return FALSE;
// Pitch
ftmp = 0;
- if(pilot.movement_x > 0 && vang_x < autocvar_g_vehicle_bumblebee_pitchlimit) ftmp = 5;
- else if(pilot.movement_x < 0 && vang_x > -autocvar_g_vehicle_bumblebee_pitchlimit) ftmp = -20;
+ if(pilot.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)
+ ftmp = -8;
newvel_x = bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel_x , autocvar_g_vehicle_bumblebee_pitchlimit);
ftmp = vang_x - bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel_x + ftmp, autocvar_g_vehicle_bumblebee_pitchlimit);
vehic.velocity += newvel * frametime;
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((pilot.BUTTON_ATCK || pilot.BUTTON_ATCK2) && vehic.vehicle_energy > autocvar_g_vehicle_bumblebee_raygun_dps * sys_frametime)
- {
+ 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.gun3.enemy == world)
+ if(trace_ent)
+ if(trace_ent.movetype)
+ if(trace_ent.takedamage)
+ if(!trace_ent.deadflag)
{
- vehic.gun3.enemy = spawn();
- Net_LinkEntity(vehic.gun3.enemy, FALSE, 0, bumble_raygun_send);
- vehic.gun3.enemy.SendFlags = BRG_SETUP;
- vehic.gun3.enemy.think = SUB_Remove;
- vehic.gun3.enemy.realowner = pilot;
- vehic.gun3.enemy.cnt = autocvar_g_vehicle_bumblebee_raygun;
+ if(teamplay)
+ {
+ if(trace_ent.team == pilot.team)
+ {
+ vehic.tur_head.enemy = trace_ent;
+ vehic.tur_head.lock_time = time + autocvar_g_vehicle_bumblebee_healgun_locktime;
+ }
+ }
+ else
+ {
+ 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);
}
+ }
+
+ vang = 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);
- vehic.gun3.enemy.nextthink = time + 0.1;
- setorigin(vehic.gun3.enemy, gettaginfo(vehic.gun3, gettagindex(vehic.gun3, "fire")));
- traceline(vehic.gun3.enemy.origin, vehic.gun3.enemy.origin + v_forward * autocvar_g_vehicle_bumblebee_raygun_range, MOVE_NORMAL, vehic);
+ if((pilot.BUTTON_ATCK || pilot.BUTTON_ATCK2) && (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.effects &~= EF_NODRAW;
+
+ vehic.gun3.enemy.hook_start = gettaginfo(vehic.gun3, gettagindex(vehic.gun3, "fire"));
+ vehic.gun3.enemy.SendFlags |= BRG_START;
+
+ traceline(vehic.gun3.enemy.hook_start, vehic.gun3.enemy.hook_start + v_forward * autocvar_g_vehicle_bumblebee_raygun_range, MOVE_NORMAL, vehic);
+
if(trace_ent)
{
if(autocvar_g_vehicle_bumblebee_raygun)
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.tur_health);
}
- else if(trace_ent.flags & FL_CLIENT)
+ 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);
}
}
}
+
vehic.gun3.enemy.hook_end = trace_endpos;
- vehic.gun3.enemy.SendFlags |= BRG_START;
+ setorigin(vehic.gun3.enemy, trace_endpos);
vehic.gun3.enemy.SendFlags |= BRG_END;
+
vehic.wait = time + 1;
}
else
- {
+ vehic.gun3.enemy.effects |= EF_NODRAW;
+ /*{
if(vehic.gun3.enemy)
remove(vehic.gun3.enemy);
vehic.gun3.enemy = world;
}
-
+ */
+
VEHICLE_UPDATE_PLAYER(pilot, health, bumblebee);
VEHICLE_UPDATE_PLAYER(pilot, energy, bumblebee);
if(vehic.vehicle_flags & VHF_HASSHIELD)
VEHICLE_UPDATE_PLAYER(pilot, shield, bumblebee);
-
+
+ vehic.angles_x *= -1;
+ makevectors(vehic.angles);
+ vehic.angles_x *= -1;
+ setorigin(pilot, vehic.origin + v_up * 48 + v_forward * 160);
pilot.BUTTON_ATCK = pilot.BUTTON_ATCK2 = pilot.BUTTON_CROUCH = 0;
self = pilot;
void bumb_think()
{
- self.velocity = self.velocity * 0.99;
- self.nextthink = time + 0.1;
+ self.movetype = MOVETYPE_TOSS;
+
+ //self.velocity = self.velocity * 0.5;
+ self.angles_z *= 0.8;
+ self.angles_x *= 0.8;
+
+ self.nextthink = time + 0.05;
+
+ if(!self.owner)
+ {
+ entity oldself = self;
+ if(self.gunner1)
+ {
+ self = self.gunner1;
+ oldself.gun1.vehicle_exit(VHEF_EJECT);
+ entity oldother = other;
+ other = self;
+ self = oldself;
+ self.phase = 0;
+ self.touch();
+ other = oldother;
+ return;
+ }
+
+ if(self.gunner2)
+ {
+ self = self.gunner2;
+ oldself.gun2.vehicle_exit(VHEF_EJECT);
+ entity oldother = other;
+ other = self;
+ self = oldself;
+ self.phase = 0;
+ self.touch();
+ other = oldother;
+ return;
+ }
+ }
+
}
void bumb_enter()
{
- self.touch = bumb_touch;
+ self.touch = bumb_touch;
+ self.nextthink = 0;
+ self.movetype = MOVETYPE_BOUNCEMISSILE;
+ //setattachment(self.owner, self.vehicle_viewport, "");
}
void bumb_exit(float eject)
{
- self.owner = world;
self.touch = vehicles_touch;
+ self.think = bumb_think;
+ self.nextthink = time;
+
+ if(!self.owner)
+ return;
+
+ fixedmakevectors(self.angles);
+ vector spot;
+ if(vlen(self.velocity) > autocvar_g_vehicle_bumblebee_speed_forward * 0.5)
+ spot = self.origin + v_up * 128 + v_forward * 200;
+ else
+ spot = self.origin + v_up * 128 - v_forward * 200;
+
+ spot = vehicles_findgoodexit(spot);
+
+
+ self.owner.velocity = 0.75 * self.vehicle.velocity + normalize(spot - self.vehicle.origin) * 200;
+ self.owner.velocity_z += 10;
+ setorigin(self.owner, spot);
+
+ /*if(eject)
+ {
+ spot = self.origin + v_forward * 100 + '0 0 64';
+ spot = vehicles_findgoodexit(spot);
+ //setorigin(self.owner , spot);
+ self.owner.velocity = (v_up + v_forward * 0.25) * 250;
+ self.owner.oldvelocity = self.owner.velocity;
+ }
+ else
+ {
+ if(vlen(self.velocity) > autocvar_g_vehicle_bumblebee_speed_forward * 0.5)
+ {
+ if(vlen(self.velocity) > autocvar_sv_maxairspeed)
+ self.owner.velocity = normalize(self.velocity) * autocvar_sv_maxairspeed;
+ else
+ self.owner.velocity = self.velocity + v_forward * 100;
+
+ self.owner.velocity_z += 200;
+ spot = self.origin + v_forward * 128 + '0 0 32';
+ spot = vehicles_findgoodexit(spot);
+ }
+ else
+ {
+ self.owner.velocity = self.velocity * 0.5;
+ self.owner.velocity_z += 10;
+ spot = self.origin - v_forward * 300 + '0 0 32';
+ spot = vehicles_findgoodexit(spot);
+ }
+ self.owner.oldvelocity = self.owner.velocity;
+ //setorigin(self.owner , spot);
+ }
+ */
+
+ antilag_clear(self.owner);
+ self.owner = world;
}
void bumb_blowup()
{
- self.deadflag = DEAD_DEAD;
-
RadiusDamage(self, self.enemy, autocvar_g_vehicle_bumblebee_blowup_coredamage,
autocvar_g_vehicle_bumblebee_blowup_edgedamage,
- autocvar_g_vehicle_bumblebee_blowup_radius, self,
+ autocvar_g_vehicle_bumblebee_blowup_radius, self, world,
autocvar_g_vehicle_bumblebee_blowup_forceintensity,
- DEATH_WAKIBLOWUP, world);
-
- self.movetype = MOVETYPE_NONE;
- self.effects = EF_NODRAW;
- self.colormod = '0 0 0';
- self.avelocity = '0 0 0';
- self.velocity = '0 0 0';
-
- //entity vehicle_tossgib(entity _template, vector _vel, string _tag, float _burn, float _explode, float _maxtime)
- 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() * 300);
- vehicle_tossgib(self.gun2, self.velocity + v_right * -300 + v_up * 100 + randomvec() * 200, "cannon_left", rint(random()), rint(random()), 6, randomvec() * 300);
- vehicle_tossgib(self.gun3, self.velocity + v_forward * 300 + v_up * -100 + randomvec() * 200, "raygun", rint(random()), rint(random()), 6, randomvec() * 300);
+ DEATH_VH_BUMB_DEATH, world);
sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
pointparticles(particleeffectnum("explosion_large"), randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
-
- setorigin(self, self.pos1);
- self.touch = SUB_Null;
- self.nextthink = 0;
+
+ if(self.owner.deadflag == DEAD_DYING)
+ self.owner.deadflag = DEAD_DEAD;
+
+ remove(self);
}
void bumb_diethink()
void bumb_die()
{
entity oldself = self;
+
+ // Hide beam
+ if(self.gun3.enemy || !wasfreed(self.gun3.enemy))
+ self.gun3.enemy.effects |= EF_NODRAW;
+
if(self.gunner1)
{
self = self.gunner1;
self.vehicle_exit(VHEF_EJECT);
- self.health = 0;
- self.event_damage = SUB_Null;
- self.solid = SOLID_CORPSE;
- self.takedamage = DAMAGE_NO;
- self.deadflag = DEAD_DYING;
- self.movetype = MOVETYPE_BOUNCE;
- self.think = bumb_diethink;
- self.nextthink = time;
- self.wait = time + 2 + (random() * 8);
-
- self.avelocity = '0 0.5 1' * (random() * 400);
- self.avelocity -= '0 0.5 1' * (random() * 400);
+ 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);
- self.colormod = '-0.5 -0.5 -0.5';
- self.touch = bumb_blowup;
+ entity _body = vehicle_tossgib(self, self.velocity + randomvec() * 200, "", rint(random()), rint(random()), 6, randomvec() * 100);
+ if(random() > 0.5)
+ _body.touch = bumb_blowup;
+ else
+ _body.touch = func_null;
+
+ _body.think = bumb_diethink;
+ _body.nextthink = time;
+ _body.wait = time + 2 + (random() * 8);
+ _body.owner = self;
+ _body.enemy = self.enemy;
+
pointparticles(particleeffectnum("explosion_medium"), findbetterlocation(self.origin, 16), '0 0 0', 1);
+
+ self.health = 0;
+ self.event_damage = func_null;
+ self.solid = SOLID_CORPSE;
+ 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);
}
+void bumb_impact()
+{
+ if(autocvar_g_vehicle_bumblebee_bouncepain_x)
+ vehilces_impact(autocvar_g_vehicle_bumblebee_bouncepain_x,
+ autocvar_g_vehicle_bumblebee_bouncepain_y,
+ autocvar_g_vehicle_bumblebee_bouncepain_z);
+}
void bumb_spawn(float _f)
{
dprint(" ------- ^1gettaginfo_name^2(",ftos(i),") ^3=", gettaginfo_name, "\n");
}
*/
-
if(!self.gun1)
{
// for some reason, autosizing of the shiled entity refuses to work for this one so set it up in advance.
vehicle_addplayerslot(self, self.gun1, HUD_BUMBLEBEE_GUN, "models/vehicles/wakizashi_cockpit.dpm", bumb_gunner_frame, bumb_gunner_exit);
vehicle_addplayerslot(self, self.gun2, HUD_BUMBLEBEE_GUN, "models/vehicles/wakizashi_cockpit.dpm", bumb_gunner_frame, bumb_gunner_exit);
- setorigin(self.vehicle_hudmodel, '45 0 45'); // Move cockpit up-forward.
- setorigin(self.vehicle_viewport, '8 0 5'); // Move camera up-forward too.
+ 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.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.movetype = MOVETYPE_TOSS;
self.solid = SOLID_BBOX;
- self.movetype = MOVETYPE_FLY;
+ //self.movetype = MOVETYPE_BOUNCEMISSILE;
+ self.movetype = MOVETYPE_TOSS;
+ self.vehicle_impact = bumb_impact;
+ self.damageforcescale = 0.025;
+
setorigin(self, self.origin + '0 0 25');
}
WriteByte(MSG_ENTITY, num_for_edict(self.realowner));
WriteByte(MSG_ENTITY, self.realowner.team);
WriteByte(MSG_ENTITY, self.cnt);
-
- //WriteCoord(MSG_ENTITY, autocvar_g_balance_electro_primary_range);
}
if(sf & BRG_START)
{
- WriteCoord(MSG_ENTITY, self.origin_x);
- WriteCoord(MSG_ENTITY, self.origin_y);
- WriteCoord(MSG_ENTITY, self.origin_z);
+ WriteCoord(MSG_ENTITY, self.hook_start_x);
+ WriteCoord(MSG_ENTITY, self.hook_start_y);
+ WriteCoord(MSG_ENTITY, self.hook_start_z);
}
if(sf & BRG_END)
_len = vlen(self.origin - self.move_origin);
_dir = normalize(self.move_origin - self.origin);
+
+ if(self.total_damages < time)
+ {
+ boxparticles(self.traileffect, self, self.origin, self.origin + _dir * -64, _dir * -_len , _dir * -_len, 1, PARTICLES_USEALPHA);
+ boxparticles(self.lip, self, self.move_origin, self.move_origin + _dir * -64, _dir * -200 , _dir * -200, 1, PARTICLES_USEALPHA);
+ self.total_damages = time + 0.1;
+ }
float i, df, sz, al;
-
for(i = -0.1; i < 0.2; i += 0.1)
{
df = DRAWFLAG_NORMAL; //((random() < 0.5) ? DRAWFLAG_ADDITIVE : DRAWFLAG_SCREEN);
- sz = 2 + random() * 6;
+ sz = 5 + random() * 5;
al = 0.25 + random() * 0.5;
_vtmp1 = self.origin + _dir * _len * (0.25 + i);
_vtmp1 += (randomvec() * (_len * 0.2) * (frametime * 2)); //self.raygun_l1;
Draw_CylindricLine(_vtmp1, self.move_origin + randomvec() * 32, sz, "gfx/colors/white.tga", 1, 1, self.colormod, al, df, view_origin);
}
-
}
void bumble_raygun_read(float bIsNew)
self.cnt = ReadByte();
self.team = ReadByte();
self.cnt = ReadByte();
+
if(self.cnt)
self.colormod = '1 0 0';
else
self.colormod = '0 1 0';
+ self.traileffect = particleeffectnum("healray_muzzleflash");
+ self.lip = particleeffectnum("healray_impact");
+
self.draw = bumble_raygun_draw;
}
-
+
+
if(sf & BRG_START)
{
self.origin_x = ReadCoord();
projects / xonotic / xonotic-data.pk3dir.git / blobdiff