Spécifications techniques Hellobounces

Dossier des spécifications techniques LISI L3 PSM – Yoann PIERRE et Aurélien BAHRI – Version 2 ion 2

Liste des fonctions

Fonctions du jeu

Fonction Détail de la fonction Réalisée à ce jour

Commandes générales

Choix du niveau L’utilisateur sélectionne le niveau de difficulté du jeu. Réalisée

Charger le monde

Cette fonction appelle toutes les fonctions nécessaires au fonctionnement du jeu. Une fois cette fonction terminée,

le joueur n’a plus qu’à appuyer sur START pour

commencer à jouer.

Réalisée

Démarrer le jeu Cette fonction lance le jeu

quand l’utilisateur appui sur le bouton START

Réalisée

Création et initialisation du plateau de jeu

Créer le monde

Cette fonction crée un tableau vide. Elle met chaque case à l’état

« neutre ».

Réalisée

Placement des obstacles Place les obstacles dans les cases indiquées. Réalisée

Placement entrée(s)/sortie(s)

Place les entrées et les sorties dans les cases du

tableau en fonction du niveau de difficulté

sélectionné.

Réalisée

Création de la feuille de dessin

Cette fonction va créer la feuille ou l’utilisateur pourra dessiner dessus. On définit

aussi le style de trait

Réalisée

(épaisseur du trait, couleurs…etc).

Fonctions pour chaque obstacle particulier

Exemple : obstacles qui freine ou accélère l’avatar, obstacles qui disparaissent

et réapparaissent à intervalle régulier…etc.

A imaginer et créer

Affichage image de fond du monde

Affiche une image de fond en fonction du monde Réalisée

Affiche le Monde Correspond à afficher les

cases contenant un obstacle ou autres (case = ! vide_mc)

Réalisée

l’avatar

Création de l’avatar Insérer dans la scène, le movieClip de l’avatar Réalisée

Positionnement initial de l’avatar

Positionne l’avatar aux coordonnées x et y de

l’entrée Réalisée

Tuer l’avatar

Si l’avatar dépasse un certain seuil (c’est-à-dire, s’il

tombe dans le « vide »), il « meurt ». On arrête alors le jeu, puis on replace l’avatar à

l’entrée.

Réalisée

Rebond de l’avatar

Définie le comportement de l’avatar (gravité, rebond,

taille…). Son comportement peut varier en fonction du

niveau de difficulté sélectionné.

Réalisée

Déplacement de la « caméra » en fonction de

l’avatar

Déplacement de l’ensemble des éléments du jeu pour

donner l’illusion d’un déplacement de caméra.

Réalisée

contrôle de l’utilisateur

Tracer un trait

Fonction qui permet à l’utilisateur de tracer des segments qui permettront d’orienter les rebonds de

l’avatar.

Réalisée

Chemin automatique Fonction qui trace automatiquement le chemin. Réalisée

Fonction de l’éditeur de niveau

(A définir suivant le temps restant)

Fonction Détail de la fonction

Réalisée / à réaliser

Commandes générales

Fonction : Choix du niveau // Début fonction ChoixNiveau (D : niveauDifficulte, D : monde)

// Déclaration de variables

D : niveauDifficulte : entier (=1)

D : monde : entier (=1)

// On demande à l’utilisateur quel niveau il a : facile (1), moyen (2) ou difficile (3) et on l’injecte dans la variable

niveauDifficulte donnée utilisateur

// Appel de la fonction de chargement du monde

ChargerMonde (D : niveauDifficulte, D : monde)

// Fin de la fonction

Fonction : Chargement du monde // Début fonction ChargerMonde (D : niveauDifficulte, D : monde)

// Déclaration de variable

Donnée : niveauDifficulte : entier (=1)

Donnée / Résultat : monde : entier

// On lance la création du monde

CreerMonde ()

// On lance le placement d’obstacles

PlacementObstacles (D : monde)

// On lance la création de l’entrée et de la sortie

PlacementEntreeSortie (D : niveauDifficulte)

// On crée la feuille de dessin

CreerFeuille (D : feuille feuille_mc)

// On lance l’affichage du fond

AffichageFond (D : monde)

// On lance l’affichage du monde

AffichageMonde ()

// On crée l’avatar

CreerAvatar ()

// On place l’avatar

PlacerAvatar ()

// On démarre le jeu

DemarrerJeu (D : start = false, D/R : premierDeplacement, D/R : coteGMonde, D : monde, D : niveauDifficulte)


Fonction : Démarrer le jeu // Début fonction DemarrerJeu (D : start = false, D/R : premierDeplacement, D/R : coteGMonde)


D / R : start : booléan (=false)

D / R : premierDeplacement : booléan (=true)

D / R : coteGMonde : entier (=0) // coordonnée du bord gauche de la zone de jeu par rapport au Monde

D : monde

D : niveauDifficulte

start : booléan

automatique : booléan

// Si le joueur appuie sur le bouton démarrer

Si l’utilisateur clique sur le bouton démarrer alors

start égal à vrai

Fin si // le joueur n’a pas appuyé sur le bouton start

// Si le joueur appuie sur le bouton automatique

Si l’utilisateur clique sur le bouton automatique alors

automatique égal à vrai

Fin si // le joueur n’a pas appuyé sur le bouton automatique

// Si l’utilisateur à cliquer sur le bouton start

Si le bouton start est vrai alors

// Si l’avatar n’est pas sur la sortie

Si l’avatar ne touche pas sortie_mc faire

Pour chaque période faire // correspondant à l’enterFrame en Action Script

// On lance la fonction pour que l’utilisateur trace un trait

Trace ()

// On lance la fonction rebond pour l’avatar

Rebondir ()

// On lance la fonction pour le déplacement de la caméra

deplaceCamera (D/R : premierDeplacement, D/R : coteGMonde)

Fin pour

Sinon l’avatar touche la sortie_mc alors faire // l’utilisateur à fini le niveau

ChargerMonde (D : niveauDifficulte, D : (monde+1)) // on charge le monde suivant

Fin si

Sinon // Si le bouton start est faux

Si le bouton automatique est vrai

// On lance le traçage automatique des traits

chargeCheminAutomatique () ;

// On lance la fonction rebond pour l’avatar

Rebondir ()

// On lance la fonction pour le déplacement de la caméra

deplaceCamera (D/R : premierDeplacement, D/R : coteGMonde)

Fin si

Fin si


Création et initialisation du plateau de jeu

Fonction : Créer le monde

Categorie correspond à un movieClip dans la bibliothèque flash de différents types possibles : carre_mc, triangle_mc, arc_mc, sortie_mc, etc… ils seront des obstacles pour l’avatar !

// Déclaration de variable

TYPE colonne (c1, c2, …, c100);

TYPE ligne (l1, l2, …, l7) ;

TYPE t_categorie (vide, obst_carre, obst_triangle2, etc…) ; // tous les movieClips (obstacles, etc…)

TYPE t_image (obstacle1_img1.jpg, obstacle3_img2.jpg, etc…) ; // toutes les images pour les éléments

TYPE t_sons (obstacle_sons1.mp3, obstacle_sons2.mp3, etc…) ; // tous les sons pour les éléments

TYPE P_CART Case (categorie : t_categorie, coord_x : entier, coord_y : entier, image : t_image, sons : t_sons);

Monde : TABLEAU (colonne, ligne) de Case ;

// Début fonction de CreerMonde ()


i : entier (=0)

j : entier (=0)

x : entier (=0)

y : entier (=0)

// Boucle pour chaque ligne et pour chaque colonne

Pour tous éléments appartenant à ligne faire (i = 1 à i = 7)

Pour tous éléments appartenant à colonne faire (j = 1 à j = 100)

// On crée un produit cartésien de type P_CART Case dans chaque case

Monde [c’j’, l’i’].case : Case < ‘vide’, ‘x’, ‘y’, ‘vide.png’, ‘’ >

Incrémentation de x par 70 // pour définir les coordonnées en x de la case

Fin pour

Incrémentation de y par 70 // pour définir les coordonnées en y de chaque case

Fin pour


Fonction : Placement des obstacles

// Début de la fonction PlacementObstacles (D : monde)


Donnée : monde : entier

// Placement des obstacles à partir d’un fichier XML

Pour chaque balise <obstacle> du XML dans <monde> (envoyé en paramètre)

// Récupère la ligne et la colonne dans le XML pour monde et le movieClip pour categorie

Récupérer Monde [<colonne>, <ligne>].Case [categorie] = <categorie>

// Récupère la ligne et la colonne dans le XML pour monde et le movieClip pour image

Récupérer Monde [<colonne>, <ligne>].Case [image] = <image>

// Récupère la ligne et la colonne dans le XML pour monde et le movieClip pour sons

Récupérer Monde [<colonne>, <ligne>].Case [sons] = <sons>

Fin pour


Fonction : Placement entrée / sortie

niveauDifficulte =1

niveauDifficulte =2

niveauDifficulte =3

Positionnement de l’entrée en fonction du niveau de difficulté

Plus le niveau de difficulté sera élevé plus l’entrée sera positionnée en bas du tableau.

Plus le niveau de difficulté sera élevé plus la sortie sera positionnée en haut du tableau.

Positionnement de la sortie en fonction du niveau de difficulté

niveauDifficulte =2

niveauDifficulte =1

niveauDifficulte =3

// Début de la fonction PlacementEntreeSortie (D : niveauDifficulte)

Donnée : niveauDifficulte : entier


ligneAleatoire : entier

// Si le niveau est facile

Si niveauDifficulte = 1 alors faire

// On place l’entrée dans la première colonne et sur la ligne 1 ou 2 définie par une variable aléatoire

ligneAleatoire = valeur aléatoire comprise entre 1 et 2

Monde [c1, l(ligneAleatoire)].Case [categorie] = entree

// On place la sortie dans la dernière colonne et sur la ligne 5 ou 6. Ceci est également défini par la variable aléatoire


Monde [c700,l(ligneAleatoire)].Case [categorie] = sortie

// Si le niveau est moyen et qu’il n’est pas facile

Sinon si niveauDifficulte = 2 alors faire





Le joueur sélectionne le niveau de difficulté avant de lancer une partie. Le niveau influence le placement de l’entrée et de la sortie. Plus le niveau sera élevée plus l’entrée et les sorties seront difficiles d’accès.



// Si le niveau est difficile et qu’il n’est ni facile ni moyen

Sinon niveauDifficulte = 3 alors faire







Fin si

// Fin fonction

Fonction : Création de la feuille de dessin

// Début fonction CreerFeuille ()

// Création du movieClip dans le movieClip monde_mc

Création du movieClip vide : feuille_mc, dans monde_mc

// Définir le style du trait qui sera tracé

Dans Feuille_mc définir trait tracé comme épais de 10 pixel et de couleur noir

// Fin fonction

Fonction : Affichage de l’image de fond

// Début fonction AffichageFond (D : monde)



// Création du movieClip

Création du movieClip vide : fond_mc, dans la scène

Coordonnées x et y du movieClip fond_mc égal à 0

// Placement de l’image de fond à partir d’un fichier XML

Chercher la balise <monde> dans le XML où elle est égale à la variable monde

Récupérer la balise <fondMonde> contenant un nom d’image dans la balise <monde> correspondant

Mettre dans fond_mc

// Fin fonction

Fonction : Affiche le Monde

// Début fonction AffichageMonde ()

// Déclaration de variables (locales)

i, j, k : entier (=0)

// Création d’un nouveau movieClip contenant les images des cases

Création du movieClip vide : fondCases_mc, dans la scène

// On parcourt chaque case du tableau Monde en regardant si la case est vide ou si il y a un obstacle

// Boucle pour chaque ligne et pour chaque colonne

Pour tous éléments appartenant à ligne faire (i = 1 à i = 7)

Pour tous éléments appartenant à colonne faire (j = 1 à j = 100)

Si Monde [c’j’, l’i’].case [categorie] différent de vide // si la case contient un obstacle ou autres

// Création d’une occurrence de la categorie spécifiée, incrémentée de k pour ne pas avoir de doublon

Création de l’occurrence Monde [c’j’, l’i’].case [categorie] : Monde [c’j’, l’i’].case [categorie]k_mc

// Affectation des coordonnées

Coordonnées x du movieClip Monde [c’j’, l’i’].case [categorie]k_mc égal à Monde [c’j’, l’i’].case [coord_x]

Coordonnées y du movieClip Monde [c’j’, l’i’].case [categorie]k_mc égal à Monde [c’j’, l’i’].case [coord_y]

// Ajout et placement de l’image dans le movieClip fondCases_mc

Mettre dans fondCases_mc l’image Monde [c’j’, l’i’].case [image] à la position Monde [c’j’, l’i’].case [coord_x] et Monde [c’j’, l’i’].case [coord_y]

// Ajout du son dans le movieClip propre à la case

Mettre dans Monde [c’j’, l’i’].case [categorie]k_mc le son Monde [c’j’, l’i’].case [son]

// Incrémentation de k

k k + 1

Fin si // Sinon la catégorie de la case est vide

Fin pour

Fin pour

// Fin fonction

L’avatar

Fonction : Création de l’avatar L’avatar est un movieClip existant dans la bibliothèque…

// Début de la fonction CreerAvatar ()

// Création d’une occurrence de l’avatar

Création de l’occurrence de avatar : avatar_mc

// Fin fonction

Fonction : Positionnement initial de l’avatar

// Début de la fonction PlacerAvatar ()

// Placement de l’avatar au centre de la case par rapport aux coordonnées x et y de l’entrée

// lire les coordonnées en x de entree_mc et les affecter à l’avatar

x de avatar = x de entree plus 35 // largeur de la case divisée par deux

// lire les coordonnées en y de entree_mc et les affecter à l’avatar

y de avatar = y de entree moins 35 // hauteur de la case divisée par deux

// Fin fonction

Fonction : Tuer l’avatar

// Début de la fonction TuerAvatar ()

// Si l’avatar est trop bas: plus bas que la zone de jeu…

Si la coordonnée en y de avatar_mc est supérieur à 500 px alors

placerAvatar ()

DemarrerJeu (D : start = false)

// Fin fonction

Fonction : l’avatar rebondi

// Début de la fonction rebondir (fonction rédigée à partir d’un exemple !)

// Déclaration des variables

D/R : avatar_yspeed : entier (=0) // vitesse de déplacement en y de l’avatar

D/R : avatar_xspeed : entier (=0) // vitesse de déplacement en x de l’avatar

D/R : gravite : entier (=0.2) // représente la gravité, c’est un coefficient

D/R : radius : entier (=5) // diamètre de l’avatar pris en compte

D/R : friction : entier (=0.90) // coefficient de friction

D/R : precision : entier (=360) // précision des calculs entre l’avatar et les obstacles

D/R : pause : booléan (=false) // vrai : le jeu est pause et faux : le jeu est arrêté

collisions : entier (=0) // nombre de collisions compté lors des tests

i : entier (=0) // pour incrémenter une boucle

marge_x : entier (=0) // marge de la position en x de l’avatar en fonction de la précision

marge_y : entier (=0) // marge de la position en y de l’avatar en fonction de la précision

maxPos_x : entier (=0) // position en x maximal la plus proche de l’avatar lors d’une collision

maxPos_y : entier (=0) // position en y maximal la plus proche de l’avatar lors d’une collision

avatar_dir : entier (=0) // correspond à la direction de la balle

avatar_cont_x : entier (=0) // uniquement le contour de sécurité en x

avatar_cont_y : entier (=0) // uniquement le contour de sécurité en y

avatar_ang_coll : entier (=0) // angle de collision de l’avatar

sol_rotation : entier (=0) // angle au sol

angle_rebond : entier (=0) // angle de rebond

vitesse : entier (=0) // vitesse de l’avatar

avatar_old_x : entier (=0) // ancienne valeur de x pour l’avatar

avatar_old_y : entier (=0) // ancienne valeur de y pour l’avatar

// Si le jeu n’est pas en pause faire

Si pause est égal à faux alors

Collisions égal à 0

maxPos_x égal à 0

maxPos_y égal à 0

Avatar_yspeed égal à avatar_yspeed + gravite

// suivant la precision on va affiner la marge

Pour i de 1 à precision faire i + 1

marge_x égal à avatar_x+radius*Sinus de (i*360/precision)

marge_y égal à avatar_y+radius*Sinus de (i*360/precision)

// Si il y a une collision entre le monde et l’avatar

Si monde_mc touche la marge

On incrémente collisions

// On définit les coordonnées max de l’avatar

maxPos_x égal à marge_x

maxPos_y égal à marge_y

Fin si

Fin Pour

// Si l’avatar touche un obstacle

Si collisions est supérieur à 0

// définir la direction de l’angle de l’avatar à partir de sa vitesse

Avatar_dir égal à l’arc tangente de (avatar_yspeed/(avatar_xspeed*-1))/(PI/180)

// en fonction du déplacement de l’avatar on agit sur sa direction

Si avatar_xspeed * -1 est inférieur à 0 alors

Ajouter 180 à avatar_dir

ou si avatar_xspeed * -1 est supérieur ou égal à 0 et que avatar_yspeed est inférieur à 0 alors

Ajouter 360 à avatar_dir

Fin si

Marge_x égal à maxPos_x / collisions

Marge_y égal à maxPos_y / collisions

avatar_cont_x égal à marge_x - avatar_x

avatar_cont_y égal à marge_y - avatar_y

// Déterminer l’angle de collision de l’avatar

avatar_ang_coll égal à l’arc tangente (avatar_cont_y / avatar_cont_x) / (PI / 180)

// En fonction du contour de sécurité on ajuste l’angle de collision de l’avatar

Si avatar_cont_x est inférieur à 0 alors

Ajouter 180 à avatar_ang_coll

Ou si avatar_cont_x est supérieur ou égal à 0 et que avatar_cont_y est inférieur à 0 alors

Ajouter 360 à avatar_ang_coll

Fin si

// À partir de l’angle de collision, on détermine l’angle au sol

Sol_rotation égal à avatar_ang_coll - 90

Si sol_rotation est inférieur à 0 alors

Ajouter 180 à sol_rotation

Fin si

Angle_rebond égal à 180 - avatar_dir – 2 * sol_rotation

Si angle_rebond est inférieur à 0 alors

Ajouter 360 à angle_rebond

Fin si

// On ajuste la vitesse de l’avatar

Vitesse égal à la racine carré de ((avatar_yspeed* avatar_yspeed)+( avatar_xspeed* avatar_xspeed))

Avatar_xspeed égal à speed * cosinus de (angle_rebond * PI / 180) * friction

Avatar_yspeed égal à speed * sinus de (angle_rebond * PI / 180) * -1 * friction

// On replace l’avatar sur l’ancienne coordonnées sans rebond

avatar_x égal à avatar_old_x

avatar_y égal à avatar_old_y

// Si l’avatar ne touche pas d’obstacle

Sinon collision est inférieure à 0 alors

// On donne la position de l’avatar comme position « sur » (sans rebond)

avatar_old_x égal à avatar_x

avatar_old_y égal à avatar_y

Fin si

// On donne les nouvelles coordonnées à l’avatar

avatar_x égal à avatar_x + avatar_xspeed

avatar_y égal à avatar_y + avatar_yspeed

Fin si // sinon le jeu est en pause

// Fin fonction

Fonction : déplacement de la caméra

// Début de la fonction deplaceCamera


D/R : premierDeplacement : booléan (=true)

D/R : coteGMonde : entier (=0) // coordonnée du bord gauche de la zone de jeu par rapport au Monde

avatar_x : entier

// Si l’avatar est un peu plus loin que le milieu de l’écran (le sens de déplacement étant de la gauche vers la droite)

Si avatar_x est supérieur ou égal au coteGMonde + 400 px alors

// Faire suivre la caméra, c’est-à-dire déplacer tout le Monde sur la gauche par rapport au déplacement effectué de l’avatar

X de Monde_mc X de Monde_mc - (Avatar_x - (coteGMonde+400))

// Nouvelle valeur du coté gauche de la zone de jeu

coteGMonde Avatar_x - (coteGMonde+400)

// premierDeplacement est mis à faux puisque l’avatar est au centre

premierDeplacement égal à faux

Fin si

// Sinon l’avatar est un peu moins loin que le milieu de l’écran

Si avatar_x est inférieur ou égal au coté gauche + 300 px alors

// Si l’avatar n’a pas été une fois au centre alors ne rien faire

Si premierDeplacement est faux alors

// Faire suivre la caméra, c’est-à-dire déplacer tout le Monde sur la droite par rapport au déplacement effectué de l’avatar

X de Monde_mc X de Monde_mc + (Avatar_x - (coteGMonde+300))

// Nouvelle valeur du coté gauche de la zone de jeu

coteGMonde Avatar_x - (coteGMonde+300)

Fin si // Sinon premierDeplacement est vrai alors rien faire

Fin si // sinon l’avatar est au centre de l’écran entre 300 et 400px par rapport à coteGMonde

// Fin fonction

Contrôle de l’utilisateur

Fonction : tracer un trait

// Début de la fonction tracer (D : feuille : chaine de caractère)

// Déclaration de variables (locales)

D : feuille // on appel la feuille ou on va dessiner

dessinEnCours : booléan (=faux)

// Dessiner si le clic gauche de la souris est enfoncé ou pas

Si le bouton de la souris est enfoncé alors

Si la variable dessinEnCours est faux alors

// Ne pas dessiner si la souris est sur l’avatar ou sur un obstacle

Si la souris ne touche pas avatar_mc ou monde_mc alors

A chaque instant, dans feuille, dessiner les mouvements de la souris à l’aide de…

…ses coordonnées x et y // un instant correspond à une frame en flash

DessinEnCours vrai

Fin si // sinon la souris touche un obstacle ou l’avatar

Fin si // Sinon la variable dessinEncours est vrai

Sinon le clic gauche de la souris est relâché alors

Arrêter de dessiner les mouvements de la souris

dessinEnCours faux

Fin si

// Fin fonction

Fonction : chemin automatique

// Début de la fonction chargeCheminAutomatique (D : monde : entier)



// Traçage des traits à partir du fichier XML

Pour chaque balise <trait> dans <automatique> dans <monde> (envoyé en paramètre) du XML

// Se déplacer aux coordonnées x1 et y1 récupérer

Placement aux coordonnées <x1> et <y1> dans feuille_mc // utilisation de moveto en AS

// Tracer jusqu’aux coordonnées x2 et y2 récupérer

Dessiner le trait jusqu’aux coordonnées <x2> et <y2> // utilisation de lineto en AS

Fin pour


Spécifications techniques Hellobounces

Documents

Transcript of Spécifications techniques Hellobounces