// 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); }