1309 lines
55 KiB
C#
1309 lines
55 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using NUnit.Framework;
|
|
using UnityEngine.TestTools;
|
|
using UnityEngine.Tilemaps;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace UnityEditor.Tilemaps.Tests
|
|
{
|
|
internal class GridBrushTest
|
|
{
|
|
private static SceneView s_SceneView;
|
|
private static GridPaintPaletteWindow s_PaletteWindow;
|
|
private static List<UnityEngine.Object> s_Objects;
|
|
|
|
private GameObject m_TilemapGameObject;
|
|
private Grid m_Grid;
|
|
private Tilemap m_Tilemap;
|
|
private TileBase m_TileA;
|
|
private TileBase m_TileB;
|
|
private TileBase m_TileC;
|
|
|
|
[TearDown]
|
|
public void TearDown()
|
|
{
|
|
SessionState.EraseInt(GridPaletteBrushes.s_SessionStateLastUsedBrush);
|
|
GridPaintingState.gridBrush = GridPaletteBrushes.brushes[0];
|
|
|
|
GridPaletteBrushes.FlushCache();
|
|
foreach (var obj in s_Objects)
|
|
Object.DestroyImmediate(obj);
|
|
Object.DestroyImmediate(m_TileA);
|
|
Object.DestroyImmediate(m_TileB);
|
|
Object.DestroyImmediate(m_TileC);
|
|
|
|
s_Objects.Clear();
|
|
s_SceneView.Close();
|
|
s_PaletteWindow.Close();
|
|
}
|
|
|
|
[SetUp]
|
|
public void SetUp()
|
|
{
|
|
s_SceneView = EditorWindow.GetWindow<SceneView>();
|
|
s_PaletteWindow = EditorWindow.GetWindow<GridPaintPaletteWindow>();
|
|
s_Objects = new List<UnityEngine.Object>();
|
|
|
|
m_TilemapGameObject = CreateTilemapGameObject();
|
|
m_Grid = m_TilemapGameObject.GetComponent<Grid>();
|
|
m_Tilemap = m_TilemapGameObject.GetComponent<Tilemap>();
|
|
Selection.activeGameObject = m_TilemapGameObject;
|
|
|
|
m_TileA = CreateScriptableObject<Tile>();
|
|
m_TileB = CreateScriptableObject<Tile>();
|
|
m_TileC = CreateScriptableObject<Tile>();
|
|
|
|
ResetSceneViewWindowPosition();
|
|
ResetPaletteWindowPosition();
|
|
ResetSceneViewCamera();
|
|
|
|
SessionState.EraseInt(GridPaletteBrushes.s_SessionStateLastUsedBrush);
|
|
GridPaintingState.gridBrush = GridPaletteBrushes.brushes[0];
|
|
}
|
|
|
|
private T CreateScriptableObject<T>() where T : ScriptableObject
|
|
{
|
|
var obj = ScriptableObject.CreateInstance<T>();
|
|
s_Objects.Add(obj);
|
|
return obj;
|
|
}
|
|
|
|
private GameObject CreateGameObject()
|
|
{
|
|
var obj = new GameObject();
|
|
s_Objects.Add(obj);
|
|
return obj;
|
|
}
|
|
|
|
private GameObject CreateTilemapGameObject()
|
|
{
|
|
var go = CreateGameObject();
|
|
go.AddComponent<Grid>();
|
|
go.AddComponent<Tilemap>();
|
|
return go;
|
|
}
|
|
|
|
private MyBrush SetupCustomBrush()
|
|
{
|
|
GridPaletteBrushes.FlushCache();
|
|
GridPaintingState.gridBrush = GridPaletteBrushes.brushes[1];
|
|
MyBrush brush = GridPaintingState.gridBrush as MyBrush;
|
|
brush.m_LastCalledMethod = "";
|
|
return brush;
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_EnsureDefaultState()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
|
|
Assert.AreEqual(1, gridBrush.size.x);
|
|
Assert.AreEqual(1, gridBrush.size.y);
|
|
Assert.AreEqual(0, gridBrush.pivot.x);
|
|
Assert.AreEqual(0, gridBrush.pivot.y);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetTiles_CellsInBrushHasTileSet()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
|
|
gridBrush.Init(new Vector3Int(2, 1, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
|
|
Assert.AreEqual(m_TileA, gridBrush.cells[0].tile);
|
|
Assert.AreEqual(m_TileB, gridBrush.cells[1].tile);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetMatrix_CellsInBrushHasMatrixSet()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
|
|
gridBrush.Init(new Vector3Int(2, 1, 1));
|
|
|
|
var matrixA = Matrix4x4.identity;
|
|
matrixA.m20 = 5;
|
|
var matrixB = Matrix4x4.identity;
|
|
matrixB.m02 = 9;
|
|
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetMatrix(Vector3Int.zero, matrixB);
|
|
gridBrush.SetMatrix(new Vector3Int(1, 0, 0), matrixA);
|
|
|
|
Assert.AreEqual(matrixB, gridBrush.cells[0].matrix);
|
|
Assert.AreEqual(matrixA, gridBrush.cells[1].matrix);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_FlipX_CellsInBrushAreFlippedHorizontally()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
var matrixFlipX = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(-1f, 1f, 1f));
|
|
|
|
gridBrush.Init(new Vector3Int(2, 1, 1));
|
|
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.Flip(GridBrush.FlipAxis.X, Grid.CellLayout.Rectangle);
|
|
|
|
Assert.AreEqual(2, gridBrush.size.x);
|
|
Assert.AreEqual(1, gridBrush.size.y);
|
|
Assert.AreEqual(1, gridBrush.pivot.x);
|
|
Assert.AreEqual(0, gridBrush.pivot.y);
|
|
Assert.AreEqual(m_TileB, gridBrush.cells[0].tile);
|
|
Assert.AreEqual(matrixFlipX, gridBrush.cells[0].matrix);
|
|
Assert.AreEqual(m_TileA, gridBrush.cells[1].tile);
|
|
Assert.AreEqual(matrixFlipX, gridBrush.cells[1].matrix);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_FlipY_CellsInBrushAreFlippedVertically()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
var matrixFlipY = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1f, -1f, 1f));
|
|
|
|
gridBrush.Init(new Vector3Int(1, 2, 1));
|
|
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.Flip(GridBrush.FlipAxis.Y, Grid.CellLayout.Rectangle);
|
|
|
|
Assert.AreEqual(1, gridBrush.size.x);
|
|
Assert.AreEqual(2, gridBrush.size.y);
|
|
Assert.AreEqual(0, gridBrush.pivot.x);
|
|
Assert.AreEqual(1, gridBrush.pivot.y);
|
|
Assert.AreEqual(m_TileB, gridBrush.cells[0].tile);
|
|
Assert.AreEqual(matrixFlipY, gridBrush.cells[0].matrix);
|
|
Assert.AreEqual(m_TileA, gridBrush.cells[1].tile);
|
|
Assert.AreEqual(matrixFlipY, gridBrush.cells[1].matrix);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_RotateClockwise_CellsInBrushAreRotatedClockwise()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
var matrixRotateClockwise = new Matrix4x4(new Vector4(0f, 1f, 0f, 0f), new Vector4(-1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f));
|
|
|
|
gridBrush.Init(new Vector3Int(2, 1, 1));
|
|
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.Rotate(GridBrush.RotationDirection.Clockwise, Grid.CellLayout.Rectangle);
|
|
|
|
Assert.AreEqual(1, gridBrush.size.x);
|
|
Assert.AreEqual(2, gridBrush.size.y);
|
|
Assert.AreEqual(0, gridBrush.pivot.x);
|
|
Assert.AreEqual(0, gridBrush.pivot.y);
|
|
Assert.AreEqual(m_TileA, gridBrush.cells[0].tile);
|
|
Assert.AreEqual(matrixRotateClockwise, gridBrush.cells[0].matrix);
|
|
Assert.AreEqual(m_TileB, gridBrush.cells[1].tile);
|
|
Assert.AreEqual(matrixRotateClockwise, gridBrush.cells[1].matrix);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_RotateCounterClockwise_CellsInBrushAreRotatedCounterClockwise()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
var matrixRotateCounterClockwise = new Matrix4x4(new Vector4(0f, -1f, 0f, 0f), new Vector4(1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f));
|
|
|
|
gridBrush.Init(new Vector3Int(2, 1, 1));
|
|
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.Rotate(GridBrush.RotationDirection.CounterClockwise, Grid.CellLayout.Rectangle);
|
|
|
|
Assert.AreEqual(1, gridBrush.size.x);
|
|
Assert.AreEqual(2, gridBrush.size.y);
|
|
Assert.AreEqual(0, gridBrush.pivot.x);
|
|
Assert.AreEqual(1, gridBrush.pivot.y);
|
|
Assert.AreEqual(m_TileB, gridBrush.cells[0].tile);
|
|
Assert.AreEqual(matrixRotateCounterClockwise, gridBrush.cells[0].matrix);
|
|
Assert.AreEqual(m_TileA, gridBrush.cells[1].tile);
|
|
Assert.AreEqual(matrixRotateCounterClockwise, gridBrush.cells[1].matrix);
|
|
}
|
|
|
|
public class FlipRotateTestCase
|
|
{
|
|
public GridBrush.FlipAxis flipAxis;
|
|
public GridBrush.RotationDirection rotationDirection;
|
|
public bool flipBeforeRotate;
|
|
public bool m_TileBBeforeTileA;
|
|
public Vector3Int size;
|
|
public Vector3Int pivot;
|
|
public Matrix4x4 transform;
|
|
|
|
public override String ToString()
|
|
{
|
|
return String.Format(flipBeforeRotate ? "{0}, {1}" : "{1}, {0}"
|
|
, Enum.GetName(typeof(GridBrush.FlipAxis), flipAxis)
|
|
, Enum.GetName(typeof(GridBrush.RotationDirection), rotationDirection));
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<FlipRotateTestCase> FlipRotateTestCases()
|
|
{
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.X,
|
|
rotationDirection = GridBrushBase.RotationDirection.Clockwise,
|
|
flipBeforeRotate = false,
|
|
m_TileBBeforeTileA = false,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = Vector3Int.zero,
|
|
transform = new Matrix4x4(new Vector4(0f, 1f, 0f, 0f), new Vector4(1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.X,
|
|
rotationDirection = GridBrushBase.RotationDirection.Clockwise,
|
|
flipBeforeRotate = true,
|
|
m_TileBBeforeTileA = true,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = new Vector3Int(0, 1, 0),
|
|
transform = new Matrix4x4(new Vector4(0f, -1f, 0f, 0f), new Vector4(-1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.X,
|
|
rotationDirection = GridBrushBase.RotationDirection.CounterClockwise,
|
|
flipBeforeRotate = false,
|
|
m_TileBBeforeTileA = true,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = new Vector3Int(0, 1, 0),
|
|
transform = new Matrix4x4(new Vector4(0f, -1f, 0f, 0f), new Vector4(-1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.X,
|
|
rotationDirection = GridBrushBase.RotationDirection.CounterClockwise,
|
|
flipBeforeRotate = true,
|
|
m_TileBBeforeTileA = false,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = Vector3Int.zero,
|
|
transform = new Matrix4x4(new Vector4(0f, 1f, 0f, 0f), new Vector4(1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.Y,
|
|
rotationDirection = GridBrushBase.RotationDirection.Clockwise,
|
|
flipBeforeRotate = false,
|
|
m_TileBBeforeTileA = true,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = new Vector3Int(0, 1, 0),
|
|
transform = new Matrix4x4(new Vector4(0f, -1f, 0f, 0f), new Vector4(-1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.Y,
|
|
rotationDirection = GridBrushBase.RotationDirection.Clockwise,
|
|
flipBeforeRotate = true,
|
|
m_TileBBeforeTileA = false,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = Vector3Int.zero,
|
|
transform = new Matrix4x4(new Vector4(0f, 1f, 0f, 0f), new Vector4(1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.Y,
|
|
rotationDirection = GridBrushBase.RotationDirection.CounterClockwise,
|
|
flipBeforeRotate = false,
|
|
m_TileBBeforeTileA = false,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = Vector3Int.zero,
|
|
transform = new Matrix4x4(new Vector4(0f, 1f, 0f, 0f), new Vector4(1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
yield return new FlipRotateTestCase
|
|
{
|
|
flipAxis = GridBrush.FlipAxis.Y,
|
|
rotationDirection = GridBrushBase.RotationDirection.CounterClockwise,
|
|
flipBeforeRotate = true,
|
|
m_TileBBeforeTileA = true,
|
|
size = new Vector3Int(1, 2, 1),
|
|
pivot = new Vector3Int(0, 1, 0),
|
|
transform = new Matrix4x4(new Vector4(0f, -1f, 0f, 0f), new Vector4(-1f, 0f, 0f, 0f),
|
|
new Vector4(0f, 0f, 1f, 0f), new Vector4(0f, 0f, 0f, 1f))
|
|
};
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_RotationAndFlip_CellsInBrushAreRotatedAndFlipped(
|
|
[ValueSource("FlipRotateTestCases")] FlipRotateTestCase testCase)
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
|
|
gridBrush.Init(new Vector3Int(2, 1, 1));
|
|
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
|
|
if (testCase.m_TileBBeforeTileA)
|
|
{
|
|
var temp = m_TileA;
|
|
m_TileA = m_TileB;
|
|
m_TileB = temp;
|
|
}
|
|
|
|
if (testCase.flipBeforeRotate)
|
|
{
|
|
gridBrush.Flip(testCase.flipAxis, Grid.CellLayout.Rectangle);
|
|
gridBrush.Rotate(testCase.rotationDirection, Grid.CellLayout.Rectangle);
|
|
}
|
|
else
|
|
{
|
|
gridBrush.Rotate(testCase.rotationDirection, Grid.CellLayout.Rectangle);
|
|
gridBrush.Flip(testCase.flipAxis, Grid.CellLayout.Rectangle);
|
|
}
|
|
|
|
Assert.AreEqual(testCase.size, gridBrush.size);
|
|
Assert.AreEqual(testCase.pivot, gridBrush.pivot);
|
|
Assert.AreEqual(m_TileA, gridBrush.cells[0].tile);
|
|
Assert.AreEqual(m_TileB, gridBrush.cells[1].tile);
|
|
Assert.AreEqual(testCase.transform, gridBrush.cells[0].matrix);
|
|
Assert.AreEqual(testCase.transform, gridBrush.cells[1].matrix);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_PaintOnTilemap_GridBrushSetsTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
|
|
gridBrush.Init(new Vector3Int(1, 1, 1));
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileA);
|
|
|
|
var targetPositionA1 = Vector3Int.zero;
|
|
var targetPositionA2 = new Vector3Int(1, 1, 0);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPositionA1);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPositionA2);
|
|
|
|
gridBrush.SetTile(Vector3Int.zero, m_TileB);
|
|
|
|
var targetPositionB1 = new Vector3Int(0, 1, 0);
|
|
var targetPositionB2 = new Vector3Int(1, 0, 0);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPositionB1);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPositionB2);
|
|
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPositionA1));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPositionA2));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPositionB1));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPositionB2));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_EraseOnTilemap_GridBrushErasesTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(1, 1, 1));
|
|
var targetPositionA1 = Vector3Int.zero;
|
|
var targetPositionA2 = new Vector3Int(1, 1, 0);
|
|
m_Tilemap.SetTile(targetPositionA1, m_TileA);
|
|
m_Tilemap.SetTile(targetPositionA2, m_TileB);
|
|
|
|
Selection.activeGameObject = m_TilemapGameObject;
|
|
gridBrush.Erase(m_Grid, Selection.activeGameObject, targetPositionA1);
|
|
gridBrush.Erase(m_Grid, Selection.activeGameObject, targetPositionA2);
|
|
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPositionA1));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPositionA2));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetWithMultipleTiles_PaintOnTilemap_GridBrushSetsMultipleTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
var targetPosition = new Vector3Int(5, 6, 0);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPosition);
|
|
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition + new Vector3Int(0, 0, 0)));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPosition + new Vector3Int(1, 0, 0)));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition + new Vector3Int(2, 0, 0)));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPosition + new Vector3Int(0, 1, 0)));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition + new Vector3Int(1, 1, 0)));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition + new Vector3Int(2, 1, 0)));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetWithMultipleTiles_PaintOnTilemap_TriggersSyncTileOncePerCall()
|
|
{
|
|
int count = 0;
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
System.Action<Tilemap, Tilemap.SyncTile[]> tilemapAction = (tilemap, syncTiles) =>
|
|
{
|
|
count++;
|
|
Assert.AreEqual(tilemap, m_Tilemap);
|
|
Assert.AreEqual(5, syncTiles.Length);
|
|
};
|
|
|
|
var targetPositionA = new Vector3Int(5, 6, 0);
|
|
var targetPositionB = new Vector3Int(6, 6, 0);
|
|
Tilemap.SetSyncTileCallback(tilemapAction);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPositionA);
|
|
Assert.AreEqual(1, count);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPositionB);
|
|
Assert.AreEqual(2, count);
|
|
Tilemap.RemoveSyncTileCallback(tilemapAction);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetWithMultipleTiles_DragPaintOnTilemap_TriggersSyncTileOncePerCall()
|
|
{
|
|
int count = 0;
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
System.Action<Tilemap, Tilemap.SyncTile[]> tilemapAction = (tilemap, syncTiles) =>
|
|
{
|
|
count++;
|
|
Assert.AreEqual(tilemap, m_Tilemap);
|
|
};
|
|
|
|
GridPaintingState.gridBrush = gridBrush;
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
SceneViewMouseEnter();
|
|
|
|
Tilemap.SetSyncTileCallback(tilemapAction);
|
|
SceneViewMouseDrag(new Vector2(75, 75), new Vector2(175, 175));
|
|
Tilemap.RemoveSyncTileCallback(tilemapAction);
|
|
|
|
Assert.AreEqual(1, count);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetWithMultipleTiles_EraseOnTilemap_GridBrushErasesMultipleTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 5, 1));
|
|
var targetPosition = new Vector3Int(5, 5, 0);
|
|
m_Tilemap.SetTile(targetPosition + new Vector3Int(0, 0, 0), m_TileA);
|
|
m_Tilemap.SetTile(targetPosition + new Vector3Int(1, 1, 0), m_TileA);
|
|
m_Tilemap.SetTile(targetPosition + new Vector3Int(2, 2, 0), m_TileA);
|
|
|
|
gridBrush.Erase(m_Grid, Selection.activeGameObject, targetPosition);
|
|
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition + new Vector3Int(0, 0, 0)));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition + new Vector3Int(1, 1, 0)));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition + new Vector3Int(2, 2, 0)));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetWithMultipleTiles_EraseOnTilemap_TriggersSyncTileOncePerCall()
|
|
{
|
|
int count = 0;
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
System.Action<Tilemap, Tilemap.SyncTile[]> tilemapAction = (tilemap, syncTiles) =>
|
|
{
|
|
count++;
|
|
Assert.AreEqual(tilemap, m_Tilemap);
|
|
Assert.AreEqual(5, syncTiles.Length);
|
|
};
|
|
|
|
var targetPosition = new Vector3Int(5, 6, 0);
|
|
gridBrush.Paint(m_Grid, Selection.activeGameObject, targetPosition);
|
|
|
|
Tilemap.SetSyncTileCallback(tilemapAction);
|
|
gridBrush.Erase(m_Grid, Selection.activeGameObject, targetPosition);
|
|
Assert.AreEqual(1, count);
|
|
Tilemap.RemoveSyncTileCallback(tilemapAction);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SetWithMultipleTiles_DragEraseOnTilemap_TriggersSyncTileOncePerCall()
|
|
{
|
|
int count = 0;
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
System.Action<Tilemap, Tilemap.SyncTile[]> tilemapAction = (tilemap, syncTiles) =>
|
|
{
|
|
count++;
|
|
Assert.AreEqual(tilemap, m_Tilemap);
|
|
};
|
|
|
|
m_Tilemap.origin = new Vector3Int(-10, -10, 0);
|
|
m_Tilemap.size = new Vector3Int(30, 30, 0);
|
|
m_Tilemap.FloodFill(Vector3Int.zero, m_TileC);
|
|
|
|
GridPaintingState.gridBrush = gridBrush;
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(EraseTool));
|
|
SceneViewMouseEnter();
|
|
|
|
Tilemap.SetSyncTileCallback(tilemapAction);
|
|
SceneViewMouseDrag(new Vector2(75, 75), new Vector2(175, 175));
|
|
Tilemap.RemoveSyncTileCallback(tilemapAction);
|
|
|
|
Assert.AreEqual(1, count);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_BoxFillOnTilemap_TriggersSyncTileOncePerCall()
|
|
{
|
|
int count = 0;
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
System.Action<Tilemap, Tilemap.SyncTile[]> tilemapAction = (tilemap, syncTiles) =>
|
|
{
|
|
count++;
|
|
Assert.AreEqual(tilemap, m_Tilemap);
|
|
Assert.AreEqual(43, syncTiles.Length);
|
|
};
|
|
|
|
var targetPosition = new BoundsInt(5, 6, 0, 7, 7, 1);
|
|
Tilemap.SetSyncTileCallback(tilemapAction);
|
|
gridBrush.BoxFill(m_Grid, Selection.activeGameObject, targetPosition);
|
|
Assert.AreEqual(1, count);
|
|
Tilemap.RemoveSyncTileCallback(tilemapAction);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_DragBoxFillOnTilemap_TriggersSyncTileOncePerCall()
|
|
{
|
|
int count = 0;
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
System.Action<Tilemap, Tilemap.SyncTile[]> tilemapAction = (tilemap, syncTiles) =>
|
|
{
|
|
count++;
|
|
Assert.AreEqual(tilemap, m_Tilemap);
|
|
};
|
|
|
|
GridPaintingState.gridBrush = gridBrush;
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(BoxTool));
|
|
SceneViewMouseEnter();
|
|
|
|
Tilemap.SetSyncTileCallback(tilemapAction);
|
|
SceneViewMouseDrag(new Vector2(75, 75), new Vector2(175, 175));
|
|
Tilemap.RemoveSyncTileCallback(tilemapAction);
|
|
Assert.AreEqual(1, count);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_BoxFillOnTilemap_GridBrushBoxFillsTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 2, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(1, 0, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 0, 0), m_TileA);
|
|
gridBrush.SetTile(new Vector3Int(0, 1, 0), m_TileB);
|
|
gridBrush.SetTile(new Vector3Int(2, 1, 0), m_TileA);
|
|
|
|
var targetPosition = new BoundsInt(5, 6, 0, 7, 7, 1);
|
|
gridBrush.BoxFill(m_Grid, Selection.activeGameObject, targetPosition);
|
|
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(0, 0, 0)));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(1, 0, 0)));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(2, 0, 0)));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(0, 1, 0)));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(1, 1, 0)));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(2, 1, 0)));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(3, 2, 0)));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(4, 2, 0)));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(5, 2, 0)));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(3, 3, 0)));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(4, 3, 0)));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(5, 3, 0)));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_BoxEraseOnTilemap_GridBrushBoxErasesTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(3, 5, 1));
|
|
var targetPosition = new BoundsInt(5, 5, 0, 3, 3, 1);
|
|
m_Tilemap.SetTile(targetPosition.min + new Vector3Int(0, 0, 0), m_TileA);
|
|
m_Tilemap.SetTile(targetPosition.min + new Vector3Int(1, 1, 0), m_TileA);
|
|
m_Tilemap.SetTile(targetPosition.min + new Vector3Int(2, 2, 0), m_TileA);
|
|
|
|
Selection.activeGameObject = m_TilemapGameObject;
|
|
gridBrush.BoxErase(m_Grid, Selection.activeGameObject, targetPosition);
|
|
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(0, 0, 0)));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(1, 1, 0)));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(targetPosition.min + new Vector3Int(2, 2, 0)));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_FloodFillOnTilemap_GridBrushFloodFillsTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(1, 1, 1));
|
|
|
|
Selection.activeGameObject = m_TilemapGameObject;
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
|
|
var targetPosition = Vector3Int.zero;
|
|
gridBrush.FloodFill(m_Grid, Selection.activeGameObject, targetPosition);
|
|
|
|
for (int y = m_Tilemap.origin.y; y < m_Tilemap.origin.y + m_Tilemap.size.y; ++y)
|
|
{
|
|
for (int x = m_Tilemap.origin.x; x < m_Tilemap.origin.x + m_Tilemap.size.x; ++x)
|
|
{
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(new Vector3Int(x, y, 0)));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_FloodFillOnTilemap_TriggersSyncTileOncePerCall()
|
|
{
|
|
int count = 0;
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(1, 1, 1));
|
|
|
|
gridBrush.SetTile(new Vector3Int(0, 0, 0), m_TileA);
|
|
|
|
System.Action<Tilemap, Tilemap.SyncTile[]> tilemapAction = (tilemap, syncTiles) =>
|
|
{
|
|
count++;
|
|
Assert.AreEqual(tilemap, m_Tilemap);
|
|
Assert.AreEqual(tilemap.size.x * tilemap.size.y, syncTiles.Length);
|
|
};
|
|
|
|
var targetPosition = Vector3Int.zero;
|
|
Tilemap.SetSyncTileCallback(tilemapAction);
|
|
gridBrush.FloodFill(m_Grid, Selection.activeGameObject, targetPosition);
|
|
Assert.AreEqual(1, count);
|
|
Tilemap.RemoveSyncTileCallback(tilemapAction);
|
|
}
|
|
|
|
[Test, Description("Case 1120310: Pick on an invalid (destroyed) GameObject Brush Target throws NullReferenceException")]
|
|
public void GridBrush_PickOnInvalidGameObject_ChangesSizeWithoutThrowingException()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
gridBrush.Init(new Vector3Int(1, 1, 1));
|
|
|
|
var size = new Vector3Int(3, 2, 1);
|
|
var targetPosition = new BoundsInt(Vector3Int.zero, size);
|
|
gridBrush.Pick(m_Grid, null, targetPosition, Vector3Int.zero);
|
|
|
|
Assert.AreEqual(size, gridBrush.size);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_SelectAndMoveOnTilemap_GridBrushMovesTilesOnTilemap()
|
|
{
|
|
var gridBrush = CreateScriptableObject<GridBrush>();
|
|
m_TilemapGameObject.transform.position = new Vector3(0.5f, 0.5f, 0f);
|
|
|
|
var startPosition = new Vector3Int(0, 0, 0);
|
|
var toPosition = new Vector3Int(0, 1, 0);
|
|
var startBounds = new BoundsInt(startPosition, new Vector3Int(2, 1, 1));
|
|
var toBounds = new BoundsInt(toPosition, new Vector3Int(2, 1, 1));
|
|
|
|
m_Tilemap.SetTile(startPosition, m_TileA);
|
|
m_Tilemap.SetTile(startPosition + Vector3Int.right, m_TileB);
|
|
|
|
gridBrush.Select(m_Grid, Selection.activeGameObject, new BoundsInt(startPosition, new Vector3Int(2, 1, 1)));
|
|
gridBrush.MoveStart(m_Grid, Selection.activeGameObject,
|
|
new BoundsInt(startPosition, new Vector3Int(2, 1, 1)));
|
|
gridBrush.Move(m_Grid, Selection.activeGameObject, startBounds, toBounds);
|
|
gridBrush.MoveEnd(m_Grid, Selection.activeGameObject, new BoundsInt(toPosition, new Vector3Int(2, 1, 1)));
|
|
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(startPosition));
|
|
Assert.AreEqual(null, m_Tilemap.GetTile(startPosition + Vector3Int.right));
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(toPosition));
|
|
Assert.AreEqual(m_TileB, m_Tilemap.GetTile(toPosition + Vector3Int.right));
|
|
}
|
|
|
|
[Test, Description("case 1117888: Prefab Mode with Auto-Save triggers a GridPaintingState Flush which should clean up previews.")]
|
|
public void GridBrush_PaintPreview_FlushGridPaintingState_CleansUpPaintPreview()
|
|
{
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
|
|
Assert.NotNull(gridBrush, "Default Brush is not a GridBrush");
|
|
gridBrush.Init(Vector3Int.one);
|
|
gridBrush.cells[0].tile = m_TileA;
|
|
|
|
GridPaintingState.scenePaintTarget = m_TilemapGameObject;
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseMove(new Vector2(100, 100));
|
|
|
|
var bounds = new BoundsInt(m_Tilemap.editorPreviewOrigin, m_Tilemap.editorPreviewSize);
|
|
var previewTile = m_Tilemap.editorPreviewOrigin;
|
|
foreach (var position in bounds.allPositionsWithin)
|
|
{
|
|
if (m_Tilemap.HasEditorPreviewTile(position))
|
|
{
|
|
previewTile = position;
|
|
break;
|
|
}
|
|
}
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetEditorPreviewTile(previewTile));
|
|
m_Tilemap.SetTile(previewTile + Vector3Int.right, m_TileB);
|
|
|
|
GridPaintingState.FlushCache();
|
|
|
|
Assert.AreNotEqual(m_TileA, m_Tilemap.GetEditorPreviewTile(previewTile));
|
|
Assert.IsNull(m_Tilemap.GetEditorPreviewTile(previewTile));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_PaintStartUpTileAndMove_StartsUpTileOnce()
|
|
{
|
|
var tile = ScriptableObject.CreateInstance<StartUpTile>();
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
|
|
Assert.NotNull(gridBrush, "Default Brush is not a GridBrush");
|
|
gridBrush.Init(Vector3Int.one);
|
|
gridBrush.cells[0].tile = tile;
|
|
|
|
GridPaintingState.scenePaintTarget = m_TilemapGameObject;
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseMove(new Vector2(100, 100));
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
SceneViewMouseMove(new Vector2(300, 300));
|
|
|
|
Assert.AreEqual(1, StartUpTile.startUpCalls,
|
|
"Start Up calls are not called only once when painting only on StartUp tile");
|
|
StartUpTile.startUpCalls = 0; // Reset StartUpTile
|
|
}
|
|
|
|
[Test, Description("Case 1119051: When Grid Swizzle is set, use Grid Forward with Tilemap transform instead of Tile Orientation")]
|
|
public void GridBrush_PickPaintCell_PicksCorrectCellForSwizzledGrid()
|
|
{
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
|
|
Assert.NotNull(gridBrush, "Default Brush is not a GridBrush");
|
|
gridBrush.Init(Vector3Int.one);
|
|
gridBrush.cells[0].tile = m_TileA;
|
|
|
|
m_Tilemap.layoutGrid.cellSwizzle = GridLayout.CellSwizzle.XZY;
|
|
m_TilemapGameObject.transform.rotation = Quaternion.Euler(45, 30, 0);
|
|
|
|
GridPaintingState.scenePaintTarget = m_TilemapGameObject;
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
var bounds = new BoundsInt(m_Tilemap.origin, m_Tilemap.size);
|
|
var tilePosition = m_Tilemap.origin;
|
|
|
|
foreach (var position in bounds.allPositionsWithin)
|
|
{
|
|
if (m_Tilemap.HasTile(position))
|
|
{
|
|
tilePosition = position;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Assert.AreEqual(m_TileA, m_Tilemap.GetTile(tilePosition));
|
|
Assert.AreNotEqual(0, tilePosition.y);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrush_HasAGridBrushEditor()
|
|
{
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
Assert.IsNotNull(gridBrush);
|
|
var gridBrushEditor = Editor.CreateEditor(gridBrush) as GridBrushEditor;
|
|
Assert.IsNotNull(gridBrushEditor);
|
|
}
|
|
|
|
[TestCase(true)]
|
|
[TestCase(false)]
|
|
[Test]
|
|
public void GridBrushEditor_CanSetCanChangeZPosition(bool canChangeZPosition)
|
|
{
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
var gridBrushEditor = Editor.CreateEditor(gridBrush) as GridBrushEditor;
|
|
gridBrushEditor.canChangeZPosition = canChangeZPosition;
|
|
Assert.AreEqual(canChangeZPosition, gridBrushEditor.canChangeZPosition);
|
|
}
|
|
|
|
[TestCase(true, 1)]
|
|
[TestCase(false, 0)]
|
|
[Test]
|
|
public void GridBrush_IncreaseZPositionShortcut_IncreaseZPositionMethodCalled(bool canChangeZPosition, int zPosition)
|
|
{
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
gridBrush.canChangeZPosition = canChangeZPosition;
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PickingTool));
|
|
SceneViewMouseEnter();
|
|
// Default Keyboard shortcut is Minus
|
|
KeyboardEvent(KeyCode.Minus);
|
|
|
|
Assert.AreEqual(zPosition, GridPaintingState.lastActiveGrid.zPosition);
|
|
}
|
|
|
|
[TestCase(true, -1)]
|
|
[TestCase(false, 0)]
|
|
[Test]
|
|
public void GridBrush_DecreaseZPositionShortcut_DecreaseZPositionMethodCalled(bool canChangeZPosition, int zPosition)
|
|
{
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
gridBrush.canChangeZPosition = canChangeZPosition;
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PickingTool));
|
|
SceneViewMouseEnter();
|
|
// Default Keyboard shortcut is Equals
|
|
KeyboardEvent(KeyCode.Equals);
|
|
|
|
Assert.AreEqual(zPosition, GridPaintingState.lastActiveGrid.zPosition);
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrushEditor_PicksAllValidTilemapsAsTargets()
|
|
{
|
|
var tilemapGameObjectB = CreateTilemapGameObject();
|
|
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
var gridBrushEditor = Editor.CreateEditor(gridBrush) as GridBrushEditor;
|
|
|
|
var validTargets = gridBrushEditor.validTargets;
|
|
Assert.AreEqual(2, validTargets.Length);
|
|
Assert.IsTrue(validTargets.Contains(m_TilemapGameObject));
|
|
Assert.IsTrue(validTargets.Contains(tilemapGameObjectB));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrushEditor_PicksAllActiveTilemapsAsTargets()
|
|
{
|
|
var tilemapGameObjectB = CreateTilemapGameObject();
|
|
tilemapGameObjectB.SetActive(false);
|
|
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
var gridBrushEditor = Editor.CreateEditor(gridBrush) as GridBrushEditor;
|
|
|
|
var validTargets = gridBrushEditor.validTargets;
|
|
Assert.AreEqual(1, validTargets.Length);
|
|
Assert.IsTrue(validTargets.Contains(m_TilemapGameObject));
|
|
Assert.IsFalse(validTargets.Contains(tilemapGameObjectB));
|
|
}
|
|
|
|
[Test]
|
|
public void GridBrushEditor_PicksAllActiveInHierarchyTilemapsAsTargets()
|
|
{
|
|
var tilemapGameObjectB = CreateTilemapGameObject();
|
|
|
|
var gameObjectC = CreateGameObject();
|
|
tilemapGameObjectB.transform.parent = gameObjectC.transform;
|
|
gameObjectC.SetActive(false);
|
|
|
|
var gridBrush = GridPaintingState.gridBrush as GridBrush;
|
|
var gridBrushEditor = Editor.CreateEditor(gridBrush) as GridBrushEditor;
|
|
|
|
var validTargets = gridBrushEditor.validTargets;
|
|
Assert.AreEqual(1, validTargets.Length);
|
|
Assert.IsTrue(validTargets.Contains(m_TilemapGameObject));
|
|
Assert.IsFalse(validTargets.Contains(tilemapGameObjectB));
|
|
Assert.IsFalse(validTargets.Contains(gameObjectC));
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_PaintOnTarget_CustomPaintMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "Paint");
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator CustomGridBrush_GridSwizzledParallelToView_PaintOnTarget_CustomPaintMethodNotCalled()
|
|
{
|
|
m_Grid.cellSwizzle = GridLayout.CellSwizzle.YZX;
|
|
yield return null;
|
|
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "");
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator CustomGridBrush_GridTransformParallelToView_PaintOnTarget_CustomPaintMethodNotCalled()
|
|
{
|
|
m_Grid.transform.rotation = Quaternion.Euler(0f, 90f, 0f);
|
|
yield return null;
|
|
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_EraseOnTarget_CustomEraseMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(EraseTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "Erase");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_BoxFillOnTarget_CustomBoxFillMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(BoxTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "BoxFill");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_BoxEraseOnTarget_CustomBoxEraseMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(BoxTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), true);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "BoxErase");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_PickOnTarget_CustomPickMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PickingTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "Pick");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_SelectOnTarget_CustomSelectMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(SelectTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "Select");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_IsSetAsLastUsedSessionBrush()
|
|
{
|
|
var defaultBrush = GridPaintingState.gridBrush;
|
|
Assert.AreEqual(GridPaletteBrushes.brushes.IndexOf(defaultBrush), SessionState.GetInt(GridPaletteBrushes.s_SessionStateLastUsedBrush, -1));
|
|
|
|
var brush = SetupCustomBrush();
|
|
|
|
Assert.AreNotEqual(defaultBrush, brush);
|
|
Assert.AreEqual(GridPaletteBrushes.brushes.IndexOf(GridPaintingState.gridBrush), SessionState.GetInt(GridPaletteBrushes.s_SessionStateLastUsedBrush, -1));
|
|
Assert.AreEqual(brush, GridPaintingState.gridBrush);
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_MoveOnTarget_CustomSelectAndMoveMethodsCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(SelectTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseDrag(new Vector2(75, 75), new Vector2(175, 175));
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(MoveTool));
|
|
brush.m_LastCalledMethod = "";
|
|
brush.m_LastCalledEditorMethods.Clear();
|
|
brush.m_LastCalledMethods.Clear();
|
|
SceneViewMouseDrag(new Vector2(125, 125), new Vector2(200, 200));
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethods[0], "MoveStart");
|
|
for (int i = 1; i < brush.m_LastCalledEditorMethods.Count - 1; i++)
|
|
Assert.AreEqual(brush.m_LastCalledMethods[i], "Move");
|
|
Assert.AreEqual(brush.m_LastCalledMethods[brush.m_LastCalledMethods.Count - 1], "MoveEnd");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_FloodFillOnTarget_CustomFloodFillMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(FillTool));
|
|
SceneViewMouseEnter();
|
|
SceneViewMouseClick(new Vector2(100, 100), false);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "FloodFill");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_IncreaseZPositionShortcut_IncreaseZPositionMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PickingTool));
|
|
SceneViewMouseEnter();
|
|
// Default Keyboard shortcut is Minus
|
|
KeyboardEvent(KeyCode.Minus);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "ChangeZPosition 1");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_DecreaseZPositionShortcut_DecreaseZPositionMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PickingTool));
|
|
SceneViewMouseEnter();
|
|
// Default Keyboard shortcut is Equals
|
|
KeyboardEvent(KeyCode.Equals);
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "ChangeZPosition -1");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_ResetZPosition_ResetZPositionMethodCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PickingTool));
|
|
SceneViewMouseEnter();
|
|
s_PaletteWindow.ResetZPosition();
|
|
|
|
Assert.AreEqual(brush.m_LastCalledMethod, "ResetZPosition");
|
|
}
|
|
|
|
[Test]
|
|
public void CustomGridBrush_EditorOnToolActivatedAndDeactivated_CustomActivateAndDeactivateMethodsCalled()
|
|
{
|
|
var brush = SetupCustomBrush();
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(BoxTool));
|
|
Assert.AreEqual("OnToolActivated_" + GridBrushBase.Tool.Box.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 1]);
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(EraseTool));
|
|
Assert.AreEqual("OnToolDeactivated_" + GridBrushBase.Tool.Box.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 2]);
|
|
Assert.AreEqual("OnToolActivated_" + GridBrushBase.Tool.Erase.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 1]);
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(FillTool));
|
|
Assert.AreEqual("OnToolDeactivated_" + GridBrushBase.Tool.Erase.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 2]);
|
|
Assert.AreEqual("OnToolActivated_" + GridBrushBase.Tool.FloodFill.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 1]);
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
Assert.AreEqual("OnToolDeactivated_" + GridBrushBase.Tool.FloodFill.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 2]);
|
|
Assert.AreEqual("OnToolActivated_" + GridBrushBase.Tool.Paint.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 1]);
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PickingTool));
|
|
Assert.AreEqual("OnToolDeactivated_" + GridBrushBase.Tool.Paint.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 2]);
|
|
Assert.AreEqual("OnToolActivated_" + GridBrushBase.Tool.Pick.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 1]);
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(SelectTool));
|
|
Assert.AreEqual("OnToolDeactivated_" + GridBrushBase.Tool.Pick.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 2]);
|
|
Assert.AreEqual("OnToolActivated_" + GridBrushBase.Tool.Select.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 1]);
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(MoveTool));
|
|
Assert.AreEqual("OnToolDeactivated_" + GridBrushBase.Tool.Select.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 2]);
|
|
Assert.AreEqual("OnToolActivated_" + GridBrushBase.Tool.Move.ToString(),
|
|
brush.m_LastCalledEditorMethods[brush.m_LastCalledEditorMethods.Count - 1]);
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator CustomGridBrush_WithNoValidTargets_CreateNewObject_MaintainsActiveTarget()
|
|
{
|
|
Selection.activeGameObject = null;
|
|
m_TilemapGameObject.name = MyBrushEditor.invalidName;
|
|
|
|
SetupCustomBrush();
|
|
TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));
|
|
SceneViewMouseEnter();
|
|
|
|
Selection.activeGameObject = m_TilemapGameObject;
|
|
|
|
// Force OnSelectionChanged to trigger for Editor
|
|
Selection.selectionChanged();
|
|
|
|
Assert.IsTrue(GridPaintingState.validTargets == null || GridPaintingState.validTargets.Length == 0);
|
|
Assert.AreEqual(m_TilemapGameObject, GridPaintingState.scenePaintTarget);
|
|
|
|
CreateGameObject();
|
|
|
|
// Wait for Editor to trigger OnHierarchyChanged
|
|
yield return null;
|
|
yield return null;
|
|
|
|
Assert.IsTrue(GridPaintingState.validTargets == null || GridPaintingState.validTargets.Length == 0);
|
|
Assert.AreEqual(m_TilemapGameObject, GridPaintingState.scenePaintTarget);
|
|
}
|
|
|
|
private void ResetSceneViewWindowPosition()
|
|
{
|
|
s_SceneView.position = new Rect(10f, 10f, 400f, 300f);
|
|
}
|
|
|
|
private void ResetPaletteWindowPosition()
|
|
{
|
|
s_PaletteWindow.position = new Rect(40f, 10f, 400f, 300f);
|
|
}
|
|
|
|
private void ResetSceneViewCamera()
|
|
{
|
|
s_SceneView.in2DMode = true;
|
|
s_SceneView.pivot = new Vector3(0f, 0f, -10f);
|
|
s_SceneView.rotation = Quaternion.identity;
|
|
s_SceneView.size = 6.0f;
|
|
s_SceneView.orthographic = true;
|
|
}
|
|
|
|
private EditorWindow SelectAndFocusSceneView()
|
|
{
|
|
EditorWindow window = SceneView.sceneViews[0] as EditorWindow;
|
|
if (!window.hasFocus)
|
|
window.Focus();
|
|
return window;
|
|
}
|
|
|
|
private void KeyboardEvent(KeyCode keyCode)
|
|
{
|
|
var window = SelectAndFocusSceneView();
|
|
var ev = new Event();
|
|
ev.keyCode = keyCode;
|
|
ev.type = EventType.KeyDown;
|
|
window.SendEvent(ev);
|
|
ev.type = EventType.KeyUp;
|
|
window.SendEvent(ev);
|
|
}
|
|
|
|
private void SceneViewMouseClick(Vector2 position, bool shift)
|
|
{
|
|
var window = SelectAndFocusSceneView();
|
|
var ev = new Event();
|
|
ev.shift = shift;
|
|
ev.mousePosition = position;
|
|
ev.type = EventType.MouseDown;
|
|
window.SendEvent(ev);
|
|
ev.type = EventType.MouseUp;
|
|
window.SendEvent(ev);
|
|
}
|
|
|
|
private void SceneViewMouseMove(Vector2 position)
|
|
{
|
|
var window = SelectAndFocusSceneView();
|
|
var ev = new Event();
|
|
ev.mousePosition = position;
|
|
ev.type = EventType.MouseMove;
|
|
window.SendEvent(ev);
|
|
}
|
|
|
|
private void SceneViewMouseDrag(Vector2 from, Vector2 to)
|
|
{
|
|
const int dragSteps = 5;
|
|
var window = SelectAndFocusSceneView();
|
|
var ev = new Event();
|
|
ev.mousePosition = from;
|
|
ev.type = EventType.MouseDown;
|
|
window.SendEvent(ev);
|
|
|
|
for (int i = 0; i < dragSteps; i++)
|
|
{
|
|
ev.mousePosition = Vector2.Lerp(from, to, (float)i / (float)dragSteps);
|
|
ev.type = EventType.MouseDrag;
|
|
window.SendEvent(ev);
|
|
}
|
|
|
|
ev.mousePosition = to;
|
|
ev.type = EventType.MouseUp;
|
|
window.SendEvent(ev);
|
|
}
|
|
|
|
private void SceneViewMouseEnter()
|
|
{
|
|
var window = SelectAndFocusSceneView();
|
|
var ev = new Event();
|
|
ev.type = EventType.MouseEnterWindow;
|
|
window.SendEvent(ev);
|
|
}
|
|
}
|
|
}
|