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