Exemple #1
0
        // unity OnInspectorGUI method
        public override void OnInspectorGUI()
        {
            DrawDefaultInspector();

            PlayerThirdPerson ptp = (PlayerThirdPerson)target;

            ptp.lookTowardsCamera = EditorGUILayout.Toggle("Look Towards Camera", ptp.lookTowardsCamera);

            if (GUI.changed)
            {
                EditorUtility.SetDirty(ptp);
                serializedObject.ApplyModifiedProperties();
            }
        }
Exemple #2
0
        protected bool m_PrevStrafing = false;                                     // keep track of strafe mode if need to reset

        /// <summary>
        /// initialize component
        /// </summary>
        public void initialize()
        {
            if (m_Initialized)
            {
                return;
            }

            m_Player = GetComponent <PlayerThirdPerson>();
            if (!m_Player)
            {
                Debug.LogError("Cannot find component 'Player'" + " < " + this.ToString() + ">"); return;
            }
            m_Player.initialize();

            // setup ragdoll callbacks
            m_Player.ragdoll.OnHit = () =>
            {
                m_Player.character.simulateRootMotion = false;
                m_Player.character.disableMove        = true;
                m_Player.character.rigidBody.velocity = Vector3.zero;

                m_Player.disableInput = true;
                m_Player.character.setIKMode(TPCharacter.IKMode.None);
                m_Player.character.rigidBody.isKinematic      = true;
                m_Player.character.rigidBody.detectCollisions = false;
                m_Player.character.capsule.enabled            = false;

                if (m_Player.ragdoll.isFullRagdoll)
                {
                    m_Player.m_Camera.switchTargets(m_Player.ragdoll.RagdollBones[(int)BodyParts.Spine]);
                }
            };
            m_Player.ragdoll.OnStartTransition = () =>
            {
                if (!m_Player.ragdoll.isFullRagdoll && !m_Player.ragdoll.isGettingUp)
                {
                    m_Player.character.simulateRootMotion         = true;
                    m_Player.character.rigidBody.detectCollisions = true;
                    m_Player.character.rigidBody.isKinematic      = false;
                    m_Player.character.capsule.enabled            = true;
                }
                else
                {
                    m_Player.character.animator.SetFloat(/*"pForward"*/ HashIDs.ForwardFloat, 0.0f);
                    m_Player.character.animator.SetFloat(/*"pSide"*/ HashIDs.SideFloat, 0.0f);
                }
            };
            //m_Player.ragdoll.ragdollEventTime = 3.0f;
            //m_Player.ragdoll.OnTimeEnd = () =>
            //{
            //    m_Player.ragdoll.blendToMecanim();
            //};
            //m_Ragdoll.OnBlendEnd = () =>
            // {
            //     Debug.Log("ON BLEND END");
            // };
            //m_Ragdoll.OnGetUpEvent = () =>
            //  {
            //      Debug.Log("ON GET UP EVENT");
            //  };
            m_Player.ragdoll.LastEvent = () =>
            {
                m_Player.character.simulateRootMotion = true;
                m_Player.character.disableMove        = false;
                m_Player.disableInput = false;
                if (m_Player.lookTowardsCamera)
                {
                    m_Player.character.setIKMode(TPCharacter.IKMode.Head);
                }
                m_Player.character.rigidBody.isKinematic      = false;
                m_Player.character.rigidBody.detectCollisions = true;
                m_Player.character.capsule.enabled            = true;
                m_Player.m_Camera.switchTargets(m_Player.m_Camera.Target);
            };

            if (m_Player.lookTowardsCamera)
            {
                m_Player.character.setIKMode(TPCharacter.IKMode.Head);
            }

            if (m_Player.triggers)
            {
                // setup trigger callbacks
                m_Player.triggers.OnTriggerStart = () =>
                {
                    if (m_Player.legsIK)
                    {
                        m_Player.legsIK.enabled = false;
                    }
                    m_Player.disableInput = true;
                    bool isOnLedge = m_Player.character.animator.GetBool(/*"pOnLedge"*/ HashIDs.OnLedgeBool);
                    if (!isOnLedge)
                    {
                        m_PrevStrafing    = m_Player.strafing;
                        m_Player.strafing = false;
                        if (m_Player.character.getIKMode() == TPCharacter.IKMode.Head ||
                            m_Player.character.getIKMode() == TPCharacter.IKMode.Waist)
                        {
                            m_Player.character.setIKMode(TPCharacter.IKMode.ToNone);
                        }
                    }
                };
                m_Player.triggers.OnTriggerEnd = () =>
                {
                    bool isOnLedge = m_Player.character.animator.GetBool(/*"pOnLedge"*/ HashIDs.OnLedgeBool);
                    if (!isOnLedge)
                    {
                        m_Player.m_Camera.additiveRotation = false;
                        m_Player.strafing = m_PrevStrafing;
                        if (m_Player.legsIK)
                        {
                            m_Player.legsIK.enabled = true;
                        }
                        if (m_Player.lookTowardsCamera)
                        {
                            m_Player.character.setIKMode(TPCharacter.IKMode.Head);
                        }
                        if (m_Player.strafing)
                        {
                            m_Player.character.setMoveMode(TPCharacter.MovingMode.Strafe);
                        }
                    }

                    m_Player.disableInput = false;
                };
            }
            m_Initialized = true;
        }
Exemple #3
0
        bool _createPlayerScript(BaseCamera camera)
        {
            switch (CharacterType)
            {
            case CharacterTypes.Default:
            {
                PlayerThirdPerson playerScript = character.GetComponent <PlayerThirdPerson>();
                if (!playerScript)
                {
                    playerScript = Undo.AddComponent <PlayerThirdPerson>(character);
                }
                playerScript.m_Camera = camera;
                // Create crouch camera target
                Transform camCrouchTargetXform = Utils.FindChildTransformByName(character.transform, "CameraCrouchTarget");
                if (!camCrouchTargetXform)
                {
                    GameObject cameraCrouchTarget = new GameObject("CameraCrouchTarget");
                    cameraCrouchTarget.transform.SetParent(character.transform);
                    cameraCrouchTarget.transform.localPosition = new Vector3(0.276f, 0.961f, 0.0f);
                    camCrouchTargetXform = cameraCrouchTarget.transform;
                }
                playerScript.crouchCameraTarget = camCrouchTargetXform;
                playerScript.standCameraTarget  = camera.Target;
            }
            break;

            case CharacterTypes.ThirdPerson:
            {
                PlayerThirdPerson playerScript = character.GetComponent <PlayerThirdPerson>();
                if (!playerScript)
                {
                    playerScript = Undo.AddComponent <PlayerThirdPerson>(character);
                }
                playerScript.m_Camera = camera;
                // Create crouch camera target
                Transform camCrouchTargetXform = Utils.FindChildTransformByName(character.transform, "CameraCrouchTarget");
                if (!camCrouchTargetXform)
                {
                    GameObject cameraCrouchTarget = new GameObject("CameraCrouchTarget");
                    cameraCrouchTarget.transform.SetParent(character.transform);
                    cameraCrouchTarget.transform.localPosition = new Vector3(0.276f, 0.961f, 0.0f);
                    camCrouchTargetXform = cameraCrouchTarget.transform;
                }
                playerScript.crouchCameraTarget = camCrouchTargetXform;
                playerScript.standCameraTarget  = camera.Target;
            }
            break;

            case CharacterTypes.TopDown:
            {
                PlayerTopDown playerScript = character.GetComponent <PlayerTopDown>();
                if (!playerScript)
                {
                    playerScript = Undo.AddComponent <PlayerTopDown>(character);
                }
                playerScript.m_Camera            = camera;
                playerScript.walkableTarrainMask = LayerMask.GetMask("Walkable");
            }
            break;
            }
            return(true);
        }
        /// <summary>
        /// initialize component
        /// </summary>
        public override bool initialize()
        {
            if (m_Initialized)
            {
                return(true);
            }

            if (!base.initialize())
            {
                return(false);
            }


            if (m_Player is PlayerThirdPerson)
            {
                m_ThirdPersonPlayer = m_Player as PlayerThirdPerson;
            }
            else
            {
                Debug.LogError("PlayerThirdPerson component missing <" + this.ToString() + ">");
                return(false);
            }

            m_ItemPicker = GetComponent <ItemPicker>();
            if (!m_ItemPicker)
            {
                Debug.LogError("Cannot find 'ItemPicker' component! < " + this.ToString() + " >"); return(false);
            }

            // setup ragdoll callbacks
            m_ThirdPersonPlayer.ragdoll.OnHit = () =>
            {
                m_Character.simulateRootMotion = false;
                m_Character.disableMove        = true;
                m_Character.rigidBody.velocity = Vector3.zero;

                m_ThirdPersonPlayer.disableInput = true;
                m_ThirdPersonPlayer.noLookIK();
                m_Character.rigidBody.isKinematic      = true;
                m_Character.rigidBody.detectCollisions = false;
                m_Character.capsule.enabled            = false;

                if (m_ThirdPersonPlayer.ragdoll.isFullRagdoll)
                {
                    m_ThirdPersonPlayer.m_Camera.switchTargets(m_ThirdPersonPlayer.ragdoll.RagdollBones[(int)BodyParts.Spine]);
                }
            };
            m_ThirdPersonPlayer.ragdoll.OnStartTransition = () =>
            {
                if (!m_ThirdPersonPlayer.ragdoll.isFullRagdoll && !m_ThirdPersonPlayer.ragdoll.isGettingUp)
                {
                    m_Character.simulateRootMotion         = true;
                    m_Character.rigidBody.detectCollisions = true;
                    m_Character.rigidBody.isKinematic      = false;
                    m_Character.capsule.enabled            = true;
                }
                else
                {
                    m_Animator.SetFloat(/*"pForward"*/ HashIDs.ForwardFloat, 0.0f);
                    m_Animator.SetFloat(/*"pSide"*/ HashIDs.SideFloat, 0.0f);
                }
            };
            m_ThirdPersonPlayer.ragdoll.ragdollEventTime = 3.0f;
            m_ThirdPersonPlayer.ragdoll.OnTimeEnd        = () =>
            {
                if (m_Stats.currentHealth > 0)
                {
                    m_ThirdPersonPlayer.ragdoll.blendToMecanim();
                }
            };
            //m_Ragdoll.OnBlendEnd = () =>
            // {
            //     Debug.Log("ON BLEND END");
            // };
            //m_Ragdoll.OnGetUpEvent = () =>
            //  {
            //      Debug.Log("ON GET UP EVENT");
            //  };
            m_ThirdPersonPlayer.ragdoll.LastEvent = () =>
            {
                m_Character.simulateRootMotion   = true;
                m_Character.disableMove          = false;
                m_ThirdPersonPlayer.disableInput = false;

                if (m_ThirdPersonPlayer.lookTowardsCamera)
                {
                    m_Character.setIKMode(TPCharacter.IKMode.Head);
                }

                m_Character.rigidBody.isKinematic      = false;
                m_Character.rigidBody.detectCollisions = true;
                m_Character.capsule.enabled            = true;
                m_ThirdPersonPlayer.m_Camera.switchTargets(m_ThirdPersonPlayer.m_Camera.Target);
            };

            if (m_ThirdPersonPlayer.lookTowardsCamera)
            {
                m_Character.setIKMode(TPCharacter.IKMode.Head);
            }


            m_ThirdPersonPlayer.OnAttackHit         = attack_hit_notify;
            m_ThirdPersonPlayer.OnAttackEndNotify   = attack_end_notify;
            m_ThirdPersonPlayer.OnAttackStartNotify = attack_start_notify;

            if (m_ThirdPersonPlayer.triggers)
            {
                // setup trigger callbacks
                m_ThirdPersonPlayer.triggers.OnTriggerStart = () =>
                {
                    if (m_ThirdPersonPlayer.legsIK)
                    {
                        m_ThirdPersonPlayer.legsIK.enabled = false;
                    }
                    m_ThirdPersonPlayer.disableInput = true;
                    bool isOnLedge = m_Animator.GetBool(/*"pOnLedge"*/ HashIDs.OnLedgeBool);
                    if (!isOnLedge)
                    {
                        m_ThirdPersonPlayer.noLookIK();
                        m_PrevStrafing = m_ThirdPersonPlayer.strafing;
                        m_ThirdPersonPlayer.strafing = false;
                    }
                };
                m_ThirdPersonPlayer.triggers.OnTriggerEnd = () =>
                {
                    bool isOnLedge = m_Animator.GetBool(/*"pOnLedge"*/ HashIDs.OnLedgeBool);
                    if (!isOnLedge)
                    {
                        m_Player.m_Camera.additiveRotation = false;
                        m_Player.strafing = m_PrevStrafing;
                        if (m_ThirdPersonPlayer.legsIK)
                        {
                            m_ThirdPersonPlayer.legsIK.enabled = true;
                        }
                        if (m_ThirdPersonPlayer.lookTowardsCamera)
                        {
                            m_Character.setIKMode(TPCharacter.IKMode.Head);
                        }
                        if (m_ThirdPersonPlayer.strafing)
                        {
                            m_Character.setMoveMode(TPCharacter.MovingMode.Strafe);
                        }
                    }
                    m_ThirdPersonPlayer.disableInput = false;
                };
            }

            def_cameraMinXangle = (m_ThirdPersonPlayer.m_Camera as OrbitCameraController).minXAngle;
            def_cameraMaxXangle = (m_ThirdPersonPlayer.m_Camera as OrbitCameraController).maxXAngle;
            def_Xconstraint     = (m_ThirdPersonPlayer.m_Camera as OrbitCameraController).Xconstraint;

            m_PrevTargetDirection = m_TargetDirection;

            m_Initialized = true;
            return(m_Initialized);
        }