public Tile GetNext()
        {
            var tileNumber = _random.Next(0, 5);
            var tile       = TileFactory.CreateTile((TileType)tileNumber);

            return(tile);
        }
예제 #2
0
        private List <Map.Tile> RecreateTilesFromMatchStatus(MatchStatus matchStatus)
        {
            var oldTiles = FindObjectsOfType <Map.Tile>();

            foreach (var tile in oldTiles)
            {
                Destroy(tile);
            }

            var tiles = new List <Map.Tile>();

            foreach (var statusTile in matchStatus.Tiles)
            {
                var tile = _tileFactory.CreateTile(statusTile.TileType, statusTile.Position.x, statusTile.Position.y, statusTile.Id);
                if (statusTile.Uncovered)
                {
                    tile.Uncover();
                }
                if (statusTile.Digged)
                {
                    tile.Dig();
                }

                tiles.Add(tile);
            }

            return(tiles);
        }
예제 #3
0
    void CreateFromRoomDataTile(Vector3 position, RoomData roomToCreate)
    {
        TileType tileTypeLocal;

        Vector2 currentPosition = new Vector2(position.x, position.y);

        //reads from roomdata
        if (roomToCreate.WallTiles.Contains(currentPosition))
        {
            tileTypeLocal = TileType.wall;
        }
        else if (roomToCreate.DoorTiles.Contains(currentPosition))
        {
            tileTypeLocal = TileType.door;
        }
        else if (roomToCreate.EnemyTiles.Contains(currentPosition))
        {
            tileTypeLocal = TileType.enemySpawner;
        }
        else if (roomToCreate.RoomSwitcherTiles.Contains(currentPosition))
        {
            tileTypeLocal = TileType.roomSwitcher;
        }
        else if (roomToCreate.DungeonEnterTiles.Contains(currentPosition))
        {
            tileTypeLocal = TileType.dungeonEnter;
        }
        else if (roomToCreate.ChestTiles.Contains(currentPosition))
        {
            tileTypeLocal = TileType.chest;
        }
        else
        {
            tileTypeLocal = TileType.walkable;
        }

        Tile tile = _tileFactory.CreateTile(tileTypeLocal, position, this.transform, this, TileManager);

        TrashController.ObjInTheRoom.Add(tile.gameObject);

        AddInMap(tileTypeLocal, tile);
    }
예제 #4
0
    void CreateTileObject(Vector3 position, LevelData levelData, int spriteIndex, GameObject parent, TileData tileData, Dictionary <string, string> tileProperties)
    {
        GameObject tile = tileFactory.CreateTile(spriteIndex, levelData.tilesets [0].tilewidth);

        tilePropertiesFactory.CreatePropertyComponents(tile, tileWidth, tileProperties);
        tile.transform.SetParent(parent.transform);
        tile.transform.Translate(position);
        if (!tileData.visible)
        {
            tile.GetComponent <SpriteRenderer>().enabled = false;
        }
    }
예제 #5
0
    public Tile GenerateTile(TileFactory tileFactory, Vector2Int gridPosition, int depth)
    {
        int         realDepth = depth - gridPosition.y;
        GroundGroup group     = GetGroup(realDepth);
        Tile        tile      = tileFactory.CreateTile(gridPosition, Tile.TileType.Ground, group.prefab);

        if (group != null)
        {
            tile.GetComponent <SpriteRenderer>().sprite = group.sprites[Random.Range(0, group.sprites.Length)];
        }

        return(tile);
    }
예제 #6
0
        private void InitializeTileMap()
        {
            var tileWidth  = _tileAtlases[0].TileWidth;
            var tileHeight = _tileAtlases[0].TileHeight;

            TileMapIterator((data) =>
            {
                if (_mapData[data.offset] == 0)
                {
                    return;
                }

                _tiles[data.offset] = _tileFactory.CreateTile(_canvasBitmaps[0],
                                                              new Vector2(data.x * tileWidth, data.y * tileHeight),
                                                              new Vector2(tileWidth, tileHeight),
                                                              (TileType)_mapData[data.offset]);
            });
        }
예제 #7
0
    private void GenerateTile(int mapValue, int gridX, int gridY)
    {
        if (mapValue == 0)
        {
            return;
        }

        var go  = TileFactory.CreateTile(mapValue);
        var trm = go.transform;

        trm.SetParent(bgTileRoot, false);
        Vector3 pos = layout.TileStartPos;

        float offx = gridX * layout.TileW;
        float offy = gridY * layout.TileH;

        pos.x = pos.x + offx;
        pos.y = pos.y - offy;
        pos.z = 0;

        trm.position   = pos;
        trm.localScale = Vector3.one * layout.Scale;
    }
예제 #8
0
        /// <summary>
        /// Initializes the Game with configured settings.
        /// </summary>
        private void Start()
        {
            tileFactory = TileFactory.instance;
            unitFactory = UnitFactory.instance;

            var selectedMap = SceneLoader.GetParam(SceneLoader.LOAD_MAP_PARAM);

            if (selectedMap != "")
            {
                mapData = MapLoader.instance.GetMapAsset(selectedMap);
            }
            else
            {
            }

            var gameTypeString = SceneLoader.GetParam(SceneLoader.GAME_TYPE_PARAM);

            if (gameTypeString == GameManager.SINGLEPLAYER_GAME_TYPE)
            {
                gameType = GameType.Singleplayer;
            }
            else if (gameTypeString == GameManager.MULTIPLAYER_GAME_TYPE)
            {
                gameType = GameType.Multiplayer;
            }
            else
            {
            }

            if (gameType == GameType.Singleplayer)
            {
                var singleGameTypeString = SceneLoader.GetParam(SceneLoader.SINGLEPLAYER_GAME_TYPE_PARAM);

                if (singleGameTypeString == GameManager.CAMPAIGN_GAME_TYPE)
                {
                    singleplayerGameType = SingleplayerGameType.Campaign;
                }
                else if (singleGameTypeString == GameManager.PRACTICE_GAME_TYPE)
                {
                    singleplayerGameType = SingleplayerGameType.Practice;
                }
                else
                {
                    throw new Exception("Singleplayer Game Type not set!");
                }
            }
            else if (gameType == GameType.Multiplayer)
            {
            }

            // Read map data from text file to get columns and rows
            var tileData = JsonUtility.FromJson <TileDataWrapper>(mapData.text);
            int cols     = tileData.Columns;
            int rows     = tileData.Rows;

            // Set up Players
            var players = new List <Player>();

            for (int playerNum = 1; playerNum <= numberOfPlayers; playerNum++)
            {
                Player newPlayer = null;

                if (gameType == GameType.Singleplayer)
                {
                    if (singleplayerGameType == SingleplayerGameType.Practice)
                    {
                        newPlayer = new Player($"Player {playerNum}", playerNum);
                    }
                    else if (singleplayerGameType == SingleplayerGameType.Campaign)
                    {
                        if (playerNum == 1)
                        {
                            newPlayer = CampaignManager.instance.CampaignPlayerData;
                            newPlayer.Units.Clear();
                        }
                        else
                        {
                            newPlayer = new Player($"Enemy Faction", playerNum);
                        }
                    }
                    else
                    {
                        throw new Exception($"Error setting up Player {playerNum}");
                    }
                }

                if (gameType == GameType.Multiplayer)
                {
                    // TODO: Get logic to set up Players with unique names from server?
                }

                players.Add(newPlayer);
            }

            // If playing a Singleplayer game, the user always controls the first Player (Player 1)
            if (gameType == GameType.Singleplayer)
            {
                ControllingPlayer = players.First();
            }

            // If playing a Multiplayer game, the server decides which player the user controls
            if (gameType == GameType.Multiplayer)
            {
                // TODO: Set up logic to find out which player the human in controlling
            }

            model.ConstructModel(cols, rows, players);

            var newObjectViews = new Dictionary <Vector2Int, ObjectView>();

            Tuple <Unit, GameObject> newUnitTuple = null;

            var boardTileData = tileData.tileData;
            var boardUnitData = boardTileData.Where(data => data.Player != 0).Select(data =>
                                                                                     new {
                Player       = data.Player,
                UnitPosition = new Vector3(data.Column, data.Row, 0f),
                UnitData     = data.UnitData
            }
                                                                                     );

            foreach (var boardTile in boardTileData)
            {
                // Initialize Tile Model/View
                var newTile = tileFactory.CreateTile(boardTile, view.tiles.transform);
                model.AddTile(newTile);
            }

            foreach (var boardUnit in boardUnitData)
            {
                var unitData     = boardUnit.UnitData;
                var unitPosition = boardUnit.UnitPosition;
                var unitPlayer   = boardUnit.Player;

                if (gameType == GameType.Singleplayer)
                {
                    if (singleplayerGameType == SingleplayerGameType.Campaign)
                    {
                        if (unitPlayer == 1)
                        {
                            const char DELIMITER       = '_';
                            const int  UNIT_NAME_INDEX = 3;

                            if (unitData == "FREE_ALLY_SQUARE")
                            {
                                // TODO: Make Free allies
                            }
                            else
                            {
                                var split_string = unitData.Split(DELIMITER);

                                if (split_string.Length == 4)
                                {
                                    // Named Unit
                                    var unitName     = split_string[UNIT_NAME_INDEX];
                                    var existingUnit =
                                        CampaignManager.instance.CampaignPlayerData.CampaignUnits.SingleOrDefault(
                                            campaignUnit => campaignUnit.Name == unitName);

                                    if (existingUnit != null)
                                    {
                                        var cloneUnit = existingUnit.Clone();
                                        newUnitTuple = unitFactory.ImportUnitForBoard(unitPosition, view.units.transform, cloneUnit, unitData);
                                    }
                                    else
                                    {
                                        newUnitTuple = unitFactory.CreateUnitForBoard(unitPosition, view.units.transform, unitData);
                                    }
                                }
                                else
                                {
                                    throw new NotImplementedException();
                                }
                            }
                        }
                        else
                        {
                            newUnitTuple = unitFactory.CreateUnitForBoard(boardUnit.UnitPosition, view.units.transform, unitData);
                            CampaignManager.instance.ModifyUnitStats(newUnitTuple.Item1);
                        }
                    }
                    else if (singleplayerGameType == SingleplayerGameType.Practice)
                    {
                        newUnitTuple = unitFactory.CreateUnitForBoard(boardUnit.UnitPosition, view.units.transform, unitData);
                    }
                    else
                    {
                        throw new Exception("Singleplayer Game Type not set");
                    }
                }
                else if (gameType == GameType.Multiplayer)
                {
                }
                else
                {
                    throw new Exception("Game Type not set");
                }

                var newUnitModel  = newUnitTuple.Item1;
                var newUnitObject = newUnitTuple.Item2;

                var newUnitView = new UnitView(newUnitObject);
                var unitPos     = unitPosition.ToVector2Int();
                newObjectViews.Add(unitPos, newUnitView);
                model.AddUnit(newUnitModel, unitPlayer, unitPos.x, unitPos.y);
            }

            // Invoke model to set up tile neighbors
            model.AddNeighbors();

            viewModel.ConstructViewModel();

            view.ConstructView(cols, rows, newObjectViews);

            view.mCamera.MoveToPosition(model.GridForUnit(ControllingPlayer.Units[0]).ToVector3());

            var text = SceneLoader.GetParam(SceneLoader.LOAD_OPENING_DIALOGUE_PARAM);

            StartGame();
            if (text != "")
            {
                dialogueManager.LoadDialogue(text);
            }
        }
예제 #9
0
        public LevelData GenerateGrid(string levelFilePath)
        {
            string         jsonString;
            List <Vector3> checkpoints = new List <Vector3>();

            if (File.Exists(levelFilePath))
            {
                using StreamReader reader = new StreamReader(File.OpenRead(levelFilePath));
                jsonString = reader.ReadToEnd();
            }
            else
            {
                throw new FileNotFoundException("The level file with the path: " + levelFilePath +
                                                " was not found! Remember to set Build Action to 'Content' and Copy to 'Copy always' in the file properties!");
            }

            data  = LevelDataConverter.ConvertJsonToLevelData(jsonString);
            _grid = new Tile[(int)data.gridSize.X, (int)data.gridSize.Y, (int)data.gridSize.Z];
            Vector3 pos = Vector3.Zero;

            for (int x = 0; x < (int)data.gridSize.X; x++)
            {
                for (int y = 0; y < (int)data.gridSize.Y; y++)
                {
                    for (int z = 0; z < (int)data.gridSize.Z; z++)
                    {
                        if (data.gridValues[x, y, z] != ETileType.None)
                        {
                            //Super duper algorithm to determine what the current tile looks like!
                            Tile.StaticTileType staticTileType = Tile.StaticTileType.DarkChocolate;
                            int count = 0;

                            for (int i = -1; i <= 1; i += 2)
                            {
                                if (x + i >= 0 && x + i < (int)data.gridSize.X)
                                {
                                    count += data.gridValues[x + i, y, z] == ETileType.Static ? 1 : 0;
                                }
                                if (y + i >= 0 && y + i < (int)data.gridSize.Y)
                                {
                                    count += data.gridValues[x, y + i, z] == ETileType.Static ? 1 : 0;
                                }
                                if (z + i >= 0 && z + i < (int)data.gridSize.Z)
                                {
                                    count += data.gridValues[x, y, z + i] == ETileType.Static ? 1 : 0;
                                }
                            }


                            if (count > 4)
                            {
                                staticTileType = Tile.StaticTileType.WhiteChocolate;
                            }
                            else if (count > 3)
                            {
                                staticTileType = Tile.StaticTileType.Chocolate;
                            }

                            if (y == 0)
                            {
                                staticTileType = Tile.StaticTileType.Chocolate;
                            }

                            Tile tile = tileFactory.CreateTile(pos + new Vector3(0, 0, data.gridSize.Z - 1),
                                                               data.gridValues[x, y, z], staticTileType);
                            tile?.InitializeTile();

                            //Giving the player a list of checkpoints, so that we can switch between them (for debug/demo purposes)
                            if (tile != null && tile.TileType == ETileType.Checkpoint)
                            {
                                checkpoints.Add(tile.Transform3D.Translation);
                            }

                            _grid[x, y, (int)data.gridSize.Z - 1 - z] = tile;
                        }
                        else
                        {
                            _grid[x, y, (int)data.gridSize.Z - 1 - z] = null;
                        }

                        pos.Z -= data.tileSize.Z; //MonoGames Forward is -UnitZ
                    }

                    pos.Z  = 0;
                    pos.Y += data.tileSize.Y;
                }

                pos.Y  = 0;
                pos.X += data.tileSize.X;
            }

            CreateShapes(data, _grid);
            SetPaths(data, _grid);
            SetActivatorIds(data, _grid);
            SetCollectibleIds(data, _grid);

            EventManager.FireEvent(new PlayerEventInfo
            {
                type = PlayerEventType.SetCheckpointList, checkpoints = checkpoints
            });

            return(data);
        }
예제 #10
0
 public override Tile.OverlapResolution OnOverlap(Tile overlapper)
 {
     Board.currBoard.SwapOutTile(overlapper, TileFactory.CreateTile(TileType.EATEN_CAKE));
     tile.Kill(Tile.KillReason.EATEN);
     return(Tile.OverlapResolution.DO_NOTHING);
 }