private void UpdateNeighboursForRemovedObstacle(ObstacleType obstacleType)
{
foreach (KeyValuePair <ObjectDirection, Tile> neighbour in _tile.Neighbours)
{
if (!neighbour.Value)
{
continue;
}
TileObstacle tileObstacleOnNeighbour = neighbour.Value.TryGetTileObstacle();
if (tileObstacleOnNeighbour == null)
{
continue;
}
Logger.Log($"We will look for connections for neighbour {neighbour.Value.GridLocation.X},{neighbour.Value.GridLocation.Y}, which is {neighbour.Key} of {_tile.GridLocation.X},{_tile.GridLocation.Y}");
TileConnectionScoreInfo obstacleConnectionScoreOnNeighbour = NeighbourTileCalculator.MapNeighbourObstaclesOfTile(neighbour.Value, obstacleType);
Logger.Log($"We calculated an obstacle connection type score of {obstacleConnectionScoreOnNeighbour} for location {neighbour.Value.GridLocation.X}, {neighbour.Value.GridLocation.Y}");
//update connection score on neighbour
tileObstacleOnNeighbour.WithConnectionScoreInfo(obstacleConnectionScoreOnNeighbour);
// If needed, place a background
if (obstacleConnectionScoreOnNeighbour.RawConnectionScore != NeighbourTileCalculator.ConnectionOnAllSidesScore)
{
EditorOverworldTileBackgroundPlacer tileBackgroundPlacer = new EditorOverworldTileBackgroundPlacer(neighbour.Value as EditorOverworldTile);
tileBackgroundPlacer.PlaceBackground <OverworldTileBaseGround>();
}
}
}
public override void RemoveTileObstacle(TileObstacle tileObstacle = null)
{
_tile.SetWalkable(true);
if (!tileObstacle)
{
tileObstacle = (TileObstacle)_tile.GetAttributes().FirstOrDefault(attribute => attribute is TileObstacle);
}
if (tileObstacle == null)
{
return;
}
if (tileObstacle is PlayerExit)
{
return;
}
ObstacleType obstacleType = tileObstacle.ObstacleType;
int oldConnectionScore = tileObstacle.ConnectionScore;
if (oldConnectionScore == NeighbourTileCalculator.ConnectionOnAllSidesScore)
{
EditorOverworldTileBackgroundPlacer tileBackgroundPlacer = new EditorOverworldTileBackgroundPlacer(_tile);
tileBackgroundPlacer.PlaceBackground <OverworldTileBaseGround>();
}
_tile.RemoveAttribute(tileObstacle);
tileObstacle.Remove();
//After removing tile, check with neighbour tiles if wall connections should be updated
UpdateNeighboursForRemovedObstacle(obstacleType);
}
public override void RemoveTileObstacle(TileObstacle tileObstacle = null)
{
if (!tileObstacle)
{
tileObstacle = (TileObstacle)_tile.GetAttributes().FirstOrDefault(attribute => attribute is TileObstacle);
}
if (tileObstacle == null)
{
return;
}
if (tileObstacle is PlayerExit)
{
return;
}
_tile.SetWalkable(true);
ObstacleType obstacleType = tileObstacle.ObstacleType;
int oldConnectionScore = tileObstacle.ConnectionScore;
// If needed, place a background in the gap that the removed path left.
// OPTIMISATION: Currently only looking at connection score from obstacles, but should also take eg. door attributes into account.
if (oldConnectionScore == NeighbourTileCalculator.ConnectionOnAllSidesScore)
{
EditorMazeTileBackgroundPlacer tileBackgroundPlacer = new EditorMazeTileBackgroundPlacer(_tile);
tileBackgroundPlacer.PlaceBackground <MazeTileBaseGround>();
}
_tile.RemoveAttribute(tileObstacle);
tileObstacle.Remove();
//After removing tile, check with neighbour tiles if wall connections should be updated
UpdateNeighboursForRemovedObstacle(obstacleType);
}
private TileObstacle VerticalCombine(TileObstacle with, float cellHeight)
{
TileObstacle obstacle;
obstacle.combineKind = CombineKind.Vertical;
obstacle.obstacle = with.obstacle;
obstacle.obstacle.center += new Vector3(0, 0, cellHeight / 2f);
obstacle.obstacle.size += new Vector3(0, 0, cellHeight);
return(obstacle);
}
private TileObstacle HorizontalCombine(TileObstacle with, float cellWidth)
{
TileObstacle obstacle;
obstacle.combineKind = CombineKind.Horizontal;
obstacle.obstacle = with.obstacle;
obstacle.obstacle.center += new Vector3(cellWidth / 2f, 0, 0);
obstacle.obstacle.size += new Vector3(cellWidth, 0, 0);
return(obstacle);
}
// Loading a tile obstacle for a tile, not creating a new one. We already have the connection score
public void PlaceTileObstacle(ObstacleType obstacleType, TileConnectionScoreInfo obstacleConnectionScore)
{
TileObstacle tileObstacle = (TileObstacle)InstantiateTileAttributeGO <TileObstacle>();
tileObstacle.WithObstacleType(obstacleType);
tileObstacle.WithConnectionScoreInfo(obstacleConnectionScore);
Tile.SetWalkable(false);
Tile.TryMakeMarkable(false);
Tile.AddAttribute(tileObstacle);
}
public void PlaceTileObstacleVariation(TileObstacle tileObstacle)
{
//return only connections that were updated
List <TileObstacle> updatedObstacleConnections = NeighbourTileCalculator.GetUpdatedTileModifiersForVariation(Tile, tileObstacle, tileObstacle.ObstacleType.ToString());
//update the sprites with the new variations
for (int i = 0; i < updatedObstacleConnections.Count; i++)
{
updatedObstacleConnections[i].WithConnectionScoreInfo(new TileConnectionScoreInfo(updatedObstacleConnections[i].ConnectionScore, updatedObstacleConnections[i].SpriteNumber));
}
}
public static TileConnectionScoreInfo MapNeighbourObstaclesOfTile(Tile tile, ObstacleType obstacleType)
{
Logger.Log($"Map neighbours of {tile.GridLocation.X},{tile.GridLocation.Y}");
TileModifierConnectionInfo <TileObstacle> obstacleRight = new TileModifierConnectionInfo <TileObstacle>(Direction.Right);
TileModifierConnectionInfo <TileObstacle> obstacleDown = new TileModifierConnectionInfo <TileObstacle>(Direction.Down);
TileModifierConnectionInfo <TileObstacle> obstacleLeft = new TileModifierConnectionInfo <TileObstacle>(Direction.Left);
TileModifierConnectionInfo <TileObstacle> obstacleUp = new TileModifierConnectionInfo <TileObstacle>(Direction.Up);
if (!EditorManager.InEditor)
{
Logger.Error("MapNeighbourObstaclesOfTile was not called from the editor");
return(null);
}
foreach (KeyValuePair <ObjectDirection, Tile> neighbour in tile.Neighbours)
{
if (!neighbour.Value)
{
continue;
}
Logger.Warning($"Neighbour at {neighbour.Value.GridLocation.X},{neighbour.Value.GridLocation.Y} is {neighbour.Key} of {tile.GridLocation.X},{tile.GridLocation.Y}");
TileObstacle tileObstacle = neighbour.Value.TryGetTileObstacle();
if (tileObstacle == null || tileObstacle.ObstacleType != obstacleType)
{
continue;
}
if (neighbour.Key == ObjectDirection.Right)
{
obstacleRight.HasConnection = true;
obstacleRight.TileModifier = tileObstacle;
}
else if (neighbour.Key == ObjectDirection.Down)
{
obstacleDown.HasConnection = true;
obstacleDown.TileModifier = tileObstacle;
}
else if (neighbour.Key == ObjectDirection.Left)
{
obstacleLeft.HasConnection = true;
obstacleLeft.TileModifier = tileObstacle;
}
else if (neighbour.Key == ObjectDirection.Up)
{
obstacleUp.HasConnection = true;
obstacleUp.TileModifier = tileObstacle;
}
}
return(TileConnectionRegister.CalculateTileConnectionScore(obstacleRight, obstacleDown, obstacleLeft, obstacleUp));
}
public void ShowObstacle(TileObstacle t)
{
if (_currentStats != t.gameObject)
{
RemoveStats();
_currentStats = t.gameObject;
Transform canvas = GameObject.Find("Canvas").transform;
var n = t.name.Split("("[0]);
string statsString =
n[0];
InstantiatePanel(statsString, canvas);
}
}
public override TileObstacle TryGetTileObstacle()
{
for (int i = 0; i < _tileAttributes.Count; i++)
{
Logger.Log($"found attribute for {GridLocation.X}, {GridLocation.Y} is {_tileAttributes[i].GetType()}");
}
TileObstacle tileObstacle = (TileObstacle)_tileAttributes.FirstOrDefault(attribute => attribute is TileObstacle);
if (tileObstacle == null)
{
Logger.Log($"did not find a tile obstacle on {GridLocation.X},{GridLocation.Y}");
return(null);
}
Logger.Log($"found tileObstacle {tileObstacle.ObstacleType} on {GridLocation.X},{GridLocation.Y}");
return(tileObstacle);
}
void Start()
{
Tilemap tilemap = GetComponent <Tilemap>();
Vector3 cellSize = tilemap.cellSize;
cellSize.Scale(transform.lossyScale);
Quaternion rotation = Quaternion.AngleAxis(-90, transform.right) * transform.rotation;
BoundsInt bounds = tilemap.cellBounds;
TileBase[] allTiles = tilemap.GetTilesBlock(bounds);
TileObstacle[] tileObstacles = new TileObstacle[(bounds.size.x + 1) * (bounds.size.y + 1)];
int width = bounds.size.x, height = bounds.size.y;
for (int x = 0; x < width; x++)
{
int ox = x + 1;
for (int y = 0; y < height; y++)
{
int oy = y + 1;
Tile tile = (allTiles[x + y * width] as Tile);
if (tile == null || tile.colliderType == Tile.ColliderType.None)
{
continue;
}
int oi = ox + oy * width;
TileObstacle combineCandidate = tileObstacles[oi - 1]; // on the left of current tile
CombineKind kind = combineCandidate.combineKind;
if (kind == CombineKind.Single || kind == CombineKind.Horizontal)
{
tileObstacles[oi - 1].combineKind = CombineKind.Horizontal;
tileObstacles[oi] = HorizontalCombine(combineCandidate, cellSize.x);
continue;
}
combineCandidate = tileObstacles[oi - width]; // on the top of current tile
kind = combineCandidate.combineKind;
if (kind == CombineKind.Single || kind == CombineKind.Vertical)
{
tileObstacles[oi - width].combineKind = CombineKind.Vertical;
tileObstacles[oi] = VerticalCombine(combineCandidate, cellSize.y);
continue;
}
var obstacleObject = new GameObject(this.name + " Nav Obstacle");
obstacleObject.isStatic = this.gameObject.isStatic;
obstacleObject.transform.parent = NavigationMain.current.transform;
Vector3 position = tilemap.CellToWorld(new Vector3Int(bounds.x + x, bounds.y + y, 0));
obstacleObject.transform.SetPositionAndRotation(new Vector3(position.x + cellSize.x / 2f, position.y + cellSize.y / 2f, 0), rotation);
var nmObstacle = obstacleObject.AddComponent <NavMeshObstacle>();
nmObstacle.carving = true;
nmObstacle.size = new Vector3(cellSize.x, obstacleHeight, cellSize.y);
tileObstacles[oi].obstacle = nmObstacle;
tileObstacles[oi].combineKind = CombineKind.Single;
}
}
Destroy(this);
}
public abstract void RemoveTileObstacle(TileObstacle tileObstacle = null);
private ISerialisableTileAttribute CreateSerialisableTileAttribute(Tile tile, ITileAttribute tileAttribute)
{
if (tileAttribute.GetType() == typeof(TileObstacle))
{
TileObstacle tileObstacle = tileAttribute as TileObstacle;
SerialisableTileObstacleAttribute serialisableTileObstacleAttribute =
new SerialisableTileObstacleAttribute(
new TileConnectionScoreInfo(tileObstacle.ConnectionScore, tileObstacle.SpriteNumber));
return(serialisableTileObstacleAttribute);
}
else if (tileAttribute.GetType() == typeof(PlayerExit))
{
PlayerExit playerExit = tileAttribute as PlayerExit;
SerialisablePlayerExitAttribute serialisablePlayerExitAttribute = new SerialisablePlayerExitAttribute(
new TileConnectionScoreInfo(playerExit.ConnectionScore, playerExit.SpriteNumber));
return(serialisablePlayerExitAttribute);
}
else if (tileAttribute.GetType() == typeof(PlayerOnly))
{
SerialisablePlayerOnlyAttribute serialisablePlayerOnlyAttribute = new SerialisablePlayerOnlyAttribute();
return(serialisablePlayerOnlyAttribute);
}
else if (tileAttribute.GetType() == typeof(PlayerSpawnpoint))
{
SerialisablePlayerSpawnpointAttribute serialisablePlayerSpawnpointAttribute = new SerialisablePlayerSpawnpointAttribute();
return(serialisablePlayerSpawnpointAttribute);
}
else if (tileAttribute.GetType() == typeof(EnemySpawnpoint))
{
EnemySpawnpoint enemySpawnpoint = tileAttribute as EnemySpawnpoint;
SerialisableEnemySpawnpointAttribute serialisableEnemySpawnpointAttribute = new SerialisableEnemySpawnpointAttribute(enemySpawnpoint.TileAreas);
return(serialisableEnemySpawnpointAttribute);
}
else if (tileAttribute.GetType() == typeof(MazeLevelEntry))
{
MazeLevelEntry mazeLevelEntry = tileAttribute as MazeLevelEntry;
SerialisableMazeLevelEntryAttribute serialisableMazeLevelEntryAttribute = new SerialisableMazeLevelEntryAttribute(mazeLevelEntry.MazeLevelName);
return(serialisableMazeLevelEntryAttribute);
}
else if (tileAttribute.GetType() == typeof(BridgePiece))
{
BridgePiece bridgePiece = tileAttribute as BridgePiece;
BridgePieceDirection bridgePieceDirection = bridgePiece.BridgePieceDirection;
SerialisableBridgePieceAttribute serialisableBridgePieceAttribute = new SerialisableBridgePieceAttribute(bridgePieceDirection);
return(serialisableBridgePieceAttribute);
}
else if (tileAttribute.GetType() == typeof(BridgeEdge))
{
BridgeEdge bridgeEdge = tileAttribute as BridgeEdge;
SerialisableBridgeEdgeAttribute serialisableBridgeEdgeAttribute = new SerialisableBridgeEdgeAttribute(bridgeEdge.EdgeSide);
return(serialisableBridgeEdgeAttribute);
}
else if (tileAttribute.GetType() == typeof(MusicInstrumentCase))
{
SerialisableMusicInstrumentCaseAttribute serialisableMusicInstrumentCaseAttribute = new SerialisableMusicInstrumentCaseAttribute();
return(serialisableMusicInstrumentCaseAttribute);
}
else
{
Logger.Error($"Could not serialise the tile attribute {tileAttribute.GetType()}");
return(null);
}
}
