void StateManager()
{
ClearMoves();
int xPos = presentTile.GetComponent<BasicTile>().XPosition,
yPos = presentTile.GetComponent<BasicTile>().YPosition;
MovementPlane.Movement[] startRoute = new MovementPlane.Movement[0];
possibleMoves = new GameObject[grid.xSize * grid.ySize];
routesFound = 0;
parsedMoves = 0;
FindMoves(xPos, yPos, startRoute, routesFound, detectionRange, detectionRange, true);
for(int i = 0; i < objectsWithinRange.Count; i++)
{
if (objectsWithinRange[i].team != team)
{
targetObject = objectsWithinRange[i];
break;
}
}
if (targetObject != null)
{
for (int i = 0; i < possibleMoves.Length; i++)
{
if (targetObject.WithinZMovesFromThis(3, possibleMoves[i].GetComponent<MovementPlane>().PresentTile.GetComponent<BasicTile>(), false))// && targetObject.presentTile.GetComponent<BasicTile>().Accessible(possibleMoves[i].GetComponent<MovementPlane>().presentTile.GetComponent<BasicTile>(), true))
{
isMoving = true;
/*if (possibleMoves[i].GetComponent<MovementPlane>().movementCost <= maxMovementPoints)
{
StartCoroutine(FollowRoute(TileObject.TruncateRoute(possibleMoves[i].GetComponent<MovementPlane>().route, maxMovementPoints, true)));
}
else*/
StartCoroutine(FollowRoute(TileObject.TruncateRoute(possibleMoves[i].GetComponent<MovementPlane>().Route, maxMovementPoints, false)));
ClearMoves();
break;
}
}
}
}
public static MovementPlane.Movement[] TruncateRoute(MovementPlane.Movement[] truncatedRoute, int newMovementCost, bool removeLastMove)
{
List<MovementPlane.Movement> newRoute = new List<MovementPlane.Movement>();
MovementPlane.Movement[] finalNewRoute = null;
int moveCost = 0;
for (int i = 0; i < truncatedRoute.Length; i++)
{
if (truncatedRoute[i].xMovement != 0 && truncatedRoute[i].yMovement != 0)
moveCost += 3;
else
moveCost += 2;
if (moveCost <= newMovementCost)
newRoute.Add(truncatedRoute[i]);
else
{
break;
}
}
if (removeLastMove)
{
finalNewRoute = new MovementPlane.Movement[newRoute.Count - 1];
for (int j = 0; j < finalNewRoute.Length; j++)
{
finalNewRoute[j] = newRoute[j];
}
}
else
{
finalNewRoute = new MovementPlane.Movement[newRoute.Count];
finalNewRoute = newRoute.ToArray();
}
return finalNewRoute;
}
public bool Accessible(BasicTile originTile, bool unitsBlock, int team)
{
bool diagonal = false, aroundCorner = false,
sameHeight = originTile.PresentHeight == presentHeight;
Orientation moveDirection = new MovementPlane.Movement(xPosition - originTile.XPosition, yPosition - originTile.YPosition).orientation;
diagonal = IsDiagonal(originTile, this);
/*if (!diagonal)
{
if (xPosition - originTile.XPosition == 1)
moveDirection = Orientation.Forward;
else if (xPosition - originTile.XPosition == -1)
moveDirection = Orientation.Backward;
else if (yPosition - originTile.YPosition == 1)
moveDirection = Orientation.Left;
else if (yPosition - originTile.YPosition == -1)
moveDirection = Orientation.Right;
else
{
moveDirection = Orientation.Directionless;
print("Caution, weird moves");
}
}*/
if (type == TileKind.Empty || type == TileKind.Impassable)
{
return false;
}
else if (!(originTile.PresentHeight == presentHeight + 1
|| originTile.PresentHeight == presentHeight
|| originTile.PresentHeight == presentHeight - 1))
{
return false;
}
else if (isOccupied && unitsBlock && team != CharacterStepping.team)
{
return false;
}
else if (diagonal)
{
aroundCorner = IsAroundCorner(originTile, this);
if (aroundCorner)
{
return false;
}
else if (!sameHeight || type != TileKind.Flat || originTile.type != TileKind.Flat)
{
return false;
}
else if (unitsBlock)
{
if (moveDirection == Orientation.ForwardRight && grid.Grid(xPosition, yPosition + 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition - 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else if (moveDirection == Orientation.BackwardRight && grid.Grid(xPosition, yPosition + 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition + 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else if (moveDirection == Orientation.BackwardLeft && grid.Grid(xPosition, yPosition - 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition + 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else if (moveDirection == Orientation.ForwardLeft && grid.Grid(xPosition, yPosition - 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition - 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else
{
return true;
}
}
else
{
return true;
}
}
else if (originTile.type == TileKind.Flat && type == TileKind.Flat && sameHeight)
{
return true;
}
else if (originTile.type == TileKind.Stair)
{
if (moveDirection != InvertOrientation(originTile.orientation) && moveDirection != originTile.orientation && originTile.orientation == orientation)
{
if (type == TileKind.Stair
&& sameHeight)
{
return true;
}
}
/*if (!(originTile.orientation == moveDirection || InvertOrientation(originTile.orientation) == moveDirection))
{
return false;
}*/
else if (originTile.orientation == moveDirection)
{
if (type == TileKind.Flat && sameHeight)
{
return true;
}
else if (type == TileKind.Stair
&& orientation == moveDirection && originTile.PresentHeight == presentHeight - 1)
{
return true;
}
else if (type == TileKind.Stair
&& InvertOrientation(orientation) == moveDirection && sameHeight)
{
return true;
}
else
{
return false;
}
}
else if (InvertOrientation(originTile.orientation) == moveDirection)
{
if (type == TileKind.Flat
&& originTile.PresentHeight == presentHeight + 1)
{
return true;
}
else if (type == TileKind.Stair && orientation == InvertOrientation(moveDirection)
&& originTile.PresentHeight == presentHeight + 1)
{
return true;
}
else if (type == TileKind.Stair
&& orientation == moveDirection && sameHeight)
{
return true;
}
else
{
return false;
}
}
else if (moveDirection != InvertOrientation(originTile.orientation) && moveDirection != originTile.orientation)
{
print("Move thing");
if (type == TileKind.Stair
&& sameHeight)
{
return true;
}
}
else
{
return false;
}
}
else if (originTile.type == TileKind.Flat && type == TileKind.Stair)
{
//print(orientation + " " + moveDirection + " " + this);
if (orientation == moveDirection && originTile.PresentHeight == presentHeight - 1)
{
return true;
}
else if (InvertOrientation(orientation) == moveDirection && sameHeight)
{
return true;
}
else
{
return false;
}
}
return false;
}
bool SetupMovement(MovementPlane.Movement move, MovementPlane.Movement[] route,
int movesFound, int xPos, int yPos, int movePointsLeft, int maxMoves, bool unitsBlock)
{
int moveCost = 0;
bool foundMove = false;
bool crossingDiagonal = false;
if(move.xMovement != 0 && move.yMovement != 0)
{
for (int i = 0; i < movesFound; i++)
{
int X = possibleMoves[i].GetComponent<MovementPlane>().PresentTile.GetComponent<BasicTile>().XPosition,
Y = possibleMoves[i].GetComponent<MovementPlane>().PresentTile.GetComponent<BasicTile>().YPosition;
if (((xPos + move.xMovement == X && yPos == Y) ||
(xPos == X && yPos + move.yMovement == Y)) &&
DiagonalsCrossing(move,
possibleMoves[i].GetComponent<MovementPlane>().Route[possibleMoves[i].GetComponent<MovementPlane>().Route.Length - 1]))
{
crossingDiagonal = true;
}
}
}
if (!(xPos + move.xMovement < grid.xSize && xPos + move.xMovement >= 0
&&
yPos + move.yMovement < grid.ySize && yPos + move.yMovement >= 0))
return foundMove;
else if (crossingDiagonal)
return foundMove;
else if (grid.Grid(xPos + move.xMovement, yPos + move.yMovement).GetComponent<BasicTile>().Accessible(grid.Grid(xPos, yPos).GetComponent<BasicTile>(), unitsBlock, team))
{
foundMove = true;
moveCost = MovementPlane.RouteMoveCost(route);
if (move.xMovement != 0 && move.yMovement != 0)
moveCost += 3;
else
moveCost += 2;
if (moveCost <= maxMoves)
{
possibleMoves[movesFound] = Instantiate(movementPlane);
MovementPlane.Movement[] newRoute = new MovementPlane.Movement[route.Length + 1];
for (int i = 0; i < route.Length; i++)
{
newRoute[i] = route[i];
}
newRoute[route.Length] = move;
possibleMoves[movesFound].GetComponent<MovementPlane>().AssignMovementPlaneValues(grid.Grid(xPos + move.xMovement, yPos + move.yMovement), true, false, this, newRoute, moveCost);
possibleMoves[movesFound].name = "Move " + (xPos + move.xMovement) + " " + (yPos + move.yMovement);
possibleMoves[movesFound].name += " costs " + possibleMoves[movesFound].GetComponent<MovementPlane>().MovementCost;
foundMove = true;
}
else
{
foundMove = false;
//MovementPlane.PrintRoute(route);
}
}
if(grid.Grid(xPos + move.xMovement, yPos + move.yMovement).GetComponent<BasicTile>().IsOccupied)
{
objectsWithinRange.Add(grid.Grid(xPos + move.xMovement, yPos + move.yMovement).GetComponent<BasicTile>().CharacterStepping);
}
return foundMove;
}
public void ShowMoves()
{
ClearMoves();
int xPos = presentTile.GetComponent<BasicTile>().XPosition,
yPos = presentTile.GetComponent<BasicTile>().YPosition;
MovementPlane.Movement[] startRoute = new MovementPlane.Movement[0];
possibleMoves = new GameObject[grid.xSize * grid.ySize];
routesFound = 0;
parsedMoves = 0;
FindMoves(xPos, yPos, startRoute, routesFound, movementPoints, movementPoints, true);
//StartCoroutine(NewFindMovesCorout(xPos, yPos, startRoute, routesFound, maxMovementPoints));
}
public IEnumerator Knockback(int knockBackTiles, BasicTile.Orientation direction)
{
MovementPlane.Movement move = new MovementPlane.Movement(direction);
int diagonalFactor;
if (direction == BasicTile.Orientation.Forward || direction == BasicTile.Orientation.Right ||
direction == BasicTile.Orientation.Backward || direction == BasicTile.Orientation.Left)
diagonalFactor = 2;
else
diagonalFactor = 3;
//print("knocking " + this + " " + knockBackTiles + " " + diagonalFactor + " " + move.orientation);
for (int i = 0; i < knockBackTiles / diagonalFactor; i++)
{
float moveProgress = 0f;
int X = presentTile.GetComponent<BasicTile>().XPosition,
Y = presentTile.GetComponent<BasicTile>().YPosition;
print(move.xMovement + " " + move.yMovement + " " + direction);
nextTile = grid.Grid(X + move.xMovement, Y + move.yMovement);
if (!nextTile.GetComponent<BasicTile>().Accessible(presentTile.GetComponent<BasicTile>(), true, team))
{
Damage(knockBackTiles - i * diagonalFactor);
break;
}
while (moveProgress <= 1f)
{
print("knocking " + presentTile + " " + nextTile + " " + moveProgress);
orientation = move.orientation;
transform.localPosition = CalculateMovement(moveProgress);
moveProgress += Time.deltaTime * speed;
yield return null;
}
print("Ending this NOW");
presentTile.GetComponent<BasicTile>().IsOccupied = false;
presentTile.GetComponent<BasicTile>().CharacterStepping = null;
presentTile = nextTile;
presentTile.GetComponent<BasicTile>().IsOccupied = true;
presentTile.GetComponent<BasicTile>().CharacterStepping = this;
nextTile = null;
moveProgress = 0f;
}
isMoving = false;
FinishedMoving();
animatedMesh.Play("Armature|WAIT01.001");
yield break;
}
public void FindMoves(int xPos, int yPos, MovementPlane.Movement[] route, int movesFound, int movementPointsLeft, int maxMoves, bool unitsBlock)
{
bool[] knownTiles = { true, true, true, true, true, true, true, true };
bool[] reachedEndOfLine = { false, false, false, false, false, false, false, false };
int endedLines = 0;
int movesFoundThisRound = 0;
parsedMoves++;
int[] straightMoves = new int[8];
MovementPlane.Movement[] directions = new MovementPlane.Movement[8];
directions[0] = new MovementPlane.Movement(1, 0);
directions[4] = new MovementPlane.Movement(1, 1);
directions[1] = new MovementPlane.Movement(0, 1);
directions[5] = new MovementPlane.Movement(-1, 1);
directions[2] = new MovementPlane.Movement(-1, 0);
directions[6] = new MovementPlane.Movement(-1, -1);
directions[3] = new MovementPlane.Movement(0, -1);
directions[7] = new MovementPlane.Movement(1, -1);
for (int i = 0; i < straightMoves.Length; i++)
{
straightMoves[i] = 1;
}
int initXPos = presentTile.GetComponent<BasicTile>().XPosition,
initYPos = presentTile.GetComponent<BasicTile>().YPosition;
while (endedLines < 8)
{
for (int j = 0; j <= 7; j++)
{
if (!reachedEndOfLine[j])
{
for (int i = 0; i < movesFound; i++)
{
int X = possibleMoves[i].GetComponent<MovementPlane>().PresentTile.GetComponent<BasicTile>().XPosition,
Y = possibleMoves[i].GetComponent<MovementPlane>().PresentTile.GetComponent<BasicTile>().YPosition,
newXPos = xPos, newYPos = yPos;
newXPos += straightMoves[j] * directions[j].xMovement;
newYPos += straightMoves[j] * directions[j].yMovement;
if ((newXPos == initXPos && newYPos == initYPos) ||
(newXPos == X && newYPos == Y))
{
knownTiles[j] = false;
}
}
if (knownTiles[j])
{
MovementPlane.Movement[] newRoute = new MovementPlane.Movement[route.Length + straightMoves[j] - 1];
int newXPos = xPos, newYPos = yPos;
for (int k = 0; k < route.Length; k++)
{
newRoute[k] = route[k];
}
for (int k = 0; k < straightMoves[j] - 1; k++)
{
newRoute[route.Length + k] = directions[j];
}
newXPos += (straightMoves[j] - 1) * directions[j].xMovement;
newYPos += (straightMoves[j] - 1) * directions[j].yMovement;
if (SetupMovement(directions[j], newRoute, movesFound, newXPos, newYPos, movementPointsLeft, maxMoves, unitsBlock))
{
//yield return new WaitForSeconds(0.1f);
straightMoves[j]++;
movesFound++;
movesFoundThisRound++;
}
else
{
reachedEndOfLine[j] = true;
endedLines++;
}
}
else
{
reachedEndOfLine[j] = true;
endedLines++;
}
}
}
}
if (possibleMoves[parsedMoves - 1] != null)
{
int X = possibleMoves[parsedMoves - 1].GetComponent<MovementPlane>().PresentTile.GetComponent<BasicTile>().XPosition,
Y = possibleMoves[parsedMoves - 1].GetComponent<MovementPlane>().PresentTile.GetComponent<BasicTile>().YPosition,
movePointsLeft = maxMoves - possibleMoves[parsedMoves - 1].GetComponent<MovementPlane>().MovementCost;
MovementPlane.Movement[] moveRoute = possibleMoves[parsedMoves - 1].GetComponent<MovementPlane>().Route;
FindMoves(X, Y, moveRoute, movesFound, movePointsLeft, maxMoves, unitsBlock);
}
return;
}