public static void Give_f(edict_t ent)
{
String name;
gitem_t it;
Int32 index;
Int32 i;
Boolean give_all;
edict_t it_ent;
if (GameBase.deathmatch.value != 0 && GameBase.sv_cheats.value == 0)
{
SV_GAME.PF_cprintfhigh(ent, "You must run the server with '+set cheats 1' to enable this command.\\n");
return;
}
name = Cmd.Args();
if (0 == Lib.Q_stricmp(name, "all"))
{
give_all = true;
}
else
{
give_all = false;
}
if (give_all || 0 == Lib.Q_stricmp(Cmd.Argv(1), "health"))
{
if (Cmd.Argc() == 3)
{
ent.health = Lib.Atoi(Cmd.Argv(2));
}
else
{
ent.health = ent.max_health;
}
if (!give_all)
{
return;
}
}
if (give_all || 0 == Lib.Q_stricmp(name, "weapons"))
{
for (i = 1; i < GameBase.game.num_items; i++)
{
it = GameItemList.itemlist[i];
if (null == it.pickup)
{
continue;
}
if (0 == (it.flags & Defines.IT_WEAPON))
{
continue;
}
ent.client.pers.inventory[i] += 1;
}
if (!give_all)
{
return;
}
}
if (give_all || 0 == Lib.Q_stricmp(name, "ammo"))
{
for (i = 1; i < GameBase.game.num_items; i++)
{
it = GameItemList.itemlist[i];
if (null == it.pickup)
{
continue;
}
if (0 == (it.flags & Defines.IT_AMMO))
{
continue;
}
GameItems.Add_Ammo(ent, it, 1000);
}
if (!give_all)
{
return;
}
}
if (give_all || Lib.Q_stricmp(name, "armor") == 0)
{
gitem_armor_t info;
it = GameItems.FindItem("Jacket Armor");
ent.client.pers.inventory[GameItems.ITEM_INDEX(it)] = 0;
it = GameItems.FindItem("Combat Armor");
ent.client.pers.inventory[GameItems.ITEM_INDEX(it)] = 0;
it = GameItems.FindItem("Body Armor");
info = ( gitem_armor_t )it.info;
ent.client.pers.inventory[GameItems.ITEM_INDEX(it)] = info.max_count;
if (!give_all)
{
return;
}
}
if (give_all || Lib.Q_stricmp(name, "Power Shield") == 0)
{
it = GameItems.FindItem("Power Shield");
it_ent = GameUtil.G_Spawn();
it_ent.classname = it.classname;
GameItems.SpawnItem(it_ent, it);
GameItems.Touch_Item(it_ent, ent, GameBase.dummyplane, null);
if (it_ent.inuse)
{
GameUtil.G_FreeEdict(it_ent);
}
if (!give_all)
{
return;
}
}
if (give_all)
{
for (i = 1; i < GameBase.game.num_items; i++)
{
it = GameItemList.itemlist[i];
if (it.pickup != null)
{
continue;
}
if ((it.flags & (Defines.IT_ARMOR | Defines.IT_WEAPON | Defines.IT_AMMO)) != 0)
{
continue;
}
ent.client.pers.inventory[i] = 1;
}
return;
}
it = GameItems.FindItem(name);
if (it == null)
{
name = Cmd.Argv(1);
it = GameItems.FindItem(name);
if (it == null)
{
SV_GAME.PF_cprintf(ent, Defines.PRINT_HIGH, "unknown item\\n");
return;
}
}
if (it.pickup == null)
{
SV_GAME.PF_cprintf(ent, Defines.PRINT_HIGH, "non-pickup item\\n");
return;
}
index = GameItems.ITEM_INDEX(it);
if ((it.flags & Defines.IT_AMMO) != 0)
{
if (Cmd.Argc() == 3)
{
ent.client.pers.inventory[index] = Lib.Atoi(Cmd.Argv(2));
}
else
{
ent.client.pers.inventory[index] += it.quantity;
}
}
else
{
it_ent = GameUtil.G_Spawn();
it_ent.classname = it.classname;
GameItems.SpawnItem(it_ent, it);
GameItems.Touch_Item(it_ent, ent, GameBase.dummyplane, null);
if (it_ent.inuse)
{
GameUtil.G_FreeEdict(it_ent);
}
}
}
public override void Use(edict_t self, edict_t other, edict_t activator)
{
int index;
if (self.item == null)
{
return;
}
if (activator.client == null)
{
return;
}
index = GameItems.ITEM_INDEX(self.item);
if (activator.client.pers.inventory[index] == 0)
{
if (GameBase.level.time < self.touch_debounce_time)
{
return;
}
self.touch_debounce_time = GameBase.level.time + 5F;
GameBase.gi.Centerprintf(activator, "You need the " + self.item.pickup_name);
GameBase.gi.Sound(activator, Defines.CHAN_AUTO, GameBase.gi.Soundindex("misc/keytry.wav"), 1, Defines.ATTN_NORM, 0);
return;
}
GameBase.gi.Sound(activator, Defines.CHAN_AUTO, GameBase.gi.Soundindex("misc/keyuse.wav"), 1, Defines.ATTN_NORM, 0);
if (GameBase.coop.value != 0)
{
int player;
edict_t ent;
if (Lib.Strcmp(self.item.classname, "key_power_cube") == 0)
{
int cube;
for (cube = 0; cube < 8; cube++)
{
if ((activator.client.pers.power_cubes & (1 << cube)) != 0)
{
break;
}
}
for (player = 1; player <= GameBase.game.maxclients; player++)
{
ent = GameBase.g_edicts[player];
if (!ent.inuse)
{
continue;
}
if (null == ent.client)
{
continue;
}
if ((ent.client.pers.power_cubes & (1 << cube)) != 0)
{
ent.client.pers.inventory[index]--;
ent.client.pers.power_cubes &= ~(1 << cube);
}
}
}
else
{
for (player = 1; player <= GameBase.game.maxclients; player++)
{
ent = GameBase.g_edicts[player];
if (!ent.inuse)
{
continue;
}
if (ent.client == null)
{
continue;
}
ent.client.pers.inventory[index] = 0;
}
}
}
else
{
activator.client.pers.inventory[index]--;
}
GameUtil.G_UseTargets(self, activator);
self.use = null;
}
public static void Say_f(edict_t ent, Boolean team, Boolean arg0)
{
Int32 i, j;
edict_t other;
String text;
gclient_t cl;
if (Cmd.Argc() < 2 && !arg0)
{
return;
}
if (0 == (( Int32 )(GameBase.dmflags.value) & (Defines.DF_MODELTEAMS | Defines.DF_SKINTEAMS)))
{
team = false;
}
if (team)
{
text = "(" + ent.client.pers.netname + "): ";
}
else
{
text = "" + ent.client.pers.netname + ": ";
}
if (arg0)
{
text += Cmd.Argv(0);
text += " ";
text += Cmd.Args();
}
else
{
if (Cmd.Args().StartsWith("\\\""))
{
text += Cmd.Args().Substring(1, Cmd.Args().Length - 1);
}
else
{
text += Cmd.Args();
}
}
if (text.Length > 150)
{
text = text.Substring(0, 150);
}
text += "\\n";
if (GameBase.flood_msgs.value != 0)
{
cl = ent.client;
if (GameBase.level.time < cl.flood_locktill)
{
SV_GAME.PF_cprintfhigh(ent, "You can't talk for " + ( Int32 )(cl.flood_locktill - GameBase.level.time) + " more seconds\\n");
return;
}
i = ( Int32 )(cl.flood_whenhead - GameBase.flood_msgs.value + 1);
if (i < 0)
{
i = (10) + i;
}
if (cl.flood_when[i] != 0 && GameBase.level.time - cl.flood_when[i] < GameBase.flood_persecond.value)
{
cl.flood_locktill = GameBase.level.time + GameBase.flood_waitdelay.value;
SV_GAME.PF_cprintf(ent, Defines.PRINT_CHAT, "Flood protection: You can't talk for " + ( Int32 )GameBase.flood_waitdelay.value + " seconds.\\n");
return;
}
cl.flood_whenhead = (cl.flood_whenhead + 1) % 10;
cl.flood_when[cl.flood_whenhead] = GameBase.level.time;
}
if (Globals.dedicated.value != 0)
{
SV_GAME.PF_cprintf(null, Defines.PRINT_CHAT, "" + text + "");
}
for (j = 1; j <= GameBase.game.maxclients; j++)
{
other = GameBase.g_edicts[j];
if (!other.inuse)
{
continue;
}
if (other.client == null)
{
continue;
}
if (team)
{
if (!GameUtil.OnSameTeam(ent, other))
{
continue;
}
}
SV_GAME.PF_cprintf(other, Defines.PRINT_CHAT, "" + text + "");
}
}
public static bool Ai_checkattack(edict_t self, float dist)
{
float[] temp = new[] { 0f, 0f, 0f };
bool hesDeadJim;
if (self.goalentity != null)
{
if ((self.monsterinfo.aiflags & Defines.AI_COMBAT_POINT) != 0)
{
return(false);
}
if ((self.monsterinfo.aiflags & Defines.AI_SOUND_TARGET) != 0)
{
if ((GameBase.level.time - self.enemy.teleport_time) > 5)
{
if (self.goalentity == self.enemy)
{
if (self.movetarget != null)
{
self.goalentity = self.movetarget;
}
else
{
self.goalentity = null;
}
}
self.monsterinfo.aiflags &= ~Defines.AI_SOUND_TARGET;
if ((self.monsterinfo.aiflags & Defines.AI_TEMP_STAND_GROUND) != 0)
{
self.monsterinfo.aiflags &= ~(Defines.AI_STAND_GROUND | Defines.AI_TEMP_STAND_GROUND);
}
}
else
{
self.show_hostile = (int)GameBase.level.time + 1;
return(false);
}
}
}
enemy_vis = false;
hesDeadJim = false;
if ((null == self.enemy) || (!self.enemy.inuse))
{
hesDeadJim = true;
}
else if ((self.monsterinfo.aiflags & Defines.AI_MEDIC) != 0)
{
if (self.enemy.health > 0)
{
hesDeadJim = true;
self.monsterinfo.aiflags &= ~Defines.AI_MEDIC;
}
}
else
{
if ((self.monsterinfo.aiflags & Defines.AI_BRUTAL) != 0)
{
if (self.enemy.health <= -80)
{
hesDeadJim = true;
}
}
else
{
if (self.enemy.health <= 0)
{
hesDeadJim = true;
}
}
}
if (hesDeadJim)
{
self.enemy = null;
if (self.oldenemy != null && self.oldenemy.health > 0)
{
self.enemy = self.oldenemy;
self.oldenemy = null;
HuntTarget(self);
}
else
{
if (self.movetarget != null)
{
self.goalentity = self.movetarget;
self.monsterinfo.walk.Think(self);
}
else
{
self.monsterinfo.pausetime = GameBase.level.time + 100000000;
self.monsterinfo.stand.Think(self);
}
return(true);
}
}
self.show_hostile = (int)GameBase.level.time + 1;
enemy_vis = GameUtil.Visible(self, self.enemy);
if (enemy_vis)
{
self.monsterinfo.search_time = GameBase.level.time + 5;
Math3D.VectorCopy(self.enemy.s.origin, self.monsterinfo.last_sighting);
}
enemy_infront = GameUtil.Infront(self, self.enemy);
enemy_range = GameUtil.Range(self, self.enemy);
Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, temp);
enemy_yaw = Math3D.Vectoyaw(temp);
if (self.monsterinfo.attack_state == Defines.AS_MISSILE)
{
Ai_run_missile(self);
return(true);
}
if (self.monsterinfo.attack_state == Defines.AS_MELEE)
{
Ai_run_melee(self);
return(true);
}
if (!enemy_vis)
{
return(false);
}
return(self.monsterinfo.checkattack.Think(self));
}
public override void Use(edict_t self, edict_t other, edict_t activator)
{
GameUtil.G_UseTargets(self, activator);
}
public override void Ai(edict_t self, float dist)
{
float[] v = new float[] { 0, 0, 0 };
edict_t tempgoal;
edict_t save;
bool new1;
edict_t marker;
float d1, d2;
trace_t tr;
float[] v_forward = new float[] { 0, 0, 0 }, v_right = new float[] { 0, 0, 0 };
float left, center, right;
float[] left_target = new float[] { 0, 0, 0 }, right_target = new float[] { 0, 0, 0 };
if ((self.monsterinfo.aiflags & Defines.AI_COMBAT_POINT) != 0)
{
M.M_MoveToGoal(self, dist);
return;
}
if ((self.monsterinfo.aiflags & Defines.AI_SOUND_TARGET) != 0)
{
Math3D.VectorSubtract(self.s.origin, self.enemy.s.origin, v);
if (Math3D.VectorLength(v) < 64)
{
self.monsterinfo.stand.Think(self);
self.spawnflags &= ~1;
self.enemy = null;
}
else
{
M.M_MoveToGoal(self, dist);
}
if (!GameUtil.FindTarget(self))
{
return;
}
}
if (Ai_checkattack(self, dist))
{
return;
}
if (self.monsterinfo.attack_state == Defines.AS_SLIDING)
{
Ai_run_slide(self, dist);
return;
}
if (enemy_vis)
{
M.M_MoveToGoal(self, dist);
self.monsterinfo.aiflags &= ~Defines.AI_LOST_SIGHT;
Math3D.VectorCopy(self.enemy.s.origin, self.monsterinfo.last_sighting);
self.monsterinfo.trail_time = GameBase.level.time;
return;
}
if (GameBase.coop.value != 0)
{
if (GameUtil.FindTarget(self))
{
return;
}
}
if ((self.monsterinfo.search_time != 0) && (GameBase.level.time > (self.monsterinfo.search_time + 20)))
{
M.M_MoveToGoal(self, dist);
self.monsterinfo.search_time = 0;
return;
}
save = self.goalentity;
tempgoal = GameUtil.G_Spawn();
self.goalentity = tempgoal;
new1 = false;
if (0 == (self.monsterinfo.aiflags & Defines.AI_LOST_SIGHT))
{
self.monsterinfo.aiflags |= (Defines.AI_LOST_SIGHT | Defines.AI_PURSUIT_LAST_SEEN);
self.monsterinfo.aiflags &= ~(Defines.AI_PURSUE_NEXT | Defines.AI_PURSUE_TEMP);
new1 = true;
}
if ((self.monsterinfo.aiflags & Defines.AI_PURSUE_NEXT) != 0)
{
self.monsterinfo.aiflags &= ~Defines.AI_PURSUE_NEXT;
self.monsterinfo.search_time = GameBase.level.time + 5;
if ((self.monsterinfo.aiflags & Defines.AI_PURSUE_TEMP) != 0)
{
self.monsterinfo.aiflags &= ~Defines.AI_PURSUE_TEMP;
marker = null;
Math3D.VectorCopy(self.monsterinfo.saved_goal, self.monsterinfo.last_sighting);
new1 = true;
}
else if ((self.monsterinfo.aiflags & Defines.AI_PURSUIT_LAST_SEEN) != 0)
{
self.monsterinfo.aiflags &= ~Defines.AI_PURSUIT_LAST_SEEN;
marker = PlayerTrail.PickFirst(self);
}
else
{
marker = PlayerTrail.PickNext(self);
}
if (marker != null)
{
Math3D.VectorCopy(marker.s.origin, self.monsterinfo.last_sighting);
self.monsterinfo.trail_time = marker.timestamp;
self.s.angles[Defines.YAW] = self.ideal_yaw = marker.s.angles[Defines.YAW];
new1 = true;
}
}
Math3D.VectorSubtract(self.s.origin, self.monsterinfo.last_sighting, v);
d1 = Math3D.VectorLength(v);
if (d1 <= dist)
{
self.monsterinfo.aiflags |= Defines.AI_PURSUE_NEXT;
dist = d1;
}
Math3D.VectorCopy(self.monsterinfo.last_sighting, self.goalentity.s.origin);
if (new1)
{
tr = GameBase.gi.Trace(self.s.origin, self.mins, self.maxs, self.monsterinfo.last_sighting, self, Defines.MASK_PLAYERSOLID);
if (tr.fraction < 1)
{
Math3D.VectorSubtract(self.goalentity.s.origin, self.s.origin, v);
d1 = Math3D.VectorLength(v);
center = tr.fraction;
d2 = d1 * ((center + 1) / 2);
self.s.angles[Defines.YAW] = self.ideal_yaw = Math3D.Vectoyaw(v);
Math3D.AngleVectors(self.s.angles, v_forward, v_right, null);
Math3D.VectorSet(v, d2, -16, 0);
Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, left_target);
tr = GameBase.gi.Trace(self.s.origin, self.mins, self.maxs, left_target, self, Defines.MASK_PLAYERSOLID);
left = tr.fraction;
Math3D.VectorSet(v, d2, 16, 0);
Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, right_target);
tr = GameBase.gi.Trace(self.s.origin, self.mins, self.maxs, right_target, self, Defines.MASK_PLAYERSOLID);
right = tr.fraction;
center = (d1 * center) / d2;
if (left >= center && left > right)
{
if (left < 1)
{
Math3D.VectorSet(v, d2 * left * 0.5F, -16F, 0F);
Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, left_target);
}
Math3D.VectorCopy(self.monsterinfo.last_sighting, self.monsterinfo.saved_goal);
self.monsterinfo.aiflags |= Defines.AI_PURSUE_TEMP;
Math3D.VectorCopy(left_target, self.goalentity.s.origin);
Math3D.VectorCopy(left_target, self.monsterinfo.last_sighting);
Math3D.VectorSubtract(self.goalentity.s.origin, self.s.origin, v);
self.s.angles[Defines.YAW] = self.ideal_yaw = Math3D.Vectoyaw(v);
}
else if (right >= center && right > left)
{
if (right < 1)
{
Math3D.VectorSet(v, d2 * right * 0.5F, 16F, 0F);
Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, right_target);
}
Math3D.VectorCopy(self.monsterinfo.last_sighting, self.monsterinfo.saved_goal);
self.monsterinfo.aiflags |= Defines.AI_PURSUE_TEMP;
Math3D.VectorCopy(right_target, self.goalentity.s.origin);
Math3D.VectorCopy(right_target, self.monsterinfo.last_sighting);
Math3D.VectorSubtract(self.goalentity.s.origin, self.s.origin, v);
self.s.angles[Defines.YAW] = self.ideal_yaw = Math3D.Vectoyaw(v);
}
}
}
M.M_MoveToGoal(self, dist);
GameUtil.G_FreeEdict(tempgoal);
if (self != null)
{
self.goalentity = save;
}
}
public static void T_Damage(edict_t targ, edict_t inflictor, edict_t attacker, float[] dir, float[] point, float[] normal, int damage, int knockback, int dflags, int mod)
{
gclient_t client;
int take;
int save;
int asave;
int psave;
int te_sparks;
if (targ.takedamage == 0)
{
return;
}
if ((targ != attacker) && ((GameBase.deathmatch.value != 0 && 0 != ((int)(GameBase.dmflags.value) & (Defines.DF_MODELTEAMS | Defines.DF_SKINTEAMS))) || GameBase.coop.value != 0))
{
if (GameUtil.OnSameTeam(targ, attacker))
{
if (((int)(GameBase.dmflags.value) & Defines.DF_NO_FRIENDLY_FIRE) != 0)
{
damage = 0;
}
else
{
mod |= Defines.MOD_FRIENDLY_FIRE;
}
}
}
GameBase.meansOfDeath = mod;
if (GameBase.skill.value == 0 && GameBase.deathmatch.value == 0 && targ.client != null)
{
damage = ( Int32 )(damage * 0.5);
if (damage == 0)
{
damage = 1;
}
}
client = targ.client;
if ((dflags & Defines.DAMAGE_BULLET) != 0)
{
te_sparks = Defines.TE_BULLET_SPARKS;
}
else
{
te_sparks = Defines.TE_SPARKS;
}
Math3D.VectorNormalize(dir);
if (0 == (dflags & Defines.DAMAGE_RADIUS) && (targ.svflags & Defines.SVF_MONSTER) != 0 && (attacker.client != null) && (targ.enemy == null) && (targ.health > 0))
{
damage *= 2;
}
if ((targ.flags & Defines.FL_NO_KNOCKBACK) != 0)
{
knockback = 0;
}
if (0 == (dflags & Defines.DAMAGE_NO_KNOCKBACK))
{
if ((knockback != 0) && (targ.movetype != Defines.MOVETYPE_NONE) && (targ.movetype != Defines.MOVETYPE_BOUNCE) && (targ.movetype != Defines.MOVETYPE_PUSH) && (targ.movetype != Defines.MOVETYPE_STOP))
{
float[] kvel = new float[] { 0, 0, 0 };
float mass;
if (targ.mass < 50)
{
mass = 50;
}
else
{
mass = targ.mass;
}
if (targ.client != null && attacker == targ)
{
Math3D.VectorScale(dir, 1600F * (float)knockback / mass, kvel);
}
else
{
Math3D.VectorScale(dir, 500F * (float)knockback / mass, kvel);
}
Math3D.VectorAdd(targ.velocity, kvel, targ.velocity);
}
}
take = damage;
save = 0;
if ((targ.flags & Defines.FL_GODMODE) != 0 && 0 == (dflags & Defines.DAMAGE_NO_PROTECTION))
{
take = 0;
save = damage;
SpawnDamage(te_sparks, point, normal, save);
}
if ((client != null && client.invincible_framenum > GameBase.level.framenum) && 0 == (dflags & Defines.DAMAGE_NO_PROTECTION))
{
if (targ.pain_debounce_time < GameBase.level.time)
{
GameBase.gi.Sound(targ, Defines.CHAN_ITEM, GameBase.gi.Soundindex("items/protect4.wav"), 1, Defines.ATTN_NORM, 0);
targ.pain_debounce_time = GameBase.level.time + 2;
}
take = 0;
save = damage;
}
psave = CheckPowerArmor(targ, point, normal, take, dflags);
take -= psave;
asave = CheckArmor(targ, point, normal, take, te_sparks, dflags);
take -= asave;
asave += save;
if (0 == (dflags & Defines.DAMAGE_NO_PROTECTION) && CheckTeamDamage(targ, attacker))
{
return;
}
if (take != 0)
{
if (0 != (targ.svflags & Defines.SVF_MONSTER) || (client != null))
{
SpawnDamage(Defines.TE_BLOOD, point, normal, take);
}
else
{
SpawnDamage(te_sparks, point, normal, take);
}
targ.health = targ.health - take;
if (targ.health <= 0)
{
if ((targ.svflags & Defines.SVF_MONSTER) != 0 || (client != null))
{
targ.flags |= Defines.FL_NO_KNOCKBACK;
}
Killed(targ, inflictor, attacker, take, point);
return;
}
}
if ((targ.svflags & Defines.SVF_MONSTER) != 0)
{
M_ReactToDamage(targ, attacker);
if (0 == (targ.monsterinfo.aiflags & Defines.AI_DUCKED) && (take != 0))
{
targ.pain.Pain(targ, attacker, knockback, take);
if (GameBase.skill.value == 3)
{
targ.pain_debounce_time = GameBase.level.time + 5;
}
}
}
else if (client != null)
{
if (((targ.flags & Defines.FL_GODMODE) == 0) && (take != 0))
{
targ.pain.Pain(targ, attacker, knockback, take);
}
}
else if (take != 0)
{
if (targ.pain != null)
{
targ.pain.Pain(targ, attacker, knockback, take);
}
}
if (client != null)
{
client.damage_parmor += psave;
client.damage_armor += asave;
client.damage_blood += take;
client.damage_knockback += knockback;
Math3D.VectorCopy(point, client.damage_from);
}
}
public static void M_ReactToDamage(edict_t targ, edict_t attacker)
{
if ((null != attacker.client) && 0 != (attacker.svflags & Defines.SVF_MONSTER))
{
return;
}
if (attacker == targ || attacker == targ.enemy)
{
return;
}
if (0 != (targ.monsterinfo.aiflags & Defines.AI_GOOD_GUY))
{
if (attacker.client != null || (attacker.monsterinfo.aiflags & Defines.AI_GOOD_GUY) != 0)
{
return;
}
}
if (attacker.client != null)
{
targ.monsterinfo.aiflags &= ~Defines.AI_SOUND_TARGET;
if (targ.enemy != null && targ.enemy.client != null)
{
if (GameUtil.Visible(targ, targ.enemy))
{
targ.oldenemy = attacker;
return;
}
targ.oldenemy = targ.enemy;
}
targ.enemy = attacker;
if (0 == (targ.monsterinfo.aiflags & Defines.AI_DUCKED))
{
GameUtil.FoundTarget(targ);
}
return;
}
if (((targ.flags & (Defines.FL_FLY | Defines.FL_SWIM)) == (attacker.flags & (Defines.FL_FLY | Defines.FL_SWIM))) && (!(targ.classname.Equals(attacker.classname))) && (!(attacker.classname.Equals("monster_tank"))) && (!(attacker.classname.Equals("monster_supertank"))) && (!(attacker.classname.Equals("monster_makron"))) && (!(attacker.classname.Equals("monster_jorg"))))
{
if (targ.enemy != null && targ.enemy.client != null)
{
targ.oldenemy = targ.enemy;
}
targ.enemy = attacker;
if (0 == (targ.monsterinfo.aiflags & Defines.AI_DUCKED))
{
GameUtil.FoundTarget(targ);
}
}
else if (attacker.enemy == targ)
{
if (targ.enemy != null && targ.enemy.client != null)
{
targ.oldenemy = targ.enemy;
}
targ.enemy = attacker;
if (0 == (targ.monsterinfo.aiflags & Defines.AI_DUCKED))
{
GameUtil.FoundTarget(targ);
}
}
else if (attacker.enemy != null && attacker.enemy != targ)
{
if (targ.enemy != null && targ.enemy.client != null)
{
targ.oldenemy = targ.enemy;
}
targ.enemy = attacker.enemy;
if (0 == (targ.monsterinfo.aiflags & Defines.AI_DUCKED))
{
GameUtil.FoundTarget(targ);
}
}
}
public override bool Think(edict_t ent)
{
float[] origin = new float[] { 0, 0, 0 };
int mod;
if (ent.owner.client != null)
{
PlayerWeapon.PlayerNoise(ent.owner, ent.s.origin, Defines.PNOISE_IMPACT);
}
if (ent.enemy != null)
{
float points = 0;
float[] v = new float[] { 0, 0, 0 };
float[] dir = new float[] { 0, 0, 0 };
Math3D.VectorAdd(ent.enemy.mins, ent.enemy.maxs, v);
Math3D.VectorMA(ent.enemy.s.origin, 0.5F, v, v);
Math3D.VectorSubtract(ent.s.origin, v, v);
points = ent.dmg - 0.5F * Math3D.VectorLength(v);
Math3D.VectorSubtract(ent.enemy.s.origin, ent.s.origin, dir);
if ((ent.spawnflags & 1) != 0)
{
mod = Defines.MOD_HANDGRENADE;
}
else
{
mod = Defines.MOD_GRENADE;
}
GameCombat.T_Damage(ent.enemy, ent, ent.owner, dir, ent.s.origin, Globals.vec3_origin, (int)points, (int)points, Defines.DAMAGE_RADIUS, mod);
}
if ((ent.spawnflags & 2) != 0)
{
mod = Defines.MOD_HELD_GRENADE;
}
else if ((ent.spawnflags & 1) != 0)
{
mod = Defines.MOD_HG_SPLASH;
}
else
{
mod = Defines.MOD_G_SPLASH;
}
GameCombat.T_RadiusDamage(ent, ent.owner, ent.dmg, ent.enemy, ent.dmg_radius, mod);
Math3D.VectorMA(ent.s.origin, -0.02F, ent.velocity, origin);
GameBase.gi.WriteByte(Defines.svc_temp_entity);
if (ent.waterlevel != 0)
{
if (ent.groundentity != null)
{
GameBase.gi.WriteByte(Defines.TE_GRENADE_EXPLOSION_WATER);
}
else
{
GameBase.gi.WriteByte(Defines.TE_ROCKET_EXPLOSION_WATER);
}
}
else
{
if (ent.groundentity != null)
{
GameBase.gi.WriteByte(Defines.TE_GRENADE_EXPLOSION);
}
else
{
GameBase.gi.WriteByte(Defines.TE_ROCKET_EXPLOSION);
}
}
GameBase.gi.WritePosition(origin);
GameBase.gi.Multicast(ent.s.origin, Defines.MULTICAST_PHS);
GameUtil.G_FreeEdict(ent);
return(true);
}
static void Check_dodge(edict_t self, float[] start, float[] dir, int speed)
{
float[] end = new float[] { 0, 0, 0 };
float[] v = new float[] { 0, 0, 0 };
trace_t tr;
float eta;
if (GameBase.skill.value == 0)
{
if (Lib.Random() > 0.25)
{
return;
}
}
Math3D.VectorMA(start, 8192, dir, end);
tr = GameBase.gi.Trace(start, null, null, end, self, Defines.MASK_SHOT);
if ((tr.ent != null) && (tr.ent.svflags & Defines.SVF_MONSTER) != 0 && (tr.ent.health > 0) && (null != tr.ent.monsterinfo.dodge) && GameUtil.Infront(tr.ent, self))
{
Math3D.VectorSubtract(tr.endpos, start, v);
eta = (Math3D.VectorLength(v) - tr.ent.maxs[0]) / speed;
tr.ent.monsterinfo.dodge.Dodge(tr.ent, self, eta);
}
}
