Un (autre) jeu de graphe

Code de BGraphe

Licence

Ce code est fourni sous une licence CC-By (cf. fin de page).
De plus, il est interdit de recompiler le jeu directement en supprimant simplement le lien «Plus de jeux», la mention «directement» restant à l'appréciation de l'auteur original du code source.

À propos du code

Le code est réparti en classes claires et nettes.
L'ensemble du fichier représente moins de 10ko !

Structure de l'application

Diagramme de BGraphe

Classe principale B-Graphe

Fichiers de bases :

Code source : Bgraphe.as
  • Langage : actionscript3
  • ΔT : 0.027s
  • Taille :5544 caractères
//Code original par Neamar. Réutilisation libre.
//neamar@neamar.fr

//Ligne de commande pour compiler :
//(après s'être placé dans le bon dossier, cf. http://neamar.fr/Res/Compiler_AS3/)
//
//bash mxmlc Sources/B-graphe/graphe.as -default-size 640 480 -compiler.strict

//Life begins when you can spend your spare time programming instead of
//watching television.
//La classe de base, fort utile !
//Les évenements "de bases", classe dont dérive MouseEvent
//Interaction utilisateur//souris
//Un point tout ce qu'il y a de plus normal : défini par (x,y).
//Champ de texte. Classe assez vaste, utilisée uniquement pour l'affichage de texte ici. Peut être du texte au format HTML.
//Classe globale pour les filtres
//Filtre d'irridescence (éclairage, le plus utilisé)
//Flouter
//Effet de biseau, appliqué sur le "Plus de jeux".
//Prépare une requete pour une page web.
//Chargement d'un fichier normal, et récupère le contenu
//Forcer le chargement du crossdomain.xml
//Execute une requete sans récuperer la réponse du serveur. Assez pratique, l'air de rien.
//Sauvegarde locale sur le PC de l'utilisateur : enregistrement du dernier niveau joué, et des niveaux débloqués.
"640""480"//Quelques paramètres pour la compilation. Ils sont cependant redéfinis dans la ligne de commande, mais laissés ici pour des raisons sentimentales (sic)
//Fond est un Sprite instance de Niveau, qui contient le niveau en cours.
"RC1"//La version
//L'image en fond du player.
//L'enregistrement du niveau en cours, et des niveaux unlockés.
//Un raccourci vers SharedObject.datas
//                      Les constantes primitives utilisées tout au long du Flash
//                      Récuperer les données locales, si elles existent.
"BGraphe"//                     SESSION.NumeroNiveauUnlockes=SESSION.NumeroNiveauActuel=11;
//                      SESSION.NumeroNiveauActuel=SESSION.NumeroNiveauUnlockes=null;
//Création de la sauvegarde.
//Recharger les dernières valeurs
//Commencer au dernier niveau
"../Trace.as""NON FINALISEE""VERSION EN DEVELOPPEMENT""ChangementsNiveaux.as"//Pendant le niveau, teste si il est fini. Prépare le passage à un nouveau niveau, et l'affiche.
"ChargementNiveaux.as"//La liste des niveaux, et les fonctions pour les charger en mémoire.
"Message.as"//La boite de message. Montre un message via la méthode ShowMessage(message:String)
"Persos.as"//Gère l'éditeur de niveau. Code assez simple.

                        //Enregistrer le nouveau joueur :
"http://neamar.fr/Res/BGraphe/Player.php"//Permet de garder des statistiques sur le nombre de joueurs même quand le jeu est hébergé sur un autre site.
//Afficher l'image de fond
//Animation
//charge le niveau de numéro NumeroNiveauActuel.

                        ////////////////////////////////
                        //Les éléments inclassables
                        ////////////////////////////////
//Fonction Utilisée sur tous les sprites de type bouton : ajoute un filtre au Sprite afin de l'illuminer
//Fonction Utilisée sur tous les sprites de type bouton : retire les filtres du Sprite
//Ajoute un filtre de rayonnement à l'objet spécifié
//Télecharger l'image de fond, l'afficher.
                                //Le Img_FondContext  sert à demander le télechargement du fichier crossdomain.xml
"http://neamar.fr/Res/BGraphe/Images/Fond.png"//Et la mettre au dernier plan
//No comment !
Code source : ChangementsNiveaux.as
  • Langage : actionscript3
  • ΔT : 0.013s
  • Taille :3064 caractères
/////////////////////////////////////
//Fonctions utilisées en cours de niveau
/////////////////////////////////////
//Teste si le niveau est terminé
//S'il ne s'agit pas d'un niveau officiel, afficher la boite de dialogue.
        }
}

/////////////////////////////////////
//Fonctions utilisées lors des changements de niveaux
/////////////////////////////////////
//Termine un niveau en affichant la boite de changement
//Débloque un nouveau niveau si le dernier est réussi.
//Réduire
//Si il vient de réussir le niveau sur lequel il était bloqué
//Débloquer un nouveau niveau
//Et enregistrer en local la progression
"Nouveau Niveau débloqué !""<u>Félicitations !</u> Vous avez fini les 12 niveaux proposés par le jeu.<br>Maintenant, pourquoi ne pas tenter votre chance sur le prédecesseur de ce jeu, <a href=\"http://www.neamar.fr/Res/Agraphe/\" target=\"_blank\">AGraphe</a>  (même graphique, mais concept différent) ? Sinon, vous pouvez aussi éteindre votre ordinateur et reprendre une activité normale...<font size=\"-4\">(z'avez pas du boulot à faire ?)</font><br>À la revoyure, Neamar."//C'est la première fois que le jeu est fini :
//Sinon, afficher la boite avec la liste des niveaux.
//Arrête le niveau directement.
"<b>Niveau abandonné !</b>"//Lancer un niveau "quelconque"
//Si Fond a déjà été utilisé, le nettoyer.
//Supprimer le fond blanc
//Repasser la boite de message au premier plan
//Rezoomer
//Le zoom à la souris, disposé sur le stage. (sinon, il faut avoir la souris SUR le niveau I.e sur un noeud ou une arete...ce qui n'est pas pratique)
//Remettre le test de fin de niveau
"<u>Liste des niveaux</u>"
Code source : ChargementNiveaux.as
  • Langage : actionscript3
  • ΔT : 0.021s
  • Taille :8523 caractères
/////////////////////////////////////
//Fonctions de création de niveau
/////////////////////////////////////
//La structure d'enregistrement de niveau est loin d'être optimale : avec du recul, je m'apercois que j'aurais du lui préferer quelque chose de similaire à :
//      1:2,3,4
//      2:3,4
//      J'y aurais gagné en clarté et en concision !
""//La representation interne du niveau
//T comme Tableau
        //Plus court à écrire que new Array() à chaque fois
//Insolemment easy
"<u>Règles de B-graphe : <font size=\"-2\"><i>(partie 1/1)</i></font></u><br>Enlevez tout croisement entre les traits pour passer au niveau suivant.<br>Pour cela, déplacez les ronds à l'aide de la souris."//Très facile (deux figures distinctes)
//Très facile
//Plutot facile
//Facile
//Moyen
//Moyen Dur
"<u>Astuce</u><br>Vous pouvez utiliser la roulette de la souris pour dézoomer le niveau, afin d'y voir plus clair. Attention cependant, seul un faible niveau de recul est permis !"//Dur
//Dur, trois figures distinctes.
//Inspiré par http://pigale.sourceforge.net/images/graphT0.png
//Pas facile, proche du maximum de densité théorique
//Le graphe maximal...à 42 noeuds. Afin de le simplifier dans sa representation, on commence par les noeuds avec le moins d'aretes. De cette façon, on obtient bien trois aretes pour CHAQUE noeud, sauf sur les trois derniers : l'anté pénultième n'en a que deux, l'avant dernier un et le dernier n'a aucune arete propre. On a donc un total de 3*n -6 aretes, ce qui est bien la limite théorique pour un graphe planaire !
"Bienvenue dans le dernier niveau de BGraphe.<br>Ce niveau est spécial : tous les autres niveaux admettaient des solutions multiples. Cette fois, il s'agit du  «graphe maximal mathématique» : le nombre d'arêtes est poussé à son maximum. En conséquent, une seule solution existe <font size=\"-4\">enfin...avec des arêtes droites</font>...pour vous aider, vous pouvez vous renseigner sur le «tapis de triangle» de Sierpinski. Bon courage..."""//Triggeré quand clic sur une des miniatures dans Boite.
//libérer de la mémoire (même si on ne peut s'assurer du passage du garbage collector)
"<u>Chargement en cours</u> (niv. <b>""</b>)"//Charger le level perso
//La fonction principale, qui charge le niveau dans un sprite
//Layer est le Sprite qui doit contenir le niveau
//prend un string en paramètre, le transforme et renvoie un niveau.
"|"",""Ce niveau est <i>à priori</i> irréalisable !"
Code source : Message.as
  • Langage : actionscript3
  • ΔT : 0.032s
  • Taille :9360 caractères

//Déclaration des Sprites
//Remplissage des Sprites
"<u>Liste des niveaux</u>"//Ajout dans Mods
"<li>RESET</li>""<li>Réduire la qualité</li>"//Lien vers http://www.mini-jeu-gratuit.fr/
"<a href=\"http://www.mini-jeu-gratuit.fr/vip/neamar/\" target=\"_blank\">Plus de jeux</a>"// SpriteSponsor.addEventListener(MouseEvent.MOUSE_MOVE,SourisIN);
// SpriteSponsor.addEventListener(MouseEvent.MOUSE_OUT,SourisOUT);
//Instanciateur de TextField
//fonction qui génére un bouton de type "Suivant".
//Affiche un message.
//Cache la boite de messages
//Le niveau est centré, il faut ajouter le paramètre .5 pour obtenir le bon emplacement
//Générer un préview des niveaux
//true indique qu'il ne faut pas afficher les messages;
//LVL_Edit est mis à jour lors du chargement d'un niveau perso
//Retour
//Informations
"Charger le niveau <b>""</b>""Niveau Perso""Dernier niveau débloqué : <b>""</b>""Dernier niveau tenté : <b>""</b>""<font size=\"-7\">{""}</font>""Informations, explications, code source...""<u>À propos...</u><br><li>Jeu réalisé par Neamar en AS3 libre.</li><li>Explications du jeu, dernières mises à jour, code source, aide à la compilation : <a href=\"http://neamar.fr/Res/BGraphe/\" target=\"_blank\">http://neamar.fr/Res/BGraphe (click to go)</a></li>"//Rezoomer
"HIGH""LOW""<li>Augmenter la qualité</li>""HIGH""<li>Réduire la qualité</li>"

Fichiers de mod

Code source : Persos.as
  • Langage : actionscript3
  • ΔT : 0.011s
  • Taille :2816 caractères
//Ajout dans Mods
"<li>Éditeur de niveaux</li>"//Graphismes de la boite
"input"",|0-9""0,1|1,5|5,4|4,0|6,7|7,3|3,2|2,6""<i>(Utilisez la roulette de la souris pour faire défiler le texte)<br><u>Éditeur de niveau</u><br>Un niveau est une simple chaine de caractères.<br>Chaque noeud est affecté d'un numéro. Pour créer un lien marquer Noeud1,Noeud2 : par exemple <b>0,1</b>.<br>Séparez les asociations de noeuds par un pipe (la barre verticale : <b>|</b> (alt-gr + 6)).<br>Exemple : le texte chargé actuellement permet de rejouer le premier niveau.<br>Dernière information : avant chaque lancement, les noeuds sont placés de façon aléatoire sur la surface de jeu : le même niveau peut donc produire plusieurs situations initiales."//Lance le chargement à partir d'un niveau perso.
//Supprimer le fond blanc
//Repasser la boite de message au premier plan
//Rezoomer

        //Repasser la boite de message au premier plan...c'est plus pratique pour la lire :-)
//Mettre à jour la preview

Classes

Code source : Niveau.as
  • Langage : actionscript3
  • ΔT : 0.015s
  • Taille :5436 caractères
//Un niveau standard : contient des liens et des noeuds !
//Interaction utilisateur//souris
//Le niveau de Taille du Fond actuel
//Le niveau final de Taille demandé pour Fond.
//Le rayon du cercle fait par les noeuds lors du chargement du niveau
//Mélange aléatoirement l'ensemble
                        }
                        //Trouver le nombre de noeuds :
//Petite astuce trigonométrique...
//Remarquer qu'on fait < et pas <=, pour contourner l'astuce
                        {//Ajouter le noeud
//Tous les liens sont crées, reste à updater :
//Paramètre forward à false pour passer en O(n) (pas de récursion)
//Renvoie les paramètres du niveau : nombre de noeuds, nombre d'arretes, et Densité
" noeuds, "" liens. Degré : "//Renvoie un indice de difficulté du niveau.
                        //Cet indice est calculé de façon empirique.
//                      //Une méthode alternative qui utilise la classification d'Euler sur la densité maximale des graphes planaires :
//                      100*(1.5*All_Liens.length/All_Noeuds.length + All_Noeuds.length/35 + All_Liens.length/30 + 0.2*(All_Liens.length/2.2 - All_Noeuds.length) - .5*(3*All_Noeuds.length -6-All_Liens.length));
//Renvoie true si aucune collision détectée
//Teste si le niveau est terminé.
                        //S'il l'est, on lance l'auto destruction. On ne renvoie le signal terminé que lorsque tout a été nettoyé.
//Le niveau est terminé, préparer l'auto destruction !
//Arreter le drag
//rendre passif tous les noeuds :
//rend le niveau passif : on ne peut pas cliquer sur les noeuds, et ils ne s'illuminent pas. Cela permet :
//              -De ne pas surharger le processeur d'évenement lrosque tous les niveaux sont affichés
//              -D'éviter de continuer un drag lors d'un changement de zoom (sinon, la souris sort du noeud et on ne peut plus le dédragger)
//L'auto destruction sert à quitter le niveau de façon agréable. Auparavant, dès qu'il était terminé, le nouveau apparaissait. Ce mode n'a pas convaincu les testeurs, d'où l'apparition de l'autodestruction.
//Zoomer // dézoomer sur le niveau
//Redonner de la réactivité au niveau.
Code source : Noeud.as
  • Langage : actionscript3
  • ΔT : 0.016s
  • Taille :5487 caractères
//Un noeud quelconque
//Interaction utilisateur//souris
//      import flash.utils.getTimer;
//La valeur de rayonnement désirée
//Le rayonnement actuel du noeud
//Le conteneur
//Evite d'avoir à recréer le filtre en permanence. En plus on utilise static ce qui allège la consommation de mémoire : les filtres ne sont crées qu'une fois au démarrage de l'application, pas à chaque instanciation de noeud.
//Même raison,
//Instancie un nouveau noeud
//Plus il y a de noeuds, plus le dessin est petit. Mais on impose une taille minimum !
//Empeche toute action sur le noeud
//                              this.Dragger();
//Simuler une sortie de souris, pour supprimer le drag et les filtres.
//Remettre les évenements souris.
//Fonctions privées
//MAJ des collisions
//Dragger : supprimer les évenements obsolets, ajouter les nouveaux.
//Quand on dragge trop vite, l'évenenement se déclenche et les filtres font du yoyo.
//                      DerniereAction=0;
//En cas de drag rapide, il peut y avoir décalage : avec cette instruction, on met à jour de façon sûre.
//Ajoute un flou à la forme.
//Il y a un facteur 2 entre ce qui est demandé et ce qui est dessiné
//Ajoute un filtre indiquant que la forme est hoverée
//Ajoute un filtre indiquant que la forme n'est plus hoverée
//gestion des filtres dans le temps

                        //Filtre HOVER
//Enlever l'évenement afin de décharger la mémoire.
Code source : Arc.as
  • Langage : actionscript3
  • ΔT : 0.014s
  • Taille :6093 caractères
//Un lien (arete, arc...peut importe le nom !)
//Extremites contient les noeuds parents
//la representation graphique de l'arc :
//Depart est l'emplacement du premier parent, avec un peu de trigonométrie...cf. plus bas
//idem
//l'angle entre les deux noeuds.

                //Les informations associées :
//Instancie un nouveau lien : prend en paramètre le conteneur et les extremités.
//garder en mémoire qu'il ne s'agit que d'une copie par référence : la mise à jour de l'un agit sur le second et vice versa.
//Redessine entièrement le lien. Cette méthode est utilisée lorsque l'un des noeuds se déplace||est déplacé
                        //Met aussi à jour la liste des collisions.
//On est obligé de ruser, sinon tous les liens d'un même noeud seraient considérés commme intersectant (ils auraient le centre du noeud en point de collision)/
                        //La ruse consiste à placer les points AUTOUR du centre, à "Rayon" de distance : ainsi, il n'y a plus de points communs. Le problème, c'est qu'on laisse ouvert le point central...en zoomant, on peut donc tricher. (dans certains cas, pas tout le temps !)
//Pour l'arrivée : en théorie :
                        //this.Extremites[1].x+Rayon*Math.cos(this.Angle+Math.PI),
                        //this.Extremites[1].y+Rayon*Math.sin(this.Angle+Math.PI) mais cos(x+pi)=-cos(pi) et sin(x+pi)=-sin(pi)
//Met à jour la liste des collisions.
                //Le paramètre Forward indique si les messages doivent se transmettre : par exemple, si une arete A a une collision avec B, qu'on la déplace de façon à enlever la collision, A demandera à B de mettre à jour sa liste de collisions, sauf si Forward vaut false.
//                      var Filtres:Array=new Array();
//                      var DegreCollision:int=CollisionAvec.length;
//                      if(DegreCollision!=0)//on pourrait aussi utiliser la méthode this.Collusion mais on cherche à faire le moins de calculs possibles, cette méthode étant souvent utilisée.
//                              Filtres.push(new GlowFilter(0xFF0000, 0.8,5,5,DegreCollision,1,false,false));
//
//                      this.filters=Filtres;
//on pourrait aussi utiliser la méthode this.Collusion mais on cherche à faire le moins de calculs possibles, cette méthode étant souvent utilisée.
//on effectue plusieurs tests, du moins lent au plus lent.
                //(fonction appelée via Array*.filter)
//Il y a une collision de moins !
                                //Demander la MAJ du trait, puisqu'il est peut être libre maintenant :
//Pas besoin de re-forwarder le message
//Renvoie true si une intersection existe entre les deux segments.
// Pas d'interesection
// Intersection en dehors du segment [AB]
//                      this.graphics.clear();
// Pas d'interesection
// Intersection en dehors du segment [CD]

                        //Si on est encore là, il y a intersection...
//Renvoie l'angle entre les extremités.
                //Rien que des maths !
Auteur
Neamar
Date
Aout 2008
But
Finir le jeu
Voir aussi
Compiler l'AS3
Retour
Retour à BGraphe
Menu
Index des ressources

Chargement du sommaire...