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);
 }
示例#2
0
        private PositionModel GetRandomPlayerPosition( MapTileModel[,] map, Random rnd )
        {
            int rndCol = rnd.Next( GameSettings.Map.NumberOfTiles_Column );
            int rndRow = rnd.Next( GameSettings.Map.NumberOfTiles_Row );

            if (map[rndCol, rndRow].Tile != 2)
            {
                return new PositionModel( rndCol, rndRow );
            }
            else
            {
                return GetRandomPlayerPosition( map, rnd );
            }
        }
示例#3
0
        private bool ShootingPathIsClear( int startColumn, int startRow, int endColumn, int endRow, MapTileModel[,] playerMap, out ArrayList tiles )
        {
            tiles = CalculateStraightLine( startColumn, startRow, endColumn, endRow );
            int tileValue;
            foreach (PositionModel tile in tiles)
            {
                tileValue = playerMap[tile.Column, tile.Row].Tile;

                if (tileValue != 1 && tileValue != 6)
                {
                    return false;
                }
            }

            return true;
        }
示例#4
0
        private bool CheckIfTilesAroundParameterTileAreUncovered( int col, int row, MapTileModel[,] map )
        {
            int rMinusOne = row - 1;
            int rPlusOne = row + 1;
            int kMinusOne = col - 1;
            int kPlusOne = col + 1;

            for (var k = kMinusOne; k <= kPlusOne; k++)
            {
                for (var r = rMinusOne; r <= rPlusOne; r++)
                {

                    if (r >= 0 && r < GameSettings.Map.NumberOfTiles_Row && k >= 0 && k < GameSettings.Map.NumberOfTiles_Column)
                    {
                        if (map[k, r].Tile == 0)
                        {
                            return false;
                        }
                    }

                }
            }

            return true;
        }
        private MapTileModel[,] CloneMap(MapTileModel[,] map)
        {
            MapTileModel[,] privateMap = new MapTileModel[GameSettings.Map.NumberOfTiles_Column, GameSettings.Map.NumberOfTiles_Row];

            for (int col = 0; col < GameSettings.Map.NumberOfTiles_Column; col++)
            {
                for (int row = 0; row < GameSettings.Map.NumberOfTiles_Row; row++)
                {
                    MapTileModel sessionTile = map[col, row];

                    privateMap[col, row] = new MapTileModel(sessionTile.Tile, sessionTile.Number, sessionTile.Graph);
                }
            }

            return privateMap;
        }
示例#6
0
        private List<PlayerInSessionModel> InitializePlayers( List<PlayerModel> players, MapTileModel[,] map )
        {
            var rnd = new Random();
            var playersInSession = new List<PlayerInSessionModel>();
            foreach (var player in players)
            {
                PositionModel pos = GetRandomPlayerPosition( map , rnd );
                playersInSession.Add( new PlayerInSessionModel( pos, player, map ) );
            }

            return playersInSession;
        }