예제 #1
0
 //turn locations into antData objects for compatibility with reused methods from previous practical
 public virtual void DoAction(GameState state, int hashcode)
 {
     //actions are serialised at the end, make sure to start fresh by clearing all the ant related data
     orders.Clear();
     allAnts.Clear();
     antLocations.Clear();
     CreatAntData(state);
 }
예제 #2
0
 protected void CreatAntData(GameState state)
 {
     foreach (Location loc in state.MyAnts)
     {
         if (!antLocations.ContainsKey(loc))
         {
             AntData newAnt = new AntData(loc);
             antLocations.Add(loc, newAnt);
             allAnts.Add(newAnt);
         }
     }
 }
예제 #3
0
        /// <summary>
        /// Ants took a page out of Google's book, "I'm feeling lucky".
        /// </summary>
        /// <param name="state"></param>
        public override void DoAction(GameState state, int hashcode)
        {
            base.DoAction(state, hashcode);

            //to guarantee the same actions regardless of the particular run
            Random random = new Random(hashcode);

            foreach (AntData ant in allAnts)
            {
                Location goal = SelectRandomNeighbor(ant.CurrentLocation, random);

                ant.AntRoute = new Route(ant.CurrentLocation, goal, new Location[] { ant.CurrentLocation, goal });

                ant.AdvancePath(this);
            }
        }
예제 #4
0
        public QState(GameState state)
        {
            MyAnts = CopyList(state.MyAnts);
            Food = CopyList(state.FoodTiles);
            EnemyAnts = CopyList(state.EnemyAnts);

            foreach (Location l in state.map)
            {

                if (state.GetIsVisible(l))
                    visibleTiles++;
                if (l.Visited)
                    visitedTiles++;
            }

            CalculateReward(state);
        }
예제 #5
0
        /// <summary>
        /// Ants will move and cluster towards enemies, dead ants add a fraction to the enemy influence.
        /// </summary>
        /// <param name="state"></param>
        public override void DoAction(GameState state, int hashcode)
        {
            base.DoAction(state, hashcode);

            // Make all ants attack, or at least close in on the enemy presence.
            foreach (AntData ant in allAnts)
            {
                // Select unoccupied/passable tile with maximum influence.
                Location next = ant.CurrentLocation.Neighbors[0];
                float max =  Globals.enemyInfluence[next.Row, next.Col];
                foreach (Location l in ant.CurrentLocation.Neighbors)
                {
                    if (Globals.enemyInfluence[l.Row, l.Col] > max && Globals.state.GetIsUnoccupied(l) && Globals.state.GetIsPassable(l))
                    {
                        max = Globals.enemyInfluence[l.Row, l.Col];
                        next = l;
                    }
                }
                //Perform move.
                ant.AntRoute = new Route(ant.CurrentLocation, next, new Location[] { ant.CurrentLocation, next });
                ant.AdvancePath(this);
            }
        }
        /// <summary>
        /// Move ants towards the nearest food source.
        /// </summary>
        /// <param name="state"></param>
        public override void DoAction(GameState state, int hashcode)
        {
            base.DoAction(state, hashcode);

            // We moved to influence based food gathering after some issues with the path planner.

            // Move all ants towards their closest food piece.
            foreach (AntData ant in allAnts)
            {
                // Select the unoccupied/passable tile in the direction of the closest food piece.
                Location next = ant.CurrentLocation.Neighbors[0];
                float max = Globals.foodInfluence[next.Row, next.Col];
                foreach (Location l in ant.CurrentLocation.Neighbors)
                    if (Globals.foodInfluence[l.Row, l.Col] > max && Globals.state.GetIsUnoccupied(l) && Globals.state.GetIsPassable(l))
                    {
                        max = Globals.foodInfluence[l.Row, l.Col];
                        next = l;
                    }
                // Perform move.
                ant.AntRoute = new Route(ant.CurrentLocation, next, new Location[] { ant.CurrentLocation, next });
                ant.AdvancePath(this);
            }
        }
예제 #7
0
        public override void DoTurn(GameState state)
        {
            foreach (Location enm in state.EnemyAnts)
                Globals.enemyInfluence.AddInfluence(enm, 10.0f);

            foreach (Location enm in state.EnemyHills)
            {
                Globals.enemyInfluence.AddInfluence(enm, 1.0f);
                Globals.hillInfluence.AddInfluence(enm, 15.0f);
            }

            foreach (Location fnd in state.MyAnts)
                Globals.friendlyInfluence.AddInfluence(fnd, 10.0f);

            foreach (Location fnd in state.MyHills)
                Globals.friendlyInfluence.AddInfluence(fnd, 1.0f);

            foreach (Location ded in state.DeadTiles)
                Globals.enemyInfluence.AddInfluence(ded, 10.0f);

            foreach (Location loc in state.FoodTiles)
                Globals.foodInfluence.AddInfluence(loc, 10.0f);

            Globals.enemyInfluence.UpdateInfluence();
            Globals.friendlyInfluence.UpdateInfluence();
            Globals.hillInfluence.UpdateInfluence();
            Globals.foodInfluence.UpdateInfluence();

            #if DEBUG

            Learner.LearnPolicy(state, false);
            #endif

            #if RELEASE
            Learner.ExecutePolicy(state,false);
            #endif
        }
예제 #8
0
        // DoTurn is run once per turn
        public override void DoTurn(GameState state)
        {
            state.expectedLocation.Clear();
            //attack until our number of ants falls below 250 from 300
            if (!attackMode && state.MyAnts.Count > 300) attackMode = true;
            if (attackMode && state.MyAnts.Count < 250) attackMode = false;

            this.diffuseOne(state);
            this.diffuseTwo(state);
            // loop through all my ants and try to give them orders
            foreach (Ant ant in state.MyAnts)
            {
                Location up = state.GetDestination(ant, Direction.North);
                Location right = state.GetDestination(ant, Direction.East);
                Location left = state.GetDestination(ant, Direction.West);
                Location down = state.GetDestination(ant, Direction.South);

                List<Tup4> adjacentTiles = new List<Tup4>();

                //use diffusion layer 1 this layer prefers to harvest food and grow the ant colony
                if (!attackMode)
                {
                    Tup4 n1 = new Tup4(state.diffusionOne[up.Row, up.Col], Direction.North, up.Row, up.Col);
                    Tup4 e1 = new Tup4(state.diffusionOne[right.Row, right.Col], Direction.East, right.Row, right.Col);
                    Tup4 w1 = new Tup4(state.diffusionOne[left.Row, left.Col], Direction.West, left.Row, left.Col);
                    Tup4 s1 = new Tup4(state.diffusionOne[down.Row, down.Col], Direction.South, down.Row, down.Col);
                    adjacentTiles.Add(n1);
                    adjacentTiles.Add(e1);
                    adjacentTiles.Add(s1);
                    adjacentTiles.Add(w1);
                }
                else
                {
                    Tup4 n2 = new Tup4(state.diffusionTwo[up.Row, up.Col], Direction.North, up.Row, up.Col);
                    Tup4 e2 = new Tup4(state.diffusionTwo[right.Row, right.Col], Direction.East, right.Row, right.Col);
                    Tup4 w2 = new Tup4(state.diffusionTwo[left.Row, left.Col], Direction.West, left.Row, left.Col);
                    Tup4 s2 = new Tup4(state.diffusionTwo[down.Row, down.Col], Direction.South, down.Row, down.Col);
                    //use diffusion layer 2, this layer prefers to be aggressive
                    adjacentTiles.Add(n2);
                    adjacentTiles.Add(s2);
                    adjacentTiles.Add(e2);
                    adjacentTiles.Add(w2);
                }

                double maxDiffusion = 0; //assume the ant can't move
                Direction direction = Direction.East;
                int ct = 0;
                int row = 0;
                int col = 0;
                //check the four adjacent tiles to move
                while (ct < 4)
                {
                   //check if this tile has a higher diffusion score and that it is not occupied already by a friendly ant
                    if (adjacentTiles[ct].Item1 > maxDiffusion && state.diffusionOne[adjacentTiles[ct].Item3, adjacentTiles[ct].Item4] > 0 && state.GetIsUnoccupied(new Location(adjacentTiles[ct].Item3, adjacentTiles[ct].Item4)))
                    {
                        maxDiffusion = adjacentTiles[ct].Item1;
                        direction = adjacentTiles[ct].Item2;
                        row = adjacentTiles[ct].Item3;
                        col = adjacentTiles[ct].Item4;
                    }
                    ct += 1;
                }

                //ants will only move onto tiles with a diffusion score > 0
                if (maxDiffusion > 0)
                {
                    IssueOrder(ant, direction);
                    state.diffusionOne[row, col] = 0;
                    state.expectedLocation[state.GetDestination(ant, direction)] = ant;
                }
                else
                {
                    //ant could not move expected location is the same
                    state.expectedLocation[new Location(ant.Row, ant.Col)] = ant;
                }
                // check if we have time left to calculate more orders
                if (state.TimeRemaining < 10)
                {
                    //exit the loop immediately to prevent the bot from timing out
                   break;
                }
            }
        }
예제 #9
0
        /// <summary>
        /// Calculate the current diffusion scores for layer 2.
        /// </summary>
        /// <param name="state">The state.</param>
        public void diffuseTwo(GameState state)
        {
            for (int row = 0; row < state.Height; row++)
            {
                for (int col = 0; col < state.Width; col++)
                {
                    if (state.map[row, col] == Tile.Water) state.diffusionTwo[row, col] = WATER_SCORE;

                    else if (state.map[row, col] == Tile.Ant
                        && state.ants.ContainsKey(new Location(row, col))
                        && state.ants[new Location(row, col)].Team != 0)
                    {
                        state.diffusionTwo[row, col] = ENEMY_ANT_SCORE_D2;
                    }
                    else if (state.map[row, col] == Tile.Unseen)
                    {
                        state.diffusionTwo[row, col] = UNSEEN_SCORE_D2;
                    }
                    else if (state.isEnemyHill(row, col))
                    {
                        state.diffusionTwo[row, col] = ENEMYHILL_SCORE_D2;
                    }
                    else if (state.isMyHill(row, col))
                    {
                        state.diffusionTwo[row, col] = MYHILL_SCORE;
                    }
                    else
                    {
                        double u = state.diffusionTwo[row, col];
                        Location location = new Location(row, col);
                        Location up = state.GetDestination(location, Direction.North);
                        Location right = state.GetDestination(location, Direction.East);
                        Location left = state.GetDestination(location, Direction.West);
                        Location down = state.GetDestination(location, Direction.South);
                        state.diffusionTwo[row, col] = u + D2_COEFFICIENT * (1
                                                     + state.diffusionTwo[up.Row, up.Col]
                                                     + state.diffusionTwo[down.Row, down.Col]
                                                     + state.diffusionTwo[left.Row, left.Col]
                                                     + state.diffusionTwo[right.Row, right.Col]
                                                     - u * 4);
                    }
                }
            }
        }
예제 #10
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        private Goal GatherFood(AntLoc ant, GameState state)
        {
            if (!state.FoodTiles.Any())
                return Scout(ant, state);

            Log("foodtiles: " + state.FoodTiles.Count);
            // look for some food
            var searchingspots = state.FoodTiles.Where(f => Goals.Count(g => g.EndPoint.Equals(f))==0);
            Log("searchingspots: " + searchingspots.Count());
            //searchingspots = searchingspots.Where(f => f.GetDistance(ant) < GetSearchRadius(state)).OrderBy(f => f.GetDistance(ant)).Take(2);
            var foodpoints = searchingspots.Select(f => new
            {
                Tile = f,
                Point = f.ToPoint(),
                Distance = state.GetDistance(ant,f)//astar.Search(ant.ToPoint(), f.ToPoint(), new Object()) ?? Enumerable.Empty<Tile>()
            });

            var closest = foodpoints.OrderBy(f => f.Distance).FirstOrDefault();

            if (closest != null)
            {
                Log("closest food:" + closest.Tile);

                return new Goal(closest.Tile, GetPath(ant,closest.Tile,state), (g => !g.HasFood(closest.Tile)), Strategy.GatherFood);
            }

            return SpreadOut(ant, state);
        }
예제 #11
0
 public abstract void Initialise(GameState state);
예제 #12
0
파일: MyBot.cs 프로젝트: ejsmile/ant
        // doTurn is run once per turn
        public override void doTurn(GameState state)
        {
            #if DEBUG
            sw.WriteLine ("!Turn " + number++);
            #endif
            destinations.Clear ();
            currentTurn.Clear ();

            #region Setup Discovery Aims
            List<Location > Discovery = new List<Location> ();
            for (int row = 0; row < state.Height / (state.ViewRadius2 / 2); row++) {
                for (int col = 0; col < state.Width / (state.ViewRadius2 / 2); col++) {
                    Discovery.Add (new Location (row, col));
                }
            }

            foreach (var ant in state.MyAnts) {
                Location tmp = new Location (ant.row / (state.ViewRadius2 / 2), ant.col / (state.ViewRadius2 / 2));
                if (Discovery.Contains (tmp))
                    Discovery.Remove (tmp);
            }
            #endregion

            Location[] hod = new Location[] {new Location (0, -state.ViewRadius2 - 1), new Location (0, state.ViewRadius2 + 1),
                new Location (-state.ViewRadius2 - 1, 0), new Location (state.ViewRadius2 + 1, 0) ,
                new Location (-state.ViewRadius2 / 2 - 1, -state.ViewRadius2 / 2 + 1),
                new Location (state.ViewRadius2 / 2 + 1, state.ViewRadius2 / 2 + 1),
                new Location (state.ViewRadius2 / 2 + 1, -state.ViewRadius2 / 2 - 1),
                new Location (-state.ViewRadius2 / 2 - 1, state.ViewRadius2 / 2 + 1)};
            Location[] smeshnie = new Location[] {new Location (0, -state.ViewRadius2 - rng.Next (state.ViewRadius2)),
                new Location (0, state.ViewRadius2 + rng.Next (state.ViewRadius2)),
                new Location (-state.ViewRadius2 - rng.Next (state.ViewRadius2), 0),
                new Location (state.ViewRadius2 + rng.Next (state.ViewRadius2), 0)};

            #region Find Guard for my Hills
            IDictionary<AntLoc, Location > Guard = new Dictionary<AntLoc, Location> ();
            foreach (var hill in state.MyHills) {
                foreach (var dest in Ants.Aim.Keys) {
                    Location loc = state.destination (hill, dest);
                    if (state.passable (loc)) {
                        Guard.Add (hill, loc);
                        break;
                    }
                }
            }
            #endregion

            #region aim ants to food + Enemy hills

            //Add Enemy Hill to AIM food :)
            foreach (var hill in state.EnemyHills) {
                state.FoodTiles.Add (new Location (hill.row, hill.col));
            }

            foreach (var food in state.FoodTiles) {
                int dist = int.MaxValue;
                AntLoc antFood = null;

                foreach (var ant in state.MyAnts) {
                    if (!currentTurn.ContainsKey (ant))
                    if (state.distance (ant, food) < dist) {
                        dist = state.distance (ant, food);
                        antFood = ant;
                    }

                }
                if (antFood != null) {
                    currentTurn.Add (antFood, food);
                    #if DEBUG
                    sw.WriteLine (" ant " + antFood + " food " + food);
                    #endif

                } else
                    break;
            }
            #endregion

            #region Enemy aim
            foreach (var ant in state.MyAnts) {
                int distEnemy = state.ViewRadius2 * 3;
                Location aimEnemy = null;
                int dist;
                int attakEnemy = 0;

                foreach (var enemy in state.EnemyAnts) {
                    dist = state.distance (ant, enemy);
                    if (dist < distEnemy) {
                        distEnemy = dist;
                        aimEnemy = enemy;
                    }
                    if (dist < state.AttackRadius2 + 1)
                        attakEnemy++;
                }

                if (aimEnemy != null) {

                    //find frinds in  state.AttackRadius2
                    int attakFrinds = 0;
                    int saveDist = state.AttackRadius2 + 1;
                    foreach (var friends in state.MyAnts) {
                        dist = state.distance (aimEnemy, friends);
                        if (dist < saveDist) {
                            attakFrinds++;
                        }
                    }
                    #if DEBUG
                    sw.WriteLine (" ant " + ant + " friends " + attakFrinds + " they " + attakEnemy + " aim " + aimEnemy);
                    #endif

                    //I am alone
                    if ((attakFrinds <= attakEnemy) && (distEnemy < state.AttackRadius2 + 3)) {
                        int runDist = distEnemy;

                        Location runLoc = null;
                        foreach (Location loc in hod) {
                            Location newLoc = state.destination (ant, loc);
                            if (state.unoccupied (newLoc)) {
                                if (runDist < state.distance (newLoc, aimEnemy)) {
                                    runDist = state.distance (newLoc, aimEnemy);
                                    runLoc = newLoc;
                                }
                            }
                        }
                        if (runLoc != null) {
                            aimEnemy = runLoc;
                            distEnemy = runDist;
                        }
                        #if DEBUG
                        sw.WriteLine (" ant " + ant + " run  from enemy to " + aimEnemy);
                        #endif
                    }
                    /**/
                    if (currentTurn.ContainsKey (ant)) {
                        int tmp = state.distance (ant, currentTurn [ant]);
                        if (tmp > distEnemy) {
                            Location food = currentTurn [ant];
                            currentTurn [ant] = aimEnemy;
                            aimEnemy = null;
                            tmp = int.MaxValue;

                            foreach (var ants in state.MyAnts) {
                                if (!currentTurn.ContainsKey (ants) && (state.distance (ant, food) < tmp)) {
                                    tmp = state.distance (ant, food);
                                    aimEnemy = ants;
                                }
                            }
                            if (aimEnemy != null)
                                currentTurn.Add (new AntLoc (aimEnemy, 0), food);
                        }
                    } else
                        currentTurn.Add (ant, aimEnemy);
                }
            }
            #endregion

            #region Move other ants
            foreach (var ant in state.MyAnts) {
                if (!currentTurn.ContainsKey (ant)) {

                    Location aim = smeshnie [rng.Next (4)];
                    if (Discovery.Count > 0) {
                        int dist = int.MaxValue;
                        foreach (var loc in Discovery) {
                            Location aimTmp = new Location (loc.row * (state.ViewRadius2 / 2), loc.col * (state.ViewRadius2 / 2));
                            int tmp = state.distance (aimTmp, ant);
                            if (tmp < dist) {
                                dist = tmp;
                                aim = aimTmp;
                            }
                        }
                    }
                    if (oldTurn.ContainsKey (ant)) {
                        if (state.distance (ant, oldTurn [ant]) > (state.ViewRadius2 / 2)) {
                            aim = oldTurn [ant];
                        }
                    }

                    currentTurn.Add (ant, aim);
                    #if DEBUG
                    sw.WriteLine (" ant " + ant + " move " + aim);
                    #endif
                }
            }
            #endregion

            #region Setup guard
            if (state.MyAnts.Count > 5 * state.MyHills.Count) {
                foreach (var hill in Guard.Keys) {
                    AntLoc tmp = new AntLoc (Guard [hill], 0);
                    if (currentTurn.ContainsKey (tmp)) {
                        currentTurn [tmp] = Guard [hill];
                    } else {

                        int dist = int.MaxValue;
                        AntLoc antGuard = null;
                        foreach (var ant in state.MyAnts) {
                            if (state.distance (hill, ant) < dist) {
                                dist = state.distance (hill, ant);
                                antGuard = ant;
                            }
                        }
                        if (antGuard != null)
                        if (currentTurn.ContainsKey (antGuard))
                            currentTurn [antGuard] = Guard [hill];
                        else
                            currentTurn.Add (antGuard, Guard [hill]);
                    }
                }
            }
            #endregion
            /**/
            #if DEBUG
            sw.WriteLine("runs ANTS");
            #endif

            #region runs Ants
            oldTurn = new Dictionary<AntLoc, Location> ();

            foreach (AntLoc ant in currentTurn.Keys) {
                List<char > directions = state.direction_algor_A (ant, currentTurn [ant]);

                if (directions.Count == 0) {
                    //добавление препядствия
                    state.addAnt (ant.row, ant.col, 0);
                    #if DEBUG
                    sw.WriteLine (" ant " + ant + " stop ");
                    #endif
                } else {
                    AntLoc NewAnt = new AntLoc (state.destination (ant, directions [0]), 0);
                    //странно пытаемся переститься на своего муровья
                    if (!oldTurn.ContainsKey (NewAnt)) {
                        issueOrder (ant, directions [0]);
                        //добавление препядствия
                        state.addAnt (NewAnt.row, NewAnt.col, 0);
                        oldTurn.Add (NewAnt, currentTurn [ant]);
                        #if DEBUG
                        sw.WriteLine (" ant " + ant + " move " + NewAnt);
                        #endif
                    } else {
                        state.addAnt (ant.row, ant.col, 0);
                    }
                }/**/

                if (state.TimeRemaining < 50) {
                    return;
                }
            }
            #endregion
        }

        #endregion Methods
    }
}
 public override bool Apllicable(GameState state)
 {
     return state.FoodTiles.Count > 0;
 }
예제 #14
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        private void SetTurnStrategy(GameState state)
        {
            foreach (var a in state.MyAnts)
            {
                Log("ant loc: " + a);
            }
            Location mycenter = new Location(state,(int)Math.Round(state.MyAnts.Average(a => a.Row)), (int)Math.Round(state.MyAnts.Average(a => a.Col)));
            Log("ants center:" + mycenter);

            int totalfriends = state.MyAnts.Count;
            int closefriends = state.MyAnts.Count(a => state.GetDistance(a, mycenter) <= state.AttackRadius2 * CLOSE_FACTOR);
            Log("friends:" + totalfriends + "," + closefriends);

            int totalenemies = state.EnemyAnts.Count;
            int closeenemies = state.EnemyAnts.Count(a => state.GetDistance(a, mycenter) <= state.AttackRadius2 * CLOSE_FACTOR);
            Log("enemies:" + totalenemies + "," + closeenemies);

            int totalfood = state.FoodTiles.Count;
            int closefood = state.FoodTiles.Count(f => state.GetDistance(f, mycenter) <= state.AttackRadius2 * CLOSE_FACTOR);
            Log("food:" + totalfood + "," + closefood);

            if (closefood > 0 || totalfood > 0)
                AlterStrategy(Strategy.GatherFood, Preference.MildlyEncourage);
            else
            {
                AlterStrategy(Strategy.Scout, Preference.StronglyEncourage);
                AlterStrategy(Strategy.Scout, Preference.StronglyEncourage);
                AlterStrategy(Strategy.Scatter, Preference.StronglyEncourage);
                AlterStrategy(Strategy.SpreadOut, Preference.StronglyEncourage);
                AlterStrategy(Strategy.SpreadOut, Preference.StronglyEncourage);
            }

            if (closeenemies > closefriends)
            {
                AlterStrategy(Strategy.Fight, Preference.StronglyDiscourage);
                AlterStrategy(Strategy.Condense, Preference.MildlyEncourage);
                AlterStrategy(Strategy.Scatter, Preference.MildlyDiscourage);
                AlterStrategy(Strategy.Retreat, Preference.StronglyEncourage);
            }
            else if (closeenemies == closefriends && closeenemies > 0)
            {
                AlterStrategy(Strategy.Condense, Preference.StronglyEncourage);
                AlterStrategy(Strategy.Scatter, Preference.StronglyDiscourage);
                AlterStrategy(Strategy.Fight, Preference.MildlyEncourage);
            }
            else  //if (closeenemies < closefriends)
            {
                if (closeenemies > 0)
                {
                    AlterStrategy(Strategy.Fight, Preference.StronglyEncourage);
                    AlterStrategy(Strategy.Retreat, Preference.StronglyDiscourage);
                    AlterStrategy(Strategy.Condense, Preference.MildlyEncourage);
                    AlterStrategy(Strategy.Scatter, Preference.StronglyDiscourage);
                }
                else
                {
                    AlterStrategy(Strategy.Scout, Preference.MildlyEncourage);
                    AlterStrategy(Strategy.Condense, Preference.MildlyDiscourage);
                    AlterStrategy(Strategy.Scatter, Preference.MildlyEncourage);
                }
            }

            if (totalfriends < totalenemies && totalenemies > 0)
            {
                if (closefood > closeenemies)
                {
                    AlterStrategy(Strategy.GatherFood, Preference.StronglyEncourage);
                    AlterStrategy(Strategy.Fight, Preference.MildlyDiscourage);
                    AlterStrategy(Strategy.Retreat, Preference.MildlyDiscourage);
                    AlterStrategy(Strategy.Scatter, Preference.MildlyEncourage);
                }
                else
                {
                    AlterStrategy(Strategy.Scout, Preference.StronglyEncourage);
                    AlterStrategy(Strategy.Fight, Preference.MildlyDiscourage);
                    AlterStrategy(Strategy.Scatter, Preference.MildlyEncourage);
                }
            }
            else  //if (totalfriends > totalenemies)
            {
                if (totalenemies > 0)
                {
                    AlterStrategy(Strategy.Fight, Preference.StronglyEncourage);
                }
                AlterStrategy(Strategy.Scout, Preference.MildlyEncourage);
                AlterStrategy(Strategy.Scatter, Preference.MildlyEncourage);
            }
        }
예제 #15
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
 private Goal Scout(AntLoc ant, GameState state)
 {
     return SpreadOut(ant, state);
 }
예제 #16
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        private Goal Scatter(AntLoc ant, GameState state)
        {
            // wander aimlessly
            foreach (var d in Ants.Ants.Aim.Values.OrderBy(c => rng.Next()))
            {
                var loc = ant.GetDestination(d);
                if (loc.IsPassable())
                {

                    return new Goal(ant, GetPath(ant, loc, state), (s => state.FoodTiles.Any()), Strategy.Scatter);
                }
            }

            return null;
        }
예제 #17
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
 private Goal Retreat(AntLoc ant, GameState state)
 {
     return Condense(ant, state);
 }
예제 #18
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
 private double GetSearchRadius(GameState state)
 {
     return Math.Sqrt(state.Width * state.Height) / 15;
 }
예제 #19
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        private LinkedList<Tile> GetPath(Location loc1, Location loc2, GameState state)
        {
            if (Math.Abs(loc1.Col - loc2.Col) > state.ViewRadius2 || Math.Abs(loc1.Row - loc2.Row) > state.ViewRadius2)
            {
                Log("closest is a map wrap - use basic path function");
                return state.GetPath(loc1, loc2);

            }
            else
            {
                Log("use astar path function");
                return astar.Search(loc1.ToPoint(), loc2.ToPoint(), new Object());
            }
        }
예제 #20
0
        // parse initial input and setup starting game state
        private void ParseSetup(List<string> input)
        {
            int width = 0, height = 0;
            int turntime = 0, loadtime = 0;
            int playerSeed = 0;
            int viewradius2 = 0, attackradius2 = 0, spawnradius2 = 0;

            foreach (string line in input) {
                if (string.IsNullOrEmpty (line))
                    continue;

                string[] tokens = line.Split();
                string key = tokens[0];

                switch (key)
                {
                case "cols":
                    width = int.Parse(tokens[1]);
                    break;
                case "rows":
                    height = int.Parse(tokens[1]);
                    break;
                case "player_seed":
                    playerSeed = int.Parse(tokens[1]);
                    break;
                case "turntime":
                    turntime = int.Parse(tokens[1]);
                    break;
                case "loadtime":
                    loadtime = int.Parse(tokens[1]);
                    break;
                case "viewradius2":
                    viewradius2 = int.Parse(tokens[1]);
                    break;
                case "attackradius2":
                    attackradius2 = int.Parse(tokens[1]);
                    break;
                case "spawnradius2":
                    spawnradius2 = int.Parse(tokens[1]);
                    break;
                }
            }

            this.state = new GameState(width, height,
                                       turntime, loadtime,
                                       viewradius2, attackradius2, spawnradius2, playerSeed);
        }
예제 #21
0
 public override bool Apllicable(GameState state)
 {
     return true;
 }
예제 #22
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        private Goal SpreadOut(AntLoc ant, GameState state)
        {
            if (state.TimeRemaining < 10)
                return Scatter(ant, state);
            // try and figure out how close to the edge of vision I am
            var x = ant.Col;
            var y = ant.Row;

            var minX = state.MyAnts.Min(a => a.Col);
            var maxX = state.MyAnts.Max(a => a.Col);
            var minY = state.MyAnts.Min(a => a.Row);
            var maxY = state.MyAnts.Max(a => a.Row);

            var widthModifier = state.Width / 30;
            if (widthModifier <= 1)
                widthModifier = 2;
            var heightModifier = state.Height / 30;
            if (heightModifier <= 1)
                heightModifier = 2;

            Func<GameState, bool> terminationFunc = (s => false);

            Log("spread out: minx:" + minX + " miny:" + minY + " maxx:" + maxX + " maxy:" + maxY + " widthmod:" + widthModifier + " heightmod:" + heightModifier);
            // near the left (ish)
            if (x < ( minX + widthModifier))
            {
                var loc = new Location(state,y,x-widthModifier); //move left
                Log("left, path :" + ant + " " + loc);
                var path = GetPath(ant, loc, state);
                if (path != null)
                {
                    return new Goal(ant, path, terminationFunc, Strategy.SpreadOut);
                }
            }
            else if (x > ( maxX - widthModifier ))
            {
                var loc = new Location(state, y,x + widthModifier); //move right
                Log("right, path :" + ant + " " + loc);
                var path = GetPath(ant, loc, state);
                if (path != null)
                {
                    return new Goal(ant, path, terminationFunc, Strategy.SpreadOut);
                }
            }
            else if (y < ( maxY + heightModifier ))
            {
                var loc = new Location(state,  y - heightModifier,x); //move up
                Log("top, path :" + ant + " " + loc);
                var path = GetPath(ant, loc, state);
                if (path != null)
                {
                    return new Goal(ant, path, terminationFunc, Strategy.SpreadOut);
                }
            }
            else if (y > ( maxY - heightModifier ))
            {
                var loc = new Location(state,  y + heightModifier,x); // move down
                Log("bottom, path :" + ant + " " + loc);
                var path = GetPath(ant, loc, state);
                if (path != null)
                {
                    return new Goal(ant, path, terminationFunc, Strategy.SpreadOut);
                }
            }

            return Scatter(ant,state);
        }
예제 #23
0
파일: Ants.cs 프로젝트: Lapixx/CS-UU-KI2
        // parse initial input and setup starting game state
        private void ParseSetup(List<string> input)
        {
            int width = 0, height = 0;
            int turntime = 0, loadtime = 0;
            int viewradius2 = 0, attackradius2 = 0, spawnradius2 = 0;

            foreach (string line in input) {
                if (line.Length <= 0) continue;

                string[] tokens = line.Split();
                string key = tokens[0];

                if (key.Equals(@"cols")) {
                    width = int.Parse(tokens[1]);
                } else if (key.Equals(@"rows")) {
                    height = int.Parse(tokens[1]);
                } else if (key.Equals(@"seed")) {
                    ;
                } else if (key.Equals(@"turntime")) {
                    turntime = int.Parse(tokens[1]);
                } else if (key.Equals(@"loadtime")) {
                    loadtime = int.Parse(tokens[1]);
                } else if (key.Equals(@"viewradius2")) {
                    viewradius2 = int.Parse(tokens[1]);
                } else if (key.Equals(@"attackradius2")) {
                    attackradius2 = int.Parse(tokens[1]);
                } else if (key.Equals(@"spawnradius2")) {
                    spawnradius2 = int.Parse(tokens[1]);
                }
            }

            this.state = new GameState(width, height,
                                       turntime, loadtime,
                                       viewradius2, attackradius2, spawnradius2);
        }
예제 #24
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        public override void doTurn(GameState state)
        {
            try
            {
                if (state.TimeRemaining < 5)
                    return;

                if (turn == 0)
                {
                    Log("my team: player " + (state.MyAnts.First().Team + 1));
                    Log("map " + state.Width+"x"+state.Height);
                    Log("turn time " + state.TurnTime);
                }
                Log("");
                Log("Turn " + (turn++));
                Log("My Ants: " + state.MyAnts.Count);

                SetTurnStrategy(state);

                string stratstring = "";

                foreach (var v in Enum.GetValues(typeof(Strategy)))
                {
                    stratstring += Enum.GetName(typeof(Strategy), v) + ":" + strategies[(int)v] + ";";
                }

                Log("Strategy: " + stratstring);

                this.Destinations.Clear();

                astar = new SpatialAStar<Tile, object>(state.Map);

                foreach (var goal in Goals)
                    goal.AntExists = false; //need to check these each turn and clean up if ant gone

                foreach (AntLoc ant in state.MyAnts)
                {
                    Log("ant: " + ant);
                    Goal goal = this.Goals.FirstOrDefault(g => g.CurrentPoint.Equals(ant));

                    if (goal != null && (goal.CurrentPath.Count==0 || goal.IsTerminated(state)))
                    {
                        if (goal.CurrentPath.Count == 0)
                            Log("ant goal complete");
                        else
                            Log("ant goal terminated");
                        Goals.Remove(goal);
                        goal = null;
                    }
                    if (goal != null)
                    {
                        goal.AntExists = true;
                        Log("ant existing goal: " + String.Join(";", goal.CurrentPath.Select(p => p.Location.ToString()).ToArray()) + " " + Enum.GetName(typeof(Strategy), goal.CurrentStrategy));
                    }
                    else
                    {
                        if (state.TimeRemaining < 50) // choose a fast strategy
                        {
                            Log("short on time ("+state.TimeRemaining+") - choose scatter");
                            goal = Scatter(ant, state);
                        }
                        else
                        {

                            goal = ChooseStrategy(ant, state);
                            if (!goal.CurrentPath.Any())
                            {
                                Log("bad goal/path - scatter instead");
                                goal = Scatter(ant, state);
                            }
                        }
                        Goals.Add(goal);
                        Log("new ant goal: " + String.Join(";", goal.CurrentPath.Select(p => p.Location.ToString()).ToArray()) + " " + Enum.GetName(typeof(Strategy), goal.CurrentStrategy));

                    }

                    if (goal != null)
                    {
                        var loc = goal.CurrentPath.Dequeue();
                        var directions = ant.GetDirections(loc.Location);

                        foreach (var d in directions)
                        {
                            var newLoc = ant.GetDestination(d);
                            if (state.IsUnoccupied(newLoc) && state.IsPassable(newLoc) && !Destinations.Contains(newLoc))
                            {
                                ant.Move(d);
                                goal.CurrentPoint = newLoc;
                                goal.CurrentStep++;
                                Destinations.Add(newLoc);
                                break;
                            }
                        }
                    }
                }
                int removed = Goals.RemoveAll(g => !g.AntExists);//clean up goals for missing ants

                Log("ant goals(" + Goals.Count + ", "+removed+" removed): " + String.Join(";", Goals.Select(g => "["+Enum.GetName(typeof(Strategy),g.CurrentStrategy)+"]"+g.CurrentPoint.ToString()+"->"+g.EndPoint.ToString()).ToArray()));
                if (removed > 0) // losing fights - condense
                {
                    AlterStrategy(Strategy.Condense, Preference.StronglyEncourage);
                    AlterStrategy(Strategy.Condense, Preference.StronglyEncourage);
                    AlterStrategy(Strategy.Condense, Preference.StronglyEncourage);
                }
            }
            catch (Exception exc)
            {
                Log(exc.Message);
                Log(exc.StackTrace);
            }
        }
예제 #25
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        private Goal ChooseStrategy(AntLoc ant, GameState state)
        {
            Strategy? strat = null;
            float rnd = rng.Next(0, (int)(strategies.Sum()*100)) * .01f;

            for (int i = 1; i < STRAT_COUNT; i++)
            {
                if (rnd < strategies.Take(i).Sum())
                {
                    strat =  (Strategy)(i - 1);
                    break;
                }
            }

            if(strat==null)
                strat = (Strategy)(STRAT_COUNT - 1);

            Goal goal = null;

            if (strat == Strategy.GatherFood)
                goal = GatherFood(ant, state);
            else if (strat == Strategy.Fight)
                goal = Fight(ant, state);
            else if (strat == Strategy.SpreadOut)
                goal = SpreadOut(ant, state);
            else if (strat == Strategy.Scatter)
                goal = Scatter(ant, state);
            else if (strat == Strategy.Scout)
                goal = Scout(ant, state);
            else if (strat == Strategy.Condense)
                goal = Condense(ant, state);
            else if (strat == Strategy.Retreat)
                goal = Retreat(ant, state);

            if (goal == null)
            {
                goal = GatherFood(ant, state);
            }
            if (goal == null)
            {
                goal = Scout(ant, state);
            }
            if (goal == null)
            {
                goal = Fight(ant, state);
            }
            if (goal == null)
            {
                goal = SpreadOut(ant, state);
            }
            if (goal == null)
            {
                goal = Scatter(ant, state);
            }
            if (goal == null)
            {
                goal = Condense(ant, state);
            }
            if (goal == null)
            {
                goal = Retreat(ant, state);
            }

            return goal;
        }
예제 #26
0
        private void CalculateReward(GameState state)
        {
            int result = 0;
            result += MyAnts.Count * 100;
            result += visibleTiles + visitedTiles;

            float foodClaimed = 0f;
            float longestDistanceToFood = 0f;

            foreach (Location food in Food)//calculates how many food bits we can gather, and how far the furthest one is
            {
                if (foodClaimed >= MyAnts.Count)
                    break;

                int leastDistance = int.MaxValue;
                Location closestAnt = null;

                foreach (Location ant in MyAnts)
                {
                    int distance = Globals.pathFinder.FindRoute(ant, food).GetDistance;

                    if (distance < leastDistance)
                    {
                        leastDistance = distance;
                        closestAnt = ant;
                    }
                }

                foodClaimed++;

                if (longestDistanceToFood < leastDistance)
                    longestDistanceToFood = leastDistance;
            }

            int expectedAntGain = (int)Math.Ceiling(foodClaimed / longestDistanceToFood);

            result += expectedAntGain * 10;

            Reward = result;
        }
예제 #27
0
 public abstract void DoTurn(GameState state);
예제 #28
0
        /// <summary>
        /// Calculate the current diffusion scores for layer 1.
        /// </summary>
        /// <param name="state">The state.</param>
        public void diffuseOne(GameState state)
        {
            for (int row = 0; row < state.Height; row++)
            {
                for (int col = 0; col < state.Width; col++)
                {
                    if (state.map[row, col] == Tile.Water)
                    {
                        state.diffusionOne[row, col] = WATER_SCORE;
                    }

                    else if (state.map[row, col] == Tile.Ant)
                    {
                        state.diffusionOne[row, col] = MY_ANT_SCORE_D1;

                        Location location = new Location(row, col);
                        if (state.ants.ContainsKey(location))
                        {
                            Ant ant = state.ants[location];

                            if (ant.Team != 0)
                            {
                                List<AntHill> myHills = state.MyHills;
                                foreach (AntHill myHill in myHills)
                                {
                                    if (state.GetDistance(myHill, ant) <= 12)
                                    {
                                        state.diffusionOne[row, col] = HILL_IN_DANGER;

                                        break;
                                    }
                                }
                            }
                        }
                    }
                    else if (state.map[row, col] == Tile.Food)
                    {
                        state.diffusionOne[row, col] = FOOD_SCORE_D1;
                    }
                    else if (state.map[row, col] == Tile.Unseen)
                    {
                        state.diffusionOne[row, col] = UNSEEN_SCORE_D1;
                    }
                    else if (state.isEnemyHill(row, col))
                    {
                        state.diffusionOne[row, col] = ENEMYHILL_SCORE_D1;
                    }
                    else if (state.isMyHill(row, col))
                    {
                        state.diffusionOne[row, col] = MYHILL_SCORE;
                    }
                    else
                    {
                        double u = state.diffusionOne[row, col];
                        Location L = new Location(row, col);
                        Location up = state.GetDestination(L, Direction.North);
                        Location right = state.GetDestination(L, Direction.East);
                        Location left = state.GetDestination(L, Direction.West);
                        Location down = state.GetDestination(L, Direction.South);
                        state.diffusionOne[row, col] = u + D1_COEFFICIENT * (1
                                                     + state.diffusionOne[up.Row, up.Col]
                                                     + state.diffusionOne[down.Row, down.Col]
                                                     + state.diffusionOne[left.Row, left.Col]
                                                     + state.diffusionOne[right.Row, right.Col]
                                                     - u * 4);
                    }
                }
            }
        }
예제 #29
0
 public abstract void LastTurn(GameState state, bool won);
예제 #30
0
파일: MyBot.cs 프로젝트: aaronm67/AntsRepo
        private Goal Fight(AntLoc ant, GameState state)
        {
            if (!state.EnemyAnts.Any())
                return Scout(ant, state);

            // look for some food
            var searchingspots = state.EnemyAnts.Where(f => Goals.Count(g => g.EndPoint.Equals(f)) <= 1);
            //searchingspots = searchingspots.Where(f => f.GetDistance(ant) < GetSearchRadius(state)).OrderBy(f => f.GetDistance(ant)).Take(2);
            var antpoint = ant.ToPoint();
            var enemypoints = searchingspots.Select(f => new
            {
                Tile = f,
                Point = f.ToPoint(),
                Distance = state.GetDistance(ant,f)//astar.Search(ant.ToPoint(), f.ToPoint(), new Object()) ?? Enumerable.Empty<Tile>()
            });

            var closest = enemypoints.OrderBy(f => f.Distance).FirstOrDefault();

            if (closest != null)
            {
                var goal = new Goal(closest.Tile, GetPath(ant, closest.Tile, state), (g => g.IsUnoccupied(closest.Tile)), Strategy.Fight);
                return goal;
            }

            return SpreadOut(ant, state);
        }