Beispiel #1
0
        public void InitTree(TyStateAnalyzer analyzer, POGame root, List <PlayerTask> options)
        {
            _sortedNodes.Clear();
            _explorableNodes.Clear();
            _nodesToEstimate.Clear();

            _analyzer = analyzer;
            _rootGame = root;

            //var initialResults = TyStateUtility.GetSimulatedGames(root, options, _analyzer);

            for (int i = 0; i < options.Count; i++)
            {
                PlayerTask task = options[i];

                var node = new TyTaskNode(this, _analyzer, task, 0.0f);

                //end turn is pretty straight forward, should not really be looked at later in the simulations, just simulate once and keep the value:
                if (task.PlayerTaskType == PlayerTaskType.END_TURN)
                {
                    TySimResult sim = TyStateUtility.GetSimulatedGame(root, task, _analyzer);
                    node.AddValue(sim.value);
                }
                else
                {
                    _explorableNodes.Add(node);
                    _sortedNodes.Add(node);
                }

                _nodesToEstimate.Add(task, node);
            }
        }
Beispiel #2
0
 public TyTaskNode(TySimTree tree, TyStateAnalyzer analyzer, PlayerTask task, float totalValue)
 {
     _tree       = tree;
     _analyzer   = analyzer;
     _task       = task;
     _totalValue = totalValue;
     _visits     = 0;
 }
        public static TySimResult GetSimulatedGame(POGame parent, PlayerTask task, TyStateAnalyzer analyzer)
        {
            POGame simulatedState = parent.Simulate(new List <PlayerTask>()
            {
                task
            })[task];
            float stateValue = GetStateValue(parent, simulatedState, task, analyzer);

            return(new TySimResult(simulatedState, task, stateValue));
        }
Beispiel #4
0
        private TycheAgentCompetition(TyStateWeights weights, bool heroBasedWeights, int episodeMultiplier, bool adjustEpisodeMultiplier)
        {
            _defaultEpisodeMultiplier = episodeMultiplier;
            _curEpisodeMultiplier     = episodeMultiplier;
            _heroBasedWeights         = heroBasedWeights;

            _analyzer = new TyStateAnalyzer(weights);
            _simTree  = new TySimTree();
            _random   = new Random();

            AdjustEpisodeMultiplier = adjustEpisodeMultiplier;
        }
        /// <summary> Estimates how good the given child state is. </summary>
        public static float GetStateValue(POGame parent, POGame child, PlayerTask task, TyStateAnalyzer analyzer)
        {
            float valueFactor = 1.0f;

            TyState myState    = null;
            TyState enemyState = null;

            Controller player   = null;
            Controller opponent = null;

            //it's a buggy state, mostly related to equipping/using weapons on heroes etc.
            //in this case use the old state and estimate the new state manually:
            if (child == null)
            {
                player   = parent._game.CurrentPlayer;
                opponent = parent._game.CurrentOpponent;

                myState    = TyState.FromSimulatedGame(parent, player, task);
                enemyState = TyState.FromSimulatedGame(parent, opponent, null);

                //if the correction failes, assume the task is x% better/worse:
                if (!TyState.CorrectBuggySimulation(myState, enemyState, parent, task))
                {
                    valueFactor = 1.25f;
                }
            }

            else
            {
                player   = child._game.CurrentPlayer;
                opponent = child._game.CurrentOpponent;

                //happens sometimes even with/without TURN_END, idk
                if (!analyzer.IsMyPlayer(player))
                {
                    player   = child._game.CurrentOpponent;
                    opponent = child._game.CurrentPlayer;
                }

                myState    = TyState.FromSimulatedGame(child, player, task);
                enemyState = TyState.FromSimulatedGame(child, opponent, null);
            }

            TyDebug.Assert(analyzer.IsMyPlayer(player));
            TyDebug.Assert(!analyzer.IsMyPlayer(opponent));
            return(analyzer.GetStateValue(myState, enemyState, player, opponent, task) * valueFactor);
        }
        /// <summary> Returns a list of simulated games with the given parameters. </summary>
        public static List <TySimResult> GetSimulatedGames(POGame parent, List <PlayerTask> options, TyStateAnalyzer analyzer)
        {
            List <TySimResult> stateTaskStructs = new List <TySimResult>();

            for (int i = 0; i < options.Count; i++)
            {
                stateTaskStructs.Add(GetSimulatedGame(parent, options[i], analyzer));
            }

            return(stateTaskStructs);
        }
 /// <summary> Returns N sorted simulated TySimResults for the given start state. </summary>
 public static List <TySimResult> GetSimulatedBestTasks(int numTasks, POGame game, List <PlayerTask> options, TyStateAnalyzer analyzer)
 {
     return(GetSortedBestTasks(numTasks, GetSimulatedGames(game, options, analyzer)));
 }
 /// <summary> Returns N sorted simulated TySimResults for the given start state. </summary>
 public static List <TySimResult> GetSimulatedBestTasks(int numTasks, POGame game, TyStateAnalyzer analyzer)
 {
     return(GetSimulatedBestTasks(numTasks, game, game._game.CurrentPlayer.Options(), analyzer));
 }