Leaderboard

Maintenant que l'on peut appliquer une force, il faut pouvoir la rattacher à un corps . On peut distinguer, là encore, deux types de corps : les dynamiques et les statiques. Les corps dynamiques seront les seuls qu'il est possible de bouger via des forces, les statiques seront considérés comme des élément du décors, il seront tout le temps immobiles (sauf si vous modifier leur position manuellement bien sur). Ainsi, les personnages, les caisses... seront dynamiques, et les élément du décors seront statiques. Voici donc la structure d'un corps : typedef struct s_body { char dynamic; float weight; t_collision_box box; t_force_container force; struct s_body *next; }t_body; Le poids (weight) sert à savoir à quel point l'objet sera dur a bouger. Ainsi, un objet de 40 kg sera deux fois plus facile à bouger qu'un objet de 80 kg. il faudra donc deux fois moins de force. Et voici donc l'unité des forces : Mètre par secondes par kilogrammes. (40 de force pour bouger un corps de 40 kg à 1m/s) la collision box, servira plus tard pour déterminer les collisions entre les corps, et le tout en liste chainnée, afin de pouvoir les stoker facilement dans une structure world : typedef struct s_physic_world { t_body *static_body; t_body *dynamic_body; }t_physic_world; Il faut faire la différence entre les corps afin d'éviter de faire des tests qui ne servent à rien (par définition, deux corps statiques ne sont jamais en collisions) Tout d'abord, la fonction de création de corps : t_body *create_static_body(float x, float y, float w, float h) { t_body *body = malloc(sizeof(*body)); if (body != NULL) { body->box.x = x; body->box.y = y; body->box.w = w / 2; body->box.h = h / 2; body->dynamic = 0; body->weight = 1; body->force.permanent_force = NULL; set_contact_force(&(body->force), 0, 0); body->force.total_force.x = 0; body->force.total_force.y = 0; body->next = NULL; } return (body); } t_body *create_dynamic_body(float x, float y, float w, float h) { t_body *body = malloc(sizeof(*body)); if (body != NULL) { body->box.x = x; body->box.y = y; body->box.w = w / 2; body->box.h = h / 2; body->dynamic = 1; body->weight = 1; body->force.permanent_force = NULL; set_contact_force(&(body->force), 0, 0); body->force.total_force.x = 0; body->force.total_force.y = 0; body->next = NULL; } return (body); } les deux fonctions sont strictement les mêmes, sauf une initialisation d'une variable. Vous pouvez facilement réunir le tout en une fonction, mais j'ai garder cette présentation car plus claire à utiliser. La fonction retourne un pointeur sur la structure afin de pouvoir la modifier et de l'ajouter à la structure physic_world (la fonction va venir, ne vous inquiétez pas). Il faut initialiser toutes les forces à 0, ont met le poids à 1 par défaut (ne jamais mettre le poids à 0, sinon il va y avoir un problème de division par 0) Il faut aussi savoir que pour déterminer les collisions, on à besoin du centre du corps, pas un de ces coins. On à aussi besoin que de la moitié de la hauteur et de la largeur, mais la conversion est faites dans la fonction, pour plus de simplicité. Et surtout pour ceux qui veulent la structure collision box : typedef struct s_collision_box { float x; float y; float w; float h; }t_collision_box; il faut maintenant aussi, pouvoir détruire une entité : void delete_body(t_body *body) { if (body != NULL) { t_force *remove = body->force.permanent_force; while (remove != NULL) { body->force.permanent_force = remove->next; free(remove); remove = body->force.permanent_force; } free(body); } } On doit enlever toutes les forces permanentes afin d'éviter les fuites de mémoires ! De plus, l'objet doit aussi avoir le poids que vous voulez : void add_weight(t_body *body, float weight) { if (body != NULL) { if (weight <= 0) { weight = 1; } body->weight = weight; } } Mais ce n'est pas finit ! Il faut aussi pouvoir ajouter le corps à la structure world. La fonction pour mettre a jour tout les corps ne va pas attendre qu'on lui passe tout les objets 1 par 1 ! Cela possède plusieurs avantages : On n'envoie qu'une grande structure au lieu de plein de petites, et vous pourrez bénéficier de la détection de collisions sans que l'objet soit présent physiquement : cela permet de faire des capteurs, de savoir si on est dans de l'eau sans autant repousser le personnage etc... Bref suit les fonctions d'initialisation, de suppression du monde physique et d'ajout de corps, rien de bien complexe, presque un copier coller des forces : t_physic_world *create_physic_world() { t_physic_world *world = malloc(sizeof(*world)); if (world != NULL) { world->static_body = NULL; world->dynamic_body = NULL; } return (world); } void delete_physic_world(t_physic_world *world) { if (world != NULL) { t_body *remove = world->static_body; while (remove != NULL) { world->static_body = remove->next; delete_body(remove); remove = world->static_body; } remove = world->dynamic_body; while (remove != NULL) { world->dynamic_body = remove->next; delete_body(remove); remove = world->dynamic_body; } free(world); } } char add_to_physic_world(t_physic_world *world, t_body *body) { if (world != NULL && body != NULL) { if (body->dynamic) { body->next = world->dynamic_body; world->dynamic_body = body; } else { body->next = world->static_body; world->static_body = body; } return (1); } else { return (0); } } Les corps sont encore empilés, car c'est toujours plus simple à faire Et maintenant, on peut mettre a jour touts les corps : void update_physic_world(t_physic_world *world, int millisecond_time) { t_body *update = world->dynamic_body; while (update != NULL) { update_force(update, millisecond_time); update = update->next; } } void update_force(t_body *body, int millisecond_time) { calc_total_force(&(body->force)); body->force.total_force.x *= (millisecond_time / 1000.0) / body->weight; body->force.total_force.y *= (millisecond_time / 1000.0) / body->weight; body->box.x += body->force.total_force.x; body->box.y += body->force.total_force.y; set_contact_force(&(body->force), 0, 0); } Je vous rappelle que seuls les corps dynamiques peuvent être en mouvement, donc il n'y a pas de raison de mettre a jours les corps statiques. La fonction attend un temps en millisecondes car la SDL utilise cette unité, mais vous pouvez changer l'unité de temps, il faudra juste adapter en conséquence. Mais vous avez sûrement remarquer la présence de la structure force_container, même chez les corps statiques, alors pourquoi ne pas l'enlever chez eux ? Tous simplement parce que sinon on doit dupliquer le code en deux : corps statiques et corps dynamiques, que c'est plus complexe à faire, que les risque de bug sont multiplier par deux, et surtout ça empêche le méga truc de la mort qui tue, mais que vous ne saurez pas dans ce tutos. Les forces de contacts sont remisent à 0 a chaque fois car on les recréer aussi à chaque fois. Et voilà, vous pouvez bouger vos personnages comme vous voulez, mais il n'y a toujours pas de collisions !

Je vais faire dans cette série de tutoriels, une construction suivit d'un moteur physique. Tout d'abord : Qu'est ce qu'un moteur physique ? Un moteur physique, est un programme qui permet de gerer la physique correctement, et qui déplace les personnages, tout en gérant les collisions. (tout les problèmes de collisions d'un jeu viennent du moteur physique). Ce qu'il faut savoir avant de commencer à le faire : Le moteur physique, que je vais vous apprendre à faire, ne gérera que des rectangles, il est donc parfait pour les jeux de plate-formes, de type mario, mais aussi d'autre styles de jeu avec que des blocs (les jeux en tiles quoi) comme zelda. Et oui le moteur ne sera qu'en 2d ! De plus, le principe majeur d'un moteur physique est la réutilisabilité de celui-ci, ce qui veut dire pas de : IF MUR THEN ... L'architecture que nous allons utilisé est celle dite "à posteriori" : -première étape, on génère des forces, comme la gravité, les forces de mouvement... -deuxième étape, on applique ces forces. -troisième étape, on détecte les collisions. -dernière étape, on les corrige. L'autre architecture, aussi appelé "à priori", utilise des matrices de résolution, afin de détecter l'instant exact de la collision. Cette architecture est plus précise, mais elle est aussi beaucoup plus lente, c'est pourquoi AUCUN moteur physique de jeu vidéo ne l'utilise, l'architecture "à posteriori" offrant des résultats satisfaisants. (Ce n'est qu'en cas extrêmes que l'ont remarque des problèmes, mais on ne les vois pas souvent). Et on va donc commencer par créer un générateur de force, et qui va les stoker dans une structure, afin de les garder en mémoire. (On attachera ensuite cette structure à un corps, afin de le déplacer) typedef struct s_force_container { t_force *permanent_force; t_force contact_force; t_force total_force; }t_force_container; Tout d'abord, j'ai distingué deux type de forces : les permanentes (la gravité, les mouvements...), et les forces de contact. celle là seront régénérées à chaque fois que le moteur se mettra à jour, donc on ne va pas créer de listes chaînées pour ça, car le risque qu'un malloc échoue devient très vite important, donc on va uniquement se contenter d'additionner les valeurs entre elles. Les forces permanentes, elles, seront stockées dans la liste chaînées, afin de pouvoir en modifier une sans impacter les autres. La force total_force, elle sert uniquement a connaître le total des forces permanentes et de contact, afin de bouger le corps en conséquences. Les forces sont représentées par la structure suivantes : typedef struct s_force { float x; float y; struct s_force *next; }t_force; Les forces en x représente normalement l'axe horizontal et l'axe x, vertical. Il n'y a pas de sens ou de direction pour les axes, vous pouvez prendre celui que vous voulez, il faudra juste adapter les forces en conséquence. il nous faut maintenant une fonction afin d'ajouter ou d'enlever une force permanente. La fonction d'ajout : t_force *create_permanent_force(t_force_container *container, float x, float y) { t_force *add = malloc(sizeof(*add)); if (add != NULL) { add->x = x; add->y = y; add->next = container->permanent_force; container->permanent_force = add; } return (add); } la fonction retourne un pointeur vers la force, afin de la modifier quand vous voulez. Les forces sont empiler les une à la suite des autres (l'ordre d'empilage n'a absolument aucune importance, c'est juste plus simple à programmer ) Et maintenant la fonction "d'enlevage" : void delete_permanent_force(t_force_container *container, t_force *remove) { if (container != NULL) { if (container->permanent_force != NULL) { t_force *search = container->permanent_force; char finish = 0; if (search == remove) { container->permanent_force = remove->next; free(remove); finish = 1; } while (search->next != NULL && !finish) { if (search->next == remove) { search->next = search->next->next; free(remove); finish = 1; } } } } } Le seul truc dur a faire ici, c'est de penser a enlever la force, tout ne perdant aucun pointeur vers les prochaines forces, tout en ne faisant pas de segfault. On s’occupe maintenant des forces de contact, les plus faciles . pour en ajouter : void add_contact_force(t_force_container *container, float x, float y) { if (container != NULL) { container->contact_force.x += x; container->contact_force.y += y; } } il n'y a pas de fonction pour retirer une force, car pour retirer les forces directement additionner, il suffit juste d'ajouter son contraire. Mais en revanche, il faut une fonction pour remettre à un certain nombre cette force, car je vous rappelle, il faut réinitialiser les forces de contacts a chaque mise à jour (bah oui sinon vous imaginez, il faudrait retenir a cause de quoi cette force de contact a été créer, vérifier si elle a toujours raison d’exister, le tout avec beaucoup de corps en mouvement, et le moteur va ramer très vite. Bref la fonction : void set_contact_force(t_force_container *container, float x, float y) { if (container != NULL) { container->contact_force.x = x; container->contact_force.y = y; } } Toujours aussi simple, normalement pas de difficulté a comprendre . Et enfin, il nous reste une dernière fonction a voir : celle qui calcule la somme de toutes les forces, afin de savoir la force finale pour bouger le corps. Elle parcours la liste chaînées des forces permanentes, les additionnent, puis ajoute les forces de contacts et met le résultat dans total_force : void calc_total_force(t_force_container *container) { if (container != NULL) { float x = 0; float y = 0; t_force *force = container->permanent_force; while (force != NULL) { x += force->x; y += force->y; force = force->next; } x += container->contact_force.x; y += container->contact_force.y; container->total_force.x = x; container->total_force.y = y; } } Et voilà ! on peut maintenant ajouter ou enlever facilement des forces, permanentes où de contact. Évidement, le code comme cela ne sert absolument a rien, il faut ajouter la notion de corps pour comprendre à quoi cela va servir.