robots/move.c

   1 /*      $NetBSD: move.c,v 1.9 1999/09/08 21:17:57 jsm Exp $     */
   2
   3 /*
   4  * Copyright (c) 1980, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 #ifndef lint
  38 #if 0
  39 static char sccsid[] = "@(#)move.c      8.1 (Berkeley) 5/31/93";
  40 #else
  41 __RCSID("$NetBSD: move.c,v 1.9 1999/09/08 21:17:57 jsm Exp $");
  42 #endif
  43 #endif /* not lint */
  44
  45 #include "robots.h"
  46
  47 # define        ESC     '\033'
  48
  49 /*
  50  * get_move:
  51  *      Get and execute a move from the player
  52  */
  53 void
  54 get_move()
  55 {
  56         int             c;
  57 #ifdef FANCY
  58         int             lastmove;
  59 #endif /*FANCY*/
  60
  61         if (Waiting)
  62                 return;
  63
  64 #ifdef  FANCY
  65         if (Pattern_roll) {
  66                 if (Next_move >= Move_list)
  67                         lastmove = *Next_move;
  68                 else
  69                         lastmove = -1;  /* flag for "first time in" */
  70         } else
  71                 lastmove = 0; /* Shut up gcc */
  72 #endif
  73         for (;;) {
  74                 if (Teleport && must_telep())
  75                         goto teleport;
  76                 if (Running)
  77                         c = Run_ch;
  78                 else if (Count != 0)
  79                         c = Cnt_move;
  80 #ifdef  FANCY
  81                 else if (Num_robots > 1 && Stand_still)
  82                         c = '>';
  83                 else if (Num_robots > 1 && Pattern_roll) {
  84                         if (*++Next_move == '\0') {
  85                                 if (lastmove < 0)
  86                                         goto over;
  87                                 Next_move = Move_list;
  88                         }
  89                         c = *Next_move;
  90                         mvaddch(0, 0, c);
  91                         if (c == lastmove)
  92                                 goto over;
  93                 }
  94 #endif
  95                 else {
  96 over:
  97                         if (Auto_bot)
  98                                 c = automove();
  99                         else
 100                                 c = getchar();
 101                         if (isdigit(c)) {
 102                                 Count = (c - '0');
 103                                 while (isdigit(c = getchar()))
 104                                         Count = Count * 10 + (c - '0');
 105                                 if (c == ESC)
 106                                         goto over;
 107                                 Cnt_move = c;
 108                                 if (Count)
 109                                         leaveok(stdscr, TRUE);
 110                         }
 111                 }
 112
 113                 switch (c) {
 114                   case ' ':
 115                   case '.':
 116                         if (do_move(0, 0))
 117                                 goto ret;
 118                         break;
 119                   case 'y':
 120                         if (do_move(-1, -1))
 121                                 goto ret;
 122                         break;
 123                   case 'k':
 124                         if (do_move(-1, 0))
 125                                 goto ret;
 126                         break;
 127                   case 'u':
 128                         if (do_move(-1, 1))
 129                                 goto ret;
 130                         break;
 131                   case 'h':
 132                         if (do_move(0, -1))
 133                                 goto ret;
 134                         break;
 135                   case 'l':
 136                         if (do_move(0, 1))
 137                                 goto ret;
 138                         break;
 139                   case 'b':
 140                         if (do_move(1, -1))
 141                                 goto ret;
 142                         break;
 143                   case 'j':
 144                         if (do_move(1, 0))
 145                                 goto ret;
 146                         break;
 147                   case 'n':
 148                         if (do_move(1, 1))
 149                                 goto ret;
 150                         break;
 151                   case 'Y': case 'U': case 'H': case 'J':
 152                   case 'K': case 'L': case 'B': case 'N':
 153                   case '>':
 154                         Running = TRUE;
 155                         if (c == '>')
 156                                 Run_ch = ' ';
 157                         else
 158                                 Run_ch = tolower(c);
 159                         leaveok(stdscr, TRUE);
 160                         break;
 161                   case 'q':
 162                   case 'Q':
 163                         if (query("Really quit?"))
 164                                 quit(0);
 165                         refresh();
 166                         break;
 167                   case 'w':
 168                   case 'W':
 169                         Waiting = TRUE;
 170                         leaveok(stdscr, TRUE);
 171                         goto ret;
 172                   case 't':
 173                   case 'T':
 174 teleport:
 175                         Running = FALSE;
 176                         mvaddch(My_pos.y, My_pos.x, ' ');
 177                         My_pos = *rnd_pos();
 178                         mvaddch(My_pos.y, My_pos.x, PLAYER);
 179                         leaveok(stdscr, FALSE);
 180                         refresh();
 181                         flush_in();
 182                         goto ret;
 183                   case CTRL('L'):
 184                         wrefresh(curscr);
 185                         break;
 186                   case EOF:
 187                         break;
 188                   default:
 189                         putchar(CTRL('G'));
 190                         reset_count();
 191                         fflush(stdout);
 192                         break;
 193                 }
 194         }
 195 ret:
 196         if (Count > 0)
 197                 if (--Count == 0)
 198                         leaveok(stdscr, FALSE);
 199 }
 200
 201 /*
 202  * must_telep:
 203  *      Must I teleport; i.e., is there anywhere I can move without
 204  * being eaten?
 205  */
 206 bool
 207 must_telep()
 208 {
 209         int             x, y;
 210         static COORD    newpos;
 211
 212 #ifdef  FANCY
 213         if (Stand_still && Num_robots > 1 && eaten(&My_pos))
 214                 return TRUE;
 215 #endif
 216
 217         for (y = -1; y <= 1; y++) {
 218                 newpos.y = My_pos.y + y;
 219                 if (newpos.y <= 0 || newpos.y >= Y_FIELDSIZE)
 220                         continue;
 221                 for (x = -1; x <= 1; x++) {
 222                         newpos.x = My_pos.x + x;
 223                         if (newpos.x <= 0 || newpos.x >= X_FIELDSIZE)
 224                                 continue;
 225                         if (Field[newpos.y][newpos.x] > 0)
 226                                 continue;
 227                         if (!eaten(&newpos))
 228                                 return FALSE;
 229                 }
 230         }
 231         return TRUE;
 232 }
 233
 234 /*
 235  * do_move:
 236  *      Execute a move
 237  */
 238 bool
 239 do_move(dy, dx)
 240         int     dy, dx;
 241 {
 242         static COORD    newpos;
 243
 244         newpos.y = My_pos.y + dy;
 245         newpos.x = My_pos.x + dx;
 246         if (newpos.y <= 0 || newpos.y >= Y_FIELDSIZE ||
 247             newpos.x <= 0 || newpos.x >= X_FIELDSIZE ||
 248             Field[newpos.y][newpos.x] > 0 || eaten(&newpos)) {
 249                 if (Running) {
 250                         Running = FALSE;
 251                         leaveok(stdscr, FALSE);
 252                         move(My_pos.y, My_pos.x);
 253                         refresh();
 254                 }
 255                 else {
 256                         putchar(CTRL('G'));
 257                         reset_count();
 258                 }
 259                 return FALSE;
 260         }
 261         else if (dy == 0 && dx == 0)
 262                 return TRUE;
 263         mvaddch(My_pos.y, My_pos.x, ' ');
 264         My_pos = newpos;
 265         mvaddch(My_pos.y, My_pos.x, PLAYER);
 266         if (!jumping())
 267                 refresh();
 268         return TRUE;
 269 }
 270
 271 /*
 272  * eaten:
 273  *      Player would get eaten at this place
 274  */
 275 bool
 276 eaten(pos)
 277         const COORD     *pos;
 278 {
 279         int     x, y;
 280
 281         for (y = pos->y - 1; y <= pos->y + 1; y++) {
 282                 if (y <= 0 || y >= Y_FIELDSIZE)
 283                         continue;
 284                 for (x = pos->x - 1; x <= pos->x + 1; x++) {
 285                         if (x <= 0 || x >= X_FIELDSIZE)
 286                                 continue;
 287                         if (Field[y][x] == 1)
 288                                 return TRUE;
 289                 }
 290         }
 291         return FALSE;
 292 }
 293
 294 /*
 295  * reset_count:
 296  *      Reset the count variables
 297  */
 298 void
 299 reset_count()
 300 {
 301         Count = 0;
 302         Running = FALSE;
 303         leaveok(stdscr, FALSE);
 304         refresh();
 305 }
 306
 307 /*
 308  * jumping:
 309  *      See if we are jumping, i.e., we should not refresh.
 310  */
 311 bool
 312 jumping()
 313 {
 314         return (Jump && (Count || Running || Waiting));
 315 }