// Return a copy of this tile grid.
public TileGrid Duplicate()
{
TileGrid duplicate = new TileGrid(size, layerCount);
// Duplicate tiles.
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
for (int i = 0; i < layerCount; i++)
{
TileGridTile tile = tiles[x, y, i];
if (tile.Tile != null && tile.Location == new Point2I(x, y))
{
TileDataInstance tileCopy = new TileDataInstance();
tileCopy.Clone(tile.Tile);
duplicate.PlaceTile(tileCopy, x, y, i);
}
}
}
}
// Duplicate event tiles.
foreach (EventTileDataInstance eventTile in eventTiles)
{
EventTileDataInstance copy = new EventTileDataInstance();
copy.Clone(eventTile);
duplicate.AddEventTile(copy);
}
return(duplicate);
}
public void PlaceTile(TileDataInstance tile, Point2I location, int layer)
{
Point2I size = tile.Size;
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
Point2I loc = new Point2I(location.X + x, location.Y + y);
if (loc.X < Width && loc.Y < Height)
{
// Remove existing tile.
TileDataInstance t = tileData[loc.X, loc.Y, layer];
if (t != null)
{
RemoveTile(t);
}
tileData[loc.X, loc.Y, layer] = tile;
}
}
}
if (tile != null)
{
tile.Location = location;
tile.Layer = layer;
tile.Room = this;
}
}
private void WriteTileData(BinaryWriter writer, TileDataInstance tile)
{
if (tile.Tileset != null)
{
//WriteTileset(writer, tileData.Tileset);
WriteResource(writer, tile.Tileset, tilesets);
writer.Write((int)tile.SheetLocation.X);
writer.Write((int)tile.SheetLocation.Y);
WriteProperties(writer, tile.Properties);
}
else
{
writer.Write((int)-1);
WriteResource(writer, tile.TileData, tileData);
WriteProperties(writer, tile.Properties);
//writer.Write((long) tileData.Flags);
//WriteTileType(writer, tileData.Type);
//WriteResource(writer, tileData.CollisionModel, collisionModels);
//WriteResource(writer, tileData.Sprite, sprites);
//WriteResource(writer, tileData.SpriteAsObject, sprites);
//WriteResource(writer, tileData.Animation, animations);
//WriteResource(writer, tileData.BreakAnimation, animations);
//WriteProperties(writer, tile.ModifiedProperties);
}
}
public static bool IsRoomEmpty(Room room)
{
TileData sameTileType = null;
for (int layer = 0; layer < room.LayerCount; layer++)
{
for (int x = 0; x < room.Width; x++)
{
for (int y = 0; y < room.Height; y++)
{
TileDataInstance tile = room.GetTile(x, y, layer);
if (tile != null && layer > 0)
{
return(false);
}
if (layer == 0)
{
if (sameTileType != null && tile == null)
{
return(false);
}
else if (sameTileType != null && tile != null && tile.TileData != sameTileType)
{
return(false);
}
else if (sameTileType == null && tile != null)
{
sameTileType = tile.TileData;
}
}
}
}
}
return(true);
}
public TileDataInstance CreateTile(TileData data, int x, int y, int layer)
{
TileDataInstance dataInstance = new TileDataInstance(data, x, y, layer);
dataInstance.Room = this;
PlaceTile(dataInstance, new Point2I(x, y), layer);
return(dataInstance);
}
public override void Deselect()
{
selectedEventTile = null;
selectedTile = null;
LevelDisplayControl.DeselectTiles();
LevelDisplayControl.DeselectSelectionGrid();
EditorControl.PropertyGrid.CloseProperties();
}
//-----------------------------------------------------------------------------
// Internal Iteration
//-----------------------------------------------------------------------------
private IEnumerable <BaseTileDataInstance> GetTilesInArea(Rectangle2I area)
{
// Make sure the area is within the level bounds.
area = Rectangle2I.Intersect(area,
new Rectangle2I(Point2I.Zero, roomSize * dimensions));
// Iterate the tile grid.
for (int x = 0; x < area.Width; x++)
{
for (int y = 0; y < area.Height; y++)
{
LevelTileCoord coord = (LevelTileCoord)(area.Point + new Point2I(x, y));
Room room = GetRoom(coord);
if (room != null)
{
Point2I tileLocation = GetTileLocation(coord);
for (int i = 0; i < roomLayerCount; i++)
{
TileDataInstance tile = room.GetTile(tileLocation, i);
if (tile != null && tile.Location == tileLocation)
{
yield return(tile);
}
}
}
}
}
// Determine the collection of rooms that will contain the event tiles.
Point2I roomAreaMin = GetRoomLocation((LevelTileCoord)area.Min);
Point2I roomAreaMax = GetRoomLocation((LevelTileCoord)area.Max);
Rectangle2I roomArea = new Rectangle2I(roomAreaMin, roomAreaMax - roomAreaMin + Point2I.One);
roomArea = Rectangle2I.Intersect(roomArea, new Rectangle2I(Point2I.Zero, dimensions));
Rectangle2I pixelArea = new Rectangle2I(
area.Point * GameSettings.TILE_SIZE,
area.Size * GameSettings.TILE_SIZE);
// Iterate event tiles.
for (int x = roomArea.Left; x < roomArea.Right; x++)
{
for (int y = roomArea.Top; y < roomArea.Bottom; y++)
{
Room room = rooms[x, y];
for (int i = 0; i < room.EventData.Count; i++)
{
EventTileDataInstance eventTile = room.EventData[i];
Rectangle2I tileBounds = eventTile.GetBounds();
tileBounds.Point += room.Location * roomSize * GameSettings.TILE_SIZE;
if (pixelArea.Contains(tileBounds.Point))
{
yield return(eventTile);
}
}
}
}
}
public void RemoveTile(int x, int y, int layer)
{
TileDataInstance tile = tileData[x, y, layer];
if (tile != null)
{
RemoveTile(tile);
}
}
private bool Matches(TileDataInstance tile1, TileDataInstance tile2)
{
if (tile1 == null)
{
return(tile2 == null);
}
else if (tile2 != null)
{
return(tile1.TileData == tile2.TileData);
}
return(false);
}
//-----------------------------------------------------------------------------
// Internal methods
//-----------------------------------------------------------------------------
private void ActivateTile(MouseButtons mouseButton, Room room, Point2I tileLocation)
{
if (mouseButton == MouseButtons.Left)
{
// Sample the tile.
TileDataInstance tile = room.GetTile(tileLocation, editorControl.CurrentLayer);
if (tile != null)
{
editorControl.SelectedTilesetTile = -Point2I.One;
editorControl.SelectedTilesetTileData = tile.TileData;
}
}
}
public override void CreateList(ListBox listBox, object value)
{
listBox.DrawItem += OnDrawItem;
listBox.DrawMode = DrawMode.OwnerDrawFixed;
listBox.ItemHeight = 20;
if (PropertyGrid.PropertyObject is TileDataInstance)
{
TileDataInstance tile = (TileDataInstance)PropertyGrid.PropertyObject;
for (int i = 0; i < tile.SpriteList.Length; i++)
{
listBox.Items.Add(i);
}
}
}
public IEnumerable <TileDataInstance> GetTiles(string id)
{
for (int i = 0; i < LayerCount; i++)
{
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
TileDataInstance tile = tileData[x, y, i];
if (tile != null && tile.Id == id)
{
yield return(tile);
}
}
}
}
}
public void RemoveTile(TileDataInstance tile)
{
if (tile.Room == this)
{
Point2I size = tile.Size;
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
Point2I loc = new Point2I(tile.Location.X + x, tile.Location.Y + y);
if (loc.X < Width && loc.Y < Height)
{
tileData[loc.X, loc.Y, tile.Layer] = null;
}
}
}
}
}
public override void OnMouseMove(MouseEventArgs e)
{
base.OnMouseMove(e);
Point2I mousePos = new Point2I(e.X, e.Y);
if (!editorControl.EventMode)
{
// Highlight tiles.
TileDataInstance tile = LevelDisplayControl.SampleTile(mousePos, editorControl.CurrentLayer);
EditorControl.HighlightMouseTile = (tile != null);
}
else
{
// Highlight event tiles.
EventTileDataInstance eventTile = LevelDisplayControl.SampleEventTile(mousePos);
EditorControl.HighlightMouseTile = (eventTile != null);
}
}
private void ReadRoom(BinaryReader reader, Room room)
{
// Read the dimensions.
int width = reader.ReadInt32();
int height = reader.ReadInt32();
int layerCount = reader.ReadInt32();
// Read the room's properties.
ReadProperties(reader, room.Properties);
// Read tile data for first layer (stored as a grid of tiles).
for (int y = 0; y < room.Height; y++)
{
for (int x = 0; x < room.Width; x++)
{
TileDataInstance tile = ReadTileData(reader);
if (tile != null)
{
room.PlaceTile(tile, new Point2I(x, y), 0);
}
}
}
// Read tile data for higher layers (stored as a list of non-null tiles).
int tileDataCount = reader.ReadInt32();
for (int i = 0; i < tileDataCount; i++)
{
int x = reader.ReadInt32();
int y = reader.ReadInt32();
int layer = reader.ReadInt32();
room.PlaceTile(ReadTileData(reader), new Point2I(x, y), layer);
}
// Read event tile data.
int eventTileDataCount = reader.ReadInt32();
for (int i = 0; i < eventTileDataCount; i++)
{
room.AddEventTile(ReadEventTileData(reader));
}
}
// Place a tile in a room, deleting any other tiles in the way.
public void PlaceTile(TileDataInstance tile, Room room, Point2I location, int layer)
{
// Remove any tiles in the way.
Point2I size = tile.Size;
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
TileDataInstance t = room.GetTile(location, layer);
if (t != null)
{
DeleteTile(t);
}
}
}
// Place the tile.
room.PlaceTile(tile, location, layer);
}
private void ActivateTile(MouseButtons mouseButton, Room room, Point2I tileLocation)
{
TileDataInstance tile = room.GetTile(tileLocation, EditorControl.CurrentLayer);
if (mouseButton == MouseButtons.Left)
{
TileData selectedTilesetTileData = editorControl.SelectedTilesetTileData as TileData;
if (selectedTilesetTileData != null)
{
// Remove the existing tile.
if (tile != null)
{
room.RemoveTile(tile);
editorControl.OnDeleteObject(tile);
}
// Place the new tile.
room.PlaceTile(
new TileDataInstance(selectedTilesetTileData),
tileLocation.X, tileLocation.Y, editorControl.CurrentLayer);
}
}
else if (mouseButton == MouseButtons.Right)
{
// Erase the tile.
if (tile != null)
{
room.RemoveTile(tile);
editorControl.OnDeleteObject(tile);
}
}
else if (mouseButton == MouseButtons.Middle)
{
// Sample the tile.
if (tile != null)
{
editorControl.SelectedTilesetTile = -Point2I.One;
editorControl.SelectedTilesetTileData = tile.TileData;
}
}
}
// Spawn a tile if it isn't already spawned.
public void SpawnTile(TileDataInstance tileData, bool staySpawned)
{
if (!IsTileSpawned(tileData))
{
TileSpawnOptions spawnOptions = tileData.SpawnOptions;
if (spawnOptions.PoofEffect)
{
Tile tile = new AppearingTile(tileData, spawnOptions);
PlaceTile(tile, tileData.Location, tileData.Layer);
}
else
{
Tile tile = Tile.CreateTile(tileData);
PlaceTile(tile, tileData.Location, tileData.Layer);
}
}
if (staySpawned)
{
tileData.Properties.Set("enabled", true);
}
}
private void OnDrawItem(object sender, DrawItemEventArgs e)
{
ListBox listBox = sender as ListBox;
Brush brush = new SolidBrush(e.ForeColor);
Rectangle bounds = new Rectangle(e.Bounds.X + 20, e.Bounds.Y + 3, e.Bounds.Width, e.Bounds.Height);
e.DrawBackground();
// Draw the label.
e.Graphics.DrawString(listBox.Items[e.Index].ToString(), e.Font, brush, bounds, StringFormat.GenericDefault);
// Draw the sprite.
if (PropertyGrid.PropertyObject is TileDataInstance)
{
TileDataInstance tile = (TileDataInstance)PropertyGrid.PropertyObject;
EditorGraphics.DrawSprite(e.Graphics, tile.SpriteList[e.Index],
tile.Room.Zone.ImageVariantID, (Point2I)(e.Bounds.Location) +
new Point2I(2, 2), new Point2I(16, 16));
}
brush.Dispose();
}
public void PlaceTile(TileDataInstance tile, Point2I location, int layer)
{
Point2I size = tile.Size;
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
Point2I loc = new Point2I(location.X + x, location.Y + y);
if (loc.X < Width && loc.Y < Height)
{
// Remove existing tile.
TileGridTile t = tiles[loc.X, loc.Y, layer];
if (t.Tile != null)
{
RemoveTile(t);
}
tiles[loc.X, loc.Y, layer].Set(tile, location.X, location.Y, layer);
}
}
}
}
public void RemoveTile(TileDataInstance tile)
{
if (tile == null)
{
return;
}
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
for (int i = 0; i < layerCount; i++)
{
TileGridTile t = tiles[x, y, i];
if (t.Tile == tile)
{
RemoveTile(t);
return;
}
}
}
}
}
// Take tiles from the level (or duplicate them) and put them into a tile grid.
public TileGrid CreateTileGrid(Rectangle2I area, bool duplicate)
{
TileGrid tileGrid = new TileGrid(area.Size, roomLayerCount);
BaseTileDataInstance[] tiles = GetTilesInArea(area).ToArray();
foreach (BaseTileDataInstance baseTileOriginal in tiles)
{
// Duplicate the tile if specified, else remove the original.
BaseTileDataInstance baseTile;
if (duplicate)
{
baseTile = baseTileOriginal.Duplicate();
}
else
{
baseTile = baseTileOriginal;
baseTileOriginal.Room.Remove(baseTileOriginal);
}
// Add the tile to the tile grid.
if (baseTile is TileDataInstance)
{
TileDataInstance tile = (TileDataInstance)baseTile;
tile.Location += tile.Room.Location * roomSize;
tile.Location -= area.Point;
tileGrid.PlaceTile(tile, tile.Location, tile.Layer);
}
else if (baseTile is EventTileDataInstance)
{
EventTileDataInstance eventTile = (EventTileDataInstance)baseTile;
eventTile.Position += eventTile.Room.Location * roomSize * GameSettings.TILE_SIZE;
eventTile.Position -= area.Point * GameSettings.TILE_SIZE;
tileGrid.AddEventTile(eventTile);
}
}
return(tileGrid);
}
private TileDataInstance ReadTileData(BinaryReader reader)
{
int tilesetIndex = reader.ReadInt32();
if (tilesetIndex == -11) // -11 indicates a null tile.
{
return(null);
}
TileDataInstance tile = new TileDataInstance();
Tileset tileset = null;
if (tilesetIndex >= 0)
{
tileset = tilesets[tilesetIndex].Resource;
}
if (tileset != null)
{
// Create tile from a tileset.
Point2I sheetLocation = new Point2I(
reader.ReadInt32(),
reader.ReadInt32());
tile.TileData = tileset.TileData[sheetLocation.X, sheetLocation.Y];
}
else
{
// Create tile from a TileData resource.
tile.TileData = ReadResource(reader, tileData);
}
// Read the tile's properties.
ReadProperties(reader, tile.Properties);
tile.Properties.BaseProperties = tile.TileData.Properties;
tile.ModifiedProperties.Clone(tile.Properties);
return(tile);
}
// Place the tiles in a tile grid starting at the given location.
public void PlaceTileGrid(TileGrid tileGrid, LevelTileCoord location)
{
// Remove tiles.
Rectangle2I area = new Rectangle2I((Point2I)location, tileGrid.Size);
RemoveArea(area);
// Place tiles.
foreach (BaseTileDataInstance baseTile in tileGrid.GetTiles())
{
if (baseTile is TileDataInstance)
{
TileDataInstance tile = (TileDataInstance)baseTile;
LevelTileCoord coord = (LevelTileCoord)((Point2I)location + tile.Location);
Room room = GetRoom(coord);
if (room != null)
{
tile.Location = GetTileLocation(coord);
room.PlaceTile(tile, tile.Location, tile.Layer);
}
}
else if (baseTile is EventTileDataInstance)
{
EventTileDataInstance eventTile = (EventTileDataInstance)baseTile;
eventTile.Position += (Point2I)location * GameSettings.TILE_SIZE;
Point2I roomLocation = eventTile.Position / (roomSize * GameSettings.TILE_SIZE);
Room room = GetRoomAt(roomLocation);
if (room != null)
{
eventTile.Position -= roomLocation * roomSize * GameSettings.TILE_SIZE;
room.AddEventTile(eventTile);
}
}
}
}
private void Fill(Point2I target, TileData fillData)
{
Point2I totalSize = editorControl.Level.Dimensions * editorControl.Level.RoomSize;
TileDataInstance targetTile = GetTileAt(target);
Point2I point;
// Don't fill in the same tiles.
if (fillData == null && targetTile == null)
{
return;
}
if (targetTile != null && targetTile.TileData == fillData)
{
return;
}
Queue <Point2I> nodes = new Queue <Point2I>();
nodes.Enqueue(target);
while (nodes.Count > 0)
{
point = nodes.Dequeue();
if (Matches(targetTile, point))
{
int width = 1;
// Travel as far left as possible.
for (; point.X - 1 >= 0 && Matches(targetTile, point - new Point2I(1, 0)); point.X--, width++)
{
;
}
// Travel as far right as possible.
for (; point.X + width < totalSize.X && Matches(targetTile, point + new Point2I(width, 0)); width++)
{
;
}
// Fill the row of tiles.
for (int i = 0; i < width; i++)
{
ReplaceTile(point + new Point2I(i, 0), fillData);
}
// This continue makes sure that one node is added for every range of pixels in a row.
bool northContinue = false, southContinue = false;
for (int i = 0; i < width; i++)
{
if (point.Y - 1 >= 0)
{
if (Matches(targetTile, point + new Point2I(i, -1)))
{
if (!northContinue)
{
nodes.Enqueue(point + new Point2I(i, -1));
northContinue = true;
}
}
else
{
northContinue = false;
}
}
if (point.Y + 1 < totalSize.Y)
{
if (Matches(targetTile, point + new Point2I(i, 1)))
{
if (!southContinue)
{
nodes.Enqueue(point + new Point2I(i, 1));
southContinue = true;
}
}
else
{
southContinue = false;
}
}
}
}
}
}
protected TileDataInstance tile; // The tile we're holding the place for.
#endregion Fields
#region Constructors
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
public PlaceHolderTile(TileDataInstance tile)
{
this.tile = tile;
}
private bool Matches(TileDataInstance targetTile, Point2I current)
{
TileDataInstance currentTile = GetTileAt(current);
return(Matches(targetTile, GetTileAt(current)));
}
public override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
Point2I mousePos = new Point2I(e.X, e.Y);
Room room = LevelDisplayControl.SampleRoom(mousePos);
Point2I tileCoord = LevelDisplayControl.SampleTileCoordinates(mousePos);
Point2I target = LevelDisplayControl.SampleLevelTileCoordinates(mousePos);
if (!EditorControl.EventMode)
{
if (e.Button == MouseButtons.Middle)
{
// Select/sample tiles.
TileDataInstance selectedTile = room.GetTile(tileCoord, editorControl.CurrentLayer);
if (selectedTile != null)
{
Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, tileCoord);
EditorControl.PropertyGrid.OpenProperties(selectedTile.Properties, selectedTile);
editorControl.SelectedTilesetTile = -Point2I.One;
editorControl.SelectedTilesetTileData = selectedTile.TileData;
}
else
{
EditorControl.PropertyGrid.CloseProperties();
}
}
else if (editorControl.CurrentLayer == 0 || GetTileAt(target) != null)
{
// Fill tiles.
TileData fillData = editorControl.SelectedTilesetTileData as TileData;
if (fillData != null)
{
if (e.Button == MouseButtons.Right)
{
fillData = null;
}
Fill(target, fillData);
}
}
}
else
{
if (e.Button == MouseButtons.Middle)
{
// Select events.
EventTileDataInstance selectedEventTile = LevelDisplayControl.SampleEventTile(mousePos);
if (selectedEventTile != null)
{
Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, tileCoord);
EditorControl.PropertyGrid.OpenProperties(selectedEventTile.Properties, selectedEventTile);
}
else
{
EditorControl.PropertyGrid.CloseProperties();
}
}
}
}
public void BeginRoom(Room room)
{
this.room = room;
this.roomLocation = room.Location;
this.dungeon = room.Dungeon;
this.isSideScrolling = room.Zone.IsSideScrolling;
// Discover the room.
room.IsDiscovered = true;
room.Level.IsDiscovered = true;
// Clear event tiles.
eventTiles.Clear();
// Clear all entities from the old room (except for the player).
entities.Clear();
if (Player != null)
{
Player.Initialize(this);
Player.EntityIndex = 0;
entities.Add(Player);
}
// Create the tile grid.
tileManager.Initialize(room);
for (int x = 0; x < room.Width; x++)
{
for (int y = 0; y < room.Height; y++)
{
for (int i = 0; i < room.LayerCount; i++)
{
TileDataInstance data = room.TileData[x, y, i];
if (data != null && data.IsAtLocation(x, y) &&
data.ModifiedProperties.GetBoolean("enabled", true))
{
// Place the tile.
Tile tile = Tile.CreateTile(data);
PlaceTile(tile, x, y, i, false);
}
}
}
}
// Create the event tiles.
eventTiles.Capacity = room.EventData.Count;
for (int i = 0; i < room.EventData.Count; i++)
{
EventTileDataInstance data = room.EventData[i];
if (data.Properties.GetBoolean("enabled", true))
{
EventTile eventTile = EventTile.CreateEvent(data);
eventTiles.Add(eventTile);
}
}
// Initialize the tiles.
tileManager.InitializeTiles();
// Initialize the event tiles.
for (int i = 0; i < eventTiles.Count; i++)
{
eventTiles[i].Initialize(this);
}
tileManager.PostInitializeTiles();
entityCount = entities.Count;
viewControl.Bounds = RoomBounds;
viewControl.ViewSize = GameSettings.VIEW_SIZE;
// Fire the RoomStart event.
GameControl.FireEvent(room, "event_room_start");
allMonstersDead = false;
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
public AppearingTile(TileDataInstance tile, TileSpawnOptions spawnOptions)
: base(tile)
{
this.spawnOptions = spawnOptions;
}
public bool IsTileSpawned(TileDataInstance tileDataInstance)
{
return(GetTiles().Any(t => t.TileDataOwner == tileDataInstance));
}
//-----------------------------------------------------------------------------
// Tile Management
//-----------------------------------------------------------------------------
public void PlaceTile(TileDataInstance tile, int x, int y, int layer)
{
PlaceTile(tile, new Point2I(x, y), layer);
}
