[DB-AL] Déplacement "Case Par Case"

Pour les scripts écrits en C#
Règles du forum
Merci de respecter la NOMENCLATURE suivante pour vos TITRES de messages :

Commencez par le niveau de vos scripts
DB = Débutant
MY = Moyen
CF = Confirmé

Puis le domaine d'application
-RS = Réseau
-AL = Algorithmie

Exemple :

[DB-RS] Mouvement perso multijoueur
djulio74
Messages : 682
Inscription : 19 Déc 2009 22:55

Re: [DB-AL] Déplacement "Case Par Case"

Message par djulio74 » 05 Nov 2018 19:38

le transform.translate ne tiens pas compte du temps. il déplace ton robot, de sa position à celle indiquée (vector3.up) , directement.
il faut tu reste avec MoveTowards

pour ton histoire de cases :
il suffit d'un array de vector2.
Ensuite pour tes déplacement, il ne faudra plus donner une direction sous forme de vector, mais sou forme de int.

Admettons un plateau de 4 x 4 case, donc une taille de 4.
tu aurra 4x4 = 16 cases. Il suffit de donner à chaque case ses coordonnées.
Après pour aller vers le haut ce sera case +4 (taille), vers le bas case -4, +1 et -1 pour gauche et droite.

Image
Admettons ton robot est en case 5. un déplacement vers le haut le mènera a la case 5+4 ( dans le case d'une grille de 4x4) donc 9. tu prend les coordonnées de la case 9 et tu y déplace ton robot.

un Exemple vite fait de script :

Code : Tout sélectionner

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class NewBehaviourScript : MonoBehaviour
{
	public int taille = 4;
	private Vector3[] cases;
	private bool[] occupe;
	public int pos; 	// stock la case sur laquelle est le robot.
	
	void Start ()
	{
		// on defini la taille des array cases et occupé
		cases = new Vector3[taille * taille];
		occupe = new bool[taille * taille];
		
		for (int i = 0; i < taille; i++) {  
			for (int j = 0; j < taille; j++) { 
				cases [i * taille + j] = new Vector3 (j,0, i);
				occupe [i * taille + j] = false;
			}
		}

		pos = 5; 
		transform.position = cases [pos]; // tu pose ton robot a la case 5
	}
	
	// Update is called once per frame
	void Update ()
	{

		if (Input.GetKeyDown (KeyCode.UpArrow)) {
			pos += taille;
			StartCoroutine( Move() );
		}
		if (Input.GetKeyDown (KeyCode.DownArrow)) {
			pos -= taille;
			StartCoroutine( Move() );
		}
		if (Input.GetKeyDown (KeyCode.LeftArrow)) {
			pos += 1;
			StartCoroutine( Move() );
		}
		if (Input.GetKeyDown (KeyCode.RightArrow)) {
			pos -= 1;
			StartCoroutine( Move() );
		}		
	}

	IEnumerator Move(){

		while (transform.position != cases[pos]) {
			transform.position = Vector3.MoveTowards(transform.position, cases[pos], Time.deltaTime * 10.0f );
			yield return null;
		}
	}
}

EDIT :
Mes code sont pour de la 3d, pour de la 2D remplacer les Vector3 par vector2, et
cases [i * taille + j] = new Vector3 (j,0, i); deviens cases [i * taille + j] = new Vector2 (j, i);
Dernière édition par djulio74 le 05 Nov 2018 19:59, édité 1 fois.

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

djulio74
Messages : 682
Inscription : 19 Déc 2009 22:55

Re: [DB-AL] Déplacement "Case Par Case"

Message par djulio74 » 05 Nov 2018 19:48

ou avec les stockage des déplacement a venir :

Code : Tout sélectionner

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class NewBehaviourScript : MonoBehaviour
{

	public int taille = 4; // taille du terrain
	private Vector3[] cases; // liste dses cases
	private bool[] occupe; 
	public int pos;	// stock la case sur laquelle est le robot.

	public List<int> deplacement = new List<int>(); // liste des déplacement a venir

	void Start ()
	{
		// on defini la taille des array cases et occupé
		cases = new Vector3[taille * taille];
		occupe = new bool[taille * taille];

		for (int i = 0; i < taille; i++) {  
			for (int j = 0; j < taille; j++) { 

				cases [i * taille + j] = new Vector3 (j,0, i);
				occupe [i * taille + j] = false;
			}
		}
		pos = 5; 
		transform.position = cases [pos]; // tu pose ton robot a la case 5
	}
	
	// Update is called once per frame
	void Update ()
	{

		if (Input.GetKeyDown (KeyCode.UpArrow)) {
			deplacement.Add(taille); // on ajoute a la liste de deplacement
		}

		if (Input.GetKeyDown (KeyCode.DownArrow)) {			
			deplacement.Add(-taille); // on ajoute a la liste de deplacement
		}

		if (Input.GetKeyDown (KeyCode.LeftArrow)) {
			deplacement.Add(1); // on ajoute a la liste de deplacement
		}

		if (Input.GetKeyDown (KeyCode.RightArrow)) {
			deplacement.Add(-1); // on ajoute a la liste de deplacement
		}

		if( Input.GetKeyDown(KeyCode.Return)){
			StartCoroutine( Move() ); // on lance tout les déplacement dans l'ordre entré
		}
	}

	IEnumerator Move(){

		for ( int i = 0 ; i < deplacement.Count; i++){  // pour chaque déplacement enregistré
			
			pos += deplacement[i]; // pos = position suivante

			while (transform.position != cases[pos]) {
				transform.position = Vector3.MoveTowards(transform.position, cases[pos], Time.deltaTime * 10.0f );
				yield return null;
			}
		}
		deplacement = new List<int>(); // on reset la liste de déplacement.
	}
}


______________________________________________________________
\_______________________ Impossible is nothing _______________________/

Avatar de l’utilisateur
boubouk50
ModoGenereux
ModoGenereux
Messages : 6216
Inscription : 28 Avr 2014 11:57
Localisation : Saint-Didier-en-Bresse (71)

Re: [DB-AL] Déplacement "Case Par Case"

Message par boubouk50 » 05 Nov 2018 19:54

Il faut bien comprendre la différence entre les méthodes et le temps associé.

Un translate bouge un objet de x,y directement. Si tu veux que ton objet avance, il faut découper en plusieurs translation sur plusieurs intervalles de temps.
Par exemple, déplacer un objet de 10 cm sur une seconde en 30 images par secondes, il faut découper ton mouvement en 30 translations, soit 1/3 cm par translation et le bouger toutes les 1/30 de secondes.
Ici, tu le bouges une fois et basta.
Il existe des fonctions toutes faites, comme le Lerp (Interpolation Linéaire) et des façons de procéder dédiées comme la coroutine.
Je t'invite donc à aller jeter un coup d’œil sur la doc et le net pour comprendre leur utilisation.

EDIT - Djulio est allé plus vite, j'ai pas lu son pavé. Peut-être as-tu déjà les clés en main.
"Ce n'est pas en améliorant la bougie, que l'on a inventé l'ampoule, c'est en marchant longtemps."
Nétiquette du forum
Savoir faire une recherche
Apprendre la programmation

SidCamelot
Messages : 27
Inscription : 16 Oct 2018 23:14

Re: [DB-AL] Déplacement "Case Par Case"

Message par SidCamelot » 06 Nov 2018 12:45

D'abord un grand merci Djulio pour avoir pris le temps de m'expliquer. C'est vraiment très précieux pour moi, très clair et le script que tu as pondu est parfait mais j'ai toujours le même problème concernant la rotation. A savoir quand je fais pivoter le robot à 90° l'ordre "avance' qui suit le fera aller vers le haut alors qu'il devrait aller vers la gauche.

Merci aussi Boubouk pour ta réponse. Je veux juste préciser quelque chose. La doc, j'y passe beaucoup de temps dessus et avant de poser une question sur ce forum je t'assure que j'ai épluché un paquet de pages sur le net. Sans parler des Tutos que je suis à la lettre. Par exemple rien que pour tenter de comprendre les problèmes de déplacement et de cases j'ai fait le Tuto sur l'échiquier, le socoban et le Rogue 2D. Des heures et des heures... Et Djulio en un seul post et une explication simple m'a fait comprendre. Je suis débutant sur Unity et en C#. Je fais de la programmation depuis des années mais jusqu'ici je n'ai travaillé que sur de la conception de devis en imprimerie... Rien à voir. Je sais que je pose des questions qui peuvent paraître "stupides" pour des pros, mais je suis bien à la section débutant ?

Unity met en avant son accessibilité et c'est vrai que c'est un outil formidable. J'ai été super enthousiaste au début, en suivant les leçons dans l'ordre plus quelques Tutos, j'ai très vite été capable de faire bouger un personnage en 3D, avec ses animations, dans un décors de rêve en relief avec des arbres etc... Mais modestement je me suis dit que je n'allais pas pèter plus haut que mon fondement et que j'allais me limiter à de la 2D pour commencer. Il me semblait alors que quelque chose d'aussi élémentaire que déplacer un personnage en 2D serait plus facile ! Mais, visiblement ce n'est même pas à la portée du débutant lambda. Honteusement, je vais vous demander si vous pouvez me donner un script qui permet seulement de :
déplacer un GameObject vers l'avant d'une unité quand on appuie sur la touche Z
pivoter un GameObject vers la droite à 90° quand on appuie sur la touche D
et quand on appuie de nouveau sur la touche Z (en avant donc) il se dirige bien vers l'avant par rapport à soi (pas par rapport au monde, donc vers la droite si on avait appuyé une fois sur D avant, ou vers le bas si on avait appuyé 2 fois sur D)
Le tout "smoothly", c'est à dire que le GameObject ne se déplace pas d'un coup mais avec un effet de transition.

Voilà, je ne suis pas très fier mais j'avoue que je ne pensais pas que ça allait me prendre plusieurs jours juste pour pondre ce petit bout de code moi même !! :gene2:

Avatar de l’utilisateur
boubouk50
ModoGenereux
ModoGenereux
Messages : 6216
Inscription : 28 Avr 2014 11:57
Localisation : Saint-Didier-en-Bresse (71)

Re: [DB-AL] Déplacement "Case Par Case"

Message par boubouk50 » 06 Nov 2018 13:03

T'inquiètes, quand je dis d'aller jeter un œil sur la doc, c'est parce que le fonctionnement et l'utilisation sont expliqués (en anglais certes). Les exemples illustrent clairement l'utilisation.
Ce sont des pistes d'exploration car tu n'as pas encore le vocabulaire associé ou la connaissance de certaines fonctions toutes faites.
Donc, ce n'est pas juste pour te renvoyer la balle. (Bon après, je fais une réponse rapide, je suis en charrette en ce moment au taff). Après, aussi il faut savoir lire correctement une documentation.

Concernant le déplacement World et pas Local, comme tu le souhaiterais, il te faut tout simplement ajouter un paramètre à la fonction Translate (). Comme tu peux le voir dans la documentation, Translate () à deux utilisations. La deuxième te permet de définir le repère dans lequel le déplacement doit être effectué. Le comportement est expliqué dessous.
public void Translate(Vector3 translation, Space relativeTo = Space.Self);
Tu peux aussi utiliser le vecteur local de l'objet plutôt que le World:
transform.up plutôt que Vector3.up.
transform.up sera toujours le vecteur de devant de ton objet quel que soit ta rotation alors que Vector.up sera toujours le vecteur vers le haut du monde. (à vérifier si c'est bien up et pas forward, je maitrise pas la 2D)

Bon par contre, je n'ai pas exploré le code de Djulio, s'il utilise les positions World, il faut rester dans ce repère car tu "vas d'une position à une autre", tu ne "déplaces pas ton objet selon un vecteur".

Il y a plusieurs façon de faire. Pour ma part, je serai passé par des commandes et des actions locales pour pas se soucier d'où on va tant qu'on n'effectue pas le déplacement.
Tu aurais un code pour tes actions qui seraient stockées dans une liste puis jouées.
Ainsi, une rotation ou un déplacement local n'en aurait rien à faire dans quel sens tu te trouves ou de savoir où tu es.
La seule condition à vérifier serait de savoir si ton objet n'avance pas hors champ lors d'une translation.
"Ce n'est pas en améliorant la bougie, que l'on a inventé l'ampoule, c'est en marchant longtemps."
Nétiquette du forum
Savoir faire une recherche
Apprendre la programmation

djulio74
Messages : 682
Inscription : 19 Déc 2009 22:55

Re: [DB-AL] Déplacement "Case Par Case"

Message par djulio74 » 06 Nov 2018 14:02

Salut.
alors oui en effet, le script que j'avais fait vite fait déplaçait juste le robot d'une case a une autre, pour que le robot tourne, et aille ensuite dans la bonne direction, il faut modifier le déplacement de la case en fonction de vers ou il pointe
Avec un "int" depActu, tu pointera dans une liste de 4 choix :
il y a 4 cas :
- ton robot point vers le haut : depActu = 0 --> son déplacement sera de " + taille" ( taille du terrain)
- ton robot pointe vers la droite : depActu = 1 --> son déplacement sera de " + 1"
- ton robot pointe vers le bas : depActu = 2 --> son déplacement sera de " - taille" ( taille du terrain)
- ton robot pointe vers la gauche : depActu = 3 --> son déplacement sera de " - 1"

en fonction de si tu tourne a droite ou gauche, depActu augmentera ou diminuera de 1, en ser repetant dans la plage ( 0,4)
exemple :
1 - ton robot pointe vers le haut : depActu = 0;
2- tu dis " avance d'une case" : on ajoute le deplacement correspondant a depActu : +taille ( une case au dessus)
3- tu dis "tourne a droite" : on ajoute une rotation de 90 degrés, et on augmente depActu de 1 : depActu passe a 1
4- tu dis " avance d'une case" : on ajoute le deplacement correspondant a depActu : +1 ( une case a droite)

Code : Tout sélectionner

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class robot : MonoBehaviour
{

	public int taille = 16;		// taille du terrain
	private Vector3[] cases;	// liste dses cases
	private bool[] occupe;		// liste de bool pour savoir si une case est occupée
	public int pos;			// case sur laquelle se trouve ton robot

	public int[] dep;		// liste des déplacement possible (+taille, -taille, +1,-1)
	public int depActu = 0;		// l'élément de "dep" en cours, en fonction de la rotation du robot

	public List<int> deplacement = new List<int> ();	// liste des déplacement a venir/enregistré
	public List<int> rot = new List<int> ();		// liste ds rotation a venir/enregistré

	void Start ()
	{
		// on defini la taille des array cases et occupé
		cases = new Vector3[taille * taille];
		occupe = new bool[taille * taille];

		for (int i = 0; i < taille; i++) {  
			for (int j = 0; j < taille; j++) { 

				cases [i * taille + j] = new Vector3 (j, 0, i);
				occupe [i * taille + j] = false;
			}
		}

		// on defini les déplacement possible, en fonction de la taille du terrain ( taille x taille)

		dep = new int[4];
		dep [0] = taille;
		dep [1] = 1;
		dep [2] = -taille;
		dep [3] = -1;


		pos = (taille / 2) * taille + taille / 2; // on place le robot au milieu du terrain 
		transform.position = cases [pos]; // tu pose ton robot a la case "pos"
	}

	void Update ()
	{

		// appuie de la fleche haut : le robot avancera devant lui
		if (Input.GetKeyDown (KeyCode.UpArrow)) {
			deplacement.Add (dep [depActu]); // on ajoute a la liste de deplacement
			rot.Add (0);	// on ajoute une rotation nulle, pour avoir le même nombre de rot/deplacement
		}

		// appuie de la fleche bas : le robot reculera
		if (Input.GetKeyDown (KeyCode.DownArrow)) {			
			deplacement.Add (-dep [depActu]); // on ajoute a la liste de deplacement
			rot.Add (0); // on ajoute une rotation nulle, pour avoir le même nombre de rot/deplacement
		}

		// appui fleche gauche, le robot tournera
		if (Input.GetKeyDown (KeyCode.LeftArrow)) {
			deplacement.Add (0); // on ajoute un deplacement nulle, car ajout de rotation
			rot.Add (90);   // on ajoute un ordre de rotation a la liste
			depActu = (int)Mathf.Repeat (depActu - 1, 4); // on change depActu car l'orientation du robot a chagé
		}

		// appui fleche droite, le robot tournera
		if (Input.GetKeyDown (KeyCode.RightArrow)) {
			deplacement.Add (0); // on ajoute un deplacement nulle, car ajout de rotation
			rot.Add (-90);  // on ajoute un ordre de rotation a la liste
			depActu = (int)Mathf.Repeat (depActu + 1, 4); // on change depActu car l'orientation du robot a chagé
		}

		// appui sur entré, on exectute la liste des actions enregistrée
		if (Input.GetKeyDown (KeyCode.Return)) {
			StartCoroutine (Move ()); // on lance tout les déplacement dans l'ordre entré
		}
	}

	IEnumerator Move ()
	{
		// pour chaque déplacement/rot enregistré ( rot.Count = deplacement.Count)
		for (int i = 0; i < deplacement.Count; i++) {  

			// seulment si la rotation est différente de zero, on procede a la rotation
			if (rot [i] != 0) {
				
				// target sera la nouvelle orientation de transform.forward( direction vers le devant du robot)
				// il sera égale a sa droite ou sa gauche ( rotation de 90 ou -90 degré)
				Vector3 target = -transform.right * Mathf.Sign (rot [i]);

				// tant que la rotation n'est pas complete, on procede
				while (transform.forward != target) {
					transform.forward = Vector3.RotateTowards (transform.forward, target, Time.deltaTime * 10.0f, 0.0f);
					yield return null;
				}
			}

			// la position suivante du robot sera sa case actuelle + le déplacement enregistré
			pos += deplacement [i];
			// tant que le robot n'est pas arrivé a destionation, on procede au deplacement
			while (transform.position != cases [pos]) {
				transform.position = Vector3.MoveTowards (transform.position, cases [pos], Time.deltaTime * 10.0f);
				yield return null;
			}
		}

		// le robot a effectué toute les action enregistré, on efface la liste de deplacement et rot
		deplacement = new List<int> (); // on reset la liste de déplacement.
		rot = new List<int> ();
	}
}
Je te laisse regarder ce bout de code ( place le juste sur un cube tu verra les déplacements), et hésite pas a demander plus de précision
;-)

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

SidCamelot
Messages : 27
Inscription : 16 Oct 2018 23:14

Re: [DB-AL] Déplacement "Case Par Case"

Message par SidCamelot » 06 Nov 2018 19:01

Djulio, c'est exactement ça, le script fonctionne parfaitement. Le seul problème c'est qu'en 2D le robot pivote sur lui même (il se met visuellement de profil au lieu de tourner à 90° vers la droite ou la gauche). J'ai bien compris la "théorie" du rotate qui pivote selon un des 3 axes vers la cible voulue, mais je n'arrive pas à modifier le code pour obtenir le résultat escompté.


Boubouk, je pense aussi que à mon niveau c'est plus simple de passer par des commandes et des actions locales. Même si le système "case par case" de Djulio est très intéressant et je vais travailler dessus pour bien comprendre.

Donc, sur cette base, y a t'il un script simple pour faire exactement ça (et rien de plus):

Code : Tout sélectionner

public class Deplacement1 : MonoBehaviour
{
    public GameObject monRobot;

    void Update()
    {
        if (Input.GetKeyDown("z"))
        {
            monRobot.transform.Translate(0, 1, 0);
        }

        if (Input.GetKeyDown("e"))
        {
            monRobot.transform.Rotate(Vector3.forward * -90);
        }

    }
}
Le robot se déplace en 2D d'une unité vers l'avant quand on appuie sur "z", et pivote à 90° à droite quand on appuie sur "e". Quand on appuie à nouveau sur "z" il avance dans la direction vers laquelle il à pivoté. Sauf que là il se déplace par accoups et j'aimerai qu'il se déplace avec une impression de mouvement.

djulio74
Messages : 682
Inscription : 19 Déc 2009 22:55

Re: [DB-AL] Déplacement "Case Par Case"

Message par djulio74 » 06 Nov 2018 20:04

Mon script de fonctionne pas au top parce qu'il est pour de la 3D vu de dessus. il suffit de changer les vector3 par les bon vector2, là la doc d'unity te dira toute les correspondance. il me semble Vector3(x,y,z) => vector2(vector3.x, vector3.z).

Pour ce qui est du déplacement en saccade, on te l'as déjà dit ;-)
tu fais des demande de déplacement en une fois sans prendre en compte le temps ou la distance restant a parcourir jusqu’à la destination voulue.
Il faut que tu regarde du coté de coroutines ( comme dans mon exemple) :

le robot est à une position, sa position cible est "sa position+ transform.forward" ( une unité de plus en suivant son vector forward, devant lui). tant qu'il n'est pas a destination :
transform.position = Vector3.MoveTowards (transform.position, positionCible, Time.deltaTime * 10.0f);

;-)

______________________________________________________________
\_______________________ Impossible is nothing _______________________/

Avatar de l’utilisateur
boubouk50
ModoGenereux
ModoGenereux
Messages : 6216
Inscription : 28 Avr 2014 11:57
Localisation : Saint-Didier-en-Bresse (71)

Re: [DB-AL] Déplacement "Case Par Case"

Message par boubouk50 » 07 Nov 2018 09:50

Code : Tout sélectionner

public class Deplacement1 : MonoBehaviour
{
    public GameObject monRobot;

    void Update()
    {
        if (Input.GetKeyDown("z"))
        {
            monRobot.transform.Translate(0, 1, 0);
        }

        if (Input.GetKeyDown("e"))
        {
            monRobot.transform.Rotate(Vector3.forward * -90);
        }

    }
}
Je vais surtout t'expliquer comment fonctionne ce code et donc pourquoi ça ne marcherait pas.
Ici, tu as la fonction Update (), fonction qui s'active à chaque rafraichissement d'images soit, par exemple, 60 fois pour du 60 fps. Dans ce cas, tu vas tester à chaque frame si une des 2 touches e et z à été appuyée. Si c'est le cas alors soit tu déplaces ton objet, soit le tourne. Cela est donc une manipulation en temps réel et pas du tout pré-paramétrée comme tu le souhaites.
Ce qu'il faut faire, c'est de l'événementiel pour le paramétrage puis du temps réel. C'est à dire qu'il faut se proscrire du temps-réel pour l'enregistrement des actions à faire, puis l'utiliser.
Tu as des boutons dans ton interface, ce sont eux qui vont remplir ta liste d'actions. Ce seront les événements.
Ensuite, le bouton de lancement activera chacune des actions préenregistrées. Là, ce sera une fonction qui à chaque seconde, donnera l'ordre de tourner ou d'avancer (en fonction de la liste). Tu auras donc 2 fonctions, une pour avancer une pour tourner, qui seront des coroutines pour gérer le temps d'exécution des actions.
"Ce n'est pas en améliorant la bougie, que l'on a inventé l'ampoule, c'est en marchant longtemps."
Nétiquette du forum
Savoir faire une recherche
Apprendre la programmation

SidCamelot
Messages : 27
Inscription : 16 Oct 2018 23:14

Re: [DB-AL] Déplacement "Case Par Case"

Message par SidCamelot » 07 Nov 2018 11:32

Djulio, ce qui concerne le passage du Vector3 au Vector2 ne me pose pas de problème, c'est plutôt au niveau du Rotate que je ne trouve pas la bonne syntaxe pour qu'il pivote correctement.

Boubouk, j'ai bien compris ce que tu m'expliques et je l'ai déjà réalisé dans mon script global, ou j'ai fait une coroutine qui me permet (entre autre) d'exécuter d'un coup les ordres stockés et de temporiser les déplacements entre chaque pas :

Code : Tout sélectionner

IEnumerator Timer()
    {
        for (int i = 0; i < nombreOrdres ; i++)
        {
            yield return new WaitForSecondsRealtime(1);
            varMonRobot.transform.Translate(0, varAvanceRecule[i], 0);
            varMonRobot.transform.Rotate(Vector3.forward * varPivoteDG[i]);

/*  Ici j'ai d'autres instructions qui gèrent entre autre la chauffe du moteur, 
avec l'affichage de niveau de chauffe, 
plus un timer qui impute plus ou moins de temps à chaque action, 
je suis dans du tour par tour donc l'affichage du chronomètre est "simulé". 
*/
        }
    }

J'ai bien conscience que l'exécution de mes ordres se fait en temps réel et je n'utilise à aucun moment le void Update() dans mon script.

Dans ma dernière question avec ce code :

Code : Tout sélectionner

public class Deplacement1 : MonoBehaviour
{
    public GameObject monRobot;

    void Update()
    {
        if (Input.GetKeyDown("z"))
        {
            monRobot.transform.Translate(0, 1, 0);
        }

        if (Input.GetKeyDown("e"))
        {
            monRobot.transform.Rotate(Vector3.forward * -90);
        }
    }
}
je n'ai fait qu'isoler le point qui me pose problème. Mais en fait c'est bien effectivement au niveau de la coroutine que tout se passe. Le problème avec le Lerp (avec le rotate aussi d'ailleurs) c'est qu'il faut connaître 2 points, celui de départ et celui d'arrivée. Donc, je me disais qu'effectivement en passant par la Grid ou la Tilemap Unity avait déjà inclus ça... Apparemment je me suis trompé, il faut donc passer par le code. Je creuse en passant par le code et je me dis qu'en générant un grille (par un array) et en travaillant l'espace "case par case" ça serait plus facile... Pas évident non plus (encore merci à Djulio grâce à qui j'ai enfin compris) et finalement, comme je peux faire correspondre 1 unité de déplacement à un Sprite "dalle" de 1 unité, du coup les cases ne me servent à rien (à ce stade). Donc, en fait la solution la plus simple me parait être la tienne effectivement. Je dois donc me concentrer sur l'interpolation apparemment ? Vector2.Lerp pour les déplacements et Quaternion.Lerp pour les rotations ?

Avoues quand même que c'est loin d'être évident pour un débutant ou alors je suis particulièrement crétin (je ne l'exclue pas, rassures toi :rouge: ) surtout pour des actions aussi basiques qu'un simple déplacement sur une surface 2D ! Je vais donc potasser à nouveau dans cet axe là, je sais que je finirais par trouver mais je vais y passer des heures alors que pour des pros comme vous c'est de la gnognote. La preuve, Djulio a pondu un super script qui répond en partie à ma question en 3D mais bizarrement en 2D c'est plus problématique.

Bref, merci de toute façon d'avoir pris la peine de me répondre.

Répondre

Revenir vers « (C#) CSharp »