Exemple #1
0
    public void Generate(Vector3 origin, bool loadGame = false)
    {
        Vector2 arraySize   = GetBoardSize();
        int     arrayWidth  = (int)arraySize.x,
                arrayHeight = (int)arraySize.y;

        List <PlayerType> lostImmortals = new List <PlayerType>()
        {
            PlayerType.Battlebeard, PlayerType.Battlebeard, PlayerType.Battlebeard, PlayerType.Battlebeard,
            PlayerType.Stormshaper, PlayerType.Stormshaper, PlayerType.Stormshaper, PlayerType.Stormshaper
        };

        // get start position
        Vector3 centreOffset = new Vector3(_TileWidth / 2, 0, _TileWidth / 2),
                boardStart   = origin - new Vector3((arrayWidth * _TileWidth) / 2, 0, (arrayHeight * _TileWidth) / 2) + centreOffset;

        for (int i = 0; i < arrayWidth; i++)
        {
            for (int j = 0; j < arrayHeight; j++)
            {
                TileData tile = GetTileAt(i, j);
                if (tile == null)
                {
                    continue;
                }
                tile.X = i;
                tile.Y = j;
                if (!loadGame)
                {
                    tile.SetDefender(null);
                    tile.Owner = PlayerType.None;
                }
                tile.Height = GetHeight(tile, loadGame);

                Vector3 position = new Vector3(i * _TileWidth, tile.Height, j * _TileWidth) + boardStart;
                tile.TileObject      = (GameObject)Instantiate(GetTerrain(tile), position, Quaternion.identity);
                tile.TileObject.name = "Tile " + "[" + i + "," + j + "]";
                if (_TileTypeDataManager.GetTerrainData(tile.Terrain).IsRotatable)
                {
                    rotateRandom(tile.TileObject);
                }
                //grab the tile holder
                TileHolder tileHolder = tile.TileObject.GetComponentInChildren <TileHolder>();
                if (tileHolder == null)
                {
                    Debug.LogError("NO TILE HOLDER :O");
                }

                //if there is a building
                if (GetBuilding(tile) != null)
                {
                    GameObject buildingGO = (GameObject)Instantiate(GetBuilding(tile), position, Quaternion.identity);
                    // Set building name??
                    buildingGO.transform.parent = tile.TileObject.transform;
                    if (_TileTypeDataManager.GetBuildingData(tile.Building).IsRotatable)
                    {
                        rotateRandom(buildingGO);
                    }
                    //add building commander markers to tile holder
                    tileHolder._MarkerCommanderBB = Utils.GetFirstChildWithTag(_MarkerCommanderBB_Tag, tile.TileObject);
                    tileHolder._MarkerCommanderSS = Utils.GetFirstChildWithTag(_MarkerCommanderSS_Tag, tile.TileObject);

                    // if the building is a fortress then assign a lost immortal (we can use owner for this)
                    if (!loadGame && tile.Building == BuildingType.Fortress)
                    {
                        int r = Random.Range(0, lostImmortals.Count);
                        tile.Owner = lostImmortals[r];
                        lostImmortals.RemoveAt(r);
                    }
                }

                if (tile.Terrain == TerrainType.CastleCorner00)
                {
                    if (tile.Building == BuildingType.CastleBattlebeard)
                    {
                        for (int c = 0; c < _BattlebeardCastles.Length; c++)
                        {
                            _BattlebeardCastles[c] = (GameObject)Instantiate(_BattlebeardCastles[c], position + new Vector3(_TileWidth / 2, 0, _TileWidth / 2), Quaternion.identity);
                            _BattlebeardCastles[c].SetActive(false);
                        }
                    }
                    if (tile.Building == BuildingType.CastleStormshaper)
                    {
                        for (int c = 0; c < _StormshaperCastles.Length; c++)
                        {
                            _StormshaperCastles[c] = (GameObject)Instantiate(_StormshaperCastles[c], position + new Vector3(_TileWidth / 2, 0, _TileWidth / 2), Quaternion.identity);
                            _StormshaperCastles[c].SetActive(false);
                        }
                    }
                }

                // set owner flag
                _FlagManager.SetFlagForTile(tile);

                if (tile.IsDefended())
                {
                    _DefendingUnitManager.SetDefenderForTile(tile);
                }

                if (tile.HasPrisoner())
                {
                    _DefendingUnitManager.SetPrisonerForTile(tile);
                }

                //if the tile is a start tile set them up
                if (tile.Building == BuildingType.StartTileBattlebeard)
                {
                    _BBStartTile = tile;
                }
                else if (tile.Building == BuildingType.StartTileStormshaper)
                {
                    _SSStartTile = tile;
                }

                // add tile reference to game object
                tileHolder._Tile = tile;
                if (!CanTraverse(tile))
                {
                    continue;
                }

                for (int x = i - 1; x <= i + 1; x++)
                {
                    for (int y = j - 1; y <= j + 1; y++)
                    {
                        if (x == i && y == j)
                        {
                            continue;
                        }
                        TileData tileAtXY = GetTileAt(x, y);
                        if (tileAtXY != null && CanTraverse(tileAtXY))
                        {
                            tile.AddConnectedTile(tileAtXY);
                        }
                    }
                }
            }
        }
    }