Bonjour à tous =)

Dans ce topic, je vous présenterai mes projets les plus notables.

N'étant actif que depuis très peu de temps sur le CBNA, vous ne me connaissez pas encore.
Cependant, à de très nombreuses reprises mon chemin a croisé celui de votre communauté...
Tant et si bien que sans le savoir, VOUS m'avez peut-être apprit des choses.
Aujourd'hui, l'élève que j'étais a acquis un nombre non négligeable de connaissances,
Il serait temps de les partager =D


Certaines choses sont préciser avant tout :
- La plupart de mes projets ne sont pas vraiment des jeux
- Ils sont TOUS des prototypes, créés avec une vague notion du projet final
- De par leur nature, le degré d'avancement est difficilement calculable
- Si il y a de belles images : Ce ne sont pas les miennes ! Je suis un piètre artiste, c'est ma chérie qui se charge de m'en faire quand elle a le temps


Passons aux choses sérieuses :
J'utilise GMS depuis peu pour mes projets, afin de vous fournir un accès facile aux projets en compilant en html5.
Mes codes sources sont sauvegardés dans un dossier dropbox que j'utilise pour y accéder depuis mes différents PC.
Je les mettrai peut être à disposition si vous êtes sages ! (j'aménagerai certainement une adresse parallèle moins changeante)
Le tout est envoyé sur un site qui, pour l'instant, est hébergé gratuitement chez Fr*e.


L'hébergeur n'est évidemment pas définitif, mais pour l'instant le site n'a pas encore eu assez de succès pour m'imposer de le déménager.
Vous m'excuserez également de sa présentation plutôt... Old School.
Je ne me suis pas encore attardé dessus, mais vu que la magie de GM le permet, je vous ferai peut être une belle page faite avec Game Maker =P


Le site est composé actuellement de 3 parties : Jeux, Prototypes et Simulations

Vous pouvez également télécharger la source de chaque projet en .rar à cette adresse :
https://skydrive.live.com/redir?resid=1FB6F147BE0E2561!108&authkey=!AAysgt8djHeWTuI

Voici une brève description de chaque projet, classés par parties


___________________________________________________________________________________________________________________

BrickBrain : Petit jeu de casse tête
But : Vous devez "manger" toutes les cases pour finir le niveau
Graphiste : Le collègue, qui m'a fournit toutes les images (je ne sais pas s'il les a fait entièrement lui même, mais ça ne m'étonnerait pas), l'idée du jeu est de lui
Commentaire : Les niveaux ne sont pas fait, c'est le collègue (pas pressé) qui doit me les trouver
Adresse : http://hugo.diranzo.free.fr/Jeux/BrickBrain/
___________________________________________________________________________________________________________________


ChocoRun : Jeu d'élevage de chocobo *se cache, de peur que square enix lui demande des comptes*
But : Elever des chocobo, faire des sélections et des reproductions de façon à avoir de meilleurs chocobos
Graphiste : Ma chérie, qui a fait toutes les images du jeu sauf celles des barrières
Avancement : Vu ce que je voudrais en faire, à peu près 1%
A faire : Nouveaux mini-jeux, plus de genes (couleurs, force, endurence, etc), systeme de culture végétale qui influe sur la mutation, et bien d'autres.
Commentaire : Le système des courses n'est pas définitif, pas de système de sauvegarde en html5 (trop complex par rapport aux autres supports)
Adresse : http://hugo.diranzo.free.fr/Jeux/ChocoRun/
___________________________________________________________________________________________________________________


Lolometry Wars : Reproduction du mode Pacific de Geometry Wars (xbox360)
But : Survivre, marquer le plus de points en passant sur des barrières (qui tue les ennemis dans un certain rayon)
Auteur : Moi
Avancement : 90%, c'est un prototype rapide, il faudrait que je change le système de collision et que je peaufine le reste.
Commentaire : Un jeu fait pour ma soeur, qui est une grande fan du jeu sur xbox360
Adresse : http://hugo.diranzo.free.fr/Jeux/LolometryWars/


___________________________________________________________________________________________________________________


Fract2 : Génère des arbres de manière pseudo fractale et de façon paramétrable (ou aléatoire)
But : Aucun
Commentaire : Un vieux projet que j'avais, j'essaierai de l'utiliser pour faire des plantes qui poussent en temps réel, pour une simulation
Adresse : http://hugo.diranzo.free.fr/Prototypes/Fract2/

___________________________________________________________________________________________________________________


CourseChocoRun : Prototype des courses du jeu ChocoRun, tourne en boucle
But : Aucun
Graphiste : Ma chérie
Avancement : 100%
Commentaire : Ce jeu est très grandement inspiré d'un jeu de foire (courses hippiques)
Adresse : http://hugo.diranzo.free.fr/Prototypes/CourseChocorun/
___________________________________________________________________________________________________________________

Subliminal : Affiche des messages subliminaux
But : Aucun
Commentaire : Ne me demandez pas pourquoi j'ai fait ça, je ne saurais pas vous répondre
Adresse : http://hugo.diranzo.free.fr/Prototypes/Subliminal/
___________________________________________________________________________________________________________________


TestIsometie : Un projet que j'ai réalisé pour m'exercer à l'iso
But : Comprendre comment fonctionne l'iso sur GM
Graphiste : Moi ! (faut bien faire des efforts quelque fois)
Commentaire : Je me resservirai sûrement de ce prototype quand je ferai un projet en isométrie
Adresse : http://hugo.diranzo.free.fr/Prototypes/TestIsometrie/


___________________________________________________________________________________________________________________
GoForward : Prototype d'algo génétique où des entités évoluent de manière à se rapprocher géographiquement d'un point fixe
But : M'entrainer aux algo génétiques
Fonctionnement : Les entités ont un séquence génétique qui définit dans quelle direction elles se déplaceront pour chaque sted pendant une période donnée. Chaque gène a 4 états possible (0 à 3), qui correspondent à gauche, droit, bas, haut.
Au bout d'un temps donné, les deux entités qui se sont le plus rapprochées du but sont sauvegardées, toute la population est tuée puis remplacé par 50% d'enfants des deux parents, et 50% d'enfants du plus rapide (parthénogenèse). Les deux types d'enfants ont un degré de mutation paramétrable avec la touche M.
Commentaire : Vous pouvez relancer la simulation avec la touche Espace, et voir les fitness des générations précédentes avec Enter
Adresse : http://hugo.diranzo.free.fr/Simulations/GoForward/
___________________________________________________________________________________________________________________


JumpForYourLife : Prototypes où des entités doivent arriver dans une zone en bout de terrain
But : Entrainement Gènes
Fonctionnement : Chaque entité a un code génétique aléatoire composé une séquence de 0 et 1, il y a 9*room_speed gènes par entité, une pour chaque step du jeu (il faut un peu moins de 9 secondes pour qu'une entité atteigne l'arrivée), après la 9eme seconde, une nouvelle génération aléatoire est produite, et l'ancienne détruite. Pas de reproduction, donc pas d'évolution.
Un gène définit aussi la couleur de chaque instance.
Commentaire : Je n'ajouterai pas de croisements génétiques, car dès qu'une entité arrive à finir la course, on peut considérer qu'elle possède un code génétique optimal vu que toutes les entités vont à la même vitesse.
Adresse : http://hugo.diranzo.free.fr/Simulations/JumpForYourLife/
___________________________________________________________________________________________________________________


RunForYourLife1 : Algo d'apprentissage à la marche ! Ah, non, apprentissage à ramper... (Les joies de l'évolution)
But : Entrainement à la génétique et à la physique avec GMS
Fonctionnement : Chaque entité possède une séquence génétique de longueur (2*room_speed)*nbMuscles.
Un gène a trois valeurs possibles : -1, 0 et 1.
En clair, chaque gène correspond à un ordre donné à un muscle, soit tourner dans un sens, soit tourner dans l'autre, soit pas du tout.
Chaque muscle appelle le gène numéro° Step de la séquence génétique qui dure 2secondes.
Chaque entité possède 4 "muscles", ayant une limite de rotation de 90°.
Chaque "crabe" (oui, ce sont des crabes) a donc un cycle de marche de 2 secondes
Commentaire : Je ne m'attendais pas à ce résultat, certains arrivent à se lever au bout de quelques générations, mais pour cela ils doivent d'abord reculer... Peut être en augmentant le temps de chaque génération ?
Adresse : http://hugo.diranzo.free.fr/Simulations/RunForYourLife1/
___________________________________________________________________________________________________________________


RunForYourLife2 : La même, cette fois ci avec des serpents ! Ah, non, des chenilles... *déprime*
But : Entrainement à la génétique et à la physique avec GMS
Fonctionnement : Exactement le même que pour le 1, sauf les entités qui changent, elles n'ont pas les mêmes proportions, pas les mêmes membres
Commentaire : Et oui, là encore, moi qui m'attendais à avoir des serpents qui font du break dance, je me suis retrouvé avec des chenilles qui rampent aussi normalement que des chenilles peuvent ramper.
Adresse : http://hugo.diranzo.free.fr/Simulations/RunForYourLife2/
___________________________________________________________________________________________________________________



D'autres projets arriveront bien vite !
Comme il n'y a pas d'autre section qui traitent des algo génétiques, vous êtes libre d'en débattre ici =)

A très bientôt, et bon code =D

Sympa tout ça :b
Et ce serait plus propice aux clics si tu mettait quelques screens

Ah, tu as raison, ça fait plus sympa =D

Personne n'a de remarque à me faire ?
Même un "c'est de la ***** ce que tu fais" me serait utile, je cherche juste à savoir ce que différentes personnes peuvent penser de mes petits projets ^^'

Et si vous avez des conseils ou des questions (sur les algo génétiques par exemple), j'y prêterai la plus grande attention =)

A mon avis le plus intéressant dans ce genre de trucs, c'est surtout la source.
Tu devrais poster des bouts de code/algos, c'est plus sur ça qu'on pourrais discuter :b

Perso ça fait plusieurs jours que j'ai pas mis les pieds sur Windows donc je n'ai pas pu tester même si les screens attire pas mal ma curiosité, tu as fait des trucs assez intéressant au niveau algo' et c'est cool, mais comme Oni le dit si bien dans des petits exemples comme ça c'est les sources qui sont à décortiquer et non pas le projet en lui même car il "ne sert à rien" (ce n'est pas péjoratif hein ).

Je vous ai fait un joli dossier sur mon skydrive perso,
Toutes les sources présentées dans ce post seront conservées en .rar à cette adresse :

https://skydrive.live.com/redir?resid=1FB6F147BE0E2561!108&authkey=!AAysgt8djHeWTuI

Par contre, toutes les sources sont au format GMS et je m'en excuse auprès de ceux qui utilisent les autres versions de GM.

Je suis débutant, je ne connais pas bien vos "coutumes", donc n'hésitez pas à me guider ^^

Ah perso je n'ai pas GMS, donc je pourrais pas regarder :s
Ce qui serais intéressant, c'est juste de récupérer les bouts de code "importants" et les mettre, genre par exemple pour les algo génétique l'event step qui gère tout ça.

Pour insérer du code t'as la balise code, mais j'imagine que tu le sais déjà.

tes protos sont très intéressants, et montre d'autres horizons à explorer même avec GM!

mes préférés :le crabe et l’élevage de choccobon!

Par contre les enjeux de tes bestioles virtuelles sont trop obscurs pour apprécier la "beauté" d'un code génétique efficace par rapport au problème qu'il rencontre.

on est spectateur de l’événement sans en comprendre le sens.


un petit élevage de choccobon avec une pincée d'interaction utilisateur ("dressage") par exemple et des course en ligne ça peut faire une appli sympa!

J'avoue que des courses en ligne après ça serait vraiment sympa, mais je ne sais pas encore appliquer les bases de données sur GMS... Ca viendra, mais ça me fait encore peur XD

Et effectivement, il faudrait que je fasse plus d'infos, un tuto au début etc, mais je suis encore dans la phase où je cherche la prochaine idée à incorporer quand j'aurai le temps.
C'est un projet qui me tient beaucoup à coeur, et qui pourrait aller loin je pense si je m'y implique assez.

Tenez, voici le code du moment où les choccobons font des bébés =P

Code:

        global.baby = instance_create(x,y,ob_choco)
        //script_execute(sc_procreation, "gaSpeed", "gpSpeed")
        //Croisement des gènes
        //gaSpeed
        rand = irandom_range(1,2)
        //Sélection du parent pour le Gène gaSpeed
        if rand = 1
            {
            rand = irandom_range(1,2)
            //Sélection du Gène actif ou passif pour l'héritage
            if rand = 1
              {
              global.baby.gaSpeed = global.chocoMate1.gaSpeed
              }
          else
              {
              global.baby.gaSpeed = global.chocoMate1.gpSpeed
              }
          }
        else
          {
            rand = irandom_range(1,2)
            if rand = 1
              {
              global.baby.gaSpeed = global.chocoMate2.gaSpeed
              }
          else
              {
              global.baby.gaSpeed = global.chocoMate2.gpSpeed
              }
          }
        mutation = irandom_range(1,20)
        if mutation = 1
            {
            global.baby.gaSpeed += 1
            }
        if mutation = 2
            {
            global.baby.gaSpeed -= 1
            }
        //gpSpeed
        rand = irandom_range(1,2)
        if rand = 1
            {
            rand = irandom_range(1,2)
            if rand = 1
              {
              global.baby.gpSpeed = global.chocoMate1.gaSpeed
              }
          else
              {
              global.baby.gpSpeed = global.chocoMate1.gpSpeed
              }
          }
        else
          {
            rand = irandom_range(1,2)
            if rand = 1
              {
              global.baby.gpSpeed = global.chocoMate2.gaSpeed
              }
          else
              {
              global.baby.gpSpeed = global.chocoMate2.gpSpeed
              }
          }
        mutation = irandom_range(1,20)
        if mutation = 1
            {
            global.baby.gpSpeed += 1
            }
        if mutation = 2
            {
            global.baby.gpSpeed -= 1
            }
        //Fin du croisement des gènes
        global.baby.mother = global.chocoMate2.name
        global.baby.father = global.chocoMate1.name
        global.chocoMate1 = 0
        global.chocoMate2 = 0

Le jeu est plutôt vieux, et quand je revois le code je me dis que j'avais pas encore toute la méthodologie que j'ai maintenant ^^'
Je m'efforce quand même d'avoir un code lisible et à peu près compréhensible
ici, global.chocoMate1 et 2 contiennent l'id des deux choccobons sélectionnés comme procréateurs (avec le petit coeur)
gaSpeed et gpSpeed représentent les gènes actifs et passifs (seul le gène actif influe sur la vitesse du choco)

Ici, la sélection se fait manuellement, donc pas de fitness à définir, et l'enfant hérite aléatoirement des gènes actifs et passifs des parents, sachant qu'un gène actif peut devenir passif et inversement.

D'ailleurs j'ai une requête : comment alléger le code si je fais plusieurs gènes ? J'avais pensé faire un tableau où mettre tous les gènes et une fonction pour les "mélanger" au moment de la reproduction, mais à l'époque où j'ai essayé j'ai eu du mal à mettre tout ça en place.

Oui pour ce genre de truc t'as tout intérêt a utiliser un tableau, même si avec GM ils sont un peu pourris.
Y a les ds_list sinon qui sont moins limitées.

Tenez, j'ai un nouveau projet "présentable" =)

Je sais qu'il y en a déjà sur le forum, mais voici le mien (je ne me suis pas aidé d'un algo déjà fait)
Un arbre pseudo fractal :



Configurable, vous pouvez aussi centrer la figure et lui donner une répartition moins aléatoire, ça donne ça :


Il y a un mode aléatoire ou manuel pour définir les variables telles que la taille du premier segment, le nombre de branches, et d'autres.

Héhé, sympa :b
Ce que tu pourrais faire vu que t'as l'air de bien aimer l'évolution, c'est un système qui améliore l'arbre en fonction des goûts de l'utilisateur.
Par exemple tu affiche un certain nombre d'arbres a l'écran, l'utilisateur en choisi un (ou plusieurs), et tu essaye de garder cette configuration pour une nouvelle génération d'arbres (avec un peu d'aléatoire), que l'utilisateur sélectionnera a nouveau, etc :b

Mais encore une fois, quand tu fait des trucs, ici on est des dev, donc ce qui nous interesse le plus, c'est le code
En plus si tu fait des conneries on pourras te les faire remarquer, et dans le cas contraire on pourras ptetre même apprendre de nouvelles astuces.

Effectivement je pourrais faire quelque chose comme ça, mais il faudrait un bon nombre de générations avant d'avoir un résultat "joli", sachant que c'est subjectif =P
Je pourrais faire un système de notes, mais on peut difficilement rester constant dans son jugement.
Sinon, faire simplement une génération, un bouton Oui et un Non, et après ça génère le prochain arbre avec les gènes des derniers Oui.
Quelqu'un a une idée ?

mais quelles sont les contraintes (environnementales) qui détermineront l'utilité du code génétique dans cet exemple?

un random orienté aura la même utilité non?

Qu'est ce que tu entends par random orienté ?

Génération procédurale ?

comme dit précédemment de tes expérience je ne vois que le résultat donc pour moi, qui n'y connais pas grands chose de surcroit, je ne vois aucune différence de méthode.

tu peux me dire que tes arbres ont un code génétique et qu'a chaque fois la nouvelle génération d'arbres à un code "amélioré" ,le résultat (c'est a dire l'image que je perçois) ne me parle pas,comme à toi.

ce n'est pas une critique et j'apprécie ce que tu montre.

j'aimerais que tu me montre un exemple ultra simplifié pour comprendre ta démarche.
(avec le code source en gml ,(par pour le voler),pour comprendre )

par exemple deux objets A et B qui se rencontrent et forment un troisième objet avec les caractéristiques "améliorées"(modifiées) ou mutées comme tu voudras

un élevage de choccobon !!!

Bon, moi aussi je me suis un peu amusé avec les algorithmes génétiques, je vous propose de tester une de mes créations : http://www.mediafire.com/download.php?tv16lstn96dno94
Accompagné de quelques screens :

Spoiler:

Spoiler:

Spoiler:

Oh, je vois ce que tu veux dire marty =)
A vrai dire, dans la plupart de mes simulations, la "population", c'est à dire les différents objets que je veux faire évoluer, possède un code génétique... Concrètement, ce que j'appelle un "gène" n'est rien d'autre qu'une variable que j'utilise d'une façon où d'une autre.

L'exemple le plus simple à mon goût c'est GoForward, je m'explique :
Ma population est composée d'objets tous simples, qui ont l'image d'un point.
Chaque objet a des gènes. En l’occurrence, chaque gène correspond à une action pour une step donnée.
Ce gène peut valoir 0, 1, 2 ou 3. (0 pour droite, 1 pour haut, etc)
Je créé autant de gènes que je veux que dure une génération. Par exemple si je veux qu'une génération dure 5secondes, je fais nbGenes = room_speed*5. Ensuite, je créé mes gènes simplement dans un tableau, comme ceci :

Code:

for (i = 0; i <= nbGenes; i +=1)
  {
  gene[i] = irandom(3)
  }

Ceci fait, tu exécute juste le gene[i] à sa step correspondante, la step i. (Il suffit de faire une variable initialisée à zéro dans un create event, puis de l'incrémenter dans l'event step)

Ici, ça donne ça : (event step)

Code:

switch (gene[i])
  {
  case 0 : x += 1
  case 1 : x -= 1
  case 2 : y += 1
  case 3 : y -= 1
  }
i += 1

Donc arrivé là, tu as des instances qui ont un "code génétique" et qui vont se déplacer selon lui. Le code génétique étant aléatoire et au moment de la création, tu as de très fortes chances d'avoir des instances qui ne feront jamais le même trajet dans le même ordre.

C'est là où ça devient intéressant ! Car nous pouvons déterminer quelle instance a été la "meilleure", dans GoForward la meilleure instance est celle qui s'est approchée le plus d'un objet "finish" situé de l'autre coté du parcourt.
Le "score" d'une instance est appelé le Fitness.

Voici le code pour savoir quelle instance a été la meilleure (dans un objet de controle UNIQUE, dans une trigger qui s'active si stepEcoulees = nbGenes. Vous pouvez aussi le mettre dans une step avec un petit if stepEcoulees = nbGenes tout simple) :

Code:

with obj_runner    //Je demande à toutes mes instances de "coureurs" de déterminer leur Fitness (score)
  {
  fitness = -distance_to_object(obj_finish)    //Tout bête, non ? Je retiens sa distance par rapport à l'objet finish
  }

global.first = instance[0].id    // J'initialise mon meilleur score avec l'id de ma première instance d'obj_runner
for (i = 0; i <= nbInstances; i +=1)
  {
  if instance[i].fitness > global.first.fitness  //Je compare avec le "premier" actuel, et prends sa place si a un plus haut Fitness
      {
      global.first = instance[i].id
      }
  }

On a l'id de notre meilleur, c'est cool ! J'en fais quoi maintenant ? Je SAUVEGARDE ses gènes.

Un moyen simple :

Code:

for (i = 0; i <= nbGenes; i += 1)
  {
  global.geneFirst[i] = global.first.gene[i]
  }

Maintenant il est temps de... Tuer tout le monde ! Youpiii =D

Code:

with ob_runner {instance_destroy()}

"Mais, euh, pourquoi tu as tué tout le monde, au fait ?"
Pas que par simple plaisir, je vous rassure, c'est AUSSI pour générer une nouvelle population, de nouveaux individus.
Sauf que cette fois ci, on ne va pas les générer aléatoirement, en tout cas plus entièrement.
On va se servir des gènes du meilleur de la génération précédente pour recréer la nouvelle population !

Et c'est là où est tout l’intérêt, on prend toujours le meilleur.
Et c'est là où il faut commencer à sérieusement ruser...
Exemple : Tu as bien sélectionné le meilleur de ta population ! Malheureusement, ça n'est pas forcément le meilleur de toutes les populations... Des individus différents, il peut y en avoir des milliards, et je peux te dire que la très grande majorité des individus sont... Attardés. Oui, un peu comme dans la vraie vie !

Pour palier à ça et trouver une solution plus vite, on peut ruser de mille et une façons...
La mutation, par exemple, particulièrement utilisée quand on a qu'un seul "meilleur", un seul parent en somme.
Il suffit de changer certains gènes à la création par un bon vieux random.

Code:

for (i = 0; i <= nbGenes; i += 1)
  {
  instance[j].gene[i] = global.geneFirst[i]
  if irandom(mutation) = 0
      {instance[j].gene[i] = irandom(3)}
  }

Encore une autre solution est de prendre les deux meilleurs, et de croiser leurs gènes.

Code:

for (i = 0; i <= nbGenes; i += 1)
  {
  instance[j].gene[i] = choose(global.geneFirst[i],global.geneSecond[i]) //On enregistre geneSecond exactement comme on l'a fait avec geneFirst, en récupérant l'id du deuxieme avec le fitness, puis en copiant les genes
  }

Attention quand même ! Selon comment tu gères ton algo, il est possible (et fort probable) que la plupart des "enfants" d'une instance, même d'un seul parent mais mutant, réalisent un fitness plus faible que celui des/du parents.
Pour ma part, les individus parents sont clonés sans mutation, pour ne pas les perdre à la prochaine génération.

Après, libre à toi de trouver d'autres astuces, des tas de livres et de gens mieux informés que moi y ont pensé ^^

Je tiens à préciser que je n'y connais RIEN en biologie, maths, et sciences en général. J'ai tout expérimenté par moi même, en cassant des oeufs, à l'ancienne. Donc désolé si je n'utilise pas les bons mots, ce sont mes propres mots, et ils ne sont pas forcément pertinents ^^'

Encore une chose, choisir les variables qu'on va prendre en gènes, la façon et le moment de les utiliser, c'est tout un art... Certaines fois c'est tellement simple qu'on n'y pense même pas =)
Et d'autres bien sûr, où c'est beaucoup plus compliqué.

*Pose le pavé sur le forum*

Je vais faire du H.S., mais bon... BONJOUUUUR LE COPAIN DE MAROUUUUU !

Moi j'adore le jeu avec les chocobos, j'ai fait pleiiiin d'oeufs <3

Hs pour moi aussi alors, ma génération 45 fait vraiment le taf là !

Oui il faudrait que je continue le projet des chocobos, même si il va sûrement falloir changer de thème pour pas avoir de problèmes avec Square Enix >.<

Et bonjour madame copine à ma chérie ! (le monde est vraiment trop petit)