~ubuntu-branches/ubuntu/vivid/berusky/vivid
» Revision
7
: .pc/04_unfinished.diff/src/berusky_gui.cpp
« back to all changes in this revision
Viewing changes to .pc/04_unfinished.diff/src/berusky_gui.cpp
- browse files at revision 7
- compare with another revision
- download diff
- download tarball
- view history from revision 7
- Committer: Bazaar Package Importer
- Author(s): Bart Martens
- Date: 2011-08-27 08:09:19 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20110827080919-1a7tyg1mm3ndg5sp
Tags: 1.3-1
* New upstream release.
* Switch to dpkg-source 3.0 (quilt) format.
* debian/berusky.6: Added. Closes: #605982.
* debian/patches/02_endian.diff: Removed.
* debian/patches/03_arraysize.diff: Removed.
* debian/patches/06_newline.diff: Removed.
* debian/patches/08_backspace.diff: Removed.
* debian/patches/09_hints.diff: Removed.
* debian/patches/10_typos.diff: Added. Closes: #616350.
* debian/berusky.desktop: Updated. Closes: #616343.
* debian/control: Build-Depends: libgtk2.0-dev.
* Switch to dpkg-source 3.0 (quilt) format.
* debian/berusky.6: Added. Closes: #605982.
* debian/patches/02_endian.diff: Removed.
* debian/patches/03_arraysize.diff: Removed.
* debian/patches/06_newline.diff: Removed.
* debian/patches/08_backspace.diff: Removed.
* debian/patches/09_hints.diff: Removed.
* debian/patches/10_typos.diff: Added. Closes: #616350.
* debian/berusky.desktop: Updated. Closes: #616343.
* debian/control: Build-Depends: libgtk2.0-dev.
- files added:
- .pc
- .pc/01_debianize.diff
- .pc/01_debianize.diff/src
- .pc/04_unfinished.diff
- .pc/04_unfinished.diff/po
- .pc/04_unfinished.diff/src
- .pc/05_no_editor.diff
- .pc/05_no_editor.diff/src
- .pc/07_quick_quit.diff
- .pc/07_quick_quit.diff/src
- .pc/10_typos.diff
- .pc/10_typos.diff/src
- debian/source
- files removed:
- data/berusky-data.spec
- files modified:
- COPYING
added
removed
.pc/04_unfinished.diff/src/berusky_gui.cpp
1
/*
2
* .þÛÛþ þ þ þÛÛþ. þ þ þÛÛÛþ. þÛÛÛþ .þÛÛþ. þ þ
3
* .þ Û Ûþ. Û Û þ. Û Û Û þ Û. Û. Û Ûþ. Û
4
* Û Û Û Û Û Û Û Û þ. Û. Û Û Û Û Û Û Û
5
* .þþÛÛÛÛþ Û Û Û þÛÛÛÛþþ. þþÛÛ. þþÛÛþ. þÛ Û Û Û Û Û
6
* .Û Û Û .þÛ Û Û. Û Û Û Û Û. þ. Û Û .þÛ
7
* þ. þ þ þ þ .þ þ .þ þ .þ þÛÛÛþ .þÛÛþ. þ þ
8
*
9
* Berusky (C) AnakreoN
10
* Martin Stransky <stransky@anakreon.cz>
11
*
12
* This program is free software; you can redistribute it and/or modify
13
* it under the terms of the GNU General Public License as published by
14
* the Free Software Foundation; either version 2 of the License, or
15
* (at your option) any later version.
16
*
17
* This program is distributed in the hope that it will be useful,
18
* but WITHOUT ANY WARRANTY; without even the implied warranty of
19
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20
* GNU General Public License for more details.
21
*
22
* You should have received a copy of the GNU General Public License
23
* along with this program; if not, write to the Free Software
24
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25
*
26
*/
27
28
#include <errno.h>
29
30
#include "portability.h"
31
32
#ifdef LINUX
33
#include <sys/wait.h>
34
#endif
35
36
#ifdef WINDOWS
37
#include <stdio.h>
38
#include <process.h>
39
#endif
40
41
#include "berusky.h"
42
#include "berusky_gui.h"
43
#include "main.h"
44
45
46
// -------------------------------------------------------
47
// Game UI
48
// -------------------------------------------------------
49
50
game_gui::game_gui(ITEM_REPOSITORY *p_repo_, DIR_LIST *p_dir_)
51
: gui_base(), p_repo(p_repo_), p_dir(p_dir_)
52
{
53
// Create game main class
54
p_ber = new BERUSKY(p_repo_,p_dir);
55
56
// Set window title
57
window_set_title(GAME_TITLE);
58
}
59
60
game_gui::~game_gui(void)
61
{
62
if(p_ber)
63
delete p_ber;
64
65
// TODO -> dat to tam kde se to SDL inicializuje
66
SDL_Quit();
67
}
68
69
70
/*
71
MENU_ENTER = 0,
72
MENU_LEAVE = 1
73
*/
74
#undef LOGO_START
75
#undef MENU_X_START
76
#undef MENU_Y_START
77
#undef MENU_X_DIFF
78
#undef MENU_Y_DIFF
79
80
/*
81
- zrusit
82
*/
83
84
void game_gui::menu_main(MENU_STATE state, int data, int data1)
85
{
86
switch(state) {
87
case MENU_RETURN:
88
case MENU_ENTER:
89
{
90
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)(&game_gui::menu_main), data, data1);
91
92
p_grf->fill(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y, 0);
93
94
tpos width = p_grf->sprite_get_width(MENU_SPRIT_LOGO);
95
96
#define LOGO_START 0
97
98
p_grf->draw(MENU_SPRIT_LOGO,(GAME_RESOLUTION_X-width)/2,LOGO_START);
99
100
#define MENU_X_START 250
101
#define MENU_Y_START 220
102
#define MENU_X_DIFF 0
103
#define MENU_Y_DIFF 35
104
105
static char *new_game = _("new game");
106
static char *password = _("password");
107
static char *help = _("help");
108
static char *editor = _("editor");
109
static char *quit = _("quit");
110
111
p_font->select(FONT_DEFAULT);
112
113
menu_item_set_pos(MENU_X_START, MENU_Y_START);
114
menu_item_set_diff(MENU_X_DIFF, MENU_Y_DIFF);
115
116
menu_item_start();
117
118
menu_item_draw(new_game, LEFT, TRUE, LEVEL_EVENT(GC_MENU_NEW_GAME));
119
menu_item_draw(password, LEFT, TRUE, LEVEL_EVENT(GC_MENU_PASSWORD));
120
menu_item_draw(help, LEFT, TRUE, LEVEL_EVENT(GC_MENU_HELP,FALSE));
121
menu_item_draw(editor, LEFT, TRUE, LEVEL_EVENT(GC_RUN_EDITOR));
122
menu_item_draw(quit, LEFT, TRUE, LEVEL_EVENT(GC_MENU_QUIT));
123
124
p_font->alignment_set(CENTER);
125
p_font->start_set(0, GAME_RESOLUTION_Y - 60);
126
p_font->print(_("berusky (C) Anakreon 1997-2007\n"));
127
p_font->print(_("distributed under GPL\n"));
128
129
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
130
p_grf->flip();
131
}
132
break;
133
case MENU_LEAVE:
134
input.mevent_clear();
135
break;
136
default:
137
break;
138
}
139
}
140
141
#undef LOGO_START
142
#undef MENU_X_START
143
#undef MENU_Y_START
144
#undef MENU_X_DIFF
145
#undef MENU_Y_DIFF
146
147
void game_gui::menu_new_game(MENU_STATE state, int data, int data1)
148
{
149
switch(state) {
150
case MENU_RETURN:
151
case MENU_ENTER:
152
{
153
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_new_game, data, data1);
154
155
p_grf->fill(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y, 0);
156
157
tpos width = p_grf->sprite_get_width(MENU_SPRIT_LOGO);
158
159
#define LOGO_START 0
160
161
p_grf->draw(MENU_SPRIT_LOGO,(GAME_RESOLUTION_X-width)/2,LOGO_START);
162
163
#define MENU_X_START 250
164
#define MENU_Y_START 240
165
#define MENU_X_DIFF 0
166
#define MENU_Y_DIFF 35
167
168
p_font->select(FONT_DEFAULT);
169
p_font->alignment_set(CENTER);
170
p_font->start_set(0, MENU_Y_START - 50);
171
p_font->print(_("select difficulty of the new game:"));
172
173
static char *training = _("training");
174
static char *easy = _("easy");
175
static char *intermediate = _("intermediate");
176
static char *advanced = _("advanced");
177
static char *impossible = _("impossible");
178
static char *back = _("back");
179
180
menu_item_set_pos(MENU_X_START, MENU_Y_START);
181
menu_item_set_diff(MENU_X_DIFF, MENU_Y_DIFF);
182
183
// udelat na to ulozeni tady flag -> prejdi a uloz!! (Zprava -> menu_back_save)
184
menu_item_start();
185
menu_item_draw(training, LEFT, TRUE, LEVEL_EVENT(GC_MENU_RUN_LEVEL, 0, 0));
186
menu_item_draw(easy, LEFT, TRUE, LEVEL_EVENT(GC_MENU_RUN_LEVEL, 1, 0));
187
menu_item_draw(intermediate, LEFT, TRUE, LEVEL_EVENT(GC_MENU_RUN_LEVEL, 2, 0));
188
menu_item_draw(advanced, LEFT, TRUE, LEVEL_EVENT(GC_MENU_RUN_LEVEL, 3, 0));
189
menu_item_draw(impossible, LEFT, TRUE, LEVEL_EVENT(GC_MENU_RUN_LEVEL, 4, 0));
190
menu_item_draw(back, LEFT, FALSE, LEVEL_EVENT(GI_MENU_BACK_POP));
191
192
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
193
p_grf->flip();
194
}
195
break;
196
case MENU_LEAVE:
197
input.mevent_clear();
198
break;
199
default:
200
break;
201
}
202
}
203
204
#undef LOGO_START
205
#undef MENU_X_START
206
#undef MENU_Y_START
207
#undef MENU_X_DIFF
208
#undef MENU_Y_DIFF
209
210
void game_gui::menu_password(MENU_STATE state, int data, int data1)
211
{
212
#define MAX_PASSWORD 10
213
static char password[MAX_PASSWORD] = "";
214
215
switch(state) {
216
case MENU_RETURN:
217
case MENU_ENTER:
218
{
219
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_password, data, data1);
220
221
p_grf->fill(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y, 0);
222
223
tpos width = p_grf->sprite_get_width(MENU_SPRIT_LOGO);
224
225
#define LOGO_START 0
226
227
p_grf->draw(MENU_SPRIT_LOGO,(GAME_RESOLUTION_X-width)/2,LOGO_START);
228
229
#define INSERT_START 200
230
p_font->select(FONT_DEFAULT);
231
p_font->alignment_set(CENTER);
232
p_font->start_set(0, INSERT_START);
233
p_font->print(_("please insert a password to level:"));
234
password[0] = '\0';
235
p_font->print(NULL, 0, INSERT_START+50, "_");
236
237
#define MENU_X_START 270
238
#define MENU_Y_START 400
239
#define MENU_X_DIFF 90
240
#define MENU_Y_DIFF 35
241
242
static char *play = _("play");
243
static char *back = _("back");
244
245
menu_item_start();
246
menu_item_draw(MENU_X_START + MENU_X_DIFF, MENU_Y_START, play, RIGHT, TRUE, LEVEL_EVENT(GC_MENU_PASSWORD_CHECK, password));
247
menu_item_draw(MENU_X_START, MENU_Y_START+MENU_Y_DIFF, back, LEFT, FALSE, LEVEL_EVENT(GI_MENU_BACK_POP));
248
249
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
250
p_grf->flip();
251
252
menu_key_input.set((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_password);
253
}
254
break;
255
case MENU_KEY_INPUT:
256
{
257
char ascii_char;
258
bool character = key_to_ascii(data,&ascii_char);
259
int len = strlen(password);
260
261
if(character && ascii_char >= ' ') {
262
if(len < MAX_PASSWORD-2) {
263
password[len] = ascii_char;
264
password[len+1] = '\0';
265
}
266
} else {
267
switch(data) {
268
case K_BKSP:
269
case K_DEL:
270
if(len > 0) {
271
password[--len] = '\0';
272
}
273
break;
274
case K_ENTER:
275
break;
276
default:
277
break;
278
}
279
}
280
281
p_font->select(FONT_DEFAULT);
282
p_font->alignment_set(CENTER);
283
p_grf->fill(0,INSERT_START+50,GAME_RESOLUTION_X,20,0);
284
p_font->print(NULL, 0, INSERT_START+50, "%s_", password);
285
p_grf->redraw_add(0,INSERT_START+50,GAME_RESOLUTION_X,20);
286
p_grf->flip();
287
}
288
break;
289
case MENU_LEAVE:
290
input.mevent_clear();
291
menu_key_input.clear();
292
break;
293
default:
294
break;
295
}
296
}
297
298
#undef LOGO_START
299
#undef MENU_X_START
300
#undef MENU_Y_START
301
#undef MENU_X_DIFF
302
#undef MENU_Y_DIFF
303
#undef INSERT_START
304
305
void game_gui::menu_password_check(MENU_STATE state, int data, int data1)
306
{
307
switch(state) {
308
case MENU_RETURN:
309
case MENU_ENTER:
310
{
311
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_password_check, data, data1);
312
313
int set, level;
314
315
if(p_ber->levelset_search((char *)data, &set, &level)) {
316
menu_level_run(MENU_ENTER,set,level);
317
} else {
318
p_grf->fill(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y, 0);
319
320
tpos width = p_grf->sprite_get_width(MENU_SPRIT_LOGO);
321
322
#define LOGO_START 0
323
324
p_grf->draw(MENU_SPRIT_LOGO,(GAME_RESOLUTION_X-width)/2,LOGO_START);
325
326
#define INSERT_START 200
327
p_font->select(FONT_DEFAULT);
328
p_font->alignment_set(CENTER);
329
p_font->start_set(0, INSERT_START);
330
p_font->print(_("Cha cha cha!!!\n"));
331
p_font->print(_("Would you like to cheat?\n"));
332
p_font->print(_("Try me again!"));
333
334
335
#define MENU_X_START 270
336
#define MENU_Y_START 400
337
#define MENU_X_DIFF 90
338
#define MENU_Y_DIFF 35
339
340
static char *back = _("back");
341
342
menu_item_start();
343
menu_item_draw(MENU_X_START, MENU_Y_START+MENU_Y_DIFF, back, LEFT, FALSE, LEVEL_EVENT(GI_MENU_BACK_POP));
344
345
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
346
p_grf->flip();
347
}
348
}
349
break;
350
case MENU_LEAVE:
351
input.mevent_clear();
352
break;
353
default:
354
break;
355
}
356
}
357
358
#undef LOGO_START
359
#undef MENU_X_START
360
#undef MENU_Y_START
361
#undef MENU_X_DIFF
362
#undef MENU_Y_DIFF
363
364
/*
365
data = bool from_game
366
*/
367
void game_gui::menu_help(MENU_STATE state, int data, int data1)
368
{
369
switch(state) {
370
case MENU_RETURN:
371
case MENU_ENTER:
372
{
373
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_help, data, data1);
374
375
p_grf->fill(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y, 0);
376
377
tpos width = p_grf->sprite_get_width(MENU_SPRIT_LOGO);
378
379
#define LOGO_START 0
380
381
p_grf->draw(MENU_SPRIT_LOGO,(GAME_RESOLUTION_X-width)/2,LOGO_START);
382
383
#define MENU_X_START 240
384
#define MENU_Y_START 240
385
#define MENU_X_DIFF 0
386
#define MENU_Y_DIFF 35
387
388
bool from_game = (bool)data;
389
390
static char *hint = _("level hint");
391
static char *keys = _("game controls");
392
static char *rules = _("game rulez");
393
static char *credits = _("authors");
394
static char *back = _("back");
395
396
menu_item_set_pos(MENU_X_START, MENU_Y_START);
397
menu_item_set_diff(MENU_X_DIFF, MENU_Y_DIFF);
398
399
menu_item_start();
400
401
if(from_game) {
402
menu_item_draw(hint, LEFT, TRUE, LEVEL_EVENT(GC_MENU_LEVEL_HINT, FALSE));
403
}
404
405
menu_item_draw(keys, LEFT, TRUE, LEVEL_EVENT(GC_MENU_HELP_KEYS));
406
menu_item_draw(rules, LEFT, TRUE, LEVEL_EVENT(GC_MENU_HELP_RULES,0));
407
menu_item_draw(credits, LEFT, TRUE, LEVEL_EVENT(GC_MENU_HELP_CREDIT));
408
menu_item_draw(back, LEFT, FALSE, LEVEL_EVENT(from_game ? GC_RESTORE_LEVEL : GI_MENU_BACK_POP));
409
410
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
411
p_grf->flip();
412
}
413
break;
414
415
case MENU_LEAVE:
416
input.mevent_clear();
417
break;
418
default:
419
break;
420
}
421
}
422
423
/*
424
*/
425
426
#undef LOGO_START
427
#undef MENU_X_START
428
#undef MENU_Y_START
429
#undef MENU_X_DIFF
430
#undef MENU_Y_DIFF
431
432
void game_gui::menu_help_rules(MENU_STATE state, int data, int data1)
433
{
434
switch(state) {
435
case MENU_RETURN:
436
case MENU_ENTER:
437
{
438
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_help_rules, data, data1);
439
440
p_grf->fill(0,0,GAME_RESOLUTION_X,GAME_RESOLUTION_Y,0);
441
p_grf->draw(MENU_SPRIT_BACK,0,0);
442
p_font->alignment_set(LEFT);
443
p_font->select(FONT_DEFAULT);
444
445
int j, i, x, y;
446
int variants;
447
int page = data;
448
449
int page_prev = page-1,
450
page_next = page+1;
451
452
switch(page) {
453
case 0:
454
p_font->print(NULL, 80, 95, _("Basic rules and game elements"));
455
456
p_font->start_set(20, 140);
457
p_font->print(_("In order to leave each level it is\n\
458
necessary to own five keys and also\n\
459
to have a free way to the exit.\n\n\
460
You will be meeting miscellaneous game\n\
461
elements while completing individual\n\
462
missions, we will try to explain their\n\
463
meaning now.\n"));
464
465
p_font->print(NULL, 20, 310, _("box - it is possible to push it."));
466
x = 20;
467
y = 340;
468
variants = p_repo->variants_get(P_BOX);
469
for (i = 0; i < variants; i++) {
470
p_repo->draw(x, y, P_BOX, i, 0);
471
x += 30;
472
}
473
474
p_font->print(NULL, 20, 380, _("explosive - can destroy the boxes."));
475
x = 20;
476
y = 410;
477
variants = p_repo->variants_get(P_TNT);
478
for (i = 0; i < variants; i++) {
479
p_repo->draw(x, y, P_TNT, i, 0);
480
x += 30;
481
}
482
483
page_prev = page;
484
485
break;
486
487
case 1:
488
p_font->print(NULL, 160, 95, _("Active game elements"));
489
490
p_font->print(NULL, 20, 140, _("key - you need five of them."));
491
p_grf->draw(p_repo->sprite_get(P_KEY, 0, 0), 20, 165);
492
493
p_font->print(NULL, 20, 200, _("exit - a gate to next level."));
494
x = 20;
495
y = 230;
496
variants = p_repo->variants_get(P_EXIT);
497
for (i = 0; i < variants - 1; i += 2) {
498
p_repo->draw(x, y, P_EXIT, i, 0);
499
x += 30;
500
}
501
p_grf->draw(p_repo->sprite_get(P_EXIT, i - 1, 0), x, y);
502
503
p_font->print(NULL, 20, 270, _("stone - can be broken by a pickax."));
504
x = 20;
505
y = 300;
506
variants = p_repo->variants_get(P_STONE);
507
for (i = 0; i < variants; i++) {
508
p_repo->draw(x, y, P_STONE, i, 0);
509
x += 30;
510
}
511
512
p_font->print(NULL, 20, 340, _("pickax - a tool for stone crushing."));
513
x = 20;
514
y = 370;
515
variants = p_repo->variants_get(P_MATTOCK);
516
for (i = 0; i < variants; i++) {
517
p_repo->draw(x, y, P_MATTOCK, i, 0);
518
x += 30;
519
}
520
521
break;
522
523
case 2:
524
p_font->print(NULL, 160, 95, _("Active game elements"));
525
526
p_font->start_set(20, 140);
527
p_font->print(_("color key - used to unlock color door,\n\
528
only a bug with identical color can\n\
529
pick them up"));
530
531
x = 20;
532
y = 210;
533
for (j = 0; j < 5; j++) {
534
variants = p_repo->variants_get(P_KEY1 + j);
535
for (i = 0; i < variants; i++) {
536
p_repo->draw(x, y, P_KEY1 + j, i, 0);
537
x += 30;
538
}
539
}
540
541
p_font->start_set(20, 250);
542
p_font->print(_("color door - can be opened by the\nrespective color key only"));
543
544
x = 40;
545
y = 300;
546
variants = p_repo->variants_get(P_DOOR1_V_Z);
547
for (i = 0; i < variants; i++) {
548
p_repo->draw(x, y, P_DOOR1_V_Z, i, 0);
549
x += 70;
550
}
551
552
p_font->start_set(20, 340);
553
p_font->print(_("color gate-way - only a bug with\n\
554
identical color is allowed to go\n\
555
through. Boxes cannot be pushed\n\
556
through."));
557
558
x = 40;
559
y = 430;
560
variants = p_repo->variants_get(P_ID_DOOR1_V_Z);
561
for (i = 0; i < variants; i++) {
562
p_repo->draw(x, y, P_ID_DOOR1_V_Z, i, 0);
563
x += 70;
564
}
565
566
break;
567
568
case 3:
569
p_font->print(NULL, 160, 95, _("Active game elements"));
570
571
p_font->start_set(20, 140);
572
p_font->print(_("one-pass door - can be used only once,\n\
573
then they close them off and there's no\n\
574
way to open them\n"));
575
576
x = 40;
577
y = 220;
578
variants = p_repo->variants_get(P_DV_V_O);
579
for (i = 0; i < variants; i++) {
580
p_repo->draw(x, y, P_DV_V_O, i, 0);
581
x += 70;
582
}
583
x = 40;
584
y = 260;
585
variants = p_repo->variants_get(P_DV_V_Z);
586
for (i = 0; i < variants; i++) {
587
p_repo->draw(x, y, P_DV_V_Z, i, 0);
588
x += 70;
589
}
590
591
p_font->start_set(20, 300);
592
p_font->print(_("Other elements not listed here are just\n\
593
walls, which have no interesting\n\
594
properties. They cannot be push away nor\n\
595
it is possible to break them anywise.\n"));
596
597
page_next = page;
598
599
break;
600
601
default:
602
assert(0);
603
break;
604
}
605
606
static char *prev = _("previous");
607
static char *next = _("next");
608
static char *back = _("back");
609
610
#define MENU_X_START 350
611
#define MENU_X_START_L MENU_X_START
612
#define MENU_X_START_R MENU_X_START_L + 250
613
#define MENU_X_START_B MENU_X_START_L + 50
614
#define MENU_Y_START 410
615
#define MENU_X_DIFF 0
616
#define MENU_Y_DIFF 30
617
618
menu_item_start();
619
menu_item_draw(MENU_X_START_L, MENU_Y_START+0*MENU_Y_DIFF, prev, LEFT, FALSE, LEVEL_EVENT(GC_MENU_HELP_RULES,page_prev));
620
menu_item_draw(MENU_X_START_R, MENU_Y_START+0*MENU_Y_DIFF, next, RIGHT, FALSE, LEVEL_EVENT(GC_MENU_HELP_RULES,page_next));
621
menu_item_draw(MENU_X_START_B, MENU_Y_START+1*MENU_Y_DIFF, back, LEFT, FALSE, LEVEL_EVENT(GI_MENU_BACK_POP));
622
623
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
624
p_grf->flip();
625
}
626
break;
627
628
case MENU_LEAVE:
629
input.mevent_clear();
630
break;
631
632
default:
633
break;
634
}
635
}
636
637
#undef LOGO_START
638
#undef MENU_X_START
639
#undef MENU_Y_START
640
#undef MENU_X_DIFF
641
#undef MENU_Y_DIFF
642
643
void game_gui::menu_help_keys(MENU_STATE state, int data, int data1)
644
{
645
switch(state) {
646
case MENU_RETURN:
647
case MENU_ENTER:
648
{
649
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_help_keys, data, data1);
650
651
p_grf->fill(0,0,GAME_RESOLUTION_X,GAME_RESOLUTION_Y,0);
652
p_grf->draw(MENU_SPRIT_BACK,0,0);
653
p_font->select(FONT_DEFAULT);
654
655
p_font->alignment_set(CENTER);
656
p_font->print(NULL, 220, 100, _("Game Controls"));
657
658
p_font->alignment_set(LEFT);
659
p_font->print(NULL, 20, 140, _("Up to five bugs are available,\n\
660
which can be controlled by these keys:"));
661
662
#define Y_DIFF 25
663
#define Y_START 200
664
int start_y;
665
666
p_font->print(NULL, 20, start_y = Y_START, _("arrows"));
667
668
p_font->print(NULL, 20, start_y += Y_DIFF, _("Tab"));
669
p_font->print(NULL, 20, start_y += Y_DIFF, _("N"));
670
p_font->print(NULL, 20, start_y += Y_DIFF, _("D"));
671
p_font->print(NULL, 20, start_y += Y_DIFF, _("CTRL+X"));
672
p_font->print(NULL, 20, start_y += Y_DIFF, _("F1"));
673
p_font->print(NULL, 20, start_y += Y_DIFF, _("F2"));
674
p_font->print(NULL, 20, start_y += Y_DIFF, _("F3"));
675
676
p_font->print(NULL, 69, start_y = Y_START, _(" . . . . . . . move the bug"));
677
p_font->print(NULL, 86, start_y += Y_DIFF, _(". . . . . . . switch among the bugs"));
678
p_font->print(NULL, 60, start_y += Y_DIFF, _(". . . . . . . . change the music"));
679
p_font->print(NULL, 60, start_y += Y_DIFF, _(". . . . . . . . demo"));
680
p_font->print(NULL, 110, start_y += Y_DIFF, _(". . . . . . quit quickly"));
681
p_font->print(NULL, 60, start_y += Y_DIFF, _(". . . . . . . . Help"));
682
p_font->print(NULL, 60, start_y += Y_DIFF, _(". . . . . . . . Save level"));
683
p_font->print(NULL, 60, start_y += Y_DIFF, _(". . . . . . . . Load level"));
684
685
#define MENU_X_START 270
686
#define MENU_Y_START 400
687
#define MENU_X_DIFF 90
688
#define MENU_Y_DIFF 35
689
690
static char *back = _("back");
691
692
menu_item_start();
693
menu_item_draw(MENU_X_START, MENU_Y_START+MENU_Y_DIFF, back, LEFT, FALSE, LEVEL_EVENT(GI_MENU_BACK_POP));
694
695
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
696
p_grf->flip();
697
}
698
break;
699
700
case MENU_LEAVE:
701
input.mevent_clear();
702
break;
703
704
default:
705
break;
706
}
707
}
708
709
#undef LOGO_START
710
#undef MENU_X_START
711
#undef MENU_Y_START
712
#undef MENU_X_DIFF
713
#undef MENU_Y_DIFF
714
#undef MENU_X_START_L
715
716
#define SCROLL_START_X 0
717
#define SCROLL_START_Y 180
718
#define SCROLL_LINES 12
719
720
void game_gui::menu_help_credits(MENU_STATE state, int data, int data1)
721
{
722
static char *p_text = NULL;
723
static int frame = 0;
724
static int position;
725
726
switch(state) {
727
case MENU_RETURN:
728
case MENU_ENTER:
729
{
730
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_help_credits, data, data1);
731
732
p_text = credit_text_load();
733
assert(p_text);
734
735
sprite::color_key_set(COLOR_KEY_GAME);
736
737
p_grf->fill(0,0,GAME_RESOLUTION_X,GAME_RESOLUTION_Y,0);
738
tpos width = p_grf->sprite_get_width(MENU_SPRIT_LOGO);
739
#define LOGO_START 0
740
p_grf->draw(MENU_SPRIT_LOGO,(GAME_RESOLUTION_X-width)/2,LOGO_START);
741
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
742
p_grf->flip();
743
744
input.keyset_set(&menu_keys);
745
746
menu_timer.set((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_help_credits, data, data1);
747
frame = 0;
748
position = 0;
749
}
750
break;
751
752
case MENU_TIMER:
753
{
754
if((frame & 0x3) == 0x0) {
755
756
p_font->alignment_set(CENTER);
757
p_font->select(FONT_DEFAULT);
758
759
if(position >= p_font->height_get_new_line(p_text)) {
760
position -= p_font->height_get_new_line(p_text);
761
p_text = strchr(p_text+1,'\n');
762
}
763
764
if(p_text) {
765
p_grf->fill(0,SCROLL_START_Y,GAME_RESOLUTION_X,GAME_RESOLUTION_Y-SCROLL_START_Y,0);
766
p_font->print(NULL, SCROLL_START_X, SCROLL_START_Y-position, SCROLL_LINES, p_text);
767
} else {
768
menu_timer.clear();
769
770
#define MENU_X_START_L (320 - 17)
771
#define MENU_Y_START 440
772
773
static char *back_string = _("back");
774
775
menu_item_start();
776
menu_item_draw(MENU_X_START_L, MENU_Y_START, back_string, LEFT, FALSE, LEVEL_EVENT(GC_MENU_START));
777
}
778
779
p_grf->redraw_add(0,SCROLL_START_Y,GAME_RESOLUTION_X,GAME_RESOLUTION_Y-SCROLL_START_Y);
780
p_grf->flip();
781
782
position += 2;
783
}
784
frame++;
785
}
786
break;
787
788
case MENU_LEAVE:
789
p_text = NULL;
790
menu_timer.clear();
791
input.keyset_set(NULL);
792
input.mevent_clear();
793
break;
794
795
default:
796
break;
797
}
798
}
799
800
#undef LOGO_START
801
#undef MENU_X_START
802
#undef MENU_Y_START
803
#undef MENU_X_DIFF
804
#undef MENU_Y_DIFF
805
806
/*
807
data = set
808
data1 = level
809
*/
810
void game_gui::menu_level_hint(MENU_STATE state, int data, int data1)
811
{
812
switch(state) {
813
case MENU_RETURN:
814
case MENU_ENTER:
815
{
816
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_level_hint, data, data1);
817
818
p_grf->fill(0,0,GAME_RESOLUTION_X,GAME_RESOLUTION_Y,0);
819
p_grf->draw(MENU_SPRIT_BACK,0,0);
820
821
p_font->select(FONT_DEFAULT);
822
p_font->alignment_set(LEFT);
823
824
char *p_hint = NULL;
825
bool from_game = data;
826
827
if(!p_ber->levelset_is_custom()) {
828
int set = p_ber->levelset_get_set();
829
int level = p_ber->levelset_get_level();
830
831
// ... Load & print hint for level ...
832
p_hint = level_hint_load(set, level);
833
}
834
835
if(p_hint) {
836
p_font->print(NULL, 20, 100, _("Level hint:"));
837
} else {
838
p_hint = _("\nSory dude, no hint available for this\nlevel.");
839
}
840
p_font->print(NULL, 20, 120, p_hint);
841
842
#define MENU_X_START 270
843
#define MENU_Y_START 400
844
#define MENU_X_DIFF 90
845
#define MENU_Y_DIFF 35
846
847
static char *back = _("back");
848
849
menu_item_start();
850
menu_item_draw(MENU_X_START, MENU_Y_START+MENU_Y_DIFF, back, LEFT, FALSE, LEVEL_EVENT(from_game ? GC_RESTORE_LEVEL : GI_MENU_BACK_POP));
851
852
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
853
p_grf->flip();
854
}
855
break;
856
857
case MENU_LEAVE:
858
input.mevent_clear();
859
break;
860
861
default:
862
break;
863
}
864
}
865
866
#undef LOGO_START
867
#undef MENU_X_START
868
#undef MENU_Y_START
869
#undef MENU_X_DIFF
870
#undef MENU_Y_DIFF
871
#undef MENU_X_START_L
872
#undef MENU_X_START_R
873
874
void game_gui::menu_level_run(MENU_STATE state, int data, int data1)
875
{
876
switch(state) {
877
case MENU_RETURN:
878
case MENU_ENTER:
879
{
880
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_level_run, data, data1);
881
882
int set = data;
883
int level = data1;
884
885
bool ret = p_ber->levelset_load(set);
886
assert(ret);
887
p_ber->levelset_set_level(level);
888
889
p_grf->fill(0,0,GAME_RESOLUTION_X,GAME_RESOLUTION_Y,0);
890
p_font->alignment_set(CENTER);
891
p_font->select(FONT_DEFAULT);
892
893
#define TEXT_START 250
894
895
switch(set) {
896
case 0:
897
p_grf->draw(MENU_SPRIT_START+0,0,50);
898
p_font->print(NULL, 0, 20,_("difficulty training"));
899
p_font->print(NULL, 0, TEXT_START+35, _("Level: %d"),level);
900
p_font->print(NULL, 0, TEXT_START+35+25, _("Password: %s"),p_ber->levelset_get_passwd(level));
901
break;
902
case 1:
903
p_grf->draw(MENU_SPRIT_START+1,0,25);
904
p_font->print(NULL, 0, 20, _("difficulty easy"));
905
p_font->print(NULL, 0, TEXT_START+35, _("Level: %d"),level);
906
p_font->print(NULL, 0, TEXT_START+35+25, _("Password: %s"),p_ber->levelset_get_passwd(level));
907
break;
908
case 2:
909
p_grf->draw(MENU_SPRIT_START+2,0,50);
910
p_font->print(NULL, 0, 20, _("difficulty intermediate"));
911
p_font->print(NULL, 0, TEXT_START+35, _("Level: %d"),level);
912
p_font->print(NULL, 0, TEXT_START+35+25, _("Password: %s"),p_ber->levelset_get_passwd(level));
913
break;
914
case 3:
915
p_grf->draw(MENU_SPRIT_START+3,0,50);
916
p_font->print(NULL, 0, 20, _("difficulty advanced"));
917
p_font->print(NULL, 0, TEXT_START+35, _("Level: %d"),level);
918
p_font->print(NULL, 0, TEXT_START+35+25, _("Password: %s"),p_ber->levelset_get_passwd(level));
919
break;
920
case 4:
921
p_grf->draw(MENU_SPRIT_START+3,0,50);
922
p_font->print(NULL, 0, 20, _("difficulty impossible"));
923
p_font->print(NULL, 0, TEXT_START+35, _("Level: %d"),level);
924
p_font->print(NULL, 0, TEXT_START+35+25, _("Password: %s"),p_ber->levelset_get_passwd(level));
925
break;
926
default:
927
assert(0);
928
break;
929
}
930
931
#define MENU_X_START_L (320 - 17 - 60)
932
#define MENU_X_START_R (320 + 60)
933
#define MENU_Y_START 360
934
#define MENU_X_DIFF 0
935
#define MENU_Y_DIFF 35
936
937
static char *play_string = _("play level");
938
static char *level_hint = _("level hint");
939
static char *back_string = _("back");
940
941
menu_item_start();
942
menu_item_draw(MENU_X_START_R, MENU_Y_START+0*MENU_Y_DIFF, play_string, RIGHT, FALSE, LEVEL_EVENT(GC_RUN_LEVEL_SET, set, level));
943
menu_item_draw(MENU_X_START_R, MENU_Y_START+1*MENU_Y_DIFF, level_hint, RIGHT, TRUE, LEVEL_EVENT(GC_MENU_LEVEL_HINT, FALSE));
944
menu_item_draw(MENU_X_START_L, MENU_Y_START+2*MENU_Y_DIFF, back_string, LEFT, FALSE, LEVEL_EVENT(GI_MENU_BACK_POP));
945
946
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
947
p_grf->flip();
948
}
949
break;
950
951
case MENU_LEAVE:
952
input.mevent_clear();
953
break;
954
955
default:
956
break;
957
}
958
}
959
960
/* Load a hint for given level */
961
962
#define MARK_START "~%d_%d"
963
#define MARK_END "~"
964
965
char * game_gui::level_hint_load(int set, int level)
966
{
967
FHANDLE f = file_open(p_dir->gamedata_get(), LEVEL_HINTS_FILE, "r");
968
969
char start_mark[1000];
970
snprintf(start_mark,1000,MARK_START,set+1,level+1);
971
972
// Search a mark in the hint file
973
char line[1000];
974
char *p_tmp = NULL;
975
while(fgets(line,1000,f)) {
976
if((p_tmp = strstr(line,start_mark)) && p_tmp == line) {
977
break;
978
}
979
}
980
981
// Did we find it?
982
if(!p_tmp || p_tmp != line) {
983
return(NULL);
984
}
985
986
// Load the hind
987
#define HINT_BUFFER_LENGHT 40000
988
static char hint_buffer[HINT_BUFFER_LENGHT];
989
990
p_tmp = hint_buffer;
991
while(1) {
992
p_tmp = fgets(p_tmp, HINT_BUFFER_LENGHT - (p_tmp - hint_buffer), f);
993
if(!p_tmp)
994
break;
995
if(p_tmp[0] == MARK_END[0]) {
996
*p_tmp = '\0';
997
break;
998
}
999
p_tmp = p_tmp + strlen(p_tmp);
1000
}
1001
1002
fclose(f);
1003
return(hint_buffer);
1004
}
1005
1006
/* Load end text for given episode */
1007
char * game_gui::level_end_text_load(int set)
1008
{
1009
char file[MAX_FILENAME];
1010
snprintf(file,MAX_FILENAME,SET_END_FILE_TEXT,set);
1011
1012
#define END_BUFFER_LENGHT 40000
1013
static char end_buffer[END_BUFFER_LENGHT];
1014
file_load_text(p_dir->gamedata_get(),file,end_buffer,END_BUFFER_LENGHT);
1015
1016
return(end_buffer);
1017
}
1018
1019
/* Load text for credits */
1020
char * game_gui::credit_text_load(void)
1021
{
1022
#define CREDITS_FILE "credits.dat"
1023
1024
// Load the whole file
1025
#define END_BUFFER_LENGHT 40000
1026
static char cr_buffer[END_BUFFER_LENGHT];
1027
file_load_text(p_dir->gamedata_get(), CREDITS_FILE, cr_buffer, END_BUFFER_LENGHT);
1028
1029
return(cr_buffer);
1030
}
1031
1032
/* Load an external level from command line */
1033
bool game_gui::level_run(LEVEL_EVENT_QUEUE *p_queue, char *p_level)
1034
{
1035
assert(p_ber);
1036
1037
/* Quit if it fails */
1038
if(p_ber->level_load(p_level) && p_ber->level_play(p_queue, 0)) {
1039
menu_leave();
1040
input.keyset_set(&game_keys);
1041
return(TRUE);
1042
} else {
1043
menu_dialog_error(_("Unable to load level %s"),p_level);
1044
p_queue->add(LEVEL_EVENT(GC_MENU_QUIT));
1045
return(FALSE);
1046
}
1047
}
1048
1049
/* Load specified level from level set */
1050
bool game_gui::level_run(LEVEL_EVENT_QUEUE *p_queue, int set, int level)
1051
{
1052
assert(p_ber);
1053
1054
menu_leave();
1055
1056
/* Run a menu if it fails */
1057
if(p_ber->levelset_load(set) && p_ber->level_play(p_queue, level)) {
1058
input.keyset_set(&game_keys);
1059
return(TRUE);
1060
} else {
1061
menu_dialog_error(_("Unable to load level %d from set %d"),level,set);
1062
p_queue->add(LEVEL_EVENT(GC_MENU_START));
1063
return(FALSE);
1064
}
1065
}
1066
1067
//void level_stop(LEVEL_EVENT_QUEUE *p_queue, bool resolved, bool levelset, int set, int level);
1068
void game_gui::level_stop(LEVEL_EVENT_QUEUE *p_queue, int cheat, int menu)
1069
{
1070
assert(p_ber);
1071
1072
input.keyset_set(NULL);
1073
1074
LEVEL_STATUS *p_status = p_ber->level_stop(p_queue);
1075
1076
if(menu) {
1077
int level = p_ber->levelset_get_level();
1078
int set = p_ber->levelset_get_set();
1079
1080
if(cheat)
1081
p_status->bug_in_exit();
1082
1083
if(p_status->resolved()) {
1084
if(p_ber->levelset_is_custom()) {
1085
p_queue->add(LEVEL_EVENT(GC_MENU_END_LEVEL_CUSTOM));
1086
} else {
1087
if(level+1 < p_ber->levelset_get_levelnum()) {
1088
p_queue->add(LEVEL_EVENT(GC_MENU_END_LEVEL, set, level));
1089
} else {
1090
p_queue->add(LEVEL_EVENT(GC_MENU_END_LEVEL_SET, set));
1091
}
1092
}
1093
} else {
1094
if(p_ber->levelset_is_custom()) {
1095
/* if we run it from command line, stop it */
1096
p_queue->add(LEVEL_EVENT(GC_MENU_QUIT));
1097
} else {
1098
/* if we run it from set, return to menu */
1099
p_queue->add(LEVEL_EVENT(GC_MENU_END_LEVEL, set, level));
1100
}
1101
}
1102
}
1103
}
1104
1105
#undef MENU_X_START_L
1106
#undef MENU_X_START_R
1107
#undef MENU_Y_START
1108
#undef MENU_X_DIFF
1109
#undef MENU_Y_DIFF
1110
1111
void game_gui::menu_level_end(MENU_STATE state, int data, int data1)
1112
{
1113
switch(state) {
1114
case MENU_RETURN:
1115
case MENU_ENTER:
1116
{
1117
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_level_end, data, data1);
1118
1119
/* Some statistics here */
1120
p_grf->fill(0,0,GAME_RESOLUTION_X,GAME_RESOLUTION_Y,0);
1121
p_font->alignment_set(CENTER);
1122
p_font->select(FONT_DEFAULT);
1123
1124
LEVEL_STATUS *p_status = p_ber->level_status_get();
1125
char tmp[100];
1126
1127
#define SMALL_LOGO_START 80
1128
p_grf->draw(MENU_SPRIT_LOGO_SMALL_2,p_grf->sprite_get_width_center(MENU_SPRIT_LOGO_SMALL_2),SMALL_LOGO_START);
1129
1130
if(p_status->resolved()) {
1131
p_font->print(NULL,0,SMALL_LOGO_START+100,_("your bugs have survived!"));
1132
p_font->print(NULL,0,SMALL_LOGO_START+130,_("difficulty %s"), p_ber->levelset_get_difficulty());
1133
p_font->print(NULL,0,SMALL_LOGO_START+180,_("it takes %d steps"), p_status->steps_get());
1134
p_font->print(NULL,0,SMALL_LOGO_START+210,_("and %s."), p_status->time_get(tmp,100));
1135
} else {
1136
p_font->print(NULL,0,SMALL_LOGO_START+100,_("your bugs have given it up!"));
1137
p_font->print(NULL,0,SMALL_LOGO_START+130,_("difficulty %s"), p_ber->levelset_get_difficulty());
1138
p_font->print(NULL,0,SMALL_LOGO_START+180,_("they made %d steps"), p_status->steps_get());
1139
p_font->print(NULL,0,SMALL_LOGO_START+210,_("and spent %s"), p_status->time_get(tmp,100));
1140
}
1141
1142
p_grf->draw(MENU_SPRIT_LOGO_SMALL_3,p_grf->sprite_get_width_center(MENU_SPRIT_LOGO_SMALL_3),SMALL_LOGO_START+240);
1143
1144
#define MENU_X_START_L (320 - 17 - 120)
1145
#define MENU_X_START_R (320 + 120)
1146
#define MENU_Y_START 400
1147
#define MENU_X_DIFF 0
1148
#define MENU_Y_DIFF 30
1149
1150
static char *play_string = _("play next level");
1151
static char *back_string = _("back to menu");
1152
1153
menu_item_start();
1154
1155
if(p_status->resolved()) {
1156
int set = data;
1157
int level = data1;
1158
menu_item_draw(MENU_X_START_R, MENU_Y_START+0*MENU_Y_DIFF, play_string, RIGHT, FALSE, LEVEL_EVENT(GC_MENU_RUN_LEVEL, set, level+1));
1159
}
1160
1161
menu_item_draw(MENU_X_START_L, MENU_Y_START+1*MENU_Y_DIFF, back_string, LEFT, FALSE, LEVEL_EVENT(GI_MENU_BACK_POP));
1162
1163
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
1164
p_grf->flip();
1165
}
1166
break;
1167
1168
case MENU_LEAVE:
1169
input.mevent_clear();
1170
break;
1171
1172
default:
1173
break;
1174
}
1175
}
1176
1177
void game_gui::menu_level_end_custom(MENU_STATE state, int data, int data1)
1178
{
1179
switch(state) {
1180
case MENU_RETURN:
1181
case MENU_ENTER:
1182
{
1183
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_level_end_custom, data, data1);
1184
1185
/* Some statistics here */
1186
p_grf->fill(0,0,GAME_RESOLUTION_X,GAME_RESOLUTION_Y,0);
1187
p_font->alignment_set(CENTER);
1188
p_font->select(FONT_DEFAULT);
1189
1190
#define SMALL_LOGO_START 80
1191
p_grf->draw(MENU_SPRIT_LOGO_SMALL_2,p_grf->sprite_get_width_center(MENU_SPRIT_LOGO_SMALL_2),SMALL_LOGO_START);
1192
1193
p_font->print(NULL,0,SMALL_LOGO_START+100,_("your bugs have survived!"));
1194
p_font->print(NULL,0,SMALL_LOGO_START+130,_("custom level %s."), p_ber->levelset_get_name());
1195
1196
LEVEL_STATUS *p_status = p_ber->level_status_get();
1197
p_font->print(NULL,0,SMALL_LOGO_START+180,_("it takes %d steps"), p_status->steps_get());
1198
char tmp[100];
1199
p_font->print(NULL,0,SMALL_LOGO_START+210,_("and %s."), p_status->time_get(tmp,100));
1200
1201
p_grf->draw(MENU_SPRIT_LOGO_SMALL_3,p_grf->sprite_get_width_center(MENU_SPRIT_LOGO_SMALL_3),SMALL_LOGO_START+240);
1202
1203
#define MENU_X_START (320 - 35)
1204
#define MENU_Y_START 400
1205
#define MENU_X_DIFF 0
1206
#define MENU_Y_DIFF 30
1207
1208
static char *back_string = _("quit");
1209
1210
menu_item_start();
1211
menu_item_draw(MENU_X_START, MENU_Y_START+0*MENU_Y_DIFF, back_string, LEFT, FALSE, LEVEL_EVENT(GC_MENU_QUIT));
1212
1213
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
1214
p_grf->flip();
1215
}
1216
break;
1217
1218
case MENU_LEAVE:
1219
input.mevent_clear();
1220
break;
1221
1222
default:
1223
break;
1224
}
1225
}
1226
1227
#undef MENU_X_START_L
1228
#undef MENU_Y_START
1229
#undef SCROLL_START_X
1230
#undef SCROLL_START_Y
1231
#undef SCROLL_LINES
1232
1233
/*
1234
int set = data;
1235
*/
1236
void game_gui::menu_levelset_end(MENU_STATE state, int data, int data1)
1237
{
1238
static char *p_text = NULL;
1239
static int frame = 0;
1240
static int position;
1241
1242
switch(state) {
1243
case MENU_RETURN:
1244
case MENU_ENTER:
1245
{
1246
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_levelset_end, data, data1);
1247
1248
int set = data;
1249
1250
p_text = level_end_text_load(set);
1251
assert(p_text);
1252
1253
sprite::color_key_set(COLOR_KEY_GAME);
1254
p_grf->sprite_delete(MENU_SPRIT_END, 1);
1255
1256
char line[1000];
1257
snprintf(line, 1000, SET_END_FILE_BACK, set+1);
1258
p_grf->sprite_insert(line, MENU_SPRIT_END, 1, NULL);
1259
1260
input.keyset_set(&menu_keys);
1261
1262
menu_timer.set((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_levelset_end, data, data1);
1263
frame = 0;
1264
position = 0;
1265
}
1266
break;
1267
1268
case MENU_TIMER:
1269
{
1270
if((frame & 0x3) == 0x0) {
1271
p_font->alignment_set(CENTER);
1272
p_font->select(FONT_DEFAULT);
1273
1274
p_grf->draw(MENU_SPRIT_END,0,0);
1275
1276
if(position >= p_font->height_get_new_line(p_text)) {
1277
position -= p_font->height_get_new_line(p_text);
1278
p_text = strchr(p_text+1,'\n');
1279
}
1280
1281
if(p_text) {
1282
#define SCROLL_START_X 0
1283
#define SCROLL_START_Y 0
1284
#define SCROLL_LINES 20
1285
1286
p_font->print(NULL, SCROLL_START_X, SCROLL_START_Y-position, SCROLL_LINES, p_text);
1287
} else {
1288
menu_timer.clear();
1289
1290
#define MENU_X_START_L (320 - 17)
1291
#define MENU_Y_START 440
1292
1293
static char *back_string = _("back");
1294
1295
menu_item_start();
1296
menu_item_draw(MENU_X_START_L, MENU_Y_START, back_string, LEFT, FALSE, LEVEL_EVENT(GC_MENU_START));
1297
}
1298
1299
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
1300
p_grf->flip();
1301
1302
/* pokud jsem na konci -> odregistrovat timer, pridat <- back menu
1303
*/
1304
position += 2;
1305
}
1306
frame++;
1307
}
1308
break;
1309
1310
case MENU_LEAVE:
1311
p_text = NULL;
1312
menu_timer.clear();
1313
input.keyset_set(NULL);
1314
input.mevent_clear();
1315
break;
1316
1317
default:
1318
break;
1319
}
1320
}
1321
1322
#undef LOGO_START
1323
#undef MENU_X_START
1324
#undef MENU_Y_START
1325
#undef MENU_X_DIFF
1326
#undef MENU_Y_DIFF
1327
1328
void game_gui::menu_in_game(MENU_STATE state, int data, int data1)
1329
{
1330
switch(state) {
1331
case MENU_RETURN:
1332
case MENU_ENTER:
1333
{
1334
menu_enter((GUI_BASE *)this,(GUI_BASE_FUNC)&game_gui::menu_in_game, data, data1);
1335
1336
p_grf->fill(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y, 0);
1337
1338
tpos width = p_grf->sprite_get_width(MENU_SPRIT_LOGO);
1339
1340
#define LOGO_START 0
1341
1342
p_grf->draw(MENU_SPRIT_LOGO,(GAME_RESOLUTION_X-width)/2,LOGO_START);
1343
1344
#define MENU_X_START 200
1345
#define MENU_Y_START 180
1346
#define MENU_X_DIFF 0
1347
#define MENU_Y_DIFF 35
1348
1349
static char *back = _("return to game (ESC)");
1350
static char *rest = _("restart level (CTRL+R)");
1351
1352
static char *save = _("save game (F2)");
1353
static char *load = _("load game (F3)");
1354
1355
static char *hint = _("level hint (CTRL+F1)");
1356
static char *help = _("help (F1)");
1357
1358
static char *menu = _("back to main menu");
1359
static char *quit = _("quit (CTRL+X)");
1360
1361
menu_item_set_pos(MENU_X_START, MENU_Y_START);
1362
menu_item_set_diff(MENU_X_DIFF, MENU_Y_DIFF);
1363
1364
menu_item_start();
1365
1366
menu_item_draw(back, LEFT, FALSE, LEVEL_EVENT(GC_RESTORE_LEVEL));
1367
menu_item_draw(rest, LEFT, FALSE, LEVEL_EVENT(GC_RESTART_LEVEL));
1368
1369
menu_item_draw(save, LEFT, FALSE, LEVEL_EVENT(GC_SAVE_LEVEL));
1370
menu_item_draw(load, LEFT, FALSE, LEVEL_EVENT(GC_LOAD_LEVEL));
1371
1372
menu_item_draw(hint, LEFT, TRUE, LEVEL_EVENT(GC_MENU_LEVEL_HINT, FALSE));
1373
menu_item_draw(help, LEFT, TRUE, LEVEL_EVENT(GC_MENU_HELP, FALSE));
1374
1375
menu_item_draw(menu, LEFT, FALSE, LEVEL_EVENT(GC_STOP_LEVEL, FALSE, FALSE), LEVEL_EVENT(GC_MENU_START));
1376
menu_item_draw(quit, LEFT, FALSE, LEVEL_EVENT(GC_STOP_LEVEL, FALSE, FALSE), LEVEL_EVENT(GC_MENU_QUIT));
1377
1378
p_grf->redraw_add(0, 0, GAME_RESOLUTION_X, GAME_RESOLUTION_Y);
1379
p_grf->flip();
1380
}
1381
break;
1382
1383
case MENU_LEAVE:
1384
input.mevent_clear();
1385
break;
1386
default:
1387
break;
1388
}
1389
}
1390
1391
void game_gui::level_suspend(LEVEL_EVENT_QUEUE *p_queue)
1392
{
1393
input.keyset_set(&suspend_keys);
1394
p_ber->level_suspend(p_queue);
1395
}
1396
1397
void game_gui::level_restore(LEVEL_EVENT_QUEUE *p_queue)
1398
{
1399
menu_leave();
1400
1401
input.keyset_set(&game_keys);
1402
p_ber->level_restore(p_queue);
1403
}
1404
1405
void game_gui::level_restart(LEVEL_EVENT_QUEUE *p_queue)
1406
{
1407
menu_leave();
1408
1409
input.keyset_set(&game_keys);
1410
p_ber->level_restart(p_queue);
1411
}
1412
1413
void game_gui::level_save(LEVEL_EVENT_QUEUE *p_queue)
1414
{
1415
if(p_ber) {
1416
p_ber->level_save();
1417
1418
p_font->select(FONT_DEFAULT);
1419
p_font->alignment_set(LEFT);
1420
p_grf->fill(0,460,GAME_RESOLUTION_X,20,0);
1421
p_font->print(NULL,0,460,_("Level saved..."));
1422
p_grf->redraw_add(0,460,GAME_RESOLUTION_X,20);
1423
p_grf->flip();
1424
delay(500);
1425
}
1426
}
1427
1428
void game_gui::level_load(LEVEL_EVENT_QUEUE *p_queue)
1429
{
1430
if(p_ber) {
1431
p_ber->level_load();
1432
1433
p_font->select(FONT_DEFAULT);
1434
p_font->alignment_set(LEFT);
1435
p_grf->fill(0,460,GAME_RESOLUTION_X,20,0);
1436
p_font->print(NULL,0,460,_("Level loaded..."));
1437
p_grf->redraw_add(0,460,GAME_RESOLUTION_X,20);
1438
p_grf->flip();
1439
delay(500);
1440
}
1441
}
1442
1443
void game_gui::run_editor(void)
1444
{
1445
#ifdef LINUX
1446
int pid = fork();
1447
if(!pid) {
1448
bprintf("%s -e",p_dir->game_binary_get());
1449
int ret = execlp(p_dir->game_binary_get(),p_dir->game_binary_get(),"-e",NULL);
1450
if(ret == -1) {
1451
bprintf("Error: %s",strerror(errno));
1452
}
1453
}
1454
else {
1455
int status;
1456
bprintf("Waiting for %d",pid);
1457
waitpid(pid,&status,0);
1458
bprintf("Pid %d done",pid);
1459
}
1460
#elif WINDOWS
1461
bprintf("%s -e",p_dir->game_binary_get());
1462
int ret = _spawnl( _P_WAIT, p_dir->game_binary_get(),p_dir->game_binary_get(),"-e",NULL);
1463
if(ret == -1) {
1464
bprintf("Error: %s",strerror(errno));
1465
}
1466
#endif
1467
}
1468
1469
bool game_gui::callback(LEVEL_EVENT_QUEUE *p_queue, int frame)
1470
{
1471
/* If there's a timer function, call it! */
1472
if(menu_timer.valid()) {
1473
(this->*menu_timer.p_func)(MENU_TIMER, menu_timer.p1, menu_timer.p2);
1474
}
1475
1476
/* load events from system by SDL event handler */
1477
input.events_loop(p_queue);
1478
1479
/* Scan the queue and do the propper action */
1480
static LEVEL_EVENT_QUEUE tmp_queue;
1481
1482
while(!p_queue->empty()) {
1483
LEVEL_EVENT ev = p_queue->get();
1484
1485
switch(ev.action_get()) {
1486
/* Start of the game
1487
* This is the firts event after start
1488
*/
1489
case GC_MENU_START:
1490
menu_main(MENU_ENTER);
1491
break;
1492
case GC_MENU_NEW_GAME:
1493
menu_new_game(MENU_ENTER);
1494
break;
1495
case GC_MENU_PASSWORD:
1496
menu_password(MENU_ENTER);
1497
break;
1498
case GC_MENU_PASSWORD_CHECK:
1499
menu_password_check(MENU_ENTER, ev.param_int_get(PARAM_0));
1500
break;
1501
case GC_MENU_HELP:
1502
menu_help(MENU_ENTER, ev.param_int_get(PARAM_0));
1503
break;
1504
case GC_MENU_QUIT:
1505
return(FALSE);
1506
break;
1507
case GC_MENU_HELP_KEYS:
1508
menu_help_keys(MENU_ENTER, ev.param_int_get(PARAM_0));
1509
break;
1510
case GC_MENU_HELP_RULES:
1511
menu_help_rules(MENU_ENTER, ev.param_int_get(PARAM_0), ev.param_int_get(PARAM_1));
1512
break;
1513
case GC_MENU_HELP_CREDIT:
1514
menu_help_credits(MENU_ENTER, ev.param_int_get(PARAM_0));
1515
break;
1516
case GC_MENU_LEVEL_HINT:
1517
menu_level_hint(MENU_ENTER, ev.param_int_get(PARAM_0));
1518
break;
1519
1520
case GC_RUN_LEVEL_LINE:
1521
level_run(&tmp_queue, (char *)ev.param_point_get(PARAM_0));
1522
break;
1523
case GC_RUN_LEVEL_SET:
1524
level_run(&tmp_queue, ev.param_int_get(PARAM_0), ev.param_int_get(PARAM_1));
1525
break;
1526
case GC_STOP_LEVEL:
1527
level_stop(&tmp_queue, ev.param_int_get(PARAM_0), ev.param_int_get(PARAM_1));
1528
break;
1529
1530
case GC_SUSPEND_LEVEL:
1531
level_suspend(&tmp_queue);
1532
break;
1533
case GC_RESTORE_LEVEL:
1534
level_restore(&tmp_queue);
1535
break;
1536
1537
case GC_RESTART_LEVEL:
1538
level_restart(&tmp_queue);
1539
break;
1540
1541
case GC_SAVE_LEVEL:
1542
level_save(&tmp_queue);
1543
break;
1544
case GC_LOAD_LEVEL:
1545
level_load(&tmp_queue);
1546
break;
1547
1548
case GC_MENU_RUN_LEVEL:
1549
menu_level_run(MENU_ENTER, ev.param_int_get(PARAM_0), ev.param_int_get(PARAM_1));
1550
break;
1551
case GC_MENU_END_LEVEL:
1552
menu_level_end(MENU_ENTER, ev.param_int_get(PARAM_0), ev.param_int_get(PARAM_1));
1553
break;
1554
case GC_MENU_END_LEVEL_CUSTOM:
1555
menu_level_end_custom(MENU_ENTER, ev.param_int_get(PARAM_0), ev.param_int_get(PARAM_1));
1556
break;
1557
case GC_MENU_END_LEVEL_SET:
1558
menu_levelset_end(MENU_ENTER, ev.param_int_get(PARAM_0));
1559
break;
1560
1561
case GC_MENU_IN_GAME:
1562
menu_in_game(MENU_ENTER);
1563
break;
1564
1565
case GC_RUN_EDITOR:
1566
run_editor();
1567
break;
1568
1569
case GI_MENU_BACK_POP:
1570
back_pop();
1571
break;
1572
case GI_MENU_BACK_PUSH:
1573
back_push();
1574
break;
1575
1576
case GI_SPRITE_DRAW:
1577
case GI_STRING_DRAW:
1578
case GI_KEY_DOWN:
1579
menu_services(ev);
1580
break;
1581
1582
default:
1583
assert(ev.valid());
1584
tmp_queue.add(ev);
1585
tmp_queue.commit();
1586
break;
1587
}
1588
}
1589
1590
/* Commit all writes */
1591
p_queue->add(&tmp_queue);
1592
p_queue->commit();
1593
tmp_queue.clear();
1594
1595
/* Call the game (if exists) */
1596
if(p_ber) {
1597
p_ber->level_callback(p_queue);
1598
}
1599
1600
return(TRUE);
1601
}
1602
1603
void game_gui::menu_dialog_error(char *p_text,...)
1604
{
1605
/*
1606
#define MAX_TEXT_LEN 2000
1607
1608
char text[MAX_TEXT_LEN];
1609
va_list arguments;
1610
1611
va_start(arguments,p_text);
1612
vsnprintf(text,MAX_TEXT_LEN,p_text,arguments);
1613
va_end(arguments);
1614
1615
GtkWidget *dialog = gtk_message_dialog_new(main_window_get(),
1616
GTK_DIALOG_DESTROY_WITH_PARENT,
1617
GTK_MESSAGE_ERROR,
1618
GTK_BUTTONS_CLOSE,
1619
text);
1620
gtk_dialog_run (GTK_DIALOG (dialog));
1621
gtk_widget_destroy (dialog);
1622
*/
1623
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1