public override void OnInit(Component.InitContext context)
{
base.OnInit(context);
if (context == InitContext.Activate && DualityApp.ExecContext == DualityApp.ExecutionContext.Game)
{
Tilemap visibilityMap = this.visibilityRenderer.ActiveTilemap;
Grid <Tile> tiles = visibilityMap.BeginUpdateTiles();
tiles.Fill(new Tile(this.unseenTile), 0, 0, visibilityMap.Size.X, visibilityMap.Size.Y);
visibilityMap.EndUpdateTiles();
}
}
public void SetupTilemap(MapGenerator.GenerationPrefs prefs)
{
TurnActionManager.PlayerMoved += UpdateTilemap;
tilemap = GameObj.GetComponent <Tilemap> ();
tilemap.Resize(prefs.Width, prefs.Height);
var tileGrid = tilemap.BeginUpdateTiles();
tileGrid.Fill(new Tile(NotVisibleTileIndex), 0, 0, tileGrid.Width, tileGrid.Height);
tilemap.EndUpdateTiles();
UpdateTilemap();
}
/// <summary>
/// Prepares the specified <see cref="Tilemap"/> for user editing using the specified size.
/// </summary>
/// <param name="tilemap"></param>
/// <param name="tilesetRef"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="isUpperLayer"></param>
public static void SetupTilemap(Tilemap tilemap, ContentRef <Tileset> tilesetRef, int width, int height, bool isUpperLayer)
{
Tileset tileset = tilesetRef.Res;
// Determine the first tile index that matches the layer type.
int fillTileIndex = GetDefaultTileIndex(tileset, isUpperLayer);
// Resize the Tilemap and fill it with the first visually non-empty tile.
tilemap.Tileset = tileset;
tilemap.Resize(width, height);
tilemap.BeginUpdateTiles().Fill(
new Tile(fillTileIndex),
0,
0,
tilemap.Size.X,
tilemap.Size.Y);
tilemap.EndUpdateTiles();
}
/// <summary>
/// Runs the flood fill algorithm on the specified position and writes the result into the specified variables.
/// </summary>
/// <param name="tilemap"></param>
/// <param name="pos"></param>
/// <param name="preview">If true, the algorithm will cancel when taking too long for an interactive preview.</param>
/// <param name="floodFillArea"></param>
/// <param name="floodFillOrigin"></param>
/// <returns>True, if the algorithm completed. False, if it was canceled.</returns>
private bool GetFloodFillArea(Tilemap tilemap, Point2 pos, bool preview, Grid <bool> floodFillArea, ref Point2 floodFillOrigin)
{
Grid <Tile> tiles = tilemap.BeginUpdateTiles();
Point2 fillTopLeft;
Point2 fillSize;
bool success = FloodFillTiles(ref this.activeFillBuffer, tiles, pos, preview ? (128 * 128) : 0, out fillTopLeft, out fillSize);
tilemap.EndUpdateTiles(0, 0, 0, 0);
// Find the filled areas boundaries and copy it to the active area
if (success)
{
floodFillOrigin = fillTopLeft;
floodFillArea.ResizeClear(fillSize.X, fillSize.Y);
this.activeFillBuffer.CopyTo(floodFillArea, 0, 0, -1, -1, floodFillOrigin.X, floodFillOrigin.Y);
}
return(success);
}
public void UpdateTilemap()
{
var tileGrid = tilemap.BeginUpdateTiles();
var generatedMap = SceneCache.Get <MapGenerator> ().GeneratedMap;
var playerPos = SceneCache.Player.GetComponent <DiscreteTransform> ().Position;
var halfRectSide = MapExtensions.MaxVisibilityDst;
var xMin = Math.Max(0, playerPos.X - halfRectSide);
var yMin = Math.Max(0, playerPos.Y - halfRectSide);
var xMax = Math.Min(playerPos.X + halfRectSide, generatedMap.Width - 1);
var yMax = Math.Min(playerPos.Y + halfRectSide, generatedMap.Height - 1);
for (var y = yMin; y <= yMax; y++)
{
for (var x = xMin; x <= xMax; x++)
{
if (generatedMap.IsVisible(playerPos, new Point2(x, y)))
{
var tileIndex = 0;
if (generatedMap[x, y] == TileType.Empty)
{
tileIndex = EmptyTileIndex;
}
else
{
if (x % 2 == 0)
{
tileIndex++;
}
if (y % 2 == 0)
{
tileIndex += 2;
}
}
tileGrid[x, y] = new Tile(tileIndex);
}
}
}
tilemap.EndUpdateTiles();
}
public void UpdateVisibility()
{
Transform visibilityTransform = (this.visibilityRenderer as Component).GameObj.Transform;
Tilemap visibilityMap = this.visibilityRenderer.ActiveTilemap;
Tilemap terrainMap = LevelMap.Current.BaseMap;
Tileset terrainTileset = terrainMap.Tileset.Res;
Vector2 tileSize = new Vector2(
this.visibilityRenderer.LocalTilemapRect.W / (float)visibilityMap.Size.X,
this.visibilityRenderer.LocalTilemapRect.H / (float)visibilityMap.Size.Y);
Grid <Tile> tiles = visibilityMap.BeginUpdateTiles();
Tile[] tileData = tiles.RawData;
int width = tiles.Width;
int height = tiles.Height;
// Fill as unseen
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
int i = x + width * y;
tileData[i].BaseIndex =
(tileData[i].BaseIndex == this.seenTile) ?
this.lastSeenTile :
this.unseenTile;
}
}
Point2 startTile = LevelMap.Current.GetTilePosition(this.playerPos);
// Note:
// Determining visibility with physical raycasts is quite inefficient.
// Doing so with so many raycasts is super super inefficient.
// Don't do this.
int raycastCount = 60;
for (int i = 0; i < raycastCount; i++)
{
float angle = MathF.TwoPi * (float)i / (float)raycastCount;
Vector2 offset = Vector2.FromAngleLength(angle, SightRadius * (tileSize.X + 1));
RayCastData hitData;
bool hit = RigidBody.RayCast(
this.playerPos,
this.playerPos + offset,
d => (d.Body.Active && d.Body.CollisionCategory.HasFlag(CollisionCategory.Cat2)) ? d.Fraction : -1.0f,
out hitData);
float hitFraction = hit ? hitData.Fraction : 1.0f;
Vector2 hitPos = this.playerPos + offset * hitFraction - offset.Normalized * 2;
Point2 endTile = LevelMap.Current.GetTilePosition(hitPos);
DrawTileLine(tileData, width, startTile.X, startTile.Y, endTile.X, endTile.Y, this.seenTile);
//Vector2 startTilePos = LevelMap.Current.GetObjectPosition(startTile);
//Vector2 endTilePos = LevelMap.Current.GetObjectPosition(endTile);
//VisualLog.Default.DrawConnection(
// this.playerPos.X,
// this.playerPos.Y,
// 0.0f,
// hitPos.X,
// hitPos.Y)
// .WithOffset(-100)
// .KeepAlive(1000);
//VisualLog.Default.DrawConnection(
// startTilePos.X,
// startTilePos.Y,
// 0.0f,
// endTilePos.X,
// endTilePos.Y)
// .WithColor(ColorRgba.Red)
// .WithOffset(-101)
// .KeepAlive(1000);
}
// Expand visibility by one in all directions
Grid <Tile> terrainTiles = terrainMap.BeginUpdateTiles();
ExpandVisible(this.visibilityBuffer, tiles, this.seenTile, terrainTiles, terrainTileset.TileData.Data);
terrainMap.EndUpdateTiles(0, 0, 0, 0);
// Update everything on the fire map
visibilityMap.EndUpdateTiles();
}
