Changeset ebe70f1 in mainline


Ignore:
Timestamp:
2009-06-09T11:10:31Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f3afd24
Parents:
080ad7f
Message:

slightly cleanup the horrible mess of tetris
introduce colors

Location:
uspace/app/tetris
Files:
1 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/tetris/input.c

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris
    39  * @{ 
     39 * @{
    4040 */
    4141/** @file
    … …  
    9393 *
    9494 */
    95 int
    96 rwait(struct timeval *tvp)
     95int rwait(struct timeval *tvp)
    9796{
    9897        struct timeval starttv, endtv, *s;
    9998        static ipc_call_t charcall;
    10099        ipcarg_t rc;
    101 
     100       
    102101        /*
    103102         * Someday, select() will do this for us.
    … …  
    111110        } else
    112111                s = NULL;
    113 
     112       
    114113        if (!lastchar) {
    115114again:
    … …  
    118117                            CONSOLE_GET_EVENT, &charcall);
    119118                }
     119               
    120120                if (!s)
    121121                        async_wait_for(getchar_inprog, &rc);
    … …  
    125125                        return (0);
    126126                }
     127               
    127128                getchar_inprog = 0;
    128                 if (rc) {
     129                if (rc)
    129130                        stop("end of file, help");
    130                 }
     131               
    131132                if (IPC_GET_ARG1(charcall) == KEY_RELEASE)
    132133                        goto again;
    133 
     134               
    134135                lastchar = IPC_GET_ARG4(charcall);
    135136        }
     137       
    136138        if (tvp) {
    137139                /* since there is input, we may not have timed out */
    138140                (void) gettimeofday(&endtv, NULL);
    139141                TV_SUB(&endtv, &starttv);
    140                 TV_SUB(tvp, &endtv);    /* adjust *tvp by elapsed time */
     142                TV_SUB(tvp, &endtv);  /* adjust *tvp by elapsed time */
    141143        }
    142         return (1);
     144       
     145        return 1;
    143146}
    144147
    … …  
    147150 * Eat any input that might be available.
    148151 */
    149 void
    150 tsleep(void)
     152void tsleep(void)
    151153{
    152154        struct timeval tv;
    153 
     155       
    154156        tv.tv_sec = 0;
    155157        tv.tv_usec = fallrate;
    … …  
    164166 * getchar with timeout.
    165167 */
    166 int
    167 tgetchar(void)
     168int tgetchar(void)
    168169{
    169170        static struct timeval timeleft;
    170171        char c;
    171 
     172       
    172173        /*
    173174         * Reset timeleft to fallrate whenever it is not positive.
    … …  
    180181         */
    181182        if (!TV_POS(&timeleft)) {
    182                 faster();       /* go faster */
     183                faster();  /* go faster */
    183184                timeleft.tv_sec = 0;
    184185                timeleft.tv_usec = fallrate;
    185186        }
     187       
    186188        if (!rwait(&timeleft))
    187                 return (-1);
     189                return -1;
     190       
    188191        c = lastchar;
    189192        lastchar = '\0';
    190         return ((int)(unsigned char)c);
     193        return ((int) (unsigned char) c);
    191194}
    192195
    193196/** @}
    194197 */
    195 

  • uspace/app/tetris/input.h

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris
    39  * @{ 
     39 * @{
    4040 */
    4141/** @file
    4242 */
    4343
    44 int     rwait(struct timeval *);
    45 int     tgetchar(void);
    46 void    tsleep(void);
     44extern int rwait(struct timeval *);
     45extern int tgetchar(void);
     46extern void tsleep(void);
    4747
    4848/** @}
    4949 */
    50 

  • uspace/app/tetris/scores.c

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris
    39  * @{ 
     39 * @{
    4040 */
    4141/** @file
    … …  
    4949 * Major whacks since then.
    5050 */
     51
    5152#include <errno.h>
    52 /* #include <err.h> */
    53 /* #include <fcntl.h> */
    54 /* #include <pwd.h> */
    5553#include <stdio.h>
    56 /* #include <stdlib.h> */
    5754#include <string.h>
    5855#include <io/console.h>
    … …  
    6057#include <vfs/vfs.h>
    6158#include <stdlib.h>
    62 /* #include <time.h> */
    63 /* #include <term.h> */
    64 /* #include <unistd.h> */
    65 /* #include <sys/param.h> */
    66 /* #include <sys/stat.h> */
    67 /* #include <sys/types.h> */
    68 
    69 #include "pathnames.h"
     59#include <fcntl.h>
     60#include <err.h>
     61#include <time.h>
     62
    7063#include "screen.h"
    7164#include "tetris.h"
    … …  
    8073 * that level.
    8174 */
    82 #define NUMSPOTS (MAXHISCORES + 1)
    83 #define NLEVELS (MAXLEVEL + 1)
    84 
    85 /* static time_t now; */
    86 /* static int nscores; */
    87 /* static int gotscores; */
    88 /* static struct highscore scores[NUMSPOTS]; */
     75
     76#define NUMSPOTS  (MAXHISCORES + 1)
     77#define NLEVELS   (MAXLEVEL + 1)
     78
    8979static struct highscore scores[NUMSPOTS];
    9080
    91 /* static int checkscores(struct highscore *, int); */
    92 /* static int cmpscores(const void *, const void *); */
    93 /* static void getscores(FILE **); */
    94 /* static void printem(int, int, struct highscore *, int, const char *); */
    95 /* static char *thisuser(void); */
     81/** Copy from hiscore table score with index src to dest
     82 *
     83 */
     84static void copyhiscore(int dest, int src)
     85{
     86        str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
     87            scores[src].hs_name);
     88        scores[dest].hs_score = scores[src].hs_score;
     89        scores[dest].hs_level = scores[src].hs_level;
     90}
    9691
    9792void showscores(int firstgame)
    … …  
    10398        printf("\tRank \tLevel \tName\t                     points\n");
    10499        printf("\t========================================================\n");
    105         for (i = 0; i < NUMSPOTS - 1; i++) {
    106                 printf("\t%6d %6d %-16s %20d\n", i+1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score);
    107         }
     100       
     101        for (i = 0; i < NUMSPOTS - 1; i++)
     102                printf("\t%6d %6d %-16s %20d\n",
     103                    i + 1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score);
     104       
    108105        if (!firstgame) {
    109106                printf("\t========================================================\n");
    110                 printf("\t  Last %6d %-16s %20d\n", scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score);
     107                printf("\t  Last %6d %-16s %20d\n",
     108                    scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score);
    111109        }
     110       
    112111        printf("\n\n\n\n\tPress any key to return to main menu.");
    113112        getchar();
    114113}
    115114
    116 /** Copy from hiscore table score with index src to dest
    117  *
    118  */
    119 static void copyhiscore(int dest, int src)
    120 {
    121         str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
    122             scores[src].hs_name);
    123         scores[dest].hs_score = scores[src].hs_score;   
    124         scores[dest].hs_level = scores[src].hs_level;
    125 }
    126 
    127115void insertscore(int score, int level)
    128116{
    129         int i,j;
     117        int i;
     118        int j;
    130119        size_t off;
    131120        console_event_t ev;
    132121       
    133122        clear_screen();
    134         moveto(10 , 10);
     123        moveto(10, 10);
    135124        puts("Insert your name: ");
    136125        str_cpy(scores[NUMSPOTS - 1].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
    137126            "Player");
    138         i = 6; off = 6;
    139 
     127        i = 6;
     128        off = 6;
     129       
    140130        moveto(10 , 28);
    141         printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
    142 
     131        printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME-i,
     132            "........................................");
     133       
    143134        while (1) {
    144135                fflush(stdout);
    145136                if (!console_get_event(fphone(stdin), &ev))
    146137                        exit(1);
    147 
     138               
    148139                if (ev.type == KEY_RELEASE)
    149140                        continue;
    150 
     141               
    151142                if (ev.key == KC_ENTER || ev.key == KC_NENTER)
    152143                        break;
    153 
     144               
    154145                if (ev.key == KC_BACKSPACE) {
    155146                        if (i > 0) {
    156147                                wchar_t uc;
    157 
     148                               
    158149                                --i;
    159150                                while (off > 0) {
    … …  
    165156                                                break;
    166157                                }
    167 
     158                               
    168159                                scores[NUMSPOTS - 1].hs_name[off] = '\0';
    169160                        }
    … …  
    178169                }
    179170               
    180                 moveto(10 , 28);
    181                 printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
     171                moveto(10, 28);
     172                printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME - i,
     173                    "........................................");
    182174        }
    183175       
    184         scores[NUMSPOTS - 1].hs_score = score; 
     176        scores[NUMSPOTS - 1].hs_score = score;
    185177        scores[NUMSPOTS - 1].hs_level = level;
    186178       
    187         i = NUMSPOTS-1;
     179        i = NUMSPOTS - 1;
    188180        while ((i > 0) && (scores[i - 1].hs_score < score))
    189181                i--;
    190 
    191         for (j = NUMSPOTS - 2; j > i; j--) {
    192                 copyhiscore(j,j-1);
     182       
     183        for (j = NUMSPOTS - 2; j > i; j--)
     184                copyhiscore(j, j-1);
     185       
     186        copyhiscore(i, NUMSPOTS - 1);
     187}
     188
     189void initscores(void)
     190{
     191        int i;
     192        for (i = 0; i < NUMSPOTS; i++) {
     193                str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team");
     194                scores[i].hs_score = (NUMSPOTS - i) * 200;
     195                scores[i].hs_level = (i + 1 > MAXLEVEL ? MAXLEVEL : i + 1);
    193196        }
    194         copyhiscore(i, NUMSPOTS - 1);   
    195 }
    196 
    197 void initscores(void)
    198 {
    199         int i;
    200         for(i = 0; i < NUMSPOTS; i++) {
    201                 str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team");
    202                 scores[i].hs_score = (NUMSPOTS - i) * 200;     
    203                 scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);
    204         }
    205 }
    206 
    207 /*
    208  * Read the score file.  Can be called from savescore (before showscores)
    209  * or showscores (if savescore will not be called).  If the given pointer
    210  * is not NULL, sets *fpp to an open file pointer that corresponds to a
    211  * read/write score file that is locked with LOCK_EX.  Otherwise, the
    212  * file is locked with LOCK_SH for the read and closed before return.
    213  *
    214  * Note, we assume closing the stdio file releases the lock.
    215  */
    216 /* static void */
    217 /* getscores(FILE **fpp) */
    218 /* { */
    219 /*      int sd, mint, lck, mask, i; */
    220 /*      char *mstr, *human; */
    221 /*      FILE *sf; */
    222 
    223 /*      if (fpp != NULL) { */
    224 /*              mint = O_RDWR | O_CREAT; */
    225 /*              mstr = "r+"; */
    226 /*              human = "read/write"; */
    227 /*              lck = LOCK_EX; */
    228 /*      } else { */
    229 /*              mint = O_RDONLY; */
    230 /*              mstr = "r"; */
    231 /*              human = "reading"; */
    232 /*              lck = LOCK_SH; */
    233 /*      } */
    234 /*      setegid(egid); */
    235 /*      mask = umask(S_IWOTH); */
    236 /*      sd = open(_PATH_SCOREFILE, mint, 0666); */
    237 /*      (void)umask(mask); */
    238 /*      setegid(gid); */
    239 /*      if (sd < 0) { */
    240 /*              if (fpp == NULL) { */
    241 /*                      nscores = 0; */
    242 /*                      return; */
    243 /*              } */
    244 /*              err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */
    245 /*      } */
    246 /*      setegid(egid); */
    247 /*      if ((sf = fdopen(sd, mstr)) == NULL) */
    248 /*              err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */
    249 /*      setegid(gid); */
    250 
    251 /*      /\* */
    252 /*       * Grab a lock. */
    253 /*       *\/ */
    254 /*      if (flock(sd, lck)) */
    255 /*              warn("warning: score file %s cannot be locked", */
    256 /*                  _PATH_SCOREFILE); */
    257 
    258 /*      nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */
    259 /*      if (ferror(sf)) */
    260 /*              err(1, "error reading %s", _PATH_SCOREFILE); */
    261 /*      for (i = 0; i < nscores; i++) */
    262 /*              if (scores[i].hs_level < MINLEVEL || */
    263 /*                  scores[i].hs_level > MAXLEVEL) */
    264 /*                      errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */
    265 
    266 /*      if (fpp) */
    267 /*              *fpp = sf; */
    268 /*      else */
    269 /*              (void)fclose(sf); */
    270 /* } */
    271 
    272 void
    273 savescore(int level)
    274 {
    275         return;
    276 }
    277 /*      struct highscore *sp; */
    278 /*      int i; */
    279 /*      int change; */
    280 /*      FILE *sf; */
    281 /*      const char *me; */
    282 
    283 /*      getscores(&sf); */
    284 /*      gotscores = 1; */
    285 /*      (void)time(&now); */
    286 
    287 /*      /\* */
    288 /*       * Allow at most one score per person per level -- see if we */
    289 /*       * can replace an existing score, or (easiest) do nothing. */
    290 /*       * Otherwise add new score at end (there is always room). */
    291 /*       *\/ */
    292 /*      change = 0; */
    293 /*      me = thisuser(); */
    294 /*      for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */
    295 /*              if (sp->hs_level != level || str_cmp(sp->hs_name, me) != 0) */
    296 /*                      continue; */
    297 /*              if (score > sp->hs_score) { */
    298 /*                      (void)printf("%s bettered %s %d score of %d!\n", */
    299 /*                          "\nYou", "your old level", level, */
    300 /*                          sp->hs_score * sp->hs_level); */
    301 /*                      sp->hs_score = score;   /\* new score *\/ */
    302 /*                      sp->hs_time = now;      /\* and time *\/ */
    303 /*                      change = 1; */
    304 /*              } else if (score == sp->hs_score) { */
    305 /*                      (void)printf("%s tied %s %d high score.\n", */
    306 /*                          "\nYou", "your old level", level); */
    307 /*                      sp->hs_time = now;      /\* renew it *\/ */
    308 /*                      change = 1;             /\* gotta rewrite, sigh *\/ */
    309 /*              } /\* else new score < old score: do nothing *\/ */
    310 /*              break; */
    311 /*      } */
    312 /*      if (i >= nscores) { */
    313 /*              strlcpy(sp->hs_name, me, sizeof sp->hs_name); */
    314 /*              sp->hs_level = level; */
    315 /*              sp->hs_score = score; */
    316 /*              sp->hs_time = now; */
    317 /*              nscores++; */
    318 /*              change = 1; */
    319 /*      } */
    320 
    321 /*      if (change) { */
    322 /*              /\* */
    323 /*               * Sort & clean the scores, then rewrite. */
    324 /*               *\/ */
    325 /*              nscores = checkscores(scores, nscores); */
    326 /*              rewind(sf); */
    327 /*              if (fwrite(scores, sizeof(*sp), nscores, sf) != nscores || */
    328 /*                  fflush(sf) == EOF) */
    329 /*                      warnx("error writing %s: %s\n\t-- %s", */
    330 /*                          _PATH_SCOREFILE, strerror(errno), */
    331 /*                          "high scores may be damaged"); */
    332 /*      } */
    333 /*      (void)fclose(sf);       /\* releases lock *\/ */
    334 /* } */
    335 
    336 /*
    337  * Get login name, or if that fails, get something suitable.
    338  * The result is always trimmed to fit in a score.
    339  */
    340 /* static char * */
    341 /* thisuser(void) */
    342 /* { */
    343 /*      const char *p; */
    344 /*      struct passwd *pw; */
    345 /*      static char u[sizeof(scores[0].hs_name)]; */
    346 
    347 /*      if (u[0]) */
    348 /*              return (u); */
    349 /*      p = getlogin(); */
    350 /*      if (p == NULL || *p == '\0') { */
    351 /*              pw = getpwuid(getuid()); */
    352 /*              if (pw != NULL) */
    353 /*                      p = pw->pw_name; */
    354 /*              else */
    355 /*                      p = "  ???"; */
    356 /*      } */
    357 /*      strlcpy(u, p, sizeof(u)); */
    358 /*      return (u); */
    359 /* } */
    360 
    361 /*
    362  * Score comparison function for qsort.
    363  *
    364  * If two scores are equal, the person who had the score first is
    365  * listed first in the highscore file.
    366  */
    367 /* static int */
    368 /* cmpscores(const void *x, const void *y) */
    369 /* { */
    370 /*      const struct highscore *a, *b; */
    371 /*      long l; */
    372 
    373 /*      a = x; */
    374 /*      b = y; */
    375 /*      l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */
    376 /*      if (l < 0) */
    377 /*              return (-1); */
    378 /*      if (l > 0) */
    379 /*              return (1); */
    380 /*      if (a->hs_time < b->hs_time) */
    381 /*              return (-1); */
    382 /*      if (a->hs_time > b->hs_time) */
    383 /*              return (1); */
    384 /*      return (0); */
    385 /* } */
    386 
    387 /*
    388  * If we've added a score to the file, we need to check the file and ensure
    389  * that this player has only a few entries.  The number of entries is
    390  * controlled by MAXSCORES, and is to ensure that the highscore file is not
    391  * monopolised by just a few people.  People who no longer have accounts are
    392  * only allowed the highest score.  Scores older than EXPIRATION seconds are
    393  * removed, unless they are someone's personal best.
    394  * Caveat:  the highest score on each level is always kept.
    395  */
    396 /* static int */
    397 /* checkscores(struct highscore *hs, int num) */
    398 /* { */
    399 /*      struct highscore *sp; */
    400 /*      int i, j, k, numnames; */
    401 /*      int levelfound[NLEVELS]; */
    402 /*      struct peruser { */
    403 /*              char *name; */
    404 /*              int times; */
    405 /*      } count[NUMSPOTS]; */
    406 /*      struct peruser *pu; */
    407 
    408 /*      /\* */
    409 /*       * Sort so that highest totals come first. */
    410 /*       * */
    411 /*       * levelfound[i] becomes set when the first high score for that */
    412 /*       * level is encountered.  By definition this is the highest score. */
    413 /*       *\/ */
    414 /*      qsort((void *)hs, nscores, sizeof(*hs), cmpscores); */
    415 /*      for (i = MINLEVEL; i < NLEVELS; i++) */
    416 /*              levelfound[i] = 0; */
    417 /*      numnames = 0; */
    418 /*      for (i = 0, sp = hs; i < num;) { */
    419 /*              /\* */
    420 /*               * This is O(n^2), but do you think we care? */
    421 /*               *\/ */
    422 /*              for (j = 0, pu = count; j < numnames; j++, pu++) */
    423 /*                      if (str_cmp(sp->hs_name, pu->name) == 0) */
    424 /*                              break; */
    425 /*              if (j == numnames) { */
    426 /*                      /\* */
    427 /*                       * Add new user, set per-user count to 1. */
    428 /*                       *\/ */
    429 /*                      pu->name = sp->hs_name; */
    430 /*                      pu->times = 1; */
    431 /*                      numnames++; */
    432 /*              } else { */
    433 /*                      /\* */
    434 /*                       * Two ways to keep this score: */
    435 /*                       * - Not too many (per user), still has acct, & */
    436 /*                       *      score not dated; or */
    437 /*                       * - High score on this level. */
    438 /*                       *\/ */
    439 /*                      if ((pu->times < MAXSCORES && */
    440 /*                           getpwnam(sp->hs_name) != NULL && */
    441 /*                           sp->hs_time + EXPIRATION >= now) || */
    442 /*                          levelfound[sp->hs_level] == 0) */
    443 /*                              pu->times++; */
    444 /*                      else { */
    445 /*                              /\* */
    446 /*                               * Delete this score, do not count it, */
    447 /*                               * do not pass go, do not collect $200. */
    448 /*                               *\/ */
    449 /*                              num--; */
    450 /*                              for (k = i; k < num; k++) */
    451 /*                                      hs[k] = hs[k + 1]; */
    452 /*                              continue; */
    453 /*                      } */
    454 /*              } */
    455 /*              levelfound[sp->hs_level] = 1; */
    456 /*              i++, sp++; */
    457 /*      } */
    458 /*      return (num > MAXHISCORES ? MAXHISCORES : num); */
    459 /* } */
    460 
    461 /*
    462  * Show current scores.  This must be called after savescore, if
    463  * savescore is called at all, for two reasons:
    464  * - Showscores munches the time field.
    465  * - Even if that were not the case, a new score must be recorded
    466  *   before it can be shown anyway.
    467  */
    468 /*
    469 void
    470 showscores(int level)
    471 {
    472         return;
    473 }
    474 */
    475 /*      struct highscore *sp; */
    476 /*      int i, n, c; */
    477 /*      const char *me; */
    478 /*      int levelfound[NLEVELS]; */
    479 
    480 /*      if (!gotscores) */
    481 /*              getscores((FILE **)NULL); */
    482 /*      (void)printf("\n\t\t    Tetris High Scores\n"); */
    483 
    484 /*      /\* */
    485 /*       * If level == 0, the person has not played a game but just asked for */
    486 /*       * the high scores; we do not need to check for printing in highlight */
    487 /*       * mode.  If SOstr is null, we can't do highlighting anyway. */
    488 /*       *\/ */
    489 /*      me = level && SOstr ? thisuser() : NULL; */
    490 
    491 /*      /\* */
    492 /*       * Set times to 0 except for high score on each level. */
    493 /*       *\/ */
    494 /*      for (i = MINLEVEL; i < NLEVELS; i++) */
    495 /*              levelfound[i] = 0; */
    496 /*      for (i = 0, sp = scores; i < nscores; i++, sp++) { */
    497 /*              if (levelfound[sp->hs_level]) */
    498 /*                      sp->hs_time = 0; */
    499 /*              else { */
    500 /*                      sp->hs_time = 1; */
    501 /*                      levelfound[sp->hs_level] = 1; */
    502 /*              } */
    503 /*      } */
    504 
    505 /*      /\* */
    506 /*       * Page each screenful of scores. */
    507 /*       *\/ */
    508 /*      for (i = 0, sp = scores; i < nscores; sp += n) { */
    509 /*              n = 20; */
    510 /*              if (i + n > nscores) */
    511 /*                      n = nscores - i; */
    512 /*              printem(level, i + 1, sp, n, me); */
    513 /*              if ((i += n) < nscores) { */
    514 /*                      (void)printf("\nHit RETURN to continue."); */
    515 /*                      (void)fflush(stdout); */
    516 /*                      while ((c = getchar()) != '\n') */
    517 /*                              if (c == EOF) */
    518 /*                                      break; */
    519 /*                      (void)printf("\n"); */
    520 /*              } */
    521 /*      } */
    522 
    523 /*      if (nscores == 0) */
    524 /*              printf("\t\t\t      - none to date.\n"); */
    525 /* } */
    526 
    527 /* static void */
    528 /* printem(int level, int offset, struct highscore *hs, int n, const char *me) */
    529 /* { */
    530 /*      struct highscore *sp; */
    531 /*      int row, highlight, i; */
    532 /*      char buf[100]; */
    533 /* #define      TITLE "Rank  Score   Name                          (points/level)" */
    534 /* #define      TITL2 "==========================================================" */
    535 
    536 /*      printf("%s\n%s\n", TITLE, TITL2); */
    537 
    538 /*      highlight = 0; */
    539 
    540 /*      for (row = 0; row < n; row++) { */
    541 /*              sp = &hs[row]; */
    542 /*              (void)snprintf(buf, sizeof(buf), */
    543 /*                  "%3d%c %6d  %-31s (%6d on %d)\n", */
    544 /*                  row + offset, sp->hs_time ? '*' : ' ', */
    545 /*                  sp->hs_score * sp->hs_level, */
    546 /*                  sp->hs_name, sp->hs_score, sp->hs_level); */
    547 /*              /\* Print leaders every three lines *\/ */
    548 /*              if ((row + 1) % 3 == 0) { */
    549 /*                      for (i = 0; i < sizeof(buf); i++) */
    550 /*                              if (buf[i] == ' ') */
    551 /*                                      buf[i] = '_'; */
    552 /*              } */
    553 /*              /\* */
    554 /*               * Highlight if appropriate.  This works because */
    555 /*               * we only get one score per level. */
    556 /*               *\/ */
    557 /*              if (me != NULL && */
    558 /*                  sp->hs_level == level && */
    559 /*                  sp->hs_score == score && */
    560 /*                  str_cmp(sp->hs_name, me) == 0) { */
    561 /*                      putpad(SOstr); */
    562 /*                      highlight = 1; */
    563 /*              } */
    564 /*              (void)printf("%s", buf); */
    565 /*              if (highlight) { */
    566 /*                      putpad(SEstr); */
    567 /*                      highlight = 0; */
    568 /*              } */
    569 /*      } */
    570 /* } */
     197}
    571198
    572199/** @}
    573200 */
    574 

  • uspace/app/tetris/scores.h

    r080ad7f rebe70f1  
    3535 *      @(#)scores.h    8.1 (Berkeley) 5/31/93
    3636 */
     37
    3738/** @addtogroup tetris
    38  * @{ 
     39 * @{
    3940 */
    4041/** @file
    … …  
    4546 * Tetris scores.
    4647 */
     48
    4749#include <sys/time.h>
    4850#include <string.h>
    4951
    50 #define MAXLOGNAME 16
     52#define MAXLOGNAME   16
     53#define MAXHISCORES  10
     54#define MAXSCORES    9  /* maximum high score entries per person */
     55#define EXPIRATION   (5L * 365 * 24 * 60 * 60)
     56
    5157struct highscore {
    52         char    hs_name[STR_BOUNDS(MAXLOGNAME) + 1];    /* login name */
    53         int     hs_score;       /* raw score */
    54         int     hs_level;       /* play level */
    55 //      time_t  hs_time;        /* time at game end */
     58        char hs_name[STR_BOUNDS(MAXLOGNAME) + 1];  /* login name */
     59        int hs_score;                              /* raw score */
     60        int hs_level;                              /* play level */
     61        time_t hs_time;                            /* time at game end */
    5662};
    5763
    58 #define MAXHISCORES     10
    59 //#define MAXSCORES     9       /* maximum high score entries per person */
    60 //#define       EXPIRATION      (5L * 365 * 24 * 60 * 60)
    61 
    62 void savescore(int);
    63 void showscores(int);
    64 void insertscore(int score, int level);
    65 void initscores(void);
     64extern void showscores(int);
     65extern void initscores(void);
     66extern void insertscore(int score, int level);
    6667
    6768/** @}
    6869 */
    69 

  • uspace/app/tetris/screen.c

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris
    39  * @{ 
     39 * @{
    4040 */
    4141/** @file
    … …  
    5757#include <io/console.h>
    5858
    59 static cell curscreen[B_SIZE];  /* 1 => standout (or otherwise marked) */
     59#define STOP  (B_COLS - 3)
     60
     61static cell curscreen[B_SIZE];  /* non-zero => standout (or otherwise marked) */
    6062static int curscore;
    61 static int isset;               /* true => terminal is in game mode */
     63static int isset;               /* true => terminal is in game mode */
     64
     65static const struct shape *lastshape;
    6266
    6367
    … …  
    7276}
    7377
    74 static void start_standout(void)
    75 {
    76         console_set_rgb_color(fphone(stdout), 0xf0f0f0, 0);
     78static void start_standout(uint32_t color)
     79{
     80        console_set_rgb_color(fphone(stdout), 0xf0f0f0, color);
    7781}
    7882
    … …  
    9195 * Clear the screen, forgetting the current contents in the process.
    9296 */
    93 void
    94 scr_clear(void)
    95 {
    96 
     97void scr_clear(void)
     98{
    9799        resume_normal();
    98100        console_clear(fphone(stdout));
    99101        curscore = -1;
    100         memset((char *)curscreen, 0, sizeof(curscreen));
     102        memset(curscreen, 0, sizeof(curscreen));
    101103}
    102104
    … …  
    104106 * Set up screen
    105107 */
    106 void
    107 scr_init(void)
     108void scr_init(void)
    108109{
    109110        console_cursor_visibility(fphone(stdout), 0);
    … …  
    127128 * Set up screen mode.
    128129 */
    129 void
    130 scr_set(void)
     130void scr_set(void)
    131131{
    132132        winsize_t ws;
    133 
    134         Rows = 0, Cols = 0;
     133       
     134        Rows = 0;
     135        Cols = 0;
     136       
    135137        if (get_display_size(&ws) == 0) {
    136138                Rows = ws.ws_row;
    137139                Cols = ws.ws_col;
    138140        }
    139         if (Rows < MINROWS || Cols < MINCOLS) {
     141       
     142        if ((Rows < MINROWS) || (Cols < MINCOLS)) {
    140143                char smallscr[55];
    141 
     144               
    142145                snprintf(smallscr, sizeof(smallscr),
    143146                    "the screen is too small (must be at least %dx%d)",
    … …  
    146149        }
    147150        isset = 1;
    148 
     151       
    149152        scr_clear();
    150153}
    … …  
    153156 * End screen mode.
    154157 */
    155 void
    156 scr_end(void)
    157 {
    158 }
    159 
    160 void
    161 stop(char *why)
    162 {
    163 
     158void scr_end(void)
     159{
     160        console_cursor_visibility(fphone(stdout), 1);
     161}
     162
     163void stop(char *why)
     164{
    164165        if (isset)
    165166                scr_end();
     167       
    166168        errx(1, "aborting: %s", why);
    167169}
    168170
    169 
    170171/*
    171172 * Update the screen.
    172173 */
    173 void
    174 scr_update(void)
    175 {
    176         cell *bp, *sp;
    177         cell so, cur_so = 0;
    178         int i, ccol, j;
    179         static const struct shape *lastshape;
    180 
    181         /* always leave cursor after last displayed point */
     174void scr_update(void)
     175{
     176        cell *bp;
     177        cell *sp;
     178        cell so;
     179        cell cur_so = 0;
     180        int i;
     181        int j;
     182        int ccol;
     183       
     184        /* Always leave cursor after last displayed point */
    182185        curscreen[D_LAST * B_COLS - 1] = -1;
    183 
     186       
    184187        if (score != curscore) {
    185188                moveto(0, 0);
    … …  
    187190                curscore = score;
    188191        }
    189 
    190         /* draw preview of next pattern */
    191         if (showpreview && (nextshape != lastshape)) {
     192       
     193        /* Draw preview of next pattern */
     194        if ((showpreview) && (nextshape != lastshape)) {
    192195                int i;
    193                 static int r=5, c=2;
     196                static int r = 5, c = 2;
    194197                int tr, tc, t;
    195 
     198               
    196199                lastshape = nextshape;
    197 
    198                 /* clean */
     200               
     201                /* Clean */
    199202                resume_normal();
    200                 moveto(r-1, c-1); putstr("          ");
    201                 moveto(r,   c-1); putstr("          ");
    202                 moveto(r+1, c-1); putstr("          ");
    203                 moveto(r+2, c-1); putstr("          ");
    204 
    205                 moveto(r-3, c-2);
     203                moveto(r - 1, c - 1);
     204                putstr("          ");
     205                moveto(r, c - 1);
     206                putstr("          ");
     207                moveto(r + 1, c - 1);
     208                putstr("          ");
     209                moveto(r + 2, c - 1);
     210                putstr("          ");
     211               
     212                moveto(r - 3, c - 2);
    206213                putstr("Next shape:");
    207 
    208                 /* draw */
    209                 start_standout();
     214               
     215                /* Draw */
     216                start_standout(nextshape->color);
    210217                moveto(r, 2 * c);
    211218                putstr("  ");
    … …  
    213220                        t = c + r * B_COLS;
    214221                        t += nextshape->off[i];
    215 
     222                       
    216223                        tr = t / B_COLS;
    217224                        tc = t % B_COLS;
    218 
     225                       
    219226                        moveto(tr, 2*tc);
    220227                        putstr("  ");
    … …  
    222229                resume_normal();
    223230        }
    224 
     231       
    225232        bp = &board[D_FIRST * B_COLS];
    226233        sp = &curscreen[D_FIRST * B_COLS];
    … …  
    230237                        if (*sp == (so = *bp))
    231238                                continue;
     239                       
    232240                        *sp = so;
    233241                        if (i != ccol) {
    … …  
    238246                                moveto(RTOD(j), CTOD(i));
    239247                        }
     248                       
    240249                        if (so != cur_so) {
    241250                                if (so)
    242                                         start_standout();
     251                                        start_standout(so);
    243252                                else
    244253                                        resume_normal();
    … …  
    246255                        }
    247256                        putstr("  ");
    248 
     257                       
    249258                        ccol = i + 1;
    250259                        /*
    … …  
    256265                         * the next cell is a different color.
    257266                         */
    258 #define STOP (B_COLS - 3)
    259                         if (i > STOP || sp[1] != bp[1] || so != bp[1])
     267                       
     268                        if ((i > STOP) || (sp[1] != bp[1]) || (so != bp[1]))
    260269                                continue;
     270                       
    261271                        if (sp[2] != bp[2])
    262272                                sp[1] = -1;
    263                         else if (i < STOP && so == bp[2] && sp[3] != bp[3]) {
     273                        else if ((i < STOP) && (so == bp[2]) && (sp[3] != bp[3])) {
    264274                                sp[2] = -1;
    265275                                sp[1] = -1;
    … …  
    267277                }
    268278        }
     279       
    269280        if (cur_so)
    270281                resume_normal();
    271         fflush(stdout);
    272 }
    273 
    274 /*
    275  * Write a message (set!=0), or clear the same message (set==0).
     282       
     283        fflush(stdout);
     284}
     285
     286/*
     287 * Write a message (set != 0), or clear the same message (set == 0).
    276288 * (We need its length in case we have to overwrite with blanks.)
    277289 */
    278 void
    279 scr_msg(char *s, int set)
    280 {
    281        
     290void scr_msg(char *s, int set)
     291{
    282292        int l = str_size(s);
    283293       
    284294        moveto(Rows - 2, ((Cols - l) >> 1) - 1);
     295       
    285296        if (set)
    286297                putstr(s);
    … …  
    292303/** @}
    293304 */
    294 

  • uspace/app/tetris/screen.h

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris
    39  * @{ 
     39 * @{
    4040 */
    4141/** @file
    … …  
    4343
    4444/*
    45  * putpad() is for padded strings with count=1.
     45 * putpad() is for padded strings with count = 1.
    4646 */
    47 #define putpad(s)       tputs(s, 1, put)
     47#define putpad(s)  tputs(s, 1, put)
    4848
    4949#include <sys/types.h>
    … …  
    5757extern winsize_t winsize;
    5858
    59 void moveto(int r, int c);
    60 void clear_screen(void);
     59extern void moveto(int r, int c);
     60extern void clear_screen(void);
    6161
    62 int     put(int);                       /* just calls putchar; for tputs */
    63 void    scr_clear(void);
    64 void    scr_end(void);
    65 void    scr_init(void);
    66 void    scr_msg(char *, int);
    67 void    scr_set(void);
    68 void    scr_update(void);
     62/* just calls putchar; for tputs */
     63extern int put(int);
     64extern void scr_clear(void);
     65extern void scr_end(void);
     66extern void scr_init(void);
     67extern void scr_msg(char *, int);
     68extern void scr_set(void);
     69extern void scr_update(void);
    6970
    7071/** @}
    7172 */
    72 

  • uspace/app/tetris/shapes.c

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris
    39  * @{ 
     39 * @{
    4040 */
    4141/** @file
    … …  
    5151#include "tetris.h"
    5252
    53 #define TL      -B_COLS-1       /* top left */
    54 #define TC      -B_COLS         /* top center */
    55 #define TR      -B_COLS+1       /* top right */
    56 #define ML      -1              /* middle left */
    57 #define MR      1               /* middle right */
    58 #define BL      B_COLS-1        /* bottom left */
    59 #define BC      B_COLS          /* bottom center */
    60 #define BR      B_COLS+1        /* bottom right */
     53#define TL  (-B_COLS - 1)  /* top left */
     54#define TC  (-B_COLS)      /* top center */
     55#define TR  (-B_COLS + 1)  /* top right */
     56#define ML  -1             /* middle left */
     57#define MR  1              /* middle right */
     58#define BL  (B_COLS - 1)   /* bottom left */
     59#define BC  B_COLS         /* bottom center */
     60#define BR  (B_COLS + 1)   /* bottom right */
    6161
    6262const struct shape shapes[] = {
    63         /* 0*/  { 7,    7,      { TL, TC, MR } },
    64         /* 1*/  { 8,    8,      { TC, TR, ML } },
    65         /* 2*/  { 9,    11,     { ML, MR, BC } },
    66         /* 3*/  { 3,    3,      { TL, TC, ML } },
    67         /* 4*/  { 12,   14,     { ML, BL, MR } },
    68         /* 5*/  { 15,   17,     { ML, BR, MR } },
    69         /* 6*/  { 18,   18,     { ML, MR, 2  } }, /* sticks out */
    70         /* 7*/  { 0,    0,      { TC, ML, BL } },
    71         /* 8*/  { 1,    1,      { TC, MR, BR } },
    72         /* 9*/  { 10,   2,      { TC, MR, BC } },
    73         /*10*/  { 11,   9,      { TC, ML, MR } },
    74         /*11*/  { 2,    10,     { TC, ML, BC } },
    75         /*12*/  { 13,   4,      { TC, BC, BR } },
    76         /*13*/  { 14,   12,     { TR, ML, MR } },
    77         /*14*/  { 4,    13,     { TL, TC, BC } },
    78         /*15*/  { 16,   5,      { TR, TC, BC } },
    79         /*16*/  { 17,   15,     { TL, MR, ML } },
    80         /*17*/  { 5,    16,     { TC, BC, BL } },
    81         /*18*/  { 6,    6,      { TC, BC, 2*B_COLS } }/* sticks out */
     63        /*  0 */  {  7,  7, { TL, TC, MR }, 0xff042d},
     64        /*  1 */  {  8,  8, { TC, TR, ML }, 0xff9304},
     65        /*  2 */  {  9, 11, { ML, MR, BC }, 0xbeff04},
     66        /*  3 */  {  3,  3, { TL, TC, ML }, 0x63ff04},
     67        /*  4 */  { 12, 14, { ML, BL, MR }, 0xce04ff},
     68        /*  5 */  { 15, 17, { ML, BR, MR }, 0xff04cf},
     69        /*  6 */  { 18, 18, { ML, MR, 2  }, 0x7604ff}, /* sticks out */
     70        /*  7 */  {  0,  0, { TC, ML, BL }, 0xff042d},
     71        /*  8 */  {  1,  1, { TC, MR, BR }, 0xff9304},
     72        /*  9 */  { 10,  2, { TC, MR, BC }, 0xbeff04},
     73        /* 10 */  { 11,  9, { TC, ML, MR }, 0xbeff04},
     74        /* 11 */  {  2, 10, { TC, ML, BC }, 0xbeff04},
     75        /* 12 */  { 13,  4, { TC, BC, BR }, 0xce04ff},
     76        /* 13 */  { 14, 12, { TR, ML, MR }, 0xce04ff},
     77        /* 14 */  {  4, 13, { TL, TC, BC }, 0xce04ff},
     78        /* 15 */  { 16,  5, { TR, TC, BC }, 0xff04cf},
     79        /* 16 */  { 17, 15, { TL, MR, ML }, 0xff04cf},
     80        /* 17 */  {  5, 16, { TC, BC, BL }, 0xff04cf},
     81        /* 18 */  {  6,  6, { TC, BC, 2 * B_COLS }, 0x7604ff}  /* sticks out */
    8282};
    8383
    … …  
    8686 * taking the current board into account.
    8787 */
    88 int
    89 fits_in(const struct shape *shape, int pos)
     88int fits_in(const struct shape *shape, int pos)
    9089{
    9190        int *o = shape->off;
    92 
    93         if (board[pos] || board[pos + *o++] || board[pos + *o++] ||
    94             board[pos + *o])
     91       
     92        if ((board[pos]) || (board[pos + *o++]) || (board[pos + *o++]) ||
     93            (board[pos + *o]))
    9594                return 0;
     95       
    9696        return 1;
    9797}
    … …  
    101101 * if `onoff' is 1, and off if `onoff' is 0.
    102102 */
    103 void
    104 place(const struct shape *shape, int pos, int onoff)
     103void place(const struct shape *shape, int pos, int onoff)
    105104{
    106105        int *o = shape->off;
    107 
    108         board[pos] = onoff;
    109         board[pos + *o++] = onoff;
    110         board[pos + *o++] = onoff;
    111         board[pos + *o] = onoff;
     106       
     107        board[pos] = onoff ? shape->color : 0x000000;
     108        board[pos + *o++] = onoff ? shape->color : 0x000000;
     109        board[pos + *o++] = onoff ? shape->color : 0x000000;
     110        board[pos + *o] = onoff ? shape->color : 0x000000;
    112111}
    113112
    114113/** @}
    115114 */
    116 

  • uspace/app/tetris/tetris.c

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris Tetris
    39  * @brief       Tetris ported from OpenBSD
    40  * @{ 
     39 * @brief Tetris ported from OpenBSD
     40 * @{
    4141 */
    4242/** @file
    4343 */
    4444
    45 #ifndef lint
    4645static const char copyright[] =
    47 "@(#) Copyright (c) 1992, 1993\n\
    48         The Regents of the University of California.  All rights reserved.\n";
    49 #endif /* not lint */
    50 
    51 /*
    52  * Tetris (or however it is spelled).
    53  */
     46        "@(#) Copyright (c) 1992, 1993\n"
     47        "\tThe Regents of the University of California.  All rights reserved.\n";
    5448
    5549#include <sys/time.h>
    5650#include <sys/types.h>
    57 
    5851#include <err.h>
    5952#include <stdio.h>
    … …  
    6154#include <string.h>
    6255#include <unistd.h>
     56#include <getopt.h>
    6357
    6458#include "input.h"
    … …  
    6761#include "tetris.h"
    6862
    69 cell    board[B_SIZE];
    70 int     Rows, Cols;
     63cell board[B_SIZE];
     64
     65int Rows;
     66int Cols;
     67
    7168const struct shape *curshape;
    7269const struct shape *nextshape;
    73 long    fallrate;
    74 int     score;
    75 //gid_t gid, egid;
    76 char    key_msg[100];
    77 int     showpreview, classic;
    78 
    79 static void     elide(void);
    80 static void     setup_board(void);
    81 const struct shape *randshape(void);
    82 void    onintr(int);
    83 void    usage(void);
     70
     71long fallrate;
     72int score;
     73char key_msg[100];
     74int showpreview;
     75int classic;
     76
     77static void elide(void);
     78static void setup_board(void);
     79static const struct shape *randshape(void);
     80
     81static void usage(void);
     82
     83static int firstgame = 1;
    8484
    8585/*
    86  * Set up the initial board.  The bottom display row is completely set,
    87  * along with another (hidden) row underneath that.  Also, the left and
     86 * Set up the initial board. The bottom display row is completely set,
     87 * along with another (hidden) row underneath that. Also, the left and
    8888 * right edges are set.
    8989 */
    90 static void
    91 setup_board(void)
     90static void setup_board(void)
    9291{
    9392        int i;
    94         cell *p;
    95 
    96         p = board;
     93        cell *p = board;
     94       
    9795        for (i = B_SIZE; i; i--)
    98                 *p++ = i <= (2 * B_COLS) || (i % B_COLS) < 2;
     96                *p++ = (i <= (2 * B_COLS) || (i % B_COLS) < 2) ? 0x0000ff : 0x000000;
    9997}
    10098
    … …  
    102100 * Elide any full active rows.
    103101 */
    104 static void
    105 elide(void)
     102static void elide(void)
    106103{
    107104        int rows = 0;
    108         int i, j, base;
     105        int i;
     106        int j;
     107        int base;
    109108        cell *p;
    110 
     109       
    111110        for (i = A_FIRST; i < A_LAST; i++) {
    112111                base = i * B_COLS + 1;
    … …  
    114113                for (j = B_COLS - 2; *p++ != 0;) {
    115114                        if (--j <= 0) {
    116                                 /* this row is to be elided */
     115                                /* This row is to be elided */
    117116                                rows++;
    118                                 memset(&board[base], 0, B_COLS - 2);
     117                                memset(&board[base], 0, sizeof(cell) * (B_COLS - 2));
     118                               
    119119                                scr_update();
    120120                                tsleep();
     121                               
    121122                                while (--base != 0)
    122123                                        board[base + B_COLS] = board[base];
     124                               
    123125                                scr_update();
    124126                                tsleep();
     127                               
    125128                                break;
    126129                        }
    127130                }
    128131        }
     132       
    129133        switch (rows) {
    130134        case 1:
    … …  
    145149}
    146150
    147 const struct shape *
    148 randshape(void)
    149 {
    150         const struct shape *tmp;
    151         int i, j;
    152 
    153         tmp = &shapes[random() % 7];
    154         j = random() % 4;
     151const struct shape *randshape(void)
     152{
     153        const struct shape *tmp = &shapes[random() % 7];
     154        int i;
     155        int j = random() % 4;
     156       
    155157        for (i = 0; i < j; i++)
    156                 tmp = &shapes[classic? tmp->rotc : tmp->rot];
     158                tmp = &shapes[classic ? tmp->rotc : tmp->rot];
     159       
    157160        return (tmp);
    158161}
    … …  
    161164{
    162165        struct timeval tv;
    163 
     166       
    164167        gettimeofday(&tv, NULL);
    165168        srandom(tv.tv_sec + tv.tv_usec / 100000);
    … …  
    168171static void tetris_menu_draw(int level)
    169172{
    170                 clear_screen();
    171                 moveto(5,10);
    172                 puts("Tetris\n\n");
    173                        
    174                 moveto(8,10);
    175                 printf("Level = %d (press keys 1 - 9 to change)",level);
    176                 moveto(9,10);
    177                 printf("Preview is %s (press 'p' to change)", (showpreview?"on ":"off"));
    178                 moveto(12,10);
    179                 printf("Press 'h' to show hiscore table.");
    180                 moveto(13,10);
    181                 printf("Press 's' to start game.");
    182                 moveto(14,10);
    183                 printf("Press 'q' to quit game.");
    184                 moveto(20,10);
    185                 printf("In game controls:");
    186                 moveto(21,0);
    187                 puts(key_msg);
    188 }
    189 
    190 static int tetris_menu(int *level)
    191 {
    192         static int firstgame = 1;
    193         int i;
    194 /*      if (showpreview == 0)
    195                 (void)printf("Your score:  %d point%s  x  level %d  =  %d\n",
    196                     score, score == 1 ? "" : "s", level, score * level);
    197         else {
    198                 (void)printf("Your score:  %d point%s x level %d x preview penalty %0.3f = %d\n",
    199                     score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,
    200                     (int)(score * level * PRE_PENALTY));
    201                 score = score * PRE_PENALTY;
    202         }
    203         savescore(level);
    204 
    205         showscores(level);
    206        
    207         printf("\nHit 's' to new game, 'q' to quit.\n");
    208 */
     173        clear_screen();
     174        moveto(5, 10);
     175        puts("Tetris\n\n");
     176       
     177        moveto(8, 10);
     178        printf("Level = %d (press keys 1 - 9 to change)", level);
     179        moveto(9, 10);
     180        printf("Preview is %s (press 'p' to change)", (showpreview ? "on ": "off"));
     181        moveto(12, 10);
     182        printf("Press 'h' to show hiscore table.");
     183        moveto(13, 10);
     184        printf("Press 's' to start game.");
     185        moveto(14, 10);
     186        printf("Press 'q' to quit game.");
     187        moveto(20, 10);
     188        printf("In game controls:");
     189        moveto(21, 0);
     190        puts(key_msg);
     191}
     192
     193static int tetris_menu(int *level)
     194{
    209195        tetris_menu_draw(*level);
    210196        while (1) {
    211        
    212                 i = getchar();
     197                int i = getchar();
    213198               
    214199                switch(i) {
    215200                        case 'p':
    216201                                showpreview = !showpreview;
    217                                 moveto(9,21);
     202                                moveto(9, 21);
    218203                                if (showpreview)
    219204                                        printf("on ");
    220205                                else
    221206                                        printf("off");
    222                                        
    223207                                break;
    224208                        case 'h':
    … …  
    236220                        case '4':
    237221                        case '5':
    238                         case '6':               
     222                        case '6':
    239223                        case '7':
    240224                        case '8':
    241225                        case '9':
    242226                                *level = i - '0';
    243                                 moveto(8,18);
     227                                moveto(8, 18);
    244228                                printf("%d", *level);
    245229                                break;
    246230                }
    247231        }
    248        
    249 }
    250 
    251 int
    252 main(int argc, char *argv[])
    253 {
    254         int pos, c;
     232}
     233
     234int main(int argc, char *argv[])
     235{
     236        int pos;
     237        int c;
    255238        char *keys;
    256239        int level = 2;
    257240        char key_write[6][10];
    258         int i, j;
    259 
     241        int i;
     242        int j;
     243        int ch;
     244       
    260245        keys = "jkl pq";
    261 
    262 //      gid = getgid();
    263 //      egid = getegid();
    264 //      setegid(gid);
    265 
     246       
    266247        classic = 0;
    267248        showpreview = 1;
    268 
    269 /*      while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */
    270 /*              switch(ch) { */
    271 /*              case 'c': */
    272 /*                      /\* */
    273 /*                       * this means: */
    274 /*                       *      - rotate the other way; */
    275 /*                       *      - no reverse video. */
    276 /*                       *\/ */
    277 /*                      classic = 1; */
    278 /*                      break; */
    279 /*              case 'k': */
    280 /*                      if (str_size(keys = optarg) != 6) */
    281 /*                              usage(); */
    282 /*                      break; */
    283 /*              case 'l': */
    284 /*                      level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */
    285 /*                          &errstr); */
    286 /*                      if (errstr) */
    287 /*                              errx(1, "level must be from %d to %d", */
    288 /*                                  MINLEVEL, MAXLEVEL); */
    289 /*                      break; */
    290 /*              case 'p': */
    291 /*                      showpreview = 1; */
    292 /*                      break; */
    293 /*              case 's': */
    294 /*                      showscores(0); */
    295 /*                      exit(0); */
    296 /*              default: */
    297 /*                      usage(); */
    298 /*              } */
    299 
    300 /*      argc -= optind; */
    301 /*      argv += optind; */
    302 
    303 /*      if (argc) */
    304 /*              usage(); */
    305 
    306        
    307 
     249       
     250        while ((ch = getopt(argc, argv, "ck:ps")) != -1)
     251                switch(ch) {
     252                case 'c':
     253                        /*
     254                         * this means:
     255                         *  - rotate the other way
     256                         *  - no reverse video
     257                         */
     258                        classic = 1;
     259                        break;
     260                case 'k':
     261                        if (str_size(keys = optarg) != 6)
     262                                usage();
     263                        break;
     264                case 'p':
     265                        showpreview = 1;
     266                        break;
     267                case 's':
     268                        showscores(0);
     269                        exit(0);
     270                default:
     271                        usage();
     272                }
     273       
     274        argc -= optind;
     275        argv += optind;
     276       
     277        if (argc)
     278                usage();
     279       
    308280        for (i = 0; i <= 5; i++) {
    309                 for (j = i+1; j <= 5; j++) {
     281                for (j = i + 1; j <= 5; j++) {
    310282                        if (keys[i] == keys[j])
    311283                                errx(1, "duplicate command keys specified.");
    312284                }
     285               
    313286                if (keys[i] == ' ')
    314                         str_cpy(key_write[i], sizeof key_write[i], "<space>");
     287                        str_cpy(key_write[i], sizeof(key_write[i]), "<space>");
    315288                else {
    316289                        key_write[i][0] = keys[i];
    … …  
    318291                }
    319292        }
    320 
    321         snprintf(key_msg, sizeof key_msg,
    322 "%s - left   %s - rotate   %s - right   %s - drop   %s - pause   %s - quit",
    323                 key_write[0], key_write[1], key_write[2], key_write[3],
    324                 key_write[4], key_write[5]);
    325 
     293       
     294        snprintf(key_msg, sizeof(key_msg),
     295            "%s - left   %s - rotate   %s - right   %s - drop   %s - pause   %s - quit",
     296            key_write[0], key_write[1], key_write[2], key_write[3],
     297            key_write[4], key_write[5]);
     298       
    326299        scr_init();
    327300        initscores();
    … …  
    331304                scr_clear();
    332305                setup_board();
    333        
     306               
    334307                srandomdev();
    335308                scr_set();
    336        
    337                 pos = A_FIRST*B_COLS + (B_COLS/2)-1;
     309               
     310                pos = A_FIRST * B_COLS + (B_COLS / 2) - 1;
    338311                nextshape = randshape();
    339312                curshape = randshape();
    340        
     313               
    341314                scr_msg(key_msg, 1);
    342        
    343                 for (;;) {
     315               
     316                while (1) {
    344317                        place(curshape, pos, 1);
    345318                        scr_update();
    … …  
    354327                                        continue;
    355328                                }
    356        
     329                               
    357330                                /*
    358331                                 * Put up the current shape `permanently',
    … …  
    362335                                score++;
    363336                                elide();
    364        
     337                               
    365338                                /*
    366339                                 * Choose a new shape.  If it does not fit,
    … …  
    369342                                curshape = nextshape;
    370343                                nextshape = randshape();
    371                                 pos = A_FIRST*B_COLS + (B_COLS/2)-1;
     344                                pos = A_FIRST * B_COLS + (B_COLS / 2) - 1;
     345                               
    372346                                if (!fits_in(curshape, pos))
    373347                                        break;
    374                                 continue;
    375                         }
    376        
     348                               
     349                                continue;
     350                        }
     351                       
    377352                        /*
    378353                         * Handle command keys.
    … …  
    382357                                break;
    383358                        }
     359                       
    384360                        if (c == keys[4]) {
    385361                                static char msg[] =
    386362                                    "paused - press RETURN to continue";
    387        
     363                               
    388364                                place(curshape, pos, 1);
    389365                                do {
    … …  
    392368                                        scr_msg(msg, 1);
    393369                                        (void) fflush(stdout);
    394                                 } while (rwait((struct timeval *)NULL) == -1);
     370                                } while (rwait((struct timeval *) NULL) == -1);
     371                               
    395372                                scr_msg(msg, 0);
    396373                                scr_msg(key_msg, 1);
    … …  
    398375                                continue;
    399376                        }
     377                       
    400378                        if (c == keys[0]) {
    401379                                /* move left */
    … …  
    404382                                continue;
    405383                        }
     384                       
    406385                        if (c == keys[1]) {
    407386                                /* turn */
    408                                 const struct shape *new = &shapes[
    409                                     classic? curshape->rotc : curshape->rot];
    410        
     387                                const struct shape *new =
     388                                    &shapes[classic ? curshape->rotc : curshape->rot];
     389                               
    411390                                if (fits_in(new, pos))
    412391                                        curshape = new;
    413392                                continue;
    414393                        }
     394                       
    415395                        if (c == keys[2]) {
    416396                                /* move right */
    … …  
    419399                                continue;
    420400                        }
     401                       
    421402                        if (c == keys[3]) {
    422403                                /* move to bottom */
    … …  
    427408                                continue;
    428409                        }
     410                       
    429411                        if (c == '\f') {
    430412                                scr_clear();
    … …  
    435417                scr_clear();
    436418                insertscore(score, level);
    437                 score=0;
     419                score = 0;
    438420        }
    439421       
    440422        scr_clear();
    441         printf("\n\n\n\t\tGame over.\n");
    442 /*     
    443         while ((i = getchar()) != '\n')
    444                 if (i == EOF)
    445                         break
    446 */
     423        printf("\nGame over.\n");
    447424        scr_end();
    448 
     425       
    449426        return 0;
    450427}
    451428
    452 /* void */
    453 /* onintr(int signo) */
    454 /* { */
    455 /*      scr_clear();            /\* XXX signal race *\/ */
    456 /*      scr_end();              /\* XXX signal race *\/ */
    457 /*      _exit(0); */
    458 /* } */
    459 
    460 void
    461 usage(void)
    462 {
    463         (void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");
     429void usage(void)
     430{
     431        fprintf(stderr, "usage: tetris [-ps] [-k keys]\n");
    464432        exit(1);
    465433}
    … …  
    467435/** @}
    468436 */
    469 

  • uspace/app/tetris/tetris.h

    r080ad7f rebe70f1  
    3737
    3838/** @addtogroup tetris
    39  * @{ 
     39 * @{
    4040 */
    4141/** @file
    … …  
    5656 */
    5757
    58         /* the board */
    59 #define B_COLS  12
    60 #define B_ROWS  23
    61 #define B_SIZE  (B_ROWS * B_COLS)
     58/* The board */
     59#define B_COLS  12
     60#define B_ROWS  23
     61#define B_SIZE  (B_ROWS * B_COLS)
    6262
    63 typedef unsigned char cell;
    64 extern cell     board[B_SIZE];  /* 1 => occupied, 0 => empty */
     63typedef uint32_t cell;
    6564
    66         /* the displayed area (rows) */
    67 #define D_FIRST 1
    68 #define D_LAST  22
     65extern cell board[B_SIZE];  /* 1 => occupied, 0 => empty */
    6966
    70         /* the active area (rows) */
    71 #define A_FIRST 1
    72 #define A_LAST  21
     67/* The displayed area (rows) */
     68#define D_FIRST  1
     69#define D_LAST   22
     70
     71/* The active area (rows) */
     72#define A_FIRST  1
     73#define A_LAST   21
    7374
    7475/*
    7576 * Minimum display size.
    7677 */
    77 #define MINROWS 23
    78 #define MINCOLS 40
     78#define MINROWS  23
     79#define MINCOLS  40
    7980
    80 extern int      Rows, Cols;     /* current screen size */
     81/* Current screen size */
     82extern int Rows;
     83extern int Cols;
    8184
    8285/*
    … …  
    8487 * As with board coordinates, display coordiates are zero origin.
    8588 */
    86 #define RTOD(x) ((x) - 1)
    87 #define CTOD(x) ((x) * 2 + (((Cols - 2 * B_COLS) >> 1) - 1))
     89#define RTOD(x)  ((x) - 1)
     90#define CTOD(x)  ((x) * 2 + (((Cols - 2 * B_COLS) >> 1) - 1))
    8891
    8992/*
    … …  
    9194 * are 7 basic shapes, each consisting of four `blots':
    9295 *
    93  *      X.X       X.X           X.X
    94  *        X.X   X.X     X.X.X   X.X     X.X.X   X.X.X   X.X.X.X
    95  *                        X             X           X
     96 *      X.X       X.X           X.X
     97 *        X.X   X.X     X.X.X   X.X     X.X.X   X.X.X   X.X.X.X
     98 *                        X             X           X
    9699 *
    97  *        0       1       2       3       4       5       6
     100 *          0     1       2       3       4       5       6
    98101 *
    99102 * Except for 3 and 6, the center of each shape is one of the blots.
    100  * This blot is designated (0,0).  The other three blots can then be
     103 * This blot is designated (0, 0).  The other three blots can then be
    101104 * described as offsets from the center.  Shape 3 is the same under
    102105 * rotation, so its center is effectively irrelevant; it has been chosen
    103106 * so that it `sticks out' upward and leftward.  Except for shape 6,
    104  * all the blots are contained in a box going from (-1,-1) to (+1,+1);
     107 * all the blots are contained in a box going from (-1, -1) to (+1, +1);
    105108 * shape 6's center `wobbles' as it rotates, so that while it `sticks out'
    106109 * rightward, its rotation---a vertical line---`sticks out' downward.
    107  * The containment box has to include the offset (2,0), making the overall
    108  * containment box range from offset (-1,-1) to (+2,+1).  (This is why
     110 * The containment box has to include the offset (2, 0), making the overall
     111 * containment box range from offset (-1, -1) to (+2, +1).  (This is why
    109112 * there is only one row above, but two rows below, the display area.)
    110113 *
    … …  
    117120 * these rows move down to make more room.  A new random shape is again
    118121 * introduced at the top of the board, and the whole process repeats.
    119  * The game ends when the new shape will not fit at (1,5).
     122 * The game ends when the new shape will not fit at (1, 5).
    120123 *
    121124 * While the shapes are falling, the user can rotate them counterclockwise
    … …  
    129132 */
    130133struct shape {
    131         int     rot;    /* index of rotated version of this shape */
    132         int     rotc;   /* -- " -- in classic version  */
    133         int     off[3]; /* offsets to other blots if center is at (0,0) */
     134        int rot;     /* index of rotated version of this shape */
     135        int rotc;    /* -- " -- in classic version  */
     136        int off[3];  /* offsets to other blots if center is at (0,0) */
     137        uint32_t color;
    134138};
    135139
    … …  
    149153 * but by then the game is utterly impossible.
    150154 */
    151 extern long     fallrate;       /* less than 1 million; smaller => faster */
    152 #define faster() (fallrate -= fallrate / 3000)
     155extern long fallrate;  /* less than 1 million; smaller => faster */
     156
     157#define faster()  (fallrate -= fallrate / 3000)
    153158
    154159/*
    … …  
    156161 * and affects scoring.
    157162 */
    158 #define MINLEVEL        1
    159 #define MAXLEVEL        9
     163#define MINLEVEL  1
     164#define MAXLEVEL  9
    160165
    161166/*
    … …  
    171176 * If previewing has been turned on, the score is multiplied by PRE_PENALTY.
    172177 */
    173 #define PRE_PENALTY 0.75
     178#define PRE_PENALTY  0.75
    174179
    175 extern int      score;          /* the obvious thing */
    176 //extern gid_t  gid, egid;
     180extern int score;  /* The obvious thing */
    177181
    178 extern char     key_msg[100];
    179 extern int      showpreview;
    180 extern int      classic;
     182extern char key_msg[100];
     183extern int showpreview;
     184extern int classic;
    181185
    182 int     fits_in(const struct shape *, int);
    183 void    place(const struct shape *, int, int);
    184 void    stop(char *);
     186extern int fits_in(const struct shape *, int);
     187extern void place(const struct shape *, int, int);
     188extern void stop(char *);
    185189
    186190/** @}
    187191 */
    188 
Note: See TracChangeset for help on using the changeset viewer.