public PlayerInSessionModel(PositionModel pos, PlayerModel player, MapTileModel[,] map)
     : this()
 {
     this.NextPosition = new PositionModel(pos.Column, pos.Row);
     this.CurrentPosition = new PositionModel(pos.Column, pos.Row);
     this.Player = player;
     this.PrivateMap = CloneMap(map);
 }
Example #2
0
        private PositionModel GetUncoveredBulletTile( ArrayList tiles, SessionMapTileModel[,] map, PositionModel uncoveredBulletTile, int index )
        {
            bool previousUncovered = false;
            PositionModel firstTile = (PositionModel)tiles[0];

            if (map[firstTile.Column, firstTile.Row].IsTileUncoveredByPlayer[index])
            {
                uncoveredBulletTile.Column = firstTile.Column;
                uncoveredBulletTile.Row = firstTile.Row;

                return uncoveredBulletTile;
            }

            foreach (PositionModel tile in tiles)
            {
                if (map[tile.Column, tile.Row].IsTileUncoveredByPlayer[index])
                {
                    if (previousUncovered)
                    {
                        return uncoveredBulletTile;
                    }
                }
                else
                {
                    previousUncovered = true;

                    uncoveredBulletTile.Column = tile.Column;
                    uncoveredBulletTile.Row = tile.Row;
                }
            }

            return uncoveredBulletTile;
        }
Example #3
0
        public void ServerBroadcastCheckUnderneathTile( string roomName, int col, int row )
        {
            GameSessionModel session = GameSessionManagerModel.Instance.GameSessionCollection.Find( m => m.Name == roomName );
            if (session == null)
            {
                return;
            }
            PlayerInSessionModel playerInGame = session.PlayersInSession.Find( m => m.Player.ConnectionId == Context.ConnectionId );
            if (playerInGame == null)
            {
                return;
            }
            //TODO: temporary
            if (playerInGame.Player.seatNumber == 0)
            {
                return;
            }

            int prevCol = playerInGame.CurrentPosition.Column;
            int prevRow = playerInGame.CurrentPosition.Row;

            playerInGame.CurrentPosition.Column = playerInGame.NextPosition.Column;
            playerInGame.CurrentPosition.Row = playerInGame.NextPosition.Row;

            playerInGame.NextPosition.Column = col;
            playerInGame.NextPosition.Row = row;

            PlayerInSessionModel otherPlayer = session.PlayersInSession.Find( m => m.Player.ConnectionId != Context.ConnectionId );

            if (IsOtherPlayerInTile( otherPlayer.NextPosition.Column, otherPlayer.NextPosition.Row, playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row ))
            {
                Clients.Client( playerInGame.Player.ConnectionId ).clientReceiveOtherPlayerPosition( otherPlayer.NextPosition.Column, otherPlayer.NextPosition.Row, otherPlayer.Player.seatNumber );
            }

            UpdateOtherPlayerPosition( session, playerInGame, otherPlayer, col, row );

            int mapTile = playerInGame.PrivateMap[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].Tile;

            //map
            // 0 = covered empty tile
            // 1 = uncovered empty tile
            // 2 = covered Mine tile
            // 3 = uncovered/destroyed Mine tile
            // 4 = uncovered/scored Mine tile
            // 5 = uncovered mine (not scored) uncovered by pineCone explosion
            // 6 = uncovered tile by pineCone explosion
            // 7 = covered turret
            // 8 = uncovered turret

            PositionModel minePosition = new PositionModel( -1, -1 );

            switch ((TileKind)mapTile)
            {
                case TileKind.CoveredEmptyTile:
                    {
                        playerInGame.PrivateMap[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].Tile = 1;
                        List<PositionModel> uncoveredTiles = CheckIfMineIsUncoveredAllAround( playerInGame );

                        playerInGame.AmmoPoints += session.Map[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].Number;

                        if (uncoveredTiles.Count > 0)
                        {
                            playerInGame.UncoveredMines += uncoveredTiles.Count;

                            Clients.Client( playerInGame.Player.ConnectionId ).clientReceiveMineHasBeenUncovered( uncoveredTiles, playerInGame.UncoveredMines );

                            if (!playerInGame.WalkedIntoMine && playerInGame.UncoveredMines == session.NumberOfMines)
                            {
                                Clients.Client( playerInGame.Player.ConnectionId ).clientReceiveWinGame( string.Format( "Player {0} has won the game by uncovering all the special tiles! Hail to the king! Congratz {0}.", playerInGame.Player.Name ) );
                                Clients.Client( otherPlayer.Player.ConnectionId ).clientReceiveWinGame( string.Format( "Player {0} has won the game by uncovering all the special tiles! Hail to the king! Congratz {0}.", playerInGame.Player.Name ) );
                            }
                        }

                        break;
                    }
                case TileKind.UncoveredEmptyTile:
                    {
                        break;
                    }
                case TileKind.CoveredMineTile:
                    {
                        playerInGame.WalkedIntoMine = true;

                        playerInGame.PrivateMap[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].Tile = 3;

                        minePosition.Column = playerInGame.CurrentPosition.Column;
                        minePosition.Row = playerInGame.CurrentPosition.Row;

                        playerInGame.CurrentPosition.Column = prevCol;
                        playerInGame.CurrentPosition.Row = prevRow;
                        playerInGame.NextPosition.Column = prevCol;
                        playerInGame.NextPosition.Row = prevRow;
                        UpdateOtherPlayerPosition( session, playerInGame, otherPlayer, prevCol, prevRow );

                        List<PositionModel> uncoveredTiles = CheckIfMineIsUncoveredAllAround( playerInGame );

                        if (uncoveredTiles.Count > 0)
                        {
                            playerInGame.UncoveredMines += uncoveredTiles.Count;

                            Clients.Client( playerInGame.Player.ConnectionId ).clientReceiveMineHasBeenUncovered( uncoveredTiles );
                        }

                        playerInGame.AmmoPoints = 0;

                        break;
                    }
                case TileKind.UncoveredDestroyedMineTile:
                    {
                        playerInGame.CurrentPosition.Column = prevCol;
                        playerInGame.CurrentPosition.Row = prevRow;
                        playerInGame.NextPosition.Column = prevCol;
                        playerInGame.NextPosition.Row = prevRow;
                        UpdateOtherPlayerPosition( session, playerInGame, otherPlayer, prevCol, prevRow );
                        break;
                    }
                case TileKind.UncoveredScoredMineTile:
                    {
                        minePosition.Column = playerInGame.CurrentPosition.Column;
                        minePosition.Row = playerInGame.CurrentPosition.Row;

                        playerInGame.CurrentPosition.Column = prevCol;
                        playerInGame.CurrentPosition.Row = prevRow;
                        playerInGame.NextPosition.Column = prevCol;
                        playerInGame.NextPosition.Row = prevRow;

                        UpdateOtherPlayerPosition( session, playerInGame, otherPlayer, prevCol, prevRow );
                        break;
                    }
                case TileKind.UncoveredMineByPineConeExplosionNotScored:
                    {
                        playerInGame.CurrentPosition.Column = prevCol;
                        playerInGame.CurrentPosition.Row = prevRow;
                        playerInGame.NextPosition.Column = prevCol;
                        playerInGame.NextPosition.Row = prevRow;
                        UpdateOtherPlayerPosition( session, playerInGame, otherPlayer, prevCol, prevRow );
                        break;
                    }
                default:
                    {
                        break;
                    }
            }

            session.Map[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].IsTileUncoveredByPlayer[playerInGame.Player.seatNumber - 1] = true;

            int mineNumber = session.Map[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].Number;

            Clients.Client( playerInGame.Player.ConnectionId ).clientReceiveUncoverTile( mapTile, mineNumber, playerInGame.CurrentPosition, minePosition );
        }