[Resolu]Déplacer le FPS du standard assets

[EmileF]

Bonjour,

Dans mon jeu j'utilise le FPSController du standard asset.
J'ai besoin à certain moment de le déplacer par script d'un point à un autre sans animation ni rien. Juste le mettre à une autre position en utilisant le transform.Position.
Il y va mais aussitôt revient à sa place. Je suppose que ça vient d'une particularité de son script, mais je n'arrive pas à trouver où, qu'elle fonction le remet à sa place, pour essayer de la court-circuiter.

Est-ce que quelqu'un a une solution, ou une idée pour y arriver.

Merci.

[boubouk50]

Peux-tu poster ton code?
Que déplaces-tu? Le rigidBody ou le Mesh? Il me semble que le FPC possède une hiérarchie, il faut déplacer le parent, et s'il contient un rigidbody, alros déplacer celui-ci, je pense.

Sinon, tu peux également faire ce changement directement dans le code du FPC, qui lui va de tout évidence continuer à contrôler le Player même si tu le modifies depuis un autre script.

[EmileF]

merci pour ta réponse,

Que déplaces-tu? Le rigidBody ou le Mesh? Il me semble que le FPC possède une hiérarchie, il faut déplacer le parent, et s'il contient un rigidbody, alors déplacer celui-ci, je pense.

Je déplaçais le transform et c'est lui le parent et il a la caméra comme enfant.
Suite à ton message j'ai essayé avec la fonction movePosition du rigidbody et c'est pareil

Sinon, tu peux également faire ce changement directement dans le code du FPC, qui lui va de tout évidence continuer à contrôler le Player même si tu le modifies depuis un autre script.

Je pense que le problème est là, et c'est là mon problème, je n'arrive pas à trouver où ça coince.

Voilà le script, en fait c'est une copie du script original du FPC auquel j'ai ajouté quelques petites modif pour n'appliquer les rotations de la caméra qu'avec la roulette de la souris pressée, et de déplacer le player vers un point cliqué au sol.

Code : Tout sélectionner

using System;
using UnityEngine;
using UnityStandardAssets.Characters.FirstPerson;
using UnityStandardAssets.CrossPlatformInput;
using UnityStandardAssets.Utility;
using Random = UnityEngine.Random;
using Utilitaires;

[RequireComponent(typeof(CharacterController))]
[RequireComponent(typeof(AudioSource))]
public class FPC : MonoBehaviour
{
    [SerializeField] private bool m_IsWalking;
    [SerializeField] private float m_WalkSpeed;
    [SerializeField] private float m_RunSpeed;
    [SerializeField] [Range(0f, 1f)] private float m_RunstepLenghten;
    [SerializeField] private float m_JumpSpeed;
    [SerializeField] private float m_StickToGroundForce;
    [SerializeField] private float m_GravityMultiplier;
    [SerializeField] private MouseLook m_MouseLook;
    [SerializeField] private bool m_UseFovKick;
    [SerializeField] private FOVKick m_FovKick = new FOVKick();
    [SerializeField] private bool m_UseHeadBob;
    [SerializeField] private CurveControlledBob m_HeadBob = new CurveControlledBob();
    [SerializeField] private LerpControlledBob m_JumpBob = new LerpControlledBob();
    [SerializeField] private float m_StepInterval;
    [SerializeField] private AudioClip[] m_FootstepSounds;    // an array of footstep sounds that will be randomly selected from.
    [SerializeField] private AudioClip m_JumpSound;           // the sound played when character leaves the ground.
    [SerializeField] private AudioClip m_LandSound;           // the sound played when character touches back on ground.

    public Camera m_Camera;
    private bool m_Jump;
    private float m_YRotation;
    private Vector2 m_Input;
    private Vector3 m_MoveDir = Vector3.zero;
    private CharacterController m_CharacterController;
    private CollisionFlags m_CollisionFlags;
    private bool m_PreviouslyGrounded;
    private Vector3 m_OriginalCameraPosition;
    private float m_StepCycle;
    private float m_NextStep;
    private bool m_Jumping;
    private AudioSource m_AudioSource;

    // Use this for initialization
    private void Start()
    {
        m_CharacterController = GetComponent<CharacterController>();
        //m_Camera = Camera.main;
        m_OriginalCameraPosition = m_Camera.transform.localPosition;
        m_FovKick.Setup(m_Camera);
        m_HeadBob.Setup(m_Camera, m_StepInterval);
        m_StepCycle = 0f;
        m_NextStep = m_StepCycle / 2f;
        m_Jumping = false;
        m_AudioSource = GetComponent<AudioSource>();
        m_MouseLook.Init(transform, m_Camera.transform);
    }

    bool move;
    Vector3 dest;
    Vector3 expos;
    // Update is called once per frame
    private void Update()
    {
        //Modif perso
        if (move)
        {
            dest.y = transform.position.y;
            RotateLook();
            Vector3 dif = dest - transform.position;
            if (dif.magnitude < 1f)
            {
                //quand on est arrivé, on précise la position et on stoppe
                transform.position = dest;
                look = false;
                move = false;
            }
            if ((expos - transform.position).magnitude < 0.01f)
            {
                look = false;
                move = false;
            }
            expos = transform.position;

        }
        else
        //fin de modif
        {
            RotateView();
            // the jump state needs to read here to make sure it is not missed
            if (!m_Jump)
            {
                m_Jump = CrossPlatformInputManager.GetButtonDown("Jump");
            }

            if (!m_PreviouslyGrounded && m_CharacterController.isGrounded)
            {
                StartCoroutine(m_JumpBob.DoBobCycle());
                PlayLandingSound();
                m_MoveDir.y = 0f;
                m_Jumping = false;
            }
            if (!m_CharacterController.isGrounded && !m_Jumping && m_PreviouslyGrounded)
            {
                m_MoveDir.y = 0f;
            }

            m_PreviouslyGrounded = m_CharacterController.isGrounded;
        }
    }


    private void PlayLandingSound()
    {
        m_AudioSource.clip = m_LandSound;
        m_AudioSource.Play();
        m_NextStep = m_StepCycle + .5f;
    }


    private void FixedUpdate()
    {
        float speed;
        GetInput(out speed);
        // always move along the camera forward as it is the direction that it being aimed at
        Vector3 desiredMove = transform.forward * m_Input.y + transform.right * m_Input.x;

        // get a normal for the surface that is being touched to move along it
        RaycastHit hitInfo;
        Physics.SphereCast(transform.position, m_CharacterController.radius, Vector3.down, out hitInfo,
                           m_CharacterController.height / 2f, Physics.AllLayers, QueryTriggerInteraction.Ignore);
        desiredMove = Vector3.ProjectOnPlane(desiredMove, hitInfo.normal).normalized;

        m_MoveDir.x = desiredMove.x * speed;
        m_MoveDir.z = desiredMove.z * speed;


        if (m_CharacterController.isGrounded)
        {
            m_MoveDir.y = -m_StickToGroundForce;

            if (m_Jump)
            {
                m_MoveDir.y = m_JumpSpeed;
                PlayJumpSound();
                m_Jump = false;
                m_Jumping = true;
            }
        }
        else
        {
            m_MoveDir += Physics.gravity * m_GravityMultiplier * Time.fixedDeltaTime;
        }
        m_CollisionFlags = m_CharacterController.Move(m_MoveDir * Time.fixedDeltaTime);

        ProgressStepCycle(speed);
        UpdateCameraPosition(speed);

        m_MouseLook.UpdateCursorLock();
    }


    private void PlayJumpSound()
    {
        m_AudioSource.clip = m_JumpSound;
        m_AudioSource.Play();
    }


    private void ProgressStepCycle(float speed)
    {
        if (m_CharacterController.velocity.sqrMagnitude > 0 && (m_Input.x != 0 || m_Input.y != 0))
        {
            m_StepCycle += (m_CharacterController.velocity.magnitude + (speed * (m_IsWalking ? 1f : m_RunstepLenghten))) *
                         Time.fixedDeltaTime;
        }

        if (!(m_StepCycle > m_NextStep))
        {
            return;
        }

        m_NextStep = m_StepCycle + m_StepInterval;

        PlayFootStepAudio();
    }


    private void PlayFootStepAudio()
    {
        if (!m_CharacterController.isGrounded)
        {
            return;
        }
        // pick & play a random footstep sound from the array,
        // excluding sound at index 0
        int n = Random.Range(1, m_FootstepSounds.Length);
        m_AudioSource.clip = m_FootstepSounds[n];
        m_AudioSource.PlayOneShot(m_AudioSource.clip);
        // move picked sound to index 0 so it's not picked next time
        m_FootstepSounds[n] = m_FootstepSounds[0];
        m_FootstepSounds[0] = m_AudioSource.clip;
    }


    private void UpdateCameraPosition(float speed)
    {
        Vector3 newCameraPosition;
        if (!m_UseHeadBob)
        {
            return;
        }
        if (m_CharacterController.velocity.magnitude > 0 && m_CharacterController.isGrounded)
        {
            m_Camera.transform.localPosition =
                m_HeadBob.DoHeadBob(m_CharacterController.velocity.magnitude +
                                  (speed * (m_IsWalking ? 1f : m_RunstepLenghten)));
            newCameraPosition = m_Camera.transform.localPosition;
            newCameraPosition.y = m_Camera.transform.localPosition.y - m_JumpBob.Offset();
        }
        else
        {
            newCameraPosition = m_Camera.transform.localPosition;
            newCameraPosition.y = m_OriginalCameraPosition.y - m_JumpBob.Offset();
        }
        m_Camera.transform.localPosition = newCameraPosition;
    }


    private void GetInput(out float speed)
    {
        //modif perso
        float horizontal = 0;
        float vertical = 1;
        if (!move)
        {
            if (Input.GetMouseButtonDown(0))
            {
                dest = m_Camera.RaycastPos("Sol");
                if (dest != Vector3.zero)
                {
                    dest.y = transform.position.y;
                    look = true;
                    horizontal = 0;
                    vertical = 1;
                    move = true;
                    RotateLook();
                }
            }
            //fin de modif
      
            // Read input
            horizontal = CrossPlatformInputManager.GetAxis("Horizontal");
            vertical = CrossPlatformInputManager.GetAxis("Vertical")
                + Input.GetAxis("Mouse ScrollWheel");
        }
        bool waswalking = m_IsWalking;

#if !MOBILE_INPUT
            // On standalone builds, walk/run speed is modified by a key press.
            // keep track of whether or not the character is walking or running
            m_IsWalking = !Input.GetKey(KeyCode.LeftShift);
#endif
            // set the desired speed to be walking or running
            speed = m_IsWalking ? m_WalkSpeed : m_RunSpeed;
            m_Input = new Vector2(horizontal, vertical);

            // normalize input if it exceeds 1 in combined length:
            if (m_Input.sqrMagnitude > 1)
            {
                m_Input.Normalize();
            }

            // handle speed change to give an fov kick
            // only if the player is going to a run, is running and the fovkick is to be used
            if (m_IsWalking != waswalking && m_UseFovKick && m_CharacterController.velocity.sqrMagnitude > 0)
            {
                StopAllCoroutines();
                StartCoroutine(!m_IsWalking ? m_FovKick.FOVKickUp() : m_FovKick.FOVKickDown());
            }
    }

    //modif perso
    bool look;
    private void RotateLook()
    {
        if (look)
        {
            //extension perso de transform : LookAt geré par Tween
            transform.LookAt(dest, 0.1f, 0, () => look = false);
        }

    }

    private void RotateView()
    {
        m_MouseLook.LookRotation(transform, m_Camera.transform);
    }


    private void OnControllerColliderHit(ControllerColliderHit hit)
    {
        Rigidbody body = hit.collider.attachedRigidbody;
        //dont move the rigidbody if the character is on top of it
        if (m_CollisionFlags == CollisionFlags.Below)
        {
            return;
        }

        if (body == null || body.isKinematic)
        {
            return;
        }
        body.AddForceAtPosition(m_CharacterController.velocity * 0.1f, hit.point, ForceMode.Impulse);
    }
}

[boubouk50]

Pour déplacer un rigidBody directement tu peux modifier la position du rigidbody (et pas du transform).
https://docs.unity3d.com/ScriptReferenc ... ition.html

If you change the position of a Rigibody using Rigidbody.position, the transform will be updated after the next physics simulation step

L'Update () et le FixedUpdate () ne sont pas synchro. Tu peux avoir plusieurs Update () entre chaque FixedUpdate (). Je pense que le conflit peut se présenter ici. Essaie de modifier ton script pour que ton déplacement ait lieu dans l'un des deux qui est le bon. (supposition)
Physique -> FixedUpdate ()
Non-Physique -> Update ()

En gros, ce que je suspecte, c'est que la position du transform n'est pas mise à jour directement et que des calculs de position sont effectués à partir de celui-ci. Pendant ce temps, la position du rigidbody est modifiée également. L'une prend le pas sur l'autre.

[EmileF]

Mon déplacement est commandé par un autre script.

En fait, j'ai créé la possibilité de faire une sauvegarde de mon jeu avec bien sûr la position du transform du joueur et sa rotation sous forme de vecteurs

Quand je veux recharger le jeu, c'est là que se situe le problème.

J'ai fait l'essai en sauvegardant le rigidbody.position et rotation et en replaçant ces même valeur à la lecture est c'est pareil.

Ca marchait avant que j'utilise le Fps du standard assets. Il marche bien, mais....

En gros, ce que je suspecte, c'est que la position du transform n'est pas mise à jour directement et que des calculs de position sont effectués à partir de celui-ci. Pendant ce temps, la position du rigidbody est modifiée également. L'une prend le pas sur l'autre.

Je suis d'accord avec toi, mais comment puis-je reprendre les commandes.

[boubouk50]

Mon déplacement est commandé par un autre script.
En fait, j'ai créé la possibilité de faire une sauvegarde de mon jeu avec bien sûr la position du transform du joueur et sa rotation sous forme de vecteurs
Quand je veux recharger le jeu, c'est là que se situe le problème.

As-tu d'autres informations importantes à me communiquer petit cachotier??

En gros, tu veux que le perso reprenne place à l'endroit exact où il a été sauvegardé? Mais ce n'est pas le cas, c'est bien ça?
Si deux scripts modifient une position en même temps alors il y aura conflit.
Il faut donc qu'il y ait soit désactivation de l'un soit unification. C'est à dire, lorsque tu places ton objet, il ne faut pas que le FPC modifie la position en même temps, ou bien que le second script appelle le premier pour que celui-ci gère la position sans conflit.

[EmileF]

Loin de moi l'idée de te cacher quelque chose

Et je suis entièrement d'accord avec toi, sur le risque de conflit en 2 commandes différentes, mais dans mes essais, je ne déplace pas mon joueur, Il est au repos.

De plus, le FPC en fait est controlé par un CharacterController, je pense que c'est là que le bas blesse. Ce pauvre rigidbody n'y est pour rien, et je n'arrive pas à voir comment le neutraliser le temps de mon transfert. D'ailleur comment font-ils les créateurs de jeu s'il on une téléportation de leur jouer? C'est une peu la même chose, non?

Je pense que je vais devoir reprendre l'ensemble du script moi-même. Mais j'aime bien la gestion des collisions du FPS du standard asset, et je ne suis pas sûr de moi sur ce point.

[boubouk50]

Tu peux garder le FPC tel quel, il te faut isoler les déplacements.
Par exemple, tu peux avoir un booléen qui gère la téléportation. Si tu téléportes alors tu ne continues pas le script de déplacement. Un peu à la manière d'un jump qui empêche le déplacement tant que le joueur est en l'air.
Il y a bien des solutions sans tout retoucher.

[EmileF]

Ca y est, merci boubouk

En fait, comme je disais dans mon message précédent, c'est un CharacterController, qui gère les déplacements du FPC, le rigidbody n'y est pour rien (le pauvre )

Au save, j'ai sauvegardé les position et rotation du FPC.Transform.

Au load, j'ai mis l'"Enabled" du "CharecterController" à false,
Rechargé et appliqué mes position et rotation au transform du FPC
et réactivé mon CharacterController.

Le tour est joué

Il faut donc qu'il y ait soit désactivation de l'un

C'est ça qui m'a mis sur la voie. Merci encore boubouk