Пример #1
0
        private void OnActionActive(CharacterAction action, bool activated)
        {
            if (activated)
            {
                //  There is currently an action running.
                if (m_activeStateAction != action && m_activeStateAction != null)
                {
                    //Debug.LogFormat("Stoppiong ActiveAction {0} |Starting Action ({1})", m_activeStateAction.GetType().Name,  action.GetType().Name);
                    m_controller.TryStopAction(m_activeStateAction, true);
                    m_activeStateAction = action;
                }
                //  If active action is the same as the incoming action.  This shoul;dn't happen.
                else if (m_activeStateAction == action)
                {
                    Debug.LogFormat("<color=yellow><b>[Warning]</color></b> ActiveAction is the same as incoming Action ({0})", action.GetType().Name);
                }
                //  there is no active action.
                else
                {
                    //Debug.LogFormat("ActiveAction is ({0})", action.GetType().Name);
                    m_activeStateAction = action;
                }

                //  If animator is matching target, stop it.
                if (m_animator.isMatchingTarget)
                {
                    m_animator.InterruptMatchTarget(false);
                }
            }
            else
            {
                if (m_activeStateAction == action)
                {
                    //Debug.LogFormat("ActiveAction {0} is now null.", m_activeStateAction.GetType().Name);
                    m_activeStateAction = null;

                    //  If animator is matching target, stop it.
                    if (m_animator.isMatchingTarget)
                    {
                        m_animator.InterruptMatchTarget(true);
                    }
                }
            }
        }
Пример #2
0
        protected void OnActionActive(CharacterAction action, bool activated)
        {
            int index = Array.IndexOf(m_Actions, action);

            if (action == m_Actions[index])
            {
                if (m_Actions[index].enabled)
                {
                    if (activated)
                    {
                        //Debug.LogFormat(" {0} is starting.", action.GetType().Name);
                        CharacterDebug.Log(action.GetType().Name, action.GetType());
                    }
                    else
                    {
                        CharacterDebug.Remove(action.GetType().Name);
                    }
                }
            }
        }
Пример #3
0
        public void TryStopAction(CharacterAction action)
        {
            if (action == null)
            {
                return;
            }

            if (action.CanStopAction())
            {
                int index = Array.IndexOf(m_Actions, action);
                if (m_ActiveAction == action)
                {
                    m_ActiveAction = null;
                }


                action.StopAction();
                ActionStopped();
            }
        }
Пример #4
0
        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            if (k_drawDefault)
            {
                base.OnGUI(position, property, label);
                return;
            }

            element    = property;
            lineHeight = EditorGUIUtility.singleLineHeight;
            rect       = position;

            EditorGUI.BeginProperty(position, label, element);
            {
                serializedObject = new SerializedObject(element.objectReferenceValue);
                if (serializedObject != null)
                {
                    CharacterAction action = (CharacterAction)element.objectReferenceValue;
                    isActive    = serializedObject.FindProperty("m_isActive");
                    actionID    = serializedObject.FindProperty("m_actionID");
                    m_startType = serializedObject.FindProperty("m_startType");
                    m_stopType  = serializedObject.FindProperty("m_stopType");

                    var allocWidth = (rect.width - 20) / 5;
                    var enumWidth  = Mathf.Clamp(allocWidth, 75, float.MaxValue);
                    rect.y     += 2;
                    enabledRect = new Rect(rect.x, rect.y, 20, lineHeight);
                    labelRect   = new Rect(rect.x + 20, rect.y, allocWidth + 20, lineHeight);
                    //stateRect = new Rect(rect.x + allocWidth + 15, rect.y, allocWidth, lineHeight);
                    startTypeRect = new Rect((rect.x + enumWidth) + 36, rect.y, enumWidth, lineHeight);
                    stopTypeRect  = new Rect(startTypeRect.x + startTypeRect.width - 4, rect.y, enumWidth, lineHeight);
                    inputRect     = new Rect(stopTypeRect.x + stopTypeRect.width - 4, rect.y, allocWidth, lineHeight);

                    if (Application.isPlaying)
                    {
                        if (action.IsActive)
                        {
                            EditorGUI.DrawRect(position, activeActiopn);
                        }
                        //else EditorGUI.DrawRect(position, inactiveAction);
                    }

                    //  Enable toggle
                    action.enabled = EditorGUI.Toggle(enabledRect, action.enabled);
                    //  Action name.
                    EditorGUI.LabelField(labelRect, action.GetType().Name, action.IsActive? m_ActiveActionTextStyle : m_DefaultActionTextStyle);
                    //  StateName

                    //  StartType
                    action.StartType = (ActionStartType)EditorGUI.EnumPopup(startTypeRect, action.StartType);
                    //  StopType
                    action.StopType = (ActionStopType)EditorGUI.EnumPopup(stopTypeRect, action.StopType);
                    //  Input
                    EditorGUI.BeginDisabledGroup(!IsStartStopInput(action));
                    var m_inputKey = serializedObject.FindProperty("m_inputKey");
                    EditorGUI.PropertyField(inputRect, m_inputKey, GUIContent.none);
                    EditorGUI.EndDisabledGroup();


                    //stateName.stringValue = EditorGUI.TextField(rect, stateName.stringValue);



                    //  Action name.
                    //rect.width = position.width * 0.40f;
                    //if (action.IsActive) {
                    //    EditorGUI.LabelField(rect, string.Format("{0} ({1})", action.GetType().Name, "Active"), m_ActiveActionTextStyle);
                    //}
                    //else {
                    //    EditorGUI.LabelField(rect, action.GetType().Name, m_DefaultActionTextStyle);
                    //}


                    ////  Action state name.
                    //rect.x += position.width * 0.40f;
                    //rect.width = position.width * 0.36f;
                    //stateName.stringValue = EditorGUI.TextField(rect, stateName.stringValue);
                    ////  Action ID
                    ////rect.x = position.width * 0.85f;
                    //rect.x = position.width - 36;
                    //rect.width = 36;
                    //actionID.intValue = EditorGUI.IntField(rect, actionID.intValue);

                    ////  Toggle Enable
                    //rect.x = position.width + 12;
                    //rect.width = 36;
                    //action.enabled = EditorGUI.Toggle(rect, action.enabled);
                    ////isActive.boolValue = EditorGUI.Toggle(rect, isActive.boolValue);
                    ////isActive.boolValue = action.enabled;

                    serializedObject.ApplyModifiedProperties();
                }
            }



            EditorGUI.EndProperty();
        }
Пример #5
0
        protected override void FixedUpdate()
        {
            if (m_TimeScale == 0)
            {
                return;
            }
            m_DeltaTime = fixedDeltaTime;

            m_Move               = true;
            m_CheckGround        = true;
            m_CheckMovement      = true;
            m_SetPhysicsMaterial = true;
            m_UpdateRotation     = true;
            m_UpdateMovement     = true;
            m_UpdateAnimator     = true;


            for (int i = 0; i < m_Actions.Length; i++)
            {
                if (m_Actions[i].enabled == false)
                {
                    continue;
                }
                CharacterAction charAction = m_Actions[i];

                if (charAction.IsActive)
                {
                    //  Move charatcer based on input values.
                    if (m_Move)
                    {
                        m_Move = charAction.Move();
                    }
                    //  Perform checks to determine if the character is on the ground.
                    if (m_CheckGround)
                    {
                        m_CheckGround = charAction.CheckGround();
                    }
                    //  Ensure the current movement direction is valid.
                    if (m_CheckMovement)
                    {
                        m_CheckMovement = charAction.CheckMovement();
                    }


                    //  Update the rotation forces.
                    if (m_UpdateRotation)
                    {
                        m_UpdateRotation = charAction.UpdateRotation();
                    }
                    //  Apply any movement.
                    if (m_UpdateMovement)
                    {
                        m_UpdateMovement = charAction.UpdateMovement();
                    }
                    // Update the Animator.
                    if (m_UpdateAnimator)
                    {
                        m_UpdateAnimator = charAction.UpdateAnimator();
                    }
                }
            }  //  end of for loop

            //  Moves the character according to the input.
            if (m_Move)
            {
                Move();
            }
            //  Perform checks to determine if the character is on the ground.
            if (m_CheckGround)
            {
                CheckGround();
            }
            //  Ensure the current movement direction is valid.
            if (m_CheckMovement)
            {
                CheckMovement();
            }
            //  Set the physic material based on the grounded and stepping state
            if (m_SetPhysicsMaterial)
            {
                SetPhysicsMaterial();
            }


            //  Update the rotation forces.
            if (m_UpdateRotation)
            {
                UpdateRotation();
            }
            //  Apply any movement.
            if (m_UpdateMovement)
            {
                UpdateMovement();
            }
            // Update the Animator.
            if (m_UpdateAnimator)
            {
                UpdateAnimator();
            }
        }
Пример #6
0
        protected void StopStartAction(CharacterAction charAction)
        {
            //  First, check if current Action can Start or Stop.

            //  Current Action is Active.
            if (charAction.enabled && charAction.IsActive)
            {
                //  Check if can stop Action is StopType is NOT Manual.
                if (charAction.StopType != ActionStopType.Manual)
                {
                    if (charAction.CanStopAction())
                    {
                        //  Start the Action and update the animator.
                        charAction.StopAction();
                        //  Reset Active Action.
                        if (m_ActiveAction = charAction)
                        {
                            m_ActiveAction = null;
                        }
                        //  Move on to the next Action.
                        return;
                    }
                }
            }
            //  Current Action is NOT Active.
            else
            {
                //  Check if can start Action is StartType is NOT Manual.
                if (charAction.enabled && charAction.StartType != ActionStartType.Manual)
                {
                    if (m_ActiveAction == null)
                    {
                        if (charAction.CanStartAction())
                        {
                            //  Start the Action and update the animator.
                            charAction.StartAction();
                            //charAction.UpdateAnimator();
                            //  Set active Action if not concurrent.
                            if (charAction.IsConcurrentAction() == false)
                            {
                                m_ActiveAction = charAction;
                            }
                            //  Move onto the next Action.
                            return;
                        }
                    }
                    else if (charAction.IsConcurrentAction())
                    {
                        if (charAction.CanStartAction())
                        {
                            //  Start the Action and update the animator.
                            charAction.StartAction();
                            //charAction.UpdateAnimator();
                            //  Move onto the next Action.
                            return;
                        }
                    }
                    else
                    {
                        return;
                    }
                }
            }
        }