public override BaseTileDataInstance Duplicate()
{
EventTileDataInstance copy = new EventTileDataInstance();
copy.Clone(this);
return(copy);
}
public override void Deselect()
{
selectedEventTile = null;
selectedTile = null;
LevelDisplayControl.ClearSelectionBox();
EditorControl.PropertyGridControl.CloseProperties();
}
// Create the room transition state for this warp point.
public RoomTransition CreateTransition(EventTileDataInstance destination)
{
int dir = destination.Properties.GetInteger("face_direction", Directions.Down);
if (warpType == WarpType.Stairs)
return new RoomTransitionFade();
return new RoomTransitionSplit();
}
//-----------------------------------------------------------------------------
// Constructors
//-----------------------------------------------------------------------------
public EventTile()
{
roomControl = null;
eventData = null;
position = Vector2F.Zero;
size = Point2I.One;
properties = new Properties();
collisionBox = new Rectangle2I(0, 0, 16, 16);
}
//-----------------------------------------------------------------------------
// Constructors
//-----------------------------------------------------------------------------
public EventTile()
{
roomControl = null;
eventData = null;
position = Vector2F.Zero;
size = Point2I.One;
properties = new Properties();
collisionBox = new Rectangle2I(0, 0, 16, 16);
}
// Create the room transition state for this warp point.
public RoomTransition CreateTransition(EventTileDataInstance destination)
{
int dir = destination.Properties.GetInteger("face_direction", Directions.Down);
if (warpType == WarpType.Stairs)
{
return(new RoomTransitionFade());
}
return(new RoomTransitionSplit());
}
public bool FindDestinationInLevel(string id, Level level, out Room destRoom, out EventTileDataInstance destEvent)
{
for (int x = 0; x < level.Width; x++) {
for (int y = 0; y < level.Height; y++) {
if (FindDestinationInRoom(id, level.GetRoomAt(x, y), out destRoom, out destEvent))
return true;
}
}
destRoom = null;
destEvent = null;
return false;
}
public bool FindDestinationInRoom(string id, Room room, out Room destRoom, out EventTileDataInstance destEvent)
{
for (int i = 0; i < room.EventData.Count; i++) {
if (room.EventData[i].Properties.GetString("id", "") == id) {
destRoom = room;
destEvent = room.EventData[i];
return true;
}
}
destRoom = null;
destEvent = null;
return false;
}
// Warp to the destination point.
public void Warp(int warpDirection)
{
EventTileDataInstance destination = FindDestinationPoint();
if (destination != null)
{
AudioSystem.PlaySound(GameData.SOUND_ROOM_EXIT);
RoomControl.Warp(this, destination);
RoomControl.Player.BeginNormalState();
}
else
{
Console.WriteLine("Invalid warp destination!");
}
}
//-----------------------------------------------------------------------------
// Static methods
//-----------------------------------------------------------------------------
// Instantiate an event tile from the given event-data.
public static EventTile CreateEvent(EventTileDataInstance data)
{
EventTile tile;
// Construct the tile.
if (data.Type == null)
{
tile = new EventTile();
}
else
{
tile = (EventTile)data.Type.GetConstructor(Type.EmptyTypes).Invoke(null);
}
tile.position = data.Position;
tile.eventData = data;
tile.size = data.Size;
tile.properties.SetAll(data.BaseProperties);
tile.properties.SetAll(data.Properties);
tile.properties.BaseProperties = data.Properties;
return(tile);
}
public void RemoveEventTile(EventTileDataInstance eventTile)
{
eventData.Remove(eventTile);
}
// 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 AddEventTile(EventTileDataInstance eventTile)
{
eventTiles.Add(eventTile);
}
//-----------------------------------------------------------------------------
// Static methods
//-----------------------------------------------------------------------------
// Instantiate an event tile from the given event-data.
public static EventTile CreateEvent(EventTileDataInstance data)
{
EventTile tile;
// Construct the tile.
if (data.Type == null)
tile = new EventTile();
else
tile = (EventTile) data.Type.GetConstructor(Type.EmptyTypes).Invoke(null);
tile.position = data.Position;
tile.eventData = data;
tile.size = data.Size;
tile.properties.SetAll(data.BaseProperties);
tile.properties.SetAll(data.Properties);
tile.properties.BaseProperties = data.Properties;
return tile;
}
// Draw an event tile.
private void DrawEventTile(Graphics2D g, EventTileDataInstance eventTile, Color color)
{
Sprite spr = eventTile.Sprite;
// Select different sprites for certain events.
if (eventTile.Type == typeof(WarpEvent)) {
string warpType = eventTile.Properties.GetString("warp_type");
if (warpType == "tunnel")
spr = GameData.SPR_EVENT_TILE_WARP_TUNNEL;
else if (warpType == "stairs")
spr = GameData.SPR_EVENT_TILE_WARP_STAIRS;
else if (warpType == "entrance")
spr = GameData.SPR_EVENT_TILE_WARP_ENTRANCE;
}
// Draw the sprite.
if (spr != null) {
g.DrawSprite(spr, eventTile.Room.Zone.ImageVariantID, eventTile.Position);
}
else {
Rectangle2I r = new Rectangle2I(eventTile.Position, eventTile.Size * GameSettings.TILE_SIZE);
g.FillRectangle(r, Color.Blue);
}
}
public override void OnEnd()
{
selectedTile = null;
selectedEventTile = null;
}
//-----------------------------------------------------------------------------
// Overridden Methods
//-----------------------------------------------------------------------------
public override void OnBegin()
{
selectedTile = null;
selectedEventTile = null;
EditorControl.HighlightMouseTile = false;
}
// Delete an already-placed event tile.
public void DeleteEventTile(EventTileDataInstance eventTile)
{
eventTile.Room.RemoveEventTile(eventTile);
editorControl.OnDeleteObject(eventTile);
}
// 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 void AddEventTile(EventTileDataInstance eventTile)
{
eventData.Add(eventTile);
eventTile.Room = this;
}
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 (e.Button == MouseButtons.Left && room != null) {
if (!editorControl.EventMode) {
if (System.Windows.Forms.Control.ModifierKeys == Keys.Shift) {
selectedRoom = room;
Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, Point2I.Zero);
LevelDisplayControl.SetSelectionBox(levelTileCoord, room.Size);
EditorControl.PropertyGridControl.OpenProperties(room.Properties, room);
}
else {
// Select tiles.
selectedTile = room.GetTile(tileCoord, editorControl.CurrentLayer);
if (selectedTile != null) {
Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, tileCoord);
LevelDisplayControl.SetSelectionBox(levelTileCoord, Point2I.One);
EditorControl.PropertyGridControl.OpenProperties(selectedTile.Properties, selectedTile);
}
else {
LevelDisplayControl.ClearSelectionBox();
EditorControl.PropertyGridControl.CloseProperties();
}
}
}
else {
// Select events.
selectedEventTile = LevelDisplayControl.SampleEventTile(mousePos);
if (selectedEventTile != null) {
Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, tileCoord);
LevelDisplayControl.SetSelectionBox(levelTileCoord, Point2I.One);
EditorControl.PropertyGridControl.OpenProperties(selectedEventTile.Properties, selectedEventTile);
}
else {
LevelDisplayControl.ClearSelectionBox();
EditorControl.PropertyGridControl.CloseProperties();
}
}
}
}
public EventTileDataInstance CreateEventTile(EventTileData data, Point2I position)
{
EventTileDataInstance dataInstance = new EventTileDataInstance(data, position);
AddEventTile(dataInstance);
return dataInstance;
}
