public static Point GetTilePixelCenter(IsoTile t)
{
var ret = new Point(t.Dx * Drawable.TileWidth / 2, (t.Dy - t.Z) * Drawable.TileHeight);
ret.Offset(Drawable.TileWidth / 2, Drawable.TileHeight / 2);
return(ret);
}
public Point GetTilePixelCenter(IsoTile t)
{
var ret = new Point(t.Dx * _config.TileWidth / 2, (t.Dy - t.Z) * _config.TileHeight);
ret.Offset(_config.TileWidth / 2, _config.TileHeight / 2);
return(ret);
}
static bool Drop_AllTile(GameObject target)
{
IsoTile tile = IsoTile.Find(target);
tile.DropToFloor();
return(false);
}
public override bool MakeUp(ref GameObject target, params object[] values)
{
bool bAutoCreation = (bool)values[0];
Vector3 vAt = (Vector3)values[1];
bool bBody = (bool)values[2];
bool bAttachments = (bool)values[3];
bool bAutoIsoLight = (bool)values[4];
IsoTile refTile = Tile;
IsoTileBulk refBulk = (IsoTileBulk)values[5];
if (target == null)
{
if (!bAutoCreation)
{
return(false);
}
return(TileControlWand.Tile_Create(ref target, vAt, refTile, bBody, bAttachments, bAutoIsoLight, refBulk));
}
IsoTile TargetTile = IsoTile.Find(target);
if (refTile == null || TargetTile == null)
{
return(false);
}
// Undo.Record() code is aleady in Copycat()
TargetTile.Copycat(refTile, bBody, bAttachments, true);
target = TargetTile.gameObject;
return(true);
}
void ToTile_Reset()
{
if (toTile != null && toTile != fromTile)
{
ColoredObject.End(toTile.gameObject);
toTile = null;
}
}
static bool Renderer_Color(GameObject target, Type type, Color color, float fBlendWeight, bool includeBody, bool includeAttachment, bool bApplyToTileOverlay = true)
{
List <SpriteRenderer> exceptions = new List <SpriteRenderer>();
List <SpriteRenderer> overlays = new List <SpriteRenderer>();
var renderers = target.GetComponentsInChildren <SpriteRenderer>();
var renderersEnumerater = renderers.GetEnumerator();
if (bApplyToTileOverlay)
{
while (renderersEnumerater.MoveNext())
{
var current = renderersEnumerater.Current as SpriteRenderer;
var iso2D = current != null?current.GetComponent <Iso2DObject>() : null;
if (iso2D != null)
{
if (!((includeBody && iso2D.IsSideOfTile) || (includeAttachment && iso2D.IsAttachment)))
{
exceptions.Add(current);
continue;
}
if (iso2D.IsSideOfTile)
{
IsoTile tile = iso2D.Tile;
overlays.AddRange(tile._attachedList.childList.
Where(r => r.AttachedObj.IsTileRCAttachment && r.AttachedObj._Type == Iso2DObject.Type.Overlay).
Select(r => r.AttachedObj.sprr).ToArray());
}
}
}
if (overlays.Count > 0)
{
ArrayUtility.AddRange(ref renderers, overlays.ToArray());
}
renderersEnumerater = renderers.GetEnumerator();
}
Undo.RecordObjects(renderers, "Tile Control Wand: Material Color");
while (renderersEnumerater.MoveNext())
{
var current = renderersEnumerater.Current as SpriteRenderer;
if (current != null && (!exceptions.Contains(current) || overlays.Contains(current)))
{
var isoLightReciver = current.GetComponent <IsoLightReciver>();
if (isoLightReciver != null)
{
isoLightReciver.UpdateBaseColor(CalcColor(isoLightReciver.GetBaseColor, color, type, fBlendWeight));
}
else
{
current.color = CalcColor(current.color, color, type, fBlendWeight);
}
}
}
return(true);
}
private void Update()
{
IsoTile _selecedTile = TouchUtility.GetTile(eventType, Cam, exceptionList);
_selecedTile = FindTopTile(_selecedTile);
FromTile_Select(_selecedTile);
FromTile_UnSelectTile();
UpdateCameraDrag();
}
IsoTile FindTopTile(IsoTile tile)
{
if (tile == null || !bAutoStack)
{
return(tile);
}
var result = tile.Bulk.GetTiles_At(tile.coordinates._xyz, Vector3.up, true, true);
result.RemoveAll(r => exceptionList.Contains(r));
return(result.Count == 0 ? tile : result.Last());
}
static bool Tile_Copy(GameObject target, IsoTile refTile, bool bIncludeBody, bool bIncludeAttachments, bool bAutoIsoLight)
{
IsoTile tile = IsoTile.Find(target);
if (tile == null || refTile == null)
{
return(false);
}
tile.Copycat(refTile, bIncludeBody, bIncludeAttachments, true);
return(true);
}
IsoTile FindTopTile(IsoTile tile)
{
if (tile == null || !bAutoStack)
{
return(tile);
}
var result = tile.Bulk.GetTileList_At(tile.coordinates._xyz, Vector3.up, true, true);
result.Remove(ghostTileInstance);
return(result.Count == 0 ? tile : result.Last());
}
public void UpdateSprite(int x, int y, int z)
{
// Destruir la instancia actual
if (grid[x, y, z].instance != null)
{
DestroyImmediate(grid[x, y, z].instance.gameObject);
}
if (grid[x, y, z].state != CellState.Empty)
{
IsoTile tile = grid[x, y, z].tile;
GameObject cellObject = new GameObject("Tile");
SpriteRenderer cellRenderer = new GameObject("Sprite").AddComponent <SpriteRenderer>();
cellRenderer.transform.parent = cellObject.transform;
IsoCell cell = cellObject.AddComponent <IsoCell>();
// Añadir el collider
MeshCollider collider = cellObject.AddComponent <MeshCollider>();
collider.hideFlags = HideFlags.HideInHierarchy;
collider.gameObject.transform.rotation = Quaternion.Euler(collider.transform.rotation.x, tile.rotation, collider.transform.rotation.z);
if (tile.mesh != null)
{
collider.sharedMesh = tile.mesh;
}
// Añadir el mesh temporal (para que se puedan generar navmesh)
MeshRenderer meshRenderer = cellObject.AddComponent <MeshRenderer>();
MeshFilter meshFilter = cellObject.AddComponent <MeshFilter>();
Material material = new Material(Shader.Find("Transparent/Diffuse"));
//Material material = new Material(Shader.Find("Diffuse"));
meshFilter.mesh = tile.mesh;
meshRenderer.material = material;
cellRenderer.sprite = tile.sprite;
material.color = new Color(0, 0, 0, 0);
// Acomodar
cellObject.transform.position = new Vector3(x, y + heightCorrection * y, z) + transform.position;
// Ajustar orden
//cellRenderer.sortingOrder = CalculateCellOrder(x, y + tile.offsetY, z);
cellRenderer.sortingOrder = CalculateCellOrder(cellRenderer.transform.position + Vector3.up * tile.offsetY);
cellObject.transform.parent = transform;
cell.CorrectRotation();
// Registrar la instancia
grid[x, y, z].instance = cell;
}
}
void GhostTile_Create()
{
ghostTileInstance = fromTile.Duplicate();
ghostTileInstance.gameObject.isStatic = false;
ColoredObject.Start(ghostTileInstance.gameObject, ghostGradient);
var cols = ghostTileInstance.GetComponentsInChildren <Collider>();
foreach (var col in cols)
{
col.enabled = false;
}
GhostTile_Update();
}
void FromTile_Select(IsoTile tile)
{
if (tile != null && tile.coordinates._xyz.y > iBaseFloor && fromTile != tile)
{
toTile = fromTile = tile;
exceptionList.Add(fromTile);
GhostTile_Create();
ColoredObject.Start(fromTile.gameObject, selectedGradient);
fTileHeight = fromTile.GetBounds_SideOnly().size.y;
}
if (fromTile != null && lastMousePos != Input.mousePosition)
{
ToTile_Set();
}
}
//---------------------------------------//
//----- FUNÇÕES -----//
//---------------------------------------//
/// <summary>
/// Lê o array contido no mapa e ordena as posições dos tiles.
/// </summary>
public override void Read()
{
IsRead = false;
TotalMap = Map.GetMap();
Tiles.Clear();
//dimensões do array
int d0 = TotalMap.GetLength(0);
int d1 = TotalMap.GetLength(1);
for (int row = 0; row < d0; row++)
{
for (int col = 0; col < d1; col++)
{
//O valor da posição no array
T index = TotalMap[row, col];
//Recebe o Tile da tabela
if (Map.Table.ContainsKey(index))
{
IsoTile tile = new IsoTile(Map.Table[index]);
//Atualiza todas as animações do tile
//tile.UpdateBounds();
//largura e altura para cálculo
//Usa as configuraçõs do tamanho do tile pela animação
//int w = tile.Animation.Bounds.Width;
//int h = tile.Animation.Bounds.Height;
//Usa as configurações de tamanho geral
int w = TileWidth;
int h = TileHeight;
float sx = StartPosition.X;
float sy = StartPosition.Y;
//O cálculo se dá na animação do topo
//antes o valor de row era positivo
tile.Actor.Transform.X = ((w / 2) * -row) + ((w / 2) * col) + sx;
tile.Actor.Transform.Y = ((h / 2) * col) - ((h / 2) * -row) + sy;
Tiles.Add(new Point(row, col), tile);
}
}
}
IsRead = true;
}
static bool Tile_Erase(ref GameObject target)
{
if (target != null)
{
var tile = IsoTile.Find(target);
if (tile != null)
{
Undo.DestroyObjectImmediate(tile.gameObject);
}
else
{
Undo.DestroyObjectImmediate(target);
}
}
target = null;
return(true);
}
void ToTile_Set()
{
var newTarget = TouchUtility.GetTile_ScreenPos(Cam, Input.mousePosition, exceptionList);
newTarget = FindTopTile(newTarget);
if (newTarget != toTile)
{
ToTile_Reset();
toTile = newTarget;
if (toTile != null && toTile != fromTile)
{
ColoredObject.Start(toTile.gameObject, destinationGradient);
}
}
GhostTile_Update();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Rebuild Sprites"))
{
isoGrid.ClearSprites();
isoGrid.UpdateSprites();
}
if (GUILayout.Button("Clear Sprites"))
{
isoGrid.ClearSprites();
}
if (GUILayout.Button("Fill"))
{
isoGrid.LoadTestGrid();
}
GUILayout.EndHorizontal();
/*if (!editMode && GUILayout.Button("Build Mode")) {
* editMode = true;
* }*/
if (editMode)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Nivel");
level = EditorGUILayout.IntSlider(level, 1, isoGrid.grid.sizeY);
editPlane = new Plane(Vector3.up, new Vector3(0, (level - 1) + isoGrid.heightCorrection * (level - 1), 0));
EditorGUILayout.EndHorizontal();
// Grid de tiles del palette
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
List <Texture> textures = new List <Texture>();
foreach (IsoTile t in isoGrid.palette.tiles)
{
textures.Add(AssetPreview.GetAssetPreview(t.sprite));
}
selected = GUILayout.SelectionGrid(selected, textures.ToArray(), (Screen.width / 50));
selectedTile = selected != -1 ? isoGrid.palette[selected] : null;
EditorGUILayout.EndVertical();
}
}
public static TileWand CreateAsset(string path, IsoTile tile)
{
TileWand newTileWand = ScriptableObject.CreateInstance <TileWand>();
string _path = AssetDatabase.GenerateUniqueAssetPath(path + ".asset");
AssetDatabase.CreateAsset(newTileWand, _path);
GameObject tileGameObject = tile.gameObject;
if (!PrefabHelper.IsPrefab(tileGameObject))
{
tileGameObject = PrefabHelper.CreatePrefab(AssetDatabase.GenerateUniqueAssetPath(path + ".prefab"), tileGameObject);
}
// Revert All Lightings
tile = IsoTile.Find(tileGameObject);
tile.LightRecivers_RevertAll();
tile.LightRecivers_RemoveAll(false);
IsometricSortingOrder iso = tile.GetComponent <IsometricSortingOrder>();
iso.Clear_Backup(false);
newTileWand.Prefab = tileGameObject;
MakeIcon(newTileWand);
if (newTileWand != null)
{
// AssetDatabase.AddObjectToAsset(tilePrefab, newTileWand);
EditorUtility.SetDirty(newTileWand);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
if (newTileWand == null)
{
newTileWand = AssetDatabase.LoadAssetAtPath <TileWand>(_path);
}
return(newTileWand);
}
static bool LowerTile(ref GameObject target)
{
bool bResult = false;
IsoTile tile = IsoTile.Find(target);
IsoTile topTile = null;
if (tile != null)
{
if ((topTile = tile.FindTop()) != null)
{
bResult = topTile.Press(Vector3.down);
}
}
if (!target)
{
target = topTile.gameObject;
}
return(bResult);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
GUILayout.Space(50);
GUILayout.Label("Selected", sectionHeaderStyle);
// Draw selected tile properties
IsoTile tile = palette.tiles[selected];
if (tile != null)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("tiles").GetArrayElementAtIndex(selected).FindPropertyRelative("sprite"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("tiles").GetArrayElementAtIndex(selected).FindPropertyRelative("mesh"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("tiles").GetArrayElementAtIndex(selected).FindPropertyRelative("rotation"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("tiles").GetArrayElementAtIndex(selected).FindPropertyRelative("offsetY"));
}
GUILayout.Space(20);
// Draw tile grid controls
GUILayout.BeginHorizontal();
if (GUILayout.Button("+", GUILayout.Width(40)))
{
palette.tiles.Add(new IsoTile());
}
GUILayout.Button("-", GUILayout.Width(40));
GUILayout.EndHorizontal();
// Draw tile grid
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
List <Texture> textures = new List <Texture>();
foreach (IsoTile t in palette.tiles)
{
textures.Add(AssetPreview.GetAssetPreview(t.sprite));
}
selected = GUILayout.SelectionGrid(selected, textures.ToArray(), (Screen.width / 50));
EditorGUILayout.EndVertical();
serializedObject.ApplyModifiedProperties();
}
public override GameObject TargetGameObject(GameObject target)
{
IsoTile tile = IsoTile.Find(target);
if (tile)
{
switch (type)
{
case Type.Tile_Control_Raise:
tile = tile.FindTop();
break;
case Type.Tile_Control_Lower:
tile = tile.FindTop();
break;
}
}
return(tile != null ? tile.gameObject : null);
}
public static bool Tile_Create(ref GameObject target, Vector3 position, IsoTile refTile, bool bIncludeBody, bool bIncludeAttachments, bool bAutoIsoLight, IsoTileBulk bulk)
{
var bulks = IsoMap.instance.BulkList;
if (bulk == null)
{
float fMin = float.MaxValue;
for (int i = 0; i < bulks.Count; ++i)
{
float fDistance = Vector3.Distance(position, bulks[i].GetBounds().ClosestPoint(position));
if (fDistance < fMin)
{
bulk = bulks[i];
fMin = fDistance;
}
}
if (bulk == null)
{
Debug.LogWarning("To create a tile, you need at least one Bulk in the Scene.");
return(false);
}
}
IsoTile tile = bulk.NewTile(position - bulk.transform.position, false);
if (tile == null)
{
return(false);
}
target = tile.gameObject;
if (refTile != null)
{
tile.Copycat(refTile, bIncludeBody, bIncludeAttachments, true);
}
return(true);
}
void FromTile_UnSelectTile()
{
bool unSelect = false;
switch (eventType)
{
case TouchUtility.EventType.Mouse:
unSelect = Input.GetMouseButtonUp(0);
break;
case TouchUtility.EventType.Touch:
unSelect = Input.touchCount == 0;
break;
}
if (unSelect)
{
if (fromTile != null)
{
ColoredObject.End(fromTile.gameObject);
}
if (fromTile != toTile)
{
FromTile_Move();
}
if (ghostTileInstance != null)
{
exceptionList.Remove(ghostTileInstance);
Destroy(ghostTileInstance.gameObject);
ghostTileInstance = null;
}
ToTile_Reset();
exceptionList.Clear();
toTile = fromTile = null;
}
}
static bool RaiseTile(ref GameObject target)
{
IsoTile targetTile = IsoTile.Find(target);
IsoTile topTile = null, leftTile = null;
if (targetTile != null)
{
if ((topTile = targetTile.FindTop()) != null)
{
leftTile = topTile.Extrude(Vector3.up, false);
}
if (topTile == targetTile && leftTile != null)
{
target = leftTile.gameObject;
}
else
{
target = targetTile.gameObject;
}
}
return(targetTile != null);
}
public static void Iso2DObjectField(SerializedObject _Iso2DSerializedObject)
{
_Iso2DSerializedObject.Update();
SerializedProperty vScaler = _Iso2DSerializedObject.FindProperty("localScale");
SerializedProperty vRotator = _Iso2DSerializedObject.FindProperty("localRotation");
Iso2DObject _Iso2D = (Iso2DObject)_Iso2DSerializedObject.targetObject;
IsoTile _parentTile = _Iso2D.GetComponentInParent <IsoTile>();
SpriteRenderer sprr = _Iso2D.GetComponent <SpriteRenderer>();
//_Iso2D._Type = (Iso2DObject.Type) EditorGUILayout.EnumPopup("Type", _Iso2D._Type);
EditorGUI.indentLevel = 0;
Undo_Iso2DSpriteField(_Iso2D, Color.cyan);
EditorGUILayout.LabelField("Type : " + _Iso2D._Type);
float iWidth = EditorGUIUtility.currentViewWidth / 2 - 4;
EditorGUILayout.BeginHorizontal();
using (new EditorGUILayout.VerticalScope(
GUILayout.MaxWidth(iWidth)))
{
GUILayout.Space(5);
Iso2DObjectEditor.Max_Slider = Mathf.Max(new float[] { 1f, vScaler.vector3Value.x, vScaler.vector3Value.y,
EditorGUILayout.FloatField("Cap of Scale Slider", Iso2DObjectEditor.Max_Slider) });
vScaler.vector3Value = Vector3Slider(vScaler.vector3Value, Vector3.one, "[Scale]",
-Iso2DObjectEditor.Max_Slider * Vector3.one, Iso2DObjectEditor.Max_Slider * Vector3.one, iWidth);
// vScaler.vector3Value = EditorGUILayout.Vector3Field("",vScaler.vector3Value, GUILayout.MaxWidth(iWidth));
using (new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.LabelField("Flip", GUILayout.MaxWidth(iWidth * 0.3f));
if (GUILayout.Button("X", EditorStyles.miniButton, GUILayout.MaxWidth(iWidth * 0.3f)))
{
vScaler.vector3Value = Vector3.Scale(vScaler.vector3Value, new Vector3(-1, 1, 1));
}
if (GUILayout.Button("Y", EditorStyles.miniButton, GUILayout.MaxWidth(iWidth * 0.3f)))
{
vScaler.vector3Value = Vector3.Scale(vScaler.vector3Value, new Vector3(1, -1, 1));
}
}
EditorGUI.BeginChangeCheck();
EditorGUILayout.ToggleLeft(
string.Format("Use Global PPU Scale(x{0:0.00})", _Iso2D.PPURefScale),
_Iso2D.bApplyPPUScale, GUILayout.MaxWidth(iWidth));
if (EditorGUI.EndChangeCheck())
{
_Iso2D.Toggle_ApplyPPUScale();
}
EditorGUI.indentLevel++;
EditorGUILayout.HelpBox("Global PPU Scale = Source PPU / Ref PPU", MessageType.None);
EditorGUILayout.LabelField(
"Image Source PPU " + sprr.sprite.pixelsPerUnit,
GUILayout.MaxWidth(iWidth));
EditorGUILayout.LabelField(
"IsoMap Reference PPU " + IsoMap.instance.ReferencePPU,
GUILayout.MaxWidth(iWidth));
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
Util.CustomEditorGUI.NewParagraph("[Rotation]");
EditorGUILayout.LabelField("Tile local rotation adjustment", GUILayout.MaxWidth(iWidth));
vRotator.vector3Value = EditorGUILayout.Vector3Field("", vRotator.vector3Value, GUILayout.MaxWidth(iWidth));
EditorGUILayout.LabelField(
string.Format("+ global tile rotation(X {0}, Y {1})",
IsoMap.instance.TileAngle.x,
IsoMap.instance.TileAngle.y), GUILayout.MaxWidth(iWidth));
EditorGUILayout.Separator();
//EditorGUILayout.EndVertical();
//GUILayout.EndArea();
}
drawPackedTexture(_Iso2D, Mathf.Min(125f, iWidth * 0.75f));
EditorGUILayout.EndHorizontal();
if (_parentTile != null && _Iso2D.gameObject != _parentTile.gameObject)
{
EditorGUILayout.Separator();
Util.CustomEditorGUI.NewParagraph("[Object Selector]");
if (_Iso2D.RC != null)
{
Util.CustomEditorGUI.ComSelector <RegularCollider>(_Iso2D.RC, "GO Controller");
}
else
{
CustomEditorGUI.ComSelector <SubColliderHelper>(_Iso2D.SC, "GO SubCollider");
}
Util.CustomEditorGUI.ComSelector <IsoTile>(_parentTile, "GO IsoTile");
}
_Iso2DSerializedObject.ApplyModifiedProperties();
}
public MapTile GetTile(IsoTile isoTile)
{
return(this[isoTile.Dx, isoTile.Dy / 2]);
}
public override GameObject TargetGameObject(GameObject target)
{
IsoTile tile = IsoTile.Find(target);
return(tile != null ? tile.gameObject : null);
}
