Esempio n. 1
0
            public override bool Think(edict_t self)
            {
                float[] target = new float[] { 0, 0, 0 };
                float[] dir    = new float[] { 0, 0, 0 };
                float   reaction_time;

                self.nextthink = GameBase.level.time + Defines.FRAMETIME;
                if (self.enemy != null && (!self.enemy.inuse || self.enemy.health <= 0))
                {
                    self.enemy = null;
                }
                if (null == self.enemy)
                {
                    if (!GameUtil.FindTarget(self))
                    {
                        return(true);
                    }
                    self.monsterinfo.trail_time = GameBase.level.time;
                    self.monsterinfo.aiflags   &= ~Defines.AI_LOST_SIGHT;
                }
                else
                {
                    if (GameUtil.Visible(self, self.enemy))
                    {
                        if ((self.monsterinfo.aiflags & Defines.AI_LOST_SIGHT) != 0)
                        {
                            self.monsterinfo.trail_time = GameBase.level.time;
                            self.monsterinfo.aiflags   &= ~Defines.AI_LOST_SIGHT;
                        }
                    }
                    else
                    {
                        self.monsterinfo.aiflags |= Defines.AI_LOST_SIGHT;
                        return(true);
                    }
                }

                Math3D.VectorCopy(self.enemy.s.origin, target);
                target[2] += self.enemy.viewheight;
                Math3D.VectorSubtract(target, self.target_ent.s.origin, dir);
                Math3D.Vectoangles(dir, self.target_ent.move_angles);
                if (GameBase.level.time < self.monsterinfo.attack_finished)
                {
                    return(true);
                }
                reaction_time = (3 - GameBase.skill.value) * 1F;
                if ((GameBase.level.time - self.monsterinfo.trail_time) < reaction_time)
                {
                    return(true);
                }
                self.monsterinfo.attack_finished = GameBase.level.time + reaction_time + 1F;
                self.target_ent.spawnflags      |= 65536;
                return(true);
            }
Esempio n. 2
0
 public override void Ai(edict_t self, float dist)
 {
     if (dist != 0)
     {
         M.M_walkmove(self, self.s.angles[Defines.YAW], dist);
     }
     if (GameUtil.FindTarget(self))
     {
         return;
     }
     M.M_ChangeYaw(self);
 }
Esempio n. 3
0
            public override void Ai(edict_t self, float dist)
            {
                float[] v = new float[] { 0, 0, 0 };
                if (dist != 0)
                {
                    M.M_walkmove(self, self.s.angles[Defines.YAW], dist);
                }
                if ((self.monsterinfo.aiflags & Defines.AI_STAND_GROUND) != 0)
                {
                    if (self.enemy != null)
                    {
                        Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, v);
                        self.ideal_yaw = Math3D.Vectoyaw(v);
                        if (self.s.angles[Defines.YAW] != self.ideal_yaw && 0 != (self.monsterinfo.aiflags & Defines.AI_TEMP_STAND_GROUND))
                        {
                            self.monsterinfo.aiflags &= ~(Defines.AI_STAND_GROUND | Defines.AI_TEMP_STAND_GROUND);
                            self.monsterinfo.run.Think(self);
                        }

                        M.M_ChangeYaw(self);
                        Ai_checkattack(self, 0);
                    }
                    else
                    {
                        GameUtil.FindTarget(self);
                    }
                    return;
                }

                if (GameUtil.FindTarget(self))
                {
                    return;
                }
                if (GameBase.level.time > self.monsterinfo.pausetime)
                {
                    self.monsterinfo.walk.Think(self);
                    return;
                }

                if (0 == (self.spawnflags & 1) && (self.monsterinfo.idle != null) && (GameBase.level.time > self.monsterinfo.idle_time))
                {
                    if (self.monsterinfo.idle_time != 0)
                    {
                        self.monsterinfo.idle.Think(self);
                        self.monsterinfo.idle_time = GameBase.level.time + 15 + ( float )Globals.rnd.NextDouble() * 15;
                    }
                    else
                    {
                        self.monsterinfo.idle_time = GameBase.level.time + ( float )Globals.rnd.NextDouble() * 15;
                    }
                }
            }
Esempio n. 4
0
 public override void Ai(edict_t self, float dist)
 {
     M.M_MoveToGoal(self, dist);
     if (GameUtil.FindTarget(self))
     {
         return;
     }
     if ((self.monsterinfo.search != null) && (GameBase.level.time > self.monsterinfo.idle_time))
     {
         if (self.monsterinfo.idle_time != 0)
         {
             self.monsterinfo.search.Think(self);
             self.monsterinfo.idle_time = GameBase.level.time + 15 + ( float )Globals.rnd.NextDouble() * 15;
         }
         else
         {
             self.monsterinfo.idle_time = GameBase.level.time + ( float )Globals.rnd.NextDouble() * 15;
         }
     }
 }
Esempio n. 5
0
 static void Ai_walk(edict_t self, float dist)
 {
     M.M_MoveToGoal(self, dist);
     if (GameUtil.FindTarget(self))
     {
         return;
     }
     if ((self.monsterinfo.search != null) && (GameBase.level.time > self.monsterinfo.idle_time))
     {
         if (self.monsterinfo.idle_time != 0)
         {
             self.monsterinfo.search.Think(self);
             self.monsterinfo.idle_time = GameBase.level.time + 15 + Lib.Random() * 15;
         }
         else
         {
             self.monsterinfo.idle_time = GameBase.level.time + Lib.Random() * 15;
         }
     }
 }
Esempio n. 6
0
            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;
                }
            }