Example #1
0
        //idle around a grave checks surroundings for enemies constantly
        void GraveHover(Architech arch, Overseer os, Grid grid, Random rnd)
        {
            var grave = arch.GetBuilding(home);

            if (grave == null)
            {
                SetHome(arch, os);
            }

            var b  = arch.GetBuilding(home);
            var ts = b.AdjacentTiles;

            if (b.AdjacentTiles.Count == 0)
            {
                List <Vector2> dests = new List <Vector2>()
                {
                    new Vector2(64, 0), new Vector2(-64, 0), new Vector2(64, 64),
                    new Vector2(-64, -64), new Vector2(-64, 64), new Vector2(64, -64), new Vector2(0, 64), new Vector2(0, -64)
                };

                destination = Grid.ToGridPosition(dests[rnd.Next(0, dests.Count - 1)], Grid.GetTileSize);
            }

            else
            {
                destination = Grid.ToGridPosition(ts[rnd.Next(0, ts.Count)], Grid.GetTileSize);
            }

            Ai_States = Ai_States.Idle;
            Think_Pathing(grid, rnd);
        }
Example #2
0
        protected void AcquireTarget(Architech arch, Grid grid, bool newTarget, Random rng)
        {
            if (newTarget)
            {
                PFResult = null;
                if (Stats.Focus == Focus.Focused && rng.Next(0, 10) > 5)
                {
                    defenderID = arch.Home;
                    var home  = arch.GetBuilding(defenderID);
                    var edges = home.AdjacentTiles;
                    if (edges == null)
                    {
                        Ai_States = Ai_States.Idle;
                        return;
                    }
                    var dest = edges.GetRandom(rng);
                    destination = Grid.ToGridPosition(dest, Grid.GetTileSize);
                }


                else
                {
                    var building = arch.NearBuilding(Position, 1000);
                    var edges    = building.Value.AdjacentTiles;

                    if (edges == null)
                    {
                        Ai_States = Ai_States.Idle;
                        return;
                    }
                    var dest = edges.GetRandom(rng);
                    destination = Grid.ToGridPosition(dest, Grid.GetTileSize);
                    defenderID  = building.Key;
                }
            }

            if (Think_Pathing(grid, rng))
            {
                Ai_States = Ai_States.Thinking;
            }

            if (pathAttempts >= maxPattempts)
            {
                wait         = false;
                pathAttempts = 0;
                Ai_States    = Ai_States.Target;
                p_wait       = true;
            }
        }
Example #3
0
        protected void Attacking(Overseer os, Architech arch, GameTime gt, Random rng)
        {
            hitElasped += gt.ElapsedGameTime.Milliseconds;

            if (CheckTarget(arch))
            {
                if (hitElasped >= Stats.HitDelay)
                {
                    os.Combat(this, arch.GetBuilding(defenderID), rng);
                    hitElasped = 0;
                    Projectile p = new Projectile(this.Center, new Point(16, 16), data.Projectile, 5, arch.GetBuilding(defenderID).Center);
                    projectile.Add(p.ID, p);
                }
            }
        }
Example #4
0
        bool CheckTarget(Architech arch)
        {
            if (arch.GetBuilding(defenderID) != null)
            {
                if (arch.IsInRange(Corners, defenderID, (float)Stats.Range))
                {
                    noRetaliate = false;
                    Ai_States   = Ai_States.Attacking;
                    return(true);
                }
                else if (WayPoints.Count == 0)
                {
                    Ai_States = Ai_States.Target;  keepTarget = !keepTarget;
                }
            }

            else
            {
                Ai_States = Ai_States.Target; defenderID = new Point(); WayPoints.Clear(); keepTarget = false;
            }

            return(false);
        }
Example #5
0
        public void Update(Cursor ms, GameTime gt, Architech arch, Grid grid, Random rng, Overseer os, UiMaster ui)
        {
            base.Update(ms, gt);
            base.Update(gt);
            base.Update(grid);
            CalculateCorners();
            GetFreeCorners(grid);

            RefreshInfo();

            if (Ai_States != Ai_States.Marching)
            {
                this.Speed = norm_speed;
            }

            if (IsHighlighted)
            {
                ui.RecieveInfo(new KeyValuePair <Guid, InfoPanel>(this.ID, Info));
            }
            else
            {
                ui.RemoveInfo(this.ID);
            }

            if (base.data.Type == Ai_Type.Archer || base.data.Type == Ai_Type.Priest)
            {
                foreach (var proj in projectile.Values)
                {
                    if (arch.GetBuilding(defenderID) != null)
                    {
                        proj.Update(gt);
                    }
                }
            }

            if (Ai_States == Ai_States.Dead)
            {
                CurrentState = "Dead";
                return;
            }
            if (Ai_States != Ai_States.Retaliating && Ai_States != Ai_States.Marching && !marcher)
            {
                CheckTarget(arch);
            }

            switch (Ai_States)
            {
            case Ai_States.Idle:
                CurrentState = "Think";
                if (wait)
                {
                    Think_Pathing(grid, rng);
                }
                else if (PFResult != null)
                {
                    Think_Pathing(grid, rng);
                }
                return;

            case Ai_States.Target:
                CurrentState = "Think";
                EasyGetTarget(arch, grid, rng);     //can go to idle or move
                break;

            case Ai_States.Moving: Moving(arch, grid, gt);                     // can go to idle or attacking
                CurrentState = "Move";
                break;

            case Ai_States.Attacking:
                CurrentState = "Attack";
                Attacking(os, arch, gt, rng);     // can go to idle or target
                break;

            case Ai_States.Retaliating:
                Fighting(os, gt, rng);
                break;

            case Ai_States.Dead:
                CurrentState = "Dead";
                return;

            case Ai_States.Marching:
                Forward(grid, arch);
                break;
            }

            prevPos = Position;
        }
Example #6
0
        void EasyGetTarget(Architech arch, Grid grid, Random rng)
        {
            if (!keepTarget)
            {
                var buildings = arch.GetBuildings;
                var focus     = Think(rng);
                int index     = 0;
                switch (focus)
                {
                case Focus.Focused:
                    index = rng.Next((int)(buildings.Count * 0.8), buildings.Count);
                    break;

                case Focus.Hyper:
                    index = rng.Next(0, (int)(buildings.Count * 0.3));
                    break;

                case Focus.Aggressive:
                    index = rng.Next((int)(buildings.Count * 0.3), buildings.Count);
                    break;

                case Focus.Violent:
                    index = rng.Next(0, (int)(buildings.Count * 0.1));
                    break;
                }

                if (buildings.Count == 0)
                {
                    return;
                }

                KeyValuePair <Point, Building> building = buildings.ToList()[index];
                var edges = building.Value.GetAdjacent(grid);

                if (edges == null || edges.Count == 0)
                {
                    defenderID = Point.Zero;
                    return;
                }

                destination = Grid.ToGridPosition(edges.GetRandom(rng), Grid.GetTileSize);
                defenderID  = building.Key;
            }

            else
            {
                Building building = arch.GetBuilding(defenderID);
                var      edges    = building.AdjacentTiles;

                if (edges == null || edges.Count == 0)
                {
                    defenderID = Point.Zero;
                    return;
                }

                destination = Grid.ToGridPosition(edges.GetRandom(rng), Grid.GetTileSize);
            }

            Ai_States = Ai_States.Idle;
            Think_Pathing(grid, rng);
        }
Example #7
0
        public void Update(Cursor ms, GameTime gt, Architech arch, Grid grid, Random rng, Overseer os, UiMaster ui)
        {
            if (stuck)
            {
                stuck = false;
                var b   = arch.GetBuilding(home);
                var adj = b.GetAdjacent(grid);
                if (adj.Count > 0)
                {
                    Position = adj[0];
                }
            }

            if (Ai_States == Ai_States.Marching)
            {
                Ai_States  = Ai_States.Target;
                this.Speed = temp_speed;
            }
            if (home == arch.Home || !arch.GetBuildings.ContainsKey(home))
            {
                SetHome(arch, os);
            }
            else
            {
                if (Vector2.Distance(Position, arch.GetBuilding(home).Center) > 264)
                {
                    Position  = arch.GetBuilding(home).Center;
                    Ai_States = Ai_States.Target;
                }
            }

            base.Update(ms, gt);
            base.Update(gt);
            base.Update(grid);
            CalculateCorners();
            GetFreeCorners(grid);
            RefreshInfo();

            if (IsHighlighted)
            {
                ui.RecieveInfo(new KeyValuePair <Guid, InfoPanel>(this.ID, Info));
            }
            else
            {
                ui.RemoveInfo(this.ID);
            }

            if (Ai_States == Ai_States.Thinking)
            {
                return;
            }

            if (base.data.Type == Ai_Type.Z_Archer || base.data.Type == Ai_Type.Z_Priest)
            {
                foreach (var proj in projectile.Values)
                {
                    if (os.Ais.ContainsKey(target))
                    {
                        proj.Update(gt);
                    }
                }
            }

            if (Ai_States == Ai_States.Dead)
            {
                return;
            }

            if (Ai_States != Ai_States.Pathing)
            {
                CheckTarget(os);
            }

            switch (Ai_States)
            {
            case Ai_States.Idle:
                CurrentState = "Think";
                if (wait)
                {
                    Think_Pathing(grid, rng);
                }
                else if (PFResult != null)
                {
                    Think_Pathing(grid, rng);
                }
                return;

            case Ai_States.Target:
                CurrentState = "Think";
                EasyGetTarget(arch, os, grid, rng);     //can go to idle or move
                break;

            case Ai_States.Moving:
                CurrentState = "Move";
                Moving(os, grid, gt);     // can go to idle or attacking
                break;

            case Ai_States.Attacking:
                CurrentState = "Attack";
                Attacking(os, arch, gt, rng, grid);     // can go to idle or target
                break;

            case Ai_States.Pathing:
                CycleDestinations(grid, rng, os);
                break;

            case Ai_States.Dead:
                return;
            }
            prevPos = Position;
        }
Example #8
0
        void EasyGetTarget(Architech arch, Overseer os, Grid grid, Random rng)
        {
            if (!keepTarget)
            {
                var units = os.GetUnitsInRange(arch.GetBuilding(home).Center, 264, true);
                var focus = Think(rng);
                int index = 0;

                if (units.Count <= 0 || stuck)
                {
                    stuck = false;
                    GraveHover(arch, os, grid, rng);

                    return;
                }

                switch (focus)
                {
                case Focus.Focused:
                    index = rng.Next((int)(units.Count * 0.8), units.Count);
                    break;

                case Focus.Hyper:
                    index = rng.Next(0, (int)(units.Count * 0.3));
                    break;

                case Focus.Aggressive:
                    index = rng.Next((int)(units.Count * 0.3), units.Count);
                    break;

                case Focus.Violent:
                    index = rng.Next(0, (int)(units.Count * 0.1));
                    break;
                }

                var unit  = units.ToList()[index];
                var Nunit = os.Ais[unit];

                foreach (var u in units)
                {
                    destinations.Add(u);
                }

                if (Nunit.WayPoints.Count > 0)
                {
                    destination = Grid.ToGridPosition(Nunit.WayPoints.Last(), Grid.GetTileSize);
                }
                else
                {
                    destination = Grid.ToGridPosition(Nunit.Position, Grid.GetTileSize);
                }
                destination = Grid.ToGridPosition(Nunit.Position, Grid.GetTileSize);
                target      = unit;
            }

            else
            {
                if (!os.Ais.ContainsKey(target))
                {
                    keepTarget = !keepTarget;
                    return;
                }

                var Nunit = os.Ais[target];

                destination = Grid.ToGridPosition(Nunit.Position, Grid.GetTileSize);
            }

            Ai_States = Ai_States.Idle;
            Think_Pathing(grid, rng);
        }