public PD_GR_P_GameStateEvaluationMetrics(
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     Update(game, pathFinder);
 }
        protected override PD_MacroAction Discarding_DuringMainPlayerActions_Behaviour(
            Random randomness_provider,
            PD_Game game,
            PD_AI_PathFinder pathFinder
            )
        {
            var allMacros = game.GetAvailableMacros(pathFinder);

            if (allMacros == null || allMacros.Count == 0)
            {
                return(null);
            }

            // DISCARD POLICY
            var soup_discard_macros = new List <PD_MacroAction>();

            foreach (var policy in Available_DiscardPolicies)
            {
                soup_discard_macros.AddRange(policy.FilterMacros(game, pathFinder, allMacros));
            }

            if (soup_discard_macros.Count > 0)
            {
                return(soup_discard_macros.GetOneRandom(randomness_provider));
            }

            return(allMacros.GetOneRandom(randomness_provider));
        }
        protected override PD_MacroAction Discarding_DuringMainPlayerActions_Behaviour(
            Random randomness_provider,
            PD_Game game,
            PD_AI_PathFinder pathFinder
            )
        {
            var allMacros = game.GetAvailableMacros(pathFinder);

            if (allMacros == null || allMacros.Count == 0)
            {
                return(null);
            }

            // DISCARD POLICY
            Available_DiscardPolicies.Shuffle(randomness_provider);

            foreach (var policy in Available_DiscardPolicies)
            {
                var macros = policy.FilterMacros(game, pathFinder, allMacros);
                if (macros.Count > 0)
                {
                    return(macros.GetOneRandom(randomness_provider));
                }
            }

            return(allMacros.GetOneRandom(randomness_provider));
        }
 public PD_GR_P_ActionStats(
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     Update(game, pathFinder);
 }
        public override void Update(
            PD_Game game,
            PD_AI_PathFinder pathFinder
            )
        {
            PercentCuredDiseases =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Percent_CuredDiseases(game);
            PercentAbilityToCureDiseases =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Percent_AbilityToCureDiseases(game, false);
            PercentAbilityToCureDiseases_Squared =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Percent_AbilityToCureDiseases(game, true);
            PercentCuredDiseases_Gradient =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Percent_CuredDiseases_Gradient(game, false);
            PercentCuredDiseases_Gradient_Squared =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Percent_CuredDiseases_Gradient(game, true);

            MinimumPercentAvailableDiseaseCubes =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Minimum_PercentAvailableDiseaseCubes_Min_1(game);
            MultipliedPercentAvailableDiseaseCubes =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Multiplied_Percent_AvailableDiseaseCubes_Min_1(game);
            AveragePercentAvailableDiseaseCubes =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_Average_Percent_AvailableDiseaseCubes_Min_1(game);

            PercentRemainingOutbreaks =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_PercentRemainingOutbreaks_Min_1(game);

            PercentRemainingPlayerCards =
                PD_AI_GameStateEvaluation_HelpMethods.Calculate_PercentRemainingPlayerCards(game);
        }
 public PD_GR_P_GameCondition(
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     Update(game, pathFinder);
 }
Exemple #7
0
        public string Get_Record_Row(
            PD_Game game,
            PD_AI_PathFinder pathFinder,
            PD_AI_Agent_Base agent,
            int repetitionIndex
            )
        {
            string record_Row;

            List <PD_Report_Part> report_Parts = new List <PD_Report_Part>();

            // game state report is included in all cases...
            GameState_Report.Update(game, pathFinder, repetitionIndex);
            report_Parts.Add(GameState_Report);

            // include game stats report?
            if (Keep_GameStats_Report == true)
            {
                GameStats_Report.Update(game, pathFinder);
                report_Parts.Add(GameStats_Report);
            }

            record_Row = PD_Report_Part.Get_Joined_CSV_Row(report_Parts);

            return(record_Row);
        }
        public override void Update(
            PD_Game game,
            PD_AI_PathFinder pathFinder
            )
        {
            NumPlayers     = game.game_state_counter.number_of_players;
            GameDifficulty = game.game_settings.game_difficulty_level;

            Player1_Role = game.role__per__player[game.players[0]].ToString();
            Player2_Role = game.role__per__player[game.players[1]].ToString();

            if (game.players.Count >= 3)
            {
                Player3_Role = game.role__per__player[game.players[2]].ToString();
            }
            else
            {
                Player3_Role = "";
            }

            if (game.players.Count >= 4)
            {
                Player4_Role = game.role__per__player[game.players[3]].ToString();
            }
            else
            {
                Player4_Role = "";
            }
        }
Exemple #9
0
        public void Expand(
            Random randomness_provider,
            PD_Game gameState,
            PD_AI_PathFinder pathFinder,
            PD_AI_Macro_Agent_Base defaultPolicyAgent
            )
        {
            PD_Game generator_GameState = gameState.Request_Randomized_Copy(randomness_provider);

            int initialTurn = generator_GameState.game_state_counter.turn_index;
            int finalTurn   = initialTurn + MaxGenomeLength - Genome.Count;
            int currentTurn = initialTurn;

            // prepare the dictionary of macros!
            Dictionary <int, List <PD_MacroAction> > macroActionsPerTurn = new Dictionary <int, List <PD_MacroAction> >();

            for (int i = initialTurn; i < finalTurn; i++)
            {
                macroActionsPerTurn.Add(
                    i,
                    new List <PD_MacroAction>()
                    );
            }

            // create the new macros and put them in the dictionary
            while (
                generator_GameState.GQ_Is_Ongoing()
                &&
                currentTurn < finalTurn
                )
            {
                var nextMacro = defaultPolicyAgent.GetNextMacroAction(
                    randomness_provider,
                    generator_GameState,
                    pathFinder
                    );

                macroActionsPerTurn[currentTurn].Add(nextMacro);

                generator_GameState.Apply_Macro_Action(
                    randomness_provider,
                    nextMacro
                    );

                currentTurn = generator_GameState.game_state_counter.turn_index;
            }

            // expand the genome
            for (int i = initialTurn; i < finalTurn; i++)
            {
                if (macroActionsPerTurn[i].Count > 0)
                {
                    RH_Gene gene = new RH_Gene(
                        i,
                        macroActionsPerTurn[i]
                        );
                    Genome.Add(gene);
                }
            }
        }
Exemple #10
0
        protected override PD_MacroAction Discarding_AfterDrawing_Behaviour(
            Random randomness_provider,
            PD_Game game,
            PD_AI_PathFinder pathFinder
            )
        {
            var allMacros = game.GetAvailableMacros(pathFinder);

            if (allMacros == null || allMacros.Count == 0)
            {
                return(null);
            }

            foreach (var discardPolicy in Discard_Policies)
            {
                var macros = discardPolicy.FilterMacros(
                    game,
                    pathFinder,
                    allMacros
                    );
                if (macros.Count > 0)
                {
                    return(macros.GetOneRandom(randomness_provider));
                }
            }
            return(allMacros.GetOneRandom(randomness_provider));
        }
 public PD_MacroAction GetNextMacroAction(
     Random randomness_provider,
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     if (game.GQ_IsInState_ApplyingMainPlayerActions())
     {
         return(MainPlayerActions_Behaviour(randomness_provider, game, pathFinder));
     }
     else if (game.GQ_IsInState_DiscardDuringMainPlayerActions())
     {
         return(Discarding_DuringMainPlayerActions_Behaviour(randomness_provider, game, pathFinder));
     }
     else if (game.GQ_IsInState_DiscardAfterDrawing())
     {
         return(Discarding_AfterDrawing_Behaviour(randomness_provider, game, pathFinder));
     }
     else
     {
         throw new System.Exception(
                   "A macro action was requested in an invalid game state"
                   );
     }
 }
 public PD_GR_P_GameSettings(
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     Update(game, pathFinder);
 }
Exemple #13
0
        public override void Update(
            PD_Game game,
            PD_AI_PathFinder pathFinder
            )
        {
            Num_RemainingPlayerCards =
                game
                .cards
                .divided_deck_of_player_cards
                .GetNumberOfElementsOfAllSubLists();

            Num_Outbreaks = game.game_state_counter.outbreaks_counter;
            Num_Epidemics = game.game_state_counter.epidemics_counter;

            Num_CuredDiseases      = 0;
            Num_EradicatedDiseases = 0;
            for (int i = 0; i < 4; i++)
            {
                if (game.game_state_counter.disease_states[i] == 1)
                {
                    Num_CuredDiseases++;
                }
                if (game.game_state_counter.disease_states[i] == 2)
                {
                    Num_CuredDiseases++;
                    Num_EradicatedDiseases++;
                }
            }
        }
        public static List <PD_MacroAction> ShareKnowledge_Positive_Now(
            PD_Game game,
            PD_AI_PathFinder pathFinder,
            List <PD_MacroAction> allMacros
            )
        {
#if DEBUG
            if (game.GQ_IsInState_ApplyingMainPlayerActions() == false)
            {
                throw new System.Exception("wrong state.");
            }
#endif

            var shareKnowledgeMacros_ExecutableNow = allMacros.FindAll(
                x =>
                x.Is_TypeOf_ShareKnowledge_Any()
                &&
                x.Is_ExecutableNow() == true
                );
            if (shareKnowledgeMacros_ExecutableNow.Count > 0)
            {
                List <PD_MacroAction> positiveShareKnowledgeMacros = new List <PD_MacroAction>();
                foreach (var macro in shareKnowledgeMacros_ExecutableNow)
                {
                    List <PD_Action> walkSequence = macro.Actions_All.CustomDeepCopy();
                    walkSequence.RemoveAt(walkSequence.Count - 1);
                    double walkSequenceValue = PD_AI_CardEvaluation_Utilities
                                               .Calculate_ListOfPlayerActions_Effect_On_Percent_AbilityToCureDiseases(
                        game,
                        walkSequence,
                        true
                        );
                    if (walkSequenceValue < 0)
                    {
                        continue;
                    }

                    PD_Action lastCommand   = macro.Find_LastCommand();
                    double    exchangeValue =
                        PD_AI_CardEvaluation_Utilities
                        .Calculate_PlayerAction_Effect_On_Percent_AbilityToCureDiseases(
                            game,
                            lastCommand,
                            true
                            );

                    if (exchangeValue > 0.0)
                    {
                        positiveShareKnowledgeMacros.Add(macro);
                    }
                }
                if (positiveShareKnowledgeMacros.Count > 0)
                {
                    return(positiveShareKnowledgeMacros);
                }
            }

            return(new List <PD_MacroAction>());
        }
Exemple #15
0
 protected override PD_MacroAction Discarding_AfterDrawing_Behaviour(
     Random randomness_provider,
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     return(GeneralAgentBehaviour(randomness_provider, game, pathFinder));
 }
Exemple #16
0
 protected override PD_MacroAction MainPlayerActions_Behaviour(
     Random randomness_provider,
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     return(GeneralAgentBehaviour(randomness_provider, game, pathFinder));
 }
        public static List <PD_MacroAction> TakePosition_Positive_NextRound(
            PD_Game game,
            PD_AI_PathFinder pathFinder,
            List <PD_MacroAction> allMacros
            )
        {
            int numberOfStepsUntilEndOfNextRound = 4 + game.GQ_RemainingPlayerActions_ThisRound();
            var takePosition_NextRound           = allMacros.FindAll(
                x =>
                x.Is_TypeOf_TakePositionFor_ShareKnowledge_Any()
                &&
                x.Is_ExecutableNow() == false
                &&
                x.Count_Total_Length() <= numberOfStepsUntilEndOfNextRound
                );

            if (takePosition_NextRound.Count > 0)
            {
                List <PD_MacroAction> takePosition_Positive_NextRound = new List <PD_MacroAction>();
                // find all take position macros that would have a positive outcome (ability to cure)
                foreach (var macro in takePosition_NextRound)
                {
                    List <PD_Action> walkSequence      = macro.Actions_All;
                    double           walkSequenceValue = PD_AI_CardEvaluation_Utilities
                                                         .Calculate_ListOfPlayerActions_Effect_On_Percent_AbilityToCureDiseases(
                        game,
                        walkSequence,
                        true
                        );
                    if (walkSequenceValue < 0)
                    {
                        continue;
                    }

                    var lastCommand = macro.NonExecutable_ShareKnowledge_Action;

                    double exchangeValue =
                        PD_AI_CardEvaluation_Utilities
                        .Calculate_PlayerAction_Effect_On_Percent_AbilityToCureDiseases(
                            game,
                            lastCommand,
                            true
                            );

                    if (exchangeValue > 0.0)
                    {
                        takePosition_Positive_NextRound.Add(macro);
                    }
                }

                if (takePosition_Positive_NextRound.Count > 0)
                {
                    return(takePosition_Positive_NextRound);
                }
            }
            return(new List <PD_MacroAction>());
        }
Exemple #18
0
 public override void Update(PD_Game game, PD_AI_PathFinder pathFinder)
 {
     GameSettings.Update(game, pathFinder);
     GameCondition.Update(game, pathFinder);
     GameScores.Update(game, pathFinder);
     ActionStats.Update(game, pathFinder);
     GameStateEvaluationMetrics.Update(game, pathFinder);
     MapStats.Update(game, pathFinder);
 }
 public override List <PD_MacroAction> FilterMacros(
     PD_Game game,
     PD_AI_PathFinder pathFinder,
     List <PD_MacroAction> allMacros)
 {
     return(allMacros.FindAll(
                x =>
                x.Is_TypeOf_Cure_Any()
                ));
 }
 public override List <PD_MacroAction> FilterMacros(
     PD_Game game,
     PD_AI_PathFinder pathFinder,
     List <PD_MacroAction> allMacros)
 {
     return(allMacros.FindAll(
                x =>
                x.Is_TypeOf_BuildResearchStation_Any_Or_MoveResearchStation()
                ));
 }
Exemple #21
0
        public void EvaluateSelf(
            Random randomness_provider,
            PD_Game initial_GameState,
            PD_AI_PathFinder pathFinder,
            PD_AI_Macro_Agent_Base defaultPolicyAgent,
            List <PD_GameStateEvaluator> gameStateEvaluators
            )
        {
            EvaluationScores = new List <double>();
            List <double> evaluationScoreSums = new List <double>();

            foreach (var evaluator in gameStateEvaluators)
            {
                EvaluationScores.Add(0.0);
                evaluationScoreSums.Add(0.0f);
            }

            for (int i = 0; i < NumSimulationsForEvaluation; i++)
            {
                PD_Game evaluation_GameState = initial_GameState.Request_Randomized_Copy(randomness_provider);
                foreach (var gene in Genome)
                {
                    if (evaluation_GameState.GQ_Is_Ongoing())
                    {
                        gene.ApplySelfOnGameState(
                            randomness_provider,
                            evaluation_GameState,
                            pathFinder,
                            defaultPolicyAgent
                            );
                    }
                }

                if (evaluation_GameState.GQ_Is_Ongoing() && IsComplete() == false)
                {
                    Expand(
                        randomness_provider,
                        evaluation_GameState,
                        pathFinder,
                        defaultPolicyAgent
                        );
                }

                for (int j = 0; j < gameStateEvaluators.Count; j++)
                {
                    evaluationScoreSums[j] += gameStateEvaluators[j].EvaluateGameState(evaluation_GameState);
                }
            }

            for (int j = 0; j < gameStateEvaluators.Count; j++)
            {
                EvaluationScores[j] = evaluationScoreSums[j] / (double)NumSimulationsForEvaluation;
            }
        }
Exemple #22
0
 public override List<PD_MacroAction> FilterMacros(
     PD_Game game, 
     PD_AI_PathFinder pathFinder, 
     List<PD_MacroAction> allMacros)
 {
     return allMacros.FindAll(
         x => 
         x.Is_TypeOf_TreatDisease_Any()
         &&
         x.Is_ExecutableNow()
         );
 }
Exemple #23
0
        public override void Update(PD_Game game, PD_AI_PathFinder pathFinder)
        {
            GameID              = game.unique_id;
            CurrentTurn         = game.game_state_counter.turn_index;
            CurrentPlayerAction = game.game_state_counter.player_action_index;
            CurrentGameStep     = CurrentTurn * 4 + CurrentPlayerAction;
            CurrentGameState    = game.game_FSM.CurrentState.GetType().Name.ToString();

            long gameDurationTicks = DateTime.UtcNow.Ticks - game.start_time.Ticks;

            GameDurMillis = (float)gameDurationTicks / 10000.0f;
        }
        public override List <PD_MacroAction> FilterMacros(PD_Game game, PD_AI_PathFinder pathFinder, List <PD_MacroAction> allMacros)
        {
#if DEBUG
            if (game.GQ_IsInState_ApplyingMainPlayerActions() == false)
            {
                throw new System.Exception("wrong state.");
            }
#endif
            var treatDiseaseMacros = allMacros.FindAll(
                x => x.Is_TypeOf_TreatDisease_Any()
                );

            if (treatDiseaseMacros.Count == 0)
            {
                return(new List <PD_MacroAction>());
            }

            // TREAT 3
            var treat_3 = Treat_3.FilterMacros(
                game,
                pathFinder,
                allMacros
                );
            if (treat_3.Count > 0)
            {
                return(treat_3);
            }

            // TREAT 2
            var treat_2 = Treat_2.FilterMacros(
                game,
                pathFinder,
                allMacros
                );
            if (treat_2.Count > 0)
            {
                return(treat_2);
            }

            // TREAT 1
            var treat_1 = Treat_1.FilterMacros(
                game,
                pathFinder,
                allMacros
                );
            if (treat_1.Count > 0)
            {
                return(treat_1);
            }

            return(new List <PD_MacroAction>());
        }
        public override List <PD_MacroAction> FilterMacros(
            PD_Game game,
            PD_AI_PathFinder pathFinder,
            List <PD_MacroAction> allMacros
            )
        {
#if DEBUG
            if (game.GQ_IsInState_ApplyingMainPlayerActions() == false)
            {
                throw new System.Exception("wrong state.");
            }
#endif

            // share positive now
            List <PD_MacroAction> shareKnowledge_Positive_Now =
                PD_AI_MacroAgent_SubPolicies.ShareKnowledge_Positive_Now(
                    game,
                    pathFinder,
                    allMacros
                    );
            if (shareKnowledge_Positive_Now.Count > 0)
            {
                return(shareKnowledge_Positive_Now);
            }

            // share positive next round
            List <PD_MacroAction> shareKnowledge_Positive_NextRound_Macros =
                PD_AI_MacroAgent_SubPolicies.ShareKnowledge_Positive_NextRound(
                    game,
                    pathFinder,
                    allMacros
                    );
            if (shareKnowledge_Positive_NextRound_Macros.Count > 0)
            {
                return(shareKnowledge_Positive_NextRound_Macros);
            }

            // take position positive now - other 4
            List <PD_MacroAction> takePosition_Positive_Now_OtherPlayerWithinFourSteps =
                PD_AI_MacroAgent_SubPolicies.TakePosition_Positive_Now_OtherPlayerWithinFourSteps(
                    game,
                    pathFinder,
                    allMacros
                    );
            if (takePosition_Positive_Now_OtherPlayerWithinFourSteps.Count > 0)
            {
                return(takePosition_Positive_Now_OtherPlayerWithinFourSteps);
            }


            return(new List <PD_MacroAction>());
        }
Exemple #26
0
        public PD_GameStats_Report(
            PD_Game game,
            PD_AI_PathFinder pathFinder
            )
        {
            GameSettings  = new PD_GR_P_GameSettings(game, pathFinder);
            GameCondition = new PD_GR_P_GameCondition(game, pathFinder);
            GameScores    = new PD_GR_P_GameScores(game, pathFinder);
            ActionStats   = new PD_GR_P_ActionStats(game, pathFinder);
            GameStateEvaluationMetrics = new PD_GR_P_GameStateEvaluationMetrics(game, pathFinder);
            MapStats = new PD_GR_P_MapStats(game, pathFinder);

            Update(game, pathFinder);
        }
Exemple #27
0
 public override List <PD_MacroAction> FilterMacros(
     PD_Game game,
     PD_AI_PathFinder pathFinder,
     List <PD_MacroAction> allMacros)
 {
     return(allMacros.FindAll(
                x =>
                (
                    x.Is_TypeOf_ShareKnowledge_Any()
                    ||
                    x.Is_TypeOf_TakePositionFor_ShareKnowledge_Any()
                )
                ));
 }
Exemple #28
0
        public override List <PD_MacroAction> FilterMacros(
            PD_Game game,
            PD_AI_PathFinder pathFinder,
            List <PD_MacroAction> allMacros
            )
        {
#if DEBUG
            if (game.GQ_IsInState_Discard_Any() == false)
            {
                throw new System.Exception("game is not in discard state");
            }
            if (
                allMacros.Any(
                    x =>
                    x.Is_TypeOf_Discard_Any() == false
                    )
                )
            {
                throw new System.Exception("non discard actions are included here...");
            }
#endif

            int playerWhoDiscards = ((I_Player_Action)allMacros[0].Actions_All[0]).Player;

            Dictionary <PD_MacroAction, double> effectPerMacroAction = new Dictionary <PD_MacroAction, double>();
            foreach (var macro in allMacros)
            {
                double effect =
                    PD_AI_CardEvaluation_Utilities
                    .Calculate_ListOfPlayerActions_Effect_On_Percent_AbilityToCureDiseases(
                        game,
                        macro.Actions_Executable_Now,
                        true
                        );
                effectPerMacroAction.Add(macro, effect);
            }

            double maximumValue = effectPerMacroAction.Max(x => x.Value);

            List <PD_MacroAction> maximumValueMacros = new List <PD_MacroAction>();
            foreach (var macro in allMacros)
            {
                if (effectPerMacroAction[macro] == maximumValue)
                {
                    maximumValueMacros.Add(macro);
                }
            }

            return(maximumValueMacros);
        }
 public override void Update(
     PD_Game game,
     PD_AI_PathFinder pathFinder
     )
 {
     GameOngoing       = game.GQ_Is_Ongoing() ? 1 : 0;
     GameWon           = game.GQ_Is_Won() ? 1 : 0;
     GameLost          = game.GQ_Is_Lost() ? 1 : 0;
     Lost_Outbreaks    = game.GQ_SS_DeadlyOutbreaks() ? 1 : 0;
     Lost_DiseaseCubes =
         game.game_state_counter.insufficient_disease_cubes_for_infection ? 1 : 0;
     Lost_PlayerCards =
         game.game_state_counter.insufficient_player_cards_to_draw ? 1 : 0;
 }
 public void Update(PD_Game game, PD_AI_PathFinder pathFinder, PolicyBased_RHE_Agent rollingHorizonAgent)
 {
     Times_AgentUsed++;
     Total_Successful_Mutations += rollingHorizonAgent.Num_Successful_Mutations_ThisTime;
     Total_Successful_Mutations_FirstActionDifferent += rollingHorizonAgent.Num_Successful_Mutations_Different_FirstAction_ThisTime;
     if (rollingHorizonAgent.Num_Successful_Mutations_ThisTime > 0)
     {
         Times_AgentUsed_With_Successful_Mutations++;
     }
     if (rollingHorizonAgent.Num_Successful_Mutations_Different_FirstAction_ThisTime > 0)
     {
         Times_AgentUsed_With_Successful_Mutations_FirstActionDifferent++;
     }
 }