games/cgram/cgram.c

   1 /* $NetBSD: cgram.c,v 1.11 2021/02/21 22:21:56 rillig Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2013, 2021 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by David A. Holland and Roland Illig.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <assert.h>
  33 #include <ctype.h>
  34 #include <curses.h>
  35 #include <err.h>
  36 #include <stdbool.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <time.h>
  41
  42 #include "pathnames.h"
  43
  44 ////////////////////////////////////////////////////////////
  45
  46 static char
  47 ch_toupper(char ch)
  48 {
  49         return (char)toupper((unsigned char)ch);
  50 }
  51
  52 static char
  53 ch_tolower(char ch)
  54 {
  55         return (char)tolower((unsigned char)ch);
  56 }
  57
  58 static bool
  59 ch_isalpha(char ch)
  60 {
  61         return isalpha((unsigned char)ch) != 0;
  62 }
  63
  64 static bool
  65 ch_islower(char ch)
  66 {
  67         return islower((unsigned char)ch) != 0;
  68 }
  69
  70 static bool
  71 ch_isupper(char ch)
  72 {
  73         return isupper((unsigned char)ch) != 0;
  74 }
  75
  76 static int
  77 imax(int a, int b)
  78 {
  79         return a > b ? a : b;
  80 }
  81
  82 static int
  83 imin(int a, int b)
  84 {
  85         return a < b ? a : b;
  86 }
  87
  88 ////////////////////////////////////////////////////////////
  89
  90 struct string {
  91         char *s;
  92         size_t len;
  93         size_t cap;
  94 };
  95
  96 struct stringarray {
  97         struct string *v;
  98         size_t num;
  99 };
 100
 101 static void
 102 string_init(struct string *s)
 103 {
 104         s->s = NULL;
 105         s->len = 0;
 106         s->cap = 0;
 107 }
 108
 109 static void
 110 string_add(struct string *s, char ch)
 111 {
 112         if (s->len >= s->cap) {
 113                 s->cap = 2 * s->cap + 16;
 114                 s->s = realloc(s->s, s->cap);
 115                 if (s->s == NULL)
 116                         errx(1, "Out of memory");
 117         }
 118         s->s[s->len++] = ch;
 119 }
 120
 121 static void
 122 string_finish(struct string *s)
 123 {
 124         string_add(s, '\0');
 125         s->len--;
 126 }
 127
 128 static void
 129 stringarray_init(struct stringarray *a)
 130 {
 131         a->v = NULL;
 132         a->num = 0;
 133 }
 134
 135 static void
 136 stringarray_cleanup(struct stringarray *a)
 137 {
 138         for (size_t i = 0; i < a->num; i++)
 139                 free(a->v[i].s);
 140         free(a->v);
 141 }
 142
 143 static void
 144 stringarray_add(struct stringarray *a, struct string *s)
 145 {
 146         size_t num = a->num++;
 147         a->v = realloc(a->v, a->num * sizeof a->v[0]);
 148         if (a->v == NULL)
 149                 errx(1, "Out of memory");
 150         a->v[num] = *s;
 151 }
 152
 153 static void
 154 stringarray_dup(struct stringarray *dst, const struct stringarray *src)
 155 {
 156         assert(dst->num == 0);
 157         for (size_t i = 0; i < src->num; i++) {
 158                 struct string str;
 159                 string_init(&str);
 160                 for (const char *p = src->v[i].s; *p != '\0'; p++)
 161                         string_add(&str, *p);
 162                 string_finish(&str);
 163                 stringarray_add(dst, &str);
 164         }
 165 }
 166
 167 ////////////////////////////////////////////////////////////
 168
 169 static struct stringarray lines;
 170 static struct stringarray sollines;
 171 static bool hinting;
 172 static int extent_x;
 173 static int extent_y;
 174 static int offset_x;
 175 static int offset_y;
 176 static int cursor_x;
 177 static int cursor_y;
 178
 179 static int
 180 cur_max_x(void)
 181 {
 182         return (int)lines.v[cursor_y].len;
 183 }
 184
 185 static int
 186 cur_max_y(void)
 187 {
 188         return extent_y - 1;
 189 }
 190
 191 static void
 192 readquote(void)
 193 {
 194         FILE *f = popen(_PATH_FORTUNE, "r");
 195         if (f == NULL)
 196                 err(1, "%s", _PATH_FORTUNE);
 197
 198         struct string line;
 199         string_init(&line);
 200
 201         int ch;
 202         while ((ch = fgetc(f)) != EOF) {
 203                 if (ch == '\n') {
 204                         string_finish(&line);
 205                         stringarray_add(&lines, &line);
 206                         string_init(&line);
 207                 } else if (ch == '\t') {
 208                         string_add(&line, ' ');
 209                         while (line.len % 8 != 0)
 210                                 string_add(&line, ' ');
 211                 } else if (ch == '\b') {
 212                         if (line.len > 0)
 213                                 line.len--;
 214                 } else {
 215                         string_add(&line, (char)ch);
 216                 }
 217         }
 218
 219         stringarray_dup(&sollines, &lines);
 220
 221         extent_y = (int)lines.num;
 222         for (int i = 0; i < extent_y; i++)
 223                 extent_x = imax(extent_x, (int)lines.v[i].len);
 224
 225         pclose(f);
 226 }
 227
 228 static void
 229 encode(void)
 230 {
 231         int key[26];
 232
 233         for (int i = 0; i < 26; i++)
 234                 key[i] = i;
 235
 236         for (int i = 26; i > 1; i--) {
 237                 int c = (int)(random() % i);
 238                 int t = key[i - 1];
 239                 key[i - 1] = key[c];
 240                 key[c] = t;
 241         }
 242
 243         for (int y = 0; y < extent_y; y++) {
 244                 for (char *p = lines.v[y].s; *p != '\0'; p++) {
 245                         if (ch_islower(*p))
 246                                 *p = (char)('a' + key[*p - 'a']);
 247                         if (ch_isupper(*p))
 248                                 *p = (char)('A' + key[*p - 'A']);
 249                 }
 250         }
 251 }
 252
 253 static bool
 254 substitute(char ch)
 255 {
 256         assert(cursor_x >= 0 && cursor_x < extent_x);
 257         assert(cursor_y >= 0 && cursor_y < extent_y);
 258         if (cursor_x >= cur_max_x()) {
 259                 beep();
 260                 return false;
 261         }
 262
 263         char och = lines.v[cursor_y].s[cursor_x];
 264         if (!ch_isalpha(och)) {
 265                 beep();
 266                 return false;
 267         }
 268
 269         char loch = ch_tolower(och);
 270         char uoch = ch_toupper(och);
 271         char lch = ch_tolower(ch);
 272         char uch = ch_toupper(ch);
 273
 274         for (int y = 0; y < (int)lines.num; y++) {
 275                 for (char *p = lines.v[y].s; *p != '\0'; p++) {
 276                         if (*p == loch)
 277                                 *p = lch;
 278                         else if (*p == uoch)
 279                                 *p = uch;
 280                         else if (*p == lch)
 281                                 *p = loch;
 282                         else if (*p == uch)
 283                                 *p = uoch;
 284                 }
 285         }
 286         return true;
 287 }
 288
 289 ////////////////////////////////////////////////////////////
 290
 291 static bool
 292 is_solved(void)
 293 {
 294         for (size_t i = 0; i < lines.num; i++)
 295                 if (strcmp(lines.v[i].s, sollines.v[i].s) != 0)
 296                         return false;
 297         return true;
 298 }
 299
 300 static void
 301 redraw(void)
 302 {
 303         erase();
 304
 305         int max_y = imin(LINES - 1, extent_y - offset_y);
 306         for (int y = 0; y < max_y; y++) {
 307                 move(y, 0);
 308
 309                 int len = (int)lines.v[offset_y + y].len;
 310                 int max_x = imin(COLS - 1, len - offset_x);
 311                 const char *line = lines.v[offset_y + y].s;
 312                 const char *solline = sollines.v[offset_y + y].s;
 313
 314                 for (int x = 0; x < max_x; x++) {
 315                         char ch = line[offset_x + x];
 316                         bool bold = hinting &&
 317                             ch == solline[offset_x + x] &&
 318                             ch_isalpha(ch);
 319
 320                         if (bold)
 321                                 attron(A_BOLD);
 322                         addch(ch);
 323                         if (bold)
 324                                 attroff(A_BOLD);
 325                 }
 326                 clrtoeol();
 327         }
 328
 329         move(LINES - 1, 0);
 330         if (is_solved())
 331                 addstr("*solved* ");
 332         addstr("~ to quit, * to cheat, ^pnfb to move");
 333
 334         move(cursor_y - offset_y, cursor_x - offset_x);
 335
 336         refresh();
 337 }
 338
 339 static void
 340 opencurses(void)
 341 {
 342         initscr();
 343         cbreak();
 344         noecho();
 345         keypad(stdscr, true);
 346 }
 347
 348 static void
 349 closecurses(void)
 350 {
 351         endwin();
 352 }
 353
 354 ////////////////////////////////////////////////////////////
 355
 356 static void
 357 saturate_cursor(void)
 358 {
 359         cursor_y = imax(cursor_y, 0);
 360         cursor_y = imin(cursor_y, cur_max_y());
 361
 362         assert(cursor_x >= 0);
 363         cursor_x = imin(cursor_x, cur_max_x());
 364 }
 365
 366 static void
 367 scroll_into_view(void)
 368 {
 369         if (cursor_x < offset_x)
 370                 offset_x = cursor_x;
 371         if (cursor_x > offset_x + COLS - 1)
 372                 offset_x = cursor_x - (COLS - 1);
 373
 374         if (cursor_y < offset_y)
 375                 offset_y = cursor_y;
 376         if (cursor_y > offset_y + LINES - 2)
 377                 offset_y = cursor_y - (LINES - 2);
 378 }
 379
 380 static void
 381 handle_char_input(int ch)
 382 {
 383         if (isascii(ch) && ch_isalpha((char)ch)) {
 384                 if (substitute((char)ch)) {
 385                         if (cursor_x < cur_max_x())
 386                                 cursor_x++;
 387                         if (cursor_x == cur_max_x() &&
 388                             cursor_y < cur_max_y()) {
 389                                 cursor_x = 0;
 390                                 cursor_y++;
 391                         }
 392                 }
 393         } else if (cursor_x < cur_max_x() &&
 394             ch == lines.v[cursor_y].s[cursor_x]) {
 395                 cursor_x++;
 396                 if (cursor_x == cur_max_x() &&
 397                     cursor_y < cur_max_y()) {
 398                         cursor_x = 0;
 399                         cursor_y++;
 400                 }
 401         } else {
 402                 beep();
 403         }
 404 }
 405
 406 static bool
 407 handle_key(void)
 408 {
 409         int ch = getch();
 410
 411         switch (ch) {
 412         case 1:                 /* ^A */
 413         case KEY_HOME:
 414                 cursor_x = 0;
 415                 break;
 416         case 2:                 /* ^B */
 417         case KEY_LEFT:
 418                 if (cursor_x > 0) {
 419                         cursor_x--;
 420                 } else if (cursor_y > 0) {
 421                         cursor_y--;
 422                         cursor_x = cur_max_x();
 423                 }
 424                 break;
 425         case 5:                 /* ^E */
 426         case KEY_END:
 427                 cursor_x = cur_max_x();
 428                 break;
 429         case 6:                 /* ^F */
 430         case KEY_RIGHT:
 431                 if (cursor_x < cur_max_x()) {
 432                         cursor_x++;
 433                 } else if (cursor_y < cur_max_y()) {
 434                         cursor_y++;
 435                         cursor_x = 0;
 436                 }
 437                 break;
 438         case 12:                /* ^L */
 439                 clear();
 440                 break;
 441         case 14:                /* ^N */
 442         case KEY_DOWN:
 443                 cursor_y++;
 444                 break;
 445         case 16:                /* ^P */
 446         case KEY_UP:
 447                 cursor_y--;
 448                 break;
 449         case KEY_PPAGE:
 450                 cursor_y -= LINES - 2;
 451                 break;
 452         case KEY_NPAGE:
 453                 cursor_y += LINES - 2;
 454                 break;
 455         case '*':
 456                 hinting = !hinting;
 457                 break;
 458         case '~':
 459                 return false;
 460         default:
 461                 handle_char_input(ch);
 462                 break;
 463         }
 464         return true;
 465 }
 466
 467 static void
 468 init(void)
 469 {
 470         stringarray_init(&lines);
 471         stringarray_init(&sollines);
 472         srandom((unsigned int)time(NULL));
 473         readquote();
 474         encode();
 475         opencurses();
 476 }
 477
 478 static void
 479 loop(void)
 480 {
 481         for (;;) {
 482                 redraw();
 483                 if (!handle_key())
 484                         break;
 485                 saturate_cursor();
 486                 scroll_into_view();
 487         }
 488 }
 489
 490 static void
 491 clean_up(void)
 492 {
 493         closecurses();
 494         stringarray_cleanup(&sollines);
 495         stringarray_cleanup(&lines);
 496 }
 497
 498 ////////////////////////////////////////////////////////////
 499
 500 int
 501 main(void)
 502 {
 503         init();
 504         loop();
 505         clean_up();
 506 }