public static void SetFuncTool(FuncTool tool)
{
EditorTools.funcTool = tool;
EditorTools.tileTool = null;
EditorTools.tempTool = null;
EditorTools.autoTool.ClearAutoTiles();
// Update Helper Text (if applicable)
EditorTools.UpdateHelperText();
}
public static void SetTileTool(TileTool tool, byte index = 0)
{
EditorTools.tileTool = tool;
EditorTools.funcTool = null;
EditorTools.tempTool = null;
EditorTools.autoTool.ClearAutoTiles();
EditorUI.currentSlotGroup = EditorTools.tileTool.slotGroup;
// Assign Index and SubIndex to TileTool (if applicable)
EditorTools.tileTool.SetIndex(index);
// Update Helper Text (if applicable)
EditorTools.UpdateHelperText();
}
public void CloneTile(short gridX, short gridY)
{
RoomFormat roomData = this.levelContent.data.rooms[this.roomID];
Dictionary <string, Dictionary <string, ArrayList> > layerData = null;
bool isObject = false;
if (LevelContent.VerifyTiles(roomData.obj, gridX, gridY))
{
layerData = roomData.obj; isObject = true;
}
else if (LevelContent.VerifyTiles(roomData.main, gridX, gridY))
{
layerData = roomData.main;
}
else if (LevelContent.VerifyTiles(roomData.fg, gridX, gridY))
{
layerData = roomData.fg;
}
else if (LevelContent.VerifyTiles(roomData.bg, gridX, gridY))
{
layerData = roomData.bg;
}
// If no tile is cloned, set the current Function Tool to "Select"
if (layerData == null)
{
FuncToolSelect selectFunc = (FuncToolSelect)FuncTool.funcToolMap[(byte)FuncToolEnum.Select];
EditorTools.SetFuncTool(selectFunc);
selectFunc.ClearSelection();
return;
}
// Get the Object from the Highlighted Tile (Search Front to Back until a tile is identified)
byte[] tileData = LevelContent.GetTileData(layerData, gridX, gridY);
// Identify the tile, and set it as the current editing tool (if applicable)
TileTool clonedTool = TileTool.GetTileToolFromTileData(tileData, isObject);
if (clonedTool is TileTool == true)
{
byte subIndex = clonedTool.subIndex; // Need to save this value to avoid subIndexSaves[] tracking.
EditorTools.SetTileTool(clonedTool, (byte)clonedTool.index);
clonedTool.SetSubIndex(subIndex);
}
}
public static void SetTileToolBySlotGroup(byte slotGroup, byte index = 0)
{
// If the current slot group is being changed:
if (EditorTools.tileTool == null || EditorTools.tileTool.slotGroup != slotGroup)
{
if (TileTool.tileToolMap.ContainsKey(slotGroup))
{
TileTool tool = TileTool.tileToolMap[slotGroup];
if (tool == null)
{
return;
}
EditorTools.SetTileTool(tool, tool.index);
}
}
// If the current slot group is the same, need to change the index only.
else
{
TileTool tool = EditorTools.tileTool;
EditorTools.SetTileTool(tool, index);
}
}
public static TileTool GetTileToolFromTileData(byte[] tileData, bool isObject = false)
{
if (tileData == null)
{
return(null);
}
// If we're retrieving a object, verify that it exists in the Object Dictionary (otherwise it's invalid).
if (isObject)
{
Dictionary <byte, System.Type> objDict = Systems.mapper.ObjectTypeDict;
if (!objDict.ContainsKey(tileData[0]))
{
return(null);
}
}
// If we're retrieving a tile, verify that it exists in the Tile Dictionary (otherwise it's invalid).
else
{
Dictionary <byte, TileObject> tileDict = Systems.mapper.TileDict;
if (!tileDict.ContainsKey(tileData[0]))
{
return(null);
}
}
// Loop through every TileTool in an effort to locate a match for the tile data.
for (byte slotGroupNum = 1; slotGroupNum < 13; slotGroupNum++)
{
List <EditorPlaceholder[]> placeholders = TileTool.tileToolMap[(byte)slotGroupNum].placeholders;
// Loop through each placeholders to see if a tileData ID match is found.
byte phLen = (byte)placeholders.Count;
for (byte i = 0; i < phLen; i++)
{
EditorPlaceholder[] pData = placeholders[i];
byte phSubLen = (byte)pData.Length;
for (byte s = 0; s < phSubLen; s++)
{
EditorPlaceholder ph = pData[s];
// Check if the placeholder matches the tileData correctly:
if (isObject)
{
if (tileData[0] != ph.objectId || tileData[1] != ph.subType)
{
continue;
}
}
else
{
if (tileData[0] != ph.tileId || tileData[1] != ph.subType)
{
continue;
}
}
// If the tileData[0] ID & SubType matches with the TileTool placeholder, we've found a match.
TileTool clonedTool = TileTool.tileToolMap[(byte)slotGroupNum];
// Set the default values for the tool.
clonedTool.index = i;
clonedTool.subIndex = s;
clonedTool.subIndexSaves[i] = s;
return(clonedTool);
}
}
}
return(null);
}
public void TileToolTick(short gridX, short gridY)
{
// Prevent drawing when a component is selected.
if (UIComponent.ComponentWithFocus != null)
{
return;
}
// Make sure placement is in valid location:
if (gridY < 0 || gridY > this.yCount)
{
return;
}
if (gridX < 0 || gridX > this.xCount)
{
return;
}
TileTool tool = EditorTools.tileTool;
// Make sure the tile tool is set, or placement cannot occur:
if (tool == null)
{
return;
}
// Check if AutoTile Tool is intended. Requires Control to be held down.
if (Systems.input.LocalKeyDown(Keys.LeftControl))
{
// If left mouse button was just clicked, AutoTile is being activated.
if (Cursor.LeftMouseState == Cursor.MouseDownState.Clicked)
{
EditorTools.StartAutoTool(gridX, gridY);
}
}
// If AutoTile Tool is active, run it's behavior:
if (EditorTools.autoTool.IsActive)
{
// If left mouse was just released and AutoTile is active, place AutoTiles.
if (Cursor.LeftMouseState == Cursor.MouseDownState.Released)
{
EditorTools.autoTool.PlaceAutoTiles(this);
}
// If Control key is not held down, auto-tiles must be deactivated.
else if (!Systems.input.LocalKeyDown(Keys.LeftControl))
{
EditorTools.autoTool.ClearAutoTiles();
}
return;
}
// Left Mouse Button (Overwrite Current Tile)
if (Cursor.mouseState.LeftButton == ButtonState.Pressed)
{
// Prevent repeat-draws on the same tile (e.g. within the last 100ms).
if (!DrawTracker.AttemptPlace(gridX, gridY))
{
return;
}
EditorPlaceholder ph = tool.CurrentPlaceholder;
// Place Tile
if (ph.tileId > 0)
{
RoomFormat roomData = this.levelContent.data.rooms[this.roomID];
if (ph.layerEnum == LayerEnum.main)
{
// Check the Tile Limiter before placing the tile.
if (this.scene.limiter.AddLimitTile(this.scene.curRoomID, ph.tileId, ph.subType))
{
this.PlaceTile(roomData.main, ph.layerEnum, gridX, gridY, ph.tileId, ph.subType, null);
}
// If the Object Limiter failed, display the error message.
else
{
UIHandler.AddNotification(UIAlertType.Error, "Limit Reached", ObjectLimiter.LastFailMessage, 240);
}
}
else if (ph.layerEnum == LayerEnum.bg)
{
this.PlaceTile(roomData.bg, ph.layerEnum, gridX, gridY, ph.tileId, ph.subType, null);
}
else if (ph.layerEnum == LayerEnum.fg)
{
this.PlaceTile(roomData.fg, ph.layerEnum, gridX, gridY, ph.tileId, ph.subType, null);
}
}
// Place Object
else if (ph.objectId > 0)
{
// Check the Object Limiter before placing the tile.
if (this.scene.limiter.AddLimitObject(this.scene.curRoomID, ph.objectId))
{
this.PlaceTile(this.levelContent.data.rooms[this.roomID].obj, LayerEnum.obj, gridX, gridY, ph.objectId, ph.subType, null);
}
// If the Object Limiter failed, display the error message.
else
{
UIHandler.AddNotification(UIAlertType.Error, "Limit Reached", ObjectLimiter.LastFailMessage, 240);
}
}
return;
}
}
