C

Formation Vidéo le projet de Jason Champagne

Madzcore — Tue, 26 Dec 2017 17:27:16 GMT

PRESENTATION DE LA FORMATION

La formation en langage C, est une formation d'un langage de programmation nommé le C, cette formation est entièrement gratuite, fait par un "amis" a moi, qui est un couteaux suisse dans le domaine de l'informatique, la formation abordera tout les sujet ou presque tout elle est vaste voici une petite liste de ce qui s'aura appris .

Les base du langage
Les structure de données :
La SDL 2.0
La programmation système
Le réseaux

Tout ceci entièrement gratuit, et accessible a tous jeune est moins jeune . Bien sur des complément de cours seront aussi posté et sera mis a jour .

QUI EST VOTRE FORMATEUR

Il s'appelle Jason Champagne c'est formation son gratuites en ligne sur YouTube les formation sont vaste encore une fois, Programmation Informatique avec les langage C, python, C++, java qui a promis de faire, bien sur le développement web n'est pas laisser de coter les langage abordé seront PHP, HTML et CSS et JavaScript et dans un futur ruby etc... ;

Il n' y a aussi le hacking éthique qui est abordé, mais comme je l'est dit les formation sont vaste, il y' a commencer une formation en Japonais, pour les amateur de manga vous voilla content j'imagine, mais pas que de dessins, de Français oui de Français, de musique il fait aussi des reprise de chant clic ici pour allez voir ;

Les moteur de jeu aussi seront abordé dans un futur, unity, unreal engine notamment .

OU REGARDER LES FORMATION PROPOSE

Et bien sur YouTube les formation sont comme déjà dit gratuite, accessible pour tout le monde .

Voici la chaine qui se nomment Formation Vidéo , il faut allez voir dans la playlist tout les vidéo sont bien rangé par thème.

INTRODUCTION

Langage C #1 - introduction

Description :

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
● SITE PERSO : https://jasonchampagne.fr
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

► Première séance sur le langage C.
Faisons ensemble une petite présentation du langage, de son histoire, et ce à quoi il peut vous servir.

██▄
Je n'utilise plus Skype, vous pouvez à la place utiliser Discord et m'ajouter en ami sur ce logiciel (tutoriel ici : https://goo.gl/qXADCa).
Pour me contacter en privé, utilisez donc de préférence Discord (si vous n'aimez pas les réseaux sociaux), sinon vous pouvez me retrouver sur Twitter, Facebook, Google+ et directement par e-mail.
██▄

MERCI DE VOTRE FIDÉLITÉ (◕_◕) !

Révélation

ABONNEZ VOUS SVP POUR QUE LA CHAINE SOIT CONNUES !

Catégorie

Science et technologie

Licence

Licence YouTube standard

[console/c] Todolist

Alemort — Mon, 07 Mar 2016 06:24:42 GMT

Bonjour, j'ai réalisé un petit projet qui a pour objectif de permettre à quelqu'un de réaliser une todolist.

Le lien de l'exécutable : todolist.tar.gz

Avec ce petit soft en console, vous pouvez :

*créer une todolist

*visualiser votre todolist

*supprimer votre todolist

*modifier votre todo list, en passant l'état de la tâche de 0 à 1, vous indiquez que vous avez finis cette tache.

A vous de tester :), le logiciel devrait être portable logiquement!

Execution : ./agenda

déclaration de structure dans un appel de fonction

cegdd — Wed, 21 Jan 2015 22:01:48 GMT

hey tout le monde !!!

petite question:

est-il possible en C, de déclaré et d'initialiser a la volée une structure dans un appel de fonction ?

exemple:

DrawText(SDL_Rect{500; 500; 500; 500}, score, BLANC, systeme);

je suis presque sûr que oui, mais je dois mal m'y prendre ^^

[Question] Un FILE* en argument de fonction

nell — Sat, 10 Jan 2015 21:16:32 GMT

Hey, je commence un projet en C et j'ai un problème avec une fonction

Je résume rapidement la fonction:

Un fichier texte est composé de plusieurs lignes, chaque ligne contient 3 chiffres, une coordonnnée x, une coordonnée y et une valeur à mettre à ces coordonnées dans la grille. La fonction remplie d'abord la grille avec des 0, puis récupères les valeurs du fichiers pour les insérer dans la grille aux bonnes coordonnées.

Ma fonction ne marche pas et fait planter le programme et j'ai vraiment du mal à la corriger, vous auriez une solution? (J'ai des doutes sur la syntaxe des arguments de la fonction...)

void lire_Grille(FILE* nomFichier[400],int grille[][9])
{
    int i, j;
    for (i=0; i<9;i++)
    {
        for (j=0;j<9;j++)
        {
            grille[i][j]=0;
        };
 
    };
    i = fgetc(nomFichier);
    do
    {
        j = fgetc(nomFichier);
        grille[i][j] = fgetc(nomFichier);
        k = fgetc(nomFichier);
        while (k==" " || k=="\n")
        {
            k=fgetc(nomFichier);
        };
        i = k;
    } while (i!=EOF);
}

[Cours] La programmation réseau

AlexMog — Tue, 28 Oct 2014 14:03:57 GMT

Bonjour à tous,

C'est un sujet aussi intéressent que difficile que nous allons voir aujourd'hui: Le réseau.

Nous allons découvrir le réseau de manière théorique et pratique, via ce cours.

Nous allons voir tout ça via diverses parties. Tenez-vous bien, après la gestion mémoire, le réseau est la deuxième plus grosse difficulté au niveau de la programmation (ce qui le rends très intéressent!), ce sera un cours principalement théorique (oui, je sais, j'en fais très TRES rarement), et du coup, vous y verrez que très peu de code.

Index:

1- Le réseau, en théorie, c'est quoi?

2- En pratique?

3- Différence entre TCP, UDP et UDT (oui oui, ça existe).

4- Quel type de données on peux envoyer en réseau?

5- Synchrone? Asynchrone? Kesako?

6- Un serveur de tchat synchrone (théorique).

7- Notre tchat en version Asynchrone (théorique).

8- Index des fonctions utiles en C (RTFM ).

1- Le réseau, en théorie, c'est quoi?

Le réseau définit un moyen pour deux programmes de pouvoir communiquer. Il existe deux définitions du réseau existantes: LAN et INET. De manière générale, le réseau LAN représente le réseau local (nous ne parlerons pas des réseaux VPN qui sont des exceptions à ce niveau là, puisqu'elles créent un réseau LAN virtuel), et les réseaux dis INET représentent les réseaux passant par internet. WOUHOUUUU!

La partie théorique a l'aire plutôt bien simple! MAIS, et c'est là que le réseau deviens très cool à connaitre, c'est ULTRA-COMPLEXE à comprendre et en même temps pas si compliqué à mettre en place. Je vais donc essayer de ne pas vous perdre durant ce cours.

2- En pratique?

Eh oui, la description ci-dessus simplifie pas mal le fonctionnement du réseau au final. Si nous voulons mettre les mains dans le cambouis, il faut savoir pas mal de choses sur le réseau (bien que pas très importantes dans la programmation en elle même, ça vous permettra au moins de comprendre comment fonctionne le réseau de l’intérieur.

Il faut savoir que la couche réseau est la 3ième couche du modèle OSI voyons un peu, pour avoir de la culture info, les 7 couches du modèle OSI:

1- Physique (Le matériel de liaison, carte wifi, blutooth, etc...)

2- Liaison (Gestion de la liaison et de la communication)

3- Réseau (Gestion des couches réseau, IPv4, IPv6, etc...)

4- Transport (Gère la communication en bout des processus, UDP, TCP, etc...)

5- Session (Gère la synchronisation des communications et la gestion des "transactions")

6- Présentation (Code les données applicatives)

7- Application (Définit les points d'accès au service, Nous sommes ICI!)

(je vous conseille de jeter un petit coup d’œil sur Wiki, c'est toujours un plus de savoir ce genre de choses , pour vous donner une idée, nous les apprenons par cœur à Epitech (3ième année))

La couche applicative est celle ou nous sommes lorsque nous développons un programme. Toutes les autres couches sont gérées par notre OS, qui fait tout le travail à notre place!

Enfin, il faut retenir une chose TRES importante, et qui va beaucoup vous aider: les SOCKETS (système qui permet la communication en réseau) sont des FDs (File descriptors), il sera donc géré comme un fichier, et il faudra toujours penser à FERMER LES SOCKETS! (laisser des FDs ouverts, c'moche! Pauvre kernel )

3- Différence entre TCP, UDP et UDT (oui oui, ça existe).

Ahhh, les protocoles de communication réseau (à ne pas confondre avec les protocoles applicatifs), beaucoup de choix, avec beaucoup de différences.

Nous allons voir ça tout de suite:

1- Le TCP

Le protocole TCP est actuellement le plus stable et certainement le plus utilisé dans le domaine applicatif (ATTENTION: pas dans le jeu-vidéo). Le TCP comporte 3 grand principes:

- Les packets sont certains d'arriver.

- Les packets arrivent dans l'ordre.

- On a une réponse de la réception du packet par le client.

Et tout ça, grâce à un header implémenté dans le packet (oui, le packet est un peu plus lourd). Pour résumer, voici ce qui se passe lorsque vous envoyez un packet TCP:

serveur = Envois du packet => client

client = J'ai bien reçu le packet! => serveur

serveur = Ok merci, j'ai bien reçu la réponse! => client

Nous voyons donc qu'il y a 3 envois réseau pour chaque packets, ce qui peux ralentir le réseau pour tout ce qui est temps-réel. ATTENTION NEANMOINS, au vue des connexions internet de nos jours, la différence ne se fait pratiquement pas ressentir.

Néanmoins, dans la plupart des jeux, le TCP permet de faire les actions importantes (envois de sorts, pop de monstres, etc...) et l'UDP permet de gérer les actions moins importantes (Déplacements, etc...) pour éviter de surcharger la couche réseau. Même si certains jeux nous montrent bien que le Full TCP, ça peux marcher aussi (RPZ World Of Warcraft).

2- L'UDP

L'UDP de manière générale est plus simple, c'est un simple envois de packet ANONYME à un serveur.

Cela offre une vitesse 3 fois plus rapide que le TCP mais néanmoins, on ne sais absolument pas sur le packet est bien arrivé au destinataire.

Il faut donc apprendre à manier le TCP aussi bien que l'UDP en fonction de ce qu'on veux faire.

2- L'UDT

Le cas de l'UDT est totalement différent, car c'est un protocole plutôt jeune qui a été créé pour pouvoir transporter un grand nombre de données (on parle ici de Téraoctets) sur un réseau généralement LAN.

Nous n'allons pas en parler ici, mais si vous souhaiter vous renseigner dessus, je vous conseille Wikipedia .

4- Quel type de données on peux envoyer en réseau?

Là est la question. Pour faire simple, qu'est-ce qui passe par du réseau, en soite? Eh bien, des données en BINAIRE! Eh oui, c'est des 1 et des 0 qui passent dans nos câbles! On s'y attendais pas, hein? Pour résumer, tant que les données peuvent être stockées en mémoire (soite presque toutes), il est possible de les envoyer en réseau (eh oui, c'est pour ça que le réseau est considéré très proche de la gestion mémoire ). D'une manière générale, faut pas faire l'imbécile, n'envoyez pas des pointeurs en réseau, puisque l'autre machine, n'aura pas allouée ce pointeur . Il faut envoyer des données dites "flat", donc des données et non pas des adresses!

Ce qui est très souvent fait, c'est d'envoyer des structures en réseau. ça permet pas mal de chose, mais c'est très peu modulable.

Une autre technique, c'est de créer un packet.

Voici un exemple du contenu d'un packet:

| taille des données dans le packet (4 octets) | données du packet.... |

du coup, lorsqu'on reçois ce packet, on lit d'abord les 4 premiers octets pour savoir quelle est la taille du packet complet, et on lit le packet .

Bref, de la théorie tout ça! On verra dans un autre cours sur le réseau du code à proprement parlé!

5- Synchrone? Asynchrone? Kesako?

Le principe de l'Asynchrone et du Synchrone se retrouve souvent dans les applications ayant plusieurs threads (sous processus).

Le principe du Synchrone, c'est d'avoir un thread qui exécute tout de manière Linéaire.

Le principe de l'Asynchrone, c'est d'avoir plusieurs threads, ayant chacun un rôle et communicant entre eux.

Dans notre cas, le Synchrone en réseau est nommé bloquant alors que l'Asynchrone est nommé non bloquant.

Pour faire simple, dans un réseau bloquant, nous attendrons que le client ait bien reçu les informations, alors que dans l'autre cas, nous envoyons les informations en NOWAIT (voir les mans des sockets) et du coup, nous n'attendons pas la réponse TCP. Ce qui nous renvois la taille des données envoyées, et dans le cas ou des données n'ont pas été envoyées, on les renvois.

D'une manière générale, le côté bloquant est utilisé dans les clients, alors que le côté non bloquant est utilisé pour les serveurs (eh oui jamie! Si on est bloquant et qu'un client lag, on fait laguer tout le monde! Exemple concret: Starcraft II, mais là encore l'exemple est spécial, puisque SCII, c'est du P2P via servering).

Pour l'UDP, il n'est pas question d'être bloquant, puisque nous ne savons pas quand le client reçoit l'information.

6- Un serveur de tchat synchrone (théorique).

A VENIR.

7- Notre tchat en version Asynchrone (théorique).

A VENIR.

8- Index des fonctions utiles en C (RTFM ).

- man 2 socket

- man 2 select (une de mes fonctions préférées en C <3)

A bientôt pour un prochain cours!

AlexMog.

Moteur physique #3

daemondragon — Sat, 06 Sep 2014 09:10:39 GMT

Et voila la fin de la création d'un moteur physique !
Il ne nous restent plus qu'a détecter les collisions et les corriger, et le moteur est finit. :lol: :lol:

Détection des collisions :

La théorie :

Pour que deux rectangles soit en collisions, il faut qu'ils se "rentrent" dedans.
Pour cela, la distance (sur un seul axe pour l'instant) entre les deux points doit être inférieur
à la somme de la moitié de leur largueur (dans le cas de l'axe x, la hauteur pour l'axe y).
C'est pour cela que dans le précédent tuto (/topic/1043-moteur-physique-2/?do=embed&embedDo=findComment%3Fcomment%3D11169%2C" data-embedcontent="" frameborder="0" src="//melinyel.net/applications/core/interface/js/spacer.png"> lors de la création de corps, on ne gardait que la moitié de la largueur et de la hauteur.
Ont peut ainsi tester chaque axe pour voir s'il y a une collision sur celui-ci.
S'il n'y a une collision que sur un seul axe, alors l'objet n'est pas en collision avec l'autre, il est simplement à coté.

Une magnifique image qui résume cela :

/applications/sslimageproxy/interface/image.php?url=http://www.turboconnard.com/b/wp-content/uploads/2010/11/carre.png"/>

La pratique :

En code, on teste chaque axe l'un après l'autre. Si sur le premier axe il n'y a pas de collision, alors on a pas besoin de tester le deuxième.

float mlb_abs(float number)
{
if (number < 0)
{
number *= -1;
}
return (number);
}
float penetration_x(t_body *f_body, t_body *s_body)
{
return (mlb_abs(f_body->box.x - s_body->box.x) - (f_body->box.w + s_body->box.w));
}
float penetration_y(t_body *f_body, t_body *s_body)
{
return (mlb_abs(f_body->box.y - s_body->box.y) - (f_body->box.h + s_body->box.h));
}
char is_collide(t_body *f_body, t_body *s_body)
{
if (penetration_x(f_body, s_body) <= 0.
&& penetration_y(f_body, s_body) <= 0.)
{
return (1);
}
return (0);
}

La fonction mlb_abs est strictement équivalente a abs() de math.h, mais à chaque fois que le moteur serait inclus dans un projet, il faudrait linker la biblio, et c'est pas pratique, donc créer la fonction est pour moi plus simple. Vous pouvez évidement la remplacer par celle de math.h si cela vous arrange.
On calcule donc les collisions sur chaque axe, et la fonction renvoie 1 en cas de collision.

Correction des collisions :

Il faut tester tout les corps entre eux pour savoir s'il y a une collision. Je vous rappelle que deux corps statiques ne seront jamais en collisions, donc on ne vas pas les tester entre eux.

void check_collision(t_physic_world *world)
{
t_body *update = world->dynamic_body;
t_body *collide_with = world->static_body;;
update = world->dynamic_body;
while (update != NULL)
{
/collide with static body/
while (collide_with != NULL)
{
if (is_collide(update, collide_with))
{
correct_collision(update, collide_with);
}
collide_with = collide_with->next;
}
/collide with dynamic body/
collide_with = update->next;
while (collide_with != NULL)
{
if (is_collide(update, collide_with))
{
correct_collision(update, collide_with);
}
collide_with = collide_with->next;
}
    update = update->next;
}

}

On teste d'abord les collisions avec les corps statiques, car cela permet d'éviter que le corps soit repoussé a travers un mur s'il est poussé par un corps dynamique, ce qu'il ne faut surtout pas.

Et maintenant, il faut pouvoir corriger ces collisions une fois quelle sont détectées !
Tout d'abord, les corrections ne seront pas les mêmes en cas de collisions dynamique / statique que des collisions dynamique / dynamique.
Les première collisions pousseront le corps dynamique hors du corps statique alors que les deuxième collisions, les deux corps se pousseront mutuellement, et celui avec la plus grande force l'emportera.
Il faut d'abord dispatcher les corps dans les bonnes collisions :

void correct_collision(t_body *f_body, t_body *s_body)
{
if (f_body->dynamic && !s_body->dynamic)
{
correct_static_collision(s_body, f_body);
}
else if (!f_body->dynamic && s_body->dynamic)
{
correct_static_collision(f_body, s_body);
}
else if (f_body->dynamic && s_body->dynamic)
{
correct_dynamic_collision(f_body, s_body);
}
}

Normalement, les collisions entre corps statique et dynamique se font dans cette ordre dans la fonction, mais cela permet de tester les collisions entre un corps qui n'appartient pas a la structure physic_world avec ce que vous voulez, sans vous souciez de l'ordre dans lequel les corps doivent être mis.
On va commencer avec les collisions avec des corps statiques :

void correct_static_collision(t_body *static_body, t_body *dynamic_body)
{
if (penetration_x(static_body, dynamic_body) > penetration_y(static_body, dynamic_body))
{
/x axis penetration/
float direction = dynamic_body->force.total_force.x / mlb_abs(dynamic_body->force.total_force.x);
dynamic_body->box.x = static_body->box.x - (dynamic_body->box.w + static_body->box.w) * direction;
    add_contact_force(&(dynamic_body->force), -dynamic_body->force.total_force.x, static_body->force.contact_force.y);
}
else
{
    /*y axis penetration*/
    float direction = dynamic_body->force.total_force.y / mlb_abs(dynamic_body->force.total_force.y);
    dynamic_body->box.y = static_body->box.y - ((dynamic_body->box.h + static_body->box.h) * direction);

    add_contact_force(&(dynamic_body->force), static_body->force.contact_force.x, -dynamic_body->force.total_force.y);
}

}

On corrige la collision en fonction de l'axe ou le corps est le moins en collision, afin de ne pas voir un corps se faire repousser violemment alors que l'on peut faire une chose moins visible.
La fonction est simple : 1ere ligne ont calcule la direction de la collision, deuxième ligne, on la corrige, et troisième ligne, on met la force contraire de l'axe ou il y a eut la collisions dans le corps dynamique afin de l’empêcher de passer a travers. Mais pourquoi le faire, si on corrige simplement, il ne passera pas non plus non ?
Ce qu'il faut savoir, c'est que le moteur physique ne peut pas être sur qu'il va être appelé suffisamment pour éviter l’effet "tunnel", le corps passe alors a travers alors qu'il aurait du y avoir une collisions. Si l'ont ajoute une force contraire mais de contact, elle ne disparaîtra que lorsque le moteur physique sera remis a jour, donc on pourra alors recorriger la collision.

De plus on peut voir que dans l'axe ou il n'y a pas de colliisons, on rajoute un force. Mais qu'est ce que c'est ?
C'est le méga truc de la mort qui tue du deuxième tuto ! Grâce a cela, on peut rajouter facilement des tapis roulant et des plate-formes mobiles, alors que sinon, dans les autres moteurs physique, ont doit tricher en rajoutant une force lorsque le personnage se trouve sur celui-ci.
Evidemment, la force de contact n'est là que si vous l'ajouter, elle est de base à 0.

Et maintenant, la correction la plus difficile : les collisions dynamiques / dynamiques dont voici la fonction :

void correct_dynamic_collision(t_body *f_body, t_body *s_body)
{
t_force common_force;
t_force total_force;
float weight;
if (penetration_x(f_body, s_body) > penetration_y(f_body, s_body))
{
    /*x axis penetration*/
    /*calculate the total force for the total body and divise it*/
    calc_total_force(&(f_body->force));
    calc_total_force(&(s_body->force));
    total_force.x = f_body->force.total_force.x;
    total_force.y = s_body->force.total_force.x;
    
    common_force.x = total_force.x + total_force.y;
    weight = f_body->weight + s_body->weight;
    common_force.y = common_force.x / weight * s_body->weight;
    common_force.x = common_force.x / weight * f_body->weight;
    
    add_contact_force(&(f_body->force), common_force.x - total_force.x, 0);
    add_contact_force(&(s_body->force), common_force.y - total_force.y, 0);

    /*correct collision*/
    float average_x = (f_body->box.y * s_body->weight + s_body->box.y * f_body->weight) / weight;
    float direction = average_x - f_body->box.x;
    if (direction < 0)
    {
        direction = -1;
    }
    else
    {
        direction = 1;
    }
    f_body->box.x = average_x - (f_body->box.w * direction);
    s_body->box.x = average_x + (s_body->box.w * direction);
}
else
{
    /*y axis penetration*/
    /*calculate the total force for the total body and divise it*/
    calc_total_force(&(f_body->force));
    calc_total_force(&(s_body->force));
    total_force.x = f_body->force.total_force.y;
    total_force.y = s_body->force.total_force.y;
    
    common_force.y = total_force.x + total_force.y;
    weight = f_body->weight + s_body->weight;
    common_force.x = common_force.y / weight * f_body->weight;
    common_force.y = common_force.y / weight * s_body->weight;

    add_contact_force(&(f_body->force), 0, common_force.x - total_force.x);
    add_contact_force(&(s_body->force), 0, common_force.y - total_force.y);

    /*correct collision*/
    float average_y = (f_body->box.y * s_body->weight + s_body->box.y * f_body->weight) / weight;
    float direction = average_y - f_body->box.y;
    if (direction < 0)
    {
        direction = -1;
    }
    else
    {
        direction = 1;
    }
    f_body->box.y = average_y - (f_body->box.h * direction);
    s_body->box.y = average_y + (s_body->box.h * direction);
}

}

Les fonctions sont exactement les mêmes sur les deux axes, il n'y a que des ajustement au niveau des axes a faire.
La fonction marche comme cela : elle calcule les forces des deux corps, calcule la moyenne de l'endroit de leur collisions en fonctions de la force de l'autre corps (car plus un corps aura de force, moins il devra être bougé car c'est lui le plus fort).
On transfère les forces dans les deux corps afin qu'ils aient la même vitesse en sortie, le tout dans des forces de contact, cela permet de faire des caisses que l'ont pourra pousser !
Et ont corrige a la fin la collision, et c'est bon.
Malgré que la fonction soit longue, elle reste relativement simple.

Et voila, le moteur physique est fini !
J'espère qu'il vous aura plus, et que vous vous en servirez

Moteur physique #2

daemondragon — Sat, 30 Aug 2014 09:24:43 GMT

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 !

Moteur physique #1

daemondragon — Fri, 29 Aug 2014 08:46:32 GMT

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.

[ALGO] algorithme de collision en fromage

cegdd — Wed, 27 Aug 2014 00:48:24 GMT

bonjour bonjour !

pour /topic/545-reconqu%C3%AAte-salvatrice/,?do=embed" data-embedcontent="" frameborder="0" src="//melinyel.net/applications/core/interface/js/spacer.png"> j'ai codé un petit algorithme qui me permet de tester si notre personnage fait face à une image ou non.

le tout avec une marge dynamique

pour les non-initié à la SDL, la structure SDL_Rect contient les coordonnées : x, y, w et h d'une image.

j'ai crois donc qu'il est important de vous le faire partager

bool colisionfromage(SDL_Rect lanceur, SDL_Rect recepteur, SDL_Rect curseur, double marge)
{
double degre, degre2, diff;
int difx, dify;
difx = (lanceur.x + lanceur.w/2) - (curseur.x + curseur.w/2); //calcul de la difference en pixel
dify = (lanceur.y + lanceur.h/2) - (curseur.y + curseur.h/2); //entre le lanceur et le pointeur de la souris
degre = atan2(dify, difx);//obtention de l'angle en radian

difx = (lanceur.x + lanceur.w/2) - (recepteur.x + recepteur.w/2); //calcul de la difference en pixel entre
dify = (lanceur.y + lanceur.h/2) - (recepteur.y + recepteur.h/2); //le lanceur et l'objectif
degre2 = atan2(dify, difx);//obtention de l'angle en radian

degre  *= 57.296;//conversion en degre
degre2 *= 57.296;

degre   += 180; //ajustement pour passer d'un systeme (-180/180) à un systeme (0/360)
degre2  += 180;

diff = degre-degre2;//calcul de la différence

if (diff < 0) //si diff est négatif, on le passe en positif
{
    diff *= -1;
}

if (diff <= 0 || diff >= marge/2) //si la différence est plus grande que la marge, nous retournons FAUX
{
    return FALSE;
}
return TRUE;

}

si vous avez des questions / remarques, comme d'habitude, je vous écoute !

edit : je sais que ce code a un défaut, le calcul de la différence ne marche pas si l'un est <360 et l'autre >0. mais je ne sais pas comment gérer ça simplement. des idées ?

[TUTO] installation SDL 2.0

cegdd — Wed, 23 Jul 2014 15:05:38 GMT

Salut tout le monde !

en exclusivité pour mes chers Melinyens ... comment installer la bibliothèque SDL2 et ses filles sur code::blocks (windows x32 / x64) !

j'avais dis que je n'expliquerais pas cela pour plusieurs raisons :

je ne suis pas un professionnel des installations de bibliothèques je ne vous garanti donc pas la propreté de l'installation.
il existe déjà des tutoriels qui traitent ce sujet. (et même des templates tout fait sur develloppez.com !)

mais ... je vois beaucoup trop de personnes qui me demandent des conseils là dessus ^_^ donc je me lance !

1) le téléchargement :

pour être complet vous allez avoir besoin des bibliothèque cité ci-dessous :

La SDL : https://www.libsdl.org/download-2.0.php
La SDL_image : https://www.libsdl.org/projects/SDL_image/
La SDL_ttf : https://www.libsdl.org/projects/SDL_ttf/
La SDL_mixer : http://www.libsdl.org/projects/SDL_mixer/

sur chaque pages, vous prendrez ce lien :/applications/sslimageproxy/interface/image.php?url=http://img11.hostingpics.net/pics/185360sdldl.jpg"/>

2) le positionnement des fichiers :

maintenant que vous avez tout téléchargé, vous devriez avoir des fichiers en ".tar.gz", décompressez les avec votre logiciel de compression/décompression habituel.

les dossiers ainsi obtenu devrais ressembler a ça : ouvrez le dossier entouré en rouge./applications/sslimageproxy/interface/image.php?url=http://img11.hostingpics.net/pics/121091files.jpg"/>

ne prenez pas les dossiers en x64 même si votre ordinateur est en x64 !

(bien entendu je m’adresse ici a un public tout aussi amateur que moi. si vous savez ce que vous faites et que votre compilateur est en x64, faites ce qu'il vous plait )

copiez maintenant dans chacune des bibliothèque précédemment téléchargées le dossier "include", "bin" et "lib"

et fusionnez les avec ceux du compilateur que vous devriez trouver à l'emplacement montré ci-dessous :

/applications/sslimageproxy/interface/image.php?url=http://img11.hostingpics.net/pics/253684mingw.jpg"/>

3) la configuration :

et maintenant ... CODE::BLOCKS !!!

créez un nouveau projet vierge "empty project",

puis allez dans :

/applications/sslimageproxy/interface/image.php?url=http://img11.hostingpics.net/pics/696488uicRSinDEVCodeBlocks1312.jpg"/>

vous devriez avoir cette fenêtre ----------------------------------|

assurez vous d'être bien dans la racine ici ! | |

v----------------------------------------------------- v

/applications/sslimageproxy/interface/image.php?url=http://img11.hostingpics.net/pics/192892kijhg.jpg"/>

vous devez maintenant en premier, cliquer sur "add" et écrire "mingw32",

puis parcourir vos fichiers pour lui indiquer tout les fichiers ".a" que vous voyez ci-dessus. Dans le même ordre !

mais ce n'est pas fini !

vous devez ensuite ajouter les dossiers "lib" et "include" de votre compilateur, comme montré ci-dessous !

/applications/sslimageproxy/interface/image.php?url=http://img11.hostingpics.net/pics/351599jyhgt.jpg"/>

et enfin :

/applications/sslimageproxy/interface/image.php?url=http://img11.hostingpics.net/pics/551051PrtScrcapture.jpg"/>

TADAM ! ! !

votre projet est maintenant configuré ! :wub:

il reste cependant un toouuuuuuut petit détail, :rolleyes:

pour pouvoir lancer votre ".exe", vous devez copier à coté du .exe toutes les ".dll" que vous trouverez dans le dossier "bin" de chaque bibliothèque ajoutée.

et voila !

n'hésitez pas à poser des questions ou à me dire si vous trouvez une erreur.

pour essayer la configuration, je vous invite à lire le premier tutoriel sur la SDL2 /topic/595-tuto-sdl-20/?do=embed" data-embedcontent="" frameborder="0" src="//melinyel.net/applications/core/interface/js/spacer.png">

/topic/595-tuto-sdl-20/?do=embed" data-embedcontent="" frameborder="0" src="//melinyel.net/applications/core/interface/js/spacer.png">

[Recensement] Les templates

Alemort — Fri, 27 Jun 2014 12:31:44 GMT

Les templates, c'est quoi?

C'est un projet qui inclut des bibliothèques externes pré-configurés, pour faire simple par exemple vous n'arrivez pas à installer la SDL en C, vous pouvez trouver un projet ou la SDL est installée directement.

SDL1.2:

Avec SDL TTF et SDL IMAGE:

http://jeux.developpez.com/telecharger/detail/id/3420/SDL-1-2-plus-SDL-Image-plus-SDL-TTF-Template-pour-Code-Blocks

SDL2:

http://jeux.developpez.com/telecharger/detail/id/3538/SDL-2-0-Template-pour-Code-Blocks

Avec SDL TTF et SDL IMAGE:

http://jeux.developpez.com/telecharger/detail/id/4036/SDL-2-0-3-plus-SDL2-Image-plus-SDL2-TTF-Template-pour-Code-Blocks

[Cours complémentaires] Les bonnes pratiques en C

AlexMog — Thu, 12 Jun 2014 16:52:20 GMT

Bonjour à tous,

Dans ce cours un peu spécial, nous allons voir ensemble les bonnes pratiques à prendre en C, nous allons aussi voir dans quels cas certaines choses sont plus optimisées que d'autres.

Nous allons donc voir d'une manière générale la propreté du code, et l'optimisation de celui-ci en passant par des exemples d'erreures que tout le monde fait.

I- Propreté du code.

Pour un code lisible en C, il est impératif de bien construire son code. Les fichiers .h (headers) sont là pour les prototypes des fonctions, ainsi, le .c ne contiendra QUE le code des dites fonctions (et non pas des prototypes ou autres structures qui trainent dans des .c... BUARK!).

DECOUPEZ VOTRE CODE! Plus votre code sera découpé, et mieu il sera, plus vous ferez en sorte d'avoir un certain nombre de fonctions (en évitant les fonctions "poubelles" quand même...), plus votre code sera lisible et propre! Prensez donc bien à découper votre code!

Evtez les fonctions de 300 lignes! (ce qui rejoint le paragraphe précédent), effectivement, vous vous en sortez mieu en découpant le tout .

Essayez de respecter la taille d'un terminal (hé oui, les programmeurs Linux programment souvent sur le terminal, il faut penser à eux!) qui est de 80 caractères. Ainsi, évitez de dépasser les 80 caractères par lignes de code .

Les includes se font EN HAUT du code, je ne veux plus jamais voir des includes en plein milieu d'un code source... BRRRRR!

Vous pouvez, en plus, respecter un certain format d'include, certains trient par ordre alphabétique, d'autres par longueur, le but étant de mettre tout de même les includes System AVANT les includes perso.

ex:

// Ca c'est bon
#include 
#include "mon_include.h"
// CA C'EST BOF!
#include "mon_include.h"
#include

Evitez les includes inutiles! Cela ralentiera votre compilation si vous gardez des includes qui n'ont rien à faire là!

Pensez à sauter des lignes, éviter le multi-exécution sur une ligne... c'est pas très propre.

Bref, rendez votre code LISIBLE! Un code source, c'est comme un livre, si tout est en bordel, on a pas envie de le lire .

II- Optimisations et bonnes pratiques!

Passons à la partie la plus intéressente! L'optimisation et les bonnes pratiques. D'une manière générale les deux sont proches.

Au niveau des optimisations, nous allons d'abord commencer par un cas très spécial:

Doit-on passer par copie ou pas? (ceci ne s'applique pas aux typpages de base, mais plutôt aux tableaux et aux structures).

La réponse est simple: TOUT DEPENDS DE VOTRE CODE!

Si vous souhaitez utiliser la variable que vous passez dans une fonction de manière locale à ladite fonction, passez la par copie.

Dans le cas contraire, si vous voulez modifier une structure ou les cases d'un tableau par exemple, NE LA PASSEZ PAS PAR COPIE! Laissez votre stack tranquile non de dieu!

Pour bien vous faire différencier ce qui est une copie et ce qui ne l'est pas, vouci des exemples concrets.

// Ceci est une copie (buark)
void mafonction(int tab[10]);
// Ceci n'est pas une copie
void mafonction(int *tab);
void mafonction(int tab[]);
// Ceci est une copie
void mafonction(struct mastruct s);
//Ceci n'est pas une copie
void mafonction(struct mastruct *s);

Nous avons aussi le cas de l'allocation, quand faut-il allouer de la mémoire? Déjà, il faut savoir que l'allocation dynamique est la chose la plus LOURDE dans le monde de la programmation.

Il est donc conseillé d'allouer tout l'espace naisséssaire au chargement de son programme, pour éviter d'allouer en plein milieu.

Si les allocations sont rares, on peut tout de même les utiliser de manière dynamique. Mais il ne faut surtout pas en abuser! (c'est pour cela qu'un tableau à une dimension (au niveau de l'alloc) sera moins lourd qu'un tableau à double dimensions).

Une autre pratique qui est plutôt bonne à connaitre pour l'optimisation: les calculs à base d'INT.

Pourquoi utiliser le typpage int plutôt que float? Il faut savoir que les int sont stockés sur un seul registre, alors qu'un float (chiffre à virgule) est stocké sur 4 registres (merci l'ASM de nous le démontrer), il est donc conseillé d'utiliser des int plutôt que des float pour optimiser les calculs. N'oubliez pas que le calcul sur 4 registres sera TOUJOURS plus long que le calcul sur 1 registre (4x plus long), et cela, peut importe la valeur stockée dans les registres.

Enfin, la meilleure pratique pour bien optimiser son programme, c'est savoir de quoi est composé le dit programme!

Je m'explique, utiliser des fonctions préfaites par la LibC, c'est bien, mais quand on ne sait pas comment elles fonctionnent, c'est MAL!

En effet, vous êtes plusieurs à ne pas savoir que dans certains cas, printf n'est pas du tout optimisé (en effet, printf passe par 3 boucles ET une bufferisation des données AVANT affichage, alors qu'un simple puts ou write aurait fait l'affaire!), je vous conseille donc de vous renseigner sur les fonctions que vous utilisez, ou encore mieu! RECODEZ LES! Vous apprendrez beaucoup plus ainsi que de n'importe qu'elle autre manière!

Je vous invites à lire mes cours dans la section C, qui utilisent le principe de l'utilisation de Fonctions System au lieu de passer par des fonctions de la LibC, pour vous apprendre à bien comprendre la différence entre les deux, et avoir de bonnes habitudes (qui sait, vous comprendrez peut être comment ça marche )

Si vous désirez d'autres informations, n'hésitez pas à laisser un commentaire ci-dessous!

A très bientôt pour un prochain cours!

AlexMog.

Apprendre l'optimisation en C?

Alemort — Sun, 08 Jun 2014 16:03:14 GMT

Comme-vous le savez lorsque l'on fait de la programmation, un point important auquel n'ont accordé aucune attention lorsque l'on commence, c'est bien l'optimisation.

Donc pour aller vers l'optimisation en language C, vers où se tourner?

Pour améliorer ses algorithmes de calcul:

-vers l'assembleur pour optimiser les différents calculs

-Utiliser des types de variables moins gourmandes

Optimisation générale:

-éviter la copie de variable ou de tableaux dans des fonctions.

-Recoder les fonctions que l'on utilise pour mieux les comprendre et en créer de moins gourmandes pour nôtres utilisations.

Mais bon, les cours sur internet né détail pas trop ces points généralement.

Quelques questions:

Pour recoder une fonction par exemple prin, on se dirige vers quel type de fonction? Les fonctions que l'on utilisera il serait bien de les recoder mais il arrivera un point ou on pourra plus continuer, non?

Y a-t-il de bons sites qui donnent des conseils sur ce genre de sujet?

Y a-t-il d'autres voix pour optimiser son programme?

Est-il préférable d'optimiser son programme en codant les fonctions, ou bien coder un programme qui marche et ensuite l'optimiser?

[TUTO] SDL2.0 #2

cegdd — Fri, 06 Jun 2014 19:51:39 GMT

Bonjour à tous !

ça fait un moment que j'en parle, voici la suite du premier cours sur la SDL2 !

malheureusement le temps me manque, le peu de temps dont je dispose, je n'ais pas de connexion internet.

la solution la plus simple est donc d'écrire le code source du cours en le SURcommentant

le code source qui vas suivre vous montre étape par étape comment animer le personnage de rayman grâce a la SDL2.

//pour le type bool
#include 
//pour les atexit
#include 
//pour les printf
#include 
//les includes SDL
#include 
#include 
int main ()
{
//initialisation de la sdl
if (SDL_Init (SDL_INIT_VIDEO) < 0)
{   printf("erreur SDL_Init: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
atexit(SDL_Quit);
//initialisation de la sdl_image
if (IMG_Init(IMG_INIT_PNG) < 0)
{   printf("erreur IMG_Init: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
atexit(IMG_Quit);
//contexte d'affichage
SDL_Window *screen;
//tampon de rendu
SDL_Renderer *renderer;
//position de l'écran, de rayman et des différents sprites de rayman
SDL_Rect pecran, prayman;
SDL_Rect raymantiles[16];

unsigned int temps, tempsbride = 0, tempsanim = 0, index, anim = 0;
bool droite = true;


//initialisation des positions
pecran.x = 0;
pecran.y = 0;
prayman.w = 120;
prayman.h = 136;
for(index = 0 ; index < 6 ; index++)
{
	raymantiles[index].x = index*60;
	raymantiles[index].y = 1100;
	raymantiles[index].w = 60;
	raymantiles[index].h = 68;
}
for(index = 0 ; index < 6 ; index++)
{
	raymantiles[index+6].x = index*60;
	raymantiles[index+6].y = 68+1100;
	raymantiles[index+6].w = 60;
	raymantiles[index+6].h = 68;
}
for(index = 0 ; index < 4 ; index++)
{
	raymantiles[index+12].x = index*60;
	raymantiles[index+12].y = 136+1100;
	raymantiles[index+12].w = 60;
	raymantiles[index+12].h = 68;
}

//suppression du curseur de souris
SDL_ShowCursor(SDL_DISABLE);
//création de la fenêtre
screen = SDL_CreateWindow("Rayman_like", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 0, 0, SDL_WINDOW_FULLSCREEN_DESKTOP);
//création du tampon de rendu
renderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_ACCELERATED);
//récupération de la taille de l'écran
SDL_GetWindowSize(screen , &pecran.w , &pecran.h);

//mise en position de rayman
prayman.x = (pecran.w/2)-(prayman.w/2);
prayman.y = (pecran.h*0.65)-(prayman.w/2);

// chargement des images
SDL_Texture *fond = IMG_LoadTexture(renderer, "fond.jpg");
SDL_Texture *rayman = IMG_LoadTexture(renderer, "rayman.png");

//test d'erreur a la création de la fenêtre, du tampon de rendu et des images. (fonction critiques qui peuvent rencontrer des erreurs
if (screen == NULL || renderer == NULL || fond == NULL || rayman == NULL)
{
	printf("erreur: %s\n", SDL_GetError());
	return EXIT_FAILURE;
}

//entrée en boucle principale
while(1)
{
	//récupération du temps
	temps = SDL_GetTicks();
	
	//si le programme tourne depuis "x" ms, on quitte;
	if (temps >= 7000) { break; }
	
	
	//test pour changer le sprite d'animation si "x" ms sont écoulées
	if (temps - tempsanim >= 60)
	{
		//sauvegarde du temps actuel pour la prochaine itération
		tempsanim = temps;
		//sprite suivant
		anim++;
		//si le dernier sprite est atteint, on reviens au premier
		if(anim == 16){anim = 0;}
	}
	
	//bride pour sinchro ecran ~60fps
	if (temps - tempsbride >= 16)
	{
		//assignation du temps actuel pour la prochaine itération
		tempsbride = temps;
		
		//si rayman touche la bordure d'écran a droite, il fait demi tour !
		if (prayman.x + prayman.w >= pecran.w) { droite = false; }
		//si il touche la bordure gauche, il fait de même.
		else if (prayman.x <= 0) {droite = true;}
		
		
		//vidage du tampon de rendu
		SDL_RenderClear(renderer);
		
		//copie du fond sur le tampon
		SDL_RenderCopy(renderer, fond, NULL, &pecran);
		
		//si rayman vas à gauche
		if (!droite)
		{
			//décrémentation horizontale de la position de rayman.
			prayman.x -= 5;
			//copie de rayman (en inversant le sens de l'image) sur le tampon
			SDL_RenderCopyEx(renderer, rayman, &raymantiles[anim], &prayman, 0,NULL, SDL_FLIP_HORIZONTAL);
		}
		//sinon
		else
		{
			//incrémentation horizontale de la position de rayman.
			prayman.x += 5;
			//copie de rayman sur le tampon
			SDL_RenderCopy(renderer, rayman, &raymantiles[anim], &prayman);
		}
		
		//affichage du tampon de rendu sur l'écran.
		SDL_RenderPresent(renderer);
	}
	else
	{
		// si l'écran ne suis pas, ont fait une pause.
		// cela permet de grandement libérer le CPU.
		SDL_Delay(5);
	}
}

//programme terminé
return EXIT_SUCCESS;

}

si vous compilez chez vous, vous devriez avoir un résultat s'approchant de ça:

https://www.youtube.com/watch?v=fTFRiKdBPec (a noter qu'ici le déplacement était au clavier et non automatique)

pour tout commentaire ou question, je suis présent pour vous répondre

voici les fichiers pour ceux qui voudrais le compiler et le modifier pour s’entraîner ----> ICI

IA #4 - le GOAP

daemondragon — Wed, 04 Jun 2014 06:44:19 GMT

Bonjour a tous !

Tous d'abord qu'est ce que le GOAP ?

C'est l'abréviation de Goal Oriented Action Planning, ce qui pour les non anglophone, veut dire la

planification des actions en fonction de tes buts, ou de tes souhaits.

C'est un type d'IA qui a pour but de remplacer les FSMs (Finite State Machine), les automates a états

finis en gros. (Le mot anglais est plus classe et plus court a écrire donc c'est celui là que je vais utiliser maintenant).
En effet, les FSMs sont bêtes et méchantes, bien que facile a réaliser. Mais dès qu'il s'agit d'un comportement où il faut que l'IA ai l'air de réfléchir, les FSMs sont inadaptées. Ainsi les GOAPs sont utilisés principalement dans les FPS,
et aussi dans le mondialement connu Starcraft.
Cette IA a pour but d'offrir plus de challenge au joueur.
Mais rien ne vous empêche de faire une IA bien plus intelligente dans les autres types de jeu comme les RPG, ou les rogues like.

Le principe des GOAP maintenant :
Un pnj a différents but, comme manger, dormir, travailler etc...
chaque but a un niveau d'importance plus ou moins grand.

schéma :

but           : importance
dormir      : 4
manger    : 2
travailler : 1

Ici par exemple le pnj a très envie de dormir.
Les niveaux d'importance sont mis a jour au fil du temps et les actions les plus importantes
sont exécutées en premier.

En code :

typedef struct t_state
{
unsigned char id;
unsigned char importance;
}t_state;
t_state but[nombre_de_but_different];
/* on initialise le tout
int i;
for( i = 0 ; i < nombre_de_but_different ; i++ )
{
but[i].id = i;
but[i].importance = 0;
}

L'id sert a savoir le but ( par exemple dormir c'est 0, manger c'est 1 et travailler c'est 3) parce qu’à chaque fois que l'importance d'un but change, il faut retrier le tableau.
Regardez du coté des algorithme de tri, et n'oubliez pas que le tableau est presque trier, seul un élément est a sa mauvaise place.

Une fonction de tri en exemple (oui c'est utile de faire cela)

void tri(t_state but[], int nb_but)
{
/* Il s'agit ici d'un tri à bulle qui marche, mais qui est le plus lent possible
c'est pour vous forcer à regarder du côté des algo de tri*/
int changement = 1;
int i;
t_state transition;
while(changement)
{
        changement = 0;
	for(i = 0 ; i < nb_but - 1 ; i++)
	{
		if(but[i].importance < but[i+1].importance)
		{
			transition.importance = but[i].importance;
			transition.id = but[i].id;
			
			but[i].importance = but[i+1].importance;
			but[i].id = but[i+1].id;
			
			but[i+1].importance = transition.importance;
			but[i+1].id = transition.id;
			
			changement = 1;
		}
	}
}

}

On regarde donc le premier élément du tableau, qui est le plus important, et on exécute l'action associé.

Et la vous allez me dire : "mais alors c'est la même chose que les FSMs non ?"
Et bah non : les état ne sont plus reliés entre eux, donc l’insertion d'un nouveau but ne nécessite pas de tout revoir, mais en contre partie, cela nécessite plus de temps de processeur pour faire cela.
Et aussi, une grande nouveauté : pourquoi ce contenter d'UNE action par but ?
Si vous avez faim, vous pouvez vous faire vous même à manger, aller chez quelqu'un, ou encore aller dans un fast-food. il y a donc plusieurs solutions possibles.

Pour chaque action, il suffit de déterminer son poids :
Celui-ci peut varier en fonction de plusieurs facteurs, comme le temps mis à faire l'action,
le prix que cela va nous coûter etc...
Et il faut aussi déterminer l'importance que vont perdre les but. Par exemple :
fastfood : manger - 2
maison : manger - 4

On peut aussi choisir une des deux actions en fonction du poids en utilisant le principe des algorithmes de Dijkstra (parcours de graphe), qui est le même principe que le pathfinding. L'avantage, c'est de pouvoir avoir une plus grande flexibilité. Il faut alors voir les actions comme un enchaînement d'actions, et plusieurs actions peuvent menées a la même suivante.

/applications/sslimageproxy/interface/image.php?url=http://serge.mehl.free.fr/anx/anx_gif/Th_gra36.gif"/>
Le poid peut être en fonction de plusieurs choses, comme le temps, et l'importance que cela va perdre.
Par exemple, si l'on a très peu de temps et on est juste à coté du fast-food, alors on va y allez, et si on a tous notre temps, et juste à coté de chez soi, autant allez à sa maison. Le poid peut aussi être influencer par l'argent dépensé etc...

exemple :

/on calcule le poid de chaque action/
poid[nb_action_differentes];
int i;
for ( i = 0 ; i < nb_action_differente ; i++)
{
poid[i] = (temps * 0,5) /* plus le temps est court, mieux c'est. 50% d'importance pour le temps*/
+ (diminution_de_l_importance * 0,5);
}

je suis parfaitement conscient que le temps a un poid totalement aléatoire en fonction de l'unité
utilisé. C'est à vous de calibrer correctement le calcul du poid. il ne s'agit ici que du principe général.
Dans ce cas, plus le poid est grand, plus le temps pris est long.
Attention, la variable diminution_de_l'importance est négative (-2, -4 etc...) !

int meilleur_poid;
int meilleur_poid = poid[0];/C'est très important d'initialiser !/
int meilleure_action;
for ( i = 0 ; i < nb_action_differente ; i++)
{
if(poid[i] < meilleur_poid)
{
meilleur_poid = poid[i];
meilleure_action = i;
}
}

et on fait l'action :

actionmeilleure_action;

Je considère ici, que l'on envoie rien a la fonction, mais vous pouvez facilement le faire.
Le tableau est un tableau de pointeur de fonctions (voir le tutoriel d'AlexMog à ce sujet).

Pensez à updater ce tableau régulièrement tout les X secondes ou millisecondes, car une action peut à un moment

être plus utile que celle que vous voulez faire, alors qu'avant, elle ne servait à rien.

Vous avez donc maintenant réussi a faire un pnj qui pourra avoir des buts et faire des actions
en conséquence.
N'oubliez pas pas que plus vous augmenter le nombres de buts et d'actions, plus le pnj sera réaliste,
et plus cela prendra de temps pour "réfléchir"(pas beaucoup non plus mais sur des milliers de pnjs, cela se ressent).
Par exemple, le FPS F.E.A.R (j’insiste sur le mot FPS là !) possède 67 buts différents (pas un seul où
il le but est de tuer l’ennemi ) et 197 actions différentes.

[Cours #8] Listes chainées

AlexMog — Tue, 03 Jun 2014 17:04:34 GMT

Bonjour à tous,

Dans ce cours, nous allons voir ce qu'est une liste chainées, et comment elle fonctionne.

I- Liste chainée? WTF?

D'après Wikipedia: "Une liste chaînée désigne en informatique une structure de données représentant une collection ordonnée et de taille arbitraire d'éléments de même type".

Pour résumer, il s'agit d'une collection de données (comme un tableau, sisi), qui a une taille variable, donc on a pas besoin de connaitre la taille de la liste à l'avance (un peu comme dans le cours sur les allocations dynamiques ). Les éléments sont enregistrés les uns après les autres.

C'est donc une grosse liste de données. Le premier élément pointe vers le second, le second vers le troisième, le troisième vers le quatrième etc...

Comme le montre le schéma ci-dessous:

(Source: Openclassroom)

C'est une liste chainée simple, et nous ne verrons que celle-ci. Pour la liste chainée circulaire, ou encore double, je vous laisse chercher par vous mêmes

II- Créons notre structure de données!

Une liste chainées à pour but de contenir des données (c'est logique...), il faut donc créer une structure pour stocker lesdites données.

Pour ma part de vais créer une liste pour stocker l'age et la taille d'un certain nombre d'utilisateurs.

typedef struct s_list
{
int taille;
int age;
struct s_list *next;
}t_list;

Oh! c'est étrange, qu'est-ce que la variable "next" vient faire ici? Comme je l'ai dit plus haut, il s'agit du pointeur sur le prochain élément de notre liste chainée. Il va falloir penser à le mettre à NULL pour connaitre la fin de notre liste chainée! En effet, lorsqu'on sera au dernier élément, on le sera grâce au NULL.

Dans ce cours, je vais uniquement vous apprendre à ajouter des éléments à votre liste, à parcourir votre liste, et enfin à supprimer votre liste. C'est à vous d'utiliser votre tête pour la suite!

III- Ajouter un élément à la liste.

Maintenant que notre structure est crée, nous allons créer plusieurs fonctions, pour gérer notre liste chainée.

Créons tout d'abord une fonction pour ajouter un élément à la liste:

int add_to_list(t_list **list, t_list *datas)
{
t_list *next;
next = NULL;
if (*list != NULL)
next = *list;
if ((*list = malloc(sizeof(t_list))) == NULL)
return (1);
(*list)->taille = datas->taille;
(*list)->age = datas->age;
(*list)->next =next;
return (0);
}

Voici un exemple d'utilisation de la fonciton:

int main(void)
{
t_list *list;
t_list datas;
*list = NULL;
datas.age = 10;
datas.taille = 180;
// On ajoute à notre liste
if (add_to_list(&list, &datas))
return (1);
// On récupère le premier noeud pour voir ce qu'il contient
printf("Age: %d, Taille: %d\n", list->age, list->taille);
return (0);
}

III- Parcourons notre liste!

Nous allons à présent parcourir notre liste.

int main(void)
{
t_list *list;
t_list datas;
int i;
i = -1;
// On remplis notre liste avec 10 éléments
while (++i < 10)
{
datas.age = i;
datas.taille = 180 + i;
if (add_to_list(&list, &datas))
return (1);
}
// On parcours et on affiche notre liste!
while (list != NULL)
{
printf("Age: %d, Taille: %d\n", list->age, list->taille);
list = list->next;
}
return (0);
}

IV- Vidons notre liste! (C'est important de vider la mémoire!)

Pour cela, créons une fonction de vidage.

void clear_list(t_list **list)
{
t_list *elem;
t_list *next;
elem = *list;
while (elem)
{
next = elem->next;
free(elem);
elem = next;
}
*list = NULL;
}

Exemple d'utilisation:

int main(void)
{
t_list *list;
t_list datas;
int i;
i = -1;
// On remplis notre liste avec 10 éléments
while (++i < 10)
{
datas.age = i;
datas.taille = 180 + i;
if (add_to_list(&list, &datas))
return (1);
}
// On parcours et on affiche notre liste! (on utilise un pointeur annexe pour ne pas perdre le noeud mère)
list *elem = list;
while (elem != NULL)
{
printf("Age: %d, Taille: %d\n", elem->age, elem->taille);
elem = elem->next;
}
clear_list(&list);
return (0);
}

Je vous laisse la joie d'analyser le code, à ce stade des cours (et si vous avez bien tout suivi) vous savez analyser le code, je vous laisse donc le comprendre par vous mêmes! Je reste disponible pour répondre à vos questions!

A bientôt pour un prochain cours!

IA #3 - les mécanismes de groupes

daemondragon — Sat, 31 May 2014 07:31:22 GMT

Qu'est ce que les mécanismes de groupe ?

Ce sont les actions qui se passent lorsque vous êtes avec un nombre
important de personnes.
Ce tutoriel va mettre en place l'algorithme flack and swarm.
Cet algorithme est issue de l'observation des "essaims" de poissons :
Lorsqu'un poissons voit un prédateur, il fuit. Le poisson a coté voit celui
qui fuit et fuit a son tour, etc... Ce mécanisme est tellement rapide
qu'un observateur à l'impression que ceci se fait directement.
C'est ça les mécanismes de groupe.

Ces mécanismes sont souvent utilisés dans des jeu de type total war,
ou un groupe de personnes n'a en fait qu'une vrai personnes qui va
"réfléchir", le reste va copier les mouvement de celui qui réfléchit.

Mais quels sont les avantages d'utiliser cette technique ?

Tout d'abord, cela consomme moins de processeur car une seule personne
réfléchit, fait son action, et tout le monde copie son action. Du coup,
personnes d'autre ne réfléchit. (vous faites aussi cela en cours, tout
le monde copie sur une unique personne, cela prend moins de temps aux
autre cerveaux pour réfléchir, donc c'est bien )
Cela permet aussi d'assurer une cohérence dans le groupe
vous imaginer une armée où chacun peut faire ce qu'il veut ?
limiter le nombre de personnes qui réfléchit permet donc de limiter les incohérences
dans le jeu pour le joueur.

Donc pour le code, il faut faire cela :
"l'entité" leader fait cela :

typedef struct t_leader
{
char etat;
void(*p_fonction)(t_info *);
}t_leader;

Si vous ne savez pas se que signifie etat, aller voir le tutoriel précédent.
p_fonction est un pointeur de fonction.
Allez voir le tutoriel d'AlexMog qui est très bien fait.

/topic/746-cours-7-les-pointeurs-sur-fonction/?do=embed" data-embedcontent="" frameborder="0" src="//melinyel.net/applications/core/interface/js/spacer.png">

Utiliser les pointeur sur fonction permet d'exécuter très rapidement la fonction,
au lieu de mettre un ID de fonction et faire un immense switch ou if, else if ...

Dès lors, afin que les sbires, où ceux qui suivent le leader fassent les même actions,
il suffit de faire :

typedef struct t_sbire
{
void(*p_fonction)(t_info );
}t_sbire;

la structure t_info contient toutes les infos utiles pour exécuter les actions
Aller encore regarder mon tutoriel précédent pour comprendre se que c'est

t_leader leader;
t_info info;
/ vous mettez le pointeur sur fonction en fonction de l'état du pnj
par exemple : */
leader.p_fonction = &attack_near_enemy;
t_sbire sbire[16]; /* 16 est un exemple */
int i;
for(i = 0 ; i < 16 ; i++)
{
sbire[i].p_fonction = leader.p_fonction;
}
/* tout les sbires vont maintenant pouvoir faire la même action que le leader /

et on exécute le tout

leader.p_fonction(&info); / on envoie la structure d'info a la fonction (un pointeur)*/
for(i = 0 ; i < 16 ; i++)
{
sbire[i].p_fonction(&info);
}

Et voila, vous pouvez maintenant créer facilement des mécaniques de groupe, afin de créer
des immense batailles, ou encore une joli danse (chacun fait la même chose que son voisin) .

IA #2 - le pnj : un automate à états finis

daemondragon — Sun, 25 May 2014 10:33:19 GMT

Bonjour à tous !

En regardant le titre, vous avez sans doute penser : "kesako ?"
Et bah c'est très simple : un automate, c'est une machine qui fait ce qu'on lui dit,
et pourquoi a états finis ?

C'est parce que cet automate peut avoir plusieurs états différents, mais il ne
peut pas prendre les états que l'on n'a pas coder pour lui. Il ne peut aussi

prendre qu'un seul état à la fois.

Les automate à état fini sont très utilisés dans les jeux vidéos car ils sont
très simples à mettre en place et à débuggés. Le majeur inconvénients, c'est
qu'il sont prédictible, ce qui peut briser l'illusion qu'un véritable joueur,
est devant le joueur. Pour éviter la prédictibilité, une des solutions possibles
est d'augmenter le nombre d'états, ce qui permet plus de variations dans le pnj

Concrètement, prenons exemple sur un soldat dans un jeu qui protège un village par exemple :
On peut lui mettre deux états différents :
État 1 : patrouille
État 2 : attaque

Il faut maintenant dire ce qu'il faut pour changer d'état (c'est mieux non ?)
Par exemple, pour aller de l'état 1 à l'état 2, il faut que le soldat ai vu un intrus
et de l'état 2 au 1, il faut que le garde ai tuer l'intrus.

Pour reprendre l'exemple du soldats, on peut créer d'autre états :

État 3 : suivit d'un intrus qui veut s'enfuir.
État 4 : fuite car l'intrus est trop fort.
État 5 : va dormir (il a le droit de dormir non ?)

Bref vous l'avez compris, plus il y a d'états, plus le pnj sera réaliste.

Et maintenant le code :

/*
la structure qui va servir pour votre pnj
*/
typedef struct t_perso t_perso;
struct t_perso
{
char etat;
char type;
t_info info;
}

l'état correspond a l'état actuel du pnj. par exemple, pour le soldat,
si l’état est égal a 1, alors le soldat patrouille, etc...
le type correspond au type de pnj que vous avez.

et la structure t_info, contient tout ce que le pnj a besoin de savoir pour changer
d'état. (il a besoin de savoir si un ennemi est proche de lui etc...)

void change_etat(t_perso pnj)
{
/
Je suppose que toutes les infos utiles sont dans la structure t_perso
touts les mot en majuscules sont soit des define, soit des énumérations;
faites ce qu'il vous plaît le plus
*/

if(pnj->etat == PATROUILLE)
{
    if(test_attaque(pnj))
    {
        pnj->etat = ATTAQUE;
    }
    else if(test_sommeil(pnj))
    {
        pnj->etat = DODO;
    }
}
if(pnj->etat == ATTAQUE)
{
    if(test_intrus_mort(pnj))
    {
        pnj->etat = PATROUILLE;
    }
    else if(test_intrus_trop_fort(pnj))
    {
        pnj->etat = FUITE;
    }    
}
if(pnj->etat == DODO)
{
    if(test_sommeil_fini(pnj))
    {
        pnj->etat = PATROUILLE;
    }    
}
if(pnj->etat == FUITE)
{
    if(test_intrus_loin(pnj))
    {
        pnj->etat = PATROUILLE;
    }
}

}

les fonctions test_quelquechose(), sont des fonctions booléenne : si la condition est vrai, alors on retourne
1, et on change d'état associé a la fonction, si la fonction retourne 0, la condition est fausse,
alors on ne change pas d'état. ces fonction nécessite une structure t_perso pour tester
les conditions, mais rien ne vous oblige à les utiliser.
Faites vos propres test avec ce qu'il faut pour changer d’état, il faut juste modifier un peu
le code.

Comme vous le voyez, ce code est simple, et est très facilement lisible, donc facilement modifiable et
débuggable.
Chaque type de personnage nécessite sa propre fonction de changement d'état(un fermier qui fabrique ses
propres vêtements n'est pas crédible, réservez cela au tailleur).

Afin de vous retrouver plus facilement dans la création de changement d'état, n'hésitez pas
à faire un graphique des différents état possible :

pour info, flee veut dire s'enfuir.

Et voila, vous avez maintenant un pnj qui peut réagir en fonction des événement

qu'il l'entoure

[Cours #7] Les pointeurs sur fonction

AlexMog — Thu, 22 May 2014 14:47:21 GMT

Bonjour à tous,
Ce cours va être très court (oh ce jeu de mot!). En effet, je vais juste vous montrer comment faire un pointeur sur fonction.

I- Pointeur sur fonction? Kesako?
Un pointeur sur fonction, c'est simplement une manière d'appeler une fonction, en passant par un pointeur.
Par exemple:

void (*function_pointer)(char);
function_pointer = &my_putchar; // Vous pouvez retrouver la fonction my_putchar sur
le cours #1.
function_pointer('A');

Le programme ci-dessus crée le pointeur sur fonction function_pointer, et lui définit l'adresse de my_putchar (qui permet d'afficher un caractère).
Il affiche 'A'.

II- Utilité?
Un pointeur sur fonction permet d'appeler une fonction via un pointeur. Il est très souvent utilisé pour les tableaux de pointeurs sur fonction. Ce qui permet, par exemple, d'appeler une fonction en fonction d'une condition, sans avoir 40 000 if/else.
Exemple de tableau de pointeurs sur fonction:

#include 
void my_putchar(char c)
{
write(1, &c, 1);
}
void my_putstr(char *str)
{
while(str)
my_putchar((str++));
}
void aff_help()
{
my_putstr("Commandes:\ncoucou: affiche salut\ndada: affiche dadi\npopo affiche caca");
}
void aff_coucou()
{
my_putstr("salut\n");
}
void aff_dada()
{
my_putstr("dadi\n");
}
void aff_popo()
{
my_putstr("caca\n");
}
void do_cmd(char *cmd)
{
void (*fptr[])() = {&aff_popo, &aff_dada, &aff_coucou};
char cmds[] = {"popo", "dada", "coucou"};
int i = -1;
while (++i < 3)
{
if (!strcmp(cmds[i], cmd))
{
fptr(i)();
return ;
}
}
my_putstr("Commande introuvable.");
}
int main(int ac, char **av)
{
int readed;
char buffer[4096];
my_putstr("Entrez votre commande. Utilisez CTRL+D pour quitter\n");
while ((readed = read(0, buffer, 4095)) != -1)
{
buffer[readed] = '\0';
do_cmd(buffer);
}
return (0);
}

III- Déclaration et appel.
Enfin, voyons comment déclarer un pointeur sur fonction, puis comment lui définir une fonction.
Déclarons notre pointeur. Forme de déclaration:

typage_renvoyé_par_la_fonction (*nom_pointeur)(arguments_pris_par_la_fonction);

Par exemple, pour printf:

int (*myptr)(char *, ...); // oui, les ... sont un type. Il existe une fonction qui permet de récupérer une infinité d'args dans une fonction, mais je vousl’expliquerais dans un prochain cours!
// Assignation
myptr = &printf;
// Utilisation
myptr("Salut tout le %s", "monde!\n");

Voilà.
Vous l'aurez compris, les pointeurs sur fonctions sont très, TRES utilisés dans le monde du développement. Il est donc important de savoir les utiliser, pour apprendre à gagner des lignes.
Je vous dis a bientôt pour un prochain cours!
Cours écrit par AlexMog. Contact: alexmog [at] live [point] fr

[Cours #6] Librairies (statiques) et fichiers Headers (.h)

AlexMog — Thu, 22 May 2014 14:37:44 GMT

Bonjour à vous,
Dans ce cours, nous allons voir à quoi corresponds un fichier header, ainsi que comment créer une librairie, et enfin, les structures!

I- Qu'est-ce qu'une lib?
Une lib, aussi nommée librairie (dynamique ou statique) est un fichier binaire contenant une liste de fonctions prédéfinies.
Je vais vous donner un exemple de son utilisation, et pourquoi il est bon de créer une lib!
Imaginons que vous avez créé plusieurs fonctions, il vous serait pratique de les ré-utiliser dans un autre programme! Malheureusement, la compilation est très longue si il y a beaucoup de fonctions.
La lib est donc là pour deux choses: partager des fonctions sur diverses programmes, et éviter une compilation inutile sur des fonctions déjà près compilées.
Pour mieux vous faire comprendre tout cela, créons trois fichiers distincts:
main.c:

int main(void)
{
my_putstr("coucou\n");
return (0);
}
my_putchar.c:
void my_putchar(char c)
{
write(1, &c, 1);
}
my_putstr.c:
void my_putstr(char *str)
{
while(str)
my_putchar((str++));
}

Tentons à présent de compiler main.c:

cc main.c

Hum.. notre linker nous gueule dessus en nous disant qu'il est impossible de trouver la fonction "my_putstr". C'est normal! my_putstr n'a pas été compilée avec notre main. Elle ne fais donc pas partie du programme.
Maintenant, tentons de compiler tous nos fichiers en même temps:

cc main.c my_putchar.c my_putstr.c

Ah! Là ça marche! On a notre a.out qui est bien créé, et qui affiche bien "coucou".C'est un bon point, mais nous ne sommes pas avancés, j'ai envie de réutiliser my_putchar et my_putstr dans mes autres programmes, je vais tenter des les compiler pour voir si je peux les ré-utiliser sans avoir à les recompiler!

cc my_putchar.c
cc my_putstr.c

Hum... Mon linker me dit cette fois-ci qu'aucun main n'a été trouvé... Je ne peux donc pas compiler mes fonctions séparément?
Eh bien si! Il a une solution, les transformer en fichiers binaires non exécutables (aussi appelées lib), leur extentions est généralement .a pour un rassemblement de mini-libs, et .o pour les fichiers de fonctions de cette lib (pour résumer, les .o sont les briques, et .a est une partie du mur ! On utilise les briques pour construire cette partie).
Créons donc nos .o!

cc -c my_putchar.c
cc -c my_putstr.c

(man cc pour plus d'informations)
Voila! Je découvre my_putchar.o et my_putstr.o, tentez la commande "file my_putchar.o" pour voir qu'il s'agit bien d'un fichier binaire non exécutable.
C'est cool, mais pour l'instant mes fichiers sont séparés, j'aimerais bien tous les avoir dans un même "packetage" pour éviter de me trimballer 40 fichiers par programmes.
Eh bien, nous allons utiliser notre linker (et non plus notre compilateur) pour tous les liés dans un même package, un véritable fichier lib: un fichier .a.
Nous l'appellerons libmy.a:
Pour créer notre lib, voici la commande linker (je vous laisse le soin de lire le man de celle-ci):

ar rc libmy.a my_putstr.o my_putchar.o

On peux en faite considérer les .o comme des briques, et les .a comme le ciment qui va maintenir ces briques sur le programme.
Nous avons enfin notre lib! Tentons à présent de compiler main.c avec notre lib (je vous laisse, encore une fois, le soin de lire le man de gcc):

cc main.c -L./ -lmy

Hop! Nous avons notre a.out fonctionnel!
Vous savez à présent créer vos propres librairies!

II- Les fichiers Header
Nous avons vu précédemment comment créer notre propre librairie, mais néanmoins, nous avons, de temps à autres, des warnings qui apparaissent lors de notre compilation, voir même des erreurs car notre compilateur ne connaît pas les fonctions qu'il utilise.Les fichiers Headers ont plusieurs particularités. Il s'agit avant tout de fichiers d'"entête" chargés de fournir des informations au compilateur pour qu'il sache où chercher les fonctions, et leur utilité dans le programme.
Il permet aussi de rendre le code plus propre: nous pourrions faire nos headers directement dans notre .c, mais c'est plus moche, et la compilation d'un .h diffère de celle d'un .c (tentez cc *.h vous verrez bien).
Un header, c'est donc un fichier de préparation à la compilation. Il contiendra ainsi les prototypes des fonctions utilisées dans notre programme.
Vous pouvez trouver des exemples de headers dans les librairies que nous avions déjà utilisé!
Souvenez-vous:
Nous avions utilisé:

#include

qui corresponds à inclure le fichier .h de la libraire unistd. les <> signifient que le header se trouve dans le dossier include de notre compilateur.
Pour inclure un fichier local, il suffit de faire

#include "fichierlocal"

tout simplement!
Donc revenons sur notre histoire de warnings, nous allons créer un .h pour la lib précédente que nous avons créé:

#ifndef MY_H
#define MY_H
void my_putchar(char);
void my_putstr(char );
#endif / MY_H */

Je vais vous expliquer le fichier lignes par lignes.
Mais avant cela, je vais vous expliquer ce qu'est un define.
Un define est une sorte de variable statique et constante. Elle permet de remplacer la valeur du define par la valeur associée à celui-ci.
Voici un exemple simple:

#define VERSION "1.0.0"

J'ai définit VERSION comme ayant comme value 1.0.0
Je peux le ré-utiliser dans mon code, si j'inclus le fichier .h qui contient ce define, comme ceci:

int main(void)
{
my_putstr(VERSION);
return (0);
}

ATTENTION: il ne s'agit pas d'une variable. Un define est remplacé par le compilateur par la valeurqui lui est destinée!
J'espère que vous m'aurez compris...
Passons donc à la définition de notre fichier .h:

#ifndef MY_H

Notre première ligne de code permet d'éviter ce qu'on appelle une "double inclusion", en effet, si on inclue notre fichier .h dans plusieurs autres fichiers du même programme, nous pouvons créer de multiples inclusions, ce qui ne sert à rien, et ralentit la compilation.

#define MY_H

Si notre fichier n'a jamais été inclus, nous définissons qu'il l'a à présent été void my_putchar(char);

void my_putstr(char );

On y ajoute ensuite les prototypes des fonctions utilisées...

#endif / MY_H */

Enfin, on ferme notre "#ifndef" (if not defined).
Nous y sommes, revoyons notre main à présent:

#include "my.h"
int main(void)
{
my_putstr("coucou\n");
return (0);
}

Compilons le:

cc main.c -lmy -L./

Et voilà! Plus aucun warnings ou erreurs! Nous pouvons passer à la suite!

III- Les Structures.
Une structure est un ensemble de données. Il permet de stocker plusieurs données sous un même typpage. (nous verrons en même temps la déclaration de typpages, grâce à typedef).
Construction d'une structure:

struct s_nom_de_ma_struct
{
int valeur_numerique;
char valeur_caractere;
typpage valeur_n'importe_quel_typpage;
};

C'est aussi simple que cela.
A savoir : Une structure doit être déclarée dans un .h!Nous allons créer une structure, qui contiendra une chaine de caractères "pseudo" et une autre
chaine de caractère "texte":

struct s_mastruct
{
char *pseudo;
char *texte;
};

Nous allons afficher les données de notre structure:

void set_structure(struct s_mastruct mastruct)
{
/ (*mastruct).pseudo = "AlexMog" est la même chose que mastruct->pseudo = "AlexMog" */
mastruct->pseudo = "AlexMog";
mastruct->texte = "Coucou! :)";
}
int main(void)
{
struct s_mastruct mastruct;
set_structure(&mastruct);
my_putstr("Pseudo: ");
my_putstr(mastruct.pseudo);
my_putchar('\n');
my_putstr("Texte: ");
my_putstr(mastruct.texte);
my_putchar('\n');
return (0);
}

Ce code nous affichera:

Pseudo: AlexMog
Texte: Coucou!

A SAVOIR: lorsque vous utilisez un pointeur sur structure (comme dans la fonction set_structure) les "." sont remplacés par "->".
Voilà, vous savez à présent vous servir des structures. Mais vous avez remarqué que taper "struct s_mastruct mastruct" est tout de même long pour la ré-utilisation de cette structure... Nous allons donc créer notre propre typage!
Rendez-vous dans le .h:

struct s_mastruct
{
char *pseudo;
char *texte;
};

et créons notre nouveau typage:

typedef struct s_mastruct
{
char *pseudo;char *texte;
} t_mastruct;

Nous pouvons à présent déclarer nos structures comme ceci:

t_mastruct mastruct;

Cool n'est-ce pas ?
Vous remarquerez, pour ceux qui font de la programmation orientée objet, qu'une structure ressemble énormément à un objet, il s'agit en faite de la maman de l'objet connu actuellement! Nous verrons cela plus en détails, lorsque j'aborderais les notions sur la programmation en C Modulaire dans un prochain cours (dans longtemps donc, puisque nous devons voir les pointeurs sur fonctions avant (un objet = une structure contenant un ensemble de données et de pointeurs sur fonctions allouée dans la mémoire)).

Voilà!
A très bientôt pour un prochain cours!
Cours écrit par AlexMog. Contact: alexmog [at] live [point] fr

[Cours #5] ArgC, ArgV et allocations Dynamiques

AlexMog — Thu, 22 May 2014 14:08:36 GMT

Bonjour à tous,
Bienvenue dans ce 4ième cours sur la programmation en C.
Aujourd'hui, nous allons voir un point intéréssent de notre programme, et un point clé en les
Arguments de lancement, et les allocations dynamiques.

I- Qu'est-ce qu'un argument de lancement?
Un argument de lancement est une string ajoutée au lancement du programme permettant de faire passer ladite string au programme (string = chaine de caractères).
Ainsi, si je lance le programme avec cette ligne de commande:

mon_programme mon_argument

mon programme recevra comme argument 1 : "mon_argument".
(En faite, d'une façon générale, les arguments sont gérés par les shells qui lancent le programme. C'est une convention de programmation).
Quelques exemples d'utilisations d'arguments:
Les commandes unix utilisent très souvent les arguments:

ls --help
cd --
cd /home
cd ~
mkdir test
...

et peuvent donc permettre de faire passer une valeur, ou même un chemin à son programme (bah oui, c'est des Strings (tableaux de caractères). Bon, passons à la pratique:

II- Récupérer des arguments de lancement
Nous avions vu la structure basique d'un main en C:

int main(void)
{
}

Eh bien, je ne vous ai pas dit la vérité sur cette fonction!
En effet, main peut prendre un void pour argument (et donc ne prendre aucun arguments), ou bien prendre un int, et un char **.
Le véritable prototypage de la fonction main est donc:

int main(int argc, char *argv)
{
}

En voyant ça, vous allez me dire "dis donc, j'ai mal à la tête, y'a un ** dans ton code!" Eh bien ne
vous inquiétez pas, il s'agit d'un tableau de chaines de caractères.Prenons pour exemple ce programme lancé comme ceci:

coucou arg1 arg2 arg3 je suis fou

Eh bien, nous pouvons récupérer les arguments de ce programme de la façon suivante:

/
** Je re-crée les fonctions d'affichage. Voir cours #1 et #2
*/
void my_putchar(char c)
{
write(1, &c, 1);
}
void my_putstr(char *str)
{
while(str)
my_putchar((str++));
}
int main(int argc, char **argv)
{
my_putstr(argv[0]); // Affichera
my_putstr(argv[1]); // Affichera
my_putstr(argv[2]); // Affichera
my_putstr(argv[3]); // Affichera
my_putstr(argv[4]); // Affichera
my_putstr(argv[5]); // Affichera
my_putstr(argv[6]); // Affichera
return (0);
}

"cocuou"
"arg1"
"arg2"
"arg3"
"je"
"suis"
"foud"

Nous butons à présent sur un problème, ré-utilisons le programme précédent, mais supprimons tous,
ou un des arguments:

Segmentation Fault

Eh oui, comme vous le voyez, nous essayons d'accéder à la valeur d'un tableau qui n'existe pas, ce qui provoque une erreur d'accès en mémoire.
Pour remédier à cela, les développeurs nous ont rajoutés "argc".
Pour mieux vous faire comprendre, je vais vous définir exactement ce que signifie argc et argv:
ArgC est un couplage entre les mots: Argument et Count, il s'agit donc du nombre d'arguments qui ont été passés en paramètres.
ArgV est un couplage entre les mots: Argument et Value, il s'agit donc des valeurs de ces dits arguments.

Maintenant que vous avez le nombre d'arguments, vous pouvez vérifier que le nombre d'arguments est correcte avant de l'afficher:

int main(int argc, char **argv)
{
if (argc > 1)
my_putstr(argv[1]);
return (0);
}

argv[0] sera toujours présent, puisqu'il s'agit du tout premier argument, qui est vital pour lancer le programme (il s'agit plus exactement de la commande utilisée pour lancer le programme).
Passons à présent à la partie complexe de ce cours: les allocations dynamiques.

III- Les allocations dynamiques
L'allocation dynamique, c'est l'art de savoir utiliser sa RAM et les répercussions de l'alloc sur celle-ci.
Nous avions vu précédemment que pour pouvoir avoir une chaine de caractère avec une certaine taille, nous devions définir un tableau de caractères, avec une taille FIXE.
Comme ceci:

char mon_tableau[talle_de_mon_tableau];

Là est le problème, imaginons que nous devions modifier notre chaine, en lui imposant une taille plus grande: SegFault.
Eh bien, la solution, c'est d'utiliser l'allocation dynamique: Au lieu de stocker notre chaine dans la stack, stockons la dans la RAM! (ce qui nous permet d'avoir plus d'espace, d'ailleurs! (généralement, la stack est limitée à quelques Ko, alors que la RAM non))
Vous comprenez donc qu'il est dangereux d'utiliser malloc de façon idiote: dans une boucle infinie par exemple... Puisque vous allez remplir votre RAM!

Prenons un exemple simple:
J'ai un programme qui connaît la taille d'une chaine de caractère, et je dois la stocker dans une variable:

int main(void)
{
int lenght = 300000; // Oui, notre chaine est très longue
}

Si je tentais de déclarer un tableau statique de char de taille 300 000, il y aura énormément de chances pour que mon programme segfault dès le lancement.
C'est problématique, en effet.
Tentons donc d’allouer un emplacement dans la ram pour cette chaine:

int main(void)
{
char *ptr;
ptr = malloc(300000 * sizeof(char));
}

Tiens, ça marche!
Lisons un peu mieux le man de malloc: en cas d'erreur, malloc retourne NULL.
Nous allons donc vérifier si il y a eu une erreur (pour éviter le segfault):

int main(void)
{
char ptr;
ptr = malloc(300000 * sizeof(char));
if (ptr == NULL)
{
my_putstr("Erreur malloc\n");
return ;
}
}

Bon, nous avons donc alloué un emplacement de type char (donc tableau de caractères) dans notre ram, avec une taille de 300 000 cases! Cool!
Nous pouvons donc remplire "ptr" exactement comme un tableau (case par case, voir cours sur les chaines de caractères).
ATTENTION: ptr est un POINTEUR. Si vous modifiez son adresse, vous perdez l'ancienne adresse allouée! Donc ceci:

int main(void)
{
char *ptr;
ptr = malloc(300000 * sizeof(char));
if (ptr == NULL)
{
my_putstr("Erreur malloc\n");
return ;
}
ptr = "coucou";
}

est interdit et stupide (ne rigolez pas, les profs de programmation font souvent l'erreur!).
Bon, c'est bien, nous avons alloué de la mémoire, mais bon, c 'est pas cool pour la RAM, on ne la vide jamais, il va falloir la vider!
Pour la vider, la fonction "free" est là pour nous aider!
Voilà mon programme une fois la fonction "free" utilisée:

int main(void)
{
char *ptr;
ptr = malloc(300000 * sizeof(char));
if (ptr == NULL)
{
my_putstr("Erreur malloc\n");
return ;
}
free(ptr);
}

Tout marche! Cool!
ATTENTION: pour bien vous montrer que modifier un pointeur est une mauvaise idée, tentez de faire ceci:

int main(void)
{
char *ptr;
ptr = malloc(300000 * sizeof(char));
if (ptr == NULL)
{
my_putstr("Erreur malloc\n");
return ;
}
ptr = "coucou";
free(ptr);
}

Hop, vous tomberez sur une erreur qui se nomme "glibC" et qui corresponds à une erreur de pointage, la fonction "free" vous hurle dessus comme quoi votre pointeur ne pointe pas sur une zone
allouée.
Pour vous montrer que mon code fonctionne, je vais afficher ma chaine de caractère, qui fera
l'alphabet avec 300 000 lettres!

int main(void)
{
char *ptr;
int i;
i = 0;
j = 0;
ptr = malloc(300000 * sizeof(char));
if (ptr == NULL)
{
my_putstr("Erreur malloc\n");
return ;
}
while(i < 300000)
{
ptr[i] = j + 'a';
i = i + 1;
j = j + 1;
if (j + 'a' >= 'z')
j = 0;
}
ptr[i] = '\0'; // NE PAS OUBLIER LA FIN DE LA CHAINE (voir cours sur les chaines de caractères)
my_putstr(ptr);
free(ptr);
}

Et voilà, vous savez à présent utiliser les allocations dynamiques!
A bientôt pour le prochain cours!
Cours écrit par AlexMog. Contact: alexmog [at] live [point] fr

IA #1 - le pathfinding (2/2)

daemondragon — Thu, 22 May 2014 13:24:02 GMT

Et voila le deuxieme tutoriel où je vais vous expliquer tout le code
du pathfinding ( et oui enfin ! )

Tout d'abord n'hésitez pas a télécharger les sources en bas du post afin
de les lire en même temps, c'est plus pratique pour comprendre de
quoi je parle.

On va commencer par le prototype de la fonction :

path_direction* create_path(const int largueur, const int hauteur, int map[][hauteur],
const path_pos debut, const path_pos fin, int pivot)

Cette fonction retourne un pointeur vers une structure, je vais vous expliquer a quoi
elle sert vers la fin. Il faut donc en paramètre la largueur et la hauteur de la map

(attention, la map doit être de format map[largueur][hauteur] et non, map[hauteur][largueur]
la map qui contient des nombres afin de représenter votre terrain, et maintenant les trucs
intéressant : la structure path_pos ne contient que deux int, x et y, pour connaître la position
du début et celle de la fin.

Attention, le début de la map commence a (0, 0), il faut faire attention !
Et enfin le pivot, mais qu'est ce que c'est ?
C'est tout simplement tout les nombres qui sont supérieur ou égal a lui sont traversables,
tout ceux inférieur sont des murs par exemples. cela nécessite par contre de penser a
cela dès le début e la conception du jeu mais c'est pas très difficile. personnellement,
j'utilise souvent des énumération pour définir les différentes tiles (blocs) de la map.

ensuite :

if(debut.x == fin.x && debut.y == fin.y)
{
return NULL;
}

assez explicite je crois, on retourne NULL afin de savoir qu'il n'y a pas de chemin.

On doit créer ensuite une grille de coût , de la taille qui faut exactement, et on initialise
le tout a 0, c'est très important !
on met a jour a grille de coût, en mettant a 1 le début.

Ainsi, on sait que tout les blocs avec un coût égal a zéro sont non explorés

Il faut ensuite créer une file, les positions actuelle et les suivantes, ce qui donne :

path_pos actuel;
path_pos suivant;
control control_list;

la structure control et donc se qui va nous servir a contrôler la file, on va mettre les donnée
en file a partir de cette structure là.
Elle contient un pointeur vers la première donnée, pour la récupérer. (n'hésitez pas a regarder
le précédent tutoriel pour voir de quoi je veux parler) Et aussi un pointeur vers la dernière
données, afin de mettre les données dans la file plus rapidement. S'il n'y en avait pas, on
aurait du parcourir TOUTES les données de la file une par une afin de trouver la fin.
Vous imaginez sur une énorme file de 1000 données ?
Il faut initialiser la file avec la position de début et on commence les choses sérieuse.

Il faut ensuite créer une boucle qui s’arrête quand on a trouvé la fin ou que la file est vide.
dedans, on met a jour la position actuelle qui erre égale a la valeur du début de file.
si la position actuelle est égale a celle de fin on sort de la boucle, sinon on regarde sur le coté.
Cela donne en code:

while(control_list.premier != NULL && fini)
{
actuel.x = control_list.premier->actuel.x;
actuel.y = control_list.premier->actuel.y;
        if(actuel.x == fin.x && actuel.y == fin.y)
        {
            fini = 0;
        }

        if(actuel.x != 0)
        {
            if(map[actuel.x-1][actuel.y] >= pivot && poid[actuel.x-1][actuel.y] == 0)
            {
                suivant.x = actuel.x-1;
                suivant.y = actuel.y;
                poid[suivant.x][suivant.y] = poid[actuel.x][actuel.y] + 1;

                add_to_file(&control_list, suivant);                    
            }
        }
        if(actuel.x != largueur -1)
        {
            if(map[actuel.x+1][actuel.y] >= pivot && poid[actuel.x+1][actuel.y] == 0)
            {
                suivant.x = actuel.x+1;
                suivant.y = actuel.y;
                poid[suivant.x][suivant.y] = poid[actuel.x][actuel.y] + 1;

                add_to_file(&control_list, suivant);
            }
        }
        if(actuel.y != 0)
        {
            if(map[actuel.x][actuel.y-1] >= pivot && poid[actuel.x][actuel.y-1] == 0)
            {                
                suivant.x = actuel.x;
                suivant.y = actuel.y-1;
                poid[suivant.x][suivant.y] = poid[actuel.x][actuel.y] + 1;
                
                add_to_file(&control_list, suivant);
            }
        }
        if(actuel.y != hauteur - 1)
        {
            if(map[actuel.x][actuel.y+1] >= pivot && poid[actuel.x][actuel.y+1] == 0)
            {                
                suivant.x = actuel.x;
                suivant.y = actuel.y+1;
                poid[suivant.x][suivant.y] = poid[actuel.x][actuel.y] + 1;

                add_to_file(&control_list, suivant);
            }
        }
        remove_to_file(&control_list);
    }

Il faut bien entendu éviter de partir sur les coté de la map, sinon on risque d'avoir des problèmes de mémoires.
Vous vous dites aussi sûrement : "mais c'est quoi add_to_file et remove to file" non ?
Ce sont les structure qui servent a mettre les données dans la file, ou a les enlever.
(regardez dans le code source fournit, elle y sont au début.)
A partir de là, la grille de coût est fini, on peut vider totalement la file, on
n'en a plus besoin. ( il faut éviter les fuites mémoires) :

while(control_list.premier != NULL)
{
remove_to_file(&control_list);
}

Et non ce n'est toujours pas fini :
Il faut regarder la variables fini, qui si elle est égale a zéro, signifie qu'on a trouvé la
fin ,sinon, il faut encore retourner NULL.
si le chemin est trouvé, on se place sur la position de fin et regarde a coté.
On va dans la direction on le coût est égal au coût - 1 de la case.
Il ne faut surtout PAS prendre la case qui a un coût inférieur a celle autour, car a ce
stade la, certaine case n'ont pas encore été explorer ( se n'était pas la peine, on
avait trouver le plus court chemin jusqu’à la fin) et sont donc encore égale a 0.
On risque alors de se trompé totalement de chemin.
On met ensuite dans la pile les directions contraire ou on va aller.
(on part de la fin je vous rappelle) et on retourne a la fin cette pile.
En code :

if (fini == 0)
{
fini = 1;
actuel.x = fin.x;
actuel.y = fin.y;
path_direction *control = NULL;
char direction;
        while((actuel.x != debut.x && fini) || (actuel.y != debut.y && fini))
        {
            //les directions sont inversé car le png va aller dans l'autre sens
            if(poid[actuel.x][actuel.y+1] == poid[actuel.x][actuel.y] - 1)
            {
                direction = NORD;
                actuel.y++;    
            }
            else if(poid[actuel.x][actuel.y-1] == poid[actuel.x][actuel.y] - 1)
            {
                direction = SUD;
                actuel.y--;
            }
            else if(poid[actuel.x+1][actuel.y] == poid[actuel.x][actuel.y] - 1)
            {
                direction = OUEST;
                actuel.x++;
            }
            else
            {
                direction = EST;
                actuel.x--;
            }
            empile(&control, direction);
        }
        return (control);
    }

La structure path_direction comporte, une direction sous forme de point cardinaux (NORD, SUD...)
et un pointeur vers la donnée suivante (c'est une pile je vous rappelle).
la fonction empile sert a empiler la direction dans la pile (elle va tout au début).
A la fin, on retourne la pile, qu'il faut récupérer avec un pointeur sur une structure path_direction

Le seul problème de ce path_finding actuel, c'est qu'il faut éviter que le chemin, se trouve sur les bord,

sinon on peut passer de l'autre coté de la map dans certain cas, ce qu'il faut a tout prix empêcher.

Dans le cas de situation différentes a celle d'un labyrinthe, (quand les chemins ont une grande

chance d'être droit, vous pouvez dirigez le path_finding en lui faisant allez dans la direction vers la

fin et en transformant la file de départ en pile. Il faut alors pouvoir réécrire un coût d'une bloc si la

deuxième fois, le coût est plus faible.

Bref, il est facilement améliorable et il ne tiens qu'à vous de le récréer totalement.

Et voila le tour est joué, vous avez maintenant un path_finding qui marche

https://github.com/daemondragon/pathfinding.git

IA #1 - le pathfinding (1/2)

daemondragon — Wed, 21 May 2014 17:34:50 GMT

Bonjour a tous !

Cette suite de tutoriel va vous expliquez comment faire une IA basique pour des pnj
que vous pourrez adapter pour des jeux simples(non ce n'est pas une super grosse IA
de la mort qui tue qui va faire vos problèmes de math toute seule).

Dans la première partie du tutoriel, nous allons voir une partie fondamentale
des IA dans les jeux vidéos : le pathfinding.
Le code du pathfinding était trop long pour être expliqué dans un seul tutoriel,
le premier traitera de la théorie et le deuxième de la pratique.

Le pathfinding, qu'est ce que c'est ?

Le pathfinding c'est le fait de dire a une personne :
tu vas du point A au point B en évitant les obstacles.
(c'est mieux que de se prendre les murs non ? )

Pour le pathfinding, nous allons mettre en place un algorithme A*, qui est
très célèbre et qui peut être utilisé un peu partout, surtout dans le jeu
utilisant un système de grille(starcraft, zelda etc...)

A* tiens son nom de la recherche "en étoile" qu'il fait :
pour chaque case, il va regarder celles d'autour qui n'ont pas été déjà exploré et va dire :
celle la elle est plus loin de la case de départ que la précédente.

petite image :

/applications/sslimageproxy/interface/image.php?url=http://www.nicolas-texier.net/fr/system/files/ExplicationAStar.png"/>

Le 0 correspond au début.
Plus on s'éloigne du 0, plus le coût (ou le poids, c'est la même chose) augmente.
Le but, c'est de prendre le chemin, qui possède le plus faible coût.

Par exemple, si vous voulez partir du point (0, 3) -> le 4eme point
tout en haut a gauche, vous n'allez pas partir carrément a gauche, faire X fois
le tour du gros truc noir, non ?
Vous allez simplement prendre le chemin le plus court.

Pour réaliser donc ce merveilleux pathfinding, vous allez donc partir du début
(le point (7, 6)) et regarder autour, si ce bloc n'est pas un mur. Vous augmenter
alors le coût du déplacement pour cette case, puis on refait cela jusqu’à ce qu'on
trouve la fin voulu ou jusqu’à ce qu'il n'y ai plus de possibilité
de passer car tous les blocs ont été explorés, il n'y a donc pas de possibilité
d'aller du point A au point B.
Puis on part de la fin et on passe par les blocs qui ont le plus faible coût.

Pour réaliser cela, on commence par créer une file (oui je parle enfin de code).
Une file est une structure de données qui permet de mettre des variables l'une après l'autre.
La première donnée qui rentre dans la file est la première à sortir.

Pour ceux qui ne savent pas ce que c'est :
/topic/783-cours-8-listes-chain%C3%A9es/?do=embed" data-embedcontent="" frameborder="0" src="//melinyel.net/applications/core/interface/js/spacer.png">

Donc ont la créer, cette file et on met, si ce n'est pas des murs, et s'il n'ont pas
été déjà explorés,la position des blocs d’à coté, tout a la fin.
A chaque tour de boucle, ont prend la première position et on refait la même chose.
Pour les minecraftien, c'est comme l'eau qui coule déjà sur la case la plus proche, puis sur celles
plus éloignées.

Quand on a trouvé la fin, la où le pnj par exemple veut aller, on arrête, ou alors quand il n'y a plus
de blocs a explorer, alors le pnj est triste car il ne peut pas y aller.

Si on a trouvé la fin, on met alors dans une pile, (les dernières données qui arrivent dedans
seront les premières à sortir), car le chemin doit être pris dans le sens contraire où l'on va.
On cherche alors, a partir de la fin, la case autour d'elle qui a le plus faible coût,
puis on enregistre sa position et on mets la direction contraire (n'oublier pas que le
pnj va parcourir le chemin dans l'autre sens) dans la pile et on refait ça
jusqu’à ce qu'on trouve le début.

Et voila vous pouvez maintenant, grâce à ces explication créer vous même votre pathfinding, ou alors
attendre le prochain tutoriel qui ne devrait pas tarder a suivre.
En utilisant uniquement le pathfinding et intelligemment vous pouvez déjà créer un planning pour chaque pnj,
ce qui va permettre de rendre une ville plus vivante (je pense surtout au village pnj de zelda qui sont
toujours au même endroit, c'est un peu triste non ?).

"else if" dans une boucle

cegdd — Tue, 29 Apr 2014 19:09:16 GMT

if (variable >= 0)
{
}
for (index = 0 ; index < 150 ; index++)
{
else if (untableau[index] == 0)
{
}
}
else
{
}

bonjour à tous,

voici un exemple pour illlustrer mon cas.

dans l'exemple ci-dessus, le compilateur n'est pas content.

mais comment éviter une cascade de "else if" ?

des avis ?

[TUTO] SDL 2.0

cegdd — Fri, 25 Apr 2014 22:03:26 GMT

Bonjour à tous,

Ce tuto a pour but de vous apprendre les bases de la bibliotheque SDL,

et plus précisément la 2.0.

Les exemples de codes seront rédigés en C car c'est le language dans lequel est écris la SDL,

bien que la SDL suporte le C++ et dispose de bindings pour le C#, le Pascal et le Python.

j'imagine donc que vous maitrisez votre langage pour la suite.

Code minimal

Pour tester l'installation et expliquer les premières fonctions voici un code de base.

int main (int argc, char *argv[])
{
SDL_Init (SDL_INIT_VIDEO);
SDL_Window *screen;
SDL_Renderer *renderer;

screen = SDL_CreateWindow("tuto", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_RESIZABLE);
renderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_ACCELERATED);

SDL_RenderPresent(renderer);
SDL_Delay(2000);

SDL_Quit();
return 0;

}

SDL_Init (SDL_INIT_VIDEO);

Fonction initialisant la sdl.

int SDL_Init(Uint32 flags)

retour :

retourne une valeur négative en cas d'erreur.

paramètres :

SDL_INIT_TIMER sous-système temps

SDL_INIT_AUDIO sous-système audio

SDL_INIT_VIDEO sous-système video

SDL_INIT_JOYSTICK sous-système pour joystick

SDL_INIT_HAPTIC sous-système pour le tactile

SDL_INIT_GAMECONTROLLER sous-système mannette de jeu

SDL_INIT_EVENTS sous-système pour les évènement

SDL_INIT_EVERYTHING tout les sous-système au dessus

SDL_INIT_NOPARACHUTE ne prend pas en compte les signaux comme SIGSEGV SIGPIPE etc DANGEREUX

SDL_CreateWindow("tuto", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_RESIZABLE);

fonction créant la fenêtre de notre programme.

SDL_Window SDL_CreateWindow(const char title, int x, int y, int w, int h, Uint32 flags)

retour :

retourne un pointeur vers la structure "SDL_Window" nouvellement créée.

paramètres :

le titre de la fenêtre
le point x de la fenêtre ou "SDL_WINDOWPOS_CENTERED" et "SDL_WINDOWPOS_UNDEFINED"
le point y de la fenêtre ou "SDL_WINDOWPOS_CENTERED" et "SDL_WINDOWPOS_UNDEFINED"
la taille horizontale de la fenêtre
la taille verticale de la fenêtre
encore des flags que voici :

SDL_WINDOW_FULLSCREEN plein écran

SDL_WINDOW_FULLSCREEN_DESKTOP plein écran a la résolution du bureau

SDL_WINDOW_OPENGL fenêtre de contexte pour OpenGL

SDL_WINDOW_SHOWN fenêtre visible

SDL_WINDOW_HIDDEN fenêtre invisible

SDL_WINDOW_BORDERLESS fenêtre sans contour

SDL_WINDOW_RESIZABLE fenêtre redimensionnable

SDL_WINDOW_MINIMIZED fenêtre minimisée

SDL_WINDOW_MAXIMIZED fenêtre agrandie

SDL_WINDOW_INPUT_GRABBED window has grabbed input focus :huh:

SDL_WINDOW_INPUT_FOCUS window has input focus :huh:

SDL_WINDOW_MOUSE_FOCUS window has mouse focus :huh:

SDL_WINDOW_FOREIGN pas de fenêtre

SDL_WINDOW_ALLOW_HIGHDPI fenêtre en mode High-DPI (SDL2.0.1 ou plus)

SDL_CreateRenderer(screen, -1, SDL_RENDERER_ACCELERATED);

Créer un renderer (le renderer est la vue, la surface que l'on va afficher à l'écran).

SDL_Renderer SDL_CreateRenderer(SDL_Window window, int index, Uint32 flags)

retour :

retourne un pointeur vers la structure "SDL_Renderer" nouvellement créée.

paramètres:

le pointeur vers la structure SDL_Window créée précédemment.
j'aurais aimé vous expliquer mais malheureusement aucune doc ou tuto n'est clair là dessus du coup, ne vous en occupez pas et donnez -1 comme argument.
ce sont encore des flags, vous pouvez en mettre plusieurs.

SDL_RENDERER_SOFTWARE rendu calculé par le CPU

SDL_RENDERER_ACCELERATED rendu calculé par le GPU (grosse nouveauté de la SDL2.0)

SDL_RENDERER_PRESENTVSYNC rendu synchronisé avec le taux de rafraichissement de votre écran

SDL_RENDERER_TARGETTEXTURE rendu pour texture

SDL_RenderPresent(renderer);

fonction affichant le rendu sur l'écran

void SDL_RenderPresent(SDL_Renderer* renderer)

paramètre :

le pointeur vers la structure SDL_Renderer créée précédemment.

SDL_Delay(2000);

fonction qui met le programme en pause pendant x milisecondes

void SDL_Delay(Uint32 ms)

paramètre:

le nombre de milisecondes

SDL_Quit();

fonction qui ferme la sdl

void SDL_Quit(void)

explication :

si vous lancez ce code, vous devriez avoir une fenêtre noire pendant 2 secondes.

c'est tout à fait normal.

à bientôt