Créer une plateforme automatique

Les plateformes automatiques, on on en trouve dans beaucoup de jeux. En général, plus particulièrement dans les jeux d’arène visant à faire s’affronter des joueurs pour son côté dynamique.

Ces plateformes ont une position fixe et une destination. Lorsqu’un joueur « monte » dessus, elle se déplace jusqu’à son second point d’encrage, attend quelques instants puis retourne à son point de départ.

Disclaimer

Cet article a été originalement écrit le 01/11/2014 sur mon précédent blog. Certaines informations présentées ici peuvent donc ne plus fonctionner telles quelles.

Mise en place

La mise en place de la scène sera assez basique : une plateforme qui va se déplacer verticalement comme un ascenseur, et des escaliers pour redescendre. Par simplicité, j’utiliserai les Sample Assets.

Voilà la scène d’exemple :

La plateforme automatique que nous allons créer a une texture de damier. Nous allons utiliser le contrôleur FPS, mais le procédé est également valable pour tout autre type de caméra / contrôleur.

L’inspecteur personnalisé

Nous allons couvrir le cas le plus simple : la plateforme a 2 points d’ancrage. Son point d’attente et son point de fin de parcourt. On va se créer un petit outil pour enregistrer simplement ces positions via l’inspecteur : un inspecteur personnalisé.

Pour se faire, il faut commencer par créer le script de notre plateforme automatique. Voici les informations qui nous intéressent pour l’instant :

public class AutomaticPlatform : MonoBehaviour
{
    public Vector3 WaitPosition;
    public Vector3 TargetPosition;
    public float MoveSpeed;
}

Nous avons là sa position d’attente, sa position cible une fois le joueur détecté, et sa vitesse de déplacement. Difficile de faire plus simple !

Pour créer un inspecteur personnalisé, il faut créer une nouvelle classe  qui va surcharger l’inspecteur pour notre composant. Voilà comment ça se passe :

[CustomEditor(typeof(AutomaticPlatform))]
public class AutomaticPlatformEditor : Editor
{
    public override void OnInspectorGUI()
    {

    }
}

Le script ne doit pas étendre MonoBehaviour mais Editor. Ensuite, il faut lui ajouter l’Attribut CustomEditor en lui donnant le type du composant dont l’inspecteur sera surchargé. Enfin, il faut surcharger la méthode OnInspectorGUI pour y mettre son code personnalisé. Vous suivez toujours ?

Si vous ajoutez le script à la plateforme et que vous jetez un oeil à l’inspecteur, vous pouvez constater… que les variables publiques ne sont pas accessibles…. et même qu’il n’y a rien du tout d’affiché !

C’est normal. Vous avez surchargé la construction de l’inspecteur sans rien y mettre. Le plus simple est de commencer par ajouter le dessin de l’inspecteur par défaut avec le code suivant :

DrawDefaultInspector();

Ce faisant, vous devez retrouver l’inspecteur par défaut avec ses champs habituels. Maintenant ajoutons les choses qui nous intéressent ! Pour commencer, il faut récupérer l’instance du composant en cours d’inspection. Elle est accessible via la variable « target« . Il vous faudra cependant la caster pour pouvoir l’utiliser :

var component = (AutomaticPlatform)target;

Le reste de cette méthode fonctionne comme l’ancienne GUI d’Unity. C’est pas super beau, mais c’est comme ça que ça marche. Créons donc deux boutons qui vont initialiser la position de départ et ramener le GameObject à cette position. De cette manière, on n’aura aucune valeur à saisir dans l’inspecteur.

GUILayout.BeginHorizontal("box");
if(GUILayout.Button("Setup Start"))
{
    component.WaitPosition = component.gameObject.transform.position;
}
if (GUILayout.Button("Move to start"))
{
    component.gameObject.transform.position = component.WaitPosition;
}
GUILayout.EndHorizontal();

Je vous laisse compléter pour faire la même chose avec le point cible. On obtient ceci dans l’inspecteur :

On peut sans doute faire plus joli… mais ça fait ce qu’on veut ! C’est tout pour les outils. Vous avez là de quoi placer facilement les deux points de passage de votre plateforme automatique !

Gestion de la plateforme automatique

Pour que la plateforme détecte le joueur, il lui faut évidemment un BoxCollider :

Comme notre modèle a déjà un BoxCollider pour gérer la collision, on va le parenter à un nouveau GameObject qui sera le conteneur de notre plateforme.  Déplacez également le composant AutomaticPlatform pour le placer sur le collider et non plus sur la plateforme en elle même. Vérifiez que les positions enregistrées sont toujours correctes.

A la détection du joueur, on enclenche le mouvement qui sera géré par iTween :

public class AutomaticPlatform : MonoBehaviour
{
    public Vector3 WaitPosition;
    public Vector3 TargetPosition;
    public float MoveSpeed;

    void OnTriggerEnter(Collider c)
    {
        print("enter");
        var hash = iTween.Hash(
            "x", TargetPosition.x,
            "y", TargetPosition.y,
            "z", TargetPosition.z,
            "delay", 1,
            "speed", MoveSpeed,
            "oncomplete", "MoveBack",
            "easetype", iTween.EaseType.linear,
            "oncompletetarget", gameObject
        );

        iTween.MoveTo(gameObject, hash);
    }

    public void MoveBack()
    {
        var hash = iTween.Hash(
            "x", WaitPosition.x,
            "y", WaitPosition.y,
            "z", WaitPosition.z,
            "speed", MoveSpeed,
            "easetype", iTween.EaseType.linear,
            "delay", 5
        );

        iTween.MoveTo(gameObject, hash);
    }
}

Et voilà. Un beau petit ascenseur automatique, avec des outils simples pour en créer d’autres !