public EventTileDataInstance CreateEventTile(EventTileData data, Point2I position) { EventTileDataInstance dataInstance = new EventTileDataInstance(data, position); AddEventTile(dataInstance); return(dataInstance); }
private void WriteEventTileData(BinaryWriter writer, EventTileDataInstance eventTile) { WriteResource(writer, eventTile.EventTileData, eventTileData); writer.Write(eventTile.Position.X); writer.Write(eventTile.Position.Y); WriteProperties(writer, eventTile.Properties); }
// 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); }
// Transition to another room through warp points. public void Warp(WarpEvent startPoint, EventTileDataInstance endPoint) { TransitionToRoom(endPoint.Room, startPoint.CreateTransition(endPoint), startPoint.CreateExitState(), null, endPoint); }
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 EventTile FindEventTile(EventTileDataInstance data) { for (int i = 0; i < eventTiles.Count; i++) { if (eventTiles[i].EventData == data) { return(eventTiles[i]); } } return(null); }
// Spawn an event tile if it isn't already spawned. public void SpawnEventTile(EventTileDataInstance eventTileData, bool staySpawned) { if (!IsEventTileSpawned(eventTileData)) { EventTile tile = EventTile.CreateEvent(eventTileData); AddEventTile(tile); } if (staySpawned) { eventTileData.Properties.Set("enabled", true); } }
private EventTileDataInstance ReadEventTileData(BinaryReader reader) { EventTileData tileData = ReadResource(reader, eventTileData); Point2I position = new Point2I( reader.ReadInt32(), reader.ReadInt32()); EventTileDataInstance eventTile = new EventTileDataInstance(tileData, position); ReadProperties(reader, eventTile.Properties); eventTile.Properties.PropertyObject = eventTile; eventTile.Properties.BaseProperties = eventTile.EventTileData.Properties; return(eventTile); }
public EventTileDataInstance FindEventTileByID(string id) { for (int x = 0; x < dimensions.X; x++) { for (int y = 0; y < dimensions.Y; y++) { EventTileDataInstance eventTile = rooms[x, y].FindEventTileByID(id); if (eventTile != null) { return(eventTile); } } } return(null); }
// Draw an event tile. private void DrawEventTile(Graphics2D g, EventTileDataInstance eventTile, Point2I position, Color drawColor) { SpriteAnimation spr = eventTile.CurrentSprite; int imageVariantID = eventTile.Properties.GetInteger("image_variant"); if (imageVariantID < 0) { imageVariantID = eventTile.Room.Zone.ImageVariantID; } // Select different sprites for certain events. if (eventTile.Type == typeof(NPCEvent)) { eventTile.SubStripIndex = eventTile.Properties.GetInteger("direction", 0); } else if (eventTile.Type == typeof(WarpEvent)) { string warpTypeStr = eventTile.Properties.GetString("warp_type", "tunnel"); WarpType warpType = (WarpType)Enum.Parse(typeof(WarpType), warpTypeStr, true); if (warpType == WarpType.Entrance) { spr = GameData.SPR_EVENT_TILE_WARP_ENTRANCE; } else if (warpType == WarpType.Tunnel) { spr = GameData.SPR_EVENT_TILE_WARP_TUNNEL; } else if (warpType == WarpType.Stairs) { spr = GameData.SPR_EVENT_TILE_WARP_STAIRS; } } // Draw the sprite. if (!spr.IsNull) { g.DrawAnimation(spr, imageVariantID, editorControl.Ticks, position, drawColor); } else { Rectangle2I r = new Rectangle2I(position, eventTile.Size * GameSettings.TILE_SIZE); g.FillRectangle(r, Color.Blue); } }
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); } }
// Sample an event tile at the given point. public EventTileDataInstance SampleEventTile(Point2I point) { Room room = SampleRoom(point); if (room == null) { return(null); } Point2I roomOffset = GetRoomDrawPosition(room); for (int i = 0; i < room.EventData.Count; i++) { EventTileDataInstance eventTile = room.EventData[i]; Rectangle2I tileRect = new Rectangle2I(eventTile.Position + roomOffset, eventTile.Size * GameSettings.TILE_SIZE); if (tileRect.Contains(point)) { return(eventTile); } } return(null); }
// 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); }
// 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); } } } }
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 TransitionToRoom(Room nextRoom, RoomTransition transition, GameState exitState, GameState enterState, EventTileDataInstance warpTile) { // Create the new room control. RoomControl newControl = new RoomControl(); newControl.gameManager = gameManager; newControl.room = nextRoom; newControl.roomLocation = nextRoom.Location; // [Exit] [Enter] // [RoomOld] -> [RoomOld] -> [Transition] -> [RoomNew] -> [RoomNew] // Create the sequence of game states for the transition. GameState postTransitionState = new GameStateAction(delegate(GameStateAction actionState) { gameManager.PopGameState(); // Pop the queue state. gameManager.PushGameState(newControl); // Push the new room control state. // Find the warp event were warping to and grab its enter-state. if (warpTile != null) { WarpEvent eventTile = newControl.FindEventTile(warpTile) as WarpEvent; if (eventTile != null) { enterState = eventTile.CreateEnterState(); } } if (enterState != null) { gameManager.PushGameState(enterState); // Push the enter state. } }); GameState preTransitionState = new GameStateAction(delegate(GameStateAction actionState) { GameControl.RoomControl = newControl; gameManager.PopGameState(); // Pop the queue state. gameManager.PopGameState(); // Pop the room control state. gameManager.PushGameState(new GameStateQueue(transition, postTransitionState)); newControl.FindEventTile(warpTile); }); if (warpTile != null) { transition.NewRoomSetup += delegate(RoomControl roomControl) { // Find the warp event were warping to. WarpEvent eventTile = newControl.FindEventTile(warpTile) as WarpEvent; if (eventTile != null) { eventTile.SetupPlayerInRoom(); } }; } // Create the game state for the transition sequence. GameState state = preTransitionState; if (exitState != null) { state = new GameStateQueue(exitState, preTransitionState); } // Begin the transition. transition.OldRoomControl = this; transition.NewRoomControl = newControl; gameManager.PushGameState(state); }
//----------------------------------------------------------------------------- // Overridden Methods //----------------------------------------------------------------------------- public override void OnBegin() { selectedTile = null; selectedEventTile = null; EditorControl.HighlightMouseTile = false; }
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; }
public override void OnEnd() { selectedTile = null; selectedEventTile = null; }
public bool IsEventTileSpawned(EventTileDataInstance eventTileDataInstance) { return(eventTiles.Any(t => t.EventData == eventTileDataInstance)); }
// Delete an already-placed event tile. public void DeleteEventTile(EventTileDataInstance eventTile) { eventTile.Room.RemoveEventTile(eventTile); editorControl.OnDeleteObject(eventTile); }
public void RemoveEventTile(EventTileDataInstance eventTile) { eventData.Remove(eventTile); }
public void AddEventTile(EventTileDataInstance eventTile) { eventData.Add(eventTile); eventTile.Room = this; }
public void AddEventTile(EventTileDataInstance eventTile) { eventTiles.Add(eventTile); }
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); if (editorControl.EventMode) { if (EditorControl.EventMode && e.Button == MouseButtons.Left) { EventTileData eventTile = editorControl.SelectedTilesetTileData as EventTileData; if (room != null && eventTile != null) { Point2I roomPos = LevelDisplayControl.GetRoomDrawPosition(room); Point2I pos = (mousePos - roomPos) / 8; pos *= 8; //Point2I tileCoord = LevelDisplayControl.SampleTileCoordinates(mousePos); room.CreateEventTile(eventTile, pos); } } else if (EditorControl.EventMode && e.Button == MouseButtons.Right) { EventTileDataInstance eventTile = LevelDisplayControl.SampleEventTile(new Point2I(e.X, e.Y)); if (eventTile != null) { eventTile.Room.RemoveEventTile(eventTile); editorControl.OnDeleteObject(eventTile); } } 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(); } } } else { if (e.Button == MouseButtons.Middle) { // Select tiles. TileDataInstance selectedTile = room.GetTile(tileCoord, editorControl.CurrentLayer); if (selectedTile != null) { Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, tileCoord); EditorControl.PropertyGrid.OpenProperties(selectedTile.Properties, selectedTile); } else { EditorControl.PropertyGrid.CloseProperties(); } } } }
private void WriteRoom(BinaryWriter writer, Room room) { writer.Write(room.Width); writer.Write(room.Height); writer.Write(room.LayerCount); WriteProperties(writer, room.Properties); // Write all tiles for the first tile layer. for (int y = 0; y < room.Height; y++) { for (int x = 0; x < room.Width; x++) { TileDataInstance tile = room.GetTile(x, y, 0); if (tile != null && tile.IsAtLocation(x, y)) { WriteTileData(writer, tile); } else { writer.Write(-11); // -11 signifies a null tile. } } } // Count non-null tile data for higher layers. int tileDataCount = 0; for (int i = 1; i < room.LayerCount; i++) { for (int y = 0; y < room.Height; y++) { for (int x = 0; x < room.Width; x++) { TileDataInstance tile = room.GetTile(x, y, i); if (tile != null && tile.IsAtLocation(x, y)) { tileDataCount++; } } } } // Write non-null tile data for higher layers. writer.Write(tileDataCount); for (int i = 1; i < room.LayerCount; i++) { for (int y = 0; y < room.Height; y++) { for (int x = 0; x < room.Width; x++) { TileDataInstance tile = room.GetTile(x, y, i); if (tile != null && tile.IsAtLocation(x, y)) { writer.Write(x); writer.Write(y); writer.Write(i); WriteTileData(writer, tile); } } } } // Write event tile data. writer.Write(room.EventData.Count); for (int i = 0; i < room.EventData.Count; i++) { EventTileDataInstance eventTile = room.EventData[i]; WriteEventTileData(writer, eventTile); } }