/// <summary>
/// Ensures that an editor exists at the specified map location if it is valid.
/// </summary>
private void EnsureEditorExists(int x, int y)
{
//if (x < 0 || x > 31 || y < 0 || y > 31) return;
bool editorPresent = false;
foreach (ScreenEditor e in editors)
{
if (e.MapLocation.X == x && e.MapLocation.Y == y)
{
editorPresent = true;
}
}
if (!editorPresent)
{
ScreenEditor newEditor = new ScreenEditor();
newEditor.EditorHost = host;
newEditor.MapLocation = new Point(x, y);
newEditor.RenderScreen();
newEditor.SelectionDragged += new EventHandler(on_EditorSelectionDragged);
newEditor.SelectedObjectChanged += new EventHandler(on_EditorSelectedObjectChanged);
newEditor.UserDraggedSelection += new EventHandler <EventArgs <Point> >(newEditor_UserDraggedSelection);
editors.Add(newEditor);
}
}
private void DrawScreen(int gameX, int gameY, int mapx, int mapY)
{
// Get currentLevelIndex and screen
LevelIndex level = levelMap.GetLevel(gameX, gameY);
bool invalidLevel = false;
if (level == LevelIndex.None ||
(levelFilter != LevelIndex.None && level != levelFilter))
{
return;
////if(!fillEmptySpots) return;
////if(levelFilter != LevelIndex.None)
//// level = levelFilter;
////else
//// level = GuessLevel(gameX, gameY);
////if(level == LevelIndex.Tourian)
//// level = LevelIndex.Kraid;
////invalidLevel = true;
}
Level levelData = rom.GetLevel(level);
int screenIndex = rom.GetScreenIndex(gameX, gameY);
if (screenIndex == 0xFF || invalidLevel) // Blank screen
{
screenIndex = GetBlankScreenIndex(level);
}
Screen screen = levelData.Screens[screenIndex];
// Load data into renderer
renderer.Level = levelData;
renderer.SelectedEnemy = -1;
// Apply paletteIndex
//screen.ApplyLevelPalette(screenBitmap); // Sprites
//renderer.ApplyPalette(screenBitmap, levelMap.GetAltPal(gameX, gameY)); // Backgrounds
ScreenEditor.ApplyPalette(levelMap.GetAltPal(gameX, gameY), levelData, screenBitmap, HighlightEffect.Invert);
// Render Screen
renderer.DefaultPalette = screen.ColorAttributeTable;
renderer.Clear();
renderer.SelectedDoor = -1;
renderer.DrawScreen(screenIndex);
IList <EnemyInstance> enemies = hideEnemies ? null : screen.Enemies;
renderer.Render(b, screenBitmap, enemies, screen.Doors, showPhysics);
Rectangle source = new Rectangle(0, 0, ScreenWidth, ScreenHeight);
Rectangle dest = new Rectangle(
mapx * ScreenWidth / scale, mapY * ScreenHeight / scale,
ScreenWidth / scale, ScreenHeight / scale);
gMap.DrawImage(screenBitmap, dest, source, GraphicsUnit.Pixel);
}
void Render()
{
Text = "Screen Browser [" + BaseIndex.ToString("x") + " - " + Math.Min(BaseIndex + 15, Level.Screens.Count - 1).ToString("x") + "]";
gBuffer.Clear(Color.Black);
gBuffer.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBilinear;
gBuffer.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
renderer.Level = this.Level;
//renderer.ApplyPalette(blitterBuffer, UseAlternatePalette);
//var pal = blitterBuffer.Palette;
//if (UseAlternatePalette) {
// Level.BgAltPalette.ApplyTable(pal.Entries,0);
// Level.BgAltPalette.ApplyTable(pal.Entries, 16);
// Level.SpriteAltPalette.ApplyTable(pal.Entries, 32);
//} else {
// Level.BgPalette.ApplyTable(pal.Entries, 0);
// Level.BgPalette.ApplyTable(pal.Entries, 16);
// Level.SpritePalette.ApplyTable(pal.Entries, 32);
//}
//blitterBuffer.Palette = pal;
ScreenEditor.ApplyPalette(UseAlternatePalette, Level, blitterBuffer, HighlightEffect.Invert);
for (int x = 0; x < 4; x++)
{
for (int y = 0; y < 4; y++)
{
int index = BaseIndex + x + y * 4;
if (index < Level.Screens.Count)
{
var screen = Level.Screens[index];
renderer.SelectedEnemy = -1;
renderer.SelectedDoor = -1;
renderer.DefaultPalette = screen.ColorAttributeTable;
renderer.Clear();
renderer.DrawScreen(index);
renderer.Render(blitter, blitterBuffer, screen.Enemies, screen.Doors, ShowPhysics);
Rectangle source = new Rectangle(0, 0, 256, 240);
Rectangle dest = new Rectangle(cellPadding + cellSpacingX * x, cellPadding + cellSpacingY * y, cellWidth, cellHeight);
gBuffer.DrawImage(blitterBuffer, dest, source, GraphicsUnit.Pixel);
if (index == HighlightedScreen)
{
dest.Inflate(2, 2);
gBuffer.DrawRectangle(SystemPens.Highlight, dest);
dest.Inflate(1, 1);
gBuffer.DrawRectangle(SystemPens.Highlight, dest);
}
}
}
}
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
UpdateCursor();
// If user left clicks and item and it is the item that was previously selected
// (oldSelection), the UI will be alerted to bring it up the structure selector
Editroid.ROM.ObjectInstance oldSelection = null;
if (_focus != null)
{
oldSelection = _focus.SelectedItem;
}
if ((ModifierKeys & Keys.Control) == Keys.Control)
{
ScreenEditor clicked = screens.GetEditorAtWorld(e.X + viewX, e.Y + viewY);
if (clicked != _focus)
{
RequestFocus(clicked);
}
PreviewEventArgs args = new PreviewEventArgs(
(ModifierKeys & Keys.Shift) == Keys.Shift,
new Point(e.X + viewX - _focus.WorldBounds.X, e.Y + viewY - _focus.WorldBounds.Y));
OnLaunchPreview(args);
}
else
{
// Mouse dragging occurs with middle button, or while holding shift and/or alt
if (e.Button == MouseButtons.Middle || UserHoldingMouseScrollKey)
{
BeginDrag(e.X, e.Y);
}
else
{
screens.SendMouseDown(e.Button, e.X + viewX, e.Y + viewY);
if (e.Button == MouseButtons.Left)
{
// Scroll structure selector to selected structure type if user clicks twice
Editroid.ROM.ObjectInstance newSelection = null;
if (_focus != null)
{
newSelection = _focus.SelectedItem;
}
if (newSelection != null && newSelection == oldSelection)
{
RequestShowObject.Raise(this);
}
}
}
}
}
public void ScrollScreen(int dx, int dy)
{
Point loc = _focus.WorldBounds.Location;
loc.Offset(ScreenEditor.CellSize.Width * dx, ScreenEditor.CellSize.Height * dy);
ScreenEditor newEditor = screens.GetEditorAtWorld(loc.X, loc.Y);
if (newEditor != null) // && newEditor.CanEdit) {
{
RequestFocus(newEditor);
ScrollView(-ScreenEditor.CellSize.Width * dx, -ScreenEditor.CellSize.Height * dy);
}
}
public void PaintScans(RectangleF[] scans, Graphics g)
{
// List of invalid regions, one for each editor
Rectangle[] invalidWorldRects = new Rectangle[editors.Count];
Rectangle BlankRect = new Rectangle();
// Invalidate editors
for (int scanIndex = 0; scanIndex < scans.Length; scanIndex++)
{
Rectangle invalidWorldRect = Rectangle.Truncate(scans[scanIndex]);
invalidWorldRect.X += host.WorldViewport.X;
invalidWorldRect.Y += host.WorldViewport.Y;
invalidWorldRect.Inflate(1, 1);
// Check this invalid scan against each editor's bounds.
for (int i = 0; i < editors.Count; i++)
{
ScreenEditor e = editors[i];
Rectangle editorWorldRect = e.WorldBounds;
// If they overlap, invalidate the editor
if (invalidWorldRect.IntersectsWith(editorWorldRect))
{
Rectangle invalidClippedWorldRect = editorWorldRect;
invalidClippedWorldRect.Intersect(invalidWorldRect);
if (invalidWorldRects[i] == BlankRect)
{
// Initialize the editor with its first invalid rect
invalidWorldRects[i] = invalidClippedWorldRect;
}
else
{
// Or expand the editor's invalid rect to include this invalid scan.
invalidWorldRects[i] = Rectangle.Union(invalidWorldRects[i], invalidWorldRect);
}
}
}
}
for (int i = 0; i < editors.Count; i++)
{
ScreenEditor e = editors[i];
if (invalidWorldRects[i] != BlankRect)
{
e.Paint(invalidWorldRects[i], g);
}
}
}
internal void SendMouseMove(System.Windows.Forms.MouseButtons buttons, int x, int y)
{
if (mouseCapture == null)
{
ScreenEditor mouseEditor = GetEditorAtWorld(x, y);
if (mouseEditor != null)
{
mouseEditor.OnMouseMove(buttons, x, y);
}
}
else
{
mouseCapture.OnMouseMove(buttons, x, y);
}
}
private void CreateAndDestroyEditors()
{
if (host == null)
{
return;
}
Rectangle view = host.WorldViewport;
// Destroy editors out of view
for (int i = 0; i < editors.Count; i++)
{
ScreenEditor editor = editors[i];
Rectangle bounds = editor.WorldBounds;
if (!bounds.IntersectsWith(view) && host.FocusedEditor != editor)
{
editor.Dispose();
editor.SelectionDragged -= new EventHandler(on_EditorSelectionDragged);
editor.SelectedObjectChanged -= new EventHandler(on_EditorSelectedObjectChanged);
editor.UserDraggedSelection -= new EventHandler <EventArgs <Point> >(newEditor_UserDraggedSelection);
editors.RemoveAt(i);
i--;
}
}
int gridLeft = view.X / ScreenEditor.CellSize.Width; //Math.Max(view.xTile / ScreenEditor.CellSize.Width, 0);
if (view.X < 0)
{
gridLeft--;
}
int gridRight = view.Right / ScreenEditor.CellSize.Width; //Math.Min(view.Right / ScreenEditor.CellSize.Width, 31);
int gridTop = view.Y / ScreenEditor.CellSize.Height; //Math.Max(view.yTile / ScreenEditor.CellSize.Height, 0);
if (view.Y < 0)
{
gridTop--;
}
int gridBottom = view.Bottom / ScreenEditor.CellSize.Height;//Math.Min(view.Bottom / ScreenEditor.CellSize.Height, 31);
for (int x = gridLeft; x <= gridRight; x++)
{
for (int y = gridTop; y <= gridBottom; y++)
{
EnsureEditorExists(x, y);
}
}
}
public void RequestFocus(ScreenEditor editor)
{
if (_focus != null)
{
ScreenEditor oldFocus = _focus;
_focus = null;
oldFocus.LoseFocus();
}
_focus = editor;
if (_focus != null)
{
_focus.GetFocus();
InitializeFocus();
}
}
public void Display(ScreenEditor editor)
{
this.currentEditor = editor;
// Get state
bool editableScreenSelected = editor.CanEdit && editor.LevelIndex != LevelIndex.None;
bool somethingInScreenSelected = editableScreenSelected && editor.SelectedItem != null;
bool structSelected = somethingInScreenSelected && editor.SelectedItem is StructInstance;
bool enemySelected = somethingInScreenSelected && editor.SelectedItem is EnemyInstance;
bool hasPasswordData = editableScreenSelected && editor.Rom.PasswordData.HasDataFor(editor.MapLocation);
bool hasMusic = editableScreenSelected && editor.Rom.GetLevel(editor.LevelIndex).AlternateMusicRooms.Contians((byte)editor.ScreenIndex);
// Set visibilities
IndexLabel.Visible = PaletteLabel.Visible = (enemySelected || structSelected);
SlotImage.Visible = SlotLabel.Visible = enemySelected;
LayoutLabel.Visible = FreespaceLabel.Visible = editableScreenSelected;
musicButton.Visible = editableScreenSelected;
PasswordDataToggle.Visible = hasPasswordData;
// Update values
if (enemySelected)
{
SlotLabel.Text = ((EnemyInstance)editor.SelectedItem).SpriteSlot.ToString();
}
if (enemySelected || structSelected)
{
int typeIndex = -1;
int palette = -1;
if (enemySelected)
{
typeIndex = ((EnemyInstance)editor.SelectedItem).EnemyType;
palette = ((EnemyInstance)editor.SelectedItem).DifficultByteValue;
}
if (structSelected)
{
typeIndex = ((StructInstance)editor.SelectedItem).ObjectType;
palette = ((StructInstance)editor.SelectedItem).PalData;
}
IndexLabel.Text = FormatHex(typeIndex);
PaletteLabel.Text = palette.ToString();
}
musicButton.State = hasMusic;
if (editableScreenSelected)
{
slotAvailableForCreepyMusicRoom = editor.Rom.GetLevel(editor.LevelIndex).AlternateMusicRooms.UsedEntryCount < currentEditor.Level.Format.AltMusicRoomCount;
LayoutLabel.Text = FormatHex(editor.ScreenIndex);
if (editor.Rom.RomFormat == RomFormats.MMC3)
{
FreespaceLabel.Text = "~" + FormatHex(Math.Max(0, editor.Rom.GetLevel(editor.LevelIndex).FreeScreenData));
}
else
{
FreespaceLabel.Text = FormatHex(Math.Max(0, editor.Rom.GetLevel(editor.LevelIndex).FreeScreenData));
}
lblMapLocation.Text = FormatHex(editor.MapLocation.X) + ", " + FormatHex(editor.MapLocation.Y);
lblDefaultPal.Text = editor.Screen.ColorAttributeTable.ToString();
}
}
public void RequestUnfocus(ScreenEditor editor)
{
RequestFocus(null);
}
