protected override IWorldCommand GetActionCommand(Vector2 mousePosition)
{
int selectedIndex = Input.GetButton("InverseFunction") ? TileIndex.New : index;
Vector2Int endCoords = TileTransformer.ScreenToCoord(mousePosition);
return(new PaintAreaCmd(level, dragStartCoords.x, endCoords.x, dragStartCoords.y, endCoords.y, selectedIndex));
}
public void CoordToWorldMapping()
{
OrientationManager.SetOrientation(Orientation.North);
Vector2Int coord1 = new Vector2Int(74, -23);
Vector2Int coord2 = new Vector2Int(-33, 13);
Vector2Int coord3 = new Vector2Int(93, 0);
Vector2 expectedWorldPos1 = new Vector2(
-98 * Settings.TILE_WIDTH_HALF,
-51 * Settings.TILE_HEIGHT_HALF);
Assert.AreEqual(TileTransformer.CoordToWorld(coord1), expectedWorldPos1);
Assert.AreEqual(TileTransformer.CoordToWorld(coord1.x, coord1.y), expectedWorldPos1);
Assert.AreEqual(TileTransformer.CoordToWorld((float)coord1.x, (float)coord1.y), expectedWorldPos1);
Vector2 expectedWorldPos2 = new Vector2(
45 * Settings.TILE_WIDTH_HALF,
20 * Settings.TILE_HEIGHT_HALF);
Assert.AreEqual(TileTransformer.CoordToWorld(coord2), expectedWorldPos2);
Assert.AreEqual(TileTransformer.CoordToWorld(coord2.x, coord2.y), expectedWorldPos2);
Assert.AreEqual(TileTransformer.CoordToWorld((float)coord2.x, (float)coord2.y), expectedWorldPos2);
Vector2 expectedWorldPos3 = new Vector2(
-94 * Settings.TILE_WIDTH_HALF,
-93 * Settings.TILE_HEIGHT_HALF);
Assert.AreEqual(TileTransformer.CoordToWorld(coord3), expectedWorldPos3);
Assert.AreEqual(TileTransformer.CoordToWorld(coord3.x, coord3.y), expectedWorldPos3);
Assert.AreEqual(TileTransformer.CoordToWorld((float)coord3.x, (float)coord3.y), expectedWorldPos3);
}
public void UpdateSprite()
{
Vector2 rotatedOffset = TileTransformer.InverseRotateCoord(new Vector2(xOffset, yOffset));
transform.position = TileTransformer.CoordToWorld(character.x + rotatedOffset.x, character.y + rotatedOffset.y);
SpriteRenderer sr = GetComponent <SpriteRenderer>();
sr.sortingOrder = SortingOrders.TileOrder(character.roundedX, character.roundedY, TileSubLayer.Character);
}
public void FloatRotationsKeepDecimals()
{
Vector2 coord1 = new Vector2(39.4f, 12.2f);
Assert.AreEqual(TileTransformer.RotateCoord(coord1), new Vector2(39.4f, 12.2f));
Assert.AreEqual(TileTransformer.InverseRotateCoord(coord1), new Vector2(39.4f, 12.2f));
OrientationManager.SetOrientation(Orientation.West);
Assert.AreEqual(TileTransformer.RotateCoord(coord1), new Vector2(12.2f, -39.4f));
Assert.AreEqual(TileTransformer.InverseRotateCoord(coord1), new Vector2(-12.2f, 39.4f));
}
public void WorldToCoordRotates()
{
OrientationManager.SetOrientation(Orientation.North);
Vector2Int coords = new Vector2Int(13, -33);
Vector2 world = TileTransformer.CoordToWorld(coords) + new Vector2(Settings.TILE_WIDTH_HALF / 2f, 0f);
Vector2Int invertedCoords = TileTransformer.WorldToCoord(world);
OrientationManager.SetOrientation(Orientation.West);
Assert.AreEqual(TileTransformer.InverseRotateCoord(invertedCoords), TileTransformer.WorldToCoord(world));
}
public void RegularRotationBehaviour()
{
Vector2Int coord = new Vector2Int(34, -21);
OrientationManager.SetOrientation(Orientation.East);
Assert.AreEqual(TileTransformer.RotateCoord(coord), new Vector2Int(21, 34));
OrientationManager.SetOrientation(Orientation.West);
Assert.AreEqual(TileTransformer.RotateCoord(coord), new Vector2Int(-21, -34));
OrientationManager.SetOrientation(Orientation.South);
Assert.AreEqual(TileTransformer.RotateCoord(coord), new Vector2Int(-34, 21));
}
public void InverseRotationBehaviour()
{
Vector2Int coord = new Vector2Int(-45, -23);
OrientationManager.SetOrientation(Orientation.East);
Assert.AreEqual(TileTransformer.InverseRotateCoord(coord), new Vector2Int(-23, 45));
OrientationManager.SetOrientation(Orientation.West);
Assert.AreEqual(TileTransformer.InverseRotateCoord(coord), new Vector2Int(23, -45));
OrientationManager.SetOrientation(Orientation.South);
Assert.AreEqual(TileTransformer.InverseRotateCoord(coord), new Vector2Int(45, 23));
}
public CollageGenerator(CollageSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
this.progressCounter = new ProgressCounter(settings.Dimensions.NumberOfRows, settings.Dimensions.NumberOfColumns);
this.randomGenerator = new RandomGenerator();
this.tileTransformer = new TileTransformer();
this.filesEnumerator = new DateFilesEnumerator(settings.InputFiles);
this.collageSaver = new CollageSaver(settings.OutputDirectory);
}
protected override IWorldCommand GetActionCommand(Vector2 mousePosition)
{
Vector2Int tilePos = TileTransformer.ScreenToCoord(mousePosition);
ITile tile = level.GetTileAt(tilePos.x, tilePos.y);
if (Input.GetButton("InverseFunction"))
{
return(new RemoveFurnitureCommand(level, tilePos.x, tilePos.y));
}
IFurniture furniture = new DecorationFurniture(index, level, tile, orientation);
return(new PlaceFurnitureCommand(level, tilePos.x, tilePos.y, furniture));
}
public void NorthRotationIsIdentity()
{
OrientationManager.SetOrientation(Orientation.North);
Vector2Int coord1 = new Vector2Int(73, 12);
Vector2Int coord2 = new Vector2Int(-89, 22);
Vector2Int coord3 = new Vector2Int(10, -4);
Assert.AreEqual(coord1, TileTransformer.RotateCoord(coord1));
Assert.AreEqual(coord2, TileTransformer.RotateCoord(coord2));
Assert.AreEqual(coord3, TileTransformer.RotateCoord(coord3));
Assert.AreEqual(coord1, TileTransformer.InverseRotateCoord(coord1));
Assert.AreEqual(coord2, TileTransformer.InverseRotateCoord(coord2));
Assert.AreEqual(coord3, TileTransformer.InverseRotateCoord(coord3));
}
void UpdateSprite(ITile tile)
{
if (gameobjects.ContainsKey(tile) == false)
{
Debug.LogError("Trying to update a furni without a gameobject created.");
return;
}
GameObject furni_go = gameobjects[tile];
furni_go.transform.position = (Vector3)TileTransformer.CoordToWorld(tile.X, tile.Y);
SpriteRenderer sr = furni_go.GetComponent <SpriteRenderer>();
sr.sprite = DataManager.furnitureSpriteData.GetDataById(tile.GetPlacedFurniture().GetIndex()).GetSprite(tile.GetPlacedFurniture());
sr.sortingOrder = SortingOrders.TileOrder(tile.X, tile.Y, TileSubLayer.Furniture);
}
void UpdateSprite(ITile tile)
{
if (gameobjects.ContainsKey(tile) == false)
{
Debug.LogError("Trying to update a tile without a gameobject created.");
return;
}
GameObject tile_go = gameobjects[tile];
tile_go.transform.position = (Vector3)TileTransformer.CoordToWorld(tile.X, tile.Y);
SpriteRenderer sr = tile_go.GetComponent <SpriteRenderer>();
sr.sprite = DataManager.tileSpriteData.GetDataById(tile.Type);
sr.sortingOrder = SortingOrders.FloorOrder(tile.X, tile.Y, FloorSubLayer.FloorTile);
}
public override void UpdateCursors(Vector2 mousePosition)
{
Vector2Int coords = TileTransformer.ScreenToCoord(mousePosition);
if (level.IsTileInBounds(coords.x, coords.y))
{
mainCursorSr.enabled = true;
mainCursorSr.sortingOrder = SortingOrders.FloorOrder(coords.x, coords.y, FloorSubLayer.Cursor);
mainCursorGo.transform.position = TileTransformer.CoordToWorld(coords);
mainCursorSr.sprite = GetCursorSprite(coords);
}
else
{
mainCursorSr.enabled = false;
}
return;
}
public override void UpdateCursors(Vector2 mousePosition)
{
Vector2Int tilePos = TileTransformer.ScreenToCoord(mousePosition);
if (level.IsTileInBounds(tilePos.x, tilePos.y))
{
mainCursorSr.enabled = true;
mainCursorSr.sortingOrder = SortingOrders.TileOrder(tilePos.x, tilePos.y, TileSubLayer.Furniture);
IFurnitureSprite sprite = DataManager.furnitureSpriteData.GetDataById(index);
mainCursorSr.sprite = sprite.GetSprite(orientation);
mainCursorGo.transform.position = TileTransformer.CoordToWorld(tilePos);
}
else
{
mainCursorSr.enabled = false;
}
}
public void Update()
{
if (showMouseCoordinates)
{
Vector2Int tileCoords = TileTransformer.ScreenToCoord(Input.mousePosition);
Vector3Int wallCoords = WallTransformer.ScreenToCoord(Input.mousePosition);
debugTextField.text = string.Format(
"Tile Coord: {0}, {1}\nWall Coord: {2}, {3}, {4}\nOrientation: {5}",
tileCoords.x,
tileCoords.y,
wallCoords.x,
wallCoords.y,
wallCoords.z,
OrientationManager.currentOrientation);
}
else
{
debugTextField.text = "";
}
}
public override void UpdateCursors(Vector2 mousePosition)
{
base.UpdateCursors(mousePosition);
while (activeStaticCursors.Count > 0)
{
SimplePool.Despawn(activeStaticCursors.Pop());
}
if (!validClickStart)
{
return;
}
Vector2Int startCoords = dragStartCoords;
Vector2Int endCoords = TileTransformer.ScreenToCoord(mousePosition);
Vector2Int minCoords = CoordUtil.MinCoords(startCoords, endCoords);
Vector2Int maxCoords = CoordUtil.MaxCoords(startCoords, endCoords);
GameObject cursorPrefab = Resources.Load <GameObject> (GamePaths.CursorPrefab);
for (int x = minCoords.x; x <= maxCoords.x; x++)
{
for (int y = minCoords.y; y <= maxCoords.y; y++)
{
Vector3 pos = TileTransformer.CoordToWorld(x, y);
GameObject staticCursorGo = SimplePool.Spawn(cursorPrefab, pos, Quaternion.identity);
SpriteRenderer staticCursorSr = staticCursorGo.GetComponent <SpriteRenderer> ();
staticCursorSr.sprite = GetCursorSprite(new Vector2Int(x, y));
staticCursorSr.sortingLayerName = mainCursorSr.sortingLayerName;
staticCursorSr.sortingOrder = SortingOrders.FloorOrder(x, y, FloorSubLayer.Cursor);
activeStaticCursors.Push(staticCursorGo);
}
}
return;
}
public void WorldToCoordRounds()
{
OrientationManager.SetOrientation(Orientation.North);
Vector2Int coords1 = new Vector2Int(42, 0);
Vector2Int coords2 = new Vector2Int(-11, -63);
Vector2Int coords3 = new Vector2Int(-52, 53);
Vector2 world1 = TileTransformer.CoordToWorld(coords1) +
new Vector2(Settings.TILE_WIDTH / 6f, Settings.TILE_HEIGHT / 9f);
Vector2 world2 = TileTransformer.CoordToWorld(coords2) +
new Vector2(Settings.TILE_WIDTH / 3f, 0f);
// This test adds a big offset so the coords change.
Vector2 world3 = TileTransformer.CoordToWorld(coords3) +
new Vector2(Settings.TILE_WIDTH_HALF, Settings.TILE_HEIGHT * 0.9f);
Assert.AreEqual(coords1, TileTransformer.WorldToCoord(world1));
Assert.AreEqual(coords2, TileTransformer.WorldToCoord(world2));
Assert.AreEqual(coords3, TileTransformer.WorldToCoord(world3) + Vector2Int.one);
}
public void CoordToWorldRotates()
{
OrientationManager.SetOrientation(Orientation.North);
Vector2Int originalCoord = new Vector2Int(77, 23);
Vector2 originalWorld = TileTransformer.CoordToWorld(originalCoord);
OrientationManager.SetOrientation(Orientation.East);
Vector2Int eastCoord = TileTransformer.RotateCoord(originalCoord);
Vector2 eastWorldFromOriginal = TileTransformer.CoordToWorld(originalCoord);
OrientationManager.SetOrientation(Orientation.West);
Vector2Int westCoord = TileTransformer.RotateCoord(originalCoord);
Vector2 westWorldFromOriginal = TileTransformer.CoordToWorld(originalCoord);
OrientationManager.SetOrientation(Orientation.South);
Vector2Int southCoord = TileTransformer.RotateCoord(originalCoord);
Vector2 southWorldFromOriginal = TileTransformer.CoordToWorld(originalCoord);
OrientationManager.SetOrientation(Orientation.North);
Assert.AreEqual(TileTransformer.CoordToWorld(eastCoord), eastWorldFromOriginal);
Assert.AreEqual(TileTransformer.CoordToWorld(westCoord), westWorldFromOriginal);
Assert.AreEqual(TileTransformer.CoordToWorld(southCoord), southWorldFromOriginal);
}
public void UpdatePosition()
{
gameObject.transform.position = TileTransformer.CoordToWorld(character.x, character.y);
}
public void TileRotationIsInvertible()
{
Vector2Int coord1 = new Vector2Int(13, 32);
Vector2Int coord2 = new Vector2Int(-42, 78);
Vector2Int coord3 = new Vector2Int(-81, -70);
// North
OrientationManager.SetOrientation(Orientation.North);
Vector2Int rotated1 = TileTransformer.RotateCoord(coord1);
Vector2Int rotated2 = TileTransformer.RotateCoord(coord2);
Vector2Int rotated3 = TileTransformer.RotateCoord(coord3);
Vector2Int inverseRotated1 = TileTransformer.InverseRotateCoord(coord1);
Vector2Int inverseRotated2 = TileTransformer.InverseRotateCoord(coord2);
Vector2Int inverseRotated3 = TileTransformer.InverseRotateCoord(coord3);
Assert.AreEqual(coord1, TileTransformer.InverseRotateCoord(rotated1));
Assert.AreEqual(coord2, TileTransformer.InverseRotateCoord(rotated2));
Assert.AreEqual(coord3, TileTransformer.InverseRotateCoord(rotated3));
Assert.AreEqual(coord1, TileTransformer.RotateCoord(inverseRotated1));
Assert.AreEqual(coord2, TileTransformer.RotateCoord(inverseRotated2));
Assert.AreEqual(coord3, TileTransformer.RotateCoord(inverseRotated3));
// East
OrientationManager.SetOrientation(Orientation.East);
rotated1 = TileTransformer.RotateCoord(coord1);
rotated2 = TileTransformer.RotateCoord(coord2);
rotated3 = TileTransformer.RotateCoord(coord3);
inverseRotated1 = TileTransformer.InverseRotateCoord(coord1);
inverseRotated2 = TileTransformer.InverseRotateCoord(coord2);
inverseRotated3 = TileTransformer.InverseRotateCoord(coord3);
Assert.AreEqual(coord1, TileTransformer.InverseRotateCoord(rotated1));
Assert.AreEqual(coord2, TileTransformer.InverseRotateCoord(rotated2));
Assert.AreEqual(coord3, TileTransformer.InverseRotateCoord(rotated3));
Assert.AreEqual(coord1, TileTransformer.RotateCoord(inverseRotated1));
Assert.AreEqual(coord2, TileTransformer.RotateCoord(inverseRotated2));
Assert.AreEqual(coord3, TileTransformer.RotateCoord(inverseRotated3));
// West
OrientationManager.SetOrientation(Orientation.West);
rotated1 = TileTransformer.RotateCoord(coord1);
rotated2 = TileTransformer.RotateCoord(coord2);
rotated3 = TileTransformer.RotateCoord(coord3);
inverseRotated1 = TileTransformer.InverseRotateCoord(coord1);
inverseRotated2 = TileTransformer.InverseRotateCoord(coord2);
inverseRotated3 = TileTransformer.InverseRotateCoord(coord3);
Assert.AreEqual(coord1, TileTransformer.InverseRotateCoord(rotated1));
Assert.AreEqual(coord2, TileTransformer.InverseRotateCoord(rotated2));
Assert.AreEqual(coord3, TileTransformer.InverseRotateCoord(rotated3));
Assert.AreEqual(coord1, TileTransformer.RotateCoord(inverseRotated1));
Assert.AreEqual(coord2, TileTransformer.RotateCoord(inverseRotated2));
Assert.AreEqual(coord3, TileTransformer.RotateCoord(inverseRotated3));
// South
OrientationManager.SetOrientation(Orientation.South);
rotated1 = TileTransformer.RotateCoord(coord1);
rotated2 = TileTransformer.RotateCoord(coord2);
rotated3 = TileTransformer.RotateCoord(coord3);
inverseRotated1 = TileTransformer.InverseRotateCoord(coord1);
inverseRotated2 = TileTransformer.InverseRotateCoord(coord2);
inverseRotated3 = TileTransformer.InverseRotateCoord(coord3);
Assert.AreEqual(coord1, TileTransformer.InverseRotateCoord(rotated1));
Assert.AreEqual(coord2, TileTransformer.InverseRotateCoord(rotated2));
Assert.AreEqual(coord3, TileTransformer.InverseRotateCoord(rotated3));
Assert.AreEqual(coord1, TileTransformer.RotateCoord(inverseRotated1));
Assert.AreEqual(coord2, TileTransformer.RotateCoord(inverseRotated2));
Assert.AreEqual(coord3, TileTransformer.RotateCoord(inverseRotated3));
}
private bool GetClippingForWall(IWall wall)
{
if (wall.Type == WallIndex.Empty)
{
return(true);
}
if (currentClipping == ClippingMode.FULL_CLIPPING)
{
return(true);
}
if (currentClipping == ClippingMode.NO_CLIP)
{
return(false);
}
Vector2Int baseTileCoords = WallTransformer.GetRotatedWallBase(new Vector3Int(wall.X, wall.Y, wall.Z));
Vector3Int rotatedWallCoords = WallTransformer.RotateInsideTile(new Vector3Int(wall.X, wall.Y, wall.Z));
ITile baseTile = level.GetTileAt(baseTileCoords.x, baseTileCoords.y);
List <ITile> tiles = new List <ITile>();
if (rotatedWallCoords.z == 1)
{
//The tiles checked for wall clipping,
Vector2Int rotatedOffset1 = TileTransformer.InverseRotateCoord(new Vector2Int(-1, 0));
Vector2Int rotatedOffSet2 = TileTransformer.InverseRotateCoord(new Vector2Int(-1, -1));
Vector2Int rotatedOffSet3 = TileTransformer.InverseRotateCoord(new Vector2Int(-2, -1));
Vector2Int rotatedOffset4 = TileTransformer.InverseRotateCoord(new Vector2Int(-2, -2));
Vector2Int rotatedOffset5 = TileTransformer.InverseRotateCoord(new Vector2Int(-3, -2));
Vector2Int rotatedOffSet6 = TileTransformer.InverseRotateCoord(new Vector2Int(-3, -3));
Vector2Int rotatedOffSet7 = TileTransformer.InverseRotateCoord(new Vector2Int(-4, 3));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffset1.x, baseTile.Y + rotatedOffset1.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet2.x, baseTile.Y + rotatedOffSet2.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet3.x, baseTile.Y + rotatedOffSet3.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffset4.x, baseTile.Y + rotatedOffset4.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffset5.x, baseTile.Y + rotatedOffset5.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet6.x, baseTile.Y + rotatedOffSet6.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet7.x, baseTile.Y + rotatedOffSet7.y));
}
else
{
Vector2Int rotatedOffset1 = TileTransformer.InverseRotateCoord(new Vector2Int(0, -1));
Vector2Int rotatedOffSet2 = TileTransformer.InverseRotateCoord(new Vector2Int(-1, -1));
Vector2Int rotatedOffSet3 = TileTransformer.InverseRotateCoord(new Vector2Int(-1, -2));
Vector2Int rotatedOffset4 = TileTransformer.InverseRotateCoord(new Vector2Int(-2, -2));
Vector2Int rotatedOffset5 = TileTransformer.InverseRotateCoord(new Vector2Int(-2, -3));
Vector2Int rotatedOffSet6 = TileTransformer.InverseRotateCoord(new Vector2Int(-3, -3));
Vector2Int rotatedOffSet7 = TileTransformer.InverseRotateCoord(new Vector2Int(-3, -4));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffset1.x, baseTile.Y + rotatedOffset1.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet2.x, baseTile.Y + rotatedOffSet2.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet3.x, baseTile.Y + rotatedOffSet3.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffset4.x, baseTile.Y + rotatedOffset4.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffset5.x, baseTile.Y + rotatedOffset5.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet6.x, baseTile.Y + rotatedOffSet6.y));
tiles.Add(level.GetTileAt(baseTile.X + rotatedOffSet7.x, baseTile.Y + rotatedOffSet7.y));
}
foreach (ITile tile in tiles)
{
if (tile.Type != TileIndex.Empty)
{
return(true);
}
}
return(false);
}
public override void ClickStart(Vector2 mousePosition)
{
base.ClickStart(mousePosition);
dragStartCoords = TileTransformer.ScreenToCoord(mousePosition);
}
public static int FloorOrder(int x, int y, FloorSubLayer layer)
{
Vector2Int rotatedCoords = TileTransformer.RotateCoord(new Vector2Int(x, y));
return(((rotatedCoords.x + rotatedCoords.y) * 10) + (int)layer);
}
public static int TileOrder(int x, int y, TileSubLayer layer)
{
Vector2Int rotatedCoords = TileTransformer.RotateCoord(new Vector2Int(x, y));
return((rotatedCoords.x + rotatedCoords.y) * 20 + ((int)layer * 2));
}
