Esempio n. 1
0
 public void DehighlightAll()
 {
     if ((mark & 0xf) != 0)
     {
         BitOperationUtility.WriteBits(ref mark, 0, 0, 3);
         RefreshHighlight();
     }
 }
Esempio n. 2
0
    private void AddDetection(Tile tile, int uid)
    {
        player Player = LevelManager.Instance.Player;

        if (Player.GridPosition == tile.gridPosition)
        {
            LevelManager.Instance.Enemies[uid].GetComponent <EnemyController>().NotifyDetection(Player);
        }

        BitOperationUtility.WriteBit(ref detection[tile.x, tile.y], uid, 1);
    }
Esempio n. 3
0
    public void DehighlightDetectionArea(int uid)
    {
        foreach (Tile tile in detectionAreas[uid])
        {
            BitOperationUtility.WriteBit(ref detectionHighlights[tile.x, tile.y], uid, 0);

            if (detectionHighlights[tile.x, tile.y] == 0)
            {
                tile.Dehighlight(Tile.HighlightColor.Red);
            }
        }

        highlightedDetectionAreas.Remove(uid);
    }
Esempio n. 4
0
    public void HighlightDetectionArea(int uid)
    {
        foreach (Tile tile in detectionAreas[uid])
        {
            if (detectionHighlights[tile.x, tile.y] == 0)
            {
                tile.Highlight(Tile.HighlightColor.Red);
            }

            BitOperationUtility.WriteBit(ref detectionHighlights[tile.x, tile.y], uid, 1);
        }

        highlightedDetectionAreas.Add(uid);
    }
Esempio n. 5
0
    public void Highlight(HighlightColor color, bool isAdditive = true)
    {
        int mask = (int)color;

        if (((mark & 0xf) ^ mask) != 0)
        {
            if (isAdditive)
            {
                mark |= mask;
            }
            else
            {
                BitOperationUtility.WriteBits(ref mark, mask, 0, 3);
            }

            RefreshHighlight();
        }
    }
    private int ReadTileType(WorldMapTile tile)
    {
        int tileType = 0;

        float latitude = Math.Abs(WorldMap.ToGeographicCoordinates(tile, length, width).y * 2f / width);

        int numLandform = (int)WorldMapTile.Landform.count;

        if (tile.v < 2 || tile.v > width - 3)
        {
            BitOperationUtility.WriteBit(ref tileType, (int)WorldMapTile.Landform.GLACIER, 1);
            tileType += (int)WorldMapTile.Landform.GLACIER << 16;
        }
        else if (tile.altitude < 0)
        {
            BitOperationUtility.WriteBit(ref tileType, (int)WorldMapTile.Landform.OCEAN, 1);
            tileType += (int)WorldMapTile.Landform.OCEAN << 16;
        }
        else if (tile.altitude < 25 + rainfall * 2)
        {
            BitOperationUtility.WriteBit(ref tileType, (int)WorldMapTile.Landform.LAKE, 1);
            tileType += (int)WorldMapTile.Landform.LAKE << 16;
        }
        else if (tile.altitude > 65 - roughness)
        {
            BitOperationUtility.WriteBit(ref tileType, (int)WorldMapTile.Landform.MOUNTAIN, 1);
            tileType += (int)WorldMapTile.Landform.MOUNTAIN << 16;
        }
        else if (tile.altitude > 60 - roughness)
        {
            BitOperationUtility.WriteBit(ref tileType, (int)WorldMapTile.Landform.HILL, 1);
            tileType += (int)WorldMapTile.Landform.HILL << 16;
        }
        else
        {
            BitOperationUtility.WriteBit(ref tileType, (int)WorldMapTile.Landform.PLAIN, 1);
            tileType += (int)WorldMapTile.Landform.PLAIN << 16;
        }

        if (tile.biome < 0 && latitude > 0.55f + temperature * 0.025f)
        {
            BitOperationUtility.WriteBit(ref tileType, numLandform + (int)WorldMapTile.Biome.TUNDRA, 1);
            tileType += (int)WorldMapTile.Biome.TUNDRA << 19;
        }
        else if (tile.biome == 0 && latitude < 0.35f + temperature * 0.025f)
        {
            BitOperationUtility.WriteBit(ref tileType, numLandform + (int)WorldMapTile.Biome.DESERT, 1);
            tileType += (int)WorldMapTile.Biome.DESERT << 19;
        }
        else if (tile.biome > 60 - rainfall)
        {
            BitOperationUtility.WriteBit(ref tileType, numLandform + (int)WorldMapTile.Biome.FOREST, 1);
            tileType += (int)WorldMapTile.Biome.FOREST << 19;
        }
        else
        {
            BitOperationUtility.WriteBit(ref tileType, numLandform + (int)WorldMapTile.Biome.GRASSLAND, 1);
            tileType += (int)WorldMapTile.Biome.GRASSLAND << 19;
        }

        return(tileType);
    }
Esempio n. 7
0
    internal void NotifyUnitPositionChange(Unit unit, Vector2Int previousGridPosition, Vector2Int currentGridPosition)
    {
        bool isNotInitialization = previousGridPosition.x >= 0;
        bool isNotDeath          = currentGridPosition.x >= 0;

        if (isNotInitialization)
        {
            units[previousGridPosition.x, previousGridPosition.y] = null;
        }

        if (isNotDeath)
        {
            units[currentGridPosition.x, currentGridPosition.y] = unit;
        }

        if (unit.GetComponent <player>())
        {
            player Player = unit.GetComponent <player>();

            if (isNotDeath)
            {
                int d = detection[currentGridPosition.x, currentGridPosition.y];

                if (d != 0)
                {
                    foreach (int uid in BitOperationUtility.GetIndicesOfOne(d))
                    {
                        if (uid < LevelManager.Instance.Enemies.Count)
                        {
                            LevelManager.Instance.Enemies[uid].GetComponent <EnemyController>().NotifyDetection(Player);
                        }
                    }
                }
            }
        }
        else if (unit.GetComponent <Enemy>())
        {
            Enemy enemy = unit.GetComponent <Enemy>();

            int uid = unit.GetComponent <EnemyController>().UID;

            HashSet <Tile> currentDetectionArea = isNotDeath ? ProjectileManager.Instance.getProjectileRange(GetTile(currentGridPosition), enemy.DetectionRange, true, unit.transform.rotation.eulerAngles.y) : null;

            if (isNotInitialization)
            {
                if (isNotDeath)
                {
                    UpdateDetection(uid, currentDetectionArea);
                }
                else
                {
                    if (highlightedDetectionAreas.Contains(uid))
                    {
                        DehighlightDetectionArea(uid);
                    }

                    foreach (Tile tile in detectionAreas[uid])
                    {
                        RemoveDetection(tile, uid);
                    }

                    detectionAreas[uid].Clear();
                }
            }
            else
            {
                enemy.onStatisticChange.AddListener(delegate(Statistic statistic, float previousValue, float currentValue)
                {
                    if (statistic == Statistic.DetectionRange)
                    {
                        UpdateDetection(uid, ProjectileManager.Instance.getProjectileRange(GetTile(unit.GridPosition), enemy.DetectionRange, true, unit.transform.rotation.eulerAngles.y));
                    }
                });

                foreach (Tile tile in currentDetectionArea)
                {
                    AddDetection(tile, uid);
                }

                detectionAreas[uid] = currentDetectionArea;
            }
        }

        onUnitMove.Invoke(unit, previousGridPosition, currentGridPosition);
    }
Esempio n. 8
0
 private void RemoveDetection(Tile tile, int uid)
 {
     BitOperationUtility.WriteBit(ref detection[tile.x, tile.y], uid, 0);
 }
Esempio n. 9
0
 private void RefreshHighlight()
 {
     GetComponent <Renderer>().material.SetColor("_Color", new Color(BitOperationUtility.ReadBit(mark, 3), BitOperationUtility.ReadBit(mark, 2), BitOperationUtility.ReadBit(mark, 1), BitOperationUtility.ReadBit(mark, 0) * alpha));
 }