You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
741 lines
31 KiB
C#
741 lines
31 KiB
C#
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
using MalbersAnimations.Events;
|
|
using MalbersAnimations.Scriptables;
|
|
using MalbersAnimations.Controller;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Collections;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
|
|
namespace MalbersAnimations.HAP
|
|
{
|
|
[AddComponentMenu("Malbers/Riding/Mount")]
|
|
public class Mount : MonoBehaviour, IAnimatorListener
|
|
{
|
|
#region References
|
|
/// <summary>Reference of the Animal</summary>
|
|
[RequiredField] public MAnimal Animal;
|
|
|
|
|
|
#region Mount Point References
|
|
public Transform MountPoint; // Reference for the RidersLink Bone
|
|
public Transform MountBase; // Reference for the RidersLink Bone
|
|
public Transform FootLeftIK; // Reference for the LeftFoot correct position on the mount
|
|
public Transform FootRightIK; // Reference for the RightFoot correct position on the mount
|
|
public Transform KneeLeftIK; // Reference for the LeftKnee correct position on the mount
|
|
public Transform KneeRightIK; // Reference for the RightKnee correct position on the mount
|
|
|
|
|
|
public Transform LeftRein; // Reference for the LeftRein
|
|
public Transform RightRein; // Reference for the RightRein
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region General
|
|
/// <summary>Enable Disable the Mount Logic</summary>
|
|
public BoolReference active = new BoolReference(true);
|
|
|
|
/// <summary></summary>
|
|
[Tooltip("Set the AI when the animal is Mounted")]
|
|
public BoolReference Set_AIMount = new BoolReference(false);
|
|
|
|
/// <summary></summary>
|
|
[Tooltip("Set the AI when the animal is Dismounted")]
|
|
public BoolReference Set_AIDismount = new BoolReference(true);
|
|
|
|
|
|
[Tooltip("Set the Input when the animal is mounted. Disable this for Mobile")]
|
|
public BoolReference Set_InputMount = new BoolReference(true);
|
|
|
|
[Tooltip("Set the Input when the animal is dismounted. Disable this for Mobile")]
|
|
public BoolReference set_InputDismount= new BoolReference(false);
|
|
|
|
|
|
|
|
[Tooltip("Set the Mount Triggers the Animal is Mounted")]
|
|
public BoolReference Set_MTriggersMount = new BoolReference(false);
|
|
|
|
[Tooltip("Set the Mount Triggers the Animal is Dismounted")]
|
|
public BoolReference Set_MTriggersDismount = new BoolReference(true);
|
|
|
|
/// <summary>Works for the ID of the Mount (EX Wagon</summary>
|
|
public IntReference ID;
|
|
|
|
|
|
/// <summary>if true then it will ignore the Mounting Animations</summary>
|
|
public BoolReference instantMount = new BoolReference(false);
|
|
public BoolReference instantDismount = new BoolReference(false);
|
|
public string mountIdle = "Idle";
|
|
|
|
/// <summary>The Rider can only Mount when the Animal is on any of these states on the list</summary>
|
|
public bool MountOnly;
|
|
/// <summary>The Rider can only Dismount when the Animal is on any of these states on the list</summary>
|
|
public bool DismountOnly;
|
|
/// <summary>The Rider is Forced to dismount if the animal is on any of these states</summary>
|
|
public bool ForceDismount;
|
|
public List<StateID> MountOnlyStates = new List<StateID>();
|
|
public List<StateID> DismountOnlyStates = new List<StateID>();
|
|
public List<StateID> ForceDismountStates = new List<StateID>();
|
|
|
|
|
|
/// <summary>Reference for the Animator Update Mode</summary>
|
|
public AnimatorUpdateMode DefaultAnimUpdateMode { get; set; }
|
|
#endregion
|
|
|
|
/// <summary>Velocity changes for diferent Animation Speeds... used on other animals</summary>
|
|
public List<SpeedTimeMultiplier> SpeedMultipliers;
|
|
|
|
#region Straight Mount
|
|
public BoolReference straightSpine; //Activate this only for other animals but the horse
|
|
public BoolReference UseSpeedModifiers;
|
|
public Vector3 pointOffset = new Vector3(0, 0, 3);
|
|
public Vector3 MonturaSpineOffset => StraightSpineOffsetTransform.TransformPoint(pointOffset);
|
|
|
|
//public float LowLimit = 45;
|
|
//public float HighLimit = 135;
|
|
|
|
public float smoothSM = 0.5f;
|
|
#endregion
|
|
|
|
#region Events
|
|
public UnityEvent OnMounted = new UnityEvent();
|
|
public UnityEvent OnDismounted = new UnityEvent();
|
|
public BoolEvent OnCanBeMounted = new BoolEvent();
|
|
#endregion
|
|
|
|
#region Properties
|
|
/// <summary>Straighen the Spine bone while mounted depends on the Mount</summary>
|
|
public bool StraightSpine { get => straightSpine; set => straightSpine.Value = value; }
|
|
|
|
|
|
/// <summary>Straighen the Spine bone while mounted depends on the Mount</summary>
|
|
public Transform StraightSpineOffsetTransform;
|
|
private bool defaultStraightSpine;
|
|
|
|
/// <summary>Reference for the Animal Animator</summary>
|
|
public Animator Anim => Animal.Anim;
|
|
/// <summary>Reference for the Animal Input Source</summary>
|
|
public IInputSource MountInput => Animal.InputSource;
|
|
/// <summary>Reference for the AI Animal Control</summary>
|
|
public IAIControl AI { get; internal set; }
|
|
|
|
/// <summary>Input for the Mount</summary>
|
|
public List<MountTriggers> MountTriggers { get; private set; }
|
|
|
|
|
|
protected bool mounted;
|
|
/// <summary> Is the animal Mounted</summary>
|
|
public bool Mounted
|
|
{
|
|
get => mounted;
|
|
set
|
|
{
|
|
if (value != mounted)
|
|
{
|
|
mounted = value;
|
|
|
|
if (mounted)
|
|
OnMounted.Invoke(); //Invoke the Event
|
|
else
|
|
OnDismounted.Invoke();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary> Dismount only when the Animal is Still on place </summary>
|
|
public virtual bool CanDismount => Mounted;
|
|
|
|
public virtual string MountIdle { get => mountIdle; set => mountIdle = value; }
|
|
|
|
/// <summary>Animal Mountable Script 'Enabled/Disabled'</summary>
|
|
public virtual bool CanBeMounted { get => active; set => active.Value = value; }
|
|
|
|
/// <summary> The Mount has all the IK Links</summary>
|
|
public bool HasIKFeet => FootLeftIK != null && FootRightIK != null && KneeLeftIK != null && KneeRightIK != null;
|
|
|
|
|
|
/// <summary>If "Mount Only" is enabled, this will capture the State the animal is at, in order to Mount</summary>
|
|
public bool CanBeMountedByState { get; set; }
|
|
/// <summary>If "Mount Only" is enabled, this will capture the State the animal is at, in order to Mount</summary>
|
|
public bool CanBeDismountedByState { get; set; }
|
|
|
|
/// <summary>Active Ride the Montura. is setted by the Rider Script </summary>
|
|
public MRider Rider { get; set; }
|
|
|
|
/// <summary>Rider that is near the Mount</summary>
|
|
public MRider NearbyRider { get; set; }
|
|
|
|
/// <summary> Ignore Mounting Animations </summary>
|
|
public bool InstantMount { get => instantMount.Value; set => instantMount.Value = value; }
|
|
public bool InstantDismount { get => instantDismount.Value; set => instantDismount.Value = value; }
|
|
#endregion
|
|
|
|
#region IK Reins
|
|
/// <summary>Left Rein Handle Default Local Position </summary>
|
|
public Vector3 DefaultLeftReinPos { get; internal set; }
|
|
|
|
/// <summary>Right Rein Handle Default Local Position </summary>
|
|
public Vector3 DefaultRightReinPos { get; internal set; }
|
|
#endregion
|
|
|
|
public bool debug;
|
|
|
|
public void Awake()
|
|
{
|
|
if (Animal == null)
|
|
Animal = this.FindComponent<MAnimal>();
|
|
|
|
AI = Animal.GetComponentInChildren<IAIControl>(true);
|
|
|
|
MountTriggers = GetComponentsInChildren<MountTriggers>(true).ToList(); //Catche all the MountTriggers of the Mount
|
|
|
|
CanBeDismountedByState = CanBeMountedByState = true; //Set as true can be mounted and canbe dismounted by state
|
|
defaultStraightSpine = StraightSpine;
|
|
if (Anim) DefaultAnimUpdateMode = Anim.updateMode;
|
|
|
|
if (!StraightSpineOffsetTransform)
|
|
{
|
|
StraightSpineOffsetTransform = transform;
|
|
}
|
|
|
|
|
|
if (LeftRein && RightRein)
|
|
{
|
|
DefaultLeftReinPos = LeftRein.localPosition; //Set the Reins Local Values Values
|
|
DefaultRightReinPos = RightRein.localPosition; //Set the Reins Local Values Values
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void OnEnable()
|
|
{
|
|
Animal.OnStateActivate.AddListener(AnimalStateChange);
|
|
Animal.OnSpeedChange.AddListener(SetAnimatorSpeed);
|
|
}
|
|
|
|
void OnDisable()
|
|
{
|
|
Animal.OnStateActivate.RemoveListener(AnimalStateChange);
|
|
Animal.OnSpeedChange.RemoveListener(SetAnimatorSpeed);
|
|
|
|
if (NearbyRider) NearbyRider.MountTriggerExit();
|
|
}
|
|
|
|
/// <summary>Enable the Input for the Mount</summary>
|
|
public virtual void EnableInput(bool value)
|
|
{
|
|
MountInput?.Enable(value);
|
|
Animal.StopMoving();
|
|
}
|
|
|
|
|
|
public void ResetRightRein()
|
|
{
|
|
if (RightRein) RightRein.localPosition = DefaultRightReinPos;
|
|
}
|
|
|
|
public void ResetLeftRein()
|
|
{
|
|
if (LeftRein) LeftRein.localPosition = DefaultLeftReinPos;
|
|
}
|
|
|
|
public virtual void StartMounting(MRider rider)
|
|
{
|
|
Mounted = true; //Set Mounting to true
|
|
Rider = rider; //Send to the Montura that it has a rider
|
|
|
|
Set_MountTriggers(Set_MTriggersMount.Value); //Disable all Mount Trigger to avoid ON Enter ON Exit Trigger Events**
|
|
}
|
|
|
|
|
|
public virtual void End_Mounting()
|
|
{
|
|
EnableInput(Set_InputMount.Value); //Enable Animal Controls
|
|
AI?.SetActive(Set_AIMount.Value); //Set the AI Value
|
|
|
|
SetAnimatorSpeed(Animal.currentSpeedModifier); //Update the Speed Modifier /Rider and Animal
|
|
}
|
|
|
|
public virtual void Start_Dismounting()
|
|
{
|
|
Mounted = false;
|
|
EnableInput(set_InputDismount.Value); //Enable/Disable Animal Controls
|
|
|
|
Animal.Mode_Interrupt();
|
|
|
|
ResetLeftRein();
|
|
ResetRightRein();
|
|
}
|
|
|
|
public virtual void EndDismounting()
|
|
{
|
|
Set_MountTriggers(Set_MTriggersDismount.Value); //Enable all Mount Triggers
|
|
AI?.SetActive(Set_AIDismount.Value); //Reactivate the AI.
|
|
Rider = null;
|
|
}
|
|
|
|
|
|
/// <summary>Used for Aiming while on the horse.... Straight Spine needs to be pause </summary>
|
|
public virtual void PauseStraightSpine(bool value) => StraightSpine = !value && defaultStraightSpine;
|
|
|
|
/// <summary>Enable/Disable Mount Triggers</summary>
|
|
public virtual void Set_MountTriggers(bool value)
|
|
{
|
|
foreach (var mt in MountTriggers)
|
|
{
|
|
mt.gameObject.SetActive(value);
|
|
mt.WasAutomounted = true;
|
|
}
|
|
|
|
if ( !value) ExitMountTrigger();
|
|
}
|
|
|
|
/// <summary>Reset All Values when Exiting Mount Triggers</summary>
|
|
public virtual void ExitMountTrigger()
|
|
{
|
|
OnCanBeMounted.Invoke(false);
|
|
NearbyRider = null;
|
|
|
|
foreach (var mt in MountTriggers)
|
|
mt.WasAutomounted = false; //Reset Automounted on the Mount Triggers
|
|
}
|
|
|
|
protected virtual void AnimalStateChange(int StateID)
|
|
{
|
|
var ActiveState = Animal.ActiveStateID;
|
|
|
|
if (MountOnly)
|
|
{
|
|
CanBeMountedByState = MountOnlyStates.Contains(ActiveState); //Set MountOnly by State
|
|
}
|
|
|
|
if (DismountOnly)
|
|
{
|
|
CanBeDismountedByState = DismountOnlyStates.Contains(ActiveState); //Set DimountOnly by State
|
|
}
|
|
|
|
if (Rider)
|
|
{
|
|
Rider.UpdateCanMountDismount();
|
|
|
|
if (ForceDismount) //Means the Rider is forced to dismount
|
|
{
|
|
if (ForceDismountStates.Contains(ActiveState))
|
|
Rider.ForceDismount();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Align the Animator Speed of the Mount with the Rider Speed</summary>
|
|
protected virtual void SetAnimatorSpeed(MSpeed SpeedModifier)
|
|
{
|
|
if (!Rider || !Rider.IsRiding) return; //if there's No Rider Skip
|
|
|
|
if (UseSpeedModifiers)
|
|
{
|
|
var speed = SpeedMultipliers.Find(s => s.name == SpeedModifier.name); //Find the Curren Animal Speed
|
|
|
|
float TargetAnimSpeed = speed != null ? speed.AnimSpeed * SpeedModifier.animator * Animal.AnimatorSpeed : 1f;
|
|
|
|
Rider.TargetSpeedMultiplier = TargetAnimSpeed;
|
|
}
|
|
}
|
|
|
|
/// <summary>Enable/Disable the StraightMount Feature </summary>
|
|
public virtual void StraightMount(bool value) => StraightSpine = value;
|
|
|
|
public virtual bool OnAnimatorBehaviourMessage(string message, object value) => this.InvokeWithParams(message, value);
|
|
|
|
[HideInInspector] public int Editor_Tabs1;
|
|
[HideInInspector] public int Editor_Tabs2;
|
|
|
|
|
|
|
|
#if UNITY_EDITOR
|
|
private void Reset()
|
|
{
|
|
Animal = GetComponent<MAnimal>();
|
|
StraightSpineOffsetTransform = transform;
|
|
|
|
MEvent RiderMountUIE = MTools.GetInstance<MEvent>("Rider Mount UI");
|
|
|
|
if (RiderMountUIE != null)
|
|
{
|
|
UnityEditor.Events.UnityEventTools.AddObjectPersistentListener<Transform>(OnCanBeMounted, RiderMountUIE.Invoke, transform);
|
|
UnityEditor.Events.UnityEventTools.AddPersistentListener(OnCanBeMounted, RiderMountUIE.Invoke);
|
|
}
|
|
}
|
|
|
|
/// <summary> Debug Options </summary>
|
|
void OnDrawGizmos()
|
|
{
|
|
if (!debug) return;
|
|
|
|
Gizmos.color = Color.red;
|
|
if (StraightSpineOffsetTransform)
|
|
{
|
|
Gizmos.DrawSphere(MonturaSpineOffset, 0.125f);
|
|
}
|
|
else
|
|
{
|
|
StraightSpineOffsetTransform = transform;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class SpeedTimeMultiplier
|
|
{
|
|
/// <summary>Name of the Speed the on the animal to apply the AnimSpeed</summary>
|
|
public string name = "SpeedName";
|
|
|
|
/// <summary>Speed Modifier multiplier for the Rider</summary>
|
|
public float AnimSpeed = 1f;
|
|
}
|
|
|
|
#region INSPECTOR
|
|
#if UNITY_EDITOR
|
|
|
|
[CanEditMultipleObjects, CustomEditor(typeof(Mount))]
|
|
public class MountEd : Editor
|
|
{
|
|
bool helpUseSpeeds;
|
|
bool helpEvents;
|
|
Mount M;
|
|
|
|
SerializedProperty
|
|
UseSpeedModifiers, MountOnly, DismountOnly, active, mountIdle, instantMount, instantDismount, straightSpine, ID, StraightSpineOffsetTransform,
|
|
pointOffset, Animal, smoothSM, mountPoint, rightIK, rightKnee, leftIK, leftKnee, SpeedMultipliers,
|
|
OnMounted, Editor_Tabs1, Editor_Tabs2, OnDismounted, OnCanBeMounted, MountOnlyStates, DismountOnlyStates, MountBase,
|
|
|
|
ForceDismountStates, ForceDismount, debug,
|
|
|
|
LeftRein, RightRein,
|
|
|
|
Set_AIMount, Set_InputMount, Set_MTriggersMount,
|
|
Set_AIDismount, Set_InputDismount, Set_MTriggersDismount
|
|
;
|
|
|
|
|
|
private void OnEnable()
|
|
{
|
|
M = (Mount)target;
|
|
|
|
UseSpeedModifiers = serializedObject.FindProperty("UseSpeedModifiers");
|
|
//syncAnimators = serializedObject.FindProperty("syncAnimators");
|
|
Animal = serializedObject.FindProperty("Animal");
|
|
// ShowLinks = serializedObject.FindProperty("ShowLinks");
|
|
debug = serializedObject.FindProperty("debug");
|
|
ID = serializedObject.FindProperty("ID");
|
|
|
|
|
|
LeftRein = serializedObject.FindProperty("LeftRein");
|
|
RightRein = serializedObject.FindProperty("RightRein");
|
|
|
|
|
|
MountOnly = serializedObject.FindProperty("MountOnly");
|
|
DismountOnly = serializedObject.FindProperty("DismountOnly");
|
|
active = serializedObject.FindProperty("active");
|
|
mountIdle = serializedObject.FindProperty("mountIdle");
|
|
instantMount = serializedObject.FindProperty("instantMount");
|
|
instantDismount = serializedObject.FindProperty("instantDismount");
|
|
straightSpine = serializedObject.FindProperty("straightSpine");
|
|
|
|
|
|
smoothSM = serializedObject.FindProperty("smoothSM");
|
|
|
|
mountPoint = serializedObject.FindProperty("MountPoint");
|
|
MountBase = serializedObject.FindProperty("MountBase");
|
|
rightIK = serializedObject.FindProperty("FootRightIK");
|
|
rightKnee = serializedObject.FindProperty("KneeRightIK");
|
|
leftIK = serializedObject.FindProperty("FootLeftIK");
|
|
leftKnee = serializedObject.FindProperty("KneeLeftIK");
|
|
|
|
Editor_Tabs1 = serializedObject.FindProperty("Editor_Tabs1");
|
|
Editor_Tabs2 = serializedObject.FindProperty("Editor_Tabs2");
|
|
|
|
SpeedMultipliers = serializedObject.FindProperty("SpeedMultipliers");
|
|
// DebugSync = serializedObject.FindProperty("DebugSync");
|
|
OnMounted = serializedObject.FindProperty("OnMounted");
|
|
pointOffset = serializedObject.FindProperty("pointOffset");
|
|
StraightSpineOffsetTransform = serializedObject.FindProperty("StraightSpineOffsetTransform");
|
|
|
|
OnDismounted = serializedObject.FindProperty("OnDismounted");
|
|
OnCanBeMounted = serializedObject.FindProperty("OnCanBeMounted");
|
|
MountOnlyStates = serializedObject.FindProperty("MountOnlyStates");
|
|
DismountOnlyStates = serializedObject.FindProperty("DismountOnlyStates");
|
|
|
|
ForceDismountStates = serializedObject.FindProperty("ForceDismountStates");
|
|
ForceDismount = serializedObject.FindProperty("ForceDismount");
|
|
|
|
Set_MTriggersMount = serializedObject.FindProperty("Set_MTriggersMount");
|
|
Set_AIMount = serializedObject.FindProperty("Set_AIMount");
|
|
Set_InputMount = serializedObject.FindProperty("Set_InputMount");
|
|
|
|
Set_MTriggersDismount = serializedObject.FindProperty("Set_MTriggersDismount");
|
|
Set_AIDismount = serializedObject.FindProperty("Set_AIDismount");
|
|
Set_InputDismount = serializedObject.FindProperty("set_InputDismount");
|
|
}
|
|
|
|
public override void OnInspectorGUI()
|
|
{
|
|
serializedObject.Update();
|
|
|
|
MalbersEditor.DrawDescription("Makes this animal mountable. Requires Mount Triggers and Moint Points");
|
|
|
|
EditorGUILayout.BeginVertical(MalbersEditor.StyleGray);
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
{
|
|
Editor_Tabs1.intValue = GUILayout.Toolbar(Editor_Tabs1.intValue, new string[] { "General", "Links", "Custom Mount" });
|
|
if (Editor_Tabs1.intValue != 3) Editor_Tabs2.intValue = 3;
|
|
|
|
Editor_Tabs2.intValue = GUILayout.Toolbar(Editor_Tabs2.intValue, new string[] { "M/D States", "Events", "Debug" });
|
|
if (Editor_Tabs2.intValue != 3) Editor_Tabs1.intValue = 3;
|
|
|
|
|
|
//First Tabs
|
|
int Selection = Editor_Tabs1.intValue;
|
|
|
|
if (Selection == 0) ShowGeneral();
|
|
else if (Selection == 1) ShowLinks();
|
|
else if (Selection == 2) ShowCustom();
|
|
|
|
//2nd Tabs
|
|
Selection = Editor_Tabs2.intValue;
|
|
|
|
if (Selection == 0) ShowStates();
|
|
else if (Selection == 1) ShowEvents();
|
|
else if (Selection == 2) ShowDebug();
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
if (M.MountPoint == null)
|
|
{
|
|
EditorGUILayout.HelpBox("'Mount Point' is empty, please set a reference", MessageType.Warning);
|
|
}
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
Undo.RecordObject(target, "Mount Inspector");
|
|
//EditorUtility.SetDirty(target);
|
|
}
|
|
serializedObject.ApplyModifiedProperties();
|
|
}
|
|
|
|
private void ShowDebug()
|
|
{
|
|
//EditorGUILayout.PropertyField(debug);
|
|
|
|
if (Application.isPlaying)
|
|
{
|
|
EditorGUI.BeginDisabledGroup(true);
|
|
EditorGUILayout.ObjectField("Current Rider", M.Rider, typeof(MRider), false);
|
|
EditorGUILayout.ObjectField("Nearby Rider", M.NearbyRider, typeof(MRider), false);
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.ToggleLeft("Mounted/Can Dismount", M.Mounted);
|
|
EditorGUILayout.ToggleLeft("Can Be Mounted by State", M.CanBeDismountedByState);
|
|
EditorGUILayout.ToggleLeft("Can Be Mounted", M.CanBeMounted);
|
|
EditorGUILayout.ToggleLeft("Straight Spine", M.StraightSpine);
|
|
Repaint();
|
|
EditorGUI.EndDisabledGroup();
|
|
}
|
|
}
|
|
|
|
|
|
private void ShowEvents()
|
|
{
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
{
|
|
EditorGUILayout.LabelField("Events", EditorStyles.boldLabel);
|
|
helpEvents = GUILayout.Toggle(helpEvents, "?", EditorStyles.miniButton, GUILayout.Width(18));
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
if (helpEvents) EditorGUILayout.HelpBox("On Mounted: Invoked when the rider start to mount the animal\nOn Dismounted: Invoked when the rider start to dismount the animal\nInvoked when the Mountable has an available Rider Nearby", MessageType.None);
|
|
|
|
EditorGUILayout.PropertyField(OnMounted);
|
|
EditorGUILayout.PropertyField(OnDismounted);
|
|
EditorGUILayout.PropertyField(OnCanBeMounted);
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
private void ShowStates()
|
|
{
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.LabelField("Mount/Dismount States", EditorStyles.boldLabel);
|
|
EditorGUILayout.PropertyField(MountOnly, new GUIContent("Mount Only", "The Rider can only Mount when the Animal is on any of these states"));
|
|
|
|
if (MountOnly.boolValue) MalbersEditor.Arrays(MountOnlyStates);
|
|
|
|
EditorGUILayout.PropertyField(DismountOnly, new GUIContent("Dismount Only", "The Rider can only Dismount when the Animal is on any of these states"));
|
|
|
|
if (DismountOnly.boolValue) MalbersEditor.Arrays(DismountOnlyStates);
|
|
|
|
|
|
EditorGUILayout.PropertyField(ForceDismount, new GUIContent("Force Dismount", "The Rider is forced to dismount when the Animal is on any of these states"));
|
|
|
|
if (ForceDismount.boolValue) MalbersEditor.Arrays(ForceDismountStates);
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
private void ShowCustom()
|
|
{
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.PropertyField(straightSpine, new GUIContent("Straight Spine", "Straighten the Mount Point to fix the Rider Animation"));
|
|
|
|
if (M.StraightSpine)
|
|
{
|
|
EditorGUILayout.PropertyField(StraightSpineOffsetTransform, new GUIContent("Transf Ref", "Transform to use for the Point Offset Calculation"));
|
|
EditorGUILayout.PropertyField(pointOffset, new GUIContent("Point Offset", "Point in front of the Mount to Straight the Spine of the Rider"));
|
|
EditorGUILayout.PropertyField(smoothSM, new GUIContent("Smoothness", "Smooth changes between the rotation and the straight Mount"));
|
|
}
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
{
|
|
EditorGUILayout.PropertyField(UseSpeedModifiers, new GUIContent("Animator Speeds", "Use this for other animals but the horse"));
|
|
helpUseSpeeds = GUILayout.Toggle(helpUseSpeeds, "?", EditorStyles.miniButton, GUILayout.Width(18));
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
if (M.UseSpeedModifiers)
|
|
{
|
|
if (helpUseSpeeds) EditorGUILayout.HelpBox("Changes the Speed on the Rider's Animator to Sync with the Animal Animator.\nThe Original Riding Animations are meant for the Horse. Only change the Speeds for other creatures", MessageType.None);
|
|
MalbersEditor.Arrays(SpeedMultipliers, new GUIContent("Animator Speed Multipliers", "Velocity changes for diferent Animation Speeds... used on other animals"));
|
|
}
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
}
|
|
|
|
private void ShowLinks()
|
|
{
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.HelpBox("'Mount Point' is obligatory, the rest are optional", MessageType.None);
|
|
|
|
EditorGUILayout.PropertyField(MountBase, new GUIContent("Mount Base", "Reference for the Mount Base, Parent of the Mount Point, used for Straight movement for the mount"));
|
|
EditorGUILayout.PropertyField(mountPoint, new GUIContent("Mount Point", "Reference for the Mount Point"));
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.PropertyField(rightIK, new GUIContent("Right Foot", "Reference for the Right Foot correct position on the mount"));
|
|
EditorGUILayout.PropertyField(rightKnee, new GUIContent("Right Knee", "Reference for the Right Knee correct position on the mount"));
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.PropertyField(leftIK, new GUIContent("Left Foot", "Reference for the Left Foot correct position on the mount"));
|
|
EditorGUILayout.PropertyField(leftKnee, new GUIContent("Left Knee", "Reference for the Left Knee correct position on the mount"));
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.LabelField("Reins [Optional]", EditorStyles.boldLabel);
|
|
EditorGUILayout.PropertyField(LeftRein, new GUIContent("Left Rein Point", "Reference for the Left Rein, to parent it to the Rider Left Hand while mounting"));
|
|
EditorGUILayout.PropertyField(RightRein, new GUIContent("Right Rein Point","Reference for the Right Rein, to parent it to the Rider Right Hand while mounting"));
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
private void ShowGeneral()
|
|
{
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.PropertyField(active, new GUIContent("Active", "If the animal can be mounted. Deactivate if the mount is death or destroyed or is not ready to be mountable"));
|
|
MalbersEditor.DrawDebugIcon(debug);
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
EditorGUILayout.PropertyField(Animal, new GUIContent("Animal", "Animal Reference for the Mounting System"));
|
|
EditorGUILayout.PropertyField(ID, new GUIContent("ID", "Default should be 0.... change this and the Stance parameter on the Rider will change to that value... allowing other types of mounts like Wagon"));
|
|
EditorGUILayout.PropertyField(instantMount, new GUIContent("Instant Mount", "Ignores the Mounting Animations"));
|
|
EditorGUILayout.PropertyField(instantDismount, new GUIContent("Instant Dismount", "Ignores the Dismount Animations"));
|
|
EditorGUILayout.PropertyField(mountIdle, new GUIContent("Mount Idle", "Animation to Play directly when instant mount is enabled"));
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.LabelField("Set values on Mounted",EditorStyles.boldLabel);
|
|
EditorGUILayout.PropertyField(Set_InputMount, new GUIContent("Mount Input"));
|
|
EditorGUILayout.PropertyField(Set_AIMount, new GUIContent("Mount AI"));
|
|
EditorGUILayout.PropertyField(Set_MTriggersMount, new GUIContent("Mount Triggers"));
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
{
|
|
EditorGUILayout.LabelField("Set values on Dismounted", EditorStyles.boldLabel);
|
|
EditorGUILayout.PropertyField(Set_InputDismount, new GUIContent("Mount Input"));
|
|
EditorGUILayout.PropertyField(Set_AIDismount, new GUIContent("Mount AI"));
|
|
EditorGUILayout.PropertyField(Set_MTriggersDismount, new GUIContent("Mount Triggers"));
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
[CustomPropertyDrawer(typeof(SpeedTimeMultiplier))]
|
|
public class SpeedTimeMultiplierDrawer : PropertyDrawer
|
|
{
|
|
// Use this for initialization
|
|
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
|
|
{
|
|
|
|
label = EditorGUI.BeginProperty(position, label, property);
|
|
// position = EditorGUI.PrefixLabel(position, label);
|
|
var indent = EditorGUI.indentLevel;
|
|
EditorGUI.indentLevel = 0;
|
|
|
|
EditorGUI.BeginChangeCheck();
|
|
|
|
var name = property.FindPropertyRelative("name");
|
|
var AnimSpeed = property.FindPropertyRelative("AnimSpeed");
|
|
var height = EditorGUIUtility.singleLineHeight;
|
|
var line = position;
|
|
line.height = height;
|
|
|
|
//line.x += 4;
|
|
//line.width -= 8;
|
|
|
|
|
|
var MainRect = new Rect(line.x, line.y, line.width / 2, height);
|
|
var lerpRect = new Rect(line.x + line.width / 2, line.y, line.width / 2, height);
|
|
|
|
EditorGUIUtility.labelWidth = 45f;
|
|
EditorGUI.PropertyField(MainRect, name, new GUIContent("Name", "Name of the Speed to modify for the Rider"));
|
|
EditorGUIUtility.labelWidth = 75f;
|
|
EditorGUI.PropertyField(lerpRect, AnimSpeed, new GUIContent(" Speed Mult", "Anim Speed Multiplier"));
|
|
if (name.stringValue == string.Empty) name.stringValue = "SpeedName";
|
|
EditorGUIUtility.labelWidth = 0;
|
|
|
|
if (EditorGUI.EndChangeCheck())
|
|
property.serializedObject.ApplyModifiedProperties();
|
|
|
|
EditorGUI.indentLevel = indent;
|
|
EditorGUI.EndProperty();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endregion
|
|
} |