physics to addons

Assets/IsoTools/Addons/Physics.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 8dd47e4d38ef9485586318e48755aff9
+folderAsset: yes
+timeCreated: 1480174284
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e3a035a6c93424c7a98d81c8cb5aad1c
+folderAsset: yes
+timeCreated: 1480174340
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoFakeCollider.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace IsoTools.Physics.Internal {
+	public class IsoFakeCollider : MonoBehaviour {
+		IsoCollider _isoCollider = null;
+
+		public IsoFakeCollider Init(IsoCollider iso_collider) {
+			_isoCollider = iso_collider;
+			return this;
+		}
+		
+		public IsoCollider isoCollider {
+			get { return _isoCollider; }
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoFakeCollider.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e6013de6edf894f15b4b45e011afe2a4
+timeCreated: 1436271657
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoFakeCollisionListener.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace IsoTools.Physics.Internal {
+	public class IsoFakeCollisionListener : MonoBehaviour {
+		GameObject _realGameObject = null;
+
+		public IsoFakeCollisionListener Init(IsoCollisionListener iso_listener) {
+			_realGameObject = iso_listener.gameObject;
+			return this;
+		}
+
+		void OnCollisionEnter(Collision collision) {
+			_realGameObject.SendMessage(
+				"OnIsoCollisionEnter",
+				new IsoCollision(collision),
+				SendMessageOptions.DontRequireReceiver);
+		}
+
+		void OnCollisionExit(Collision collision) {
+			_realGameObject.SendMessage(
+				"OnIsoCollisionExit",
+				new IsoCollision(collision),
+				SendMessageOptions.DontRequireReceiver);
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoFakeCollisionListener.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b3ba702b17e9f4b85aad7b29b1a06eed
+timeCreated: 1461097028
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoFakeObject.cs

@@ -0,0 +1,35 @@
+using UnityEngine;
+
+namespace IsoTools.Physics.Internal {
+	public class IsoFakeObject : MonoBehaviour {
+
+		IsoObject _isoObject    = null;
+		Vector3   _lastPosition = Vector3.zero;
+
+		public void Init(IsoObject iso_object) {
+			_isoObject         = iso_object;
+			_lastPosition      = iso_object.position;
+			transform.position = iso_object.position;
+		}
+
+		public IsoObject isoObject {
+			get { return _isoObject; }
+		}
+
+		void CheckLayers() {
+			var iso_object_layer = isoObject.gameObject.layer;
+			if ( gameObject.layer != iso_object_layer ) {
+				gameObject.layer = iso_object_layer;
+			}
+		}
+
+		void FixedUpdate() {
+			CheckLayers();
+			if ( _lastPosition != isoObject.position ) {
+				_lastPosition = transform.position = isoObject.position;
+			} else if ( _lastPosition != transform.position ) {
+				_lastPosition = isoObject.position = transform.position;
+			}
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoFakeObject.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 84780b4561da348638be7996e45f96aa
+timeCreated: 1434281884
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoFakeRigidbody.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace IsoTools.Physics.Internal {
+	public class IsoFakeRigidbody : MonoBehaviour {
+		IsoRigidbody _isoRigidbody = null;
+		
+		public IsoFakeRigidbody Init(IsoRigidbody iso_rigidbody) {
+			_isoRigidbody = iso_rigidbody;
+			return this;
+		}
+		
+		public IsoRigidbody isoRigidbody {
+			get { return _isoRigidbody; }
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoFakeRigidbody.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c68ba79b8c53c4643b17ed586ffbbab8
+timeCreated: 1436374575
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoFakeTriggerListener.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace IsoTools.Physics.Internal {
+	public class IsoFakeTriggerListener : MonoBehaviour {
+		GameObject _realGameObject = null;
+
+		public IsoFakeTriggerListener Init(IsoTriggerListener iso_listener) {
+			_realGameObject = iso_listener.gameObject;
+			return this;
+		}
+
+		void OnTriggerEnter(Collider collider) {
+			_realGameObject.SendMessage(
+				"OnIsoTriggerEnter",
+				IsoPhysicsUtils.IsoConvertCollider(collider),
+				SendMessageOptions.DontRequireReceiver);
+		}
+
+		void OnTriggerExit(Collider collider) {
+			_realGameObject.SendMessage(
+				"OnIsoTriggerExit",
+				IsoPhysicsUtils.IsoConvertCollider(collider),
+				SendMessageOptions.DontRequireReceiver);
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoFakeTriggerListener.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 85a92cf713a8c4da68454e88e803bbce
+timeCreated: 1461097013
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoPhysicsHelper.cs

@@ -0,0 +1,31 @@
+using UnityEngine;
+
+namespace IsoTools.Physics.Internal {
+	[DisallowMultipleComponent]
+	[RequireComponent(typeof(IsoObject))]
+	public class IsoPhysicsHelper : MonoBehaviour {
+
+		GameObject _isoFakeObject = null;
+		public GameObject isoFakeObject {
+			get { return _isoFakeObject; }
+		}
+
+		void Awake() {
+			hideFlags = HideFlags.HideInInspector;
+			var iso_object = GetComponent<IsoObject>();
+			if ( iso_object ) {
+				_isoFakeObject = new GameObject("_Fake" + gameObject.name);
+				_isoFakeObject.AddComponent<IsoFakeObject>().Init(iso_object);
+				_isoFakeObject.hideFlags = HideFlags.HideInHierarchy | HideFlags.NotEditable;
+				GameObject.DontDestroyOnLoad(_isoFakeObject);
+			}
+		}
+
+		void OnDestroy() {
+			if ( _isoFakeObject ) {
+				DestroyImmediate(_isoFakeObject);
+				_isoFakeObject = null;
+			}
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoPhysicsHelper.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 02be875c33a5b4b2799ff198d4c93806
+timeCreated: 1434298128
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoPhysicsHelperHolder.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+using IsoTools.Internal;
+using System.Collections.Generic;
+
+namespace IsoTools.Physics.Internal {
+	public class IsoPhysicsHelperHolder : MonoBehaviour {
+
+		static List<IsoPhysicsHelperHolder> _tmpHolders = new List<IsoPhysicsHelperHolder>(7);
+
+		protected GameObject fakeObject {
+			get { return physicsHelper.isoFakeObject; }
+		}
+
+		protected IsoPhysicsHelper physicsHelper {
+			get { return IsoUtils.GetOrCreateComponent<IsoPhysicsHelper>(gameObject); }
+		}
+
+		protected void DestroyUnnecessaryCheck() {
+			GetComponents<IsoPhysicsHelperHolder>(_tmpHolders);
+			if ( _tmpHolders.Count == 1 && _tmpHolders[0] == this ) {
+				Destroy(physicsHelper);
+			}
+			_tmpHolders.Clear();
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoPhysicsHelperHolder.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 24e253f6697d448229f535a2e796f72b
+timeCreated: 1461163442
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/Internal/IsoPhysicsUtils.cs

@@ -0,0 +1,37 @@
+using UnityEngine;
+
+namespace IsoTools.Physics.Internal {
+	public static class IsoPhysicsUtils {
+		public static IsoCollider IsoConvertCollider(Collider collider) {
+			var fake_collider = collider ? collider.GetComponent<IsoFakeCollider>() : null;
+			return fake_collider ? fake_collider.isoCollider : null;
+		}
+
+		public static IsoRigidbody IsoConvertRigidbody(Rigidbody rigidbody) {
+			var fake_rigidbody = rigidbody ? rigidbody.GetComponent<IsoFakeRigidbody>() : null;
+			return fake_rigidbody ? fake_rigidbody.isoRigidbody : null;
+		}
+
+		public static GameObject IsoConvertGameObject(GameObject game_object) {
+			var fake_object = game_object ? game_object.GetComponent<IsoFakeObject>() : null;
+			var iso_object = fake_object ? fake_object.isoObject : null;
+			return iso_object ? iso_object.gameObject : null;
+		}
+
+		public static IsoContactPoint[] IsoConvertContactPoints(ContactPoint[] points) {
+			var iso_points = new IsoContactPoint[points.Length];
+			for ( int i = 0, e = points.Length; i < e; ++i ) {
+				iso_points[i] = new IsoContactPoint(points[i]);
+			}
+			return iso_points;
+		}
+
+		public static IsoRaycastHit[] IsoConvertRaycastHits(RaycastHit[] hits) {
+			var iso_hits = new IsoRaycastHit[hits.Length];
+			for ( int i = 0, e = hits.Length; i < e; ++i ) {
+				iso_hits[i] = new IsoRaycastHit(hits[i]);
+			}
+			return iso_hits;
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/Internal/IsoPhysicsUtils.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0d44532ca15804cdc997583d81cf4df1
+timeCreated: 1480196616
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoBoxCollider.cs

@@ -0,0 +1,77 @@
+using UnityEngine;
+using IsoTools.Internal;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace IsoTools.Physics {
+	[RequireComponent(typeof(IsoObject))]
+	public class IsoBoxCollider : IsoCollider {
+
+		[SerializeField]
+		public Vector3 _size = Vector3.zero;
+		public Vector3 size {
+			get { return _size; }
+			set {
+				_size = value;
+				if ( realBoxCollider ) {
+					realBoxCollider.size = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public Vector3 _offset = Vector3.zero;
+		public Vector3 offset {
+			get { return _offset; }
+			set {
+				_offset = value;
+				if ( realBoxCollider ) {
+					realBoxCollider.center = value;
+				}
+			}
+		}
+
+		protected override Collider CreateRealCollider(GameObject target) {
+			var collider    = target.AddComponent<BoxCollider>();
+			collider.size   = size;
+			collider.center = offset;
+			return collider;
+		}
+
+		public BoxCollider realBoxCollider {
+			get { return realCollider as BoxCollider; }
+		}
+
+	#if UNITY_EDITOR
+		protected override void Reset() {
+			base.Reset();
+			var iso_object      = GetComponent<IsoObject>();
+			var iso_object_size = iso_object ? iso_object.size : Vector3.zero;
+			size                = iso_object_size;
+			offset              = iso_object_size * 0.5f;
+			EditorUtility.SetDirty(this);
+		}
+
+		protected override void OnValidate() {
+			base.OnValidate();
+			if ( realBoxCollider ) {
+				realBoxCollider.size   = size;
+				realBoxCollider.center = offset;
+			}
+		}
+
+		void OnDrawGizmosSelected() {
+			var iso_object = GetComponent<IsoObject>();
+			if ( iso_object && iso_object.isoWorld ) {
+				IsoUtils.DrawCube(
+					iso_object.isoWorld,
+					iso_object.position + offset,
+					size,
+					Color.green);
+			}
+		}
+	#endif
+	}
+}

Assets/IsoTools/Addons/Physics/IsoBoxCollider.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b256250c588ee4e4590a3e58eaa69b1d
+timeCreated: 1434220443
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoCapsuleCollider.cs

@@ -0,0 +1,111 @@
+using UnityEngine;
+using IsoTools.Internal;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace IsoTools.Physics {
+	[RequireComponent(typeof(IsoObject))]
+	public class IsoCapsuleCollider : IsoCollider {
+
+		[SerializeField]
+		public float _height = 0.0f;
+		public float height {
+			get { return _height; }
+			set {
+				_height = value;
+				if ( realCapsuleCollider ) {
+					realCapsuleCollider.height = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public float _radius = 0.0f;
+		public float radius {
+			get { return _radius; }
+			set {
+				_radius = value;
+				if ( realCapsuleCollider ) {
+					realCapsuleCollider.radius = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public Vector3 _offset = Vector3.zero;
+		public Vector3 offset {
+			get { return _offset; }
+			set {
+				_offset = value;
+				if ( realCapsuleCollider ) {
+					realCapsuleCollider.center = value;
+				}
+			}
+		}
+
+		protected override Collider CreateRealCollider(GameObject target) {
+			var collider       = target.AddComponent<CapsuleCollider>();
+			collider.height    = height;
+			collider.radius    = radius;
+			collider.center    = offset;
+			collider.direction = 2; // z-axis
+			return collider;
+		}
+
+		public CapsuleCollider realCapsuleCollider {
+			get { return realCollider as CapsuleCollider; }
+		}
+
+	#if UNITY_EDITOR
+		protected override void Reset() {
+			base.Reset();
+			var iso_object      = GetComponent<IsoObject>();
+			var iso_object_size = iso_object ? iso_object.size : Vector3.zero;
+			height              = iso_object.size.z;
+			radius              = IsoUtils.Vec3MinF(iso_object_size) * 0.5f;
+			offset              = iso_object_size * 0.5f;
+			EditorUtility.SetDirty(this);
+		}
+
+		protected override void OnValidate() {
+			base.OnValidate();
+			if ( realCapsuleCollider ) {
+				realCapsuleCollider.height = height;
+				realCapsuleCollider.radius = radius;
+				realCapsuleCollider.center = offset;
+			}
+		}
+
+		void OnDrawGizmosSelected() {
+			var iso_object = GetComponent<IsoObject>();
+			if ( iso_object && iso_object.isoWorld ) {
+				if ( radius * 2 < height ) {
+					IsoUtils.DrawCube(
+						iso_object.isoWorld,
+						iso_object.position + offset,
+						new Vector3(radius * 2.0f, radius * 2.0f, height - radius),
+						Color.green);
+					IsoUtils.DrawSphere(
+						iso_object.isoWorld,
+						iso_object.position + offset - IsoUtils.Vec3FromZ(height * 0.5f - radius),
+						radius,
+						Color.green);
+					IsoUtils.DrawSphere(
+						iso_object.isoWorld,
+						iso_object.position + offset + IsoUtils.Vec3FromZ(height * 0.5f - radius),
+						radius,
+						Color.green);
+				} else {
+					IsoUtils.DrawSphere(
+						iso_object.isoWorld,
+						iso_object.position + offset,
+						radius,
+						Color.green);
+				}
+			}
+		}
+	#endif
+	}
+}

Assets/IsoTools/Addons/Physics/IsoCapsuleCollider.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d4d35c70ee62a44288b95ff88ca8e87c
+timeCreated: 1461359219
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoCollider.cs

@@ -0,0 +1,129 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace IsoTools.Physics {
+	[RequireComponent(typeof(IsoObject))]
+	public abstract class IsoCollider : IsoPhysicsHelperHolder {
+		protected abstract Collider CreateRealCollider(GameObject target);
+
+		IsoFakeCollider _fakeCollider;
+
+		Collider _realCollider = null;
+		protected Collider realCollider {
+			get { return _realCollider; }
+		}
+
+		[SerializeField]
+		public PhysicMaterial _material  = null;
+		public PhysicMaterial material {
+			get { return _material; }
+			set {
+				_material = value;
+				if ( realCollider ) {
+					realCollider.material = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public bool _isTrigger = false;
+		public bool isTrigger {
+			get { return _isTrigger; }
+			set {
+				_isTrigger = value;
+				if ( realCollider ) {
+					realCollider.isTrigger = value;
+				}
+			}
+		}
+
+		public IsoRigidbody attachedRigidbody {
+			get {
+				return realCollider
+					? IsoPhysicsUtils.IsoConvertRigidbody(realCollider.attachedRigidbody)
+					: null;
+			}
+		}
+
+		public Bounds bounds {
+			get {
+				return realCollider
+					? realCollider.bounds
+					: new Bounds();
+			}
+		}
+
+		public float contactOffset {
+			get {
+				return realCollider
+					? realCollider.contactOffset
+					: 0.0f;
+			} set {
+				if ( realCollider ) {
+					realCollider.contactOffset = value;
+				}
+			}
+		}
+
+		public Vector3 ClosestPointOnBounds(Vector3 position) {
+			return realCollider
+				? realCollider.ClosestPointOnBounds(position)
+				: Vector3.zero;
+		}
+
+		public bool Raycast(Ray ray, out IsoRaycastHit iso_hit_info, float max_distance) {
+			var hit_info = new RaycastHit();
+			var result = realCollider
+				? realCollider.Raycast(ray, out hit_info, max_distance)
+				: false;
+			iso_hit_info = result ? new IsoRaycastHit(hit_info) : new IsoRaycastHit();
+			return result;
+		}
+
+		void Awake() {
+			_fakeCollider           = fakeObject.AddComponent<IsoFakeCollider>().Init(this);
+			_realCollider           = CreateRealCollider(fakeObject);
+			_realCollider.material  = material;
+			_realCollider.isTrigger = isTrigger;
+		}
+
+		void OnEnable() {
+			if ( realCollider ) {
+				realCollider.enabled = true;
+			}
+		}
+
+		void OnDisable() {
+			if ( realCollider ) {
+				realCollider.enabled = false;
+			}
+		}
+
+		void OnDestroy() {
+			if ( _realCollider ) {
+				Destroy(_realCollider);
+			}
+			if ( _fakeCollider ) {
+				Destroy(_fakeCollider);
+			}
+			DestroyUnnecessaryCheck();
+		}
+
+	#if UNITY_EDITOR
+		protected virtual void Reset() {
+			material  = null;
+			isTrigger = false;
+			EditorUtility.SetDirty(this);
+		}
+
+		protected virtual void OnValidate() {
+			material  = _material;
+			isTrigger = _isTrigger;
+		}
+	#endif
+	}
+}

Assets/IsoTools/Addons/Physics/IsoCollider.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7bea029ebf6f04de6881354d27cb4193
+timeCreated: 1434264681
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoCollision.cs

@@ -0,0 +1,23 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+namespace IsoTools.Physics {
+	public class IsoCollision {
+
+		public IsoCollider       collider         { get; private set; }
+		public IsoContactPoint[] contacts         { get; private set; }
+		public GameObject        gameObject       { get; private set; }
+		public Vector3           impulse          { get; private set; }
+		public Vector3           relativeVelocity { get; private set; }
+		public IsoRigidbody      rigidbody        { get; private set; }
+
+		public IsoCollision(Collision collision) {
+			collider         = IsoPhysicsUtils.IsoConvertCollider(collision.collider);
+			contacts         = IsoPhysicsUtils.IsoConvertContactPoints(collision.contacts);
+			gameObject       = IsoPhysicsUtils.IsoConvertGameObject(collision.gameObject);
+			impulse          = collision.impulse;
+			relativeVelocity = collision.relativeVelocity;
+			rigidbody        = IsoPhysicsUtils.IsoConvertRigidbody(collision.rigidbody);
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/IsoCollision.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6a0c6ad7ad6d84258be23c24fad58b84
+timeCreated: 1436119603
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoCollisionListener.cs

@@ -0,0 +1,22 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+namespace IsoTools.Physics {
+	[DisallowMultipleComponent]
+	[RequireComponent(typeof(IsoObject))]
+	public class IsoCollisionListener : IsoPhysicsHelperHolder {
+
+		IsoFakeCollisionListener _fakeListener;
+
+		void Awake() {
+			_fakeListener = fakeObject.AddComponent<IsoFakeCollisionListener>().Init(this);
+		}
+
+		void OnDestroy() {
+			if ( _fakeListener ) {
+				Destroy(_fakeListener);
+			}
+			DestroyUnnecessaryCheck();
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/IsoCollisionListener.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c9634e461d1e942de8174ee80528a2d3
+timeCreated: 1461096905
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoContactPoint.cs

@@ -0,0 +1,21 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+namespace IsoTools.Physics {
+	public struct IsoContactPoint {
+
+		public Vector3     normal        { get; private set; }
+		public IsoCollider otherCollider { get; private set; }
+		public Vector3     point         { get; private set; }
+		public float       separation    { get; private set; }
+		public IsoCollider thisCollider  { get; private set; }
+
+		public IsoContactPoint(ContactPoint contact_point) : this() {
+			normal        = contact_point.normal;
+			otherCollider = IsoPhysicsUtils.IsoConvertCollider(contact_point.otherCollider);
+			point         = contact_point.point;
+			separation    = contact_point.separation;
+			thisCollider  = IsoPhysicsUtils.IsoConvertCollider(contact_point.thisCollider);
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/IsoContactPoint.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 121a2248ec18d4aa4be6bec03265e86e
+timeCreated: 1436119761
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoPhysics.cs

@@ -0,0 +1,120 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+namespace IsoTools.Physics {
+	public static class IsoPhysics {
+
+		//
+		// Raycast
+		//
+
+		public static bool Raycast(Ray ray, out IsoRaycastHit iso_hit_info) {
+			return Raycast(ray, out iso_hit_info,
+				Mathf.Infinity, UnityEngine.Physics.DefaultRaycastLayers,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static bool Raycast(Ray ray, out IsoRaycastHit iso_hit_info,
+			float max_distance)
+		{
+			return Raycast(ray, out iso_hit_info,
+				max_distance, UnityEngine.Physics.DefaultRaycastLayers,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static bool Raycast(Ray ray, out IsoRaycastHit iso_hit_info,
+			float max_distance, int layer_mask)
+		{
+			return Raycast(ray, out iso_hit_info,
+				max_distance, layer_mask,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static bool Raycast(Ray ray, out IsoRaycastHit iso_hit_info,
+			float max_distance, int layer_mask,
+			QueryTriggerInteraction query_trigger_interaction)
+		{
+			var hit_info = new RaycastHit();
+			var result = UnityEngine.Physics.Raycast(ray, out hit_info,
+				max_distance, layer_mask, query_trigger_interaction);
+			iso_hit_info = result ? new IsoRaycastHit(hit_info) : new IsoRaycastHit();
+			return result;
+		}
+
+		//
+		// RaycastAll
+		//
+
+		public static IsoRaycastHit[] RaycastAll(Ray ray) {
+			return RaycastAll(ray,
+				Mathf.Infinity, UnityEngine.Physics.DefaultRaycastLayers,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static IsoRaycastHit[] RaycastAll(Ray ray,
+			float max_distance)
+		{
+			return RaycastAll(ray,
+				max_distance, UnityEngine.Physics.DefaultRaycastLayers,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static IsoRaycastHit[] RaycastAll(Ray ray,
+			float max_distance, int layer_mask)
+		{
+			return RaycastAll(ray,
+				max_distance, layer_mask,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static IsoRaycastHit[] RaycastAll(Ray ray,
+			float max_distance, int layer_mask,
+			QueryTriggerInteraction query_trigger_interaction)
+		{
+			var hits_info = UnityEngine.Physics.RaycastAll(ray,
+				max_distance, layer_mask, query_trigger_interaction);
+			return IsoPhysicsUtils.IsoConvertRaycastHits(hits_info);
+		}
+
+		//
+		// RaycastNonAlloc
+		//
+
+		public static int RaycastNonAlloc(Ray ray, IsoRaycastHit[] results) {
+			return RaycastNonAlloc(ray, results,
+				Mathf.Infinity, UnityEngine.Physics.DefaultRaycastLayers,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static int RaycastNonAlloc(Ray ray, IsoRaycastHit[] results,
+			float max_distance)
+		{
+			return RaycastNonAlloc(ray, results,
+				max_distance, UnityEngine.Physics.DefaultRaycastLayers,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		public static int RaycastNonAlloc(Ray ray, IsoRaycastHit[] results,
+			float max_distance, int layer_mask)
+		{
+			return RaycastNonAlloc(ray, results,
+				max_distance, layer_mask,
+				QueryTriggerInteraction.UseGlobal);
+		}
+
+		static RaycastHit[] _raycastNonAllocBuffer = new RaycastHit[128];
+		public static int RaycastNonAlloc(Ray ray, IsoRaycastHit[] results,
+			float max_distance, int layer_mask,
+			QueryTriggerInteraction query_trigger_interaction)
+		{
+			var hit_count = UnityEngine.Physics.RaycastNonAlloc(ray, _raycastNonAllocBuffer,
+				max_distance, layer_mask, query_trigger_interaction);
+			var min_hit_count = Mathf.Min(hit_count, results.Length);
+			for ( var i = 0; i < min_hit_count; ++i ) {
+				results[i] = new IsoRaycastHit(_raycastNonAllocBuffer[i]);
+			}
+			System.Array.Clear(_raycastNonAllocBuffer, 0, _raycastNonAllocBuffer.Length);
+			return min_hit_count;
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/IsoPhysics.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 40ab1c30204174ffa8d877e00af23a62
+timeCreated: 1480174712
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoRaycastHit.cs

@@ -0,0 +1,21 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+namespace IsoTools.Physics {
+	public struct IsoRaycastHit {
+
+		public IsoCollider  collider  { get; private set; }
+		public float        distance  { get; private set; }
+		public Vector3      normal    { get; private set; }
+		public Vector3      point     { get; private set; }
+		public IsoRigidbody rigidbody { get; private set; }
+
+		public IsoRaycastHit(RaycastHit hit_info) : this() {
+			collider  = IsoPhysicsUtils.IsoConvertCollider(hit_info.collider);
+			distance  = hit_info.distance;
+			normal    = hit_info.normal;
+			point     = hit_info.point;
+			rigidbody = IsoPhysicsUtils.IsoConvertRigidbody(hit_info.rigidbody);
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/IsoRaycastHit.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 46f4f6ce0e20940eab6088741047b2c1
+timeCreated: 1436363986
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoRigidbody.cs

@@ -0,0 +1,401 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace IsoTools.Physics {
+	[DisallowMultipleComponent]
+	[RequireComponent(typeof(IsoObject))]
+	public class IsoRigidbody : IsoPhysicsHelperHolder {
+
+		IsoFakeRigidbody _fakeRigidbody;
+
+		Rigidbody _realRigidbody = null;
+		Rigidbody realRigidbody {
+			get { return _realRigidbody; }
+		}
+
+		[SerializeField]
+		public float _mass = 1.0f;
+		public float mass {
+			get { return _mass; }
+			set {
+				_mass = value;
+				if ( realRigidbody ) {
+					realRigidbody.mass = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public float _drag = 0.0f;
+		public float drag {
+			get { return _drag; }
+			set {
+				_drag = value;
+				if ( realRigidbody ) {
+					realRigidbody.drag = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public bool _useGravity = true;
+		public bool useGravity {
+			get { return _useGravity; }
+			set {
+				_useGravity = value;
+				if ( realRigidbody ) {
+					realRigidbody.useGravity = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public bool _isKinematic = false;
+		public bool isKinematic {
+			get { return _isKinematic; }
+			set {
+				_isKinematic = value;
+				if ( realRigidbody ) {
+					realRigidbody.isKinematic = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public RigidbodyInterpolation _interpolation = RigidbodyInterpolation.None;
+		public RigidbodyInterpolation interpolation {
+			get { return _interpolation; }
+			set {
+				_interpolation = value;
+				if ( realRigidbody ) {
+					realRigidbody.interpolation = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public CollisionDetectionMode _collisionDetectionMode = CollisionDetectionMode.Discrete;
+		public CollisionDetectionMode collisionDetectionMode {
+			get { return _collisionDetectionMode; }
+			set {
+				_collisionDetectionMode = value;
+				if ( realRigidbody ) {
+					realRigidbody.collisionDetectionMode = value;
+				}
+			}
+		}
+
+		public Vector3 centerOfMass {
+			get { return realRigidbody ? realRigidbody.centerOfMass : Vector3.zero; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.centerOfMass = value;
+				}
+			}
+		}
+
+		public Vector3 inertiaTensor {
+			get { return realRigidbody ? realRigidbody.inertiaTensor : Vector3.zero; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.inertiaTensor = value;
+				}
+			}
+		}
+
+		public float maxDepenetrationVelocity {
+			get { return realRigidbody ? realRigidbody.maxDepenetrationVelocity : 0.0f; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.maxDepenetrationVelocity = value;
+				}
+			}
+		}
+
+		public float sleepThreshold {
+			get { return realRigidbody ? realRigidbody.sleepThreshold : 0.0f; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.sleepThreshold = value;
+				}
+			}
+		}
+
+	#if UNITY_5_4_OR_NEWER
+		public int solverIterations {
+			get { return realRigidbody ? realRigidbody.solverIterations : 0; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.solverIterations = value;
+				}
+			}
+		}
+
+		public int solverVelocityIterations {
+			get { return realRigidbody ? realRigidbody.solverVelocityIterations : 0; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.solverVelocityIterations = value;
+				}
+			}
+		}
+	#else
+		public int solverIterationCount {
+			get { return realRigidbody ? realRigidbody.solverIterationCount : 0; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.solverIterationCount = value;
+				}
+			}
+		}
+
+		public int solverVelocityIterationCount {
+			get { return realRigidbody ? realRigidbody.solverVelocityIterationCount : 0; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.solverVelocityIterationCount = value;
+				}
+			}
+		}
+	#endif
+
+		public bool useConeFriction {
+			get { return realRigidbody ? realRigidbody.useConeFriction : false; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.useConeFriction = value;
+				}
+			}
+		}
+		
+		public Vector3 velocity {
+			get { return realRigidbody ? realRigidbody.velocity : Vector3.zero; }
+			set {
+				if ( realRigidbody ) {
+					realRigidbody.velocity = value;
+				}
+			}
+		}
+		
+		public Vector3 worldCenterOfMass {
+			get { return realRigidbody ? realRigidbody.worldCenterOfMass : Vector3.zero; }
+		}
+
+		public void AddExplosionForce(
+			float explosion_force, Vector3 explosion_position, float explosion_radius)
+		{
+			AddExplosionForce(
+				explosion_force, explosion_position, explosion_radius,
+				0.0f, ForceMode.Force);
+		}
+
+		public void AddExplosionForce(
+			float explosion_force, Vector3 explosion_position, float explosion_radius,
+			float upwards_modifier)
+		{
+			AddExplosionForce(
+				explosion_force, explosion_position, explosion_radius,
+				upwards_modifier, ForceMode.Force);
+		}
+
+		public void AddExplosionForce(
+			float explosion_force, Vector3 explosion_position, float explosion_radius,
+			float upwards_modifier, ForceMode mode)
+		{
+			if ( realRigidbody ) {
+				realRigidbody.AddExplosionForce(
+					explosion_force, explosion_position, explosion_radius,
+					upwards_modifier, mode);
+			}
+		}
+
+		public void AddForce(Vector3 force) {
+			AddForce(force, ForceMode.Force);
+		}
+
+		public void AddForce(Vector3 force, ForceMode mode) {
+			if ( realRigidbody ) {
+				realRigidbody.AddForce(force, mode);
+			}
+		}
+
+		public void AddForceAtPosition(Vector3 force, Vector3 position) {
+			AddForceAtPosition(force, position, ForceMode.Force);
+		}
+
+		public void AddForceAtPosition(Vector3 force, Vector3 position, ForceMode mode) {
+			if ( realRigidbody ) {
+				realRigidbody.AddForceAtPosition(force, position, mode);
+			}
+		}
+
+		public void AddRelativeForce(Vector3 force) {
+			AddRelativeForce(force, ForceMode.Force);
+		}
+		
+		public void AddRelativeForce(Vector3 force, ForceMode mode) {
+			if ( realRigidbody ) {
+				realRigidbody.AddRelativeForce(force, mode);
+			}
+		}
+
+		public Vector3 ClosestPointOnBounds(Vector3 position) {
+			return realRigidbody
+				? realRigidbody.ClosestPointOnBounds(position)
+				: Vector3.zero;
+		}
+
+		public Vector3 GetPointVelocity(Vector3 world_point) {
+			return realRigidbody
+				? realRigidbody.GetPointVelocity(world_point)
+				: Vector3.zero;
+		}
+
+		public Vector3 GetRelativePointVelocity(Vector3 relative_point) {
+			return realRigidbody
+				? realRigidbody.GetRelativePointVelocity(relative_point)
+				: Vector3.zero;
+		}
+
+		public bool IsSleeping() {
+			return realRigidbody
+				? realRigidbody.IsSleeping()
+				: false;
+		}
+
+		public void MovePosition(Vector3 position) {
+			if ( realRigidbody ) {
+				realRigidbody.MovePosition(position);
+			}
+		}
+
+		public void ResetCenterOfMass() {
+			if ( realRigidbody ) {
+				realRigidbody.ResetCenterOfMass();
+			}
+		}
+
+		public void ResetInertiaTensor() {
+			if ( realRigidbody ) {
+				realRigidbody.ResetInertiaTensor();
+			}
+		}
+
+		public void SetDensity(float density) {
+			if ( realRigidbody ) {
+				realRigidbody.SetDensity(density);
+			}
+		}
+
+		public void Sleep() {
+			if ( realRigidbody ) {
+				realRigidbody.Sleep();
+			}
+		}
+
+		public bool SweepTest(Vector3 direction, out IsoRaycastHit iso_hit_info) {
+			return SweepTest(direction, out iso_hit_info, Mathf.Infinity, QueryTriggerInteraction.UseGlobal);
+		}
+
+		public bool SweepTest(Vector3 direction, out IsoRaycastHit iso_hit_info, float max_distance) {
+			return SweepTest(direction, out iso_hit_info, max_distance, QueryTriggerInteraction.UseGlobal);
+		}
+
+		public bool SweepTest(
+			Vector3 direction, out IsoRaycastHit iso_hit_info,
+			float max_distance, QueryTriggerInteraction query_trigger_interaction)
+		{
+			var hit_info = new RaycastHit();
+			var result = realRigidbody
+				? realRigidbody.SweepTest(direction, out hit_info, max_distance, query_trigger_interaction)
+				: false;
+			iso_hit_info = result ? new IsoRaycastHit(hit_info) : new IsoRaycastHit();
+			return result;
+		}
+
+		public IsoRaycastHit[] SweepTestAll(Vector3 direction) {
+			return SweepTestAll(direction, Mathf.Infinity, QueryTriggerInteraction.UseGlobal);
+		}
+
+		public IsoRaycastHit[] SweepTestAll(Vector3 direction, float max_distance) {
+			return SweepTestAll(direction, max_distance, QueryTriggerInteraction.UseGlobal);
+		}
+
+		public IsoRaycastHit[] SweepTestAll(
+			Vector3 direction,
+			float max_distance, QueryTriggerInteraction query_trigger_interaction)
+		{
+			return realRigidbody
+				? IsoPhysicsUtils.IsoConvertRaycastHits(
+					realRigidbody.SweepTestAll(direction, max_distance, query_trigger_interaction))
+				: new IsoRaycastHit[0];
+		}
+
+		public void WakeUp() {
+			if ( realRigidbody ) {
+				realRigidbody.WakeUp();
+			}
+		}
+		
+		void Awake() {
+			_fakeRigidbody                        = fakeObject.AddComponent<IsoFakeRigidbody>().Init(this);
+			_realRigidbody                        = fakeObject.AddComponent<Rigidbody>();
+			_realRigidbody.freezeRotation         = true;
+			_realRigidbody.mass                   = mass;
+			_realRigidbody.drag                   = drag;
+			_realRigidbody.useGravity             = useGravity;
+			_realRigidbody.isKinematic            = isKinematic;
+			_realRigidbody.interpolation          = interpolation;
+			_realRigidbody.collisionDetectionMode = collisionDetectionMode;
+		}
+
+		void OnEnable() {
+			if ( realRigidbody ) {
+				realRigidbody.detectCollisions = true;
+			}
+		}
+		
+		void OnDisable() {
+			if ( realRigidbody ) {
+				realRigidbody.detectCollisions = false;
+			}
+		}
+		
+		void OnDestroy() {
+			if ( _realRigidbody ) {
+				Destroy(_realRigidbody);
+			}
+			if ( _fakeRigidbody ) {
+				Destroy(_fakeRigidbody);
+			}
+			DestroyUnnecessaryCheck();
+		}
+
+	#if UNITY_EDITOR
+		void Reset() {
+			mass                   = 1.0f;
+			drag                   = 0.0f;
+			useGravity             = true;
+			isKinematic            = false;
+			interpolation          = RigidbodyInterpolation.None;
+			collisionDetectionMode = CollisionDetectionMode.Discrete;
+			EditorUtility.SetDirty(this);
+		}
+		
+		void OnValidate() {
+			if ( realRigidbody ) {
+				realRigidbody.mass                   = mass;
+				realRigidbody.drag                   = drag;
+				realRigidbody.useGravity             = useGravity;
+				realRigidbody.isKinematic            = isKinematic;
+				realRigidbody.interpolation          = interpolation;
+				realRigidbody.collisionDetectionMode = collisionDetectionMode;
+			}
+		}
+	#endif
+	}
+}

Assets/IsoTools/Addons/Physics/IsoRigidbody.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4febe544112bb4678bdd59fa963c802d
+timeCreated: 1434220421
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoSphereCollider.cs

@@ -0,0 +1,77 @@
+using UnityEngine;
+using IsoTools.Internal;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace IsoTools.Physics {
+	[RequireComponent(typeof(IsoObject))]
+	public class IsoSphereCollider : IsoCollider {
+
+		[SerializeField]
+		public float _radius = 0.0f;
+		public float radius {
+			get { return _radius; }
+			set {
+				_radius = value;
+				if ( realSphereCollider ) {
+					realSphereCollider.radius = value;
+				}
+			}
+		}
+
+		[SerializeField]
+		public Vector3 _offset = Vector3.zero;
+		public Vector3 offset {
+			get { return _offset; }
+			set {
+				_offset = value;
+				if ( realSphereCollider ) {
+					realSphereCollider.center = value;
+				}
+			}
+		}
+
+		protected override Collider CreateRealCollider(GameObject target) {
+			var collider    = target.AddComponent<SphereCollider>();
+			collider.radius = radius;
+			collider.center = offset;
+			return collider;
+		}
+
+		public SphereCollider realSphereCollider {
+			get { return realCollider as SphereCollider; }
+		}
+
+	#if UNITY_EDITOR
+		protected override void Reset() {
+			base.Reset();
+			var iso_object      = GetComponent<IsoObject>();
+			var iso_object_size = iso_object ? iso_object.size : Vector3.zero;
+			radius              = IsoUtils.Vec3MinF(iso_object_size) * 0.5f;
+			offset              = iso_object_size * 0.5f;
+			EditorUtility.SetDirty(this);
+		}
+
+		protected override void OnValidate() {
+			base.OnValidate();
+			if ( realSphereCollider ) {
+				realSphereCollider.radius = radius;
+				realSphereCollider.center = offset;
+			}
+		}
+
+		void OnDrawGizmosSelected() {
+			var iso_object = GetComponent<IsoObject>();
+			if ( iso_object && iso_object.isoWorld ) {
+				IsoUtils.DrawSphere(
+					iso_object.isoWorld,
+					iso_object.position + offset,
+					radius,
+					Color.green);
+			}
+		}
+	#endif
+	}
+}

Assets/IsoTools/Addons/Physics/IsoSphereCollider.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9ec3a3f10718e4e62b5c518c8b960d55
+timeCreated: 1434220433
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/IsoTools/Addons/Physics/IsoTriggerListener.cs

@@ -0,0 +1,22 @@
+using UnityEngine;
+using IsoTools.Physics.Internal;
+
+namespace IsoTools.Physics {
+	[DisallowMultipleComponent]
+	[RequireComponent(typeof(IsoObject))]
+	public class IsoTriggerListener : IsoPhysicsHelperHolder {
+
+		IsoFakeTriggerListener _fakeListener;
+
+		void Awake() {
+			_fakeListener = fakeObject.AddComponent<IsoFakeTriggerListener>().Init(this);
+		}
+
+		void OnDestroy() {
+			if ( _fakeListener ) {
+				Destroy(_fakeListener);
+			}
+			DestroyUnnecessaryCheck();
+		}
+	}
+}

Assets/IsoTools/Addons/Physics/IsoTriggerListener.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1925507eee33e42c2a04a1ae1eaa1ec5
+timeCreated: 1461096892
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: