private static float DistBetween(MovementTile current, MovementTile neighbor)
{
float x = current.x - neighbor.x;
float y = current.y - neighbor.y;
return(x * x + y * y);
}
public void CreateBoardingPlank()
{
if (createdPlank)
{
return;
}
createdPlank = true;
Transform plank = Instantiate(plankPrefab, new Vector2(2, .25f), Quaternion.identity).transform;
MovementTile[,] plankTiles = new MovementTile[2, 1];
for (int x = 0; x < plankTiles.GetLength(0); x++)
{
for (int y = 0; y < plankTiles.GetLength(1); y++)
{
plankTiles [x, y] = plank.GetChild(x * 1 + y).GetComponent <MovementTile> ();
plankTiles [x, y].x = x;
plankTiles [x, y].y = y;
}
}
AStar.AddAreaToLayout(plankTiles);
LevelLayout.Portal portalPlayerPlank = new LevelLayout.Portal(playerBoarding, plankTiles [0, 0]);
AStar.AddPortalToLayout(portalPlayerPlank);
LevelLayout.Portal portalPlankShip = new LevelLayout.Portal(plankTiles [1, 0], otherBoarding);
AStar.AddPortalToLayout(portalPlankShip);
}
private void RePrioritize(List <CrewMember> priorities, MovementTile tile)
{
for (int i = 0; i < priorities.Count; i++)
{
if (!priorities [i])
{
priorities.RemoveAt(i);
i--;
}
}
for (int i = priorities.Count - 1; i > 0; i--)
{
for (int j = i; j > 0; j--)
{
if (CompareCrewMember(priorities [j - 1], priorities [j], tile) > 0)
{
CrewMember c = priorities [j - 1];
priorities [j - 1] = priorities [j];
priorities [j] = c;
}
else
{
break;
}
}
}
}
//sort tile lower into heap
void SortDown(MovementTile item)
{
while (true)
{
int leftChildIndex = item.heapIndex * 2 + 1;
int rightChildIndex = (item.heapIndex * 2) + 2;
int swapIndex = 0;
if (leftChildIndex < itemCount)
{
swapIndex = leftChildIndex;
if (rightChildIndex < itemCount)
{
if (heapTiles [leftChildIndex].CompareTo(heapTiles [rightChildIndex]) < 0)
{
swapIndex = rightChildIndex;
}
}
if (item.CompareTo(heapTiles [swapIndex]) < 0)
{
Swap(item, heapTiles [swapIndex]);
}
else
{
return;
}
}
else
{
return;
}
}
}
//add item into heap and sort it into position
public void Add(MovementTile item)
{
item.heapIndex = itemCount;
heapTiles [itemCount] = item;
SortUp(item);
itemCount++;
}
private void RotateTowardsDiagonal(MovementTile t)
{
Vector2 targetDir = t.transform.position - transform.position;
float angle = Mathf.Atan2(targetDir.y, targetDir.x) * Mathf.Rad2Deg - 90 - 45;
transform.rotation = Quaternion.AngleAxis(angle, Vector3.forward);
}
public BailPosition GetClosestFloodedTile(MovementTile tile)
{
BailPosition bp = null;
int shortestPathCount = int.MaxValue;
for (int i = 0; i < floodedTiles.Count; i++)
{
if (!floodedTiles[i])
{
floodedTiles.RemoveAt(i);
i--;
}
if (!floodedTiles[i].isManned)
{
int pathCount = AStar.FindPath(tile, floodedTiles[i].tile, true).Count;
if (shortestPathCount > pathCount)
{
shortestPathCount = pathCount;
bp = floodedTiles[i];
}
}
}
return(bp);
}
private List <MovementTile> FindAdjacents()
{
List <MovementTile> adjacents = new List <MovementTile> ();
MovementTile temp = AStar.GetTile(tile.x, tile.y + 1, tile.layer);
if (temp && temp.floodedTile)
{
adjacents.Add(temp);
}
temp = AStar.GetTile(tile.x + 1, tile.y, tile.layer);
if (temp && temp.floodedTile)
{
adjacents.Add(temp);
}
temp = AStar.GetTile(tile.x, tile.y - 1, tile.layer);
if (temp && temp.floodedTile)
{
adjacents.Add(temp);
}
temp = AStar.GetTile(tile.x - 1, tile.y, tile.layer);
if (temp && temp.floodedTile)
{
adjacents.Add(temp);
}
return(adjacents);
}
private static void PrintPathRetrace(MovementTile end)
{
while (end != null)
{
Debug.Log(end.x + ", " + end.y);
end = end.prev;
}
}
private void ChangeCurrentTile(MovementTile newCurrent)
{
current.crewMem = null;
newCurrent.crewMem = this;
current = newCurrent;
anim.SetInteger("FacingDirection", GetDirectionOfTile(current));
}
public void Init(MovementTile dest, bool hit, bool shotByPlayer, Ship targetShip, int damage)
{
this.hit = hit;
destination = dest;
this.shotByPlayer = shotByPlayer;
this.targetShip = targetShip;
targetPos = hit ? dest.transform.position : ((dest.transform.position - transform.position) * 3);
this.damage = damage;
}
public static MovementTile[] GetTileNeighbors(MovementTile tile)
{
MovementTile[] neighbors = new MovementTile [4];
neighbors [0] = RangeCheckTile(tile.x + 1, tile.y, tile.layer);
neighbors [1] = RangeCheckTile(tile.x, tile.y + 1, tile.layer);
neighbors [2] = RangeCheckTile(tile.x - 1, tile.y, tile.layer);
neighbors [3] = RangeCheckTile(tile.x, tile.y - 1, tile.layer);
return(neighbors);
}
//swap tiles
void Swap(MovementTile item1, MovementTile item2)
{
heapTiles [item1.heapIndex] = item2;
heapTiles [item2.heapIndex] = item1;
int tempIndex = item1.heapIndex;
item1.heapIndex = item2.heapIndex;
item2.heapIndex = tempIndex;
}
//remove first tile and resort heap
public MovementTile RemoveFirst()
{
MovementTile first = heapTiles [0];
itemCount--;
heapTiles [0] = heapTiles [itemCount];
heapTiles [0].heapIndex = 0;
SortDown(heapTiles [0]);
return(first);
}
protected CrewMember CreateCrewMember(MovementTile tile)
{
CrewMember c = Instantiate(crewPrefab, tile.transform.position, Quaternion.identity).GetComponent <CrewMember> ();
c.current = tile;
tile.crewMem = c;
AssignBaseStats(c);
return(c);
}
private void PaintTileBasedOnMovementCost(MovementTile movementTile)
{
var movementCostPercentage = 1.1f - (float)movementTile.MovementCost / Movement.MaxCost;
var uvRect = new Rect2D(new Vector2(movementCostPercentage, 0),
new Vector2(movementCostPercentage, 0),
new Vector2(movementCostPercentage, 0),
new Vector2(movementCostPercentage, 0));
movementTile.SetUVs(uvRect);
}
private static MyLinkedList <MovementTile> CreatePath(MovementTile finish)
{
MyLinkedList <MovementTile> path = new MyLinkedList <MovementTile> ();
while (finish != null)
{
path.AddFirst(finish);
finish = finish.prev;
}
return(path);
}
private int IsCloserToThan(CrewMember crew1, CrewMember crew2, MovementTile tile)
{
float disToPortal1 = Vector2.SqrMagnitude(crew1.transform.position - tile.transform.position);
float disToPortal2 = Vector2.SqrMagnitude(crew2.transform.position - tile.transform.position);
if (disToPortal1 == disToPortal2)
{
return(0);
}
return(disToPortal1 < disToPortal2 ? -1 : 1);
}
private List <Vector3Int> RetracePath(MovementTile startTile, MovementTile endTile)
{
List <Vector3Int> path = new List <Vector3Int>();
MovementTile currentTile = endTile;
while (currentTile != startTile)
{
path.Add(currentTile.coordinates);
currentTile = currentTile.parent;
}
path.Reverse();
return(path);
}
void Awake()
{
layers = new int[areas.Length];
edgeTiles = new List <MovementTile> ();
floodedTiles = new List <BailPosition> ();
List <MovementTile[, ]> areaTiles = new List <MovementTile[, ]> ();
for (int i = 0; i < areas.Length; i++)
{
Transform area = areas[i].area;
Vector2Int dims = areas [i].dimensions;
MovementTile[,] tiles = new MovementTile [dims.x, dims.y];
for (int x = 0; x < dims.x; x++)
{
for (int y = 0; y < dims.y; y++)
{
tiles [x, y] = area.GetChild(x * 8 + y).GetComponent <MovementTile> ();
tiles [x, y].x = x;
tiles [x, y].y = y;
if (tiles [x, y].isEdgeTile)
{
edgeTiles.Add(tiles [x, y]);
}
if (tiles [x, y].walkable)
{
maxFloodTiles++;
//TODO: testing this (also in plank prefab)
tiles[x, y].GetComponent <SpriteRenderer> ().enabled = false;
}
}
}
layers [i] = tiles [0, 0].layer;
areaTiles.Add(tiles);
AStar.AddAreaToLayout(tiles);
}
List <LevelLayout.Portal> portalTiles = new List <LevelLayout.Portal> ();
for (int i = 0; i < portals.Length; i++)
{
portalTiles.Add(portals [i]);
AStar.AddPortalToLayout(portals [i]);
}
}
private int GetHeuristicDistance(MovementTile neighbor, MovementTile endTile)
{
int distX = Mathf.Abs(neighbor.coordinates.x - endTile.coordinates.x);
int distY = Mathf.Abs(neighbor.coordinates.y - endTile.coordinates.y);
if (distX > distY)
{
return(Mathf.RoundToInt(1.4f * distY + (distX - distY)));
}
else
{
return(Mathf.RoundToInt(1.4f * distX + (distY - distX)));
}
}
private BailPosition CreateFloodedTile(MovementTile t)
{
BailPosition bp = Instantiate(floodedTilePrefab, t.transform.position,
Quaternion.identity).GetComponent <BailPosition> ();
bp.transform.parent = transform.parent;
t.floodedTile = bp;
bp.tile = t;
bp.isAssignAbleTo = isAssignAbleTo;
//TODO: make know which ship
transform.parent.GetComponent <Ship> ().AddFloodedTile(bp);
return(bp);
}
public MyLinkedList <MovementTile> GetShortestPathToEdgeTile(MovementTile tile)
{
MyLinkedList <MovementTile> shortestPath = null;
for (int i = 0; i < edgeTiles.Count; i++)
{
MyLinkedList <MovementTile> path = AStar.FindPath(tile, edgeTiles [i], true);
if (shortestPath == null || shortestPath.Count > path.Count)
{
shortestPath = path;
}
}
return(shortestPath);
}
public void Fire(BattleManager battleManager, bool hit)
{
MovementTile t = battleManager.GetRandomTile(!isAssignAbleTo);
CannonBall cb = Instantiate(cannonBall, spawnLoc.position, Quaternion.identity).GetComponent <CannonBall> ();
//TODO: maybe fix this reroll system
while (!t.walkable)
{
t = battleManager.GetRandomTile(!isAssignAbleTo);
}
Ship target = isAssignAbleTo ? battleManager.otherShip : battleManager.playerShip;
int damage = isAssignAbleTo ? battleManager.playerShip.cannonDamage : battleManager.otherShip.cannonDamage;
cb.Init(t, hit, isAssignAbleTo, target, damage);
}
private int CompareCrewMember(CrewMember crew1, CrewMember crew2, MovementTile tile)
{
if (crew1.role == CrewMember.Role.CANNONEER)
{
if (crew2.role == CrewMember.Role.CANNONEER)
{
return(IsCloserToThan(crew1, crew2, tile));
}
return(-1);
}
else if (crew2.role == CrewMember.Role.CANNONEER)
{
return(1);
}
else
{
return(IsCloserToThan(crew1, crew2, tile));
}
}
//sort item higher into heap
void SortUp(MovementTile item)
{
int indexOfParent = (item.heapIndex - 1) / 2;
while (true)
{
MovementTile parent = heapTiles [indexOfParent];
if (item.CompareTo(parent) > 0)
{
Swap(item, parent);
}
else
{
break;
}
indexOfParent = (item.heapIndex - 1) / 2;
}
}
public DamagedPosition GetClosestDamagedTile(MovementTile tile)
{
DamagedPosition dp = null;
int shortestPathCount = int.MaxValue;
for (int i = 0; i < damagedTiles.Count; i++)
{
if (damagedTiles[i].IsAvailable())
{
int pathCount = AStar.FindPath(tile, damagedTiles[i].tile, true).Count;
if (shortestPathCount > pathCount)
{
shortestPathCount = pathCount;
dp = damagedTiles[i];
}
}
}
return(dp);
}
private List <MovementTile> FindDiagonals(List <MovementTile> adjacents)
{
List <MovementTile> diagonals = new List <MovementTile> ();
for (int i = 0; i < adjacents.Count; i++)
{
MovementTile t1 = i == 0 ? adjacents[adjacents.Count - 1] : adjacents[i - 1];
MovementTile t2 = adjacents[i];
if ((t1.x - t2.x) * (t1.x - t2.x) + (t1.y - t2.y) * (t1.y - t2.y) == 2)
{
int x = tile.x != t1.x ? t1.x : t2.x;
int y = tile.y != t1.y ? t1.y : t2.y;
MovementTile diagonal = AStar.GetTile(x, y, tile.layer);
if (diagonal.floodedTile && !diagonals.Contains(diagonal))
{
diagonals.Add(diagonal);
}
}
}
return(diagonals);
}
private int GetDirectionOfTile(MovementTile tile)
{
float angle = Vector2.SignedAngle(Vector3.right, tile.transform.position - transform.position);
int num = 0;
if (angle < 45 && angle > -45)
{
num = 0;
}
else if (angle > 45 && angle < 135)
{
num = 1;
}
else if (angle > 135 || angle < -135)
{
num = 2;
}
else if (angle < -45 && angle > -135)
{
num = 3;
}
return(num);
}
public void UpdateTileImage()
{
List <MovementTile> adjacents = FindAdjacents();
List <MovementTile> diagonals = FindDiagonals(adjacents);
Sprite current = sr.sprite;
switch (adjacents.Count)
{
case 0:
sr.sprite = none;
break;
case 1:
sr.sprite = one;
RotateTowardsAdjacent(adjacents[0]);
break;
case 2:
MovementTile t1 = adjacents[0];
MovementTile t2 = adjacents[1];
Vector2Int vec = new Vector2Int(t1.x - t2.x, t1.y - t2.y);
if (vec.x * vec.x + vec.y * vec.y == 4)
{
RotateTowardsAdjacent(adjacents[0]);
sr.sprite = twoAcross;
}
else
{
RotateTowardsDiagonal(AStar.GetTile(t1.x - tile.x + t2.x,
t1.y - tile.y + t2.y, tile.layer));
sr.sprite = diagonals.Count == 1 ? twoAdjacentDiagonal : twoAdjacent;
}
break;
case 3:
//find where adjacent isnt
MovementTile second = null;
MovementTile[] neighbors = AStar.GetTileNeighbors(tile);
for (int i = 0; i < neighbors.Length; i++)
{
if (!neighbors[i] || !neighbors[i].floodedTile)
{
second = neighbors[(i + 2) % 4];
}
}
RotateTowardsAdjacent(second);
switch (diagonals.Count)
{
case 0:
sr.sprite = three;
break;
case 1:
float angle = Vector2.SignedAngle(second.transform.position - transform.position,
diagonals[0].transform.position - transform.position);
sr.sprite = angle > 0 ? threeDiagonalLeft : threeDiagonalRight;
break;
case 2:
sr.sprite = threeTwoDiagonal;
break;
}
break;
case 4:
switch (diagonals.Count)
{
case 0:
sr.sprite = four;
break;
case 1:
RotateTowardsDiagonal(diagonals[0]);
sr.sprite = fourOneDiagonal;
break;
case 2:
MovementTile d1 = diagonals[0];
MovementTile d2 = diagonals[1];
if ((d1.x - d2.x) * (d1.x - d2.x) + (d1.y - d2.y) * (d1.y - d2.y) == 4)
{
int x = (d1.x + d2.x) / 2;
int y = (d1.y + d2.y) / 2;
MovementTile middle = AStar.GetTile(x, y, tile.layer);
RotateTowardsAdjacent(middle);
sr.sprite = fourTwoDiagonalAdjacent;
}
else
{
RotateTowardsDiagonal(diagonals[0]);
sr.sprite = fourTwoDiagonalAcross;
}
break;
case 3:
int tx = -(diagonals[0].x + diagonals[1].x + diagonals[2].x - 3 * tile.x) + tile.x;
int ty = -(diagonals[0].y + diagonals[1].y + diagonals[2].y - 3 * tile.y) + tile.y;
MovementTile t = AStar.GetTile(tx, ty, tile.layer);
RotateTowardsDiagonal(t);
sr.sprite = fourThreeDiagonal;
break;
case 4:
sr.sprite = fourFourDiagonal;
break;
}
break;
}
if (current != sr.sprite)
{
for (int i = 0; i < adjacents.Count; i++)
{
if (adjacents[i] && adjacents[i].floodedTile)
{
adjacents[i].floodedTile.UpdateTileImage();
}
}
}
}
