DEADSOFTWARE

menu: remove data field from menu_t
[flatwaifu.git] / src / menu.c
1 /*
2 Copyright (C) Prikol Software 1996-1997
3 Copyright (C) Aleksey Volynskov 1996-1997
4 Copyright (C) <ARembo@gmail.com> 2011
6 This file is part of the Doom2D:Rembo project.
8 Doom2D:Rembo is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License version 2 as
10 published by the Free Software Foundation.
12 Doom2D:Rembo is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, see <http://www.gnu.org/licenses/> or
19 write to the Free Software Foundation, Inc.,
20 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 */
23 #include "glob.h"
24 #include "files.h"
25 #include "memory.h"
26 #include "error.h"
27 #include "sound.h"
28 #include "view.h"
29 #include "player.h"
30 #include "switch.h"
31 #include "menu.h"
32 #include "misc.h"
33 #include "render.h"
34 #include "config.h"
35 #include "game.h"
36 #include "player.h"
37 #include "sound.h"
38 #include "music.h"
39 #include "input.h"
40 #include "system.h"
42 #include "save.h"
44 #include <stdio.h>
45 #include <string.h>
46 #include <stdlib.h>
47 #include <assert.h>
49 #define PCOLORN 10
50 static byte pcolortab[PCOLORN] = {
51 0x18, 0x20, 0x40, 0x58, 0x60, 0x70, 0x80, 0xB0, 0xC0, 0xD0
52 };
53 static int p1color = 5;
54 static int p2color = 4;
56 byte _warp;
58 #define MAX_STACK 8
59 static struct {
60 const menu_t *m;
61 } stack[MAX_STACK];
62 static int stack_p = -1;
64 #define GM_MAX_INPUT 24
65 char ibuf[GM_MAX_INPUT];
66 byte input;
67 int icur;
68 int imax;
69 static byte cbuf[32];
70 short lastkey;
72 #define QSND_NUM 14
73 static int qsnd[QSND_NUM];
74 static snd_t *csnd1, *csnd2, *msnd1, *msnd2, *msnd3, *msnd4, *msnd5, *msnd6;
75 static snd_t *voc;
76 static int voc_ch;
78 static void GM_stop (void) {
79 if (voc != NULL) {
80 if (voc_ch) {
81 S_stop(voc_ch);
82 voc_ch = 0;
83 }
84 S_free(voc);
85 voc = NULL;
86 }
87 }
89 static int GM_say (const char nm[8]) {
90 snd_t *snd = S_load(nm);
91 if (snd) {
92 GM_stop();
93 voc = S_load(nm);
94 voc_ch = S_play(voc, 0, 255);
95 }
96 return 1;
97 }
99 int GM_init_int0 (menu_msg_t *msg, int i, int a, int b, int s) {
100 assert(msg != NULL);
101 msg->integer.i = i;
102 msg->integer.a = a;
103 msg->integer.b = b;
104 msg->integer.s = s;
105 return 1;
108 int GM_init_int (menu_msg_t *msg, int i, int a, int b, int s) {
109 assert(msg != NULL);
110 assert(a <= b);
111 assert(s >= 0);
112 return GM_init_int0(msg, min(max(i, a), b), a, b, s);
115 int GM_init_str (menu_msg_t *msg, char *str, int maxlen) {
116 assert(msg != NULL);
117 assert(str != NULL);
118 assert(maxlen >= 0);
119 msg->string.s = str;
120 msg->string.maxlen = maxlen;
121 return 1;
124 int basic_menu_handler (menu_msg_t *msg, byte type, char *title, char *say, int n, int *cur) {
125 assert(msg != NULL);
126 assert(type == GM_BIG || type == GM_SMALL);
127 assert(title != NULL);
128 assert(n >= 0);
129 assert(cur != NULL);
130 switch (msg->type) {
131 case GM_QUERY: return GM_init_int0(msg, *cur, n, n, type);
132 case GM_GETTITLE: return GM_init_str(msg, title, strlen(title));
133 case GM_ENTER: return say ? GM_say(say) : 1;
134 case GM_UP: *cur = GM_CYCLE(*cur - 1, 0, n - 1); return 1;
135 case GM_DOWN: *cur = GM_CYCLE(*cur + 1, 0, n - 1); return 1;
137 return 0;
140 int simple_menu_handler (menu_msg_t *msg, int i, int n, const simple_menu_t *m, int *cur) {
141 assert(msg != NULL);
142 assert(n >= 0);
143 assert(i >= 0 && i < n);
144 assert(m != NULL);
145 assert(cur != NULL);
146 switch (msg->type) {
147 case GM_GETENTRY: return GM_init_int0(msg, m->type == GM_SMALL ? GM_SMALL_BUTTON : GM_BUTTON, 0, 0, 0);
148 case GM_GETCAPTION: return GM_init_str(msg, m->entries[i].caption, strlen(m->entries[i].caption));
149 case GM_SELECT: return m->entries[i].submenu ? GM_push(m->entries[i].submenu) : 1;
151 return basic_menu_handler(msg, m->type, m->title, m->say, n, cur);
154 static int start_game (int twoplayers, int dm, int level) {
155 _2pl = twoplayers;
156 g_dm = dm;
157 g_map = level ? level : 1;
158 PL_reset();
159 pl1.color = pcolortab[p1color];
160 pl2.color = pcolortab[p2color];
161 G_start();
162 return GM_popall();
165 static int new_game_menu_handler (menu_msg_t *msg, const menu_t *m, int i) {
166 static int cur;
167 enum { ONEPLAYER, TWOPLAYERS, DEATHMATCH, __NUM__ };
168 static const simple_menu_t sm = {
169 GM_BIG, "New Game", "_NEWGAME",
171 { "One Player", NULL },
172 { "Two Players", NULL },
173 { "Deathmatch", NULL },
175 };
176 if (msg->type == GM_SELECT) {
177 switch (i) {
178 case ONEPLAYER: GM_say("_1PLAYER"); return start_game(0, 0, _warp);
179 case TWOPLAYERS: GM_say("_2PLAYER"); return start_game(1, 0, _warp);
180 case DEATHMATCH: GM_say("_DM"); return start_game(1, 1, _warp);
181 // GM_say("_COOP");
184 return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
187 static int load_game_menu_handler (menu_msg_t *msg, const menu_t *m, int i) {
188 static int cur;
189 const int max_slots = 7;
190 assert(i >= 0 && i < max_slots);
191 switch (msg->type) {
192 case GM_ENTER: F_getsavnames(); break;
193 case GM_GETENTRY: return GM_init_int0(msg, GM_TEXTFIELD_BUTTON, 0, 0, 0);
194 case GM_GETSTR: return GM_init_str(msg, (char*)savname[i], 24);
195 case GM_SELECT:
196 if (savok[i]) {
197 load_game(i);
198 GM_popall();
200 return 1;
202 return basic_menu_handler(msg, GM_BIG, "Load game", "_OLDGAME", max_slots, &cur);
205 static int save_game_menu_handler (menu_msg_t *msg, const menu_t *m, int i) {
206 static int cur;
207 const int max_slots = 7;
208 assert(i >= 0 && i < max_slots);
209 switch (msg->type) {
210 case GM_ENTER:
211 if (g_st == GS_GAME) {
212 F_getsavnames();
213 break;
214 } else {
215 return GM_pop();
217 case GM_GETENTRY: return GM_init_int0(msg, GM_TEXTFIELD, 0, 0, 0);
218 case GM_GETSTR: return GM_init_str(msg, (char*)savname[i], 24);
219 case GM_END:
220 if (g_st == GS_GAME) {
221 assert(msg->string.maxlen >= 24);
222 F_savegame(i, msg->string.s);
224 return GM_popall();
226 return basic_menu_handler(msg, GM_BIG, "Save game", "_SAVGAME", max_slots, &cur);
229 static int options_menu_handler (menu_msg_t *msg, const menu_t *m, int i) {
230 static int cur;
231 const menu_t *mm;
232 enum { VIDEO, SOUND, MUSIC, __NUM__ };
233 static const simple_menu_t sm = {
234 GM_BIG, "Options", NULL,
236 { "Video", NULL },
237 { "Sound", NULL },
238 { "Music", NULL },
240 };
241 if (msg->type == GM_SELECT) {
242 switch (i) {
243 case VIDEO: mm = R_menu(); break;
244 case SOUND: mm = S_menu(); break;
245 case MUSIC: mm = MUS_menu(); break;
246 default: mm = NULL;
248 if (mm != NULL) {
249 return GM_push(mm);
252 return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
255 static int exit_menu_handler (menu_msg_t *msg, const menu_t *m, int i) {
256 static int cur;
257 enum { YES, NO, __NUM__ };
258 static const simple_menu_t sm = {
259 GM_SMALL, "You are sure?", NULL,
261 { "Yes", NULL },
262 { "No", NULL },
264 };
265 if (msg->type == GM_ENTER) {
266 return GM_say(rand() & 1 ? "_EXIT1" : "_EXIT2");
267 } else if (msg->type == GM_SELECT) {
268 switch (i) {
269 case YES:
270 MUS_free();
271 GM_stop();
272 Z_sound(S_get(qsnd[myrand(QSND_NUM)]), 255);
273 S_wait();
274 ERR_quit();
275 return 1;
276 case NO:
277 return GM_pop();
280 return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
283 static int main_menu_handler (menu_msg_t *msg, const menu_t *m, int i) {
284 enum { NEWGAME, OLDGAME, SAVEGAME, OPTIONS, EXIT, __NUM__ };
285 assert(i >= 0 && i < __NUM__);
286 static int cur;
287 static const menu_t hm[__NUM__] = {
288 { new_game_menu_handler },
289 { load_game_menu_handler },
290 { save_game_menu_handler },
291 { options_menu_handler},
292 { exit_menu_handler }
293 };
294 static const simple_menu_t sm = {
295 GM_BIG, "Menu", NULL,
297 { "New Game", &hm[NEWGAME] },
298 { "Load Game", &hm[OLDGAME] },
299 { "Save Game", &hm[SAVEGAME] },
300 { "Options", &hm[OPTIONS] },
301 { "Exit", &hm[EXIT] }
303 };
304 return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
307 static const menu_t main_menu = { &main_menu_handler };
309 int GM_push (const menu_t *m) {
310 assert(m != NULL);
311 assert(stack_p >= -1);
312 assert(stack_p < MAX_STACK - 1);
313 menu_msg_t msg;
314 stack_p += 1;
315 stack[stack_p].m = m;
316 msg.type = GM_ENTER;
317 GM_send_this(m, &msg);
318 return 1;
321 int GM_pop (void) {
322 assert(stack_p >= 0);
323 menu_msg_t msg;
324 stack_p -= 1;
325 msg.type = GM_LEAVE;
326 GM_send_this(stack[stack_p + 1].m, &msg);
327 return 1;
330 int GM_popall (void) {
331 int i;
332 for (i = 0; i >= -1; i--) {
333 GM_pop();
335 return 1;
338 const menu_t *GM_get (void) {
339 if (stack_p >= 0) {
340 return stack[stack_p].m;
341 } else {
342 return NULL;
346 static void GM_normalize_message (menu_msg_t *msg) {
347 switch (msg->type) {
348 case GM_SETINT:
349 msg->integer.i = min(max(msg->integer.i, msg->integer.a), msg->integer.b);
350 break;
351 case GM_SETSTR:
352 assert(msg->string.maxlen >= 0);
353 break;
357 int GM_send_this (const menu_t *m, menu_msg_t *msg) {
358 assert(m != NULL);
359 assert(msg != NULL);
360 if (m->handler != NULL) {
361 GM_normalize_message(msg);
362 return m->handler(msg, m, 0);
364 return 0;
367 int GM_send (const menu_t *m, int i, menu_msg_t *msg) {
368 assert(m != NULL);
369 assert(i >= 0);
370 assert(msg != NULL);
371 if (m->handler != NULL) {
372 GM_normalize_message(msg);
373 return m->handler(msg, m, i);
375 return 0;
378 void G_code (void) {
379 void *s;
380 s=csnd2;
381 if(memcmp(cbuf+32-5,"IDDQD",5)==0) {
382 PL_hit(&pl1,400,0,HIT_SOME);
383 if(_2pl) PL_hit(&pl2,400,0,HIT_SOME);
384 s=csnd1;
385 }else if(memcmp(cbuf+32-4,"TANK",4)==0) {
386 pl1.life=pl1.armor=200;pl1.drawst|=PL_DRAWARMOR|PL_DRAWLIFE;
387 if(_2pl) {pl2.life=pl2.armor=200;pl2.drawst|=PL_DRAWARMOR|PL_DRAWLIFE;}
388 }else if(memcmp(cbuf+32-8,"BULLFROG",8)==0) {
389 PL_JUMP=(PL_JUMP==10)?20:10;
390 }else if(memcmp(cbuf+32-8,"FORMULA1",8)==0) {
391 PL_RUN=(PL_RUN==8)?24:8;
392 }else if(memcmp(cbuf+32-5,"RAMBO",5)==0) {
393 pl1.ammo=pl1.shel=pl1.rock=pl1.cell=pl1.fuel=30000;
394 pl1.wpns=0x7FF;pl1.drawst|=PL_DRAWWPN|PL_DRAWKEYS;
395 pl1.keys=0x70;
396 if(_2pl) {
397 pl2.ammo=pl2.shel=pl2.rock=pl2.cell=pl1.fuel=30000;
398 pl2.wpns=0x7FF;pl2.drawst|=PL_DRAWWPN|PL_DRAWKEYS;
399 pl2.keys=0x70;
401 }else if(memcmp(cbuf+32-5,"UJHTW",5)==0) {
402 p_immortal=!p_immortal;
403 }else if(memcmp(cbuf+32-9,",TKSQJHTK",9)==0) {
404 p_fly=!p_fly;
405 }else if(memcmp(cbuf+32-6,"CBVCBV",6)==0) {
406 SW_cheat_open();
407 }else if(memcmp(cbuf+32-7,"GOODBYE",7)==0) {
408 g_exit=1;
409 }else if(memcmp(cbuf+32-9,"GJITKYF",7)==0) {
410 if(cbuf[30]>='0' && cbuf[30]<='9' && cbuf[31]>='0' && cbuf[31]<='9') {
411 g_map=(cbuf[30]=='0')?0:(cbuf[30]-'0')*10;
412 g_map+=(cbuf[31]=='0')?0:(cbuf[31]-'0');
413 G_start();
415 }else return;
416 memset(cbuf,0,32);
417 Z_sound(s,128);
420 static int strnlen (const char *s, int len) {
421 int i = 0;
422 while (i < len && s[i] != 0) {
423 i++;
425 return i;
428 static int state_for_anykey (int x) {
429 return x == GS_TITLE || x == GS_ENDSCR;
432 int GM_act (void) {
433 menu_msg_t msg;
434 int n, cur, type;
435 const menu_t *m = GM_get();
436 if (m == NULL) {
437 if (lastkey == KEY_ESCAPE || (state_for_anykey(g_st) && lastkey != KEY_UNKNOWN)) {
438 GM_push(&main_menu);
439 Z_sound(msnd3, 128);
441 } else {
442 msg.type = GM_QUERY;
443 if (GM_send_this(m, &msg)) {
444 cur = msg.integer.i;
445 n = msg.integer.a;
446 msg.type = GM_GETENTRY;
447 if (GM_send(m, cur, &msg)) {
448 type = msg.integer.i;
449 switch (lastkey) {
450 case KEY_ESCAPE:
451 if (type == GM_TEXTFIELD && input) {
452 input = 0;
453 Y_disable_text_input();
454 msg.type = GM_CANCEL;
455 GM_send(m, cur, &msg);
456 } else {
457 GM_pop();
458 Z_sound(msnd4, 128);
460 break;
461 case KEY_UP:
462 case KEY_DOWN:
463 if (input == 0) {
464 msg.type = lastkey == KEY_UP ? GM_UP : GM_DOWN;
465 if (GM_send(m, cur, &msg)) {
466 Z_sound(msnd1, 128);
469 break;
470 case KEY_LEFT:
471 case KEY_RIGHT:
472 if (type == GM_SCROLLER) {
473 msg.integer.type = GM_GETINT;
474 if (GM_send(m, cur, &msg)) {
475 msg.integer.type = GM_SETINT;
476 msg.integer.i += lastkey == KEY_LEFT ? -msg.integer.s : msg.integer.s;
477 msg.integer.i = min(max(msg.integer.i, msg.integer.a), msg.integer.b);
478 if (GM_send(m, cur, &msg)) {
479 Z_sound(lastkey == KEY_LEFT ? msnd5 : msnd6, 255);
482 } else if (type == GM_TEXTFIELD) {
483 //if (input) {
484 // icur += lastkey == KEY_LEFT ? -1 : +1;
485 // icur = min(max(icur, 0), strnlen(ibuf, imax));
486 //}
488 break;
489 case KEY_BACKSPACE:
490 if (type == GM_TEXTFIELD) {
491 if (input && icur > 0) {
492 // FIXIT buffers in strncpy must not overlap
493 strncpy(&ibuf[icur - 1], &ibuf[icur], imax - icur);
494 ibuf[imax - 1] = 0;
495 icur -= 1;
498 break;
499 case KEY_RETURN:
500 if (type == GM_TEXTFIELD) {
501 if (input) {
502 input = 0;
503 Y_disable_text_input();
504 msg.type = GM_END;
505 msg.string.s = ibuf;
506 msg.string.maxlen = imax;
507 GM_send(m, cur, &msg);
508 } else {
509 msg.type = GM_GETSTR;
510 if (GM_send(m, cur, &msg)) {
511 imax = min(msg.string.maxlen, GM_MAX_INPUT);
512 strncpy(ibuf, msg.string.s, imax);
513 icur = strnlen(ibuf, imax);
514 } else {
515 memset(ibuf, 0, GM_MAX_INPUT);
516 imax = GM_MAX_INPUT;
517 icur = 0;
519 input = 1;
520 Y_enable_text_input();
521 msg.type = GM_BEGIN;
522 GM_send(m, cur, &msg);
524 Z_sound(msnd2, 128);
525 } else {
526 msg.type = GM_SELECT;
527 if (cur < 0) abort();
528 if (GM_send(m, cur, &msg)) {
529 Z_sound(msnd2, 128);
532 break;
537 lastkey = KEY_UNKNOWN;
538 return m != NULL;
541 void GM_input (int ch) {
542 if (ch != 0 && input) {
543 if (icur < imax) {
544 ibuf[icur] = ch;
545 icur += 1;
546 if (icur < imax) {
547 ibuf[icur] = 0;
553 void GM_key (int key, int down) {
554 int i;
555 if (down) {
556 lastkey = key;
557 if (!_2pl || cheat) {
558 for (i = 0; i < 31; i++) {
559 cbuf[i] = cbuf[i + 1];
561 if (key >= KEY_0 && key <= KEY_9) {
562 cbuf[31] = key - KEY_0 + '0';
563 } else if (key >= KEY_A && key <= KEY_Z) {
564 cbuf[31] = key - KEY_A + 'A';
565 } else {
566 cbuf[31] = 0;
572 void GM_init (void) {
573 int i;
574 char s[8];
575 static const char nm[QSND_NUM][6] = {
576 "CYBSIT", "KNTDTH", "MNPAIN", "PEPAIN", "SLOP", "MANSIT", "BOSPN", "VILACT",
577 "PLFALL", "BGACT", "BGDTH2", "POPAIN", "SGTATK", "VILDTH"
578 };
579 s[0] = 'D';
580 s[1] = 'S';
581 for (i = 0; i < QSND_NUM; ++i) {
582 memcpy(s + 2, nm[i], 6);
583 qsnd[i] = F_getresid(s);
585 csnd1 = Z_getsnd("HAHA1");
586 csnd2 = Z_getsnd("RADIO");
587 msnd1 = Z_getsnd("PSTOP");
588 msnd2 = Z_getsnd("PISTOL");
589 msnd3 = Z_getsnd("SWTCHN");
590 msnd4 = Z_getsnd("SWTCHX");
591 msnd5 = Z_getsnd("SUDI");
592 msnd6 = Z_getsnd("TUDI");
593 MUS_load("MENU");
594 MUS_start(0);