internal void OnDeserializedMethod(StreamingContext context)
{
//DiagManager.Instance.LogInfo(String.Format("GroundMap.OnDeserializedMethod(): Map {0} deserialized!", AssetName));
//recompute the grid
grid = new AABB.Grid(Width, Height, GraphicsManager.TileSize);
//TODO: v0.5: remove this
if (Background == null)
{
Background = new MapBG();
}
if (BlankBG == null)
{
BlankBG = new AutoTile();
}
if (ActiveChar != null)
{
ActiveChar.OnDeserializeMap(this);
signCharToMap(ActiveChar);
}
ReloadEntLayer(0);
}
public void AutoTile_Edit(AutoTile element, TileBoxViewModel.EditElementOp op)
{
TileEditForm frmData = new TileEditForm();
TileEditViewModel tmv = new TileEditViewModel();
frmData.DataContext = tmv;
tmv.Name = element.ToString();
//load as if eyedropping
tmv.TileBrowser.TileSize = ZoneManager.Instance.CurrentGround.TileSize;
tmv.AutotileBrowser.TileSize = ZoneManager.Instance.CurrentGround.TileSize;
tmv.LoadTile(element);
tmv.SelectedOKEvent += () =>
{
element = tmv.GetTile();
op(element);
frmData.Close();
};
tmv.SelectedCancelEvent += () =>
{
frmData.Close();
};
DevForm form = (DevForm)DiagManager.Instance.DevEditor;
form.GroundEditForm.RegisterChild(frmData);
frmData.Show();
}
public AutoTile GetSanitizedTile(Loc offset)
{
if (autotile > -1)
{
AutoTile auto = new AutoTile(autotile, associates);
return(auto);
}
TileLayer newLayer = new TileLayer();
bool hasFilled = false;
foreach (TileFrame frame in layer.Frames)
{
TileFrame newFrame = new TileFrame(frame.TexLoc + offset, frame.Sheet);
//check for emptiness
long tilePos = GraphicsManager.TileIndex.GetPosition(newFrame.Sheet, newFrame.TexLoc);
if (tilePos > 0)
{
newLayer.Frames.Add(newFrame);
hasFilled = true;
}
else
{
newLayer.Frames.Add(TileFrame.Empty);
}
}
if (!hasFilled)
{
return(new AutoTile());
}
newLayer.FrameLength = layer.FrameLength;
return(new AutoTile(newLayer));
}
void Update()
{
if (Input.GetMouseButtonDown(0) && isDialogActive() == false)
{
Vector2 pos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D hit = Physics2D.Raycast(pos, Vector2.zero);
//Unit Touch or AutoTile Touch
if (hit.collider != null)
{
//1. 유닛 팔레트에선 Unit이 있는 오브젝트일 것임
//2. 선택타일에선 AutoTile이 나타날 것이다
GameObject gameObject = hit.collider.gameObject;
Unit unit = gameObject.GetComponent <Unit>();
AutoTile tile = gameObject.GetComponent <AutoTile>();
if (unit != null)
{
if (gameObject.tag == "pallette")
{
SelectPallette(unit);
selectedUnit = gameObject;
}
}
else if (tile != null)
{
if (gameObject.tag == "placable")
{
SelectAutoTile(tile);
}
}
}
}
}
private GameObject GetBoardTile(AutoTile autoTile, Point point, int tile)
{
return autoTile.GetTile(
!_board.InBounds(point + Point.Right) || _board.GetTile(point + Point.Right) == tile,
!_board.InBounds(point + Point.Down) || _board.GetTile(point + Point.Down) == tile,
!_board.InBounds(point + Point.Left) || _board.GetTile(point + Point.Left) == tile,
!_board.InBounds(point + Point.Up) || _board.GetTile(point + Point.Up) == tile
);
}
public override void OnInspectorGUI()
{
AutoTile autoTile = (AutoTile)target;
DrawDefaultInspector();
if (GUILayout.Button("Update"))
{
autoTile.UpdateState();
}
}
public void OnEnable()
{
_autoTile = (AutoTile)target;
_icons[(int)AutoTile.TileEdge.All] = Resources.Load("Icons/AutoTile/autotile_0000") as Texture;
_icons[(int)AutoTile.TileEdge.ThreeSides] = Resources.Load("Icons/AutoTile/autotile_1000") as Texture;
_icons[(int)AutoTile.TileEdge.OppositeSides] = Resources.Load("Icons/AutoTile/autotile_0101") as Texture;
_icons[(int)AutoTile.TileEdge.Corner] = Resources.Load("Icons/AutoTile/autotile_1100") as Texture;
_icons[(int)AutoTile.TileEdge.OneSide] = Resources.Load("Icons/AutoTile/autotile_1101") as Texture;
_icons[(int)AutoTile.TileEdge.None] = Resources.Load("Icons/AutoTile/autotile_1111") as Texture;
}
public void SelectAutoTile(AutoTile tile)
{
if (selected2.activeInHierarchy)
{
selected.SetActive(true);
tile.attach(selected);
this.selectedTile = tile;
//유닛 설치에 관한 다이얼로그 표시
//TODO : 다이얼로그 만들고 이 클래스에 인터페이스를 추가하는식으로 이어줘야 한다
OKCancelDialog dialog = okCancelDialog.GetComponent <OKCancelDialog>();
dialog.SetDialogListener(this);
okCancelDialog.SetActive(true);
dialog.SetText("이 곳에 해당 유닛을 위치시키겠습니까?");
}
}
private void OnNewAutoTile(object sender, EventArgs eventArgs)
{
int[] indexSet = new int[16];
for (int index = 0; index < 16; index++)
{
indexSet[index] = -1;
}
// determine unused name
int nameIndex = 1;
string newId = null;
while (true)
{
newId = "Auto Tile #" + nameIndex;
bool duplicate = false;
foreach (AutoTile autoTile in m_autoTiles)
{
if (autoTile.Id == newId)
{
duplicate = true;
break;
}
}
if (!duplicate)
{
break;
}
++nameIndex;
}
AutoTile newAutoTile = new AutoTile(newId, m_tileSheet, indexSet);
m_autoTiles.Add(newAutoTile);
m_selectedAutoTile = newAutoTile;
SortAutoTiles();
UpdateIdComboBox();
m_cmbId.SelectedIndex = m_autoTiles.IndexOf(m_selectedAutoTile);
UpdateDialogState(true);
m_btnRename.Enabled = true;
m_tilePicker.Enabled = true;
m_btnDelete.Enabled = true;
}
public static void CreateAutoTileAsset(string path, params string[] tilenames)
{
var alltilesprites = AssetDatabase.LoadAllAssetsAtPath(path).OfType <Sprite>().OrderBy(s => s.name).ToList();
for (var i = 0; i < tilenames.Length; i++)
{
var spriteList = alltilesprites.Skip(i * toPaint.Length).Take(toPaint.Length).ToList();
var autotile = new AutoTile()
{
name = (tilenames[i]),
sprites = spriteIndex.Select(j => spriteList[j]).ToArray()
};
AssetDatabase.CreateAsset(autotile, "assets\\" + tilenames[i] + ".asset");
}
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
}
private bool CompareNeighbor(int x, int y)
{
GameObject neighbor = getNeighbor(x, y);
if (!neighbor)
{
return(false);
}
AutoTile neighborAutoTile = neighbor.GetComponent <AutoTile>();
if (!neighborAutoTile)
{
return(false);
}
return(neighborAutoTile.tileTag == tileTag);
}
public void attach()
{
string name = "autotile(" + this.x + "," + this.y + ")";
Transform tfAutoTile = this.autoMapper.transform.Find(name);
GameObject goAutoTile = tfAutoTile.gameObject;
if (goAutoTile == null)
{
throw new CannotFindComponentException(name + "을 찾지못함");
}
AutoTile tile = goAutoTile.GetComponent <AutoTile>();
if (tile == null)
{
throw new CannotFindComponentException(name + " AutoTile 을 찾지못함");
}
tile.attach(this.gameObject);
}
/// <summary> Add auto-tile definition. Mainly for editor use. </summary>
public void AddAutoTile(bool withCorners)
{
AutoTile at = new AutoTile()
{
id = nextAutoTileId++, tiles = new GameMapTile[withCorners ? 47 : 16]
};
for (int i = 0; i < at.tiles.Length; i++)
{
at.tiles[i] = new GameMapTile()
{
id = nextTileId++, _aid = at.id
};
}
autoTiles.Add(at);
_cache = null;
}
void ToggleTool()
{
if (pointHit && pointHit.gameObject.GetComponent <AutoTile>() != null)
{
AutoTile currentTile = pointHit.gameObject.GetComponent <AutoTile>();
AutoTileMode newValue;
switch (currentTile.autoTileMode)
{
case AutoTileMode.Corner: newValue = AutoTileMode.Slope; break;
case AutoTileMode.Slope: newValue = AutoTileMode.Corner; break;
default: newValue = AutoTileMode.Corner; break;
}
SerializedObject target = new SerializedObject(currentTile);
target.FindProperty("autoTileMode").enumValueIndex = (int)newValue;
target.ApplyModifiedProperties();
currentTile.UpdateTile();
}
}
public GroundMap()
{
AssetName = "";
rand = new ReRandom(0);
ScriptEvents = new Dictionary <LuaEngine.EMapCallbacks, ScriptEvent>();
Entities = new List <EntityLayer>();
Status = new Dictionary <int, MapStatus>();
Background = new MapBG();
BlankBG = new AutoTile();
Name = new LocalText();
Comment = "";
Music = "";
Layers = new List <MapLayer>();
Decorations = new List <AnimLayer>();
}
public static Dictionary <string, Sprite> GetSprites(TileData tileData)
{
Dictionary <string, Sprite> sprites = new Dictionary <string, Sprite>();
AutoTileAnimated animation = tileData.GetModifierOfType <AutoTileAnimated>() as AutoTileAnimated;
if (animation != null)
{
for (int i = 0; i < animation.frames; ++i)
{
foreach (TerrainBrush.TileType tileType in Enum.GetValues(typeof(TerrainBrush.TileType)))
{
sprites[tileData.Name + tileType.ToString("") + i] = GetTileSprite(tileData.Name + tileType.ToString("") + i);
}
}
return(sprites);
}
AutoTile autoTile = tileData.GetModifierOfType <AutoTile>() as AutoTile;
if (autoTile != null)
{
foreach (TerrainBrush.TileType tileType in Enum.GetValues(typeof(TerrainBrush.TileType)))
{
sprites[tileData.Name + tileType.ToString("")] = GetTileSprite(tileData.Name + tileType.ToString(""));
}
return(sprites);
}
TileRenderer renderer = tileData.GetModifierOfType <TileRenderer>() as TileRenderer;
if (renderer != null)
{
for (int i = 0; i < renderer.tileAmounts; ++i)
{
sprites[tileData.Name + i] = GetTileSprite(tileData.Name + i);
}
return(sprites);
}
return(null);
}
void NotificateChange(int x, int y)
{
if (x < 0 || y < 0 || x >= width || y >= height)
{
return;
}
Node node = nodeMap[x, y];
GameObject block = node.GetBlock();
if (!block)
{
return;
}
AutoTile autoTile = block.GetComponent <AutoTile>() as AutoTile;
if (autoTile == null)
{
return;
}
autoTile.UpdateState();
}
protected override void PostDraw(SpriteBatch spriteBatch)
{
Matrix matrix = Matrix.CreateScale(new Vector3(drawScale, drawScale, 1));
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, null, null, null, matrix);
if (AutoTileInProgress != null)
{
for (int jj = viewTileRect.Y; jj < viewTileRect.End.Y; jj++)
{
for (int ii = viewTileRect.X; ii < viewTileRect.End.X; ii++)
{
Loc testLoc = new Loc(ii, jj);
if (Collision.InBounds(ZoneManager.Instance.CurrentMap.Width, ZoneManager.Instance.CurrentMap.Height, testLoc) &&
AutoTileInProgress.IncludesLoc(testLoc))
{
AutoTile brush = AutoTileInProgress.GetBrush(testLoc);
if (brush.IsEmpty())
{
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(ii * GraphicsManager.TileSize - ViewRect.X, jj * GraphicsManager.TileSize - ViewRect.Y, GraphicsManager.TileSize, GraphicsManager.TileSize), null, Color.Black);
}
else
{
brush.Draw(spriteBatch, new Loc(ii * GraphicsManager.TileSize, jj * GraphicsManager.TileSize) - ViewRect.Start);
}
}
}
}
}
//draw the blocks
for (int jj = viewTileRect.Y; jj < viewTileRect.End.Y; jj++)
{
for (int ii = viewTileRect.X; ii < viewTileRect.End.X; ii++)
{
Loc testLoc = new Loc(ii, jj);
if (Collision.InBounds(ZoneManager.Instance.CurrentMap.Width, ZoneManager.Instance.CurrentMap.Height, testLoc))
{
TerrainTile tile = ZoneManager.Instance.CurrentMap.Tiles[ii][jj].Data;
if (TerrainInProgress != null && TerrainInProgress.IncludesLoc(testLoc))
{
tile = TerrainInProgress.GetBrush(testLoc);
if (tile.TileTex.IsEmpty())
{
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(ii * GraphicsManager.TileSize - ViewRect.X, jj * GraphicsManager.TileSize - ViewRect.Y, GraphicsManager.TileSize, GraphicsManager.TileSize), null, Color.Black);
}
else
{
tile.TileTex.Draw(spriteBatch, new Loc(ii * GraphicsManager.TileSize, jj * GraphicsManager.TileSize) - ViewRect.Start);
}
}
if (ShowTerrain)
{
TerrainData data = tile.GetData();
Color color = Color.Transparent;
switch (data.BlockType)
{
case TerrainData.Mobility.Block:
color = Color.Red;
break;
case TerrainData.Mobility.Water:
color = Color.Blue;
break;
case TerrainData.Mobility.Lava:
color = Color.Orange;
break;
case TerrainData.Mobility.Abyss:
color = Color.Black;
break;
case TerrainData.Mobility.Impassable:
color = Color.White;
break;
}
if (color != Color.Transparent)
{
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(ii * GraphicsManager.TileSize - ViewRect.X, jj * GraphicsManager.TileSize - ViewRect.Y, GraphicsManager.TileSize, GraphicsManager.TileSize), null, color * 0.5f);
}
}
}
}
}
if (ShowEntrances)
{
foreach (LocRay8 entrance in ZoneManager.Instance.CurrentMap.EntryPoints)
{
Color showColor = Color.OrangeRed;
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(entrance.Loc.X * GraphicsManager.TileSize - ViewRect.X, entrance.Loc.Y * GraphicsManager.TileSize - ViewRect.Y, GraphicsManager.TileSize, GraphicsManager.TileSize), null, showColor * 0.75f);
}
}
if (TileInProgress != null)
{
for (int jj = viewTileRect.Y; jj < viewTileRect.End.Y; jj++)
{
for (int ii = viewTileRect.X; ii < viewTileRect.End.X; ii++)
{
Loc testLoc = new Loc(ii, jj);
if (Collision.InBounds(ZoneManager.Instance.CurrentMap.Width, ZoneManager.Instance.CurrentMap.Height, testLoc) &&
TileInProgress.IncludesLoc(testLoc))
{
EffectTile tile = TileInProgress.GetBrush(testLoc);
if (tile.ID < 0)
{
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(ii * GraphicsManager.TileSize - ViewRect.X, jj * GraphicsManager.TileSize - ViewRect.Y, GraphicsManager.TileSize, GraphicsManager.TileSize), null, Color.Black);
}
else
{
TileData entry = DataManager.Instance.GetTile(tile.ID);
if (entry.Anim.AnimIndex != "")
{
DirSheet sheet = GraphicsManager.GetObject(entry.Anim.AnimIndex);
Loc drawLoc = new Loc(ii * GraphicsManager.TileSize, jj * GraphicsManager.TileSize) - ViewRect.Start + new Loc(GraphicsManager.TileSize / 2) - new Loc(sheet.Width, sheet.Height) / 2;
sheet.DrawDir(spriteBatch, drawLoc.ToVector2(), entry.Anim.GetCurrentFrame(GraphicsManager.TotalFrameTick, sheet.TotalFrames),
entry.Anim.GetDrawDir(Dir8.None), Color.White);
}
else
{
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(ii * GraphicsManager.TileSize - ViewRect.X, jj * GraphicsManager.TileSize - ViewRect.Y, GraphicsManager.TileSize, GraphicsManager.TileSize), null, Color.White);
}
}
}
}
}
}
spriteBatch.End();
}
public void AddAutoTile(AutoTile autoTile)
{
autoTiles.Add(autoTile.Id, autoTile);
}
void OnSceneGUI()
{
Event current = Event.current;
int controlID = GUIUtility.GetControlID(FocusType.Passive);
HandleUtility.AddDefaultControl(controlID);
EventType currentEventType = current.GetTypeForControl(controlID);
bool skip = false;
int saveControl = GUIUtility.hotControl;
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
pointHit = Physics2D.OverlapPoint(ray.origin);
radiusHit = Physics2D.OverlapCircle(ray.origin, 0.333f);
if (!pointHit && radiusHit)
{
AutoTile currentTile = radiusHit.gameObject.GetComponent <AutoTile>();
if (currentTile.autoTileMode == AutoTileMode.Slope)
{
pointHit = radiusHit;
}
}
if (currentEventType == EventType.Layout)
{
skip = true;
}
if (currentEventType == EventType.ScrollWheel)
{
skip = true;
}
if (current.button != 0)
{
skip = true;
}
if (style == null)
{
style = new GUIStyle();
style.normal.textColor = Color.red;
style.normal.background = new Texture2D(1, 1);
style.normal.background.SetPixel(0, 0, Color.white);
style.normal.background.Apply();
}
if (SceneView.currentDrawingSceneView.in2DMode)
{
style.normal.textColor = Color.black;
Handles.Label(HandleUtility.GUIPointToWorldRay(Vector3.zero).origin, "LMB: Draw/Erase , RMB: Toggle corners", style);
if (current.button == 0 && !skip)
{
GUIUtility.hotControl = controlID;
switch (current.type)
{
case EventType.KeyDown: if (current.keyCode == KeyCode.Escape)
{
Selection.activeGameObject = null; Event.current.Use();
}
break;
case EventType.MouseDown: GetTool(); break;
case EventType.MouseDrag: TileTool(); break;
case EventType.MouseUp: TileTool = null; break;
}
}
}
else
{
style.normal.textColor = Color.red;
Handles.Label(HandleUtility.GUIPointToWorldRay(Vector3.zero).origin, "Tile editing requires 2D mode", style);
}
if (current.button == 1 && current.type == EventType.MouseDown)
{
ToggleTool();
}
GUIUtility.hotControl = saveControl;
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
}
public override void DrawGame(SpriteBatch spriteBatch)
{
//
//When in editor mode, we want to display an overlay over some entities
//
base.DrawGame(spriteBatch);
if (DiagManager.Instance.DevEditor.GroundEditor.Active && ZoneManager.Instance.CurrentGround != null)
{
if (AutoTileInProgress != null)
{
for (int jj = viewTileRect.Y; jj < viewTileRect.End.Y; jj++)
{
for (int ii = viewTileRect.X; ii < viewTileRect.End.X; ii++)
{
Loc testLoc = new Loc(ii, jj);
if (Collision.InBounds(ZoneManager.Instance.CurrentGround.Width, ZoneManager.Instance.CurrentGround.Height, testLoc) &&
AutoTileInProgress.IncludesLoc(testLoc))
{
AutoTile brush = AutoTileInProgress.GetBrush(testLoc);
if (brush.IsEmpty())
{
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(ii * ZoneManager.Instance.CurrentGround.TileSize - ViewRect.X, jj * ZoneManager.Instance.CurrentGround.TileSize - ViewRect.Y, ZoneManager.Instance.CurrentGround.TileSize, ZoneManager.Instance.CurrentGround.TileSize), null, Color.Black);
}
else
{
brush.Draw(spriteBatch, new Loc(ii * ZoneManager.Instance.CurrentGround.TileSize, jj * ZoneManager.Instance.CurrentGround.TileSize) - ViewRect.Start);
}
}
}
}
}
//draw the blocks
if (ShowWalls)
{
int texSize = ZoneManager.Instance.CurrentGround.TexSize;
for (int jj = viewTileRect.Y * texSize; jj < viewTileRect.End.Y * texSize; jj++)
{
for (int ii = viewTileRect.X * texSize; ii < viewTileRect.End.X * texSize; ii++)
{
Loc testLoc = new Loc(ii, jj);
if (Collision.InBounds(ZoneManager.Instance.CurrentGround.Width * texSize, ZoneManager.Instance.CurrentGround.Height * texSize, testLoc))
{
bool blocked = ZoneManager.Instance.CurrentGround.GetObstacle(ii, jj) == 1u;
if (BlockInProgress != null && BlockInProgress.IncludesLoc(testLoc))
{
blocked = BlockInProgress.GetBrush(testLoc);
}
if (blocked)
{
GraphicsManager.Pixel.Draw(spriteBatch, new Rectangle(ii * GraphicsManager.TEX_SIZE - ViewRect.X, jj * GraphicsManager.TEX_SIZE - ViewRect.Y, GraphicsManager.TEX_SIZE, GraphicsManager.TEX_SIZE), null, Color.Red * 0.6f);
}
}
}
}
}
//DevHasGraphics()
//Draw Entity bounds
GroundDebug dbg = new GroundDebug(spriteBatch, Color.BlueViolet);
foreach (GroundEntity entity in ZoneManager.Instance.CurrentGround.IterateEntities())
{
if (entity.DevEntitySelected)
{
//Invert the color of selected entities
dbg.DrawColor = new Color(entity.DevEntColoring.B, entity.DevEntColoring.G, entity.DevEntColoring.R, entity.DevEntColoring.A);
dbg.LineThickness = 1.0f;
dbg.DrawFilledBox(new Rect(entity.Bounds.X, entity.Bounds.Y, entity.Width - 1, entity.Height - 1), 92);
}
else if (!entity.DevHasGraphics())
{
//Draw entities with no graphics of their own as a filled box
dbg.DrawColor = entity.DevEntColoring;
dbg.LineThickness = 1.0f;
dbg.DrawFilledBox(new Rect(entity.Bounds.X, entity.Bounds.Y, entity.Width - 1, entity.Height - 1), 128);
}
else
{
//Draw boxes around other entities with graphics using low opacity
dbg.DrawColor = new Color(entity.DevEntColoring.R, entity.DevEntColoring.G, entity.DevEntColoring.B, 92);
dbg.LineThickness = 1.0f;
dbg.DrawBox(new Rect(entity.Bounds.X, entity.Bounds.Y, entity.Width - 1, entity.Height - 1));
}
//And don't draw bounds of entities that have a graphics representation
}
}
}
/// <summary>
/// Build this BlockMesh's geometry
/// </summary>
public void Build()
{
Point size = new Point(_blocks.GetLength(0) - 2, _blocks.GetLength(1) - 2, _blocks.GetLength(2) - 2);
if (size != _size)
{
Resize(size, true);
}
List <Vector3> vertices = new List <Vector3>();
List <int> triangles = new List <int>();
List <Vector2> uvs = new List <Vector2>();
// Start building the block sides
Point.ForEachXYZ(Point.Zero, _size, (Point point) => {
Vector3 blockCenter = point.ToVector();
int blockType = GetBlock(point);
// Only create geometry for blocks that have a nonzero type, and have a BlockProperty associated to its type
if (blockType != 0 && BlockProperties.Length > blockType && BlockProperties[blockType] != null)
{
// For each side of the block, create an 8-bit adjacency bitstring, with each bit represents that side's neighbor
// blocks, in clockwise order from LSB to MSB. If the neighbor has the same block type, the bit is 1, 0 otherwise.
// The AutoTile then uses that adjacency bitstring to determine how to create the side's geometry.
for (int side = 0; side < Point.Neighbors.Length; side++)
{
Point sideForward = Point.Neighbors[side];
Point neighbor = point + sideForward;
AutoTile autoTile = BlockProperties[blockType].SideTiles[side];
if (autoTile != null && GetBlock(neighbor) != blockType)
{
// Get adjacency bitstring for the AutoTile texture
byte tileAdjacency = 0;
int adjacencyIdx = 0;
for (int sideNeighborIdx = 0; sideNeighborIdx < _BLOCK_SIDE_NEIGHBORS.GetLength(1); sideNeighborIdx++)
{
// Check each neighbor, and the block in front of that neighbor
// If the block in front of the neighbor is occupied, then don't include the neighbor
// in the adjacency string.
// This lets the texture reset its tiling against edges.
Point sideNeighbor = point + _BLOCK_SIDE_NEIGHBORS[side, sideNeighborIdx];
byte neighborType = GetBlock(sideNeighbor);
byte neighborFrontType = GetBlock(sideNeighbor + sideForward);
if (InArray(sideNeighbor) && neighborType == blockType &&
neighborFrontType != blockType)
{
tileAdjacency |= (byte)(1 << adjacencyIdx);
}
adjacencyIdx++;
// Check the corners
int cornerIdx = (sideNeighborIdx + 1) % _BLOCK_SIDE_NEIGHBORS.GetLength(1);
sideNeighbor = point + _BLOCK_SIDE_NEIGHBORS[side, sideNeighborIdx]
+ _BLOCK_SIDE_NEIGHBORS[side, cornerIdx];
neighborType = GetBlock(sideNeighbor);
neighborFrontType = GetBlock(sideNeighbor + sideForward);
if (InArray(sideNeighbor) && neighborType == blockType &&
neighborFrontType != blockType)
{
tileAdjacency |= (byte)(1 << adjacencyIdx);
}
adjacencyIdx++;
}
Vector3 sideCenter = blockCenter + 0.5f * Point.Neighbors[side].ToVector();
// Generate the side mesh
autoTile.AddTile(
sideCenter,
_SIDE_VECTORS[side, 0],
_SIDE_VECTORS[side, 1],
tileAdjacency,
vertices,
triangles,
uvs
);
}
}
}
});
// Assign the geometry to the MeshFilter
if (_meshFilter.sharedMesh == null)
{
_meshFilter.sharedMesh = new Mesh();
}
else
{
_meshFilter.sharedMesh.Clear();
}
_meshFilter.sharedMesh.vertices = vertices.ToArray();
_meshFilter.sharedMesh.triangles = triangles.ToArray();
_meshFilter.sharedMesh.uv = uvs.ToArray();
_meshFilter.sharedMesh.RecalculateNormals();
}
