void OnTriggerEnter(Collider col)
{
if (Input.GetMouseButton(0))
{
enterEdge = GetEdge(Input.mousePosition);
}
}
private static List <TileEdge> _ConvertChordlessPolygonToPolyEdges(ImmutableArray <Vector2> outerPerim, Dictionary <PolyEdge, TileEdge> polyToTileMap)
{
var outerEdges = new List <TileEdge>();
for (int i = 0; i < outerPerim.Length - 1; i++)
{
Vector2 thisVertex = outerPerim[i];
Vector2 nextVertex = outerPerim[i + 1];
foreach (PolyEdge polyEdge in polyToTileMap.Keys)
{
if (polyEdge.a == thisVertex && polyEdge.b == nextVertex ||
polyEdge.b == thisVertex && polyEdge.a == nextVertex)
{
TileEdge tileEdge = polyToTileMap[polyEdge];
if (polyEdge.a == thisVertex)
{
outerEdges.Add(tileEdge);
}
else
{
var reverseEdge = tileEdge.GetReverseEdge() as TileEdge;
outerEdges.Add(reverseEdge);
}
}
}
}
return(outerEdges);
}
/// <summary>
/// Converts an outer perimeter represented by PolygonSplittingGraphNodes to a list of PolyEdges in the same order.
/// </summary>
/// <param name="outerNodes">List of PolygonSplittingGraphNodes in order forming an outer perimeter.</param>
/// <param name="polyToTileMap">A Dictionary mapping PolyEdges to their respective TileEdges.</param>
/// <returns>List of PolyEdges forming the same outer perimeter described by <param>outerNodes</param>.</returns>
private static List <TileEdge> _ConvertPolygonNodesToPolyEdges(List <PolygonSplittingGraphNode> outerNodes, Dictionary <PolyEdge, TileEdge> polyToTileMap)
{
var outerEdges = new List <TileEdge>();
for (int i = 0; i < outerNodes.Count - 1; i++)
{
var thisVertex = new Vector2(outerNodes[i].x, outerNodes[i].y);
var nextVertex = new Vector2(outerNodes[i + 1].x, outerNodes[i + 1].y);
foreach (PolyEdge polyEdge in polyToTileMap.Keys)
{
if (polyEdge.a == thisVertex && polyEdge.b == nextVertex ||
polyEdge.b == thisVertex && polyEdge.a == nextVertex)
{
TileEdge tileEdge = polyToTileMap[polyEdge];
if (polyEdge.a == thisVertex)
{
outerEdges.Add(tileEdge);
}
else
{
var reverseEdge = tileEdge.GetReverseEdge() as TileEdge;
outerEdges.Add(reverseEdge);
}
}
}
}
return(outerEdges);
}
void SetTileEdges(Sprite sprite)
{
for (int edgeIndex = 0; edgeIndex < (int)ETileEdge.COUNT; ++edgeIndex)
{
edge[edgeIndex] = new TileEdge(sprite, (ETileEdge)edgeIndex, tileFlags);
}
}
private void computeOxyLevel()
{
int deriver = 1;
float value = o2Level;
if (TileEdge.IsPassable(down) && downNeighbour != null && TileEdge.IsPassable(downNeighbour.up))
{
deriver++;
value += downNeighbour.o2Level;
}
if (TileEdge.IsPassable(up) && upNeighbour != null && TileEdge.IsPassable(upNeighbour.down))
{
deriver++;
value += upNeighbour.o2Level;
}
if (TileEdge.IsPassable(left) && leftNeighbour != null && TileEdge.IsPassable(leftNeighbour.right))
{
deriver++;
value += leftNeighbour.o2Level;
}
if (TileEdge.IsPassable(right) && rightNeighbour != null && TileEdge.IsPassable(rightNeighbour.left))
{
deriver++;
value += rightNeighbour.o2Level;
}
o2Level = value / deriver;
}
/// <summary>Draw a tile border.</summary>
/// <param name="spriteBatch">The sprite batch to which to draw.</param>
/// <param name="origin">The top-left pixel position of the tile relative to the screen.</param>
/// <param name="edge">The tile edge to draw.</param>
/// <param name="color">The border color.</param>
/// <param name="width">The border width.</param>
/// <returns>Returns whether a border was drawn. This may return false if the width is zero, or the edge is invalid.</returns>
private bool DrawBorder(SpriteBatch spriteBatch, Vector2 origin, TileEdge edge, Color color, int width)
{
if (width <= 0)
{
return(false);
}
switch (edge)
{
case TileEdge.Left:
spriteBatch.Draw(CommonHelper.Pixel, new Rectangle((int)origin.X, (int)origin.Y, width, Game1.tileSize), color);
return(true);
case TileEdge.Right:
spriteBatch.Draw(CommonHelper.Pixel, new Rectangle((int)(origin.X + Game1.tileSize - width), (int)origin.Y, width, Game1.tileSize), color);
return(true);
case TileEdge.Top:
spriteBatch.Draw(CommonHelper.Pixel, new Rectangle((int)origin.X, (int)origin.Y, Game1.tileSize, width), color);
return(true);
case TileEdge.Bottom:
spriteBatch.Draw(CommonHelper.Pixel, new Rectangle((int)origin.X, (int)(origin.Y + Game1.tileSize - width), Game1.tileSize, width), color);
return(true);
}
return(false);
}
/// <summary>
/// Checks if a ledge would be valid if superimposed to a higher tilemap by checking if said higher
/// tilemap contains a tile either:
/// 1. Above (on the superimposed tile map) the tile that the ledge originated from (on base tilemap)
/// 2. Above and adjacent (on superimposed tilemap) the tile that the ledge originated from IN THE
/// DIRECTION that the ledge is in.
/// </summary>
/// <param name="ledge">Ledge being checked for validity.</param>
/// <param name="baseTileMap">TileMap that the ledge is on.</param>
/// <param name="superTileMap">TileMap that ledge would be superimposed to if valid.</param>
/// <returns>True is valid, false otherwise.</returns>
private static bool _IsLedgeValid(TileEdge ledge, TileMap baseTileMap, TileMap superTileMap)
{
Vector2 aboveTile = TileFuncs.GetTileAboveOrBelow(ledge.tileCoords, baseTileMap.ZIndex, superTileMap.ZIndex);
Vector2 adjAboveTile = TileFuncs.GetTileAdjacent(aboveTile, ledge.tileSide);
return(superTileMap.GetCellv(aboveTile) == TileMap.InvalidCell &&
superTileMap.GetCellv(adjAboveTile) == TileMap.InvalidCell);
}
public void SetEdge(int Index, TileEdge Edge)
{
Configuration.SetEdge(Index, Edge);
if (NeighborTiles[Index] != null && NeighborTiles[Index].Configuration.GetEdge((Index + 3) % 6) != Edge)
{
NeighborTiles[Index].SetEdge((Index + 3) % 6, Edge);
}
}
public GameObject GetEdge(TileEdge edge)
{
if (edge == TileEdge.Count) {
throw new ArgumentException("Invalid Tile Edge", "edge");
}
return _edges[(int)edge];
}
public RobotPosition Rotate(TileEdge heading)
{
if (heading.tile != tile)
{
Debug.LogError(string.Format("Trying to rotate while on other tile {0}:{1} but on {2}", heading, heading.tile, tile));
return(this);
}
return(new RobotPosition(tile, heading));
}
/// <summary>
/// Given some input edge, grabs the tile it originated from and attempts to calculate coordinates
/// for some adjacent tile on the observed layer (which should be lower than the current layer).
/// </summary>
/// <param name="edge">Edge that is checked for what tile it originated from.</param>
/// <param name="currentLayer">Layer of edge.</param>
/// <param name="observedLayer">Layer of the tile that this func calcs coords for.</param>
/// <returns>Coordinates of some adjacent tile on the observed layer, even if it does not exist.</returns>
private static Vector2 _GetAdjLowerCoords(TileEdge edge, int currentLayer, int observedLayer)
{
Vector2 currentTile = edge.tileCoords;
int side = edge.tileSide;
Vector2 belowTile = TileFuncs.GetTileAboveOrBelow(currentTile, currentLayer, observedLayer);
Vector2 adjBelowTile = TileFuncs.GetTileAdjacent(belowTile, side);
return(adjBelowTile);
}
protected override void Initialize()
{
// refactor
viewState = GameObject.Find("GameController").GetComponent <ViewStateController>();
tileCollider = GetComponent <BoxCollider>();
boundsCenter = tileCollider.bounds.center;
boundsMin = tileCollider.bounds.min;
boundsMax = tileCollider.bounds.max;
enterEdge = exitEdge = TileEdge.None;
}
Color EdgeColor(TileEdge Edge, bool Higher, int Elevation)
{
Color c = _EdgeColors[(int)Edge];
if (c.A > 0)
{
return(c);
}
return(Higher ? _ElevationColors[Math.Min(_ElevationColors.Length - 1, Math.Max(0, Elevation))] : c);
}
public override bool Equals(object obj)
{
TileEdge otherTE = obj as TileEdge;
if (otherTE == null)
{
return(false);
}
return(this.tile.Equals(otherTE.tile));
}
/// <summary>
/// Sets this cell's neighbor in the given direction to the given tile.
/// Also reciprocates and sets the opposite neighbor of the given tile
/// to this tile.
/// </summary>
/// <param name="direction">The direction `tile` is in.</param>
/// <param name="tile">The new neighbor! Howdy!</param>
public void SetNeighbor(TileEdge direction, Tile tile)
{
neighbors[( int )direction] = tile;
// avoid NRE
if (tile == null)
{
return;
}
tile.neighbors[( int )direction.Opposite()] = this; // update it for that tile as well
}
public TileEdge Forward(TileEdge entry)
{
for (int i = 0; i < entries.Length; i++)
{
if (entries[i] == entry)
{
return(exits[i]);
}
}
Debug.LogError(string.Format("Looking for Forward from {0}:{1} on {2}", entry.name, entry.tile.name, name));
throw new MissingComponentException();
}
public TileEdge Right(TileEdge heading, int steps = 1)
{
for (int i = 0; i < exits.Length; i++)
{
if (exits[i] == heading)
{
return(exits[i + steps >= exits.Length ? i + steps - exits.Length : i + steps]);
}
}
Debug.LogError(string.Format("Looking for Right from {0}:{1} on {2}", heading.name, heading.tile.name, name));
throw new MissingComponentException();
}
/// <summary>
/// Checks if the input collection contains the edge. Required because the Edge class is more than just Points A and B (it also
/// includes the tile it originated from and tile side) but we only care about those two properties.
/// </summary>
/// <param name="collection">Collection being checked for whether it contains Edge (but just the points).</param>
/// <param name="edge">Edge being checked.</param>
/// <returns>Index of identical edge in collection with matching points to the input edge, or -1 if no match found.</returns>
private static int _ContainsEdge(IReadOnlyList <TileEdge> collection, TileEdge edge)
{
for (int i = 0; i < collection.Count; i++)
{
TileEdge examinee = collection[i];
if (examinee.IsIdentical(edge))
{
return(i);
}
}
return(-1);
}
public TileEffect Bump(TileEdge fromDirection, bool flameBurning)
{
if (flameBurning)
{
var tileFire = GetComponentInChildren <TileFire>();
if (tileFire)
{
tileFire.StartFire();
tileEffect = TileEffect.Burning;
}
}
return(TileEffect);
}
/// <summary>
/// Given some input EdgeCollection, iterates through its edges and adds 'valid' ones to a new
/// collection, which is then returned.
/// Validity is determined through the _IsLedgeValid function.
/// </summary>
/// <param name="ledgeColl"></param>
/// <param name="preTileMap"></param>
/// <param name="superTileMap"></param>
/// <returns></returns>
private static EdgeCollection <TileEdge> _BuildHoleGroupValidLedges(EdgeCollection <TileEdge> ledgeColl, TileMap preTileMap, TileMap superTileMap)
{
var validLedges = new EdgeCollection <TileEdge>();
foreach (TileEdge ledge in ledgeColl)
{
if (_IsLedgeValid(ledge, preTileMap, superTileMap))
{
TileEdge superimposedLedge = ledge.GetShiftedByN(SHIFT_DIST);
if (!validLedges.HasEdgePoints(superimposedLedge))
{
validLedges.Add(superimposedLedge);
}
}
}
return(validLedges);
}
public void addNeighbor(Tile start, Tile end, float edgeCost)
{
if (!outgoingEdges.ContainsKey(start))
{
outgoingEdges.Add(start, new HashSet <TileEdge>());
}
// Add a new edge from start pointing towards end
TileEdge newOutEdge = new TileEdge(end, Mathf.RoundToInt(edgeCost));
outgoingEdges[start].Add(newOutEdge);
if (!incomingTiles.ContainsKey(end))
{
incomingTiles.Add(end, new HashSet <Tile>());
}
// End now has an incoming edge from start
incomingTiles[end].Add(start);
}
/// <summary>
/// From some input edge, grab the tile it originated from and check if there is an adjacent tile
/// in the direction TO the edge on any lower TileMap.
/// Basically we are checking if it is possible to move from the original tile in the direction
/// of the edge and fall to a lower tile.
/// Should no adjacent tile exist, returns the current tile.
/// </summary>
/// <param name="tileMaps">List of all tilemaps.</param>
/// <param name="edge">Edge that is being examined.</param>
/// <param name="currentLayer">Current layer that edge is on.</param>
/// <returns>Coords of the highest adjacent tile, or current tile if no adjacent tile exists.</returns>
private static Vector2 _GetAdjacentLowerTile(TileMapList tileMaps, TileEdge edge, int currentLayer)
{
Vector2 currentTile = edge.tileCoords;
Vector2 adjTile = currentTile;
for (int i = currentLayer; i >= 0; i--)
{
Vector2 adjCoords = _GetAdjLowerCoords(edge, currentLayer, i);
TileMap lowerTileMap = tileMaps[i];
if (adjCoords != currentTile && lowerTileMap.GetCellv(adjCoords) != TileMap.InvalidCell)
{
adjTile = adjCoords;
break; //no need to continue searching we have the highest adj tile
}
}
return(adjTile);
}
public static bool IsPassable(TileEdge edge)
{
if (edge == null)
{
return(true);
}
if (edge.isBroken)
{
return(true);
}
if (edge is Door && (edge as Door).isOpened)
{
return(true);
}
return(false);
}
/// <summary>
/// Tessellates a single part of the hexagonal outline with the given position, color, and thickness.
/// </summary>
/// <param name="center"></param>
/// <param name="outerRadius"></param>
/// <param name="thickness"></param>
/// <param name="direction"></param>
/// <param name="color"></param>
public void Tessellate2D(Vector3 center, float outerRadius, float thickness, TileEdge direction, Color color)
{
float innerRadius = outerRadius - thickness;
int i = ( int )direction;
AddTriangle(
center + (UNIT_HEXAGON[i] * innerRadius),
center + (UNIT_HEXAGON[i] * outerRadius),
center + (UNIT_HEXAGON[i + 1] * innerRadius)
);
AddTriangleColor(color);
AddTriangle(
center + (UNIT_HEXAGON[i] * outerRadius),
center + (UNIT_HEXAGON[i + 1] * outerRadius),
center + (UNIT_HEXAGON[i + 1] * innerRadius)
);
AddTriangleColor(color);
}
/// <summary>
/// This pass will create mountain ranges.
/// </summary>
/// <param name="tiles">The tiles.</param>
private static void CreateMountains(Tile[] tiles, int landmass)
{
int mountainRanges = random.Next(1, 5) * random.Next(1, (landmass / 50) + 2);
int range = ( int )(2 * Mathf.Sqrt(landmass / mountainRanges));
for (int i = 0; i < mountainRanges; i++)
{
// find a random land tile by guessing
Tile start;
do
{
start = tiles[random.Next(0, tiles.Length)]; // choose a random tile
}while (!start.type.isLand);
// choose a random direction
TileEdge direction = ( TileEdge )random.Next(0, 5);
int size = CreateMountainRangeAt(start, range, direction);
}
}
void GenerateVoidScent()
{
Queue <Tile> queue = new Queue <Tile> ();
HashSet <Tile> visitedTiles = new HashSet <Tile> ();
foreach (Tile tile in tiles)
{
if (tile.isVoidGenerator)
{
queue.Enqueue(tile);
}
tile.voidScent = false;
}
while (queue.Count > 0)
{
Tile tile = queue.Dequeue();
tile.voidScent = true;
visitedTiles.Add(tile);
if (tile.upNeighbour && !visitedTiles.Contains(tile.upNeighbour) && TileEdge.IsPassable(tile.up) && TileEdge.IsPassable(tile.upNeighbour.down))
{
tile.upNeighbour.voidScent = true;
queue.Enqueue(tile.upNeighbour);
}
if (tile.downNeighbour && !visitedTiles.Contains(tile.downNeighbour) && TileEdge.IsPassable(tile.down) && TileEdge.IsPassable(tile.downNeighbour.up))
{
tile.downNeighbour.voidScent = true;
queue.Enqueue(tile.downNeighbour);
}
if (tile.leftNeighbour && !visitedTiles.Contains(tile.leftNeighbour) && TileEdge.IsPassable(tile.left) && TileEdge.IsPassable(tile.leftNeighbour.right))
{
tile.leftNeighbour.voidScent = true;
queue.Enqueue(tile.leftNeighbour);
}
if (tile.rightNeighbour && !visitedTiles.Contains(tile.rightNeighbour) && TileEdge.IsPassable(tile.right) && TileEdge.IsPassable(tile.rightNeighbour.left))
{
tile.rightNeighbour.voidScent = true;
queue.Enqueue(tile.rightNeighbour);
}
}
}
void Propagate()
{
int firesStarted = 0;
int contagiousness = Config.me.FireContagiousness;
if (tile.system != null)
{
tile.system.GetComponent <TileSystem>().isBroken = true;
}
if (firesStarted < contagiousness && tile.downNeighbour != null && (TileEdge.IsPassable(tile.down)) && TileEdge.IsPassable(tile.downNeighbour.up))
{
if (tile.downNeighbour.StartFire())
{
firesStarted++;
}
}
if (firesStarted < contagiousness && tile.upNeighbour != null && TileEdge.IsPassable(tile.up) && TileEdge.IsPassable(tile.upNeighbour.down))
{
if (tile.upNeighbour.StartFire())
{
firesStarted++;
}
}
if (firesStarted < contagiousness && tile.leftNeighbour != null && TileEdge.IsPassable(tile.left) && TileEdge.IsPassable(tile.leftNeighbour.right))
{
if (tile.leftNeighbour.StartFire())
{
firesStarted++;
}
}
if (firesStarted < contagiousness && tile.rightNeighbour != null && TileEdge.IsPassable(tile.right) && TileEdge.IsPassable(tile.rightNeighbour.left))
{
if (tile.rightNeighbour.StartFire())
{
firesStarted++;
}
}
level = 0;
}
public List <TileEdge> GetTileNeighborEdges()
{
List <TileEdge> tileEdges = new List <TileEdge>();
for (int tileEdge = 0; tileEdge < (int)ETileEdge.COUNT; ++tileEdge)
{
ETileEdge eTileEdge = (ETileEdge)tileEdge;
ETileEdge eOppositeEdge = eTileEdge.Opposite();
Tile neighbor = GetNeighbor(eTileEdge);
if (neighbor != null)
{
TileEdge neighborEdge = neighbor.GetTileEdge(eOppositeEdge);
if (neighborEdge != null)
{
tileEdges.Add(neighborEdge);
}
}
}
return(tileEdges);
}
/// <summary>
/// Creates a mountain range starting at the given type and spreading out the
/// given range.
/// </summary>
/// <param name="tile"></param>
/// <param name="range"></param>
/// <returns></returns>
private static int CreateMountainRangeAt(Tile tile, int range, TileEdge direction)
{
// if the tile doesn't exist, isn't land, or already is a mountain, end the chain
if (tile == null || !tile.type.isLand || tile.type == TileType.MOUNTAIN)
{
return(0);
}
// set the type to mountains
tile.type = TileType.MOUNTAIN;
int sum = 1;
if (range >= random.Next(0, 5))
{
// expand in the given direction
CreateMountainRangeAt(tile.GetNeighbor(direction), range - random.Next(0, 5), direction);
// expand backwards too
CreateMountainRangeAt(tile.GetNeighbor(direction.Opposite()), range - random.Next(0, 5), direction);
// create mountains in the given directions
for (int i = 0; i < 6; i++)
{
// expand mostly in the given direction and the opposite direction
if (i == ( int )direction || i == ( int )direction.Opposite())
{
CreateMountainRangeAt(tile.GetNeighbor(( TileEdge )i), range - random.Next(0, 5), direction);
}
// 70% chance that it will branch off in another direction, but will suffer massive hits to the range
else if (random.Next(1, 10) <= 7)
{
CreateMountainRangeAt(tile.GetNeighbor(( TileEdge )i), range - random.Next(5, 15), direction);
}
}
}
return(sum);
}
Boolean checkIfCanMove(InGamePosition pos, bool up, bool down, bool left, bool right)
{
Ship ship = GameObject.FindGameObjectWithTag("ship").GetComponent <Ship>();
Tile tile = ship.GetTileOnPosition(pos);
if (left &&
TileEdge.IsPassable(tile.down) &&
tile.downNeighbour != null &&
TileEdge.IsPassable(tile.downNeighbour.up))
{
return(true);
}
if (right &&
TileEdge.IsPassable(tile.up) &&
tile.upNeighbour != null &&
TileEdge.IsPassable(tile.upNeighbour.down))
{
return(true);
}
if (down &&
TileEdge.IsPassable(tile.left) &&
tile.leftNeighbour != null &&
TileEdge.IsPassable(tile.leftNeighbour.right))
{
return(true);
}
if (up &&
TileEdge.IsPassable(tile.right) &&
tile.rightNeighbour != null &&
TileEdge.IsPassable(tile.rightNeighbour.left))
{
return(true);
}
return(false);
}
public TileEdge Backward(TileEdge heading)
{
return(Forward(heading));
}
public EdgeRotation(TileEdge edge, Quaternion rotation)
{
Edge = edge;
Rotation = rotation;
}
public void SetEdge(TileEdge edge, GameObject prefab)
{
if (edge == TileEdge.Count) {
throw new ArgumentException("Invalid Tile Edge", "edge");
}
_edges[(int)edge] = prefab;
}
