private void ResetBurningDistance(TileData tileData)
    {
        string tileKey = tileData.PositionX.ToString() + tileData.PositionY.ToString();

        for (int x = tileData.PositionX - 1; x <= tileData.PositionX + 1; x++)
        {
            if (x < 0 || x >= _tileMapData.GetTileData().Length)
            {
                continue;
            }

            for (int y = tileData.PositionY - 1; y <= tileData.PositionY + 1; y++)
            {
                if (y < 0 || y >= _tileMapData.GetTileData()[x].Length)
                {
                    continue;
                }
                if (x == tileData.PositionX && y == tileData.PositionY)
                {
                    continue;
                }

                if (_tileMapData.GetTileData(x, y).FireSpreadingDistance.ContainsKey(tileKey))
                {
                    _tileMapData.GetTileData(x, y).FireSpreadingDistance[tileKey] = 0.0f;
                }
            }
        }
    }
Exemple #2
0
        private List <TileData> GetUnburningNeighbours(TileData selectedTile)
        {
            List <TileData> neighbours = new List <TileData>();

            for (int x = selectedTile.PositionX - 1; x <= selectedTile.PositionX + 1; x++)
            {
                if (x < 0 || x >= _tileMap._tileMapData.GetTileData().Length)
                {
                    continue;
                }

                for (int y = selectedTile.PositionY - 1; y <= selectedTile.PositionY + 1; y++)
                {
                    if (y < 0 || y >= _tileMap._tileMapData.GetTileData()[x].Length)
                    {
                        continue;
                    }
                    if (x == selectedTile.PositionX && y == selectedTile.PositionY)
                    {
                        continue;
                    }

                    if (!_tileMapData.GetTileData(x, y).IsBurning)
                    {
                        neighbours.Add(_tileMapData.GetTileData(x, y));
                    }
                }
            }

            return(neighbours);
        }
    private float GetMeanVertexHeight(int vertexX, int vertexY, TileMapData tileMapData)
    {
        List <TileData> tiles = new List <TileData>();

        tiles.Add(tileMapData.GetTileData(vertexX - 1, vertexY - 1));
        tiles.Add(tileMapData.GetTileData(vertexX - 1, vertexY));
        tiles.Add(tileMapData.GetTileData(vertexX, vertexY));
        tiles.Add(tileMapData.GetTileData(vertexX, vertexY - 1));

        tiles.RemoveAll(item => item == null);
        float sum = tiles.Sum(data => data.TerrainData.Height);

        return(sum / tiles.Count);
    }
    public void TestGetTileDataArray()
    {
        TileData[,] tileDataArray = _tileMapData.GetTileData();

        Assert.AreEqual(MAP_SQUARE_SIZE, tileDataArray.GetLength(0));
        Assert.AreEqual(MAP_SQUARE_SIZE, tileDataArray.GetLength(1));
    }
    public void Setup()
    {
        _tileMapData         = new TileMapData(MAP_SQUARE_SIZE, MAP_SQUARE_SIZE);
        TileData[,] tileData = _tileMapData.GetTileData();
        for (int x = 0; x < MAP_SQUARE_SIZE; x++)
        {
            for (int z = 0; z < MAP_SQUARE_SIZE; z++)
            {
                tileData [x, z] = GetGrassTileData();
            }
        }

        // Add un-walkable tiles in middle of tilemap
        tileData [4, 4] = GetWaterTileData();
        tileData [5, 4] = GetWaterTileData();
        tileData [6, 4] = GetWaterTileData();

        Graph graph = new Graph(MAP_SQUARE_SIZE, MAP_SQUARE_SIZE);

        graph.Generate4WayGraph();
        _nodeGrapth = graph.GetGraph();

        _validStraightPathfinder = new Pathfinder(_tileMapData, _nodeGrapth);
        _validStraightPathfinder.GeneratePath(0, 0, 5, 0);

        _invalidPathfinder = new Pathfinder(_tileMapData, _nodeGrapth);
        _invalidPathfinder.GeneratePath(0, 0, 0, 0);

        _validIgnoreUnWalkablePathfinder = new Pathfinder(_tileMapData, _nodeGrapth);
        _validIgnoreUnWalkablePathfinder.GeneratePath(new Vector3(3, 0, 4), new Vector3(7, 0, 4));
    }
    public void Setup()
    {
        _tileMapData         = new TileMapData(MAP_SQUARE_SIZE, MAP_SQUARE_SIZE);
        TileData[,] tileData = _tileMapData.GetTileData();
        for (int x = 0; x < MAP_SQUARE_SIZE; x++)
        {
            for (int z = 0; z < MAP_SQUARE_SIZE; z++)
            {
                tileData [x, z] = GetGrassTileData();
            }
        }

        // Add un-walkable tiles in middle of tilemap
        tileData [4, 4] = GetWaterTileData();
    }
    private Texture2D GenerateTextureData(TileMapData tileMapData)
    {
        int       textureWidth  = _tileResolution * _tileSizeX;
        int       textureHeight = _tileResolution * _tileSizeZ;
        Texture2D texture       = new Texture2D(textureWidth, textureHeight);

        for (int y = 0; y < _tileSizeZ; y++)
        {
            for (int x = 0; x < _tileSizeX; x++)
            {
                TileData tileData         = tileMapData.GetTileData(x, y);
                int      textureIndex     = MapTerrainToTexture(tileData.TerrainData.Type);
                Color[]  extractedTexture = _extractedTextures[textureIndex];
                texture.SetPixels(x * _tileResolution, y * _tileResolution, _tileResolution, _tileResolution, extractedTexture);
            }
        }

        texture.wrapMode   = TextureWrapMode.Clamp;
        texture.filterMode = FilterMode.Point;
        texture.Apply();
        return(texture);
    }
Exemple #8
0
    /// <summary>
    /// Builds the texture.
    /// </summary>
    private void BuildTexture()
    {
        int       texWidth  = Width * TileResolution;
        int       texHeight = Height * TileResolution;
        Texture2D texture   = new Texture2D(texWidth, texHeight);

        TileData[,] tileData = _tileMapData.GetTileData();

        for (int y = 0; y < Height; y++)
        {
            for (int x = 0; x < Width; x++)
            {
                TileData currentTileData = tileData [x, y];
                string   imagePath       = currentTileData.ImagePath;

                // Grab texture from cache if available, if not, load from disk then put in cache
                //Texture2D loadedTexture;
                Color[] pixels;
                if (_pixelCache.ContainsKey(imagePath))
                {
                    pixels = _pixelCache [imagePath];
                }
                else
                {
                    Texture2D loadedTexture = new Texture2D(texWidth, texHeight);
                    string    path          = Utility.CombinePaths(Application.streamingAssetsPath, TILE_SET_ROOT_DIRECTORY, TileSet, "Tiles", imagePath);

                    byte[] bytes = File.ReadAllBytes(path);
                    loadedTexture.LoadImage(bytes);

                    pixels = loadedTexture.GetPixels(0, 0, TileResolution, TileResolution);
                    _pixelCache.Add(imagePath, pixels);
                }
                // Set pixels
                texture.SetPixels(x * TileResolution, y * TileResolution, TileResolution, TileResolution, pixels);

                // If a unit is on the tile, instantiate them and move them to that tile
                if (currentTileData.UnitResRef != null)
                {
                    Unit unit = Unit.InstantiateUnit(currentTileData.UnitResRef);
                    unit.gameObject.name = unit.GetFullName();
                    currentTileData.Unit = unit;
                    unit.Tile            = currentTileData.Position;

                    unit.transform.position = TileMapUtil.TileMapToWorldCentered(currentTileData.Position, TileSize);
                    GameManager.Instance.GetTurnOrderController().AddUnsortedUnit(unit);

                    if (unit.UnitData.Type == UnitData.UnitType.PLAYER)
                    {
                        _allies.Add(unit);
                    }
                    else if (unit.UnitData.Type == UnitData.UnitType.ENEMY)
                    {
                        _enemies.Add(unit);
                    }
                }
            }
        }

        texture.filterMode = FilterMode.Point;
        texture.wrapMode   = TextureWrapMode.Clamp;
        texture.Apply();

        MeshRenderer mesh_renderer = GetComponent <MeshRenderer>();

        mesh_renderer.sharedMaterials [0].mainTexture = texture;

        //Debug.Log ("Done Texture!");
    }