public override void Touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf)
{
if (other.client != null)
{
if ((self.spawnflags & 2) != 0)
{
return;
}
}
else if ((other.svflags & Defines.SVF_MONSTER) != 0)
{
if (0 == (self.spawnflags & 1))
{
return;
}
}
else
{
return;
}
if (!Math3D.VectorEquals(self.movedir, Globals.vec3_origin))
{
float[] forward = new float[] { 0, 0, 0 };
Math3D.AngleVectors(other.s.angles, forward, null, null);
if (Math3D.DotProduct(forward, self.movedir) < 0)
{
return;
}
}
self.activator = other;
Multi_trigger(self);
}
public override bool Think(edict_t self)
{
float[] start = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] aim = new float[] { 0, 0, 0 };
int flash_number;
if (self.s.frame == FRAME_attak105)
{
flash_number = Defines.MZ2_GUNNER_GRENADE_1;
}
else if (self.s.frame == FRAME_attak108)
{
flash_number = Defines.MZ2_GUNNER_GRENADE_2;
}
else if (self.s.frame == FRAME_attak111)
{
flash_number = Defines.MZ2_GUNNER_GRENADE_3;
}
else
{
flash_number = Defines.MZ2_GUNNER_GRENADE_4;
}
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[flash_number], forward, right, start);
Math3D.VectorCopy(forward, aim);
Monster.Monster_fire_grenade(self, start, aim, 50, 600, flash_number);
return(true);
}
public static void PM_ClampAngles( )
{
Int16 temp;
Int32 i;
if ((pm.s.pm_flags & pmove_t.PMF_TIME_TELEPORT) != 0)
{
pm.viewangles[Defines.YAW] = Math3D.SHORT2ANGLE(pm.cmd.angles[Defines.YAW] + pm.s.delta_angles[Defines.YAW]);
pm.viewangles[Defines.PITCH] = 0;
pm.viewangles[Defines.ROLL] = 0;
}
else
{
for (i = 0; i < 3; i++)
{
temp = ( Int16 )(pm.cmd.angles[i] + pm.s.delta_angles[i]);
pm.viewangles[i] = Math3D.SHORT2ANGLE(temp);
}
if (pm.viewangles[Defines.PITCH] > 89 && pm.viewangles[Defines.PITCH] < 180)
{
pm.viewangles[Defines.PITCH] = 89;
}
else if (pm.viewangles[Defines.PITCH] < 271 && pm.viewangles[Defines.PITCH] >= 180)
{
pm.viewangles[Defines.PITCH] = 271;
}
}
Math3D.AngleVectors(pm.viewangles, pml.forward, pml.right, pml.up);
}
public override bool Think(edict_t self)
{
float[] start = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] end = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
int effect;
if ((self.s.frame == FRAME_attack9) || (self.s.frame == FRAME_attack12))
{
effect = Defines.EF_BLASTER;
}
else if ((self.s.frame == FRAME_attack19) || (self.s.frame == FRAME_attack22) || (self.s.frame == FRAME_attack25) || (self.s.frame == FRAME_attack28))
{
effect = Defines.EF_HYPERBLASTER;
}
else
{
effect = 0;
}
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_MEDIC_BLASTER_1], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, end);
end[2] += self.enemy.viewheight;
Math3D.VectorSubtract(end, start, dir);
Monster.Monster_fire_blaster(self, start, dir, 2, 1000, Defines.MZ2_MEDIC_BLASTER_1, effect);
return(true);
}
public override bool Think(edict_t self)
{
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] start = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
float[] vec = new float[] { 0, 0, 0 };
int flash_number;
if (self.s.frame == FRAME_attak2_8)
{
flash_number = Defines.MZ2_SUPERTANK_ROCKET_1;
}
else if (self.s.frame == FRAME_attak2_11)
{
flash_number = Defines.MZ2_SUPERTANK_ROCKET_2;
}
else
{
flash_number = Defines.MZ2_SUPERTANK_ROCKET_3;
}
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[flash_number], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, vec);
vec[2] += self.enemy.viewheight;
Math3D.VectorSubtract(vec, start, dir);
Math3D.VectorNormalize(dir);
Monster.Monster_fire_rocket(self, start, dir, 50, 500, flash_number);
return(true);
}
public override bool Think(edict_t self)
{
float[] dir = new float[] { 0, 0, 0 };
float[] vec = new float[] { 0, 0, 0 };
float[] start = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
int flash_number;
flash_number = Defines.MZ2_SUPERTANK_MACHINEGUN_1 + (self.s.frame - FRAME_attak1_1);
dir[0] = 0;
dir[1] = self.s.angles[1];
dir[2] = 0;
Math3D.AngleVectors(dir, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[flash_number], forward, right, start);
if (self.enemy != null)
{
Math3D.VectorCopy(self.enemy.s.origin, vec);
Math3D.VectorMA(vec, 0, self.enemy.velocity, vec);
vec[2] += self.enemy.viewheight;
Math3D.VectorSubtract(vec, start, forward);
Math3D.VectorNormalize(forward);
}
Monster.Monster_fire_bullet(self, start, forward, 6, 4, Defines.DEFAULT_BULLET_HSPREAD, Defines.DEFAULT_BULLET_VSPREAD, flash_number);
return(true);
}
public static void Fire_grenade(edict_t self, float[] start, float[] aimdir, int damage, int speed, float timer, float damage_radius)
{
edict_t grenade;
float[] dir = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 }, up = new float[] { 0, 0, 0 };
Math3D.Vectoangles(aimdir, dir);
Math3D.AngleVectors(dir, forward, right, up);
grenade = GameUtil.G_Spawn();
Math3D.VectorCopy(start, grenade.s.origin);
Math3D.VectorScale(aimdir, speed, grenade.velocity);
Math3D.VectorMA(grenade.velocity, 200F + Lib.Crandom() * 10F, up, grenade.velocity);
Math3D.VectorMA(grenade.velocity, Lib.Crandom() * 10F, right, grenade.velocity);
Math3D.VectorSet(grenade.avelocity, 300, 300, 300);
grenade.movetype = Defines.MOVETYPE_BOUNCE;
grenade.clipmask = Defines.MASK_SHOT;
grenade.solid = Defines.SOLID_BBOX;
grenade.s.effects |= Defines.EF_GRENADE;
Math3D.VectorClear(grenade.mins);
Math3D.VectorClear(grenade.maxs);
grenade.s.modelindex = GameBase.gi.Modelindex("models/objects/grenade/tris.md2");
grenade.owner = self;
grenade.touch = Grenade_Touch;
grenade.nextthink = GameBase.level.time + timer;
grenade.think = Grenade_Explode;
grenade.dmg = damage;
grenade.dmg_radius = damage_radius;
grenade.classname = "grenade";
GameBase.gi.Linkentity(grenade);
}
public override bool Think(edict_t self)
{
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] start = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
float[] vec = new float[] { 0, 0, 0 };
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_1], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, vec);
vec[2] += self.enemy.viewheight;
Math3D.VectorSubtract(vec, start, dir);
Math3D.VectorNormalize(dir);
Monster.Monster_fire_rocket(self, start, dir, 50, 500, Defines.MZ2_BOSS2_ROCKET_1);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_2], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, vec);
vec[2] += self.enemy.viewheight;
Math3D.VectorSubtract(vec, start, dir);
Math3D.VectorNormalize(dir);
Monster.Monster_fire_rocket(self, start, dir, 50, 500, Defines.MZ2_BOSS2_ROCKET_2);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_3], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, vec);
vec[2] += self.enemy.viewheight;
Math3D.VectorSubtract(vec, start, dir);
Math3D.VectorNormalize(dir);
Monster.Monster_fire_rocket(self, start, dir, 50, 500, Defines.MZ2_BOSS2_ROCKET_3);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_4], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, vec);
vec[2] += self.enemy.viewheight;
Math3D.VectorSubtract(vec, start, dir);
Math3D.VectorNormalize(dir);
Monster.Monster_fire_rocket(self, start, dir, 50, 500, Defines.MZ2_BOSS2_ROCKET_4);
return(true);
}
public override bool Think(edict_t self)
{
float[] offset = new float[] { 0, 0, 0 }, start = new float[] { 0, 0, 0 }, f = new float[] { 0, 0, 0 }, r = new float[] { 0, 0, 0 }, end = new float[] { 0, 0, 0 }, dir = new float[] { 0, 0, 0 };
trace_t tr;
int damage;
Math3D.AngleVectors(self.s.angles, f, r, null);
Math3D.VectorSet(offset, 24, 0, 6);
Math3D.G_ProjectSource(self.s.origin, offset, f, r, start);
Math3D.VectorCopy(self.enemy.s.origin, end);
if (!Parasite_drain_attack_ok(start, end))
{
end[2] = self.enemy.s.origin[2] + self.enemy.maxs[2] - 8;
if (!Parasite_drain_attack_ok(start, end))
{
end[2] = self.enemy.s.origin[2] + self.enemy.mins[2] + 8;
if (!Parasite_drain_attack_ok(start, end))
{
return(true);
}
}
}
Math3D.VectorCopy(self.enemy.s.origin, end);
tr = GameBase.gi.Trace(start, null, null, end, self, Defines.MASK_SHOT);
if (tr.ent != self.enemy)
{
return(true);
}
if (self.s.frame == FRAME_drain03)
{
damage = 5;
GameBase.gi.Sound(self.enemy, Defines.CHAN_AUTO, sound_impact, 1, Defines.ATTN_NORM, 0);
}
else
{
if (self.s.frame == FRAME_drain04)
{
GameBase.gi.Sound(self, Defines.CHAN_WEAPON, sound_suck, 1, Defines.ATTN_NORM, 0);
}
damage = 2;
}
GameBase.gi.WriteByte(Defines.svc_temp_entity);
GameBase.gi.WriteByte(Defines.TE_PARASITE_ATTACK);
GameBase.gi.WriteShort(self.index);
GameBase.gi.WritePosition(start);
GameBase.gi.WritePosition(end);
GameBase.gi.Multicast(self.s.origin, Defines.MULTICAST_PVS);
Math3D.VectorSubtract(start, end, dir);
GameCombat.T_Damage(self.enemy, self, self, dir, self.enemy.s.origin, Globals.vec3_origin, damage, 0, Defines.DAMAGE_NO_KNOCKBACK, Defines.MOD_UNKNOWN);
return(true);
}
public override bool Think(edict_t self)
{
float[] start = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_GLADIATOR_RAILGUN_1], forward, right, start);
Math3D.VectorSubtract(self.pos1, start, dir);
Math3D.VectorNormalize(dir);
Monster.Monster_fire_railgun(self, start, dir, 50, 100, Defines.MZ2_GLADIATOR_RAILGUN_1);
return(true);
}
public override bool Think(edict_t self)
{
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 }, target = new float[] { 0, 0, 0 };
float[] start = new float[] { 0, 0, 0 };
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_JORG_MACHINEGUN_L1], forward, right, start);
Math3D.VectorMA(self.enemy.s.origin, -0.2F, self.enemy.velocity, target);
target[2] += self.enemy.viewheight;
Math3D.VectorSubtract(target, start, forward);
Math3D.VectorNormalize(forward);
Monster.Monster_fire_bullet(self, start, forward, 6, 4, Defines.DEFAULT_BULLET_HSPREAD, Defines.DEFAULT_BULLET_VSPREAD, Defines.MZ2_JORG_MACHINEGUN_L1);
return(true);
}
public virtual void R_SetupFrame( )
{
r_framecount++;
Math3D.VectorCopy(r_newrefdef.vieworg, r_origin);
Math3D.AngleVectors(r_newrefdef.viewangles, vpn, vright, vup);
mleaf_t leaf;
if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0)
{
r_oldviewcluster = r_viewcluster;
r_oldviewcluster2 = r_viewcluster2;
leaf = Mod_PointInLeaf(r_origin, r_worldmodel);
r_viewcluster = r_viewcluster2 = leaf.cluster;
if (leaf.contents == 0)
{
Math3D.VectorCopy(r_origin, temp);
temp[2] -= 16;
leaf = Mod_PointInLeaf(temp, r_worldmodel);
if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2))
{
r_viewcluster2 = leaf.cluster;
}
}
else
{
Math3D.VectorCopy(r_origin, temp);
temp[2] += 16;
leaf = Mod_PointInLeaf(temp, r_worldmodel);
if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2))
{
r_viewcluster2 = leaf.cluster;
}
}
}
for (var i = 0; i < 4; i++)
{
v_blend[i] = r_newrefdef.blend[i];
}
c_brush_polys = 0;
c_alias_polys = 0;
if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0)
{
GL.Enable(EnableCap.ScissorTest);
GL.ClearColor(0.3F, 0.3F, 0.3F, 1F);
GL.Scissor(r_newrefdef.x, vid.GetHeight() - r_newrefdef.height - r_newrefdef.y, r_newrefdef.width, r_newrefdef.height);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.ClearColor(1F, 0F, 0.5F, 0.5F);
GL.Disable(EnableCap.ScissorTest);
}
}
public override bool Think(edict_t self)
{
float[] forward = new float[] { 0, 0, 0 };
GameBase.gi.Sound(self, Defines.CHAN_VOICE, sound_sight, 1, Defines.ATTN_NORM, 0);
Math3D.AngleVectors(self.s.angles, forward, null, null);
self.s.origin[2] += 1;
Math3D.VectorScale(forward, 600, self.velocity);
self.velocity[2] = 250;
self.groundentity = null;
self.monsterinfo.aiflags |= Defines.AI_DUCKED;
self.monsterinfo.attack_finished = GameBase.level.time + 3;
self.touch = mutant_jump_touch;
return(true);
}
/*
* =============== CL_TrackerTrail ===============
*/
public static void TrackerTrail(float[] start, float[] end, int particleColor)
{
float len;
cparticle_t p;
int dec;
float dist;
Math3D.VectorCopy(start, CL_newfx.move);
Math3D.VectorSubtract(end, start, CL_newfx.vec);
len = Math3D.VectorNormalize(CL_newfx.vec);
Math3D.VectorCopy(CL_newfx.vec, CL_newfx.forward);
Math3D.vectoangles(CL_newfx.forward, CL_newfx.angle_dir);
Math3D.AngleVectors(CL_newfx.angle_dir, CL_newfx.forward, CL_newfx.right, CL_newfx.up);
dec = 3;
Math3D.VectorScale(CL_newfx.vec, 3, CL_newfx.vec);
// FIXME: this is a really silly way to have a loop
while (len > 0)
{
len -= dec;
if (CL_fx.free_particles == null)
{
return;
}
p = CL_fx.free_particles;
CL_fx.free_particles = p.next;
p.next = CL_fx.active_particles;
CL_fx.active_particles = p;
Math3D.VectorClear(p.accel);
p.time = Globals.cl.time;
p.alpha = 1.0f;
p.alphavel = -2.0f;
p.color = particleColor;
dist = Math3D.DotProduct(CL_newfx.move, CL_newfx.forward);
Math3D.VectorMA(CL_newfx.move, (float)(8 * Math.Cos(dist)), CL_newfx.up, p.org);
for (var j = 0; j < 3; j++)
{
p.vel[j] = 0;
p.accel[j] = 0;
}
p.vel[2] = 5;
Math3D.VectorAdd(CL_newfx.move, CL_newfx.vec, CL_newfx.move);
}
}
public override bool Think(edict_t self)
{
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] start = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
float[] vec = new float[] { 0, 0, 0 };
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[Defines.MZ2_JORG_BFG_1], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, vec);
vec[2] += self.enemy.viewheight;
Math3D.VectorSubtract(vec, start, dir);
Math3D.VectorNormalize(dir);
GameBase.gi.Sound(self, Defines.CHAN_VOICE, sound_attack2, 1, Defines.ATTN_NORM, 0);
Monster.Monster_fire_bfg(self, start, dir, 50, 300, 100, 200, Defines.MZ2_JORG_BFG_1);
return(true);
}
public static void Turret_breach_fire(edict_t self)
{
float[] f = new float[] { 0, 0, 0 }, r = new float[] { 0, 0, 0 }, u = new float[] { 0, 0, 0 };
float[] start = new float[] { 0, 0, 0 };
int damage;
int speed;
Math3D.AngleVectors(self.s.angles, f, r, u);
Math3D.VectorMA(self.s.origin, self.move_origin[0], f, start);
Math3D.VectorMA(start, self.move_origin[1], r, start);
Math3D.VectorMA(start, self.move_origin[2], u, start);
damage = (int)(100 + Lib.Random() * 50);
speed = (int)(550 + 50 * GameBase.skill.value);
GameWeapon.Fire_rocket(self.teammaster.owner, start, f, damage, speed, 150, damage);
GameBase.gi.Positioned_sound(start, self, Defines.CHAN_WEAPON, GameBase.gi.Soundindex("weapons/rocklf1a.wav"), 1, Defines.ATTN_NORM, 0);
}
public static bool Infront(edict_t self, edict_t other)
{
float[] vec = new float[] { 0, 0, 0 };
float dot;
float[] forward = new float[] { 0, 0, 0 };
Math3D.AngleVectors(self.s.angles, forward, null, null);
Math3D.VectorSubtract(other.s.origin, self.s.origin, vec);
Math3D.VectorNormalize(vec);
dot = Math3D.DotProduct(vec, forward);
if (dot > 0.3)
{
return(true);
}
return(false);
}
public static void Fire_grenade2(edict_t self, float[] start, float[] aimdir, int damage, int speed, float timer, float damage_radius, bool held)
{
edict_t grenade;
float[] dir = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 }, up = new float[] { 0, 0, 0 };
Math3D.Vectoangles(aimdir, dir);
Math3D.AngleVectors(dir, forward, right, up);
grenade = GameUtil.G_Spawn();
Math3D.VectorCopy(start, grenade.s.origin);
Math3D.VectorScale(aimdir, speed, grenade.velocity);
Math3D.VectorMA(grenade.velocity, 200F + Lib.Crandom() * 10F, up, grenade.velocity);
Math3D.VectorMA(grenade.velocity, Lib.Crandom() * 10F, right, grenade.velocity);
Math3D.VectorSet(grenade.avelocity, 300F, 300F, 300F);
grenade.movetype = Defines.MOVETYPE_BOUNCE;
grenade.clipmask = Defines.MASK_SHOT;
grenade.solid = Defines.SOLID_BBOX;
grenade.s.effects |= Defines.EF_GRENADE;
Math3D.VectorClear(grenade.mins);
Math3D.VectorClear(grenade.maxs);
grenade.s.modelindex = GameBase.gi.Modelindex("models/objects/grenade2/tris.md2");
grenade.owner = self;
grenade.touch = Grenade_Touch;
grenade.nextthink = GameBase.level.time + timer;
grenade.think = Grenade_Explode;
grenade.dmg = damage;
grenade.dmg_radius = damage_radius;
grenade.classname = "hgrenade";
if (held)
{
grenade.spawnflags = 3;
}
else
{
grenade.spawnflags = 1;
}
grenade.s.sound = GameBase.gi.Soundindex("weapons/hgrenc1b.wav");
if (timer <= 0)
{
Grenade_Explode.Think(grenade);
}
else
{
GameBase.gi.Sound(self, Defines.CHAN_WEAPON, GameBase.gi.Soundindex("weapons/hgrent1a.wav"), 1, Defines.ATTN_NORM, 0);
GameBase.gi.Linkentity(grenade);
}
}
public static void G_SetMovedir(float[] angles, float[] movedir)
{
if (Math3D.VectorEquals(angles, VEC_UP))
{
Math3D.VectorCopy(MOVEDIR_UP, movedir);
}
else if (Math3D.VectorEquals(angles, VEC_DOWN))
{
Math3D.VectorCopy(MOVEDIR_DOWN, movedir);
}
else
{
Math3D.AngleVectors(angles, movedir, null, null);
}
Math3D.VectorClear(angles);
}
public static void TrackerTrail(float[] start, float[] end, int particleColor)
{
float len;
cparticle_t p;
int dec;
float dist;
Math3D.VectorCopy(start, move);
Math3D.VectorSubtract(end, start, vec);
len = Math3D.VectorNormalize(vec);
Math3D.VectorCopy(vec, forward);
Math3D.Vectoangles(forward, angle_dir);
Math3D.AngleVectors(angle_dir, forward, right, up);
dec = 3;
Math3D.VectorScale(vec, 3, vec);
while (len > 0)
{
len -= dec;
if (CL_fx.free_particles == null)
{
return;
}
p = CL_fx.free_particles;
CL_fx.free_particles = p.next;
p.next = CL_fx.active_particles;
CL_fx.active_particles = p;
Math3D.VectorClear(p.accel);
p.time = Globals.cl.time;
p.alpha = 1F;
p.alphavel = -2F;
p.color = particleColor;
dist = Math3D.DotProduct(move, forward);
Math3D.VectorMA(move, (float)(8 * Math.Cos(dist)), up, p.org);
for (int j = 0; j < 3; j++)
{
p.vel[j] = 0;
p.accel[j] = 0;
}
p.vel[2] = 5;
Math3D.VectorAdd(move, vec, move);
}
}
public override bool Think(edict_t self)
{
float[] start = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] target = new float[] { 0, 0, 0 };
float[] aim = new float[] { 0, 0, 0 };
int flash_number;
flash_number = Defines.MZ2_GUNNER_MACHINEGUN_1 + (self.s.frame - FRAME_attak216);
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[flash_number], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, target);
Math3D.VectorMA(target, -0.2F, self.enemy.velocity, target);
target[2] += self.enemy.viewheight;
Math3D.VectorSubtract(target, start, aim);
Math3D.VectorNormalize(aim);
Monster.Monster_fire_bullet(self, start, aim, 3, 4, Defines.DEFAULT_BULLET_HSPREAD, Defines.DEFAULT_BULLET_VSPREAD, flash_number);
return(true);
}
public override bool Think(edict_t self)
{
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] origin = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
float[] offset = new float[] { 0, 0, 0 };
Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, dir);
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.VectorSet(offset, 18.5F, -0.9F, 10F);
Math3D.G_ProjectSource(self.s.origin, offset, forward, right, origin);
GameBase.gi.Sound(self, Defines.CHAN_WEAPON, sound_attack2, 1, Defines.ATTN_NORM, 0);
GameBase.gi.WriteByte(Defines.svc_temp_entity);
GameBase.gi.WriteByte(Defines.TE_SPLASH);
GameBase.gi.WriteByte(32);
GameBase.gi.WritePosition(origin);
GameBase.gi.WriteDir(dir);
GameBase.gi.WriteByte(1);
GameBase.gi.Multicast(origin, Defines.MULTICAST_PVS);
GameCombat.T_Damage(self.enemy, self, self, dir, self.enemy.s.origin, Globals.vec3_origin, 5 + Lib.Rand() % 6, -10, Defines.DAMAGE_ENERGY, Defines.MOD_UNKNOWN);
return(true);
}
static void Flyer_fire(edict_t self, int flash_number)
{
float[] start = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] end = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
int effect;
if ((self.s.frame == FRAME_attak204) || (self.s.frame == FRAME_attak207) || (self.s.frame == FRAME_attak210))
{
effect = Defines.EF_HYPERBLASTER;
}
else
{
effect = 0;
}
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[flash_number], forward, right, start);
Math3D.VectorCopy(self.enemy.s.origin, end);
end[2] += self.enemy.viewheight;
Math3D.VectorSubtract(end, start, dir);
Monster.Monster_fire_blaster(self, start, dir, 1, 1000, flash_number, effect);
}
public override bool Think(edict_t self)
{
float[] start = new float[] { 0, 0, 0 }, target = new float[] { 0, 0, 0 };
float[] forward = new float[] { 0, 0, 0 }, right = new float[] { 0, 0, 0 };
float[] vec = new float[] { 0, 0, 0 };
int flash_number;
if (self.s.frame == FRAME_attak111)
{
flash_number = Defines.MZ2_INFANTRY_MACHINEGUN_1;
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[flash_number], forward, right, start);
if (self.enemy != null)
{
Math3D.VectorMA(self.enemy.s.origin, -0.2F, self.enemy.velocity, target);
target[2] += self.enemy.viewheight;
Math3D.VectorSubtract(target, start, forward);
Math3D.VectorNormalize(forward);
}
else
{
Math3D.AngleVectors(self.s.angles, forward, right, null);
}
}
else
{
flash_number = Defines.MZ2_INFANTRY_MACHINEGUN_2 + (self.s.frame - FRAME_death211);
Math3D.AngleVectors(self.s.angles, forward, right, null);
Math3D.G_ProjectSource(self.s.origin, M_Flash.monster_flash_offset[flash_number], forward, right, start);
Math3D.VectorSubtract(self.s.angles, aimangles[flash_number - Defines.MZ2_INFANTRY_MACHINEGUN_2], vec);
Math3D.AngleVectors(vec, forward, null, null);
}
Monster.Monster_fire_bullet(self, start, forward, 3, 4, Defines.DEFAULT_BULLET_HSPREAD, Defines.DEFAULT_BULLET_VSPREAD, flash_number);
return(true);
}
public virtual void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, Single backlerp)
{
Single l;
qfiles.daliasframe_t frame, oldframe;
Int32[] v, ov;
Int32[] order;
var orderIndex = 0;
Int32 count;
Single frontlerp;
Single alpha;
Single[] move = new Single[] { 0, 0, 0 };
Single[][] vectors = new Single[][] { new Single[] { 0, 0, 0 }, new Single[] { 0, 0, 0 }, new Single[] { 0, 0, 0 } };
Single[] frontv = new Single[] { 0, 0, 0 };
Single[] backv = new Single[] { 0, 0, 0 };
Int32 i;
Int32 index_xyz;
frame = paliashdr.aliasFrames[currententity.frame];
v = frame.verts;
oldframe = paliashdr.aliasFrames[currententity.oldframe];
ov = oldframe.verts;
order = paliashdr.glCmds;
if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0)
{
alpha = currententity.alpha;
}
else
{
alpha = 1F;
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
GL.Disable(EnableCap.Texture2D);
}
frontlerp = 1F - backlerp;
Math3D.VectorSubtract(currententity.oldorigin, currententity.origin, frontv);
Math3D.AngleVectors(currententity.angles, vectors[0], vectors[1], vectors[2]);
move[0] = Math3D.DotProduct(frontv, vectors[0]);
move[1] = -Math3D.DotProduct(frontv, vectors[1]);
move[2] = Math3D.DotProduct(frontv, vectors[2]);
Math3D.VectorAdd(move, oldframe.translate, move);
for (i = 0; i < 3; i++)
{
move[i] = backlerp * move[i] + frontlerp * frame.translate[i];
frontv[i] = frontlerp * frame.scale[i];
backv[i] = backlerp * oldframe.scale[i];
}
if (gl_vertex_arrays.value != 0F)
{
GL_LerpVerts(paliashdr.num_xyz, ov, v, move, frontv, backv);
GL.EnableClientState(ArrayCap.VertexArray);
new Pinnable(vertexArrayBuf.Array, (ptr) =>
{
GL.VertexPointer(3, VertexPointerType.Float, 0, ptr);
});
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
GL.DisableClientState(ArrayCap.ColorArray);
GL.Color4(shadelight[0], shadelight[1], shadelight[2], alpha);
}
else
{
GL.EnableClientState(ArrayCap.ColorArray);
new Pinnable(colorArrayBuf.Array, (ptr) =>
{
GL.ColorPointer(4, ColorPointerType.Float, 0, ptr);
});
SingleBuffer color = colorArrayBuf;
var j = 0;
for (i = 0; i < paliashdr.num_xyz; i++)
{
l = shadedots[(v[i] >> 24) & 0xFF];
color.Put(j++, l * shadelight[0]);
color.Put(j++, l * shadelight[1]);
color.Put(j++, l * shadelight[2]);
color.Put(j++, alpha);
}
}
//if (qglLockArraysEXT)
// gl.GlLockArraysEXT(0, paliashdr.num_xyz);
while (true)
{
count = order[orderIndex++];
if (count == 0)
{
break;
}
if (count < 0)
{
count = -count;
GL.Begin(PrimitiveType.TriangleFan);
}
else
{
GL.Begin(PrimitiveType.TriangleStrip);
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
do
{
index_xyz = order[orderIndex + 2];
orderIndex += 3;
GL.ArrayElement(index_xyz);
}while (--count != 0);
}
else
{
do
{
GL.TexCoord2(BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 0])), BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 1])));
index_xyz = order[orderIndex + 2];
orderIndex += 3;
GL.ArrayElement(index_xyz);
}while (--count != 0);
}
GL.End();
}
// if (qglLockArraysEXT)
// gl.GlUnlockArraysEXT();
}
else
{
GL_LerpVerts(paliashdr.num_xyz, ov, v, s_lerped, move, frontv, backv);
Single[] tmp;
while (true)
{
count = order[orderIndex++];
if (count == 0)
{
break;
}
if (count < 0)
{
count = -count;
GL.Begin(PrimitiveType.TriangleFan);
}
else
{
GL.Begin(PrimitiveType.TriangleStrip);
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE)) != 0)
{
do
{
index_xyz = order[orderIndex + 2];
orderIndex += 3;
GL.Color4(shadelight[0], shadelight[1], shadelight[2], alpha);
tmp = s_lerped[index_xyz];
GL.Vertex3(tmp[0], tmp[1], tmp[2]);
}while (--count != 0);
}
else
{
do
{
GL.TexCoord2(BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 0])), BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 1])));
index_xyz = order[orderIndex + 2];
orderIndex += 3;
l = shadedots[(v[index_xyz] >> 24) & 0xFF];
GL.Color4(l * shadelight[0], l * shadelight[1], l * shadelight[2], alpha);
tmp = s_lerped[index_xyz];
GL.Vertex3(tmp[0], tmp[1], tmp[2]);
}while (--count != 0);
}
GL.End();
}
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
GL.Enable(EnableCap.Texture2D);
}
}
public virtual System.Boolean R_CullAliasModel(Single[][] bbox, entity_t e)
{
Int32 i;
Single[] mins = new Single[] { 0, 0, 0 };
Single[] maxs = new Single[] { 0, 0, 0 };
qfiles.dmdl_t paliashdr;
Single[][] vectors = new Single[][] { new Single[] { 0, 0, 0 }, new Single[] { 0, 0, 0 }, new Single[] { 0, 0, 0 } };
Single[] thismins = new Single[] { 0, 0, 0 };
Single[] oldmins = new Single[] { 0, 0, 0 };
Single[] thismaxs = new Single[] { 0, 0, 0 };
Single[] oldmaxs = new Single[] { 0, 0, 0 };
qfiles.daliasframe_t pframe, poldframe;
Single[] angles = new Single[] { 0, 0, 0 };
paliashdr = (qfiles.dmdl_t)currentmodel.extradata;
if ((e.frame >= paliashdr.num_frames) || (e.frame < 0))
{
VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such frame " + e.frame + '\\');
e.frame = 0;
}
if ((e.oldframe >= paliashdr.num_frames) || (e.oldframe < 0))
{
VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such oldframe " + e.oldframe + '\\');
e.oldframe = 0;
}
pframe = paliashdr.aliasFrames[e.frame];
poldframe = paliashdr.aliasFrames[e.oldframe];
if (pframe == poldframe)
{
for (i = 0; i < 3; i++)
{
mins[i] = pframe.translate[i];
maxs[i] = mins[i] + pframe.scale[i] * 255;
}
}
else
{
for (i = 0; i < 3; i++)
{
thismins[i] = pframe.translate[i];
thismaxs[i] = thismins[i] + pframe.scale[i] * 255;
oldmins[i] = poldframe.translate[i];
oldmaxs[i] = oldmins[i] + poldframe.scale[i] * 255;
if (thismins[i] < oldmins[i])
{
mins[i] = thismins[i];
}
else
{
mins[i] = oldmins[i];
}
if (thismaxs[i] > oldmaxs[i])
{
maxs[i] = thismaxs[i];
}
else
{
maxs[i] = oldmaxs[i];
}
}
}
for (i = 0; i < 8; i++)
{
Single[] tmp = new Single[] { 0, 0, 0 };
if ((i & 1) != 0)
{
tmp[0] = mins[0];
}
else
{
tmp[0] = maxs[0];
}
if ((i & 2) != 0)
{
tmp[1] = mins[1];
}
else
{
tmp[1] = maxs[1];
}
if ((i & 4) != 0)
{
tmp[2] = mins[2];
}
else
{
tmp[2] = maxs[2];
}
Math3D.VectorCopy(tmp, bbox[i]);
}
Math3D.VectorCopy(e.angles, angles);
angles[YAW] = -angles[YAW];
Math3D.AngleVectors(angles, vectors[0], vectors[1], vectors[2]);
for (i = 0; i < 8; i++)
{
Single[] tmp = new Single[] { 0, 0, 0 };
Math3D.VectorCopy(bbox[i], tmp);
bbox[i][0] = Math3D.DotProduct(vectors[0], tmp);
bbox[i][1] = -Math3D.DotProduct(vectors[1], tmp);
bbox[i][2] = Math3D.DotProduct(vectors[2], tmp);
Math3D.VectorAdd(e.origin, bbox[i], bbox[i]);
}
{
Int32 p, f;
var aggregatemask = ~0;
for (p = 0; p < 8; p++)
{
var mask = 0;
for (f = 0; f < 4; f++)
{
var dp = Math3D.DotProduct(frustum[f].normal, bbox[p]);
if ((dp - frustum[f].dist) < 0)
{
mask |= (1 << f);
}
}
aggregatemask &= mask;
}
if (aggregatemask != 0)
{
return(true);
}
return(false);
}
}
public override bool Think(edict_t self)
{
float[] offset = new float[] { 0, 0, 0 }, start = new float[] { 0, 0, 0 }, end = new float[] { 0, 0, 0 }, f = new float[] { 0, 0, 0 }, r = new float[] { 0, 0, 0 };
trace_t tr;
float[] dir = new float[] { 0, 0, 0 }, angles = new float[] { 0, 0, 0 };
float distance;
if (!self.enemy.inuse)
{
return(true);
}
Math3D.AngleVectors(self.s.angles, f, r, null);
Math3D.VectorCopy(medic_cable_offsets[self.s.frame - FRAME_attack42], offset);
Math3D.G_ProjectSource(self.s.origin, offset, f, r, start);
Math3D.VectorSubtract(start, self.enemy.s.origin, dir);
distance = Math3D.VectorLength(dir);
if (distance > 256)
{
return(true);
}
Math3D.Vectoangles(dir, angles);
if (angles[0] < -180)
{
angles[0] += 360;
}
if (Math.Abs(angles[0]) > 45)
{
return(true);
}
tr = GameBase.gi.Trace(start, null, null, self.enemy.s.origin, self, Defines.MASK_SHOT);
if (tr.fraction != 1 && tr.ent != self.enemy)
{
return(true);
}
if (self.s.frame == FRAME_attack43)
{
GameBase.gi.Sound(self.enemy, Defines.CHAN_AUTO, sound_hook_hit, 1, Defines.ATTN_NORM, 0);
self.enemy.monsterinfo.aiflags |= Defines.AI_RESURRECTING;
}
else if (self.s.frame == FRAME_attack50)
{
self.enemy.spawnflags = 0;
self.enemy.monsterinfo.aiflags = 0;
self.enemy.target = null;
self.enemy.targetname = null;
self.enemy.combattarget = null;
self.enemy.deathtarget = null;
self.enemy.owner = self;
GameSpawn.ED_CallSpawn(self.enemy);
self.enemy.owner = null;
if (self.enemy.think != null)
{
self.enemy.nextthink = GameBase.level.time;
self.enemy.think.Think(self.enemy);
}
self.enemy.monsterinfo.aiflags |= Defines.AI_RESURRECTING;
if (self.oldenemy != null && self.oldenemy.client != null)
{
self.enemy.enemy = self.oldenemy;
GameUtil.FoundTarget(self.enemy);
}
}
else
{
if (self.s.frame == FRAME_attack44)
{
GameBase.gi.Sound(self, Defines.CHAN_WEAPON, sound_hook_heal, 1, Defines.ATTN_NORM, 0);
}
}
Math3D.VectorMA(start, 8, f, start);
Math3D.VectorCopy(self.enemy.s.origin, end);
end[2] = self.enemy.absmin[2] + self.enemy.size[2] / 2;
GameBase.gi.WriteByte(Defines.svc_temp_entity);
GameBase.gi.WriteByte(Defines.TE_MEDIC_CABLE_ATTACK);
GameBase.gi.WriteShort(self.index);
GameBase.gi.WritePosition(start);
GameBase.gi.WritePosition(end);
GameBase.gi.Multicast(self.s.origin, Defines.MULTICAST_PVS);
return(true);
}
public static void Pmove(pmove_t pmove)
{
pm = pmove;
pm.numtouch = 0;
Math3D.VectorClear(pm.viewangles);
pm.viewheight = 0;
pm.groundentity = null;
pm.watertype = 0;
pm.waterlevel = 0;
pml.groundsurface = null;
pml.groundcontents = 0;
pml.origin[0] = pm.s.origin[0] * 0.125F;
pml.origin[1] = pm.s.origin[1] * 0.125F;
pml.origin[2] = pm.s.origin[2] * 0.125F;
pml.velocity[0] = pm.s.velocity[0] * 0.125F;
pml.velocity[1] = pm.s.velocity[1] * 0.125F;
pml.velocity[2] = pm.s.velocity[2] * 0.125F;
Math3D.VectorCopy(pm.s.origin, pml.previous_origin);
pml.frametime = (pm.cmd.msec & 0xFF) * 0.001F;
PM_ClampAngles();
if (pm.s.pm_type == Defines.PM_SPECTATOR)
{
PM_FlyMove(false);
PM_SnapPosition();
return;
}
if (pm.s.pm_type >= Defines.PM_DEAD)
{
pm.cmd.forwardmove = 0;
pm.cmd.sidemove = 0;
pm.cmd.upmove = 0;
}
if (pm.s.pm_type == Defines.PM_FREEZE)
{
return;
}
PM_CheckDuck();
if (pm.snapinitial)
{
PM_InitialSnapPosition();
}
PM_CatagorizePosition();
if (pm.s.pm_type == Defines.PM_DEAD)
{
PM_DeadMove();
}
PM_CheckSpecialMovement();
if (pm.s.pm_time != 0)
{
Int32 msec;
msec = pm.cmd.msec >> 3;
if (msec == 0)
{
msec = 1;
}
if (msec >= (pm.s.pm_time & 0xFF))
{
pm.s.pm_flags &= (Byte) ~(pmove_t.PMF_TIME_WATERJUMP | pmove_t.PMF_TIME_LAND | pmove_t.PMF_TIME_TELEPORT);
pm.s.pm_time = 0;
}
else
{
pm.s.pm_time = ( Byte )((pm.s.pm_time & 0xFF) - msec);
}
}
if ((pm.s.pm_flags & pmove_t.PMF_TIME_TELEPORT) != 0)
{
}
else if ((pm.s.pm_flags & pmove_t.PMF_TIME_WATERJUMP) != 0)
{
pml.velocity[2] -= pm.s.gravity * pml.frametime;
if (pml.velocity[2] < 0)
{
pm.s.pm_flags &= (Byte) ~(pmove_t.PMF_TIME_WATERJUMP | pmove_t.PMF_TIME_LAND | pmove_t.PMF_TIME_TELEPORT);
pm.s.pm_time = 0;
}
PM_StepSlideMove();
}
else
{
PM_CheckJump();
PM_Friction();
if (pm.waterlevel >= 2)
{
PM_WaterMove();
}
else
{
Single[] angles = new Single[] { 0, 0, 0 };
Math3D.VectorCopy(pm.viewangles, angles);
if (angles[Defines.PITCH] > 180)
{
angles[Defines.PITCH] = angles[Defines.PITCH] - 360;
}
angles[Defines.PITCH] /= 3;
Math3D.AngleVectors(angles, pml.forward, pml.right, pml.up);
PM_AirMove();
}
}
PM_CatagorizePosition();
PM_SnapPosition();
}
private void RunTest()
{
if (refdef == null)
{
refdef = new refdef_t();
refdef.x = 0;
refdef.y = 0;
refdef.width = viddef.GetWidth();
refdef.height = viddef.GetHeight();
refdef.fov_x = (Globals.fov == null) ? this.fov_x : Globals.fov.value;
refdef.fov_x = this.fov_x;
refdef.fov_y = Math3D.CalcFov(refdef.fov_x, refdef.width, refdef.height);
refdef.vieworg = new float[] { 140, -140, 50 };
refdef.viewangles = new float[] { 0, 0, 0 };
refdef.blend = new float[] { 0F, 0F, 0F, 0F };
refdef.areabits = null;
ent = new entity_t();
model_t weapon = re.RegisterModel("models/monsters/soldier/tris.md2");
image_t weaponSkin = re.RegisterSkin("models/monsters/soldier/skin.pcx");
ent.model = weapon;
ent.skin = weaponSkin;
ent.origin = new float[] { -60, 80, 25 };
Math3D.VectorCopy(ent.origin, ent.oldorigin);
ent.angles = new float[] { 0, 300, 0 };
refdef.entities = new entity_t[] { ent };
refdef.num_entities = refdef.entities.Length;
lightstyle_t light = new lightstyle_t();
light.rgb = new float[] { 1F, 1F, 1F };
light.white = 3F;
refdef.lightstyles = new lightstyle_t[Defines.MAX_LIGHTSTYLES];
for (int i = 0; i < Defines.MAX_LIGHTSTYLES; i++)
{
refdef.lightstyles[i] = new lightstyle_t();
refdef.lightstyles[i].rgb = new float[] { 1F, 1F, 1F };
refdef.lightstyles[i].white = 3F;
}
refdef.viewangles[1] = 130;
refdef.time = Time() * 0.001F;
}
refdef.viewangles[0] += KBD.my * 0.1F;
refdef.viewangles[1] -= KBD.mx * 0.1F;
float dt = Time() * 0.001F - refdef.time;
if (movePlayer != 0)
{
float velocity = 150F * dt;
Math3D.AngleVectors(refdef.viewangles, vpn, vright, vup);
if ((movePlayer & FORWARD_MASK) != 0)
{
Math3D.VectorMA(refdef.vieworg, -velocity, vpn, refdef.vieworg);
}
if ((movePlayer & BACKWARD_MASK) != 0)
{
Math3D.VectorMA(refdef.vieworg, velocity, vpn, refdef.vieworg);
}
if ((movePlayer & LEFT_MASK) != 0)
{
Math3D.VectorMA(refdef.vieworg, velocity, vright, refdef.vieworg);
}
if ((movePlayer & RIGHT_MASK) != 0)
{
Math3D.VectorMA(refdef.vieworg, -velocity, vright, refdef.vieworg);
}
refdef.vieworg[0] += 1F / 16;
refdef.vieworg[1] += 1F / 16;
refdef.vieworg[2] += 1F / 16;
}
refdef.time = Time() * 0.001F;
r_numparticles = 0;
float[] diff = new float[] { 0, 0, 0 };
Math3D.VectorSubtract(refdef.vieworg, ent.origin, diff);
if (Math3D.VectorLength(diff) < 250 && active_particles.Size() == 0)
{
RailTrail(ent.origin, refdef.vieworg);
}
else
{
if (active_particles.Size() > 0)
{
ent.frame = (int)((Time() * 0.013F) % 15);
Math3D.VectorNormalize(diff);
Math3D.Vectoangles(diff, ent.angles);
AnimateParticles();
refdef.num_particles = r_numparticles;
}
else
{
ent.frame = 0;
refdef.num_particles = 0;
}
}
refdef.num_dlights = 0;
re.RenderFrame(refdef);
}
/**
* Called for each player at the end of the server frame and right after
* spawning.
*/
public static void ClientEndServerFrame(edict_t ent)
{
float bobtime;
int i;
PlayerView.current_player = ent;
PlayerView.current_client = ent.client;
//
// If the origin or velocity have changed since ClientThink(),
// update the pmove values. This will happen when the client
// is pushed by a bmodel or kicked by an explosion.
//
// If it wasn't updated here, the view position would lag a frame
// behind the body position when pushed -- "sinking into plats"
//
for (i = 0; i < 3; i++)
{
PlayerView.current_client.ps.pmove.origin[i] = (short)(ent.s.origin[i] * 8.0);
PlayerView.current_client.ps.pmove.velocity[i] = (short)(ent.velocity[i] * 8.0);
}
//
// If the end of unit layout is displayed, don't give
// the player any normal movement attributes
//
if (GameBase.level.intermissiontime != 0)
{
// FIXME: add view drifting here?
PlayerView.current_client.ps.blend[3] = 0;
PlayerView.current_client.ps.fov = 90;
PlayerHud.G_SetStats(ent);
return;
}
Math3D.AngleVectors(ent.client.v_angle, PlayerView.forward, PlayerView.right, PlayerView.up);
// burn from lava, etc
PlayerView.P_WorldEffects();
//
// set model angles from view angles so other things in
// the world can tell which direction you are looking
//
if (ent.client.v_angle[Defines.PITCH] > 180)
{
ent.s.angles[Defines.PITCH] = (-360 + ent.client.v_angle[Defines.PITCH]) / 3;
}
else
{
ent.s.angles[Defines.PITCH] = ent.client.v_angle[Defines.PITCH] / 3;
}
ent.s.angles[Defines.YAW] = ent.client.v_angle[Defines.YAW];
ent.s.angles[Defines.ROLL] = 0;
ent.s.angles[Defines.ROLL] = PlayerView.SV_CalcRoll(ent.s.angles, ent.velocity) * 4;
//
// calculate speed and cycle to be used for
// all cyclic walking effects
//
PlayerView.xyspeed = (float)Math.Sqrt(ent.velocity[0] * ent.velocity[0] + ent.velocity[1] * ent.velocity[1]);
if (PlayerView.xyspeed < 5)
{
PlayerView.bobmove = 0;
PlayerView.current_client.bobtime = 0; // start at beginning of cycle again
}
else if (ent.groundentity != null)
{
// so bobbing only cycles when on
// ground
if (PlayerView.xyspeed > 210)
{
PlayerView.bobmove = 0.25f;
}
else if (PlayerView.xyspeed > 100)
{
PlayerView.bobmove = 0.125f;
}
else
{
PlayerView.bobmove = 0.0625f;
}
}
bobtime = PlayerView.current_client.bobtime += PlayerView.bobmove;
if ((PlayerView.current_client.ps.pmove.pm_flags & pmove_t.PMF_DUCKED) != 0)
{
bobtime *= 4;
}
PlayerView.bobcycle = (int)bobtime;
PlayerView.bobfracsin = (float)Math.Abs(Math.Sin(bobtime * Math.PI));
// detect hitting the floor
PlayerView.P_FallingDamage(ent);
// apply all the damage taken this frame
PlayerView.P_DamageFeedback(ent);
// determine the view offsets
PlayerView.SV_CalcViewOffset(ent);
// determine the gun offsets
PlayerView.SV_CalcGunOffset(ent);
// determine the full screen color blend
// must be after viewoffset, so eye contents can be
// accurately determined
// FIXME: with client prediction, the contents
// should be determined by the client
PlayerView.SV_CalcBlend(ent);
// chase cam stuff
if (ent.client.resp.spectator)
{
PlayerHud.G_SetSpectatorStats(ent);
}
else
{
PlayerHud.G_SetStats(ent);
}
PlayerHud.G_CheckChaseStats(ent);
PlayerView.G_SetClientEvent(ent);
PlayerView.G_SetClientEffects(ent);
PlayerView.G_SetClientSound(ent);
PlayerView.G_SetClientFrame(ent);
Math3D.VectorCopy(ent.velocity, ent.client.oldvelocity);
Math3D.VectorCopy(ent.client.ps.viewangles, ent.client.oldviewangles);
// clear weapon kicks
Math3D.VectorClear(ent.client.kick_origin);
Math3D.VectorClear(ent.client.kick_angles);
// if the scoreboard is up, update it
if (ent.client.showscores && 0 == (GameBase.level.framenum & 31))
{
PlayerHud.DeathmatchScoreboardMessage(ent, ent.enemy);
GameBase.gi.unicast(ent, false);
}
}
