Exemplo n.º 1
0
    public CommandShowHand(Player caller, HandZone hand, bool cardsAreFacingUp)
    {
        this.caller           = caller;
        this.hand             = hand;
        this.cardsAreFacingUp = cardsAreFacingUp;
        exCardsAreFacingUp    = hand.CardsAreVisibleToOthers;

        cards         = hand.GetCardsInhand().ToArray();
        isFacingUps   = new bool[cards.Length];
        exIsFacingUps = new bool[cards.Length];

        for (int i = 0; i < cards.Length; i++)
        {
            isFacingUps[i]   = cardsAreFacingUp;
            exIsFacingUps[i] = cards[i].ExIsFacingUp;
        }
    }
Exemplo n.º 2
0
    void SpawnHandAndTable()
    {
        //hand.transform.localPosition.Set(0, -2.7f, 0);
        hand = Instantiate(handPrefab, this.transform);
        //hand.parent = this.gameObject;
        hand.ownerNetId = this.netId;
        hand.zoneName   = playerName + "'s hand";
        hand.zoneColor  = this.playerColor;


        NetworkServer.Spawn(hand.gameObject);
        handObject = hand.gameObject;

        Table = Instantiate(tablePrefab, this.transform);
        NetworkServer.Spawn(Table.gameObject);
        tableObject = Table.gameObject;

        TableEditorDataHolder tableEditorManager = GameObject.FindGameObjectWithTag("TableEditorDataHolder").GetComponent <TableEditorDataHolder>();

        tableEditorManager.PlayerTable.SpawnEntities(Table.gameObject, this);
    }
        public void CreateFullInformationGame(List <Card> deck_player1, DeckZone deckzone_player1, HandZone handzone_player1, List <Card> deck_player2, DeckZone deckzone_player2, HandZone handzone_player2)
        {
            game.Player1.DeckCards = deck_player1;
            game.Player1.DeckZone  = deckzone_player1;
            game.Player1.HandZone  = handzone_player1;

            game.Player2.DeckCards = deck_player2;
            game.Player2.DeckZone  = deckzone_player2;
            game.Player2.HandZone  = handzone_player2;
        }
Exemplo n.º 4
0
 public static void DisposeHandZoneListener(this IHandZoneListener Listener)
 {
     HandZone.DisposeHandZoneListener(Listener);
 }
Exemplo n.º 5
0
 public static void RegisterHandZoneListener(this IHandZoneListener Listener)
 {
     HandZone.RegisterHandZoneListener(Listener);
 }
Exemplo n.º 6
0
        private int getHandCardCount(Controller player)
        {
            HandZone handZone = player.HandZone;

            return(handZone.Count);
        }
Exemplo n.º 7
0
        public float SocketEvaluate(Game game)
        {
            //int[] features = new int[163];
            int       count       = 0;
            HandZone  Hand        = game.CurrentPlayer.HandZone;
            BoardZone BoardZone   = game.CurrentPlayer.BoardZone;
            BoardZone OpBoardZone = game.CurrentPlayer.Opponent.BoardZone;

            Minion[] minions = BoardZone.GetAll();
            features[count++] = (game.Turn);
            features[count++] = ((int)game.CurrentPlayer.HeroClass);
            features[count++] = (game.CurrentPlayer.Hero.Weapon == null ? 0 : game.CurrentPlayer.Hero.Weapon.Card.AssetId);
            features[count++] = (game.CurrentPlayer.Hero.Weapon == null ? 0 : game.CurrentPlayer.Hero.Weapon.AttackDamage);
            features[count++] = (game.CurrentPlayer.Hero.Weapon == null ? 0 : game.CurrentPlayer.Hero.Weapon.Durability);
            features[count++] = (game.CurrentPlayer.Hero.Health);
            features[count++] = (game.CurrentPlayer.BaseMana);
            features[count++] = (game.CurrentPlayer.HandZone.Count);
            features[count++] = (game.CurrentPlayer.DeckZone.Count);
            features[count++] = (game.CurrentPlayer.BoardZone.Count);
            for (int i = 0; i < game.CurrentPlayer.HandZone.Count; i++)
            {
                features[count++] = (game.CurrentPlayer.HandZone[i].Card.AssetId);
            }
            for (int i = 0; i < 10 - game.CurrentPlayer.HandZone.Count; i++)
            {
                features[count++] = (0);
            }
            foreach (Minion minion in minions)
            {
                features[count++] = (minion.Card.AssetId);
                features[count++] = (minion[GameTag.ATK]);
                features[count++] = (minion[GameTag.HEALTH]);
                features[count++] = (minion[GameTag.DAMAGE]);
                features[count++] = (minion[GameTag.STEALTH]);
                features[count++] = (minion[GameTag.IMMUNE]);
                features[count++] = (minion[GameTag.TAUNT]);
                features[count++] = (minion[GameTag.CANT_BE_TARGETED_BY_SPELLS]);
                features[count++] = (minion[GameTag.NUM_ATTACKS_THIS_TURN]);
                features[count++] = (minion.Card.AssetId);
            }
            for (int _ = 0; _ < 7 - minions.Length; _++)
            {
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
            }
            features[count++] = ((int)game.CurrentOpponent.HeroClass);
            features[count++] = (game.CurrentOpponent.Hero.Weapon == null ? 0 : game.CurrentOpponent.Hero.Weapon.Card.AssetId);
            features[count++] = (game.CurrentOpponent.Hero.Weapon == null ? 0 : game.CurrentOpponent.Hero.Weapon.AttackDamage);
            features[count++] = (game.CurrentOpponent.Hero.Weapon == null ? 0 : game.CurrentOpponent.Hero.Weapon.Durability);
            features[count++] = (game.CurrentOpponent.Hero.Health);
            features[count++] = (game.CurrentOpponent.BaseMana);
            features[count++] = (game.CurrentOpponent.HandZone.Count);
            features[count++] = (game.CurrentOpponent.DeckZone.Count);
            features[count++] = (game.CurrentOpponent.BoardZone.Count);
            minions           = OpBoardZone.GetAll();
            foreach (Minion minion in minions)
            {
                features[count++] = (minion.Card.AssetId);
                features[count++] = (minion[GameTag.ATK]);
                features[count++] = (minion[GameTag.HEALTH]);
                features[count++] = (minion[GameTag.DAMAGE]);
                features[count++] = (minion[GameTag.STEALTH]);
                features[count++] = (minion[GameTag.IMMUNE]);
                features[count++] = (minion[GameTag.TAUNT]);
                features[count++] = (minion[GameTag.CANT_BE_TARGETED_BY_SPELLS]);
                features[count++] = (minion[GameTag.NUM_ATTACKS_THIS_TURN]);
                features[count++] = (minion.Card.AssetId);
            }
            for (int _ = 0; _ < 7 - minions.Length; _++)
            {
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
                features[count++] = (0);
            }

            // Safety check
            if (count != 169)
            {
                Console.WriteLine("ERROR: Incorrect parameter size!");
            }

            for (int i = 0; i < features.Length; i++)
            {
                byte[] tmpBytes = BitConverter.GetBytes(features[i]);
                dataBuffer[4 * i + 0] = tmpBytes[0];
                dataBuffer[4 * i + 1] = tmpBytes[1];
                dataBuffer[4 * i + 2] = tmpBytes[2];
                dataBuffer[4 * i + 3] = tmpBytes[3];
            }

            NNSocket.Send(dataBuffer);

            NNSocket.Receive(receiveBuffer, 4, SocketFlags.None);

            return(BitConverter.ToSingle(receiveBuffer));
        }
        public void OutputCurrentGameForTrainingData(Game game)
        {
            List <int> features    = new List <int>();
            HandZone   Hand        = game.CurrentPlayer.HandZone;
            BoardZone  BoardZone   = game.CurrentPlayer.BoardZone;
            BoardZone  OpBoardZone = game.CurrentPlayer.Opponent.BoardZone;

            Minion[] minions = BoardZone.GetAll();
            features.Add(game.Turn);
            features.Add((int)game.CurrentPlayer.HeroClass);
            features.Add(game.CurrentPlayer.Hero.Weapon == null? 0 : game.CurrentPlayer.Hero.Weapon.Card.AssetId);
            features.Add(game.CurrentPlayer.Hero.Weapon == null? 0 : game.CurrentPlayer.Hero.Weapon.AttackDamage);
            features.Add(game.CurrentPlayer.Hero.Weapon == null? 0 : game.CurrentPlayer.Hero.Weapon.Durability);
            features.Add(game.CurrentPlayer.Hero.Health);
            features.Add(game.CurrentPlayer.BaseMana);
            features.Add(game.CurrentPlayer.HandZone.Count);
            features.Add(game.CurrentPlayer.DeckZone.Count);
            features.Add(game.CurrentPlayer.BoardZone.Count);
            for (int i = 0; i < game.CurrentPlayer.HandZone.Count; i++)
            {
                features.Add(game.CurrentPlayer.HandZone[i].Card.AssetId);
            }
            for (int i = 0; i < 10 - game.CurrentPlayer.HandZone.Count; i++)
            {
                features.Add(0);
            }
            foreach (Minion minion in minions)
            {
                features.Add(minion.Card.AssetId);
                features.Add(minion[GameTag.ATK]);
                features.Add(minion[GameTag.HEALTH]);
                features.Add(minion[GameTag.DAMAGE]);
                features.Add(minion[GameTag.STEALTH]);
                features.Add(minion[GameTag.IMMUNE]);
                features.Add(minion[GameTag.TAUNT]);
                features.Add(minion[GameTag.CANT_BE_TARGETED_BY_SPELLS]);
                features.Add(minion[GameTag.NUM_ATTACKS_THIS_TURN]);
                features.Add(minion.Card.AssetId);
            }
            for (int _ = 0; _ < 7 - minions.Length; _++)
            {
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
            }
            features.Add((int)game.CurrentOpponent.HeroClass);
            features.Add(game.CurrentOpponent.Hero.Weapon == null ? 0 : game.CurrentOpponent.Hero.Weapon.Card.AssetId);
            features.Add(game.CurrentOpponent.Hero.Weapon == null ? 0 : game.CurrentOpponent.Hero.Weapon.AttackDamage);
            features.Add(game.CurrentOpponent.Hero.Weapon == null ? 0 : game.CurrentOpponent.Hero.Weapon.Durability);
            features.Add(game.CurrentOpponent.Hero.Health);
            features.Add(game.CurrentOpponent.BaseMana);
            features.Add(game.CurrentOpponent.HandZone.Count);
            features.Add(game.CurrentOpponent.DeckZone.Count);
            features.Add(game.CurrentOpponent.BoardZone.Count);
            minions = OpBoardZone.GetAll();
            foreach (Minion minion in minions)
            {
                features.Add(minion.Card.AssetId);
                features.Add(minion[GameTag.ATK]);
                features.Add(minion[GameTag.HEALTH]);
                features.Add(minion[GameTag.DAMAGE]);
                features.Add(minion[GameTag.STEALTH]);
                features.Add(minion[GameTag.IMMUNE]);
                features.Add(minion[GameTag.TAUNT]);
                features.Add(minion[GameTag.CANT_BE_TARGETED_BY_SPELLS]);
                features.Add(minion[GameTag.NUM_ATTACKS_THIS_TURN]);
                features.Add(minion.Card.AssetId);
            }
            for (int _ = 0; _ < 7 - minions.Length; _++)
            {
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
                features.Add(0);
            }
            tmpData.Enqueue(features);
        }
Exemplo n.º 9
0
        /// <summary>
        /// Updates this agent's estimation of the opponent
        /// </summary>
        void UpdateOpponent(int handSize)
        {
            Opponent.Game     = BlindGame;
            Opponent.Deck     = OpponentDeck.Clone();
            Opponent.DeckZone = OpponentDeckZone.Clone(Opponent);
            //OpponentDeckZone.Controller = Opponent;

            OpponentHandZone = new HandZone(Opponent);
            //{
            //	Controller = Opponent
            //};

            foreach (Card card in OpponentDeck)
            {
                Entity.FromCard(Opponent, card, null, OpponentDeckZone);
            }

            foreach (Card card in PlayedSoFar)
            {
                if (OpponentDeckZone.Contains(card))
                {
                    OpponentDeckZone.Remove(card);
                }
            }

            for (int i = 0; i < handSize; ++i)
            {
                IPlayable rnd = OpponentDeckZone.Random;
                OpponentDeckZone.Remove(rnd);
                rnd.Controller = OpponentHandZone.Controller;
                OpponentHandZone.Add(rnd);
            }

            Opponent.HandZone     = OpponentHandZone.Clone(Opponent);
            OpponentGraveyardZone = BlindGame.CurrentOpponent.GraveyardZone.Clone(Opponent);

            if (BlindGame.CurrentOpponent.SecretZone.Count == 0)
            {
                OpponentSecretZone = new SecretZone(Opponent);
            }

            else if (BlindGame.CurrentOpponent.SecretZone.Count == 1 && BlindGame.CurrentOpponent.SecretZone.Contains(s => s.IsQuest))
            {
                OpponentSecretZone = BlindGame.CurrentOpponent.SecretZone.Clone(Opponent);
            }

            else
            {
                OpponentSecretZone = new SecretZone(Opponent);
                if (!OpponentDeck.Contains(c => c.IsSecret))
                {
                    AddBlindSecrets();
                }

                else
                {
                    var secretsPlayed = OpponentGraveyardZone.Where(p => p.Card.IsSecret).ToList();
                    if (secretsPlayed != null)
                    {
                        List <string> secrets = GetSecrets(Opponent.HeroClass);
                        foreach (Spell s in secretsPlayed)
                        {
                            if (secretsPlayed.Count(s) > 2)
                            {
                                secrets.Remove(s.Card.Name);
                            }
                        }

                        if (secrets.Count != 0)
                        {
                            AddBlindSecrets(secrets);
                        }

                        else
                        {
                            AddBlindSecrets(GetSecrets(Opponent.HeroClass));
                        }
                    }
                }
            }

            BlindGame.Player2              = Opponent;
            BlindGame.CurrentPlayer.Game   = BlindGame;
            BlindGame.CurrentOpponent.Game = BlindGame;
        }
Exemplo n.º 10
0
        /// <summary>
        /// TODO: API
        /// </summary>
        /// <param name="oppGame"></param>
        /// <param name="opponent">the controller of the opponent</param>
        /// <param name="predicitionMap">the map with all predictions</param>
        /// <param name="newSimulations"></param>
        /// <returns></returns>
        private double simulateOpponentWithPrediction(double lowerTimeBound, double timePerLeaf, POGame.POGame oppGame, Controller opponent,
                                                      List <Prediction> predicitionMap, ref Dictionary <POGame.POGame, List <MCTSNode> > newSimulations)
        {
            double predictionScore = 0;

            if (predicitionMap?.Any() ?? false)
            {
                int denominator = predicitionMap.Count;
                var scorings    = predicitionMap.GroupBy(p => p.Deck.Scoring)
                                  .Select(c => new MCTSNode.ScoreExt(((double)c.Count() / denominator), c.Key))
                                  .OrderByDescending(s => s.Value).ToList();

                // the simulation time for one prediction
                double timePerPrediction = timePerLeaf / predicitionMap.Count;

                // use prediction for each game
                for (int i = 0; i < predicitionMap.Count; i++)
                {
                    Prediction prediction   = predicitionMap[i];
                    var        setasideZone = opponent.ControlledZones[Zone.SETASIDE] as SetasideZone;
                    setasideZone = new SetasideZone(opponent);

                    // create deck zone
                    List <Card> deckCards = prediction.Deck.Cards;
                    var         deckZone  = opponent.ControlledZones[Zone.DECK] as DeckZone;
                    deckZone = new DeckZone(opponent);
                    createZone(opponent, deckCards, deckZone, ref setasideZone);
                    deckZone.Shuffle();

                    // create hand zone
                    List <Card> handCards = prediction.Hand.Cards;
                    var         handZone  = opponent.ControlledZones[Zone.HAND] as HandZone;
                    handZone = new HandZone(opponent);
                    createZone(opponent, handCards, handZone, ref setasideZone);

                    var    oppLeafNodes = new List <MCTSNode>();
                    IScore oppStrategy  = prediction.Deck.Scoring;

                    // forward game
                    POGame.POGame forwardGame = oppGame.getCopy();

                    // upper time bound for simulation the opponent using the current prediction
                    double oppSimulationTime = lowerTimeBound + (i + 1) * timePerPrediction / 2;

                    // simulate opponent's moves
                    while (forwardGame != null &&
                           forwardGame.State == State.RUNNING &&
                           forwardGame.CurrentPlayer.Id == opponent.Id)
                    {
                        // simulate
                        var      oppRoot     = new MCTSNode(opponent.Id, scorings, forwardGame, null, null);
                        MCTSNode bestOppNode = simulate(oppSimulationTime, oppRoot, ref oppLeafNodes);
                        // get solution
                        List <PlayerTask> solutions = bestOppNode.GetSolution();
                        for (int j = 0; j < solutions.Count && (forwardGame != null); j++)
                        {
                            PlayerTask oppTask = solutions[j];
                            Dictionary <PlayerTask, POGame.POGame> dir = forwardGame.Simulate(new List <PlayerTask> {
                                oppTask
                            });
                            forwardGame = dir[oppTask];

                            if (forwardGame != null && forwardGame.CurrentPlayer.Choice != null)
                            {
                                break;
                            }
                        }
                    }

                    // upper time bound for simulation the player using the forwarded game
                    double simulationTime = oppSimulationTime + timePerPrediction / 2;
                    double score          = 0;
                    var    leafs          = new List <MCTSNode>();

                    // simulate player using forwarded opponent game
                    while (forwardGame != null &&
                           forwardGame.State == State.RUNNING &&
                           forwardGame.CurrentPlayer.Id == _playerId)
                    {
                        // simulate
                        var root = new MCTSNode(_playerId, new List <MCTSNode.ScoreExt> {
                            new MCTSNode.ScoreExt(1.0, _scoring)
                        }, forwardGame, null, null);
                        MCTSNode bestNode = simulate(simulationTime, root, ref leafs);
                        // get solution
                        List <PlayerTask> solutions = bestNode.GetSolution();
                        for (int j = 0; j < solutions.Count && (forwardGame != null); j++)
                        {
                            PlayerTask task = solutions[j];
                            Dictionary <PlayerTask, POGame.POGame> dir = forwardGame.Simulate(new List <PlayerTask> {
                                task
                            });
                            forwardGame = dir[task];

                            if (forwardGame != null && forwardGame.CurrentPlayer.Choice != null)
                            {
                                break;
                            }
                        }
                        // TODO: maybe penalty forwardGame == null
                        score = bestNode.TotalScore;
                    }
                    predictionScore += score;

                    if (forwardGame != null)
                    {
                        newSimulations.Add(forwardGame, leafs);
                    }
                }
            }
            return(predictionScore);
        }
Exemplo n.º 11
0
        //Choice cards***can choose a task when you play it
        private PlayerTask PlayCard(List <PlayerTask> PlayerTaskList, Controller myself, HandZone myHand, BoardZone theBoard, POGame game)
        {
            PlayerTask returnTask         = null;
            int        maxManaCard        = 0;
            int        HighestDamage      = 0;
            int        WeaponAttackDamage = 0;

            //For each valid option, prints all available moves and the cost of the card
            foreach (PlayerTask task in PlayerTaskList)
            {
                if (task.PlayerTaskType == PlayerTaskType.PLAY_CARD)
                {
                    /*if(task.Target != null){
                     *      Console.WriteLine($"Can Play: {task} Mana: {task.Source.Card.Cost} Target Controller: {task.Target.Controller} Type: {task.Source.Card.Type}");
                     * }
                     * else{
                     *      Console.WriteLine($"Can Play {task}, {task.Source.Card.Cost} mana. Type: {task.Source.Card.Type}");
                     * }*/

                    var cardType = task.Source.Card.Type;
                    if (game.CurrentPlayer.RemainingMana > 0)
                    {
                        if (cardType == CardType.MINION)
                        {
                            //Console.WriteLine(task);
                            //Console.WriteLine($"Entered if statement 0");
                            if (task.Source.Card.Taunt == true)
                            {
                                //Console.WriteLine($"Entered if statement 1");
                                if (theBoard.Count() >= 1)
                                {
                                    //Console.WriteLine($"Entered if statement 2");
                                    returnTask = task;
                                }
                            }
                            else if (task.Source.Card.Charge == true || task.Source.Card.Rush == true && task.PlayerTaskType == PlayerTaskType.PLAY_CARD && task.Source.Card.Cost >= maxManaCard)
                            {
                                //Adds to the task list because these  minions can attack in the same turn
                                //Console.WriteLine($"Entered if statement 3");
                                maxManaCard = task.Source.Card.Cost;
                                returnTask  = task;
                                var    mi             = new MinionID();                  //mi = minion id
                                Minion PlayerMinion   = null;
                                Minion OpponentMinion = null;
                                foreach (var x in playerList)
                                {
                                    if (x.ToString().Equals(task.Source.ToString()))
                                    {
                                        PlayerMinion = x;
                                    }
                                }
                                int Damage = 0;
                                foreach (var y in opponentList)
                                {
                                    if (y.AttackDamage > Damage)
                                    {
                                        Damage         = Damage + y.AttackDamage;
                                        OpponentMinion = y;
                                    }
                                }
                                mi.playerMinion   = PlayerMinion;
                                mi.opponentMinion = OpponentMinion;
                                TurnTaskList.Add(mi);
                                continue;
                            }
                            else
                            {
                                if (task.PlayerTaskType == PlayerTaskType.PLAY_CARD && task.Source.Card.Cost >= maxManaCard)
                                {
                                    maxManaCard = task.Source.Card.Cost;
                                    returnTask  = task;
                                }
                            }
                        }
                        else if (cardType == CardType.SPELL && task.Target != null && task.Target.Controller != myself && task.Target.Health > 0)
                        {
                            //Better way to verify spell target by ID
                            for (int i = 0; i < opponentList.Count(); i++)
                            {
                                if (opponentList[i].Id == task.Target.Id)
                                {
                                    returnTask = task;
                                }
                                else if (task.Target.AttackDamage > HighestDamage)
                                {
                                    HighestDamage = task.Target.AttackDamage;
                                    returnTask    = task;
                                }
                            }
                            if (task.Target.Id == game.CurrentOpponent.Hero.Id)
                            {
                                returnTask = task;
                            }
                            continue;
                        }
                        else if (cardType == CardType.WEAPON)
                        {
                            if (task.Source.Card.ATK > WeaponAttackDamage)
                            {
                                WeaponAttackDamage = task.Source.Card.ATK;
                                returnTask         = task;
                            }
                        }
                        // can't explicitly target own minions and hero
                        else if (task.Target == null)
                        {
                            maxManaCard = task.Source.Card.Cost;
                            returnTask  = task;
                        }
                    }
                    else if (myHand.Count() == 1)
                    {
                        returnTask = task;
                    }
                    else
                    {
                        //Console.WriteLine($"No play card task available");
                    }
                }
            }


            /*if(returnTask == null){
             *      Console.WriteLine("Return Playcard task: No card selected");
             * }
             * else{
             *      Console.WriteLine($"Return PlayCard task: {returnTask}");
             * }*/

            return(returnTask);
        }