Commit: baa4ee3f812d338a411aef0666213d8176e342eb - CedecAI2013 (git)

CEDEC AI 2013 の決勝で使用したプログラムのソースコード。

Commit MetaInfo

• Revisão: baa4ee3f812d338a411aef0666213d8176e342eb (tree)
• Hora: 2013-08-15 18:48:30
• Autor: B_head <b_head@user...>
• Commiter: B_head

Mensagem de Log

オーダーシステム作成。

Signed-off-by: B_head <[e-mail]>

Mudança Sumário

• modified: CedecAI.v11.suo
• add: Common/ColonizeAI.cs
• modified: Common/Common.cs
• modified: Common/Common.csproj
• add: Common/CompanyAI.cs
• add: Common/DispositionRobot.cs
• add: Common/DistanceMap.cs
• add: Common/EvaluateGround.cs
• modified: Common/ExamineFunction.cs
• modified: Common/Field.cs
• modified: Common/GameField.cs
• add: Common/GovernAI.cs
• add: Common/InvadeAI.cs
• add: Common/KamikazeAI.cs
• add: Common/Orders.cs
• add: Common/SearchNearRobot.cs
• modified: Common/TestAI.cs
• modified: Production/App.config
• modified: Production/LinkGameField.cs
• modified: Production/Production.csproj
• modified: Production/Program.cs
• modified: Visualizer/GameManager.cs
• modified: Visualizer/GenerateGameField.cs
• modified: Visualizer/MainWindow.xaml
• modified: Visualizer/MainWindow.xaml.cs
• modified: Visualizer/MassInformation.xaml.cs

Diff

Binary files a/CedecAI.v11.suo and b/CedecAI.v11.suo differ

--- /dev/null
+++ b/Common/ColonizeAI.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    class ColonizeAI
+    {
+    }
+}

--- a/Common/Common.cs
+++ b/Common/Common.cs
@@ -15,6 +15,12 @@ namespace Common
         public int WaitRobot;
     }
 
+    public struct IntPoint
+    {
+        public int X;
+        public int Y;
+    }
+
     public enum Terrain
     {
         Outside,
@@ -31,22 +37,27 @@ namespace Common
 
     public enum Direction
     {
+        Center,
         Right,
-        UpperRight,
         DownerRight,
+        DownerLeft,
         Left,
         UpperLeft,
-        DownerLeft,
+        UpperRight,
     }
 
     public interface GameAI
     {
         string Prepare(int player, GameField field);
-        void Think(int turn, int maxTurn, int player, GameField field, Commander com);
+        void Think(int turn, int maxTurn, int player, GameField field, Commander commander);
     }
 
     public interface Commander
     {
+        bool IsMove { get; }
+        bool IsBuild { get; }
+        bool IsFinish { get; }
+        int Player { get; }
         void Move(int x, int y, Direction dir, int robot);
         void Build(int x, int y, Terrain building);
         void Finish();

--- a/Common/Common.csproj
+++ b/Common/Common.csproj
@@ -11,7 +11,7 @@
     <AssemblyName>Common</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -39,10 +39,16 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Common.cs" />
+    <Compile Include="DispositionRobot.cs" />
+    <Compile Include="DistanceMap.cs" />
     <Compile Include="ExamineFunction.cs" />
     <Compile Include="GameField.cs" />
     <Compile Include="Field.cs" />
+    <Compile Include="KamikazeAI.cs" />
+    <Compile Include="Orders.cs" />
+    <Compile Include="EvaluateGround.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SearchNearRobot.cs" />
     <Compile Include="TestAI.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

--- /dev/null
+++ b/Common/CompanyAI.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    class CompanyAI
+    {
+    }
+}

--- /dev/null
+++ b/Common/DispositionRobot.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    public class DispositionRobot
+    {
+        public readonly int Player;
+        List<Order> orders;
+
+        public DispositionRobot(int player)
+        {
+            Player = player;
+            orders = new List<Order>();
+        }
+
+        public Order this[int index]
+        {
+            get
+            {
+                return orders[index];
+            }
+        }
+
+        public void AddMoveOrder(int priority, int x, int y, int robot, bool once)
+        {
+            OrderMove temp = new OrderMove(priority, x, y, robot, once);
+            orders.Add(temp);
+        }
+
+        public void AddBuildOrder(int priority, int x, int y, Terrain building)
+        {
+            OrderBuild temp = new OrderBuild(priority, x, y, building);
+            orders.Add(temp);
+        }
+
+        public void Clear()
+        {
+            orders.Clear();
+        }
+
+        public void Dispose(GameField field, Commander commander)
+        {
+            orders.Sort();
+            for (int i = orders.Count - 1; i >= 0; i--)
+            {
+                if (orders[i].Execute(field, commander))
+                {
+                    orders.RemoveAt(i);
+                }
+            }
+            commander.Finish();
+        }
+    }
+}

--- /dev/null
+++ b/Common/DistanceMap.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    public class DistanceMap : Field<byte>
+    {
+        readonly GameField gameField;
+        public const byte Impossible = byte.MaxValue;
+
+        public DistanceMap(GameField gameField, int player, int x, int y)
+            : base(gameField.Width, gameField.Height)
+        {
+            this.gameField = gameField;
+            Initalize();
+            Investigate(0, player, x, y);
+        }
+
+        private void Initalize()
+        {
+            for (int x = 0; x < Width; x++)
+            {
+                for (int y = 0; y < Height; y++)
+                {
+                    field[x, y] = Impossible;
+                }
+            }
+        }
+
+        private void Investigate(byte distanse, int player, int x, int y)
+        {
+            if (!IsInRange(x, y)) return;
+            if (field[x, y] <= distanse) return;
+            if (gameField[x, y].Ter == Terrain.Outside) return;
+            if (gameField[x, y].Player != player && 
+                gameField[x, y].Ter != Terrain.Wasteland && gameField[x, y].Ter != Terrain.Hole) return;
+            if (gameField[x, y].Ter == Terrain.Hole && distanse > 0) return;
+            field[x, y] = distanse;
+            int tx, ty;
+            for (int i = 1; i < 7; i++)
+            {
+                TransformDirection(i, x, y, out tx, out ty);
+                Investigate((byte)(distanse + 1), player, tx, ty);
+            }
+        }
+
+        public Direction ApproachTerget(int x, int y)
+        {
+            int tx, ty;
+            for (int i = 1; i < 7; i++)
+            {
+                if (TransformDirection(i, x, y, out tx, out ty)) continue;
+                if (gameField[tx, ty].Ter == Terrain.Hole && field[tx, ty] != 0) continue;
+                if (field[x, y] - 1 == field[tx, ty])
+                {
+                    return (Direction)i;
+                }
+            }
+            return Direction.Center;
+        }
+    }
+}

--- /dev/null
+++ b/Common/EvaluateGround.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    public class EvaluateGround : Field<byte>
+    {
+        GameField gameField;
+        public const byte Obstacle = byte.MaxValue;
+
+        public EvaluateGround(GameField gameField)
+            : base(gameField.Width, gameField.Height)
+        {
+            this.gameField = gameField;
+            Initalize();
+            AllEvaluate();
+        }
+
+        private void Initalize()
+        {
+            for (int x = 0; x < Width; x++)
+            {
+                for (int y = 0; y < Height; y++)
+                {
+                    if (gameField[x, y].Ter != Terrain.Wasteland)
+                    {
+                        field[x, y] = Obstacle;
+                    }
+                }
+            }
+        }
+
+        private void AllEvaluate()
+        {
+            for (int x = 0; x < Width; x++)
+            {
+                for (int y = 0; y < Height; y++)
+                {
+                    if (field[x, y] == Obstacle) continue;
+                    field[x, y] = (byte)Evaluate(x, y);
+                }
+            }
+        }
+
+        private int Evaluate(int x, int y)
+        {
+            int result = 0, tx, ty;
+            for (int i = 0; i < 12; i++)
+            {
+                if (TransformSitePropose(i, x, y, out tx, out ty)) continue;
+                if (!PertEvaluate(tx, ty)) continue;
+                if(i <6)
+                {
+                    result += 2;
+                }
+                else
+                {
+                    result += 3;
+                }
+            }
+            return result;
+        }
+
+        private bool PertEvaluate(int x, int y)
+        {
+            int tx, ty;
+            for (int i = 0; i < 7; i++)
+            {
+                if (TransformDirection(i, x, y, out tx, out ty)) return false;
+                if (field[tx, ty] == Obstacle) return false;
+            }
+            return true;
+        }
+
+        public bool TransformSitePropose(int i, int x, int y, out int tx, out int ty)
+        {
+            tx = x;
+            ty = y;
+            switch (i)
+            {
+                case 0: tx += 1; ty += 0; break;
+                case 1: tx += 1; ty += -1; break;
+                case 2: tx += 0; ty += 1; break;
+                case 3: tx += -1; ty += 0; break;
+                case 4: tx += -1; ty += 1; break;
+                case 5: tx += 0; ty += -1; break;
+                case 6: tx += 1; ty += 1; break;
+                case 7: tx += -1; ty += 2; break;
+                case 8: tx += -2; ty += 1; break;
+                case 9: tx += -1; ty += -1; break;
+                case 10: tx += 1; ty += -2; break;
+                case 11: tx += 2; ty += -1; break;
+                default: throw new Exception();
+            }
+            return !IsInRange(tx, ty);
+        }
+    }
+}

--- a/Common/ExamineFunction.cs
+++ b/Common/ExamineFunction.cs
@@ -13,8 +13,7 @@ namespace Common
             int result = 0, tx, ty;
             for (int i = 1; i < 13; i++)
             {
-                field.TransformTowerRange(i, x, y, out tx, out ty);
-                if (field.IsInRange(tx, ty)) continue;
+                if (field.TransformTowerRange(i, x, y, out tx, out ty)) continue;
                 if (field[tx, ty].Ter != Terrain.AttackTower) continue;
                 if (field[tx, ty].Player == player) continue;
                 result += 2;

--- a/Common/Field.cs
+++ b/Common/Field.cs
@@ -29,12 +29,35 @@ namespace Common
 
         public bool IsInRange(int x, int y)
         {
-            return x < 0 || x >= Width || y < 0 || y >= Height;
+            return x >= 0 && x < Width && y >= 0 && y < Height;
         }
 
         public void CopyTo(Field<TYPE> other)
         {
             Array.Copy(field, other.field, Width * Height);
         }
+
+        public bool TransformDirection(int dir, int x, int y, out int tx, out int ty)
+        {
+            return TransformDirection((Direction)dir, x, y, out tx, out ty);
+        }
+
+        public bool TransformDirection(Direction dir, int x, int y, out int tx, out int ty)
+        {
+            tx = x;
+            ty = y;
+            switch (dir)
+            {
+                case Direction.Center: tx += 0; ty += 0; break;
+                case Direction.Right: tx += 1; ty += 0; break;
+                case Direction.UpperRight: tx += 1; ty += -1; break;
+                case Direction.DownerRight: tx += 0; ty += 1; break;
+                case Direction.Left: tx += -1; ty += 0; break;
+                case Direction.DownerLeft: tx += -1; ty += 1; break;
+                case Direction.UpperLeft: tx += 0; ty += -1; break;
+                default: throw new Exception();
+            }
+            return !IsInRange(tx, ty);
+        }
     }
 }

--- a/Common/GameField.cs
+++ b/Common/GameField.cs
@@ -39,12 +39,13 @@ namespace Common
             }
         }
 
-        public bool Move(int player, int fromX, int fromY, Direction dir, int robot)
+        public bool Move(int fromX, int fromY, Direction dir, int robot)
         {
-            if (!IsMove(player, fromX, fromY, dir, robot)) return false;
+            if (!IsMove(fromX, fromY, dir, robot)) return false;
             int toX, toY;
             TransformDirection(dir, fromX, fromY, out toX, out toY);
             GameMass from = field[fromX, fromY], to = field[toX, toY];
+            int player = from.Player;
             if (to.Player == player)
             {
                 from.ActiveRobot -= robot;
@@ -68,14 +69,13 @@ namespace Common
             return true;
         }
 
-        public bool IsMove(int player, int fromX, int fromY, Direction dir, int robot)
+        public bool IsMove(int fromX, int fromY, Direction dir, int robot)
         {
             if (robot <= 0) return false;
             int toX, toY;
-            TransformDirection(dir, fromX, fromY, out toX, out toY);
-            if (IsInRange(toX, toY)) return false;
+            if (TransformDirection(dir, fromX, fromY, out toX, out toY)) return false;
             GameMass from = field[fromX, fromY], to = field[toX, toY];
-            if (from.Player != player) return false;
+            int player = from.Player;
             if (from.ActiveRobot < robot) return false;
             if (from.Ter == Terrain.Hole) return false;
             if (to.Player == player)
@@ -89,23 +89,30 @@ namespace Common
             return true;
         }
 
-        public bool Build(int player, int x, int y, Terrain building, ref int extraPoint)
+        public bool Build(int x, int y, Terrain building, ref int extraPoint)
         {
-            if (!IsBuild(player, x, y, building)) return false;
+            if (!IsBuild(x, y, building)) return false;
             int resource, robot;
             GetRequirement(building, out resource, out robot);
             if (building == Terrain.Town)
             {
                 extraPoint += GetPrepareResource(x, y) - resource;
+                int tx, ty, player = field[x,y].Player;
+                for (int i = 1; i < 7; i++)
+                {
+                    if (TransformDirection(i, x, y, out tx, out ty)) continue;
+                    if (field[tx, ty].Player != player) continue;
+                    if (field[tx, ty].Ter != Terrain.Wasteland) continue;
+                    field[tx, ty].Ter = Terrain.House;
+                }
             }
             field[x, y].ActiveRobot -= robot;
             field[x, y].Ter = building;
             return true;
         }
 
-        public bool IsBuild(int player, int x, int y, Terrain building)
+        public bool IsBuild(int x, int y, Terrain building)
         {
-            if (field[x, y].Player != player) return false;
             if (field[x, y].Ter != Terrain.Wasteland && field[x, y].Ter != Terrain.Hole) return false;
             if (field[x, y].Ter == Terrain.Wasteland && building == Terrain.Bridge) return false;
             if (field[x, y].Ter == Terrain.Hole && building != Terrain.Bridge) return false;
@@ -215,10 +222,9 @@ namespace Common
         {
             if (field[x, y].Player == player) return 0;
             int result = 0, tx, ty;
-            for (int i = 1; i < 13; i++)
+            for (int i = 0; i < 12; i++)
             {
-                TransformTowerRange(i, x, y, out tx, out ty);
-                if (IsInRange(tx, ty)) continue;
+                if (TransformTowerRange(i, x, y, out tx, out ty)) continue;
                 if (field[tx, ty].Ter != Terrain.AttackTower) continue;
                 if (field[tx, ty].Player != player) continue;
                 result += 2;
@@ -231,8 +237,7 @@ namespace Common
             int result = 0, player = field[x, y].Player, tx, ty;
             for (int i = 0; i < 7; i++)
             {
-                TransformAdjoin(i, x, y, out tx, out ty);
-                if (IsInRange(tx, ty)) continue;
+                if (TransformDirection(i, x, y, out tx, out ty)) continue;
                 if (field[tx, ty].Player != player) continue;
                 result += GetYieldResource(tx, ty);
             }
@@ -245,8 +250,7 @@ namespace Common
             int result = 1, player = field[x, y].Player, tx, ty;
             for (int i = 1; i < 7; i++)
             {
-                TransformAdjoin(i, x, y, out tx, out ty);
-                if (IsInRange(tx, ty)) continue;
+                if (TransformDirection(i, x, y, out tx, out ty)) continue;
                 if (field[tx, ty].Player != player) continue;
                 if (field[tx, ty].Ter != Terrain.Excavator) continue;
                 result++;
@@ -254,60 +258,27 @@ namespace Common
             return result;
         }
 
-        public void TransformDirection(Direction dir, int x, int y, out int tx, out int ty)
-        {
-            tx = x;
-            ty = y;
-            switch (dir)
-            {
-                case Direction.Right: tx += 1; ty += 0; break;
-                case Direction.UpperRight: tx += 1; ty += -1; break;
-                case Direction.DownerRight: tx += 0; ty += 1; break;
-                case Direction.Left: tx += -1; ty += 0; break;
-                case Direction.DownerLeft: tx += -1; ty += 1; break;
-                case Direction.UpperLeft: tx += 0; ty += -1; break;
-                default: throw new Exception();
-            }
-        }
-
-        public void TransformAdjoin(int i, int x, int y, out int tx, out int ty)
-        {
-            tx = x;
-            ty = y;
-            switch (i)
-            {
-                case 0: tx += 0; ty += 0; break;
-                case 1: tx += 1; ty += 0; break;
-                case 2: tx += 1; ty += -1; break;
-                case 3: tx += 0; ty += 1; break;
-                case 4: tx += -1; ty += 0; break;
-                case 5: tx += -1; ty += 1; break;
-                case 6: tx += 0; ty += -1; break;
-                default: throw new Exception();
-            }
-        }
-
-        public void TransformTowerRange(int i, int x, int y, out int tx, out int ty)
+        public bool TransformTowerRange(int i, int x, int y, out int tx, out int ty)
         {
             tx = x;
             ty = y;
             switch (i)
             {
-                case 0: tx += 0; ty += 0; break;
-                case 1: tx += 1; ty += 0; break;
-                case 2: tx += 1; ty += -1; break;
-                case 3: tx += 0; ty += 1; break;
-                case 4: tx += -1; ty += 0; break;
-                case 5: tx += -1; ty += 1; break;
-                case 6: tx += 0; ty += -1; break;
-                case 7: tx += 2; ty += 0; break;
-                case 8: tx += 2; ty += -2; break;
-                case 9: tx += 0; ty += 2; break;
-                case 10: tx += -2; ty += 0; break;
-                case 11: tx += -2; ty += 2; break;
-                case 12: tx += 0; ty += -2; break;
+                case 0: tx += 1; ty += 0; break;
+                case 1: tx += 1; ty += -1; break;
+                case 2: tx += 0; ty += 1; break;
+                case 3: tx += -1; ty += 0; break;
+                case 4: tx += -1; ty += 1; break;
+                case 5: tx += 0; ty += -1; break;
+                case 6: tx += 2; ty += 0; break;
+                case 7: tx += 2; ty += -2; break;
+                case 8: tx += 0; ty += 2; break;
+                case 9: tx += -2; ty += 0; break;
+                case 10: tx += -2; ty += 2; break;
+                case 11: tx += 0; ty += -2; break;
                 default: throw new Exception();
             }
+            return !IsInRange(tx, ty);
         }
     }
 }

--- /dev/null
+++ b/Common/GovernAI.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    class GovernAI
+    {
+    }
+}

--- /dev/null
+++ b/Common/InvadeAI.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    class InvadeAI
+    {
+    }
+}

--- /dev/null
+++ b/Common/KamikazeAI.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    public class KamikazeAI : GameAI
+    {
+        DispositionRobot disposition;
+
+        public string Prepare(int player, GameField field)
+        {
+            disposition = new DispositionRobot(player);
+            return "B_head:KamikazeAI";
+        }
+
+        public void Think(int turn, int maxTurn, int player, GameField field, Commander commander)
+        {
+            int w = field.Width, h = field.Height;
+            for (int x = 0; x < w; x++)
+            {
+                for (int y = 0; y < h; y++)
+                {
+                    if (field[x, y].Player != player && field[x, y].Ter == Terrain.Wasteland)
+                    {
+                        disposition.AddMoveOrder(-field[x, y].WaitRobot, x, y, field[x, y].WaitRobot + 1, true);
+                    }
+                }
+            }
+            disposition.Dispose(field, commander);
+        }
+    }
+}

--- /dev/null
+++ b/Common/Orders.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+    public abstract class Order : IComparable<Order>
+    {
+        int priority;
+
+        public Order(int priority)
+        {
+            this.priority = priority;
+        }
+
+        public abstract bool Execute(GameField field, Commander commander);
+
+        protected bool IsForbidMove(Commander commander)
+        {
+            return commander.IsBuild || commander.IsFinish;
+        }
+
+        protected bool IsForbidBuild(Commander commander)
+        {
+            return commander.IsMove || commander.IsBuild || commander.IsFinish;
+        }
+
+        protected void NearRobotMove(int x, int y, int robot, GameField field, Commander commander)
+        {
+            SearchNearRobot search = new SearchNearRobot(field, commander.Player, x, y);
+            int moveCount = 0, tx, ty;
+            Direction dir;
+            while (moveCount < robot)
+            {
+                if (search.Next(out tx, out ty, out dir)) break;
+                int moveRobot = Math.Min(field[tx, ty].ActiveRobot, robot - moveCount);
+                field.Move(tx, ty, dir, moveRobot);
+                if (dir != Direction.Center)
+                {
+                    commander.Move(tx, ty, dir, moveRobot);
+                }
+                moveCount += moveRobot;
+            }
+        }
+
+        public int CompareTo(Order other)
+        {
+            return priority - other.priority;
+        }
+    }
+
+    public class OrderMove : Order
+    {
+        int x;
+        int y;
+        int robot;
+        bool once;
+
+        public OrderMove(int priority, int x, int y, int robot, bool once)
+            : base(priority)
+        {
+            this.x = x;
+            this.y = y;
+            this.robot = robot;
+            this.once = once;
+        }
+
+        public override bool Execute(GameField field, Commander commander)
+        {
+            if (IsForbidMove(commander)) return once;
+            NearRobotMove(x, y, robot, field, commander);
+            return once;
+        }
+    }
+
+    public class OrderBuild : Order
+    {
+        int x;
+        int y;
+        Terrain building;
+
+        public OrderBuild(int priority, int x, int y, Terrain building)
+            : base(priority)
+        {
+            this.x = x;
+            this.y = y;
+            this.building = building;
+        }
+
+        public override bool Execute(GameField field, Commander commander)
+        {
+            if (!IsForbidBuild(commander) || field.IsBuild(x, y, building))
+            {
+                commander.Build(x, y, building);
+                return true;
+            }
+            if (IsForbidMove(commander)) return false;
+            int resource, robot;
+            field.GetRequirement(building, out resource, out robot);
+            NearRobotMove(x, y, robot, field, commander);
+            return false;
+        }
+    }
+}

--- /dev/null
+++ b/Common/SearchNearRobot.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Common
+{
+
+    public class SearchNearRobot
+    {
+        Queue<IntPoint> queue;
+        GameField field;
+        DistanceMap distance;
+        int player;
+
+        public SearchNearRobot(GameField field, int player, int x, int y)
+        {
+            queue = new Queue<IntPoint>();
+            queue.Enqueue(new IntPoint { X = x, Y = y });
+            this.field = field;
+            distance = new DistanceMap(field, player, x, y);
+            this.player = player;
+        }
+
+        //todo 重複して捜査している。
+        public bool Next(out int x, out int y, out Direction dir)
+        {
+            while (queue.Count > 0)
+            {
+                IntPoint point = queue.Dequeue();
+                if (field[point.X, point.Y].Player == player && field[point.X, point.Y].ActiveRobot > 0)
+                {
+                    x = point.X;
+                    y = point.Y;
+                    dir = distance.ApproachTerget(x, y);
+                    return false;
+                }
+                int tx, ty;
+                for (int i = 1; i < 7; i++)
+                {
+                    if (distance.TransformDirection(i, point.X, point.Y, out tx, out ty)) continue;
+                    int temp = distance[point.X, point.Y] + 1;
+                    if (temp == distance[tx, ty] && field[tx, ty].Ter != Terrain.Hole)
+                    {
+                        queue.Enqueue(new IntPoint { X = tx, Y = ty });
+                    }
+                }
+            }
+            x = -1;
+            y = -1;
+            dir = Direction.Center;
+            return true;
+        }
+    }
+}

--- a/Common/TestAI.cs
+++ b/Common/TestAI.cs
@@ -20,16 +20,16 @@ namespace Common
             return "B_head:TestAI";
         }
 
-        public void Think(int turn, int maxTurn, int player, GameField field, Commander com)
+        public void Think(int turn, int maxTurn, int player, GameField field, Commander commander)
         {
-            if (!Build(player, field, com))
+            if (!Build(player, field, commander))
             {
-                Move(player, field, com);
+                Move(player, field, commander);
             }
-            com.Finish();
+            commander.Finish();
         }
 
-        private void Move(int player, GameField field, Commander com)
+        private void Move(int player, GameField field, Commander commander)
         {
             int w = field.Width, h = field.Height;
             for (int x = 0; x < w; x++)
@@ -38,15 +38,15 @@ namespace Common
                 {
                     Direction dir = ToDirection(random.Next(6));
                     int robot = random.Next(field[x, y].ActiveRobot) + 1;
-                    if (field.IsMove(player, x, y, dir, robot))
+                    if (field.IsMove(x, y, dir, robot))
                     {
-                        com.Move(x, y, dir, robot);
+                        commander.Move(x, y, dir, robot);
                     }
                 }
             }
         }
 
-        private bool Build(int player, GameField field, Commander com)
+        private bool Build(int player, GameField field, Commander commander)
         {
             Terrain building = ToBuilding(random.Next(6));
             int w = field.Width, h = field.Height;
@@ -54,9 +54,9 @@ namespace Common
             {
                 for (int y = 0; y < h; y++)
                 {
-                    if (field.IsBuild(player, x, y, building))
+                    if (field.IsBuild(x, y, building))
                     {
-                        com.Build(x, y, building);
+                        commander.Build(x, y, building);
                         return true;
                     }
                 }

--- a/Production/App.config
+++ b/Production/App.config
@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <configuration>
     <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0,Profile=Client"/>
     </startup>
 </configuration>

--- a/Production/LinkGameField.cs
+++ b/Production/LinkGameField.cs
@@ -10,22 +10,26 @@ namespace Production
 {
     class LinkGameField : GameField
     {
-        public LinkGameField(int size)
+        public readonly int Turn;
+        public readonly int MaxTurn;
+        public readonly int Player;
+
+        public LinkGameField(int size, int turn, int maxTurn, int player)
             : base(size)
         {
-
+            Turn = turn;
+            MaxTurn = maxTurn;
+            Player = player;
         }
 
-        public static LinkGameField ParseText(out int turn, out int maxTurn, out int playerTurn)
+        public static LinkGameField ParseText()
         {
             string[] line;
             if (Console.ReadLine() != "START") throw new Exception();
             line = Console.ReadLine().Split(' ');
-            turn = int.Parse(line[0]);
-            maxTurn = int.Parse(line[1]);
-            playerTurn = int.Parse(line[2]);
+            int turn = int.Parse(line[0]), maxTurn = int.Parse(line[1]), playerTurn = int.Parse(line[2]);
             line = Console.ReadLine().Split(' ');
-            LinkGameField result = new LinkGameField(int.Parse(line[0]));
+            LinkGameField result = new LinkGameField(int.Parse(line[0]), turn, maxTurn, playerTurn);
             int count = int.Parse(line[1]);
             for (int i = 0; i < count; i++)
             {
@@ -92,17 +96,29 @@ namespace Production
         class LinkCommander : Commander
         {
             LinkGameField parent;
+            public bool IsMove { get; private set; }
+            public bool IsBuild { get; private set; }
+            public bool IsFinish { get; private set; }
 
             public LinkCommander(LinkGameField parent)
             {
                 this.parent = parent;
             }
 
+            public int Player
+            {
+                get
+                {
+                    return parent.Player;
+                }
+            }
+
             public void Move(int x, int y, Direction dir, int robot)
             {
                 string temp = GenerateDirectionCode(dir);
                 parent.ToRedress(ref x, ref y);
                 Console.WriteLine("move {0} {1} {2} {3}", x, y, temp, robot);
+                IsMove = true;
             }
 
             public void Build(int x, int y, Terrain building)
@@ -110,11 +126,13 @@ namespace Production
                 string temp = GenerateBuildingCode(building);
                 parent.ToRedress(ref x, ref y);
                 Console.WriteLine("build {0} {1} {2}", x, y, temp);
+                IsBuild = true;
             }
 
             public void Finish()
             {
                 Console.WriteLine("finish");
+                IsFinish = true;
             }
 
             private string GenerateDirectionCode(Direction dir)

--- a/Production/Production.csproj
+++ b/Production/Production.csproj
@@ -11,7 +11,7 @@
     <AssemblyName>Production</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>

--- a/Production/Program.cs
+++ b/Production/Program.cs
@@ -11,14 +11,13 @@ namespace Production
     {
         static void Main(string[] args)
         {
-            int turn, maxTurn, player;
             GameAI ai = new TestAI();
-            LinkGameField field = LinkGameField.ParseText(out turn, out maxTurn, out player);
-            Console.WriteLine(ai.Prepare(player, field));
-            for (int i = 0; i < maxTurn; i++)
+            LinkGameField field = LinkGameField.ParseText();
+            Console.WriteLine(ai.Prepare(field.Player, field));
+            for (int i = 0; i < field.MaxTurn; i++)
             {
-                field = LinkGameField.ParseText(out turn, out maxTurn, out player);
-                ai.Think(turn, maxTurn, player, field, field.GetCommander());
+                field = LinkGameField.ParseText();
+                ai.Think(field.Turn, field.MaxTurn, field.Player, field, field.GetCommander());
             }
         }
     }

--- a/Visualizer/GameManager.cs
+++ b/Visualizer/GameManager.cs
@@ -65,26 +65,36 @@ namespace Visualizer
         class ManagerCommander : Commander
         {
             GameManager parent;
-            public bool IsMove;
-            public bool IsBuild;
-            public bool IsFinish;
+            public bool IsMove { get; private set; }
+            public bool IsBuild { get; private set; }
+            public bool IsFinish { get; private set; }
 
             public ManagerCommander(GameManager parent)
             {
                 this.parent = parent;
             }
 
+            public int Player
+            {
+                get
+                {
+                    return parent.Player;
+                }
+            }
+
             public void Move(int x, int y, Direction dir, int robot)
             {
                 if (IsFinish || IsBuild) throw new Exception();
-                if (!parent.Field.Move(parent.Player, x, y, dir, robot)) throw new Exception();
+                if (parent.Field[x, y].Player != Player) throw new Exception();
+                if (!parent.Field.Move(x, y, dir, robot)) throw new Exception();
                 IsMove = true;
             }
 
             public void Build(int x, int y, Terrain building)
             {
                 if (IsFinish || IsBuild || IsMove) throw new Exception();
-                if (!parent.Field.Build(parent.Player, x, y, building, ref parent.ExtraPoint[parent.Player])) throw new Exception();
+                if (parent.Field[x, y].Player != Player) throw new Exception();
+                if (!parent.Field.Build(x, y, building, ref parent.ExtraPoint[parent.Player])) throw new Exception();
                 IsBuild = true;
             }
 

--- a/Visualizer/GenerateGameField.cs
+++ b/Visualizer/GenerateGameField.cs
@@ -85,14 +85,14 @@ namespace Visualizer
 
         private int JoiningCount(bool[,] settled, int x, int y)
         {
-            if (IsInRange(x, y)) return 0;
+            if (!IsInRange(x, y)) return 0;
             if (settled[x, y]) return 0;
             if (field[x, y].Ter == Terrain.Outside || field[x, y].Ter == Terrain.Hole) return 0;
             int result = 1, tx, ty;
             settled[x, y] = true;
             for (int i = 1; i < 7; i++)
             {
-                TransformAdjoin(i, x, y, out tx, out ty);
+                TransformDirection(i, x, y, out tx, out ty);
                 result += JoiningCount(settled, tx, ty);
             }
             return result;

--- a/Visualizer/MainWindow.xaml
+++ b/Visualizer/MainWindow.xaml
@@ -18,6 +18,8 @@
             <CheckBox x:Name="ShowRobot" Content="Robot" IsChecked="True" Click="ShowChangeHandler"/>
             <CheckBox x:Name="ShowResource" Content="Resource" Click="ShowChangeHandler"/>
             <CheckBox x:Name="ShowTowerDamage" Content="Tower damage" Click="ShowChangeHandler"/>
+            <CheckBox x:Name="ShowDistanse" Content="Distance" Click="ShowChangeHandler"/>
+            <CheckBox x:Name="ShowEvaluate" Content="Evaluate" Click="ShowChangeHandler"/>
         </StackPanel>
         <GridSplitter Width="1" IsEnabled="False" Background="Black" Margin="0"/>
     </Grid>

--- a/Visualizer/MainWindow.xaml.cs
+++ b/Visualizer/MainWindow.xaml.cs
@@ -22,23 +22,30 @@ namespace Visualizer
     public partial class MainWindow : Window
     {
         GameManager manager;
+        DistanceMap distance;
+        EvaluateGround evaluate;
         MassInformation[,] mass;
+        int selectX;
+        int selectY;
 
         public MainWindow()
         {
             InitializeComponent();
             manager = new GameManager(new Random());
-            manager.AI[0] = new TestAI();
-            manager.AI[1] = new TestAI();
-            manager.AI[2] = new TestAI();
+            manager.AI[0] = new KamikazeAI();
+            manager.AI[1] = new KamikazeAI();
+            manager.AI[2] = new KamikazeAI();
             manager.Prepare();
             int w = manager.Field.Width, h = manager.Field.Height;
             mass = new MassInformation[w, h];
+            selectX = w / 2;
+            selectY = h / 2;
             for (int x = 0; x < w; x++)
             {
                 for (int y = 0; y < h; y++)
                 {
                     MassInformation temp = new MassInformation();
+                    temp.MouseDown += CreateMassSelectHandler(x, y);
                     mass[x, y] = temp;
                     FieldInfo.Children.Add(temp);
                     Canvas.SetLeft(temp, (x + y / 2.0) * temp.Width);
@@ -48,17 +55,30 @@ namespace Visualizer
             UpdateInfo();
         }
 
+        private MouseButtonEventHandler CreateMassSelectHandler(int x, int y)
+        {
+            return (sender, e) => 
+            { 
+                selectX = x;
+                selectY = y;
+                UpdateInfo();
+            };
+        }
+
         private void UpdateInfo()
         {
             Player1Info.Text = manager.GetPlayerInfo(0);
             Player2Info.Text = manager.GetPlayerInfo(1);
             Player3Info.Text = manager.GetPlayerInfo(2);
+            distance = new DistanceMap(manager.Field, manager.Player, selectX, selectY);
+            evaluate = new EvaluateGround(manager.Field);
             GameField field = manager.Field;
             int w = field.Width, h = field.Height;
             for (int x = 0; x < w; x++)
             {
                 for (int y = 0; y < h; y++)
                 {
+                    mass[x, y].UpdateSelected(x == selectX && y == selectY);
                     mass[x, y].UpdateTerrain(field[x, y].Player, field[x, y].Ter);
                     mass[x, y].UpdateTextInfo(BuildMassInfo(x, y));
                 }
@@ -81,6 +101,14 @@ namespace Visualizer
             {
                 result.AppendLine("Td:" + field.GetEstimateTowerDamage(field[x, y].Player, x, y) + "(" + field.GetTowerDamage(manager.Player, x, y).ToString() + ")");
             }
+            if (ShowDistanse.IsChecked == true)
+            {
+                result.AppendLine("Dt:" + distance[x, y].ToString());
+            }
+            if (ShowEvaluate.IsChecked == true)
+            {
+                result.AppendLine("Ev:" + evaluate[x, y].ToString());
+            }
             return result.ToString();
         }
 

--- a/Visualizer/MassInformation.xaml.cs
+++ b/Visualizer/MassInformation.xaml.cs
@@ -57,6 +57,18 @@ namespace Visualizer
             return result;
         }
 
+        public void UpdateSelected(bool select)
+        {
+            if (select)
+            {
+                BorderBrush = Brushes.White;
+            }
+            else
+            {
+                BorderBrush = Brushes.Black;
+            }
+        }
+
         public void UpdateTerrain(int player, Terrain ter)
         {
             switch (player)