Example #1
0
        public override void TakeTurn(IBoardGame gameBoard)
        {
            if (!this.CanTakeTurn)
            {
                return;
            }

            // hard code in specific abilities depending on the monster
            var cleanupTurn = new CleanupTurn(this);
            cleanupTurn.Cleanup();

            // simply attack right now
            var humanPlayers = gameBoard.GetHumanPlayers().ToList();
            var humanToAttack = new RandomPlayer().TargetPlayer(humanPlayers);

            if (humanToAttack < 0)
            {
                return;
            }

            var humanPlayer = humanPlayers[humanToAttack];
            var attackAmount = new StaticAmount().AttackAmount();
            var attackParameters = new AttackParameters
                                       {
                                           AdjustedAmount = attackAmount,
                                           OriginalAmount = attackAmount,
                                           PlayerAttacking = this,
                                           PlayerBeingAttacked = humanPlayer
                                       };

            humanPlayer.TakeDamage(gameBoard, attackParameters);

            GameLogger.LogFormat("{0} gave {1} damage to {2}", this.Name, attackAmount, attackParameters.ReportPlayersBeingAttacked());
        }
Example #2
0
 public MCTSPlayer(IBoardGame <TGameState> game, double confidenceCoef, TimeSpan simulationTimeLimit)
 {
     Game                = game;
     ConfidenceCoef      = confidenceCoef;
     SimulationTimeLimit = simulationTimeLimit;
     Statistics          = new Dictionary <TGameState, StatisticsRecord>();
 }
Example #3
0
 public AttackCard(HumanPlayer player, IBoardGame gameBoard, ITargetPlayer targetPlayer, IAttackAmount attackAmount)
 {
     this.player = player;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
     this.attackAmount = attackAmount;
 }
Example #4
0
        public override void DrawCard(IBoardGame gameBoard)
        {
            if (CurrentCards.Count > 4)
            {
                GameLogger.LogFormat("{0} drew no cards because they have {1} already.", this.Name, this.CurrentCards.Count);
                return;
            }

            var iter = 0;
            while (this.CurrentCards.Count < 5 && iter < 5)
            {
                // select from the list of cards to draw from
                if (this.CardsToDrawFrom.Any())
                {
                    var randCardIdx = Randomizer.GetRandomValue(0, this.CardsToDrawFrom.Count - 1);
                    var firstCard = this.CardsToDrawFrom[randCardIdx];

                    GameLogger.LogFormat("{0} drew {1}.", this.Name, firstCard.Name);
                    this.CurrentCards.Add(firstCard);
                }
                else
                {
                    // reshuffle
                    foreach (var card in this.DrawnCards)
                    {
                        this.CardsToDrawFrom.Add(card);
                    }

                    this.DrawnCards.Clear();
                }

                iter++;
            }
        }
 void Awake()
 {
     Debug.Log("AREngine Starting up..");
     arRaycastManager = GetComponent <ARRaycastManager>();
     touchPosition    = default;
     boardGame        = Game.CURRENTGAMEMETADATA.GetBoardGame();
     boardPlaced      = false;
     Debug.Log("AREngine Online");
 }
Example #6
0
        public override void Initialize(IBoardGame gameBoard)
        {
            for (var i = 0; i < 4; i++)
            {
                var card = new DrainLife(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 6; i++)
            {
                var card = new MagicMissile(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 6; i++)
            {
                var card = new DragonFlame(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 3; i++)
            {
                var card = new FrostBolt(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 6; i++)
            {
                var card = new SurefireShot(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 3; i++)
            {
                var card = new LightningBolt(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 6; i++)
            {
                var card = new ColdSnap(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 1; i++)
            {
                var card = new FireBall(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }

            for (var i = 0; i < 1; i++)
            {
                var card = new BallOfForce(this, gameBoard, new LowestHpPlayer());
                this.CardsToDrawFrom.Add(card);
            }
        }
 public BoardEngine(
     IGameSettings gameSettings,
     IBoardGame boardGame,
     IPlayer player1,
     IPlayer player2)
 {
     _gameSettings = gameSettings;
     _boardGame    = boardGame;
     _player1      = player1;
     _player2      = player2;
 }
Example #8
0
        public override Move <ConnectFourToken> GetNextMove(IBoardGame <ConnectFourToken> game)
        {
            string input;
            Move <ConnectFourToken> move;

            do
            {
                Console.Write($"Player {this}, enter a column number [{1}, {game.Width}]: ");
                input = Console.ReadLine();
            }while (!int.TryParse(input, out int result) || !game.IsMoveAllowed(move = new Move <ConnectFourToken>(this, new Coordinate(result, 1))));

            return(move);
        }
Example #9
0
        private void startGame(String name)
        {
            // end any games that may have been running
            endGameThread();

            prepareRenderPanel();

            IBoardGame myGame = gamePool.getGame(name);

            myGame.setRenderSurface(renderPanel);
            // make and start a new thread
            gamethread = new Thread(new ThreadStart(myGame.gameLoop));
            gamethread.Start();
        }
Example #10
0
        /**
         *
         */
        public bool loadPlugins(String argDirectory, out Dictionary <String, IBoardGame> argCollection)
        {
            // make the collection class we want to set as our out parameter
            Dictionary <String, IBoardGame> plugins = new Dictionary <String, IBoardGame>();
            bool success = true;

            // log it
            Logger.log("PluginLoader: Loading plugins...", LEVEL.DEBUG);

            try
            {
                // try to obtain a list of all plugins, this may throw an exception
                List <String> paths = getAllPlugins(argDirectory);

                // if there are no plugins present...
                if (paths.Count == 0)
                {
                    Logger.log("PluginLoader: Warning - no plugins found", LEVEL.WARNING);
                }

                // for all plugin paths in the list...
                foreach (String path in paths)
                {
                    // load the game from the path
                    IBoardGame game = loadGameFromDll(path);

                    // check we didnt obtain a null pointer
                    if (game != null)
                    {
                        // add the plugin to our collection
                        plugins.Add(game.getName(), game);

                        // log it
                        Logger.log("PluginLoader: Loaded: " + game.getName() + " [game version " + game.getGameVersion() + ", engine version " + game.getEngineVersion() + "]", LEVEL.DEBUG);
                    }
                }
            }
            catch (System.IO.DirectoryNotFoundException)
            {
                // we cannot find a plugins directory
                // log it and return false
                Logger.log("PluginLoader: Error - plugin directory not found", LEVEL.ERROR);
                success = false;
            }

            // assing the out parameter
            argCollection = plugins;

            return(success);
        }
Example #11
0
        public override void TakeDamage(IBoardGame gameBoard, AttackParameters attackParameters)
        {
            var humanPlayers = gameBoard.GetHumanPlayers();

            // all of them will play defensive cards
            foreach (var humanPlayer in humanPlayers)
            {
                var defensiveInstant = humanPlayer.CurrentCards.FirstOrDefault(card => card.IsDefensiveInstant);
                if (defensiveInstant != null && !humanPlayer.UsedInstantCard && defensiveInstant.CanUse(attackParameters))
                {
                    defensiveInstant.Use(attackParameters);
                    humanPlayer.CurrentCards.Remove(defensiveInstant);
                }
            }

            // we'll take damage here
            base.TakeDamage(gameBoard, attackParameters);
        }
        public override Move <ConnectFourToken> GetNextMove(IBoardGame <ConnectFourToken> game)
        {
            ConnectFourGame clone = (ConnectFourGame)game.Clone();

            (Move <ConnectFourToken> nextMove, int _) = Minimax(
                moveAndPosition: (Move <ConnectFourToken> .Default, clone),
                depth: MinimaxDepth,
                alpha: int.MinValue,
                beta: int.MaxValue,
                currentPlayer: clone.CurrentPlayer,
                maximizingCurrentPlayer: true);

            if (!game.IsMoveAllowed(nextMove))
            {
                throw new InvalidOperationException();
            }

            return(nextMove);
        }
        public IMove ABNegamax(IBoardGame game, int maxDepth, int currentDepth, double alfa, double beta)
        {
            if (maxDepth == currentDepth || game.GameIsOver())
                return game.EvaluatePosition();
            IMove bestMove = null;
            var moves = (new RandomList<IMove>(game.GetLegalMoves())).Randomize();
            foreach (var validMove in moves)
            {
                if (bestMove == null) bestMove = validMove;
                IBoardGame testGame = game.TestMove(validMove);
                validMove.SetMoveScore(-(ABNegamax(testGame, maxDepth, currentDepth + 1, -beta, -Math.Max(alfa, bestMove.GetMoveScore())).GetMoveScore()));
                if (validMove.GetMoveScore() > bestMove.GetMoveScore())
                {
                    bestMove = validMove;
                }
                if (bestMove.GetMoveScore() >= beta)
                    return bestMove;

            }
            return bestMove;
        }
        public IMove AdaptiveABNegamax(IBoardGame game, int maxDepth, int currentDepth, double alfa, double beta, List<IMove> opponentsList, IMove opponentsMove)
        {
            List<IMove> rankedMoveList = EvaluateMoves(game, maxDepth, 0, alfa, beta);
            int rank = 0;
            for (int index = 0; index < opponentsList.Count; index++)
            {

                if (!opponentsList[index].IsEqual(opponentsMove)) continue;
                else
                {
                    rank = index;
                    break;

                }
            }
            if (rank < rankedMoveList.Count)
            {
                while (rank >= 0 && rankedMoveList[rank].GetMoveScore() < 0)
                {
                    rank--;
                }
                if (rank >= 0)
                    return rankedMoveList[rank];
                else
                    return rankedMoveList[0];
            }
            else
            {
                rank = rankedMoveList.Count - 1;
                while (rank >= 0 && rankedMoveList[rank].GetMoveScore() < 0)
                {
                    rank--;
                }
                if (rank >= 0)
                    return rankedMoveList[rank];
                else
                    return rankedMoveList[0];
            }
        }
Example #15
0
        /**
         */
        private IBoardGame loadGameFromDll(String path)
        {
            IBoardGame myGame = null;

            // load the assembly
            Assembly myAs = Assembly.LoadFrom(path);

            // for all the types in this assembly
            foreach (Type t in myAs.GetTypes())
            {
                // make sure the type is a non-abstract class, visible and implements our interface
                if (t.IsClass && !t.IsAbstract && t.IsVisible && (t.GetInterface("BoardSoup.Interface.IBoardGame", true) == typeof(IBoardGame)))
                {
                    // instantiate the class
                    try
                    {
                        object obj = myAs.CreateInstance(t.FullName);

                        // if it is an implementation of our board game interface...
                        if (obj is IBoardGame)
                        {
                            // log debut output
                            Logger.log("PluginLoader: Loading: " + t.FullName + " from " + t.Module, LEVEL.DEBUG);

                            // cast our class to a board game
                            myGame = (IBoardGame)obj;
                        }
                    }
                    catch (Exception e)
                    {
                        System.Console.WriteLine("-------------------------------");
                        System.Console.WriteLine("Error loading " + t.FullName + " see: " + e.StackTrace);
                        System.Console.WriteLine("-------------------------------");
                    }
                }
            }

            return(myGame);
        }
Example #16
0
 public abstract Move <TToken> GetNextMove(IBoardGame <TToken> game);
Example #17
0
 public SwordAttack(Warrior warriorPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.warriorPlayer = warriorPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #18
0
 public BoardGameController(IBoardGame boardGameService, IMapper mapper)
 {
     _boardGameService = boardGameService;
 }
Example #19
0
 public FireBall(Wizard wizardPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.wizardPlayer = wizardPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #20
0
 public BallOfForce(Wizard wizardPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.wizardPlayer = wizardPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #21
0
 public Remember(Warrior warriorPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.warriorPlayer = warriorPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
 public override Move <TicTacToeToken> GetNextMove(IBoardGame <TicTacToeToken> game)
 {
     return(GetNextMove((TicTacToeGame)game));
 }
Example #23
0
 public ShieldBlock(Warrior warriorPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.warriorPlayer = warriorPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
 public DefensiveBarrier(Wizard wizardPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.wizardPlayer = wizardPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #25
0
 public Consecrate(Cleric clericPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.clericPlayer = clericPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
 public RejuvenatingStrike(Warrior warriorPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.warriorPlayer = warriorPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #27
0
 public SteadyAim(Archer archerPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.archerPlayer = archerPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #28
0
        /// <summary>
        /// Gets all fields of the given board that the card on the given board field can be moved to.
        /// </summary>
        /// <param name="game"></param>
        /// <param name="field"></param>
        /// <returns></returns>
        /// <remarks>AiBase classes can call this on themselves since they implement IBoardGame.</remarks>
        public static List <BoardField> GetMoveTargetFields(IBoardGame game, BoardField field)
        {
            var fields = new List <BoardField>();
            var card   = field?.Card as OnlineCard; // Firewall card cannot be moved directly to another field

            if (card == null || card.Owner == null)
            {
                return(fields);
            }
            // No move possible if it is the turn of the other player
            if (card.Owner.PlayerNumber == 1 && game.Phase == GamePhase.Player2Turn ||
                card.Owner.PlayerNumber == 2 && game.Phase == GamePhase.Player1Turn)
            {
                return(fields);
            }

            var x = field.X;
            var y = field.Y;

            // Code was written for single player mode.
            // In online play, the board is flipped for player 2
            // We cannot transform the coordinates here or everything will be screwed up
            // Therefore we just invert the player number
            var currentPlayer = game.Phase == GamePhase.Player1Turn ? 1 : 2;
            int opponent      = game.Phase == GamePhase.Player1Turn ? 2 : 1;

            #region Deployment
            // THIS CODE IS NOT NEEDED ANYMORE. JUST HERE FOR REFERENCE
            //if (game.Phase == GamePhase.Deployment)
            //{
            //    // In this phase you can only move cards between stack and deployment fields.
            //    var owner = card.Owner.PlayerNumber;
            //    var depFields = new BoardField[16];
            //    var y1 = owner == 1 ? 0 : 7;
            //    var y2 = owner == 1 ? 1 : 6;
            //    var y3 = owner == 1 ? 8 : 9;
            //    for (int ix = 0; ix<=7; ++ix)
            //    {
            //        // Set deployment fields
            //        if (ix == 3 || ix == 4)
            //            depFields[ix] = game.Board[ix, y2];
            //        else
            //            depFields[ix] = game.Board[ix, y1];
            //        // Set stack fields
            //        depFields[ix+8] = game.Board[ix, y3];
            //    }
            //    // Select all fields that have no card
            //    fields.AddRange(depFields.Where(o => o.Card == null));
            //}
            #endregion
            if (game.Phase == GamePhase.Player1Turn || game.Phase == GamePhase.Player2Turn)
            {
                // without boost there are 4 possible locations
                var fs = new BoardField[4];
                if (y > 0 && y <= 7) // Down
                {
                    fs[0] = game.Board[x, y - 1];
                }
                else
                {
                    // Special case for exit fields:
                    if (y == 0 && field.IsExit && currentPlayer == 2)
                    {
                        fs[0] = game.Board[4, 10];
                    }
                }

                if (y >= 0 && y < 7) // Up
                {
                    fs[1] = game.Board[x, y + 1];
                }
                else
                {
                    // Special case for exit fields:
                    if (y == 7 && field.IsExit && currentPlayer == 1)
                    {
                        fs[1] = game.Board[5, 10];
                    }
                }

                if (x > 0 && x <= 7 && y <= 7) // Left;  Mask out stack fields
                {
                    fs[2] = game.Board[x - 1, y];
                }
                if (x >= 0 && x < 7 && y <= 7) // Right
                {
                    fs[3] = game.Board[x + 1, y];
                }

                // Moves on opponents cards are allowed, move on own card not
                for (int i = 0; i < 4; ++i)
                {
                    if (fs[i] == null)
                    {
                        continue;
                    }
                    if (fs[i].Card != null && fs[i].Card.Owner.PlayerNumber == currentPlayer)
                    {
                        continue;
                    }
                    if (fs[i].Card != null && !(fs[i].Card is OnlineCard))
                    {
                        continue;                                                    // Can only jump on online cards <- This ignores the firewall card
                    }
                    if (fs[i].IsStack)
                    {
                        continue;
                    }
                    if (fs[i].IsExit)
                    {
                        // Exit field is allowed, but only your opponents
                        if (currentPlayer == 1 && fs[i].Y == 0)
                        {
                            continue;
                        }
                        if (currentPlayer == 2 && fs[i].Y == 7)
                        {
                            continue;
                        }
                    }
                    fields.Add(fs[i]);
                }

                // Boost can add additional fields
                if (card.HasBoost)
                {
                    // The same checks as above apply for all fields
                    var additionalfields = new List <BoardField>();
                    foreach (var f in fields)
                    {
                        // Ignore field if it has an opponents card
                        if (f.Card != null)
                        {
                            continue;
                        }

                        fs = new BoardField[4];
                        x  = f.X;
                        y  = f.Y;
                        if (y > 0 && y <= 7)
                        {
                            fs[0] = game.Board[x, y - 1];
                        }
                        else
                        {
                            // Special case for exit fields:
                            if (y == 0 && f.IsExit && currentPlayer == 2)
                            {
                                fs[0] = game.Board[4, 10];
                            }
                        }

                        if (y >= 0 && y < 7)
                        {
                            fs[1] = game.Board[x, y + 1];
                        }
                        else
                        {
                            // Special case for exit fields:
                            if (y == 7 && f.IsExit && currentPlayer == 1)
                            {
                                fs[1] = game.Board[5, 10];
                            }
                        }

                        if (x > 0 && x <= 7 && y <= 7) // No Stack fields!
                        {
                            fs[2] = game.Board[x - 1, y];
                        }
                        if (x >= 0 && x < 7 && y <= 7) // No Stack fields!
                        {
                            fs[3] = game.Board[x + 1, y];
                        }

                        for (int i = 0; i < 4; ++i)
                        {
                            if (fs[i] == null)
                            {
                                continue;
                            }
                            if (fs[i].Card != null && fs[i].Card.Owner.PlayerNumber == currentPlayer)
                            {
                                continue;
                            }
                            if (fs[i].Card != null && !(fs[i].Card is OnlineCard))
                            {
                                continue;                                                    // Can only jump on online cards <- This ignores the firewall card
                            }
                            if (fs[i].IsStack)
                            {
                                continue;
                            }
                            if (fs[i].IsExit)
                            {
                                // Exit field is allowed, but only your opponents
                                if (currentPlayer == 1 && fs[i].Y == 0)
                                {
                                    continue;
                                }
                                if (currentPlayer == 2 && fs[i].Y == 7)
                                {
                                    continue;
                                }
                            }
                            additionalfields.Add(fs[i]);
                        }
                    }

                    foreach (var f in additionalfields)
                    {
                        if (!fields.Contains(f))
                        {
                            fields.Add(f);
                        }
                    }
                }
            }

            return(fields);
        }
 public VampiricDagger(Thief thiefPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.thiefPlayer = thiefPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #30
0
 public FireArrow(Archer archerPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.archerPlayer = archerPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #31
0
 public TwinStrike(Archer archerPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.archerPlayer = archerPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #32
0
 public static int GetWinnerId <TGameState>(this IBoardGame <TGameState> game)
     where TGameState : IGameState
 => game.CurrentState.GetWinnerId();
Example #33
0
 public SurefireShot(Wizard wizardPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.wizardPlayer = wizardPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #34
0
 public Recall(Cleric clericPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.clericPlayer = clericPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
 public RainofDaggers(Thief thiefPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.thiefPlayer = thiefPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #36
0
 public PerfectShot(Archer archerPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.archerPlayer = archerPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #37
0
 public SpellBuff(Wizard wizardPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.wizardPlayer = wizardPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #38
0
        public override void TakeTurn(IBoardGame gameBoard)
        {
            if (!this.CanTakeTurn)
            {
                return;
            }

            // perform discard cards
            var discardCards = new DiscardCards(this);
            discardCards.Discard();

            // perform draw
            this.DrawCard(gameBoard);

            if (this.CurrentCards.Any())
            {
                // use a card that's not defensive
                var nonDefensiveInstantCards = this.CurrentCards.Where(card1 => !card1.IsDefensiveInstant).ToList();
                var randCardIdx = Randomizer.GetRandomValue(0, nonDefensiveInstantCards.Count() - 1);
                var card = nonDefensiveInstantCards.ElementAt(randCardIdx);
                card.Use();
                this.CurrentCards.RemoveAt(randCardIdx);
            }

            // cleanup
            var cleanupTurn = new CleanupTurn(this);
            cleanupTurn.Cleanup();
        }
Example #39
0
 public Riposte(Thief thiefPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.thiefPlayer = thiefPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #40
0
 public virtual void DrawCard(IBoardGame gameBoard)
 {
 }
Example #41
0
 public MagicDefense(Warrior warriorPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.warriorPlayer = warriorPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #42
0
 public virtual void Initialize(IBoardGame gameBoard)
 {
 }
Example #43
0
 public HolyPillar(Cleric clericPlayer, IBoardGame gameBoard, ITargetPlayer targetPlayer)
 {
     this.clericPlayer = clericPlayer;
     this.gameBoard = gameBoard;
     this.targetPlayer = targetPlayer;
 }
Example #44
0
 public static bool IsEnded <TGameState>(this IBoardGame <TGameState> game)
     where TGameState : IGameState
 => game.CurrentState.IsTerminal();