1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
| State game_state <- { intro, home, options, end, // Écrans
gamer_1, gamer_2, game_pause, game_end, animation_new_game, // Pendant le jeu
animation_intro_home, animation_home_options, animation_options_home, animation_home_game, animation_game_home, animation_end }
// Pas forcément utile: c'est bien pour montrer l'idée de l'algo
// Cela sert surtout à savoir si le jeu peut recevoir des interactions
State logic_state <- { Wait, IA, Display, Program_End }
// Pas forcément utile: c'est bien pour montrer l'idée de l'algo
User_Interactions ui <- { none, click_play, click_options, click_exit, click_replay,
click_pause, click_menu, click_case_1, click_case_2, click_case_3, ... click_case_N, // Pendant le jeu
/* ... */ }
game_state <- intro
last_game_state <- gamer_1
logic_state <- Wait
ui <- none
// Initialise le jeu
// Déclaration de toutes les données
// ...
last_time <- now
diff_time <- 0
time_animation <- 0
while(logic_state != Program_End) {
logic_state <- Wait
// Le jeux attend Xms
// Si tu veux 25fps, X = 1/ 25
sleep(Xms);
// Mise à jour du temps
diff_time <- now - last_time
last_time <- now
// Si le programme se termine on peut faire un continue pour quitter le jeu
if (logic_state != Program_End) { logic_state <- IA }
else { game_state <- end /* || animation_end*/ }
// On recalcule le jeu avec les interactions des joueurs
// Peut-être qu'il n'y a rien à faire: ui == none
// Pour toutes les animations le mieux c'est d'utiliser le temps au lieu de faire des incréments fixes (variable diff_time)
// <- IA Début
switch(game_state) {
case intro:
// On calcule éventuellement les animations
// On attend un peu avant de lancer l'animation d'introduction
time_animation <- time_animation + diff_time
if time_animation > time_intro {
time_animation <- 0
state <- animation_intro_home
}
break
case home:
// On calcule éventuellement les animations
// comme les boutons qui scintillent par exemple
switch(ui) {
case click_play: case click_replay: state <- animation_home_game break;
case click_options: state <- animation_home_options break;
case click_exit: state <- end break;
case /* les autres interactions utilisateurs sur l'écran d'accueil */
}
break
case options:
// On calcule éventuellement les animations
// comme les boutons qui scintillent par exemple
switch(ui) {
case click_menu: state <- animation_options_home break
case /* les autres interactions utilisateurs dans les options */
}
break
case end:
time_animation <- time_animation + diff_time
// On calcule éventuellement les animations
// On attend un peu avant de lancer l'animation de fin
if time_animation > time_end {
time_animation <- 0
state <- animation_end
// Si ce n'est pas encore fait, c'est peut-être le moment de détruire toutes les données
// Ou alors faire cela après la boucle while s'il y a plusieurs endroits pour quitter la boucle
}
break
case gamer_1: case gamer_2:
// On calcule éventuellement les animations
switch(ui) {
case click_pause:
// Ici il faudra éventuellement gérer les données afin qu'on puisse rejouer
last_game_state <- state; state <- game_pause break
case click_menu:
// Ici il faudra gérer les données afin qu'on puisse rejouer si on revient dans le jeu
state <- animation_game_home
break
case click_case_1: case click_case_2: case click_case_3: case ... case click_case_N:
// C'est ici qu'il va y avoir l'IA du jeu
// Ici il faut gérer les données puisque l'état peut passer à game_end
break;
case /* les autres interactions utilisateurs avec le jeu */
}
break
case game_pause:
switch(ui) {
case click_pause:
// Ici il faudra éventuellement gérer les données afin qu'on puisse rejouer
state <- last_game_state
break
case /* les autres interactions utilisateurs pendant la pause */
}
break
case game_end:
switch(ui) {
case case click_replay:
// Ici il faut gérer les données pour une nouvelle partie
state <- animation_new_game
break
case click_menu:
// Ici il faut gérer les données puisque pour qu'on puisse après lancer une nouvelle partie
state <- animation_game_home
break
case /* les autres interactions utilisateurs lors d'une fin de partie */
}
break;
case animation_home_options:
case animation_options_home:
case animation_home_game:
case animation_game_home:
time_animation <- time_animation + diff_time
if time_animation < time_animation_2_screens {
// On calcule l'animation
} else {
time_animation <- 0
state <- home || last_game_state /* || animation_new_game */ || options
}
break
case animation_new_game:
// On calcule l'animation de début de partie
// Et à la fin state <- gamer_1
// Ici il faudra initialiser une nouvelle partie
break
case animation_intro_home:
// On calcule l'animation d'introduction
// Et à la fin state <- home
break
case animation_end:
// On calcule l'animation de fin
break
}
// -> IA Fin
// Si le programme se termine on peut ne pas afficher le jeu
if (logic_state != Program_End) { logic_state <- Display }
// On affiche le jeu avec les nouvelles données de l'IA
// <- Display Début
switch(game_state) {
case intro:
// On affiche l'écran d'introduction
break
case home:
// On affiche l'écran d'accueil
break
case options:
// On affiche l'écran des options
break
case gamer_1: case gamer_2:
// On affiche un écran du jeu: une grille de jeu
break
case game_pause:
// On affiche un écran du style: la grille de jeu avec un message "Pause"
break
case game_end:
// On affiche un écran du style: la grille de jeu avec un message "Fin de partie"
break;
case end:
// On affiche un écran de fin
break
case animation_home_options:
case animation_options_home:
case animation_home_game:
case animation_game_home:
case animation_new_game:
case animation_intro_home:
case animation_end:
// On affiche une des animations du jeu
break
}
// -> Display Fin
// Il me semble que c'est le bon endroit pour "des choses classiques": faire des sauvegardes, calcul du fps, ...
// Et aussi; si soit l'IA soit l'affichage soit les 2 prennent du temps, on peut faire aussi des choses ici:
// regarder s'il y a eu des interactions, redéfinir le temps d'attente, ...
}
// Si ce n'est pas encore fait, c'est le moment de détruire toutes les données |
pour projet merci d'avance pour vos reponse
creer un jeu en C
: il me semble qu'on arrête de dormir si un joueur joue.
Envoyé par Avatar91
)
Répondre avec citation
Partager