Bonsoir

J´ai deux où trois questions sur la programation.
Jusqu´a présent j´avait cru comprendre l´utilité des tableaux mais, maintenant, je me demande si j´ai bien saisi!! Qu´apporte un tableau?? Faire une liste de 50 variable ayant un nom distinct n´est t-il pas plus pratique??

Ensuite je voudrais vérifier si je comprend bien;
Alors une "fonction" c´est un bout de code que l´on peu rappelé? En gros celà évite de réécrire une truc a chaque fois, c´est çà?

Puis un "objet" c´est une sorte de boîte qui contient plusieurs fonction, c´est ça??

Pour finir une fois la partie papier d´un jeu terminer par quoi commencer? Au niveau programation je veux dire.
Par quoi commencer vous?

ps: heu si vous pouviez m´xpliquer comme si j´avais 6 ans...lol...

un tableau n´est pas comme une liste de variable car il peut avoir plusieurs dimensions. Prenons un exemple concret, un emploi du temps de ce type :
http://edt.essi.fr/

Il ya une dimension "heure de la journée" et une dimension "journée", il ya donc deux dimensions. On dira donc par exemple : "lundi à 8h".

Admettons que tu veuille transcrire ce tableau dans ton prog, tu aura une table de la forme "edt[jour][heure]". Si tu veux connaitre l´activité du "lundi à 8h", tu ecrira un truc du genre "activite = edt[lundi][8] ;"

Après rien ne t´empèche de créer un tableau à 3 dimensions (pour y stocker par exemple des coordonnées de type x:y:z), mais aussi à 12 dimensions voir plus si ça te chante et si ça t´est utile (et si tu n´as pas peur de devenir dingue lol)

Pour la fonction tu as raison, mais ça ne se limite pas à ça. Par exemple une fonction peut s´appeler elle-même, on dira alors qu´elle est récursive ; ça a des tas d´applications.

Pour le reste je vais passer mon tour !

merci bcp.

Mais, faire une variable "lundi à 5 heure" ça reviens pas au même?? S
Si je prend un tableau de 2*5, soit 10 cases, crée 10 variable n´est pas la même choses en mieux!!
Dans un tableau pour desugner la première case on disigne [0,0] ce qui est moin parlant qu´une variable appellé "case1=", non??

en effet mais si tu as un tableau de 100x256 cases c´est bien plus comode que 25600 variables ! de plus avec un tableau tu peux par utiliser des variables pour appeler une case précise.
Par exemple, un prompt demande à l´utilisateur quelles cases il veut regarder et stocke les 2 valeurs dans les variables x et y. Il suffit ensuite de demander la valeur de "tableau[x][y]" pour obtenir la valeur souhaitée ! tu peux également afficher la case suivante simplement par "tableau[x][y+1]". C´est vraiment très utile !
tu peux ainsi parcourir toutes les cases d´un tableau grace à une boucle, par exemple pour tester si certaines valeurs répondent à une condition

Pour l´utilité des tableaux, je pense qu´un exemple t´éclairera mieux :

imagine que tu fasses un jeu style beat´em all :
tu as des gars dans la rue qui viennent frapper ton perso.
Quand tu donnes un coup, tu dois vérifier si ton coup frappe un gars : pour cela, pas d´autres solutions [...] que de regarder si ça touche l´ennemi 1, puis l´ennemi 2, puis l´ennemi 3, etc...

2 façons :
sans tableau :

if (collision(player,ennemi1)) {...}
if (collision(player,ennemi2)) {...}
if (collision(player,ennemi3)) {...}
...
if (collision(player,ennemiN)) {...}

Imagine que tu aies 200 gars (comme Brule Lee) qui viennent sur ton bonhomme, tu faits 200 lignes de copier coller ?

Astuce donc : tu fais un tableau d´ennemis et tu dis :

int i;
for(i=0;i<nombre_max_ennemis;i++)
{
if (collistion(player,ennemi[i]) {...}
}

autrement plus compact
Tout est une question d´organisation en mémoire...

tu remarqueras la fonction "collision" que j´ai créé pour l´exemple : sans l´implémenter, je définis que cette fonction renverra vrai ou faux selon que les 2 personnages passés en parametres se touchent ou non ...

Les fonctions permettent au programme d´etre lisible, car on comprend aisément, dans l´exemple, qu´on teste une collision en écrivant texto : if(collision .... )

Les tableau peuvent te permettre aussi de te positionner de maniere geographique.

Imagine un terrain de 100x100 chacune de ces case contenant une valeur de hauteur.

Pour connaitre la hauteur a laquelle tu te trouve c´est tres simple.
si tu es a 30 unité en x et a 50 en z (oui y est la heuteur) tu as juste a recuperer la valeur Map[posZ*nb_point_x+posX] dans le cas d´un tableau a une dimension qui emule un tableau a deux.
Map[posX][posZ] pour un tableau a deux dimension.

haaaaaa j´ai compris
LOl, effectivement avec l´exemple de jean yves yves ça rentre.
Je voyais pas l´utilité du tableau dans le sens ou si il faisait 100 cases, je devrais quand même entrer 100 valeur!
En faite si on depard y´a pas de différence (faire 100 variables où entré 100 valeurs c´est kifkif...), c´est par la suite que sont utilité devient évidente!! (l´exemple de jean).

Merci!

Autrement pour les objets j´ai juste?
Et pour le comencement dans une prog de jeu?

Pour les objets c´est un peu compliqué...

Un objet est une instance d´une classe.

Une classe, c´est un peu le CONCEPT de quelquechose. Tu veux représenter cette chose dans un programme et tu vas définir une classe qui comporte des fonctions et des variables. Une classe régit tout ce que ta chose peut ou ne aps faire, tout ce qu´elle est.

Disons que tu crée un jeu sur le monde animal.

Tu crée une classe Animal, qui sera composé des variables suivantes : nombre_de_patte, milieu_naturel, type_de_nourriture ; et des fonctions suivantes : marche(), mange(), crie()

Un Objet de la classe Animal sera par exemple l´objet Girafe(nombre_de_pattes=4 ; milieu_naturel=savane ; nourriture = herbivore)

un autre objet, Canard(nombre_de_pattes = 2 ; milieu_naturel = rivière ; nourriture = carnivore)

Bon là où ça devient intéressant, c´est que les classes peuvent se décliner en "sous-classes", ou classes filles, qui héritent des propriétés de leur classe mère.

Ainsi tu peux créer une classe fille qui hérite des propriétés de Girafe, mais permet de définir plusieurs girafes différentes, en ajoutant par exemple des variables comme Taille, Age, Sexe, Identifiant...

Ainsi la girafe n°3 qui mesure 12,30m fait partie de la classe Girafe mais aussi de la classe Animal. Elle peut donc marcher(), manger()...

C´est le principe de la programation orientée objet. J´espère avoir été a peu près clair !

Pour commencer ton jeu tu peux commencer par définir les classes qui te seront utiles...

Les objets doivent donc servir bcp ds les jeux de stratégie .
Ac tt ses persos différents et des capacités différentes qui évoluent .Par exemple si on fait une classe geurrier (ac les fonctions défense ,attaque) que l´on fait un objet archer ,si l´on veut faire un super archer on fait une sous-classe (ac les fonctions défense ,attaque ,tir enflammé).
C´est cela ?

Pour les tableaux, tu n´es pas obligée de les initialiser a la main : des boucles peuvent également etre utiles.
Imagine un fichier Mesh (fichier représentant un objet 3D, composé de milliers de triangles)
que tu as créé avec un logiciel spécial.
Récuperer les triangles revient a faire cela : (algorithme formel)

for(i=0;i<nombre_triangles;i++)
{
Triangle[i] = lire_prochain_triangle(fichier);
}

Et la le tableau est indispensable (certains modeles (si par exemple c´est tout un monde) comportent des centaines de milliers de triangles)

Pour les objets, c´es des structures avec davantages de possibilités (pour simplifier). Note que l´exemple ci dessus est orienté objet :
en effet, je dis que j´ai un type "Triangle", qu´est ce qu´un triangle ? une structure ou une classe.
Une classe est une boite noire avec des fonctionnalités dessus regarde mon tuto (non terminé) §C (cf ma carte)

Pour faire un jeu, tout comme une rédac, il faut faire un plan.
Le plan "passe partout" est le suivant :

initialise_donnees();
while(!game_over()) // BOUCLE PRINCIPALE DU JEU
{
recupere_input();
evolue();
affiche();
}
libere_donnees();

Prenons l´exemple d´un PONG :

-> initialise_donnees() : tu vas charger ici toutes les structures en mémoire.
Par exemple, pour un pong, tu vas faire 3 objets : 2 raquetets et une balle. La dedans, tu vas placer la balle au milieu, tu donner un vecteur déplacement de départ, placer les raquettes au milieu...
-> recupere_input() : la dedans, tu vas regarder si un joueur a appuyé sur quelque chose. Je te conseille de garder en mémoire un objet, ou des variables contenant les requetes (touches appuyées) faites par les joueurs.
-> evolue() : relis les requettes, fait bouger les raquettes en conséquence, vérifie qu´elles ne sortent pas du décor, bouge la balle, test la collision de la balle, rebondis si besoin, ... en 1 mot : fait avancer le jeu "d´un pas".
-> affiche() : illustre tes structures : en effet, il faut bien garder en tete que toute l´astuce réside uniquement a mettre a jour des structures représentant ton jeu. L´affichage n´est qu´un détail par la suite... Mais le jeu se passe dans les autres étapes...
Beaucoup de noobs font cette erreur de se jeter tete baissée sur l´affichage : "j´affiche déja la raquette, on verra apres" -> tres mauvais, il faut garder en mémoire un objet raquette avant de l´afficher, on parle ainsi de gestion de sprite.
-> libere_donnes() : important d´effacer tout ce qu´on a alloué pour ne pas etre considéré comme "gros porc" par la communauté des programmeurs !

Voila donc un petit aperçu.

bon il ne reste plus qu´une seule question sans réponse:
"Et pour le comencement dans une prog de jeu?"

A) il faut bien detailler ton jeu sur papier (l´histoire ou le genre ne suffit pas)

1) il faut voir sur papier les element dont aura besoin ton programme. (variables, fonction, ...)
2) commencer une ébauche du fonctionnement de ton jeu. encahinement des fonctions majeures...)
3) ecrire (ou résumer) tes fonctions principales soit dans un langage particulier soit en pseudo-algo.

fin de la partie papier

B) partie programmation

1) choisir un langage en fonction de test besoins et de tes connaissance dans tel ou tel langage.
2) normalement si tu a bien détailler ton prog sur papier le code découle tout seul.
3) test debugage (rien ne fonctionne du premier coup ça se saurai...)

Voila en gros c´est comme ça que moi je fais. Il ne faut pas négliger la partie papier. Si tu te retrouve devant ton PC sans savoir quoi faire c´est que tu a encore du boulot sur papier.

pour info c´est quoi ton jeu qui est pret?

Merci bcp! Même si j´ai rien compris au sujets des objets! Déjà que j´ai des explications simple dans les manuels et que je comprend pas avec l´explication donné plus haut ben...haï!

Après j´ai plusieurs idées de jeux mais rien de très défini encore. C´est juste que pour la partie papier je connais.(au depard une idée, puis transformé l´idée en concept, puis definir le type de jeux, l´histoire, le sénario, lister les variables, le gameplay...)

cependant pour definir les fonctions celà peu être quoi par exemple?? (pour un jeu).

Et je pense que commencer par programmer les fonctions et les outils( par exemple un éditeur de niveau), est le plus judicieux, non?

mais les fonctions et les objets j´ai un bloquage...

jessika en effet tu comprends bien les principes du developement de projet complexe. il faut reflechir avant d´agir.
En effet on commence en general par ecrire les fonctions de base de son programme.

Pour les objets, je vais essayer de te donner un exemple simple.
Tu as un type d´objet fenetre avec des proprietes: type de poigne, couleurs, matiere... et des fonctions permettant d´agir sur la fenetre comme repeindre, ouvrir, ferme, cassé...
ca ressemble fortement a des variables et a des fonctio ns sur ces variables, mais ca les presente d´une maniere plus coherente, par exemple ca te permet de gerer des problemes comme: que se passe t´il si l´on ouvre une fentre deja ouverte ?

mais les fonctions et les objets j´ai un bloquage...

pour les fonctions c´est problématique pour pouvoir démarer. pour les objets c´est moins grave pour un 1er jeu (et meme les autres); tu peux tres bien faire un jeu dans un langage non objet (C,pascal,...)

au lieu de réflechir avec des objets tu réflechis avec des variables "normales".
(meme si le pb revient un peu au meme)

pour les fonctions principales:
en gros il faut
-affichage
-gerer les interractions avec le joueur
-faire évoluer le jeu.

apres tu découpe tout ça en sous truc plus simples.

pour les variables; il faut se poser les questions suivantes:
-de quoi j´ai besoin pour faire évoluer mon jeu
(point de vie, position de cela, nombre de ceci,...)
ensuite tu pense au type de tes variables, et au moyen de les modifier, dans quelles fonctions seront-elle utiles, et tout et tout.

merci encore.

Mais... heu les objets ça rentre pas!

si je reprend l´exemple de l´objet fenetre, en gros c´est que, si j´appel cette objet, il me crait une fenetre et me donne accès a toutes les fonctions qui permettent d´agir sur cette dernière?
Donc, en schematisant, on peu dire qu´un objet c´est une boite qui contient des fonctions?

Donc, en schematisant, on peu dire qu´un objet c´est une boite qui contient des fonctions?

pas seulement; ce serait plutot une boite qui contient des varaibles ((int)couleur de la porte, (int)taille,(boolean)EstOuvert...) et des fonctions ("methodes") pour s´en servir (peindre,ouvrir...)

ha ok ba c´est plus clair déja.