public void ChangeTool(int newTool)
{
if (newTool != (int)currentTool)
{
previousTool = (int)currentTool;
currentTool = (Tools)newTool;
switch (currentTool)
{
case Tools.Arrow:
Cursor.SetCursor(standardCursor, Vector2.zero, CursorMode.Auto);
if (currentPuzzleElementSelected && !currentPuzzleElementSelected.activeSelf)
{
currentPuzzleElementSelected.SetActive(true);
}
break;
case Tools.Brush:
Cursor.SetCursor(brushCursor, new Vector2(0, brushCursor.height - 60), CursorMode.Auto);
if (currentPuzzleElementSelected && currentPuzzleElementSelected.activeSelf)
{
currentPuzzleElementSelected.SetActive(false);
}
break;
case Tools.Eraser:
Cursor.SetCursor(eraserCursor, new Vector2(0, eraserCursor.height - 126), CursorMode.Auto);
if (currentPuzzleElementSelected && currentPuzzleElementSelected.activeSelf)
{
currentPuzzleElementSelected.SetActive(false);
}
break;
case Tools.Dropper:
Cursor.SetCursor(dropperCursor, new Vector2(-11, dropperCursor.height - 11), CursorMode.Auto);
if (currentPuzzleElementSelected && currentPuzzleElementSelected.activeSelf)
{
currentPuzzleElementSelected.SetActive(false);
}
break;
}
}
else
{
if (currentTool == Tools.Brush)
{
selectedTile = TileButton.Tiles.None;
currentSelectedTile = allTiles.blankCursorTile;
}
}
}
// Update is called once per frame
void Update()
{
if (mouseBlockedByUI || LevelManager.instance.mode != LevelManager.LevelMode.Editor)
{
return;
}
Vector3Int mousePos = HLTilemap.WorldToCell(cam.ScreenToWorldPoint(Input.mousePosition));
// Change Tools Keyboard Controls -------------------------------------------
if (!LevelManager.instance.levelName.isFocused && !LevelManager.instance.levelDescription.isFocused)
{
if (Input.GetKeyDown(KeyCode.R))
{
ChangeTool((int)Tools.Dropper);
}
if (Input.GetKeyDown(KeyCode.E))
{
ChangeTool((int)Tools.Eraser);
}
if (Input.GetKeyDown(KeyCode.W))
{
ChangeTool((int)Tools.Brush);
}
if (Input.GetKeyDown(KeyCode.Q))
{
ChangeTool((int)Tools.Arrow);
}
}
// --------------------------------------------------------------------------
// Change Tool to EyeDropper
if (Input.GetKeyDown(KeyCode.LeftAlt) && !LevelManager.instance.levelName.isFocused && !LevelManager.instance.levelDescription.isFocused)
{
ChangeTool((int)Tools.Dropper);
}
switch (currentTool)
{
case Tools.Arrow:
if (mousePos != previousCoordinate)
{
HLTilemap.SetTile(previousCoordinate, null);
if (sizeLimit.HasTile(mousePos))
{
HLTilemap.SetTile(mousePos, allTiles.blankArrowToolTile);
previousCoordinate = mousePos;
}
else
{
previousCoordinate = new Vector3Int(-999, -999, -999);
}
}
if (Input.GetMouseButton(0) && currentPuzzleElementSelected && sizeLimit.HasTile(mousePos))
{
currentPuzzleElementSelected.GetComponent <PuzzleElementPlaceHolder>().ChangeState(PuzzleElementPlaceHolder.States.InLevel);
LinkElementPlaceholder LEP = currentPuzzleElementSelected.GetComponent <LinkElementPlaceholder>();
if (LEP)
{
if (!linkingObjects.ContainsKey(currentPuzzleElementSelected))
{
linkingObjects.Add(currentPuzzleElementSelected, LEP.type);
}
}
currentPuzzleElementSelected = null;
}
if (Input.GetMouseButton(1) && currentPuzzleElementSelected)
{
Destroy(currentPuzzleElementSelected);
currentPuzzleElementSelected = null;
}
break;
case Tools.Brush:
if (mousePos != previousCoordinate)
{
HLTilemap.SetTile(previousCoordinate, null);
if (sizeLimit.HasTile(mousePos))
{
HLTilemap.SetTile(mousePos, currentSelectedTile);
previousCoordinate = mousePos;
}
else
{
previousCoordinate = new Vector3Int(-999, -999, -999);
}
}
// Paint Tiles
if (Input.GetMouseButton(0) && currentSelectedTile != allTiles.blankCursorTile && sizeLimit.HasTile(mousePos))
{
desiredTM.SetTile(mousePos, currentSelectedTile);
if (desiredTM != baseTM)
{
baseTM.SetTile(mousePos, null);
}
if (desiredTM != collidable)
{
collidable.SetTile(mousePos, null);
}
}
// Erase Tiles
if (Input.GetMouseButton(1))
{
if (collidable.GetTile(mousePos))
{
collidable.SetTile(mousePos, null);
}
if (baseTM.GetTile(mousePos))
{
baseTM.SetTile(mousePos, null);
}
}
// Reset Brush
if (Input.GetMouseButtonDown(2))
{
selectedTile = TileButton.Tiles.None;
currentSelectedTile = allTiles.blankCursorTile;
previousCoordinate = new Vector3Int(-999, -999, -999);
}
break;
case Tools.Eraser:
if (mousePos != previousCoordinate)
{
HLTilemap.SetTile(previousCoordinate, null);
HLTilemap.SetTile(previousCoordinate, null);
if (sizeLimit.HasTile(mousePos))
{
HLTilemap.SetTile(mousePos, allTiles.blankArrowToolTile);
previousCoordinate = mousePos;
}
else
{
previousCoordinate = new Vector3Int(-999, -999, -999);
}
}
if (Input.GetMouseButton(0))
{
if (collidable.GetTile(mousePos))
{
collidable.SetTile(mousePos, null);
}
if (baseTM.GetTile(mousePos))
{
baseTM.SetTile(mousePos, null);
}
}
break;
case Tools.Dropper:
if (Input.GetKeyUp(KeyCode.LeftAlt) && previousTool != -1 && previousTool != (int)Tools.Dropper)
{
ChangeTool(previousTool);
}
if (mousePos != previousCoordinate)
{
HLTilemap.SetTile(previousCoordinate, null);
if (sizeLimit.HasTile(mousePos))
{
HLTilemap.SetTile(mousePos, allTiles.blankArrowToolTile);
previousCoordinate = mousePos;
}
else
{
previousCoordinate = new Vector3Int(-999, -999, -999);
}
}
if (Input.GetMouseButtonUp(0))
{
Ray ray = cam.ScreenPointToRay(Input.mousePosition);
RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction);
if (hit.collider && hit.collider.CompareTag("Placeholder"))
{
currentPuzzleElementSelected = Instantiate(hit.collider.gameObject);
currentPuzzleElementSelected.GetComponent <PuzzleElementPlaceHolder>().ChangeState(PuzzleElementPlaceHolder.States.Selected);
ChangeTool((int)Tools.Arrow);
return;
}
TileBase tileSelected = null;
if (collidable.GetTile(mousePos))
{
tileSelected = collidable.GetTile(mousePos);
desiredTM = collidable;
}
if (baseTM.GetTile(mousePos))
{
tileSelected = baseTM.GetTile(mousePos);
desiredTM = baseTM;
}
if (tileSelected)
{
currentSelectedTile = tileSelected;
ChangeTool((int)Tools.Brush);
}
}
break;
}
}
// Start is called before the first frame update
void Start()
{
selectedTile = TileButton.Tiles.None;
currentSelectedTile = allTiles.blankCursorTile;
Cursor.SetCursor(standardCursor, Vector2.zero, CursorMode.Auto);
}
public void TileToPaintSelected(TileButton.Tiles tile)
{
if (tile == selectedTile)
{
currentSelectedTile = allTiles.blankCursorTile;
selectedTile = TileButton.Tiles.None;
return;
}
selectedTile = tile;
switch (tile)
{
case TileButton.Tiles.Ground:
currentSelectedTile = allTiles.groundTile;
desiredTM = baseTM;
break;
case TileButton.Tiles.DarkGround:
currentSelectedTile = allTiles.darkGroundTile;
desiredTM = baseTM;
break;
case TileButton.Tiles.VerticalWall:
currentSelectedTile = allTiles.verticalWallTile;
desiredTM = collidable;
break;
case TileButton.Tiles.HorizontalWall:
currentSelectedTile = allTiles.horizontalWallTile;
desiredTM = collidable;
break;
case TileButton.Tiles.LUCorner:
currentSelectedTile = allTiles.LUCornerTile;
desiredTM = collidable;
break;
case TileButton.Tiles.LDCorner:
currentSelectedTile = allTiles.LDCornerTile;
desiredTM = collidable;
break;
case TileButton.Tiles.RUCorner:
currentSelectedTile = allTiles.RUCornerTile;
desiredTM = collidable;
break;
case TileButton.Tiles.RDCorner:
currentSelectedTile = allTiles.RDCornerTile;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadEndUp:
currentSelectedTile = allTiles.DeadEndUp;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadEndDown:
currentSelectedTile = allTiles.DeadEndDown;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadEndRight:
currentSelectedTile = allTiles.DeadEndRight;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadEndLeft:
currentSelectedTile = allTiles.DeadEndLeft;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadContinuousLeft:
currentSelectedTile = allTiles.DeadContinuousLeft;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadContinuousRight:
currentSelectedTile = allTiles.DeadContinuousRight;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadContinuousUp:
currentSelectedTile = allTiles.DeadContinuousUp;
desiredTM = collidable;
break;
case TileButton.Tiles.DeadContinuousDown:
currentSelectedTile = allTiles.DeadContinuousDown;
desiredTM = collidable;
break;
case TileButton.Tiles.RotatingCylinder:
currentSelectedTile = allTiles.RotatingCylinder;
desiredTM = collidable;
break;
case TileButton.Tiles.lightsPanel:
currentSelectedTile = allTiles.LightsPanel;
desiredTM = collidable;
break;
}
if (currentTool != Tools.Brush)
{
ChangeTool(1);
}
}
public static int CheckTile(TileBase tile)
{
TileButton.Tiles i = TileButton.Tiles.None;
AllTiles aT = PuzzleEditorController.instance.allTiles;
if (tile == aT.groundTile)
{
i = TileButton.Tiles.Ground;
}
else if (tile == aT.darkGroundTile)
{
i = TileButton.Tiles.DarkGround;
}
else if (tile == aT.verticalWallTile)
{
i = TileButton.Tiles.VerticalWall;
}
else if (tile == aT.horizontalWallTile)
{
i = TileButton.Tiles.HorizontalWall;
}
else if (tile == aT.LUCornerTile)
{
i = TileButton.Tiles.LUCorner;
}
else if (tile == aT.LDCornerTile)
{
i = TileButton.Tiles.LDCorner;
}
else if (tile == aT.RUCornerTile)
{
i = TileButton.Tiles.RUCorner;
}
else if (tile == aT.RDCornerTile)
{
i = TileButton.Tiles.RDCorner;
}
else if (tile == aT.DeadEndUp)
{
i = TileButton.Tiles.DeadEndUp;
}
else if (tile == aT.DeadEndDown)
{
i = TileButton.Tiles.DeadEndDown;
}
else if (tile == aT.DeadEndLeft)
{
i = TileButton.Tiles.DeadEndLeft;
}
else if (tile == aT.DeadEndRight)
{
i = TileButton.Tiles.DeadEndRight;
}
else if (tile == aT.DeadContinuousLeft)
{
i = TileButton.Tiles.DeadContinuousLeft;
}
else if (tile == aT.DeadContinuousRight)
{
i = TileButton.Tiles.DeadContinuousRight;
}
else if (tile == aT.DeadContinuousUp)
{
i = TileButton.Tiles.DeadContinuousUp;
}
else if (tile == aT.DeadContinuousDown)
{
i = TileButton.Tiles.DeadContinuousDown;
}
else if (tile == aT.RotatingCylinder)
{
i = TileButton.Tiles.RotatingCylinder;
}
else if (tile == aT.LightsPanel)
{
i = TileButton.Tiles.lightsPanel;
}
return((int)i);
}
