예제 #1
0
        //finds the best mapping between selected moveTo coordinates and the real robots
        private int[] MapRobotsToMoveTo(Storage storage, GridRule rule)
        {
            int[]   bestPerm = new int[4];
            int[][] indexes  = { new int[] { 1, 2, 3, 0 },
                                 new int[]  { 1, 2, 0, 3 },
                                 new int[]  { 1, 3, 2, 0 },
                                 new int[]  { 1, 3, 0, 2 },
                                 new int[]  { 1, 0, 2, 3 },
                                 new int[]  { 1, 0, 3, 2 },
                                 new int[]  { 2, 1, 3, 0 },
                                 new int[]  { 2, 1, 0, 3 },
                                 new int[]  { 2, 3, 1, 0 },
                                 new int[]  { 2, 3, 0, 1 },
                                 new int[]  { 2, 0, 1, 3 },
                                 new int[]  { 2, 0, 3, 1 },
                                 new int[]  { 3, 1, 2, 0 },
                                 new int[]  { 3, 1, 0, 2 },
                                 new int[]  { 3, 2, 1, 0 },
                                 new int[]  { 3, 2, 0, 1 },
                                 new int[]  { 3, 0, 1, 2 },
                                 new int[]  { 3, 0, 2, 1 },
                                 new int[]  { 0, 1, 2, 3 },
                                 new int[]  { 0, 1, 3, 2 },
                                 new int[]  { 0, 2, 1, 3 },
                                 new int[]  { 0, 2, 3, 1 },
                                 new int[]  { 0, 3, 1, 2 },
                                 new int[]  { 0, 3, 2, 1 } };

            double min = double.MaxValue;

            foreach (int[] i in indexes)
            {
                double moveRuleSize = gStrategy.GridToReal(rule.Move[0], gameSetting).DistanceFrom(storage.RightRobots[i[0]].Position)
                                      + gStrategy.GridToReal(rule.Move[1], gameSetting).DistanceFrom(storage.RightRobots[i[1]].Position)
                                      + gStrategy.GridToReal(rule.Move[2], gameSetting).DistanceFrom(storage.RightRobots[i[2]].Position)
                                      + gStrategy.GridToReal(rule.Move[3], gameSetting).DistanceFrom(storage.RightRobots[i[3]].Position);
                if (moveRuleSize < min)
                {
                    min      = moveRuleSize;
                    bestPerm = i;
                }
            }

            return(bestPerm);
        }
예제 #2
0
        // tik strategie urcujici co se ma pri kazdem kroku vykonat
        public override void TickStrategy(Storage storage)
        {
            SetGoalkeeperStrategy(storage.RightRobots[gameSetting.NUMBER_OF_ROBOTS - 1], storage);

            // strategie
            //if (RobotsInDesiredGrid(storage) >= gStrategy.RuleException)
            //currentRule = FindBestRule(ref ruleIndex, storage);
            //currentRule = FindBestRule4(storage);

            currentRule = FindBestRuleGraph(storage);

            SharedMutex.getMutex().WaitOne();
            if (currentRule != null)
            {
                //for (int i = 0; i < gameSetting.NUMBER_OF_ROBOTS - 1; i++)
                //    storage.RightRobots[ruleIndex[i]].PositionMove = gStrategy.GridToReal(currentRule.Move[i], gameSetting);
                int[] mapping = MapRobotsToMoveTo(storage, currentRule);
                for (int i = 0; i < gameSetting.NUMBER_OF_ROBOTS - 1; i++)
                {
                    storage.RightRobots[mapping[i]].PositionMove = gStrategy.GridToReal(currentRule.Move[i], gameSetting);
                }
            }
            SharedMutex.getMutex().ReleaseMutex();


            //taktiky
            SharedMutex.getMutex().WaitOne();
            tactic.chooseTactic(storage.changeRobots());
            SharedMutex.getMutex().ReleaseMutex();


            //TACTIC if (currentRule != null)
            //{
            //    for (int i = 0; i < gameSetting.NUMBER_OF_ROBOTS - 1; i++)
            //    {
            //        if (!storage.MyRobots[ruleIndex[i]].tactic &&
            //            gStrategy.RealToGrid(storage.MyRobots[ruleIndex[i]].Position) != currentRule.Move[i])
            //        {
            //            storage.MyRobots[ruleIndex[i]].GoTo(storage.MyRobots[ruleIndex[i]].Strat_pos);
            //        }
            //    }
            //}
        }
예제 #3
0
        // konstruktor zajistujici spravne rozparsrovani vsech dat ze souboru a nacteni do promennych a pripadne x-ove preklopeni pravidel
        public GridStrategy(String fileName, bool mirror)
        {
            CultureInfo nfi = new CultureInfo("en-US", false);

            StreamReader reader = new StreamReader(new FileStream(fileName, FileMode.Open));

            this.name      = getValue(reader.ReadLine(), "Strategy");
            this.algorithm = getValue(reader.ReadLine(), "Algorithm");
            this.author    = getValue(reader.ReadLine(), "Author");
            this.date      = getValue(reader.ReadLine(), "Date");
            String[] s_size = getValue(reader.ReadLine(), "Size").Split(new char[] { ',' });
            this.size          = new Vector2D(Convert.ToDouble(s_size[0], nfi), Convert.ToDouble(s_size[1], nfi));
            this.attackerMin   = Int32.Parse(getValue(reader.ReadLine(), "AttackerMin"));
            this.ruleException = Int32.Parse(getValue(reader.ReadLine(), "RuleException"));
            String[] s_priorityMine = getValue(reader.ReadLine(), "PriorityMine").Split(new char[] { ' ', '\t' });
            this.priorityMine = new int[] { Int32.Parse(s_priorityMine[0]), Int32.Parse(s_priorityMine[1]), Int32.Parse(s_priorityMine[2]), Int32.Parse(s_priorityMine[3]) };
            String[] s_priorityMineD = getValue(reader.ReadLine(), "PriorityMineD").Split(new char[] { ' ', '\t' });
            this.priorityMineD = new int[] { Int32.Parse(s_priorityMineD[0]), Int32.Parse(s_priorityMineD[1]), Int32.Parse(s_priorityMineD[2]), Int32.Parse(s_priorityMineD[3]) };
            String[] s_priorityOpponent = getValue(reader.ReadLine(), "PriorityOpponent").Split(new char[] { ' ', '\t' });
            this.priorityOpponent = new int[] { Int32.Parse(s_priorityOpponent[0]), Int32.Parse(s_priorityOpponent[1]), Int32.Parse(s_priorityOpponent[2]), Int32.Parse(s_priorityOpponent[3]) };
            String[] s_priorityOpponentD = getValue(reader.ReadLine(), "PriorityOpponentD").Split(new char[] { ' ', '\t' });
            this.priorityOpponentD = new int[] { Int32.Parse(s_priorityOpponentD[0]), Int32.Parse(s_priorityOpponentD[1]), Int32.Parse(s_priorityOpponentD[2]), Int32.Parse(s_priorityOpponentD[3]) };
            this.priorityBall      = Int32.Parse(getValue(reader.ReadLine(), "PriorityBall"));

            rules = new List <GridRule>();
            try
            {
                while (!reader.EndOfStream)
                {
                    reader.ReadLine();
                    GridRule r = new GridRule(reader.ReadLine(), reader.ReadLine(), reader.ReadLine(), reader.ReadLine(), reader.ReadLine());
                    if (mirror)
                    {
                        r.Mirror((int)size.X);
                    }
                    r.fillZOrder();
                    rules.Add(r);
                }
            }
            catch (Exception) { }
            reader.Close();
        }
예제 #4
0
        public void Fill_LeftStrg31(GridStrategy gStrategy, GameSetting gameSetting)
        {
            //double _treshold = 0.7;
            double _treshold = 0;

            StringBuilder sb = new StringBuilder();

            //nodes
            for (int i = 0; i < gStrategy.Rules.Count; i++)
            {
                AddNode(new Node(i, gStrategy.Rules[i]));
            }

            GridStrategy offensiveM = new GridStrategy();

            offensiveM.Rules.Add(gStrategy.Rules[0]);
            offensiveM.Rules.Add(gStrategy.Rules[1]);
            offensiveM.Rules.Add(gStrategy.Rules[2]);
            offensiveM.Rules.Add(gStrategy.Rules[3]);
            GridStrategy offensiveR = new GridStrategy();

            offensiveR.Rules.Add(gStrategy.Rules[4]);
            offensiveR.Rules.Add(gStrategy.Rules[5]);
            offensiveR.Rules.Add(gStrategy.Rules[6]);
            offensiveR.Rules.Add(gStrategy.Rules[7]);
            offensiveR.Rules.Add(gStrategy.Rules[8]);
            offensiveR.Rules.Add(gStrategy.Rules[9]);
            GridStrategy offensiveL = new GridStrategy();

            offensiveL.Rules.Add(gStrategy.Rules[10]);
            offensiveL.Rules.Add(gStrategy.Rules[11]);
            offensiveL.Rules.Add(gStrategy.Rules[12]);
            offensiveL.Rules.Add(gStrategy.Rules[13]);
            offensiveL.Rules.Add(gStrategy.Rules[14]);
            offensiveL.Rules.Add(gStrategy.Rules[15]);
            GridStrategy defensiveM = new GridStrategy();

            defensiveM.Rules.Add(gStrategy.Rules[16]);
            defensiveM.Rules.Add(gStrategy.Rules[17]);
            defensiveM.Rules.Add(gStrategy.Rules[18]);
            defensiveM.Rules.Add(gStrategy.Rules[19]);
            GridStrategy defensiveR = new GridStrategy();

            defensiveR.Rules.Add(gStrategy.Rules[20]);
            defensiveR.Rules.Add(gStrategy.Rules[21]);
            defensiveR.Rules.Add(gStrategy.Rules[22]);
            defensiveR.Rules.Add(gStrategy.Rules[23]);
            defensiveR.Rules.Add(gStrategy.Rules[24]);
            defensiveR.Rules.Add(gStrategy.Rules[25]);
            GridStrategy defensiveL = new GridStrategy();

            defensiveL.Rules.Add(gStrategy.Rules[26]);
            defensiveL.Rules.Add(gStrategy.Rules[27]);
            defensiveL.Rules.Add(gStrategy.Rules[28]);
            defensiveL.Rules.Add(gStrategy.Rules[29]);
            defensiveL.Rules.Add(gStrategy.Rules[30]);

            List <GridStrategy> lStrategy = new List <GridStrategy>();

            lStrategy.Add(offensiveM);
            lStrategy.Add(offensiveR);
            lStrategy.Add(offensiveL);
            lStrategy.Add(defensiveM);
            lStrategy.Add(defensiveR);
            lStrategy.Add(defensiveL);

            //edges
            double        max    = -1;
            List <Triple> values = new List <Triple>();

            foreach (GridStrategy tempStrg in lStrategy)
            {
                for (int i = 0; i < tempStrg.Rules.Count - 1; i++)
                {
                    for (int j = i + 1; j < tempStrg.Rules.Count; j++)
                    {
                        GridRule r1 = tempStrg.Rules[i];
                        GridRule r2 = tempStrg.Rules[j];

                        //ball
                        double ballRuleSize = gStrategy.GridToReal(r1.Ball, gameSetting).DistanceFrom(
                            gStrategy.GridToReal(r2.Ball, gameSetting)
                            );

                        //mine
                        double mineSize = 0;
                        for (int k = 0; k < gameSetting.NUMBER_OF_ROBOTS - 1; k++)
                        {
                            mineSize += gStrategy.GridToReal(r1.Mine[r1.ZMine[k]], gameSetting).DistanceFrom(
                                gStrategy.GridToReal(r2.Mine[r2.ZMine[k]], gameSetting)
                                );
                        }

                        //oppnt
                        double oppntSize = 0;
                        for (int k = 0; k < gameSetting.NUMBER_OF_ROBOTS - 1; k++)
                        {
                            oppntSize += gStrategy.GridToReal(r1.Oppnt[r1.ZOppnt[k]], gameSetting).DistanceFrom(
                                gStrategy.GridToReal(r2.Oppnt[r2.ZOppnt[k]], gameSetting)
                                );
                        }

                        if (ballRuleSize + mineSize + oppntSize > max)
                        {
                            max = ballRuleSize + mineSize + oppntSize;
                        }

                        int ii = gStrategy.Rules.IndexOf(tempStrg.Rules[i]);
                        int ij = gStrategy.Rules.IndexOf(tempStrg.Rules[j]);

                        values.Add(new Triple(ii, ij, ballRuleSize + mineSize + oppntSize));
                    }
                }
            }

            for (int i = 0; i < values.Count; i++)
            {
                double norm = 1 - (values[i].z / max);
                sb.AppendLine(values[i].x + " " + values[i].y + " " + Math.Round(norm, 3).ToString().Replace(',', '.'));
                //Console.WriteLine("{0} {1} {2} {3}", values[i].x, values[i].y, values[i].z, norm);

                if (norm >= _treshold)
                {
                    AddEdge(nodes[values[i].x], nodes[values[i].y], norm);
                }
            }

            string filename = "GRAPH_" + gStrategy.Name + ".txt";

            File.Delete(filename);
            using (StreamWriter sw = new StreamWriter(new FileStream(filename, FileMode.CreateNew)))
            {
                sw.Write(sb.ToString());
            }
        }
예제 #5
0
        public void Fill(GridStrategy gStrategy, GameSetting gameSetting, double _treshold)
        {
            StringBuilder sb = new StringBuilder();

            //nodes
            for (int i = 0; i < gStrategy.Rules.Count; i++)
            {
                AddNode(new Node(i, gStrategy.Rules[i]));
            }

            //edges
            double        max    = -1;
            List <Triple> values = new List <Triple>();

            for (int i = 0; i < gStrategy.Rules.Count - 1; i++)
            {
                for (int j = i + 1; j < gStrategy.Rules.Count; j++)
                {
                    GridRule r1 = gStrategy.Rules[i];
                    GridRule r2 = gStrategy.Rules[j];

                    //ball
                    double ballRuleSize = gStrategy.GridToReal(r1.Ball, gameSetting).DistanceFrom(
                        gStrategy.GridToReal(r2.Ball, gameSetting)
                        );

                    //mine
                    double mineSize = 0;
                    for (int k = 0; k < gameSetting.NUMBER_OF_ROBOTS - 1; k++)
                    {
                        mineSize += gStrategy.GridToReal(r1.Mine[r1.ZMine[k]], gameSetting).DistanceFrom(
                            gStrategy.GridToReal(r2.Mine[r2.ZMine[k]], gameSetting)
                            );
                    }

                    //oppnt
                    double oppntSize = 0;
                    for (int k = 0; k < gameSetting.NUMBER_OF_ROBOTS - 1; k++)
                    {
                        oppntSize += gStrategy.GridToReal(r1.Oppnt[r1.ZOppnt[k]], gameSetting).DistanceFrom(
                            gStrategy.GridToReal(r2.Oppnt[r2.ZOppnt[k]], gameSetting)
                            );
                    }

                    if (ballRuleSize + mineSize + oppntSize > max)
                    {
                        max = ballRuleSize + mineSize + oppntSize;
                    }

                    values.Add(new Triple(i, j, ballRuleSize + mineSize + oppntSize));
                }
            }

            for (int i = 0; i < values.Count; i++)
            {
                double norm = 1 - (values[i].z / max);
                //Console.WriteLine("{0} {1} {2} {3}", values[i].x, values[i].y, values[i].z, norm);

                if (norm >= _treshold)
                {
                    AddEdge(nodes[values[i].x], nodes[values[i].y], norm);
                    sb.AppendLine(values[i].x + " " + values[i].y + " " + Math.Round(norm, 3).ToString().Replace(',', '.'));
                }
            }

            /**
             * string filename = "GRAPH_" + gStrategy.Name + ".txt";
             * File.Delete(filename);
             * using (StreamWriter sw = new StreamWriter(new FileStream(filename, FileMode.CreateNew)))
             * {
             *  sw.Write(sb.ToString());
             *  sw.Close();
             * }
             */
        }
예제 #6
0
        //################################################################################################################################################

        #region funkce pro strategie

        private GridRule FindBestRuleGraph(Storage storage)
        {
            GridRule bestRule = null;
            int      x, y;

            //mine
            matrix = new List <int> [6, 4];
            for (int i = 0; i < storage.RightRobots.Length - 1; i++)
            {
                Vector2D v = gStrategy.RealToGrid(storage.RightRobots[i].Position, gameSetting);
                x = Convert.ToInt32(v.X);
                y = Convert.ToInt32(v.Y);
                if (matrix[x, y] != null)
                {
                    matrix[x, y].Add(i);
                }
                else
                {
                    matrix[x, y] = new List <int>()
                    {
                        i
                    }
                };
            }
            List <int> actMine = zorder.zOrderMain(matrix, 2);

            //oppnt
            matrix = new List <int> [6, 4];
            for (int i = 0; i < storage.LeftRobots.Length - 1; i++)
            {
                Vector2D v = gStrategy.RealToGrid(storage.LeftRobots[i].Position, gameSetting);
                x = Convert.ToInt32(v.X);
                y = Convert.ToInt32(v.Y);
                if (matrix[x, y] != null)
                {
                    matrix[x, y].Add(i);
                }
                else
                {
                    matrix[x, y] = new List <int>()
                    {
                        i
                    }
                };
            }
            List <int> actOppnt = zorder.zOrderMain(matrix, 2);

            //nejpodobnejsi pravidlo
            double min = Double.MaxValue;

            if (lastRule == -1)
            {
                GridRule rule;
                for (int r = 0; r < gStrategy.Rules.Count; r++)
                {
                    //nesmysl
                    //if (graph.Nodes[r].neighbours.Count == 0)
                    //{
                    //    if (gStrategy.Rules.Count > 0)
                    //    {
                    //        bestRule = gStrategy.Rules[0];
                    //        lastRule = 0;
                    //    }
                    //    break;
                    //}

                    rule = gStrategy.Rules[r];

                    double ballRuleSize = gStrategy.GridToReal(rule.Ball, gameSetting).DistanceFrom(storage.Ball.Position);

                    double mineSize = 0;
                    for (int i = 0; i < actMine.Count; i++)
                    {
                        mineSize += gStrategy.GridToReal(rule.Mine[rule.ZMine[i]], gameSetting).DistanceFrom(storage.LeftRobots[actMine[i]].Position);
                    }

                    double oppntSize = 0;
                    for (int i = 0; i < actOppnt.Count; i++)
                    {
                        oppntSize += gStrategy.GridToReal(rule.Oppnt[rule.ZOppnt[i]], gameSetting).DistanceFrom(storage.RightRobots[actOppnt[i]].Position);
                    }

                    if (ballRuleSize + mineSize + oppntSize < min)
                    {
                        min      = ballRuleSize + mineSize + oppntSize;
                        bestRule = rule;
                        lastRule = r;
                    }
                }
            }
            else
            {
                Node       actNode = graph.Nodes[lastRule];
                GridRule   rule;
                List <int> tempKeys = new List <int>(actNode.neighbours.Keys);
                tempKeys.Add(lastRule);
                //foreach (int k in actNode.neighbours.Keys)
                foreach (int k in tempKeys)
                {
                    rule = (GridRule)graph.Nodes[k].data;

                    double ballRuleSize = gStrategy.GridToReal(rule.Ball, gameSetting).DistanceFrom(storage.Ball.Position);

                    double mineSize = 0;
                    for (int i = 0; i < actMine.Count; i++)
                    {
                        mineSize += gStrategy.GridToReal(rule.Mine[rule.ZMine[i]], gameSetting).DistanceFrom(storage.RightRobots[actMine[i]].Position);
                    }

                    double oppntSize = 0;
                    for (int i = 0; i < actOppnt.Count; i++)
                    {
                        oppntSize += gStrategy.GridToReal(rule.Oppnt[rule.ZOppnt[i]], gameSetting).DistanceFrom(storage.LeftRobots[actOppnt[i]].Position);
                    }

                    if (ballRuleSize + mineSize + oppntSize < min)
                    {
                        min      = ballRuleSize + mineSize + oppntSize;
                        bestRule = rule;
                        lastRule = k;
                    }
                }
            }
            return(bestRule);
        }