public static bool SameTeam(TileScript atk, TileScript def)
{
if(atk.unit && def.unit) {
return atk.GetUnitScript().GetTeam() == def.GetUnitScript().GetTeam();
}
return false;
}
private void updateWorldAfterAbility(TileScript atk, TileScript def)
{
// Check for death;
if(!def || !def.unit) return;
if(def.GetUnitScript().health <= 0) {
def.RemoveUnit();
def.Explosion();
Game.getInstance().UnBattle();
Game.getInstance().CheckWin();
}
}
public List<GameObject> canUseAbilityOn(TileScript attacker)
{
if(!attacker.unit)
return new List<GameObject>();
List<GameObject> list = new List<GameObject>();
TileMap tileMap = gameObject.GetComponent<TileMap>();
int range = attacker.GetUnitScript().atkRange;
int minX = Mathf.Max(attacker.x - range, 0);
int maxX = Mathf.Min(attacker.x + range+1, tileMap.width-1);
int minY = Mathf.Max(attacker.y - range, 0);
int maxY = Mathf.Min(attacker.y + range+1, tileMap.height-1);
// Calculate which tiles to call 'attackable'
for(int i = minX; i <= maxX; i++) {
for(int j = minY; j <= maxY; j++) {
TileScript dest = tileMap.At (i, j);
if(i == attacker.x && j == attacker.y) continue;
if(distBetween(attacker, dest) > range) continue;
if (dest.specialTerrain && dest.specialTerrain.name == "Tree")
{ // Can only attack someone in a tree if you are next to them.
if (distBetween(attacker, dest) > 1) continue;
}
if(dest.unit) {
// thats for attack only
//if(attacker.GetUnitScript().GetTeam() == dest.GetUnitScript().GetTeam()) continue;
list.Add(dest.gameObject);
}
}
}
return list;
}
public List<TileScript> visibleTilesFrom(TileScript from)
{
int range = from.GetUnitScript().visibilityRange;
return visibleTilesFrom(from, range);
}
public void SelectTile(TileScript tileScript)
{
if(!mySelector)
mySelector = Object.Instantiate(selectorType) as GameObject;
TileMap tileMap = gameObject.GetComponent<TileMap>();
mySelector.gameObject.light.color = Color.yellow;
//Game.getInstance().GetCurrentTeam().color;
putObjectAboveTile(mySelector, tileScript, 0.75f);
if(tileScript.specialTerrain) {
UnitScript specialTerrainScript = tileScript.specialTerrain.GetComponent<UnitScript>();
if(specialTerrainScript != null) {
}
}
//Put lights over each Tile;
if (tileScript.unit && tileScript.GetUnitScript().CanMove())
{
// The Selector light
// Don't display movement tiles for enemies.
if (tileScript.GetUnitScript().GetTeam() != Game.getInstance().currentTeam)
return;
int range = Mathf.Min(
tileScript.GetUnitScript().RemainingMovement(),
Game.getInstance().GetCurrentTeam().actionPoints
);
minX = Mathf.Max(tileScript.x - range, 0);
maxX = Mathf.Min(tileScript.x + range + 1, tileMap.width - 1);
minY = Mathf.Max(tileScript.y - range, 0);
maxY = Mathf.Min(tileScript.y + range + 1, tileMap.height - 1);
//Add all unvisited nodes to the list
for (int i = minX; i <= maxX; i++)
{
for (int j = minY; j <= maxY; j++)
{
if (distBetween(tileScript, tileMap.At(i, j)) > range) continue;
bool visible = Game.getInstance().GetCurrentTeam().foundTiles.Contains(tileMap.At(i,j));
if(tileMap.At(i,j).tileType == TileScript.TileType.WATER && visible) continue;
if (tileMap.At(i, j).unit != null && tileMap.At(i, j).GetUnitScript().GetTeam() == tileScript.GetUnitScript().GetTeam()) continue;
if (tileMap.At(i, j).unit != null && tileMap.At(i, j).GetUnitScript().GetVisible()) continue;
if (tileMap.At(i, j).unit == tileScript) continue;
unVisitedTiles.Add(tileMap.At(i, j));
}
}
tileScript.dist = 0;
range = 25;
getTiles(tileScript, range);
for (int k = 0; k < visitedTiles.Count; k++)
{
// Added a shitty fix but anyway visitedTiles shouldn't have a repeat tile!!
if (markedTiles.Contains(visitedTiles[k]))
{
continue;
//Debug.Log ("uh what???" + k + ", " + visitedTiles[k].x + ", " + visitedTiles[k].y);
}
GameObject movementMarker = Object.Instantiate(movementType) as GameObject;
putObjectAboveTile(movementMarker, visitedTiles[k].x, visitedTiles[k].y, 0.6f);
movementMarker.transform.parent = visitedTiles[k].gameObject.transform;
markedTiles.Add(visitedTiles[k]);
visitedTiles[k].marker = movementMarker;
}
if (range == 0)
{
mySelector.gameObject.light.color = Color.red;
}
Game.getInstance().RefreshUnitDescriptions();
}
}
public bool MoveUnit(TileScript source, TileScript dest)
{
if(!markedTiles.Contains (dest)) return false;
if(!source.unit) return false;
if (source.GetUnitScript().CanMove())
{
source.GetUnitScript().timesMoved++;
Debug.Log("Moved " + source.GetUnitScript().timesMoved + "times.");
UnitScript unitToMove = source.GetUnitScript();
//THIS WHOLE WHILE LOOP IS JUST TO FIND WHICH WAY TO GO FIRST.
//FROM HERE
TileScript tempSource = dest;
while (tempSource != source)
{
if (tempSource.directionFrom == TileScript.Direction.LEFT)
{
tempSource = tileMap.At(tempSource.x - 1, tempSource.y);
tempSource.directionToGo = TileScript.Direction.RIGHT;
if (tempSource == source)
{
source.directionToGo = TileScript.Direction.RIGHT;
break;
}
}
else if (tempSource.directionFrom == TileScript.Direction.RIGHT)
{
tempSource = tileMap.At(tempSource.x + 1, tempSource.y);
tempSource.directionToGo = TileScript.Direction.LEFT;
if (tempSource == source)
{
source.directionToGo = TileScript.Direction.LEFT;
break;
}
}
else if (tempSource.directionFrom == TileScript.Direction.DOWN)
{
tempSource = tileMap.At(tempSource.x, tempSource.y - 1);
tempSource.directionToGo = TileScript.Direction.UP;
if (tempSource == source)
{
source.directionToGo = TileScript.Direction.UP;
Debug.Log("source will go " + source.directionToGo);
break;
}
}
else if (tempSource.directionFrom == TileScript.Direction.UP)
{
tempSource = tileMap.At(tempSource.x, tempSource.y + 1);
tempSource.directionToGo = TileScript.Direction.DOWN;
if (tempSource == source)
{
source.directionToGo = TileScript.Direction.DOWN;
break;
}
}
}
//TO HERE
// This makes the animations better so the idiot unit doesn't turn left at the end of moving
if (dest.directionFrom == TileScript.Direction.LEFT)
dest.directionToGo = TileScript.Direction.RIGHT;
else if (dest.directionFrom == TileScript.Direction.RIGHT)
dest.directionToGo = TileScript.Direction.LEFT;
else if (dest.directionFrom == TileScript.Direction.UP)
dest.directionToGo = TileScript.Direction.DOWN;
else if (dest.directionFrom == TileScript.Direction.DOWN)
dest.directionToGo = TileScript.Direction.UP;
//THE ACTUAL MOVEMENT.
List<TileScript> tilesToMoveTo = new List<TileScript>();
while (source != dest)
{
Game.Team team = GetComponent<Game>().GetCurrentTeam();
team.actionPoints -= source.GetImpedence();
unitToMove.tilesMovedThisTurn += source.GetImpedence();
if (source.directionToGo == TileScript.Direction.LEFT)
{
if(!FoundInterruption(tilesToMoveTo, source, -1, 0))
source = tileMap.At(source.x - 1, source.y);
else
break;
}
else if (source.directionToGo == TileScript.Direction.RIGHT)
{
if(!FoundInterruption(tilesToMoveTo, source, 1, 0))
source = tileMap.At(source.x + 1, source.y);
else
break;
}
else if (source.directionToGo == TileScript.Direction.DOWN)
{
if(!FoundInterruption(tilesToMoveTo, source, 0, -1))
source = tileMap.At(source.x, source.y-1);
else
break;
}
else if (source.directionToGo == TileScript.Direction.UP)
{
if(!FoundInterruption(tilesToMoveTo, source, 0, 1))
source = tileMap.At(source.x, source.y + 1);
else
break;
}
}
if(foundWater) {
foundWater = false;
if(unitToMove.tilesMovedThisTurn < unitToMove.range) {
unitToMove.timesMoved--;
unitToMove.tilesMovedThisTurn--;
}
Debug.Log ("F**K THIS CODE");
}
/*
foreach(TileScript tile in tilesToMoveTo) {
foreach(TileScript visTile in visibleTilesFrom(tile)) {
Game.getInstance().GetCurrentTeam().foundTiles.Add (visTile);
}
}
*/
// reset soruce to the original
source = unitToMove.parentTile;
unitToMove.gameObject.AddComponent<UnitMoveScript>().moveTo(tilesToMoveTo); // animation
tilesToMoveTo[tilesToMoveTo.Count - 1].AddUnit(source.unit); // sets unit's new location
source.unit = null;
if(unitToMove.CanMove())
unitToMove.tilesMovedThisTurn = 0;
//Game.getInstance().UnitMovedCallback();
return true;
}
else
return false;
}
