Source-Changes-HG archive

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]

[src/trunk]: src/games/snake/snake Convert snake to use curses, and generally...



details:   https://anonhg.NetBSD.org/src/rev/c579a0c239eb
branches:  trunk
changeset: 476357:c579a0c239eb
user:      jsm <jsm%NetBSD.org@localhost>
date:      Tue Sep 14 18:07:21 1999 +0000

description:
Convert snake to use curses, and generally clean it up somewhat.

Includes bugfixes from or inspired by OpenBSD.

diffstat:

 games/snake/snake/Makefile |    8 +-
 games/snake/snake/move.c   |  712 ---------------------------------------------
 games/snake/snake/snake.6  |    7 +-
 games/snake/snake/snake.c  |  367 ++++++++++++----------
 games/snake/snake/snake.h  |  126 -------
 5 files changed, 212 insertions(+), 1008 deletions(-)

diffs (truncated from 1671 to 300 lines):

diff -r e7e934bb1736 -r c579a0c239eb games/snake/snake/Makefile
--- a/games/snake/snake/Makefile        Tue Sep 14 17:11:45 1999 +0000
+++ b/games/snake/snake/Makefile        Tue Sep 14 18:07:21 1999 +0000
@@ -1,11 +1,11 @@
-#      $NetBSD: Makefile,v 1.8 1998/02/04 10:24:13 christos Exp $
+#      $NetBSD: Makefile,v 1.9 1999/09/14 18:07:21 jsm Exp $
 #      @(#)Makefile    8.1 (Berkeley) 5/31/93
 
 PROG=  snake
-SRCS=  snake.c move.c
+SRCS=  snake.c
 MAN=   snake.6
-DPADD= ${LIBM} ${LIBTERMCAP}
-LDADD= -lm -ltermcap
+DPADD= ${LIBM} ${LIBCURSES}
+LDADD= -lm -lcurses
 HIDEGAME=hidegame
 SETGIDGAME=yes
 
diff -r e7e934bb1736 -r c579a0c239eb games/snake/snake/move.c
--- a/games/snake/snake/move.c  Tue Sep 14 17:11:45 1999 +0000
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,712 +0,0 @@
-/*     $NetBSD: move.c,v 1.17 1999/09/08 21:17:59 jsm Exp $    */
-
-/*
- * Copyright (c) 1980, 1993
- *     The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-#ifndef lint
-#if 0
-static char sccsid[] = "@(#)move.c     8.1 (Berkeley) 7/19/93";
-#else
-__RCSID("$NetBSD: move.c,v 1.17 1999/09/08 21:17:59 jsm Exp $");
-#endif
-#endif                         /* not lint */
-
-/*************************************************************************
- *
- *     MOVE LIBRARY
- *
- *     This set of subroutines moves a cursor to a predefined
- *     location, independent of the terminal type.  If the
- *     terminal has an addressable cursor, it uses it.  If
- *     not, it optimizes for tabs (currently) even if you don't
- *      have them.
- *
- *     At all times the current address of the cursor must be maintained,
- *     and that is available as structure cursor.
- *
- *     The following calls are allowed:
- *             move(sp)        move to point sp.
- *             up()            move up one line.
- *             down()          move down one line.
- *             bs()            move left one space (except column 0).
- *             nd()            move right one space(no write).
- *             clear()         clear screen.
- *             home()          home.
- *             ll()            move to lower left corner of screen.
- *             cr()            carriage return (no line feed).
- *             pr()            just like standard printf, but keeps track
- *                             of cursor position. (Uses pstring).
- *             apr()           same as printf, but first argument is &point.
- *                             (Uses pstring).
- *             pstring(s)      output the string of printing characters.
- *                             However, '\r' is interpreted to mean return
- *                             to column of origination AND do linefeed.
- *                             '\n' causes <cr><lf>.
- *             putpad(str)     calls tputs to output character with proper
- *                                     padding.
- *             outch()         the output routine for a character used by
- *                                     tputs. It just calls putchar.
- *             pch(ch)         output character to screen and update
- *                                     cursor address (must be a standard
- *                                     printing character). WILL SCROLL.
- *             pchar(ps,ch)    prints one character if it is on the
- *                                     screen at the specified location;
- *                                     otherwise, dumps it.(no wrap-around).
- *
- *             getcap()        initializes strings for later calls.
- *             cap(string)     outputs the string designated in the termcap
- *                                     data base. (Should not move the cursor.)
- *             done()          returns the terminal to intial state and exits.
- *
- *             point(&p,x,y)   return point set to x,y.
- *
- *             delay(t)        causes an approximately constant delay
- *                                     independent of baudrate.
- *                                     Duration is ~ t/20 seconds.
- *
- ******************************************************************************/
-
-#if __STDC__
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
-#include "snake.h"
-
-int     CMlength;
-int     NDlength;
-int     BSlength;
-int     delaystr[10];
-short ospeed;
-
-static char str[80];
-
-void
-move(sp)
-       struct point *sp;
-{
-       int     distance;
-       int     tabcol, ct;
-       struct point z;
-
-       if (sp->line < 0 || sp->col < 0 || sp->col > COLUMNS) {
-               pr("move to [%d,%d]?", sp->line, sp->col);
-               return;
-       }
-       if (sp->line >= LINES) {
-               move(point(&z, sp->col, LINES - 1));
-               while (sp->line-- >= LINES)
-                       putchar('\n');
-               return;
-       }
-       if (CM != 0) {
-               char   *cmstr = tgoto(CM, sp->col, sp->line);
-
-               CMlength = strlen(cmstr);
-               if (cursor.line == sp->line) {
-                       distance = sp->col - cursor.col;
-                       if (distance == 0)
-                               return; /* Already there! */
-                       if (distance > 0) {     /* Moving to the right */
-                               if (distance * NDlength < CMlength) {
-                                       right(sp);
-                                       return;
-                               }
-                               if (TA) {
-                                       ct = sp->col & 7;
-                                       tabcol = (cursor.col | 7) + 1;
-                                       do {
-                                               ct++;
-                                               tabcol = (tabcol | 7) + 1;
-                                       }
-                                       while (tabcol < sp->col);
-                                       if (ct < CMlength) {
-                                               right(sp);
-                                               return;
-                                       }
-                               }
-                       } else {/* Moving to the left */
-                               if (-distance * BSlength < CMlength) {
-                                       gto(sp);
-                                       return;
-                               }
-                       }
-                       if (sp->col < CMlength) {
-                               cr();
-                               right(sp);
-                               return;
-                       }
-                       /* No more optimizations on same row. */
-               }
-               distance = sp->col - cursor.col;
-               distance = distance > 0 ?
-                   distance * NDlength : -distance * BSlength;
-               if (distance < 0)
-                       pr("ERROR: distance is negative: %d", distance);
-               distance += abs(sp->line - cursor.line);
-               if (distance >= CMlength) {
-                       putpad(cmstr);
-                       cursor.line = sp->line;
-                       cursor.col = sp->col;
-                       return;
-               }
-       }
-       /*
-        * If we get here we have a terminal that can't cursor
-        * address but has local motions or one which can cursor
-        * address but can get there quicker with local motions.
-        */
-       gto(sp);
-}
-
-void
-gto(sp)
-       const struct point *sp;
-{
-
-       int     distance, f, tfield;
-
-       if (cursor.line > LINES || cursor.line < 0 ||
-           cursor.col < 0 || cursor.col > COLUMNS)
-               pr("ERROR: cursor is at %d,%d\n",
-                   cursor.line, cursor.col);
-       if (sp->line > LINES || sp->line < 0 ||
-           sp->col < 0 || sp->col > COLUMNS)
-               pr("ERROR: target is %d,%d\n", sp->line, sp->col);
-       tfield = (sp->col) >> 3;
-       if (sp->line == cursor.line) {
-               if (sp->col > cursor.col)
-                       right(sp);
-               else {
-                       distance = (cursor.col - sp->col) * BSlength;
-                       if (((TA) &&
-                               (distance > tfield + ((sp->col) & 7) * NDlength)
-                           ) ||
-                           (((cursor.col) * NDlength) < distance)
-                           ) {
-                               cr();
-                               right(sp);
-                       } else {
-                               while (cursor.col > sp->col)
-                                       bs();
-                       }
-               }
-               return;
-       }
-       /* must change row */
-       if (cursor.col - sp->col > (cursor.col >> 3)) {
-               if (cursor.col == 0)
-                       f = 0;
-               else
-                       f = -1;
-       } else
-               f = cursor.col >> 3;
-       if (((sp->line << 1) + 1 < cursor.line - f) && (HO != 0)) {
-               /*
-                * home quicker than rlf:
-                * (sp->line + f > cursor.line - sp->line)
-                */
-               putpad(HO);
-               cursor.col = cursor.line = 0;
-               gto(sp);
-               return;
-       }
-       if (((sp->line << 1) > cursor.line + LINES + 1 + f) && (LL != 0)) {
-               /* home,rlf quicker than lf (LINES+1 - sp->line + f < sp->line
-                * - cursor.line) */
-               if (cursor.line > f + 1) {
-                       /* is home faster than wraparound lf? (cursor.line +
-                        * 20 - sp->line > 21 - sp->line + f) */
-                       ll();
-                       gto(sp);
-                       return;
-               }
-       }
-       if ((LL != 0) && (sp->line > cursor.line + (LINES >> 1) - 1))
-               cursor.line += LINES;
-       while (sp->line > cursor.line)
-               down();
-       while (sp->line < cursor.line)
-               up();
-       gto(sp);                /* can recurse since cursor.line = sp->line */
-}
-
-void
-right(sp)
-       const struct point *sp;
-{
-       int     field, tfield;
-       int     tabcol, strlength;
-
-       if (sp->col < cursor.col)
-               pr("ERROR:right() can't move left\n");
-       if (TA) {               /* If No Tabs: can't send tabs because
-                                * ttydrive loses count with control
-                                * characters. */
-               field = cursor.col >> 3;



Home | Main Index | Thread Index | Old Index