public TileData this[Point2 point]
{
get
{
return tiles[point.X + point.Y * LayerWidth];
}
set { tiles[point.X + point.Y * LayerWidth] = value; }
}
public void CanAddTileTypeWithoutPrefab()
{
LayerData ld = new LayerData(null, "SuperLayer", 1, 1);
TileType type = new TileType(1);
Point2 position = new Point2(0, 0);
bool result = ld.AddTile(position, type);
Assert.IsTrue(result);
Assert.IsNotNull(ld[position]);
}
public bool AddTile(Point2 tilePoint, TileData prefab)
{
if (this[tilePoint.X, tilePoint.Y] == null) return false;
if (AddTile(tilePoint, prefab.TileType))
{
this[tilePoint.X, tilePoint.Y].Transform.localScale = prefab.Transform.localScale;
this[tilePoint.X, tilePoint.Y].Transform.rotation = prefab.Transform.rotation;
return true;
}
else
return false;
}
public void CanAddTileTypeWithPrefab()
{
LayerData ld = new LayerData(null, "SuperLayer", 1, 1);
GameObject go = new GameObject("TestGo");
TileType type = new TileType(1,go);
Point2 position = new Point2(0, 0);
bool result = ld.AddTile(position, type);
Assert.IsTrue(result);
Assert.IsNotNull(ld[position]);
Assert.IsNotNull(ld[position].GameObject);
}
public ArchitectTilePositionGetter(Vector3 position, LayerData selectedLayer)
{
layer = selectedLayer;
if (selectedLayer == null)
{
Clear();
Valid = false;
}
else
{
Vector3 TileP = position.Div(new Vector3(selectedLayer.TileWidth, selectedLayer.TileHeight, 1)).Round().SetValues(0, Axes.Z);
tilePosition = new Point2((int)TileP.x, (int)TileP.y);
tileWorlPosition = TileP.Mult(new Vector3(selectedLayer.TileWidth, selectedLayer.TileHeight, 1));
Valid = layer.IsInLayerBound(tilePosition.X, tilePosition.Y);
}
}
public void AddTile(Point2 tilePoint, TileType tileType, ArchitectRotationFlip rotationFlip)
{
if (this[tilePoint.X, tilePoint.Y] == null) return;
AddTile(tilePoint, tileType);
rotationFlip.ApplyTo(this[tilePoint.X, tilePoint.Y].Transform);
}
public void AddTile(Point2 tilePoint, TileType tileType, int rotationFlags)
{
if (this[tilePoint.X, tilePoint.Y] == null) return;
AddTile(tilePoint, tileType);
ArchitectRotationHandler.ApplyFlipFlags(this[tilePoint.X, tilePoint.Y].Transform, rotationFlags);
}
public void EmptyTile(Point2 tilePoint)
{
this[tilePoint.X, tilePoint.Y].GameObject.Destroy();
this[tilePoint.X, tilePoint.Y] = TileData.Empty;
}
public void Open(string path)
{
OpenFileBrowser.gameObject.SetActive(false);
clearAllLayer();
var layers = WorldOpener.OpenFile(Linker, path, MapParent);
mapDimension = new Point2(layers[0].LayerWidth, layers[0].LayerHeight);
Layers.AddRange(layers);
SelectedLayer = layers[0];
//LayerPanel.RefreshUI();
ResetGridSize();
}
public void New(string text, int width, int height)
{
FileName = text;
mapDimension = new Point2(width, height);
New();
}
public bool IsTileEmpty(Point2 tilePoint)
{
TileData tileData = this[tilePoint.X, tilePoint.Y];
return (tileData == null || tileData.TileType.IsNullOrIdZero());
}
private bool InRange(Point2 tilePoint)
{
return getTile(tilePoint.X, tilePoint.Y) != null;
}
private void Clear()
{
tilePosition = Point2.Zero;
tileWorlPosition = Vector3.zero;
}
public bool IsTileEmpty(Point2 tilePoint)
{
TileData tileData = this[tilePoint.X, tilePoint.Y];
return(tileData == null || tileData.TileType.IsNullOrIdZero());
}
public MazeChunk CreateChunk(Point2 position, Orientations orientation, GameObject maze, MazeChunk[,] map)
{
position += ToDirection(orientation);
var chunk = Instantiate(Chunks.GetRandom());
chunk.name = string.Format("{0}_{1}", position.X, position.Y);
chunk.Position = position;
chunk.Orientation = orientation;
chunk.CachedTransform.parent = maze.transform;
chunk.CachedTransform.localPosition = position;
map[position.X, position.Y] = chunk;
CreateWalls(chunk, map);
return chunk;
}
public bool HasValidOrientation(Point2 position, MazeChunk[,] map)
{
for (int i = 0; i < orientations.Length; i++)
{
var orientation = orientations[i];
var adjustedPoint = position + ToDirection(orientation);
if (map.ContainsPoint(adjustedPoint) && map.Get(adjustedPoint) == null)
return true;
}
return false;
}
public static bool ContainsPoint <T>(this T[,] array, Point2 point)
{
return(point.X >= array.GetLowerBound(0) && point.X < array.GetUpperBound(0) && point.Y >= array.GetLowerBound(1) && point.Y < array.GetUpperBound(1));
}
public static void Set <T>(this T[,] array, Point2 point, T value)
{
array[point.X, point.Y] = value;
}
public static T Get <T>(this T[,] array, Point2 point)
{
return(array[point.X, point.Y]);
}
/*public void setSelectedTile(int id)
{
SelectedTileType = Linker.Tilesets[0].Tiles[id - 1];
}
public void AddSelectedTileType(LayerData layer, Vector3 worldP, Point2 tilePoint)
{
layer.AddTile(tilePoint, toolControler.SelectedTileType, toolControler.RotationFlip);
}*/
/*public void AddTile(LayerData layer, Vector3 worldP, Point2 tilePoint, TileType tileType)
{
layer.AddTile(tilePoint, tileType, toolControler.RotationFlip);
}*/
public void AddTile(LayerData layer, Vector3 worldP, Point2 tilePoint, TileType tileType, ArchitectRotationFlip RotationFlip)
{
layer.AddTile(tilePoint, tileType, RotationFlip);
}
public void RemoveTile(Point2 tilePoint)
{
SelectedLayer.EmptyTile(tilePoint);
}
public Orientations GetRandomValidOrientation(Point2 position, MazeChunk[,] map)
{
orientations.Shuffle();
for (int i = 0; i < orientations.Length; i++)
{
var orientation = orientations[i];
var adjustedPoint = position + ToDirection(orientation);
if (map.ContainsPoint(adjustedPoint) && map.Get(adjustedPoint) == null)
return orientation;
}
return Orientations.Right;
}
public void AddTile(Point2 tilePoint, TileType tileType, float angle, bool horizontal, bool vertical)
{
if (this[tilePoint.X, tilePoint.Y] == null) return;
AddTile(tilePoint, tileType);
ArchitectRotationHandler.ApplyRotationFlip(this[tilePoint.X, tilePoint.Y].Transform, angle, horizontal, vertical);
}
public bool AddTile(Point2 tilePoint, TileType tileType)
{
if (!InRange(tilePoint)) return false;
if (tileType == null) return false;
if (tileType.Prefab != null)
{
GameObject newTile = UnityEngine.Object.Instantiate(tileType.Prefab);
newTile.transform.SetPosition(new Vector3(tilePoint.X, tilePoint.Y, 0));
newTile.transform.parent = LayerTransform;
newTile.name = tileType.Prefab.name;
TileData tileData = new TileData(tileType, newTile);
this[tilePoint.X, tilePoint.Y] = tileData;
}
else
{
TileData tileData = new TileData(tileType, null);
this[tilePoint.X, tilePoint.Y] = tileData;
}
return true;
}
public void EmptyTile(Point2 tilePoint)
{
this[tilePoint.X, tilePoint.Y].GameObject.Destroy();
this[tilePoint.X, tilePoint.Y] = TileData.Empty;
}
private void readLayerLine(LayerData layer, int y, int lineWidth)
{
for (int x = 0; x < lineWidth; x++)
{
int value = readNextInt();
int id = ArchitectRotationHandler.RemoveRotationFlags(value);
int rotationFlags = ArchitectRotationHandler.GetRotationFlags(value);
Point2 position = new Point2(x, y);
TileType tileType = null;
if (id == 0)
continue;
tileType = linker.Tilesets[0][id - 1];
layer.AddTile(position, tileType, rotationFlags);
}
}
private bool InRange(Point2 tilePoint)
{
return(getTile(tilePoint.X, tilePoint.Y) != null);
}
