Пример #1
0
        private void test1ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            TarranQLearning q = new TarranQLearning();

            for (int i = 0; i < 10; i++)
            {
                QStringState          s      = (QStringState)String.Format("{0:0000}", i);
                int                   action = q.GetActionFromIndex(q.GetActionIndex(s));
                TarranQLearningAction ta     = (TarranQLearningAction)action;
                Console.WriteLine(ta.ToString());
            }
            String tmp = JsonConvert.SerializeObject(q);

            Console.WriteLine(tmp);
            BinaryWriter bw = new BinaryWriter(new FileStream("test.q", FileMode.Create));

            q.Save(bw);
            bw.Close();

            BinaryReader    br = new BinaryReader(new FileStream("test.q", FileMode.Open));
            TarranQLearning q2 = new TarranQLearning();

            q2.Load(br);
            br.Close();
            Console.WriteLine(JsonConvert.SerializeObject(q2));

            //TarranQLearning q3 = JsonConvert.DeserializeObject<TarranQLearning>(tmp);
            //Console.WriteLine(JsonConvert.SerializeObject(q3));
        }
Пример #2
0
        public override SC2APIProtocol.Action Process()
        {
            int armyToAttack = 15;

            SC2APIProtocol.Action answer = NewAction();
            Observation           obs    = newObservation.Observation;

            List <Unit> CCs     = GetMyUnits(UNIT_TYPEID.TERRAN_COMMANDCENTER);
            List <Unit> OCCs    = GetMyUnits(UNIT_TYPEID.TERRAN_ORBITALCOMMAND);
            List <Unit> SCVs    = GetMyUnits(UNIT_TYPEID.TERRAN_SCV);
            List <Unit> Supplys = GetMyUnits(UNIT_TYPEID.TERRAN_SUPPLYDEPOT, true);

            Supplys.AddRange(GetMyUnits(UNIT_TYPEID.TERRAN_SUPPLYDEPOTLOWERED, true));
            List <Unit> Refineries   = GetMyUnits(UNIT_TYPEID.TERRAN_REFINERY);
            List <Unit> Barracks     = GetMyUnits(UNIT_TYPEID.TERRAN_BARRACKS);
            List <Unit> Factories    = GetMyUnits(UNIT_TYPEID.TERRAN_FACTORY);
            List <Unit> Engineerings = GetMyUnits(UNIT_TYPEID.TERRAN_ENGINEERINGBAY);
            //MyArmy ArmyUnits =  GetMyArmyUnits();
            int supplyBuildingProgress = CountBuildingOnProgress(SCVs, ABILITY_ID.BUILD_SUPPLYDEPOT);
            int barrakIdleCount        = 0;

            foreach (Unit u in Barracks)
            {
                if (IsIdle(u))
                {
                    barrakIdleCount++;
                }
            }
            logPrintf("CC {0} OCC {6} SCV {1} SUPPLY {2} + {5} REFINERY {3} BARRAKS {4} {8} FACTORY {11} ENG {12} ARMY {7} {9} {10}",
                      CCs.Count, SCVs.Count, Supplys.Count, Refineries.Count, Barracks.Count,
                      supplyBuildingProgress, OCCs.Count, myUnit.armyUnit.Count, barrakIdleCount, myUnit.engaging.Count,
                      myUnit.engagingUnit.Count, Factories.Count, Engineerings.Count
                      );

            if (myUnit.engagingUnit.Count > 0)
            {
                List <Unit> stimUnits = new List <Unit>();
                foreach (Unit u in myUnit.engagingUnit)
                {
                    if (IsUpgraded(UPGRADE_ID.STIMPACK) && u.CanStimpack())
                    {
                        if (u.Health < u.HealthMax)
                        {
                            stimUnits.Add(u);
                        }
                    }
                }
                if (stimUnits.Count > 0)
                {
                    logPrintf("STIM {0}", stimUnits.Count);
                    answer = Stimpack(stimUnits);
                    return(answer);
                }
            }

            if (myUnit.armyUnit.Count > 0)
            {
                if (enemyUnit.armyUnit.Count > 0)
                {
                    // Engagin Unit
                    List <Unit> fightingUnits = myUnit.armyUnit.Where(u => u.GetUnitInRange(enemyUnit.armyUnit).Count > 0).ToList();
                    gameState.AIActions.Clear();
                    if (fightingUnits.Count > 0)
                    {
                        int  index = rand.Next(fightingUnits.Count);
                        Unit u     = fightingUnits[index];
                        Console.WriteLine("" + q.qData.Count());
                        TarranQLearningAction action = (TarranQLearningAction)q.GetBestAction((QStringState)String.Format("{0}", fightingUnits.Count));
                        switch (action)
                        {
                        case TarranQLearningAction.RETREAT_TO_FRIEND:
                        {
                            answer = RetreatToFriend(u);
                            answer.ActionRaw.UnitCommand.QueueCommand = false;
                            gameState.AIActions.Add(new SC2UnitAction()
                                {
                                    Tag = u.Tag, cmd = SC2Action.RETREAT_TO_FRIEND, action = answer
                                });
                            return(answer);
                        }

                        case TarranQLearningAction.NONE:
                        {
                            gameState.AIActions.Add(new SC2UnitAction()
                                {
                                    Tag = u.Tag, cmd = SC2Action.NONE, action = answer
                                });
                            break;
                        }
                        }
                    }
                }
                // Send to Dead
                List <Unit> noOrderUnits = myUnit.armyUnit.Where(u => u.Orders.Count == 0).ToList();
                if (noOrderUnits.Count > 0)
                {
                    SC2APIProtocol.Action ret = AttackAttack(noOrderUnits);
                    if (ret != null)
                    {
                        return(ret);
                    }
                }
            }

            if (IsUpgraded(UPGRADE_ID.STIMPACK) && myUnit.armyUnit.Count > armyToAttack)
            {
                List <Unit> idleArmy = new List <Unit>();
                foreach (Unit u in myUnit.armyUnit)
                {
                    if (!u.HasOrder(ABILITY_ID.ATTACK_ATTACK))
                    {
                        idleArmy.Add(u);
                    }
                }
                if (idleArmy.Count > 5)
                {
                    SC2APIProtocol.Action ret = AttackAttack(idleArmy);
                    if (ret != null)
                    {
                        return(ret);
                    }
                }
            }

            //Avoid high ground enemy
            if (enemyUnit.armyUnit.Count > 0)
            {
            }

            Unit scv = null;

            foreach (Unit u in SCVs)
            {
                if (u.HasOrder(ABILITY_ID.BUILD_SUPPLYDEPOT) ||
                    u.HasOrder(ABILITY_ID.BUILD_REFINERY) ||
                    u.HasOrder(ABILITY_ID.BUILD_BARRACKS) ||
                    u.HasOrder(ABILITY_ID.BUILD_ARMORY) ||
                    u.HasOrder(ABILITY_ID.BUILD_FACTORY) ||
                    u.HasOrder(ABILITY_ID.BUILD_STARPORT)
                    )
                {
                    //logDebug("Supply is building by " + u.ToString());
                    //scv = null;
                    //break;
                    continue;
                }
                scv = u;
            }
            if (scv != null)
            {
                //return answer;
                if (HasResouce(100, 0, 0) && (GetAvailableSupplyRoom() < 10) && (supplyBuildingProgress < 1))
                {
                    SC2APIProtocol.Action ret = BuildSupply(scv);
                    if (ret != null)
                    {
                        logDebug("BuildSupply " + scv);
                        return(ret);
                    }
                }

                if (HasResouce(75, 0, 0) && (Supplys.Count > 0) && (Refineries.Count < 1) && (Barracks.Count > 0))
                {
                    SC2APIProtocol.Action ret = BuildGas(scv);
                    if (ret != null)
                    {
                        logDebug("BuildGas " + scv);
                        return(ret);
                    }
                }
                if (HasResouce(75, 0, 0) && (Supplys.Count > 0) && (Refineries.Count < 2) && (Factories.Count > 0))
                {
                    SC2APIProtocol.Action ret = BuildGas(scv);
                    if (ret != null)
                    {
                        logDebug("BuildGas " + scv);
                        return(ret);
                    }
                }

                if (HasResouce(150, 0, 0) && (Supplys.Count > 0) && (Barracks.Count < 3))
                {
                    if (!coolDownCommand.IsDelayed("BuildBarrak"))
                    {
                        SC2APIProtocol.Action ret = BuildBarrak(scv);
                        if (ret != null)
                        {
                            logDebug("BuildBarrak " + scv);
                            coolDownCommand.Add(new CoolDownCommandData()
                            {
                                key = "BuildBarrak", finishStep = gameLoop + 50
                            });
                            return(ret);
                        }
                    }
                }

                if (HasResouce(300, 100, 0) && (Supplys.Count > 0) && (Barracks.Count >= 3) && (Factories.Count < 1))
                {
                    if (!coolDownCommand.IsDelayed("BuildFactory"))
                    {
                        SC2APIProtocol.Action ret = BuildFactory(scv);
                        if (ret != null)
                        {
                            logDebug("BuildFactory " + scv);
                            coolDownCommand.Add(new CoolDownCommandData()
                            {
                                key = "BuildFactory", finishStep = gameLoop + 50
                            });
                            return(ret);
                        }
                    }
                }

                if (HasResouce(300, 100, 0) && (Factories.Count >= 1) && (Engineerings.Count < 1))
                {
                    if (!coolDownCommand.IsDelayed("BuildEngineering"))
                    {
                        SC2APIProtocol.Action ret = BuildEngineering(scv);
                        if (ret != null)
                        {
                            logDebug("BuildEngineering " + scv);
                            coolDownCommand.Add(new CoolDownCommandData()
                            {
                                key = "BuildEngineering", finishStep = gameLoop + 50
                            });
                            return(ret);
                        }
                    }
                }

                if (Refineries.Count > 0)
                {
                    if (!coolDownCommand.IsDelayed("GatherGas"))
                    {
                        SC2APIProtocol.Action ret = GatherGas(scv);
                        if (ret != null)
                        {
                            logDebug("GatherGas " + scv);
                            coolDownCommand.Add(new CoolDownCommandData()
                            {
                                key = "GatherGas", finishStep = gameLoop + 50
                            });
                            return(ret);
                        }
                    }
                }
            }
            return(answer);
        }