private Tile GetRandomTile()
{
Tile tile = null;
List <Tile> tileList = GridManager.GetTileList();
int iterateCount = 0;
while (true)
{
iterateCount += 1;
if (iterateCount > 10)
{
break;
}
tile = tileList[Random.Range(0, tileList.Count)];
if (!tile.walkable)
{
continue;
}
if (tile.unit != null)
{
continue;
}
if (tile.collectible != null)
{
continue;
}
break;
}
return(tile);
}
public void Init()
{
if (init)
{
return;
}
init = true;
thisT = transform;
Transform deploymentIndicator = null;
Transform moveableIndicator = null;
Transform hostileIndicator = null;
Transform abRangeIndicator = null;
Transform abTargetIndicator = null;
if (GridManager.GetTileType() == _TileType.Hex)
{
deploymentIndicator = hexDeployment;
moveableIndicator = hexMoveable;
hostileIndicator = hexHostile;
abRangeIndicator = hexAbRange;
abTargetIndicator = hexAbTarget;
cursorIndicatorF = (Transform)Instantiate(hexCursorF);
cursorIndicatorH = (Transform)Instantiate(hexCursorH);
selectIndicator = (Transform)Instantiate(hexSelected);
}
else if (GridManager.GetTileType() == _TileType.Square)
{
deploymentIndicator = sqDeployment;
moveableIndicator = sqMoveable;
hostileIndicator = sqHostile;
abRangeIndicator = sqAbRange;
abTargetIndicator = sqAbTarget;
cursorIndicatorF = (Transform)Instantiate(sqCursorF);
cursorIndicatorH = (Transform)Instantiate(sqCursorH);
selectIndicator = (Transform)Instantiate(sqSelected);
}
cursorIndicatorF.parent = thisT;
cursorIndicatorH.parent = thisT;
selectIndicator.parent = thisT;
for (int i = 0; i < 20; i++)
{
deploymentIndicatorList.Add((Transform)Instantiate(deploymentIndicator));
deploymentIndicatorList[i].gameObject.SetActive(false);
deploymentIndicatorList[i].parent = thisT;
}
for (int i = 0; i < 20; i++)
{
moveableIndicatorList.Add((Transform)Instantiate(moveableIndicator));
moveableIndicatorList[i].gameObject.SetActive(false);
moveableIndicatorList[i].parent = thisT;
}
for (int i = 0; i < 10; i++)
{
hostileIndicatorList.Add((Transform)Instantiate(hostileIndicator));
hostileIndicatorList[i].gameObject.SetActive(false);
hostileIndicatorList[i].parent = thisT;
}
for (int i = 0; i < 20; i++)
{
abRangeIndicatorList.Add((Transform)Instantiate(abRangeIndicator));
abRangeIndicatorList[i].gameObject.SetActive(false);
abRangeIndicatorList[i].parent = thisT;
}
for (int i = 0; i < 20; i++)
{
abTargetIndicatorList.Add((Transform)Instantiate(abTargetIndicator));
abTargetIndicatorList[i].gameObject.SetActive(false);
abTargetIndicatorList[i].parent = thisT;
}
if (TurnControl.GetTurnMode() == _TurnMode.FactionPerTurn)
{
//create the moved indicator
for (int i = 0; i < 10; i++)
{
movedIndicatorList.Add((Transform)Instantiate(movedIndicator));
movedIndicatorList[i].gameObject.SetActive(false);
movedIndicatorList[i].parent = thisT;
}
}
if (GameControl.EnableFogOfWar())
{
Transform fogObj = null;
if (GridManager.GetTileType() == _TileType.Hex)
{
fogObj = hexFogObj;
}
else if (GridManager.GetTileType() == _TileType.Square)
{
fogObj = sqFogObj;
}
List <Tile> tileList = GridManager.GetTileList();
for (int i = 0; i < tileList.Count; i++)
{
//if(!tileList[i].walkable) continue;
tileList[i].SetFogOfWarObj((Transform)Instantiate(fogObj));
}
}
if (GameControl.EnableCover())
{
float scaleOffset = GridManager.GetTileType() == _TileType.Hex ? 0.5f : 0.8f;
float tileSize = GridManager.GetTileSize();
for (int i = 0; i < 5; i++)
{
coverOverlayHList.Add((Transform)Instantiate(coverOverlayH));
coverOverlayFList.Add((Transform)Instantiate(coverOverlayF));
coverOverlayHList[i].localScale *= tileSize * scaleOffset;
coverOverlayHList[i].parent = thisT;
coverOverlayHList[i].gameObject.SetActive(false);
coverOverlayFList[i].localScale *= tileSize * scaleOffset;
coverOverlayFList[i].parent = thisT;
coverOverlayFList[i].gameObject.SetActive(false);
}
}
}
IEnumerator _ApplyAbilityEffect(Tile targetTile, Ability ability, int type, Unit srcUnit = null, float critMult = 1.0f)
{
if (targetTile != null && ability.effectObject != null)
{
if (!ability.autoDestroyEffect)
{
ObjectPoolManager.Spawn(ability.effectObject, targetTile.GetPos(), Quaternion.identity);
}
else
{
ObjectPoolManager.Spawn(ability.effectObject, targetTile.GetPos(), Quaternion.identity, ability.effectObjectDuration);
}
}
if (!ability.useDefaultEffect)
{
yield break;
}
if (ability.effectDelayDuration > 0)
{
yield return(new WaitForSeconds(ability.effectDelayDuration));
}
if (type == 1) //_AbilityType.Generic
{
List <Tile> tileList = new List <Tile>();
if (targetTile != null)
{
if (ability.aoeRange > 0)
{
tileList = GridManager.GetTilesWithinDistance(targetTile, ability.aoeRange);
}
tileList.Add(targetTile);
}
else
{
if (ability.effTargetType == _EffectTargetType.Tile)
{
tileList = GridManager.GetTileList();
}
else
{
List <Unit> unitList = FactionManager.GetAllUnit();
for (int i = 0; i < unitList.Count; i++)
{
tileList.Add(unitList[i].tile);
}
}
}
if (ability.effTargetType == _EffectTargetType.AllUnit)
{
for (int i = 0; i < tileList.Count; i++)
{
if (tileList[i].unit == null)
{
continue;
}
tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult), srcUnit);
SpawnEffectObjTarget(ability, tileList[i]);
}
}
else if (ability.effTargetType == _EffectTargetType.HostileUnit)
{
for (int i = 0; i < tileList.Count; i++)
{
if (tileList[i].unit == null)
{
continue;
}
if (tileList[i].unit.factionID == ability.factionID)
{
continue;
}
tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult), srcUnit);
SpawnEffectObjTarget(ability, tileList[i]);
}
}
else if (ability.effTargetType == _EffectTargetType.FriendlyUnit)
{
for (int i = 0; i < tileList.Count; i++)
{
if (tileList[i].unit == null)
{
continue;
}
if (tileList[i].unit.factionID != ability.factionID)
{
continue;
}
tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult), srcUnit);
SpawnEffectObjTarget(ability, tileList[i]);
}
}
else if (ability.effTargetType == _EffectTargetType.Tile)
{
for (int i = 0; i < tileList.Count; i++)
{
tileList[i].ApplyEffect(ability.CloneEffect(critMult));
SpawnEffectObjTarget(ability, tileList[i]);
}
}
}
else if (type == 2) //_AbilityType.SpawnNew
{
Quaternion rot = srcUnit != null ? srcUnit.thisT.rotation : Quaternion.identity;
GameObject unitObj = (GameObject)Instantiate(ability.spawnUnit.gameObject, targetTile.GetPos(), rot);
Unit unit = unitObj.GetComponent <Unit>();
unitObj.transform.position = targetTile.GetPos();
if (srcUnit != null)
{
unitObj.transform.rotation = srcUnit.thisT.rotation;
}
else
{
Faction faction = FactionManager.GetFaction(ability.factionID);
if (faction != null)
{
unitObj.transform.rotation = Quaternion.Euler(0, faction.spawnDirection, 0);
}
}
FactionManager.InsertUnit(unit, ability.factionID);
unit.SetNewTile(targetTile);
//if(GridManager.GetDistance(targetTile, srcUnit.tile)<=srcUnit.GetMoveRange()) GameControl.SelectUnit(srcUnit);
}
else if (type == 3) //_AbilityType.ScanFogOfWar)
{
List <Tile> targetTileList = GridManager.GetTilesWithinDistance(targetTile, ability.GetAOERange());
targetTileList.Add(targetTile);
for (int i = 0; i < targetTileList.Count; i++)
{
targetTileList[i].ForceVisible(ability.effect.duration);
}
}
else if (type == 4) //_AbilityType.Overwatch
{
targetTile.unit.Overwatch(ability.CloneEffect(critMult));
}
else if (type == 5) //_AbilityType.Teleport
{
Quaternion wantedRot = Quaternion.LookRotation(targetTile.GetPos() - ability.unit.tile.GetPos());
ability.unit.thisT.rotation = wantedRot;
GameControl.ClearSelectedUnit();
ability.unit.SetNewTile(targetTile);
GameControl.SelectUnit(srcUnit);
}
else if (type == 6) //charge attack
{
List <Tile> tileList = GridManager.GetTilesInALine(srcUnit.tile, targetTile, ability.GetRange());
for (int i = 0; i < tileList.Count; i++)
{
while (true)
{
float dist = Vector3.Distance(srcUnit.thisT.position, tileList[i].GetPos());
if (dist < 0.05f)
{
if (tileList[i].unit != null)
{
tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult));
SpawnEffectObjTarget(ability, tileList[i]);
}
break;
}
Quaternion wantedRot = Quaternion.LookRotation(tileList[i].GetPos() - srcUnit.thisT.position);
srcUnit.thisT.rotation = Quaternion.Slerp(srcUnit.thisT.rotation, wantedRot, Time.deltaTime * srcUnit.moveSpeed * 6);
Vector3 dir = (tileList[i].GetPos() - srcUnit.thisT.position).normalized;
srcUnit.thisT.Translate(dir * Mathf.Min(srcUnit.moveSpeed * 2 * Time.deltaTime, dist), Space.World);
yield return(null);
}
}
srcUnit.tile.unit = null;
srcUnit.tile = tileList[tileList.Count - 1];
tileList[tileList.Count - 1].unit = srcUnit;
GameControl.ReselectUnit();
}
else if (type == 7) //attack all unit in a straight line
{
List <Tile> tileList = GridManager.GetTilesInALine(srcUnit.tile, targetTile, ability.GetRange());
for (int i = 0; i < tileList.Count; i++)
{
if (tileList[i].unit == null)
{
continue;
}
tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult));
SpawnEffectObjTarget(ability, tileList[i]);
}
}
else
{
Debug.LogWarning("Error, unknown ability type (" + type + ")");
}
yield return(null);
}
