mirror of
https://github.com/BlackMATov/unity-iso-tools.git
synced 2025-12-14 17:09:31 +07:00
290 lines
7.8 KiB
C#
290 lines
7.8 KiB
C#
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
|
|
namespace IsoTools {
|
|
[ExecuteInEditMode]
|
|
public class IsoWorld : MonoBehaviour {
|
|
|
|
/// <summary>World tile types.</summary>
|
|
public enum TileTypes {
|
|
Isometric,
|
|
UpDown
|
|
}
|
|
|
|
/// <summary>World tile type.</summary>
|
|
public TileTypes TileType = TileTypes.Isometric;
|
|
/// <summary>Isometric tile size.</summary>
|
|
public float TileSize = 32.0f;
|
|
/// <summary>Start sorting depth value.</summary>
|
|
public float MinDepth = 0.0f;
|
|
/// <summary>Step sorting depth value.</summary>
|
|
public float MaxDepth = 100.0f;
|
|
|
|
class ObjectInfo {
|
|
public IsoObject IsoObject;
|
|
public bool Visited;
|
|
public int BeginDepend;
|
|
public int EndDepend;
|
|
public ObjectInfo(IsoObject obj) {
|
|
IsoObject = obj;
|
|
}
|
|
public void Reset(int first_depend) {
|
|
Visited = false;
|
|
BeginDepend = first_depend;
|
|
EndDepend = first_depend;
|
|
}
|
|
}
|
|
|
|
bool _dirty = true;
|
|
float _lastTileSize = 0.0f;
|
|
TileTypes _lastTileType = TileTypes.Isometric;
|
|
|
|
// ------------------------------------------------------------------------
|
|
/// <summary>
|
|
/// Marks world for resorting.
|
|
/// </summary>
|
|
// ------------------------------------------------------------------------
|
|
public void MarkDirty() {
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Marks world for resorting one object only
|
|
/// </summary>
|
|
/// <param name="obj">Isometric object for resorting.</param>
|
|
public void MarkDirty(IsoObject obj) {
|
|
if ( !_dirty ) {
|
|
_manualSort(obj);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
/// <summary>
|
|
/// Convert isometric coordinates to screen coordinates
|
|
/// </summary>
|
|
/// <returns>Screen coordinates</returns>
|
|
/// <param name="pos">Isometric coordinates.</param>
|
|
// ------------------------------------------------------------------------
|
|
public Vector2 IsoToScreen(Vector3 pos) {
|
|
switch ( TileType ) {
|
|
case TileTypes.Isometric:
|
|
return new Vector2(
|
|
(pos.x - pos.y),
|
|
(pos.x + pos.y) * 0.5f + pos.z) * TileSize;
|
|
case TileTypes.UpDown:
|
|
return new Vector2(
|
|
pos.x,
|
|
pos.y + pos.z) * TileSize;
|
|
default:
|
|
throw new UnityException("IsoWorld. Type is wrong!");
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
/// <summary>
|
|
/// Convert screen coordinates to isometric coordinates
|
|
/// </summary>
|
|
/// <returns>Isometric coordinates</returns>
|
|
/// <param name="pos">Screen coordinates.</param>
|
|
// ------------------------------------------------------------------------
|
|
public Vector3 ScreenToIso(Vector2 pos) {
|
|
switch ( TileType ) {
|
|
case TileTypes.Isometric:
|
|
return new Vector3(
|
|
(pos.x * 0.5f + pos.y),
|
|
(pos.y - pos.x * 0.5f),
|
|
0.0f) / TileSize;
|
|
case TileTypes.UpDown:
|
|
return new Vector3(
|
|
pos.x,
|
|
pos.y,
|
|
0.0f) / TileSize;
|
|
default:
|
|
throw new UnityException("IsoWorld. Type is wrong!");
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
/// <summary>
|
|
/// Convert screen coordinates to isometric coordinates with specified isometric height
|
|
/// </summary>
|
|
/// <returns>Isometric coordinates</returns>
|
|
/// <param name="pos">Screen coordinates.</param>
|
|
/// <param name="iso_z">Point isometric height.</param>
|
|
// ------------------------------------------------------------------------
|
|
public Vector3 ScreenToIso(Vector2 pos, float iso_z) {
|
|
switch ( TileType ) {
|
|
case TileTypes.Isometric: {
|
|
var iso_pos = ScreenToIso(new Vector2(pos.x, pos.y - iso_z * TileSize));
|
|
iso_pos.z = iso_z;
|
|
return iso_pos;
|
|
}
|
|
case TileTypes.UpDown: {
|
|
var iso_pos = ScreenToIso(new Vector2(pos.x, pos.y - iso_z * TileSize));
|
|
iso_pos.z = iso_z;
|
|
return iso_pos;
|
|
}
|
|
default:
|
|
throw new UnityException("IsoWorld. Type is wrong!");
|
|
}
|
|
}
|
|
|
|
void _fixAllTransforms() {
|
|
var objects = _scanObjects(false);
|
|
foreach ( var obj in objects ) {
|
|
obj.IsoObject.FixTransform();
|
|
}
|
|
}
|
|
|
|
void _fixTileSize() {
|
|
MarkDirty();
|
|
_fixAllTransforms();
|
|
_lastTileSize = TileSize;
|
|
}
|
|
|
|
void _fixTileType() {
|
|
MarkDirty();
|
|
_fixAllTransforms();
|
|
_lastTileType = TileType;
|
|
}
|
|
|
|
void _fixDirty() {
|
|
_manualSort();
|
|
Debug.Log("Resort!");
|
|
_dirty = false;
|
|
}
|
|
|
|
void _fixDisable() {
|
|
var objects = _scanObjects(false);
|
|
foreach ( var obj in objects ) {
|
|
obj.IsoObject.ResetIsoWorld();
|
|
}
|
|
}
|
|
|
|
IList<ObjectInfo> _scanObjects(bool onlySorting) {
|
|
var iso_objects = GameObject.FindObjectsOfType<IsoObject>();
|
|
var objects = new List<ObjectInfo>(iso_objects.Length);
|
|
foreach ( var iso_object in iso_objects ) {
|
|
if ( !onlySorting || iso_object.Sorting ) {
|
|
var info = new ObjectInfo(iso_object);
|
|
objects.Add(info);
|
|
}
|
|
}
|
|
return objects;
|
|
}
|
|
|
|
IList<int> _scanDepends(IList<ObjectInfo> objects) {
|
|
var depends = new List<int>(objects.Count);
|
|
foreach ( var obj_a in objects ) {
|
|
obj_a.Reset(depends.Count);
|
|
var obj_ao = obj_a.IsoObject;
|
|
var max_ax = obj_ao.Position.x + obj_ao.Size.x;
|
|
var max_ay = obj_ao.Position.y + obj_ao.Size.y;
|
|
for ( int i = 0; i < objects.Count; ++i ) {
|
|
var obj_bo = objects[i].IsoObject;
|
|
if ( obj_ao != obj_bo ) {
|
|
if ( obj_bo.Position.x < max_ax && obj_bo.Position.y < max_ay ) {
|
|
var max_bz = obj_bo.Position.z + obj_bo.Size.z;
|
|
if ( obj_ao.Position.z < max_bz ) {
|
|
depends.Add(i);
|
|
++obj_a.EndDepend;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return depends;
|
|
}
|
|
|
|
void _manualSort() {
|
|
var objects = _scanObjects(true);
|
|
var depends = _scanDepends(objects);
|
|
var depth = MinDepth;
|
|
foreach ( var info in objects ) {
|
|
_placeObject(info, objects, depends, ref depth);
|
|
}
|
|
}
|
|
|
|
bool _isDepends(IsoObject obj_ao, IsoObject obj_bo) {
|
|
if ( obj_ao != obj_bo ) {
|
|
var max_ax = obj_ao.Position.x + obj_ao.Size.x;
|
|
var max_ay = obj_ao.Position.y + obj_ao.Size.y;
|
|
if ( obj_bo.Position.x < max_ax && obj_bo.Position.y < max_ay ) {
|
|
var max_bz = obj_bo.Position.z + obj_bo.Size.z;
|
|
if ( obj_ao.Position.z < max_bz ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void _manualSort(IsoObject obj) {
|
|
var objects = _scanObjects(true);
|
|
var min_depth = float.MinValue;
|
|
foreach ( var obj_b in objects ) {
|
|
if ( _isDepends(obj, obj_b.IsoObject) ) {
|
|
min_depth = Mathf.Max(min_depth, obj_b.IsoObject.transform.position.z);
|
|
}
|
|
}
|
|
var max_depth = float.MaxValue;
|
|
foreach ( var obj_a in objects ) {
|
|
if ( _isDepends(obj_a.IsoObject, obj) ) {
|
|
max_depth = Mathf.Min(max_depth, obj_a.IsoObject.transform.position.z);
|
|
}
|
|
}
|
|
if ( max_depth == float.MaxValue ) {
|
|
max_depth = MaxDepth;
|
|
}
|
|
if ( min_depth == float.MinValue ) {
|
|
min_depth = MinDepth;
|
|
}
|
|
//TODO: Epsilon!!!!!
|
|
if ( Mathf.Abs(max_depth - min_depth) <= Mathf.Epsilon ) {
|
|
MarkDirty();
|
|
} else {
|
|
_placeObject(obj, (min_depth + max_depth) / 2.0f);
|
|
}
|
|
}
|
|
|
|
void _placeObject(IsoObject obj, float depth) {
|
|
var pos = obj.gameObject.transform.position;
|
|
obj.gameObject.transform.position = new Vector3(pos.x, pos.y, depth);
|
|
}
|
|
|
|
void _placeObject(ObjectInfo info, IList<ObjectInfo> objects, IList<int> depends, ref float depth) {
|
|
if ( !info.Visited ) {
|
|
info.Visited = true;
|
|
for ( int i = info.BeginDepend; i < info.EndDepend && i < depends.Count; ++i ) {
|
|
var object_index = depends[i];
|
|
var obj = objects[object_index];
|
|
_placeObject(obj, objects, depends, ref depth);
|
|
}
|
|
_placeObject(info.IsoObject, depth);
|
|
depth += (MaxDepth - MinDepth) / objects.Count;
|
|
}
|
|
}
|
|
|
|
void Start() {
|
|
_fixTileSize();
|
|
_fixTileType();
|
|
_fixDirty();
|
|
}
|
|
|
|
void LateUpdate() {
|
|
if ( _lastTileSize != TileSize ) {
|
|
_fixTileSize();
|
|
}
|
|
if ( _lastTileType != TileType ) {
|
|
_fixTileType();
|
|
}
|
|
if ( _dirty ) {
|
|
_fixDirty();
|
|
}
|
|
}
|
|
|
|
void OnDisable() {
|
|
_fixDisable();
|
|
}
|
|
}
|
|
} // namespace IsoTools |