public Unit GetUnit(Type type, Point point)
    {
        switch (type)
        {
        case Type.Enemy:
            if (EnemyCollection.ContainsKey(point))
            {
                return(EnemyCollection[point]);
            }
            Debug.LogError("[EnvironmentManager] Enemy Does not exist. Returning Null");
            return(null);

        case Type.Envrionment:
            if (EnvironmentCollection.ContainsKey(point))
            {
                return(EnvironmentCollection[point]);
            }
            Debug.LogError("[EnvironmentManager] Environment Does not exist. Returning Null");
            return(null);

        default:
            Debug.LogError("[EnvironmentManager] GetUnit() only accepts Type.Environment or Type.Enemy");
            return(null);
        }
    }
    public void MoveUnit(Type type, Point curPoint, Point newPoint)
    {
        switch (type)
        {
        case Type.Envrionment:

            if (!EnvironmentCollection.ContainsKey(curPoint) || EnvironmentCollection.ContainsKey(newPoint))
            {
                Debug.LogError("[EnvironmentManager] Failed to set unit to new position");
                return;
            }

            EnviromentalUnit temp = EnvironmentCollection[curPoint];
            EnvironmentCollection.Remove(curPoint);
            EnvironmentCollection.Add(newPoint, temp);
            break;

        case Type.Enemy:

            if (!EnemyCollection.ContainsKey(curPoint) || EnemyCollection.ContainsKey(newPoint))
            {
                Debug.LogError("[EnvironmentManager] Failed to set unit to new position");
                return;
            }

            EnemyUnit enemyTemp = EnemyCollection[curPoint];
            EnemyCollection.Remove(curPoint);
            EnemyCollection.Add(newPoint, enemyTemp);
            break;

        default:
            break;
        }
    }
    public void SinkEntities(int refPoint)
    {
        //TODO/HACK: hard coded length
        for (int i = 0; i < 8; i++)
        {
            Point tarPoint = new Point(refPoint, 0, i);
            if (EnvironmentCollection.ContainsKey(tarPoint))
            {
                if (EnvironmentCollection[tarPoint] == null)
                {
                    continue;
                }
                EnvironmentCollection[tarPoint].GetComponent <TileDecorator>().SinkComponents();
                EnvironmentCollection[tarPoint].gameObject.SetActive(false);
            }
        }

        for (int i = 0; i < 8; i++)
        {
            Point tarPoint = new Point(refPoint, 0, i);
            if (EnemyCollection.ContainsKey(tarPoint))
            {
                if (EnemyCollection[tarPoint] == null)
                {
                    continue;
                }
                EnemyCollection[tarPoint].GetComponent <TileDecorator>()?.SinkComponents();
            }
        }
    }
    public void RaiseEntities(int refPoint)
    {
        //TODO/HACK: hard coded length
        for (int i = 0; i < 8; i++)
        {
            Point tarPoint = new Point(refPoint, 0, i);

            if (EnvironmentCollection.ContainsKey(tarPoint))
            {
                if (EnvironmentCollection[tarPoint] == null)
                {
                    return;
                }
                EnvironmentCollection[tarPoint]?.gameObject.SetActive(true);
                EnvironmentCollection[tarPoint]?.GetComponent <TileDecorator>()?.RaiseComponents();
            }

            if (EnemyCollection.ContainsKey(tarPoint))
            {
                if (EnemyCollection[tarPoint] == null)
                {
                    return;
                }
                EnemyCollection[tarPoint]?.gameObject.SetActive(true);
                EnemyCollection[tarPoint]?.GetComponent <TileDecorator>()?.RaiseComponents();
            }
        }
    }
    public void SpawnHellBloom(Point SpawnPoint, HellBloom hellbloomPrefab)
    {
        if (EnvironmentCollection.ContainsKey(SpawnPoint) || Units.Contains(SpawnPoint))
        {
            return;
        }

        HellBloom temp = Instantiate(hellbloomPrefab, new Vector3(SpawnPoint.x, 1, SpawnPoint.z), Quaternion.identity);

        temp.GetComponent <EnviromentalUnit>().WorldPosition = SpawnPoint;
        temp.GetComponent <EnviromentalUnit>().SetPosition(SpawnPoint);
        temp.GetComponent <TileDecorator>().RaiseInstant();
        AddSpawnedEnvironment(SpawnPoint, temp.GetComponent <EnviromentalUnit>());
    }
    public void SpawnMountain(Point SpawnPoint)
    {
        if (EnvironmentCollection.ContainsKey(SpawnPoint) || Units.Contains(SpawnPoint))
        {
            return;
        }

        GameObject temp = GameObject.Instantiate(Mountain, new Vector3(SpawnPoint.x, 1, SpawnPoint.z), Quaternion.identity);

        temp.GetComponent <EnviromentalUnit>().WorldPosition = SpawnPoint;
        temp.GetComponent <EnviromentalUnit>().SetPosition(SpawnPoint);
        temp.GetComponent <TileDecorator>().RaiseComponents();
        AddSpawnedEnvironment(SpawnPoint, temp.GetComponent <EnviromentalUnit>());
    }
    public void AddSpawnedEnvironment(Point point, EnviromentalUnit unit)
    {
        if (EnvironmentCollection.ContainsKey(point) || EnvironmentCollection.ContainsValue(unit))
        {
            Debug.LogError($"[EnvironmentManager] Envrionmental Unit Already Exists. {unit.name} {unit.WorldPosition}, Conflicting Unit: {EnvironmentCollection[point].name} {EnvironmentCollection[point].WorldPosition}", unit);
            return;
        }

        if (AddUnitToMap(point, unit))
        {
            EnvironmentCollection.Add(point, unit);
            return;
        }

        Debug.LogError("[EnvironmentManager] Failed setting environment");
    }