classe, interface, héritage, polymorphisme sont en fait tous des concepts de base de la programmation orienté objet (c#, java, ... et à peu prêt tt les langage actuel....). Je t'invite à découvrir tout ca sur le tutoriel d'openclassroom :
https://openclassrooms.com/courses/prog ... jet-avec-c
Je vais quand même essayer de répondre à tes questions sans te faire vider le tube d'aspirine.
La classe est par exemple ton fichier Lapin.cs, le script l'algorithme dans ce fichier.
C'est très bien de faire des prefab, ca te permet de placer rapidement les lapins sur ta scène mais ca ne résous pas la question de savoir quels scripts doivent être placé sur ton préfab lapin.
Pour revenir un peu plus haut et répondre a ta question
Parce qu'il y a une explication que je n'ai pas trouvé dans les tutos, c'est que j'ai du mal à voir quelles fonctions vont être appelées dans un script
Les 2 grand point d'entrée pour tes scripts vont se trouver dans la classe Monobehaviour et toutes les classes l'implémentant, les méthodes Start() et Update().
La méthode Start() va s'executer une seule fois dès que ton GameObject associé sera chargé.
La méthode Update() va s'executer a peu prêt 60fois par secondes tant que ton GameObject est présent.
Une des facon la plus propre de coder différents comportement est d'abord d'avoir une classe contenant les mouvements.
Code : Tout sélectionner
public class Lapin {
// une méthode pour se deplacer à gauche
public void moveLeft() {
transform.Translate(Vector3.right * Time.deltaTime * -1)
}
// une méthode pour se déplacer à droite
public void moveRight() {
transform.Translate(Vector3.right * Time.deltaTime)
}
// une méthode pour se déplacer en avant
public void moveForward() {
transform.Translate(Vector3.forward * Time.deltaTime)
}
// une méthode pour se déplacer en arrière
public void moveBackward() {
transform.Translate(Vector3.forward * Time.deltaTime * -1)
}
}
Et de l'autre une classe IA qui utilise ces méthodes
Code : Tout sélectionner
public class IALapinPassif : Monobehaviour {
// on récupère la référence du lapin
Lapin myLapin = gameObject.GetComponent<Lapin>();
// on prépare notre objet de génération de nombre aléatoire
Random rnd;
void Start() {
rnd = new Random();
}
void Update() {
// on génére aléatoirement un nombre qui définira une direction
// on ne génère le nombre qu'une fois toute les 200 frames pour éviter d'avoir un lapin sous extasie
if (frames % 200 == 0) {
int move = rnd.Next(5);
}
if (move ==0) { myLapin.moveLeft() }
if (move ==1) { myLapin.moveRight() }
if (move ==2) { myLapin.moveForward() }
if (move ==3) { myLapin.moveBackward() }
if (move ==4) {//le lapin reste sur place) }
}
}
Tu px ensuite faire d'autre IA en suivant la meme structure.
Code : Tout sélectionner
public class IALapinSuicidaire : Monobehaviour {
// on récupère la référence du lapin
Lapin myLapin = gameObject.GetComponent<Lapin>();
void Start() {
}
void Update() {
Debug.log("This world is too rude for little Rabbit");
Destroy(this.gameObject);
}
}
Et la je me dis "Mince, je voulais aussi des canards avec le même comportement mais j'ai la flemme de réécrire tout le code et de l'adapter pour mes canards !"
Du coup je rajoute une interface IAnimal
Code : Tout sélectionner
public interface Animal {
// quel que soit l'animal, il devra pouvoir aller en avant, en arrière, a gauche et a droite
// une méthode pour se deplacer à gauche
public void moveLeft();
// une méthode pour se déplacer à droite
public void moveRight();
// une méthode pour se déplacer en avant
public void moveForward();
// une méthode pour se déplacer en arrière
public void moveBackward();
}
On ne fait que définir les déplacements, il faudra plus tard, pour chaque animal, coder la façon de se déplacer.
Code : Tout sélectionner
public class Lapin : Animal {
// une méthode pour se deplacer à gauche
public void moveLeft() {
transform.Translate(Vector3.right * Time.deltaTime * -1)
}
// une méthode pour se déplacer à droite
public void moveRight() {
transform.Translate(Vector3.right * Time.deltaTime)
}
// une méthode pour se déplacer en avant
public void moveForward() {
transform.Translate(Vector3.forward * Time.deltaTime)
}
// une méthode pour se déplacer en arrière
public void moveBackward() {
transform.Translate(Vector3.forward * Time.deltaTime * -1)
}
}
Code : Tout sélectionner
public class Canard: Animal {
// mon canard sera 2 fois moins rapide que le lapin, j'ajoute un paramètre de 0.5 pour chacun des déplacements.
// une méthode pour se deplacer à gauche
public void moveLeft() {
transform.Translate(Vector3.right * Time.deltaTime * -0.5)
}
// une méthode pour se déplacer à droite
public void moveRight() {
transform.Translate(Vector3.right * Time.deltaTime * 0.5)
}
// une méthode pour se déplacer en avant
public void moveForward() {
transform.Translate(Vector3.forward * Time.deltaTime * 0.5)
}
// une méthode pour se déplacer en arrière
public void moveBackward() {
transform.Translate(Vector3.forward * Time.deltaTime * -0.5)
}
Et mnt on modifie un chouillat les classes IA pour qu'elles acceptent n'importe quel animal
Code : Tout sélectionner
public class IAPassif : Monobehaviour {
// on récupère la référence de l'animal
IAnimal myAnimal= gameObject.GetComponent<IAnimal>();
void Start() {
}
void Update() {
// on génére aléatoirement un nombre qui définira une direction
// on ne génère le nombre qu'une fois toute les 200 frames pour éviter d'avoir un lapin sous extasie
Random rnd = new Random();
if (frames % 200 == 0) {
int move = rnd.Next(5);
}
if (move ==0) { myAnimal.moveLeft() }
if (move ==1) { myAnimal.moveRight() }
if (move ==2) { myAnimal.moveForward() }
if (move ==3) { myAnimal.moveBackward() }
if (move ==4) {//l'animal reste sur place) }
}
}
Ma classe IA peut a présent contrôler des canards, des lapins, des poulets, des chats, n'importe quoi qui implémente l'interface animal. C'est la polymorphie
“La théorie, c'est quand on sait tout et que rien ne fonctionne. La pratique, c'est quand tout fonctionne et que personne ne sait pourquoi. Ici, nous avons réuni théorie et pratique : Rien ne fonctionne... et personne ne sait pourquoi !”
