tests/first.c

   1 #include <libchimara/glk.h>
   2
   3 /* model.c: Model program for Glk API, version 0.5.
   4     Designed by Andrew Plotkin <erkyrath@eblong.com>
   5     http://www.eblong.com/zarf/glk/index.html
   6     This program is in the public domain.
   7 */
   8
   9 /* This is a simple model of a text adventure which uses the Glk API.
  10     It shows how to input a line of text, display results, maintain a
  11     status window, write to a transcript file, and so on. */
  12
  13 /* This is the cleanest possible form of a Glk program. It includes only
  14     "glk.h", and doesn't call any functions outside Glk at all. We even
  15     define our own str_eq() and str_len(), rather than relying on the
  16     standard libraries. */
  17
  18 /* We also define our own TRUE and FALSE and NULL. */
  19 #ifndef TRUE
  20 #define TRUE 1
  21 #endif
  22 #ifndef FALSE
  23 #define FALSE 0
  24 #endif
  25 #ifndef NULL
  26 #define NULL 0
  27 #endif
  28
  29 /* The story, status, and quote windows. */
  30 static winid_t mainwin = NULL;
  31 static winid_t statuswin = NULL;
  32 static winid_t quotewin = NULL;
  33
  34 /* A file reference for the transcript file. */
  35 static frefid_t scriptref = NULL;
  36 /* A stream for the transcript file, when it's open. */
  37 static strid_t scriptstr = NULL;
  38
  39 /* Your location. This determines what appears in the status line. */
  40 static int current_room;
  41
  42 /* A flag indicating whether you should look around. */
  43 static int need_look;
  44
  45 /* Forward declarations */
  46 void glk_main(void);
  47
  48 static void draw_statuswin(void);
  49 static int yes_or_no(void);
  50
  51 static int str_eq(char *s1, char *s2);
  52 static int str_len(char *s1);
  53
  54 static void verb_help(void);
  55 static void verb_jump(void);
  56 static void verb_yada(void);
  57 static void verb_quote(void);
  58 static void verb_move(void);
  59 static void verb_quit(void);
  60 static void verb_script(void);
  61 static void verb_unscript(void);
  62 static void verb_save(void);
  63 static void verb_restore(void);
  64 static void verb_alert(void);
  65 static void verb_notice(void);
  66
  67 /* The glk_main() function is called by the Glk system; it's the main entry
  68     point for your program. */
  69 void glk_main(void)
  70 {
  71     /* Open the main window. */
  72     mainwin = glk_window_open(0, 0, 0, wintype_TextBuffer, 1);
  73     if (!mainwin) {
  74         /* It's possible that the main window failed to open. There's
  75             nothing we can do without it, so exit. */
  76         return;
  77     }
  78
  79     /* Set the current output stream to print to it. */
  80     glk_set_window(mainwin);
  81
  82     /* Open a second window: a text grid, above the main window, three lines
  83         high. It is possible that this will fail also, but we accept that. */
  84     statuswin = glk_window_open(mainwin, winmethod_Above | winmethod_Fixed,
  85         3, wintype_TextGrid, 0);
  86
  87     /* The third window, quotewin, isn't opened immediately. We'll do
  88         that in verb_quote(). */
  89
  90     glk_put_string("Model Glk Program\nAn Interactive Model Glk Program\n");
  91     glk_put_string("By Andrew Plotkin.\nRelease 7.\n");
  92     glk_put_string("Type \"help\" for a list of commands.\n");
  93
  94     current_room = 0; /* Set initial location. */
  95     need_look = TRUE;
  96
  97     while (1) {
  98         char commandbuf[256];
  99         char *cx, *cmd;
 100         int gotline, len;
 101         event_t ev;
 102
 103         draw_statuswin();
 104
 105         if (need_look) {
 106             need_look = FALSE;
 107             glk_put_string("\n");
 108             glk_set_style(style_Subheader);
 109             if (current_room == 0)
 110                 glk_put_string("The Room\n");
 111             else
 112                 glk_put_string("A Different Room\n");
 113             glk_set_style(style_Normal);
 114             glk_put_string("You're in a room of some sort.\n");
 115         }
 116
 117         glk_put_string("\n>");
 118         /* We request up to 255 characters. The buffer can hold 256, but we
 119             are going to stick a null character at the end, so we have to
 120             leave room for that. Note that the Glk library does *not*
 121             put on that null character. */
 122         glk_request_line_event(mainwin, commandbuf, 255, 0);
 123
 124         gotline = FALSE;
 125         while (!gotline) {
 126
 127             /* Grab an event. */
 128             glk_select(&ev);
 129
 130             switch (ev.type) {
 131
 132                 case evtype_LineInput:
 133                     if (ev.win == mainwin) {
 134                         gotline = TRUE;
 135                         /* Really the event can *only* be from mainwin,
 136                             because we never request line input from the
 137                             status window. But we do a paranoia test,
 138                             because commandbuf is only filled if the line
 139                             event comes from the mainwin request. If the
 140                             line event comes from anywhere else, we ignore
 141                             it. */
 142                     }
 143                     break;
 144
 145                 case evtype_Arrange:
 146                     /* Windows have changed size, so we have to redraw the
 147                         status window. */
 148                     draw_statuswin();
 149                     break;
 150             }
 151         }
 152
 153         /* commandbuf now contains a line of input from the main window.
 154             You would now run your parser and do something with it. */
 155
 156         /* First, if there's a blockquote window open, let's close it.
 157             This ensures that quotes remain visible for exactly one
 158             command. */
 159         if (quotewin) {
 160             glk_window_close(quotewin, NULL);
 161             quotewin = 0;
 162         }
 163
 164         /* The line we have received in commandbuf is not null-terminated.
 165             We handle that first. */
 166         len = ev.val1; /* Will be between 0 and 255, inclusive. */
 167         commandbuf[len] = '\0';
 168
 169         /* Then squash to lower-case. */
 170         for (cx = commandbuf; *cx; cx++) {
 171             *cx = glk_char_to_lower(*cx);
 172         }
 173
 174         /* Then trim whitespace before and after. */
 175
 176         for (cx = commandbuf; *cx == ' '; cx++) { };
 177
 178         cmd = cx;
 179
 180         for (cx = commandbuf+len-1; cx >= cmd && *cx == ' '; cx--) { };
 181         *(cx+1) = '\0';
 182
 183         /* cmd now points to a nice null-terminated string. We'll do the
 184             simplest possible parsing. */
 185         if (str_eq(cmd, "")) {
 186             glk_put_string("Excuse me?\n");
 187         }
 188         else if (str_eq(cmd, "help")) {
 189             verb_help();
 190         }
 191         else if (str_eq(cmd, "move")) {
 192             verb_move();
 193         }
 194         else if (str_eq(cmd, "jump")) {
 195             verb_jump();
 196         }
 197         else if (str_eq(cmd, "yada")) {
 198             verb_yada();
 199         }
 200         else if (str_eq(cmd, "quote")) {
 201             verb_quote();
 202         }
 203         else if (str_eq(cmd, "quit")) {
 204             verb_quit();
 205         }
 206         else if (str_eq(cmd, "save")) {
 207             verb_save();
 208         }
 209         else if (str_eq(cmd, "restore")) {
 210             verb_restore();
 211         }
 212         else if (str_eq(cmd, "script")) {
 213             verb_script();
 214         }
 215         else if (str_eq(cmd, "unscript")) {
 216             verb_unscript();
 217         }
 218         else if (str_eq(cmd, "alert")) {
 219             verb_alert();
 220         }
 221         else if (str_eq(cmd, "notice")) {
 222             verb_notice();
 223         }
 224         else {
 225             glk_put_string("I don't understand the command \"");
 226             glk_put_string(cmd);
 227             glk_put_string("\".\n");
 228         }
 229     }
 230 }
 231
 232 static void draw_statuswin(void)
 233 {
 234     char *roomname;
 235     glui32 width, height;
 236
 237     if (!statuswin) {
 238         /* It is possible that the window was not successfully
 239             created. If that's the case, don't try to draw it. */
 240         return;
 241     }
 242
 243     if (current_room == 0)
 244         roomname = "The Room";
 245     else
 246         roomname = "A Different Room";
 247
 248     glk_set_window(statuswin);
 249     glk_window_clear(statuswin);
 250
 251     glk_window_get_size(statuswin, &width, &height);
 252
 253     /* Print the room name, centered. */
 254     glk_window_move_cursor(statuswin, (width - str_len(roomname)) / 2, 1);
 255     glk_put_string(roomname);
 256
 257     /* Draw a decorative compass rose in the upper right. */
 258     glk_window_move_cursor(statuswin, width - 3, 0);
 259     glk_put_string("\\|/");
 260     glk_window_move_cursor(statuswin, width - 3, 1);
 261     glk_put_string("-*-");
 262     glk_window_move_cursor(statuswin, width - 3, 2);
 263     glk_put_string("/|\\");
 264
 265     glk_set_window(mainwin);
 266 }
 267
 268 static int yes_or_no(void)
 269 {
 270     char commandbuf[256];
 271     char *cx;
 272     int gotline, len;
 273     event_t ev;
 274
 275     draw_statuswin();
 276
 277     /* This loop is identical to the main command loop in glk_main(). */
 278
 279     while (1) {
 280         glk_request_line_event(mainwin, commandbuf, 255, 0);
 281
 282         gotline = FALSE;
 283         while (!gotline) {
 284
 285             glk_select(&ev);
 286
 287             switch (ev.type) {
 288                 case evtype_LineInput:
 289                     if (ev.win == mainwin) {
 290                         gotline = TRUE;
 291                     }
 292                     break;
 293
 294                 case evtype_Arrange:
 295                     draw_statuswin();
 296                     break;
 297             }
 298         }
 299
 300         len = ev.val1;
 301         commandbuf[len] = '\0';
 302         for (cx = commandbuf; *cx == ' '; cx++) { };
 303
 304         if (*cx == 'y' || *cx == 'Y')
 305             return TRUE;
 306         if (*cx == 'n' || *cx == 'N')
 307             return FALSE;
 308
 309         glk_put_string("Please enter \"yes\" or \"no\": ");
 310     }
 311
 312 }
 313
 314 static void verb_help(void)
 315 {
 316     glk_put_string("This model only understands the following commands:\n");
 317     glk_put_string("HELP: Display this list.\n");
 318     glk_put_string("JUMP: A verb which just prints some text.\n");
 319     glk_put_string("YADA: A verb which prints a very long stream of text.\n");
 320     glk_put_string("MOVE: A verb which prints some text, and also changes the status line display.\n");
 321     glk_put_string("QUOTE: A verb which displays a block quote in a temporary third window.\n");
 322     glk_put_string("SCRIPT: Turn on transcripting, so that output will be echoed to a text file.\n");
 323     glk_put_string("UNSCRIPT: Turn off transcripting.\n");
 324     glk_put_string("SAVE: Write fake data to a save file.\n");
 325     glk_put_string("RESTORE: Read it back in.\n");
 326     glk_put_string("ALERT: Print a frightful message.\n");
 327     glk_put_string("NOTICE: Print an interesting message.\n");
 328     glk_put_string("QUIT: Quit and exit.\n");
 329 }
 330
 331 static void verb_jump(void)
 332 {
 333     glk_put_string("You jump on the fruit, spotlessly.\n");
 334 }
 335
 336 static void verb_yada(void)
 337 {
 338     /* This is a goofy (and overly ornate) way to print a long paragraph.
 339         It just shows off line wrapping in the Glk implementation. */
 340     #define NUMWORDS (13)
 341     static char *wordcaplist[NUMWORDS] = {
 342         "Ga", "Bo", "Wa", "Mu", "Bi", "Fo", "Za", "Mo", "Ra", "Po",
 343             "Ha", "Ni", "Na"
 344     };
 345     static char *wordlist[NUMWORDS] = {
 346         "figgle", "wob", "shim", "fleb", "moobosh", "fonk", "wabble",
 347             "gazoon", "ting", "floo", "zonk", "loof", "lob",
 348     };
 349     static int wcount1 = 0;
 350     static int wcount2 = 0;
 351     static int wstep = 1;
 352     static int jx = 0;
 353     int ix;
 354     int first = TRUE;
 355
 356     for (ix=0; ix<85; ix++) {
 357         if (ix > 0) {
 358             glk_put_string(" ");
 359         }
 360
 361         if (first) {
 362             glk_put_string(wordcaplist[(ix / 17) % NUMWORDS]);
 363             first = FALSE;
 364         }
 365
 366         glk_put_string(wordlist[jx]);
 367         jx = (jx + wstep) % NUMWORDS;
 368         wcount1++;
 369         if (wcount1 >= NUMWORDS) {
 370             wcount1 = 0;
 371             wstep++;
 372             wcount2++;
 373             if (wcount2 >= NUMWORDS-2) {
 374                 wcount2 = 0;
 375                 wstep = 1;
 376             }
 377         }
 378
 379         if ((ix % 17) == 16) {
 380             glk_put_string(".");
 381             first = TRUE;
 382         }
 383     }
 384
 385     glk_put_char('\n');
 386 }
 387
 388 static void verb_quote(void)
 389 {
 390     glk_put_string("Someone quotes some poetry.\n");
 391
 392     /* Open a third window, or clear it if it's already open. Actually,
 393         since quotewin is closed right after line input, we know it
 394         can't be open. But better safe, etc. */
 395     if (!quotewin) {
 396         /* A five-line window above the main window, fixed size. */
 397         quotewin = glk_window_open(mainwin, winmethod_Above | winmethod_Fixed,
 398             5, wintype_TextBuffer, 0);
 399         if (!quotewin) {
 400             /* It's possible the quotewin couldn't be opened. In that
 401                 case, just give up. */
 402             return;
 403         }
 404     }
 405     else {
 406         glk_window_clear(quotewin);
 407     }
 408
 409     /* Print some quote. */
 410     glk_set_window(quotewin);
 411     glk_set_style(style_BlockQuote);
 412     glk_put_string("Tomorrow probably never rose ");
 413         glk_put_string("or set\n Or went out and bought cheese, or anything like that\n"
 414         "And anyway, what light through yonder quote box breaks\n"
 415         "Handle to my hand?\n");
 416     glk_put_string("              -- Fred\n");
 417
 418     glk_set_window(mainwin);
 419 }
 420
 421 static void verb_move(void)
 422 {
 423     current_room = (current_room+1) % 2;
 424     need_look = TRUE;
 425
 426     glk_put_string("You ");
 427         glk_set_style(style_Emphasized);
 428         glk_put_string("walk");
 429         glk_set_style(style_Normal);
 430         glk_put_string(" for a while.\n");
 431 }
 432
 433 static void verb_quit(void)
 434 {
 435     glk_put_string("Are you sure you want to quit? ");
 436     if (yes_or_no()) {
 437         glk_put_string("Thanks for playing.\n");
 438         glk_exit();
 439         /* glk_exit() actually stops the process; it does not return. */
 440     }
 441 }
 442
 443 static void verb_script(void)
 444 {
 445     if (scriptstr) {
 446         glk_put_string("Scripting is already on.\n");
 447         return;
 448     }
 449
 450     /* If we've turned on scripting before, use the same file reference;
 451         otherwise, prompt the player for a file. */
 452     if (!scriptref) {
 453         scriptref = glk_fileref_create_by_prompt(
 454             fileusage_Transcript | fileusage_TextMode,
 455             filemode_WriteAppend, 0);
 456         if (!scriptref) {
 457             glk_put_string("Unable to place script file.\n");
 458             return;
 459         }
 460     }
 461
 462     /* Open the file. */
 463     scriptstr = glk_stream_open_file(scriptref, filemode_WriteAppend, 0);
 464     if (!scriptstr) {
 465         glk_put_string("Unable to write to script file.\n");
 466         return;
 467     }
 468     glk_put_string("Scripting on.\n");
 469     glk_window_set_echo_stream(mainwin, scriptstr);
 470     glk_put_string_stream(scriptstr,
 471         "This is the beginning of a transcript.\n");
 472 }
 473
 474 static void verb_unscript(void)
 475 {
 476     if (!scriptstr) {
 477         glk_put_string("Scripting is already off.\n");
 478         return;
 479     }
 480
 481     /* Close the file. */
 482     glk_put_string_stream(scriptstr,
 483         "This is the end of a transcript.\n\n");
 484     glk_stream_close(scriptstr, NULL);
 485     glk_put_string("Scripting off.\n");
 486     scriptstr = NULL;
 487 }
 488
 489 static void verb_save(void)
 490 {
 491     int ix;
 492     frefid_t saveref;
 493     strid_t savestr;
 494
 495     saveref = glk_fileref_create_by_prompt(
 496         fileusage_SavedGame | fileusage_BinaryMode,
 497         filemode_Write, 0);
 498     if (!saveref) {
 499         glk_put_string("Unable to place save file.\n");
 500         return;
 501     }
 502
 503     savestr = glk_stream_open_file(saveref, filemode_Write, 0);
 504     if (!savestr) {
 505         glk_put_string("Unable to write to save file.\n");
 506         glk_fileref_destroy(saveref);
 507         return;
 508     }
 509
 510     glk_fileref_destroy(saveref); /* We're done with the file ref now. */
 511
 512     /* Write some binary data. */
 513     for (ix=0; ix<256; ix++) {
 514         glk_put_char_stream(savestr, (unsigned char)ix);
 515     }
 516
 517     glk_stream_close(savestr, NULL);
 518
 519     glk_put_string("Game saved.\n");
 520 }
 521
 522 static void verb_restore(void)
 523 {
 524     int ix;
 525     int err;
 526     glui32 ch;
 527     frefid_t saveref;
 528     strid_t savestr;
 529
 530     saveref = glk_fileref_create_by_prompt(
 531         fileusage_SavedGame | fileusage_BinaryMode,
 532         filemode_Read, 0);
 533     if (!saveref) {
 534         glk_put_string("Unable to find save file.\n");
 535         return;
 536     }
 537
 538     savestr = glk_stream_open_file(saveref, filemode_Read, 0);
 539     if (!savestr) {
 540         glk_put_string("Unable to read from save file.\n");
 541         glk_fileref_destroy(saveref);
 542         return;
 543     }
 544
 545     glk_fileref_destroy(saveref); /* We're done with the file ref now. */
 546
 547     /* Read some binary data. */
 548     err = FALSE;
 549
 550     for (ix=0; ix<256; ix++) {
 551         ch = glk_get_char_stream(savestr);
 552         if (ch == (glui32)(-1)) {
 553             glk_put_string("Unexpected end of file.\n");
 554             err = TRUE;
 555             break;
 556         }
 557         if (ch != (glui32)ix) {
 558             glk_put_string("This does not appear to be a valid saved game.\n");
 559             err = TRUE;
 560             break;
 561         }
 562     }
 563
 564     glk_stream_close(savestr, NULL);
 565
 566     if (err) {
 567         glk_put_string("Failed.\n");
 568         return;
 569     }
 570
 571     glk_put_string("Game restored.\n");
 572 }
 573
 574 void verb_alert()
 575 {
 576         glk_set_style(style_Alert);
 577         glk_put_string("O noes!\n");
 578         glk_set_style(style_Normal);
 579 }
 580
 581 void verb_notice()
 582 {
 583         glk_set_style(style_Note);
 584         glk_put_string("The answer... is 42!\n");
 585         glk_set_style(style_Normal);
 586 }
 587
 588
 589 /* simple string length test */
 590 static int str_len(char *s1)
 591 {
 592     int len;
 593     for (len = 0; *s1; s1++)
 594         len++;
 595     return len;
 596 }
 597
 598 /* simple string comparison test */
 599 static int str_eq(char *s1, char *s2)
 600 {
 601     for (; *s1 && *s2; s1++, s2++) {
 602         if (*s1 != *s2)
 603             return FALSE;
 604     }
 605
 606     if (*s1 || *s2)
 607         return FALSE;
 608     else
 609         return TRUE;
 610 }
 611