mirror of
https://github.com/vattam/BSDGames.git
synced 2025-12-21 03:14:50 +00:00
New upstream source
git-svn-id: file:///srv/svn/joey/bsdgames-trunk@5102 a4a2c43b-8ac3-0310-8836-e0e880c912e2
This commit is contained in:
joey
600
atc/atc.6
600
atc/atc.6
@@ -1,600 +0,0 @@
|
||||
.\" $NetBSD: atc.6,v 1.4 1998/07/24 23:36:59 briggs Exp $
|
||||
.\"
|
||||
.\" Copyright (c) 1990, 1993
|
||||
.\" The Regents of the University of California. All rights reserved.
|
||||
.\"
|
||||
.\" This code is derived from software contributed to Berkeley by
|
||||
.\" Ed James.
|
||||
.\"
|
||||
.\" 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.
|
||||
.\"
|
||||
.\" @(#)atc.6 8.1 (Berkeley) 5/31/93
|
||||
.\"
|
||||
. \" XP - exdented paragraph
|
||||
.de XP
|
||||
.RT
|
||||
.if \\n(1T .sp \\n(PDu
|
||||
.ne 1.1
|
||||
.if !\\n(IP .nr IP +1
|
||||
.in +\\n(I\\n(IRu
|
||||
.ti -\\n(I\\n(IRu
|
||||
..
|
||||
.\" Copyright (c) 1986 Ed James. All rights reserved.
|
||||
.\"
|
||||
.TH ATC 6 "May 31, 1993"
|
||||
.UC
|
||||
.SH NAME
|
||||
atc \- air traffic controller game
|
||||
.SH SYNOPSIS
|
||||
.B atc
|
||||
-[u?lstp] [-[gf] game_name] [-r random seed]
|
||||
.SH DESCRIPTION
|
||||
.LP
|
||||
.I Atc
|
||||
lets you try your hand at the nerve wracking duties of the air traffic
|
||||
controller without endangering the lives of millions of
|
||||
travelers each year.
|
||||
Your responsibilities require you to direct the flight of jets
|
||||
and prop planes into and out of the flight arena and airports.
|
||||
The speed (update time) and frequency of the planes depend on the
|
||||
difficulty of the chosen arena.
|
||||
.SH OPTIONS
|
||||
.LP
|
||||
.TP 8
|
||||
.B \-u
|
||||
Print the usage line and exit.
|
||||
.TP
|
||||
.B \-?
|
||||
Same as
|
||||
.B \-u.
|
||||
.TP
|
||||
.B \-l
|
||||
Print a list of available games and exit.
|
||||
The first game name printed is the default game.
|
||||
.TP
|
||||
.B \-s
|
||||
Print the score list (formerly the Top Ten list).
|
||||
.TP
|
||||
.B \-t
|
||||
Same as
|
||||
.B \-s.
|
||||
.TP
|
||||
.B \-p
|
||||
Print the path to the special directory where
|
||||
.I atc
|
||||
expects to find its private files. This is used during the
|
||||
installation of the program.
|
||||
.TP
|
||||
.B "\-g game"
|
||||
Play the named game. If the game listed is not one of the
|
||||
ones printed from the
|
||||
.B \-l
|
||||
option, the default game is played.
|
||||
.TP
|
||||
.B "\-f game"
|
||||
Same as
|
||||
.B \-g.
|
||||
.TP
|
||||
.B "\-r seed"
|
||||
Set the random seed. The purpose of this flag is questionable.
|
||||
.SH GOALS
|
||||
.LP
|
||||
Your goal in
|
||||
.I atc
|
||||
is to keep the game going as long as possible.
|
||||
There is no winning state, except to beat the times of other players.
|
||||
You will need to: launch planes at airports (by instructing them to
|
||||
increase their altitude); land planes at airports (by instructing them to
|
||||
go to altitude zero when exactly over the airport); and maneuver planes
|
||||
out of exit points.
|
||||
.LP
|
||||
Several things will cause the end of the game.
|
||||
Each plane has a destination (see information area), and
|
||||
sending a plane to the wrong destination is an error.
|
||||
Planes can run out of fuel, or can collide. Collision is defined as
|
||||
adjacency in all three dimensions. A plane leaving the arena
|
||||
in any other way than through its destination exit is an error as well.
|
||||
.LP
|
||||
Scores are sorted in order of the number of planes safe. The other
|
||||
statistics are provided merely for fun. There is no penalty for
|
||||
taking longer than another player (except in the case of ties).
|
||||
.LP
|
||||
Suspending a game is not permitted. If you get a talk message, tough.
|
||||
When was the last time an Air Traffic Controller got called away to
|
||||
the phone?
|
||||
.SH "THE DISPLAY"
|
||||
.LP
|
||||
Depending on the terminal you run
|
||||
.I atc
|
||||
on, the screen will be divided into 4 areas.
|
||||
It should be stressed that the terminal driver portion of the
|
||||
game was designed to be reconfigurable, so the display format can vary
|
||||
depending the version you are playing. The descriptions here are based
|
||||
on the ascii version
|
||||
of the game. The game rules and input format, however,
|
||||
should remain consistent.
|
||||
Control-L redraws the screen, should it become muddled.
|
||||
.SS RADAR
|
||||
.IP
|
||||
The first screen area is the radar display, showing the relative locations
|
||||
of the planes, airports, standard entry/exit points, radar
|
||||
beacons, and "lines" which simply serve to aid you in guiding
|
||||
the planes.
|
||||
.IP
|
||||
Planes are shown as a single letter with an altitude. If
|
||||
the numerical altitude is a single digit, then it represents
|
||||
thousands of feet.
|
||||
Some distinction is made between the prop
|
||||
planes and the jets. On ascii terminals, prop planes are
|
||||
represented by a upper case letter, jets by a lower case letter.
|
||||
.IP
|
||||
Airports are shown as a number and some indication of the direction
|
||||
planes must be going to land at the airport.
|
||||
On ascii terminals, this is one of '^', '>', '<', and 'v', to indicate
|
||||
north (0 degrees), east (90), west (270) and south (180), respectively.
|
||||
The planes will also
|
||||
take off in this direction.
|
||||
.IP
|
||||
Beacons are represented as circles or asterisks and a number.
|
||||
Their purpose is to offer a place of easy reference to the plane pilots.
|
||||
See 'the delay command' under the input section of this manual.
|
||||
.IP
|
||||
Entry/exit points are displayed as numbers along the border of the
|
||||
radar screen. Planes will enter the arena from these points without
|
||||
warning. These points have a direction associated with them, and
|
||||
planes will always enter the arena from this direction. On the
|
||||
ascii version of
|
||||
.I atc,
|
||||
this direction is not displayed. It will become apparent
|
||||
what this direction is as the game progresses.
|
||||
.IP
|
||||
Incoming planes will always enter at the same altitude: 7000 feet.
|
||||
For a plane to successfully depart through an entry/exit point,
|
||||
it must be flying at 9000 feet.
|
||||
It is not necessary for the planes to be flying in any particular
|
||||
direction when they leave the arena (yet).
|
||||
.SS "INFORMATION AREA"
|
||||
.IP
|
||||
The second area of the display is the information area, which lists
|
||||
the time (number of updates since start), and the number of planes you
|
||||
have directed safely out of the arena.
|
||||
Below this is a list of planes currently in the air, followed by a
|
||||
blank line, and then a list of planes on the ground (at airports).
|
||||
Each line lists the plane name and its current altitude,
|
||||
an optional asterisk indicating low fuel, the plane's destination,
|
||||
and the plane's current command. Changing altitude is not considered
|
||||
to be a command and is therefore not displayed. The following are
|
||||
some possible information lines:
|
||||
.IP
|
||||
B4*A0: Circle @ b1
|
||||
.br
|
||||
g7 E4: 225
|
||||
.IP
|
||||
The first example shows a prop plane named 'B' that is flying at 4000
|
||||
feet. It is low on fuel (note the '*'). It's destination is
|
||||
Airport #0.
|
||||
The next command it expects
|
||||
to do is circle when it reaches Beacon #1.
|
||||
The second example shows a jet named 'g' at 7000 feet, destined for
|
||||
Exit #4. It is just now executing a turn to 225 degrees (South-West).
|
||||
.SS "INPUT AREA"
|
||||
.IP
|
||||
The third area of the display is the input area. It is here that
|
||||
your input is reflected. See the INPUT heading of this manual
|
||||
for more details.
|
||||
.SS "AUTHOR AREA"
|
||||
.IP
|
||||
This area is used simply to give credit where credit is due. :-)
|
||||
.SH INPUT
|
||||
.LP
|
||||
A command completion interface is built into
|
||||
the game. At any time, typing '?' will list possible input characters.
|
||||
Typing a backspace (your erase character) backs up, erasing the last part
|
||||
of the command. When a command is complete, a return enters it, and
|
||||
any semantic checking is done at that time. If no errors are detected,
|
||||
the command is sent to the appropriate plane. If an error is discovered
|
||||
during the check, the offending statement will be underscored and a
|
||||
(hopefully) descriptive message will be printed under it.
|
||||
.LP
|
||||
The command syntax is broken into two parts:
|
||||
.I "Immediate Only"
|
||||
and
|
||||
.I Delayable
|
||||
commands.
|
||||
.I "Immediate Only"
|
||||
commands happen on the next
|
||||
update.
|
||||
.I Delayable
|
||||
commands also happen on the next update unless they
|
||||
are followed by an optional predicate called the
|
||||
.I Delay
|
||||
command.
|
||||
.LP
|
||||
In the following tables, the syntax
|
||||
.B [0\-9]
|
||||
means any single digit, and
|
||||
.B <dir>
|
||||
refers to the keys around the 's' key, namely ``wedcxzaq''.
|
||||
In absolute references, 'q' refers to North-West or 315 degrees, and 'w'
|
||||
refers to North, or 0 degrees.
|
||||
In relative references, 'q' refers to -45 degrees or 45 degrees left, and 'w'
|
||||
refers to 0 degrees, or no change in direction.
|
||||
.LP
|
||||
All commands start with a plane letter. This indicates the recipient
|
||||
of the command. Case is ignored.
|
||||
.SS "IMMEDIATE ONLY COMMANDS"
|
||||
.RS
|
||||
.B "\- a Altitude:"
|
||||
.RS
|
||||
Affect a plane's altitude (and take off).
|
||||
.RE
|
||||
.RS
|
||||
.B "\- [0\-9] Number:"
|
||||
.RS
|
||||
Go to the given altitude (thousands of feet).
|
||||
.RE
|
||||
.B "\- c/+ Climb:"
|
||||
.RS
|
||||
Relative altitude change.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- [0\-9] Number:"
|
||||
.RS
|
||||
Difference in thousands of feet.
|
||||
.RE
|
||||
.RE
|
||||
.B "\- d/\- Descend:"
|
||||
.RS
|
||||
Relative altitude change.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- [0\-9] Number:"
|
||||
.RS
|
||||
Difference in thousands of feet.
|
||||
.RE
|
||||
.RE
|
||||
.RE
|
||||
.B "\- m Mark:"
|
||||
.RS
|
||||
Display in highlighted mode. Command is displayed normally.
|
||||
.RE
|
||||
.B "\- i Ignore:"
|
||||
.RS
|
||||
Do not display highlighted. Command is displayed as a
|
||||
line of dashes if there is no command.
|
||||
.RE
|
||||
.B "\- u Unmark:"
|
||||
.RS
|
||||
Same as ignore, but if a delayed command is processed,
|
||||
the plane will become marked. This is useful if you want
|
||||
to forget about a plane during part, but not all, of its
|
||||
journey.
|
||||
.RE
|
||||
.RE
|
||||
.SS "DELAYABLE COMMANDS"
|
||||
.RS
|
||||
.B "\- c Circle:"
|
||||
.RS
|
||||
Have the plane circle (clockwise by default).
|
||||
.RE
|
||||
.RS
|
||||
.B "\- l Left:"
|
||||
.RS
|
||||
Circle counterclockwise.
|
||||
.RE
|
||||
.B "\- r Right:"
|
||||
.RS
|
||||
Circle clockwise.
|
||||
.RE
|
||||
.RE
|
||||
.B "\- t Turn:"
|
||||
.RS
|
||||
Change direction.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- l Left:"
|
||||
.RS
|
||||
Turn counterclockwise (45 degrees by default).
|
||||
.RE
|
||||
.RS
|
||||
.B "\- <dir> Direction:"
|
||||
.RS
|
||||
Turn ccw the given number of degrees.
|
||||
Zero degrees is no turn. A ccw turn
|
||||
of -45 degrees is 45 cw.
|
||||
.RE
|
||||
.RE
|
||||
.B "\- r Right:"
|
||||
.RS
|
||||
Turn clockwise (45 degrees by default).
|
||||
.RE
|
||||
.RS
|
||||
.B "\- <dir> Direction:"
|
||||
.RS
|
||||
Same as turn left <dir>.
|
||||
.RE
|
||||
.RE
|
||||
.B "\- L Left 90:"
|
||||
.RS
|
||||
Turn counterclockwise 90 degrees.
|
||||
.RE
|
||||
.B "\- R Right 90:"
|
||||
.RS
|
||||
Turn clockwise 90 degrees.
|
||||
.RE
|
||||
.B "\- <dir> Direction:"
|
||||
.RS
|
||||
Turn to the absolute compass heading given.
|
||||
The shortest turn will be taken.
|
||||
.RE
|
||||
.B "\- t Towards:"
|
||||
.RS
|
||||
Turn towards a beacon, airport or exit. The turn is
|
||||
just an estimate.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- b/* Beacon:"
|
||||
.RS
|
||||
Turn towards the beacon.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- [0-9] Number:"
|
||||
.RS
|
||||
The beacon number.
|
||||
.RE
|
||||
.RE
|
||||
.B "\- e Exit:"
|
||||
.RS
|
||||
Turn towards the exit.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- [0-9] Number:"
|
||||
.RS
|
||||
The exit number.
|
||||
.RE
|
||||
.RE
|
||||
.B "\- a Airport:"
|
||||
.RS
|
||||
Turn towards the airport.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- [0-9] Number:"
|
||||
.RS
|
||||
The airport number.
|
||||
.RE
|
||||
.RE
|
||||
.RE
|
||||
.RE
|
||||
.RE
|
||||
.SS THE DELAY COMMAND
|
||||
.LP
|
||||
The
|
||||
.B Delay
|
||||
(a/@)
|
||||
command may be appended to any
|
||||
.B Delayable
|
||||
command. It allows the controller to instruct a plane to do an action
|
||||
when the plane reaches a particular beacon (or other objects in future
|
||||
versions).
|
||||
.sp
|
||||
.RS
|
||||
.B "\- a/@ At:"
|
||||
.RS
|
||||
Do the given delayable command when the plane reaches the given beacon.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- b/* Beacon:"
|
||||
.RS
|
||||
This is redundant to allow for expansion.
|
||||
.RE
|
||||
.RS
|
||||
.B "\- [0-9] Number:"
|
||||
.RS
|
||||
The beacon number.
|
||||
.RE
|
||||
.RE
|
||||
.RE
|
||||
.RE
|
||||
.SS "MARKING, UNMARKING AND IGNORING"
|
||||
.LP
|
||||
Planes are
|
||||
.B marked
|
||||
when they enter the arena. This means they are displayed in highlighted
|
||||
mode on the radar display. A plane may also be either
|
||||
.B unmarked
|
||||
or
|
||||
.B ignored.
|
||||
An
|
||||
.B unmarked
|
||||
plane is drawn in unhighlighted mode, and a line of dashes is displayed in
|
||||
the command field of the information area. The plane will remain this
|
||||
way until a mark command has been issued. Any other command will be issued,
|
||||
but the command line will return to a line of dashes when the command
|
||||
is completed.
|
||||
.LP
|
||||
An
|
||||
.B ignored
|
||||
plane is treated the same as an unmarked plane, except that it will
|
||||
automatically switch to
|
||||
.B marked
|
||||
status when a delayed command has been processed. This is useful if
|
||||
you want to forget about a plane for a while, but its flight path has
|
||||
not yet been completely set.
|
||||
.LP
|
||||
As with all of the commands, marking, unmarking and ignoring will take effect
|
||||
at the beginning of the next update. Do not be surprised if the plane does
|
||||
not immediately switch to unhighlighted mode.
|
||||
.SS EXAMPLES
|
||||
.RS
|
||||
.TP 16
|
||||
atlab1
|
||||
a: turn left at beacon #1
|
||||
.TP 16
|
||||
cc
|
||||
C: circle
|
||||
.TP 16
|
||||
gtte4ab2
|
||||
g: turn towards exit #4 at beacon #2
|
||||
.TP 16
|
||||
ma+2
|
||||
m: altitude: climb 2000 feet
|
||||
.TP 16
|
||||
stq
|
||||
S: turn to 315
|
||||
.TP 16
|
||||
xi
|
||||
x: ignore
|
||||
.RE
|
||||
.SH "OTHER INFORMATION"
|
||||
.LP
|
||||
Jets move every update; prop planes move every other update.
|
||||
.LP
|
||||
All planes turn a most 90 degrees per movement.
|
||||
.LP
|
||||
Planes enter at 7000 feet and leave at 9000 feet.
|
||||
.LP
|
||||
Planes flying at an altitude of 0 crash if they are not over an airport.
|
||||
.LP
|
||||
Planes waiting at airports can only be told to take off (climb in altitude).
|
||||
.SH "NEW GAMES"
|
||||
.LP
|
||||
The
|
||||
.B Game_List
|
||||
file lists the currently available play fields. New field description
|
||||
file names must be placed in this file to be 'playable'. If a player
|
||||
specifies a game not in this file, his score will not be logged.
|
||||
.LP
|
||||
The game field description files are broken into two parts. The first
|
||||
part is the definition section. Here, the four tunable game parameters
|
||||
must be set. These variables are set with the syntax:
|
||||
.IP
|
||||
variable = number;
|
||||
.LP
|
||||
Variable may be one of:
|
||||
.B update,
|
||||
indicating the number of seconds between forced updates;
|
||||
.B newplane,
|
||||
indicating (about) the number of updates between new plane entries;
|
||||
.B width,
|
||||
indicating the width of the play field; and
|
||||
.B height,
|
||||
indicating the height of the play field.
|
||||
.LP
|
||||
The second part of the field description files describes the locations
|
||||
of the exits, the beacons, the airports and the lines.
|
||||
The syntax is as follows:
|
||||
.IP
|
||||
beacon: (x y) ... ;
|
||||
.br
|
||||
airport: (x y direction) ... ;
|
||||
.br
|
||||
exit: (x y direction) ... ;
|
||||
.br
|
||||
line: [ (x1 y1) (x2 y2) ] ... ;
|
||||
.LP
|
||||
For beacons, a simple x, y coordinate pair is used (enclosed in parenthesis).
|
||||
Airports and exits require a third value, a direction, which is one
|
||||
of
|
||||
.B wedcxzaq.
|
||||
For airports, this is the direction that planes must be going to take
|
||||
off and land, and for exits, this is the direction that planes will going
|
||||
when they
|
||||
.B enter
|
||||
the arena. This may not seem intuitive, but as there is no restriction on
|
||||
direction of exit, this is appropriate.
|
||||
Lines are slightly different, since they need two coordinate pairs to
|
||||
specify the line endpoints. These endpoints must be enclosed in
|
||||
square brackets.
|
||||
.LP
|
||||
All statements are semi-colon (;) terminated. Multiple item statements
|
||||
accumulate. Each definition must occur exactly once, before any
|
||||
item statements. Comments begin with a hash (#) symbol
|
||||
and terminate with a newline.
|
||||
The coordinates are between zero and width-1 and height-1
|
||||
inclusive. All of the exit coordinates must lie on the borders, and
|
||||
all of the beacons and airports must lie inside of the borders.
|
||||
Line endpoints may be anywhere within the field, so long as
|
||||
the lines are horizontal, vertical or
|
||||
.B "exactly diagonal."
|
||||
.SS "FIELD FILE EXAMPLE"
|
||||
.RS
|
||||
.sp
|
||||
.nf
|
||||
.TA 1i 1i
|
||||
.ta 1i 1i
|
||||
# This is the default game.
|
||||
|
||||
update = 5;
|
||||
newplane = 5;
|
||||
width = 30;
|
||||
height = 21;
|
||||
|
||||
exit: ( 12 0 x ) ( 29 0 z ) ( 29 7 a ) ( 29 17 a )
|
||||
( 9 20 e ) ( 0 13 d ) ( 0 7 d ) ( 0 0 c ) ;
|
||||
|
||||
beacon: ( 12 7 ) ( 12 17 ) ;
|
||||
|
||||
airport: ( 20 15 w ) ( 20 18 d ) ;
|
||||
|
||||
line: [ ( 1 1 ) ( 6 6 ) ]
|
||||
[ ( 12 1 ) ( 12 6 ) ]
|
||||
[ ( 13 7 ) ( 28 7 ) ]
|
||||
[ ( 28 1 ) ( 13 16 ) ]
|
||||
[ ( 1 13 ) ( 11 13 ) ]
|
||||
[ ( 12 8 ) ( 12 16 ) ]
|
||||
[ ( 11 18 ) ( 10 19 ) ]
|
||||
[ ( 13 17 ) ( 28 17 ) ]
|
||||
[ ( 1 7 ) ( 11 7 ) ] ;
|
||||
.fi
|
||||
.RE
|
||||
.SH FILES
|
||||
.LP
|
||||
Files are kept in a special directory. See the OPTIONS for a way to
|
||||
print this path out.
|
||||
.TP 16
|
||||
.B ATC_score
|
||||
Where the scores are kept.
|
||||
.TP 16
|
||||
.B Game_List
|
||||
The list of playable games.
|
||||
.SH AUTHOR
|
||||
.LP
|
||||
Ed James, UC Berkeley: edjames@ucbvax.berkeley.edu, ucbvax!edjames
|
||||
.LP
|
||||
This game is based on someone's description of the overall flavor
|
||||
of a game written for some unknown PC many years ago, maybe.
|
||||
.SH BUGS
|
||||
.LP
|
||||
The screen sometimes refreshes after you have quit.
|
||||
.LP
|
||||
Yet Another Curses Bug was discovered during the development of this game.
|
||||
If your curses library clrtobot.o is version 5.1 or earlier,
|
||||
you will have erase problems with the backspace operator in the input
|
||||
window.
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
/* $NetBSD: main.c,v 1.9 1999/02/10 12:29:47 hubertf Exp $ */
|
||||
/* $NetBSD: main.c,v 1.15 1999/09/17 17:07:11 jsm Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1980, 1993
|
||||
@@ -43,21 +43,21 @@ __COPYRIGHT("@(#) Copyright (c) 1980, 1993\n\
|
||||
#if 0
|
||||
static char sccsid[] = "@(#)main.c 8.1 (Berkeley) 5/31/93";
|
||||
#else
|
||||
__RCSID("$NetBSD: main.c,v 1.9 1999/02/10 12:29:47 hubertf Exp $");
|
||||
__RCSID("$NetBSD: main.c,v 1.15 1999/09/17 17:07:11 jsm Exp $");
|
||||
#endif
|
||||
#endif /* not lint */
|
||||
|
||||
#include <time.h>
|
||||
|
||||
#include "back.h"
|
||||
#include "backlocal.h"
|
||||
|
||||
#include <time.h>
|
||||
|
||||
#define MVPAUSE 5 /* time to sleep when stuck */
|
||||
|
||||
extern const char *const instr[]; /* text of instructions */
|
||||
extern const char *const message[]; /* update message */
|
||||
#ifndef NCURSES_VERSION
|
||||
speed_t ospeed; /* tty output speed */
|
||||
short ospeed; /* tty output speed */
|
||||
#endif
|
||||
|
||||
const char *const helpm[] = { /* help message */
|
||||
@@ -122,7 +122,7 @@ main(argc, argv)
|
||||
/* use whole screen for text */
|
||||
if (tflag)
|
||||
begscr = 0;
|
||||
t = time(0);
|
||||
t = time(NULL);
|
||||
srandom(t); /* 'random' seed */
|
||||
|
||||
#ifdef V7
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
There are no potentially offensive fortunes installed on this
|
||||
system. For further details, contact your system administrator.
|
||||
File diff suppressed because it is too large
Load Diff
38619
hangman/words
38619
hangman/words
File diff suppressed because it is too large
Load Diff
@@ -1,8 +0,0 @@
|
||||
/* tzfile.h - bsd-games version of <tzfile.h> that defines isleap */
|
||||
|
||||
#ifndef LINUX_BSD_GAMES_TZFILE_H
|
||||
#define LINUX_BSD_GAMES_TZFILE_H 1
|
||||
|
||||
#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)
|
||||
|
||||
#endif /* !defined(LINUX_BSD_GAMES_TZFILE_H) */
|
||||
@@ -1,4 +1,4 @@
|
||||
/* $NetBSD: main.c,v 1.7 1997/10/12 14:16:26 lukem Exp $ */
|
||||
/* $NetBSD: main.c,v 1.11 1999/09/12 09:02:22 jsm Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1980, 1993
|
||||
@@ -43,7 +43,7 @@ __COPYRIGHT("@(#) Copyright (c) 1980, 1993\n\
|
||||
#if 0
|
||||
static char sccsid[] = "@(#)main.c 8.1 (Berkeley) 5/31/93";
|
||||
#else
|
||||
__RCSID("$NetBSD: main.c,v 1.7 1997/10/12 14:16:26 lukem Exp $");
|
||||
__RCSID("$NetBSD: main.c,v 1.11 1999/09/12 09:02:22 jsm Exp $");
|
||||
#endif
|
||||
#endif /* not lint */
|
||||
|
||||
@@ -74,6 +74,7 @@ main(ac, av)
|
||||
setregid(getgid(), getgid());
|
||||
|
||||
show_only = FALSE;
|
||||
Num_games = 1;
|
||||
if (ac > 1) {
|
||||
bad_arg = FALSE;
|
||||
for (++av; ac > 1 && *av[0]; av++, ac--)
|
||||
@@ -102,6 +103,9 @@ main(ac, av)
|
||||
else
|
||||
for (sp = &av[0][1]; *sp; sp++)
|
||||
switch (*sp) {
|
||||
case 'A':
|
||||
Auto_bot = TRUE;
|
||||
break;
|
||||
case 's':
|
||||
show_only = TRUE;
|
||||
break;
|
||||
@@ -111,12 +115,16 @@ main(ac, av)
|
||||
case 'a':
|
||||
Start_level = 4;
|
||||
break;
|
||||
case 'n':
|
||||
Num_games++;
|
||||
break;
|
||||
case 'j':
|
||||
Jump = TRUE;
|
||||
break;
|
||||
case 't':
|
||||
Teleport = TRUE;
|
||||
break;
|
||||
|
||||
default:
|
||||
fprintf(stderr, "robots: uknown option: %c\n", *sp);
|
||||
bad_arg = TRUE;
|
||||
@@ -135,6 +143,7 @@ main(ac, av)
|
||||
}
|
||||
|
||||
if (score_wfd < 0) {
|
||||
errno = score_err;
|
||||
warn("%s", Scorefile);
|
||||
warnx("High scores will not be recorded!");
|
||||
sleep(2);
|
||||
@@ -160,16 +169,25 @@ main(ac, av)
|
||||
if (Real_time)
|
||||
signal(SIGALRM, move_robots);
|
||||
do {
|
||||
init_field();
|
||||
for (Level = Start_level; !Dead; Level++) {
|
||||
make_level();
|
||||
play_level();
|
||||
while (Num_games--) {
|
||||
init_field();
|
||||
for (Level = Start_level; !Dead; Level++) {
|
||||
make_level();
|
||||
play_level();
|
||||
if (Auto_bot)
|
||||
sleep(1);
|
||||
}
|
||||
move(My_pos.y, My_pos.x);
|
||||
printw("AARRrrgghhhh....");
|
||||
refresh();
|
||||
if (Auto_bot)
|
||||
sleep(1);
|
||||
score(score_wfd);
|
||||
if (Auto_bot)
|
||||
sleep(1);
|
||||
refresh();
|
||||
}
|
||||
move(My_pos.y, My_pos.x);
|
||||
printw("AARRrrgghhhh....");
|
||||
refresh();
|
||||
score(score_wfd);
|
||||
} while (another());
|
||||
} while (!Auto_bot && another());
|
||||
quit(0);
|
||||
/* NOTREACHED */
|
||||
return(0);
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
/* $NetBSD: sync.c,v 1.11 1999/02/10 00:45:46 hubertf Exp $ */
|
||||
/* $NetBSD: sync.c,v 1.13 1999/09/09 17:30:20 jsm Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1983, 1993
|
||||
@@ -38,7 +38,7 @@
|
||||
#if 0
|
||||
static char sccsid[] = "@(#)sync.c 8.2 (Berkeley) 4/28/95";
|
||||
#else
|
||||
__RCSID("$NetBSD: sync.c,v 1.10 1998/09/11 14:15:46 hubertf Exp $");
|
||||
__RCSID("$NetBSD: sync.c,v 1.13 1999/09/09 17:30:20 jsm Exp $");
|
||||
#endif
|
||||
#endif /* not lint */
|
||||
|
||||
|
||||
@@ -1,717 +0,0 @@
|
||||
/* $NetBSD: move.c,v 1.15 1997/10/14 01:02:48 lukem 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.15 1997/10/14 01:02:48 lukem 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 <unistd.h> /* For _POSIX_VDISABLE */
|
||||
#include "snake.h"
|
||||
|
||||
int CMlength;
|
||||
int NDlength;
|
||||
int BSlength;
|
||||
int delaystr[10];
|
||||
#ifndef NCURSES_VERSION
|
||||
speed_t ospeed;
|
||||
#endif
|
||||
|
||||
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)
|
||||
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)
|
||||
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;
|
||||
/*
|
||||
* This code is useful for a terminal which wraps around on backspaces.
|
||||
* (Mine does.) Unfortunately, this is not specified in termcap, and
|
||||
* most terminals don't work that way. (Of course, most terminals
|
||||
* have addressible cursors, too).
|
||||
*/
|
||||
if (BW && (CM == 0) &&
|
||||
((sp->col << 1) - field > (COLUMNS - 8) << 1)
|
||||
) {
|
||||
if (cursor.line == 0) {
|
||||
outch('\n');
|
||||
}
|
||||
outch('\r');
|
||||
cursor.col = COLUMNS + 1;
|
||||
while (cursor.col > sp->col)
|
||||
bs();
|
||||
if (cursor.line != 0)
|
||||
outch('\n');
|
||||
return;
|
||||
}
|
||||
tfield = sp->col >> 3;
|
||||
|
||||
while (field < tfield) {
|
||||
putpad(TA);
|
||||
cursor.col = ++field << 3;
|
||||
}
|
||||
tabcol = (cursor.col | 7) + 1;
|
||||
strlength = (tabcol - sp->col) * BSlength + 1;
|
||||
/* length of sequence to overshoot */
|
||||
if (((sp->col - cursor.col) * NDlength > strlength) &&
|
||||
(tabcol < COLUMNS)
|
||||
) {
|
||||
/*
|
||||
* Tab past and backup
|
||||
*/
|
||||
putpad(TA);
|
||||
cursor.col = (cursor.col | 7) + 1;
|
||||
while (cursor.col > sp->col)
|
||||
bs();
|
||||
}
|
||||
}
|
||||
while (sp->col > cursor.col) {
|
||||
nd();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
cr()
|
||||
{
|
||||
outch('\r');
|
||||
cursor.col = 0;
|
||||
}
|
||||
|
||||
void
|
||||
clear()
|
||||
{
|
||||
int i;
|
||||
|
||||
if (CL) {
|
||||
putpad(CL);
|
||||
cursor.col = cursor.line = 0;
|
||||
} else {
|
||||
for (i = 0; i < LINES; i++) {
|
||||
putchar('\n');
|
||||
}
|
||||
cursor.line = LINES - 1;
|
||||
home();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
home()
|
||||
{
|
||||
struct point z;
|
||||
|
||||
if (HO != 0) {
|
||||
putpad(HO);
|
||||
cursor.col = cursor.line = 0;
|
||||
return;
|
||||
}
|
||||
z.col = z.line = 0;
|
||||
move(&z);
|
||||
}
|
||||
|
||||
void
|
||||
ll()
|
||||
{
|
||||
int l;
|
||||
struct point z;
|
||||
|
||||
l = lcnt + 2;
|
||||
if (LL != NULL && LINES == l) {
|
||||
putpad(LL);
|
||||
cursor.line = LINES - 1;
|
||||
cursor.col = 0;
|
||||
return;
|
||||
}
|
||||
z.col = 0;
|
||||
z.line = l - 1;
|
||||
move(&z);
|
||||
}
|
||||
|
||||
void
|
||||
up()
|
||||
{
|
||||
putpad(UP);
|
||||
cursor.line--;
|
||||
}
|
||||
|
||||
void
|
||||
down()
|
||||
{
|
||||
putpad(DO);
|
||||
cursor.line++;
|
||||
if (cursor.line >= LINES)
|
||||
cursor.line = LINES - 1;
|
||||
}
|
||||
|
||||
void
|
||||
bs()
|
||||
{
|
||||
if (cursor.col > 0) {
|
||||
putpad(BS);
|
||||
cursor.col--;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nd()
|
||||
{
|
||||
putpad(ND);
|
||||
cursor.col++;
|
||||
if (cursor.col == COLUMNS + 1) {
|
||||
cursor.line++;
|
||||
cursor.col = 0;
|
||||
if (cursor.line >= LINES)
|
||||
cursor.line = LINES - 1;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
pch(c)
|
||||
int c;
|
||||
{
|
||||
outch(c);
|
||||
if (++cursor.col >= COLUMNS && AM) {
|
||||
cursor.col = 0;
|
||||
++cursor.line;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
#if __STDC__
|
||||
apr(struct point * ps, const char *fmt,...)
|
||||
#else
|
||||
apr(ps, fmt, va_alist)
|
||||
struct point *ps;
|
||||
char *fmt;
|
||||
va_dcl
|
||||
#endif
|
||||
{
|
||||
struct point p;
|
||||
va_list ap;
|
||||
|
||||
p.line = ps->line + 1;
|
||||
p.col = ps->col + 1;
|
||||
move(&p);
|
||||
#if __STDC__
|
||||
va_start(ap, fmt);
|
||||
#else
|
||||
va_start(ap);
|
||||
#endif
|
||||
(void) vsprintf(str, fmt, ap);
|
||||
va_end(ap);
|
||||
pstring(str);
|
||||
}
|
||||
|
||||
void
|
||||
#if __STDC__
|
||||
pr(const char *fmt,...)
|
||||
#else
|
||||
pr(fmt, va_alist)
|
||||
char *fmt;
|
||||
va_dcl
|
||||
#endif
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
#if __STDC__
|
||||
va_start(ap, fmt);
|
||||
#else
|
||||
va_start(ap);
|
||||
#endif
|
||||
(void) vsprintf(str, fmt, ap);
|
||||
va_end(ap);
|
||||
pstring(str);
|
||||
}
|
||||
|
||||
void
|
||||
pstring(s)
|
||||
const char *s;
|
||||
{
|
||||
struct point z;
|
||||
int stcol;
|
||||
|
||||
stcol = cursor.col;
|
||||
while (s[0] != '\0') {
|
||||
switch (s[0]) {
|
||||
case '\n':
|
||||
move(point(&z, 0, cursor.line + 1));
|
||||
break;
|
||||
case '\r':
|
||||
move(point(&z, stcol, cursor.line + 1));
|
||||
break;
|
||||
case '\t':
|
||||
z.col = (((cursor.col + 8) >> 3) << 3);
|
||||
z.line = cursor.line;
|
||||
move(&z);
|
||||
break;
|
||||
case '\b':
|
||||
bs();
|
||||
break;
|
||||
case CTRL('g'):
|
||||
outch(CTRL('g'));
|
||||
break;
|
||||
default:
|
||||
if (s[0] < ' ')
|
||||
break;
|
||||
pch(s[0]);
|
||||
}
|
||||
s++;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
pchar(ps, ch)
|
||||
struct point *ps;
|
||||
char ch;
|
||||
{
|
||||
struct point p;
|
||||
p.col = ps->col + 1;
|
||||
p.line = ps->line + 1;
|
||||
if (
|
||||
(p.col >= 0) &&
|
||||
(p.line >= 0) &&
|
||||
(
|
||||
(
|
||||
(p.line < LINES) &&
|
||||
(p.col < COLUMNS)
|
||||
) ||
|
||||
(
|
||||
(p.col == COLUMNS) &&
|
||||
(p.line < LINES - 1)
|
||||
)
|
||||
)
|
||||
) {
|
||||
move(&p);
|
||||
pch(ch);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
outch(c)
|
||||
int c;
|
||||
{
|
||||
return putchar(c);
|
||||
}
|
||||
|
||||
void
|
||||
putpad(str)
|
||||
char *str;
|
||||
{
|
||||
if (str)
|
||||
tputs(str, 1, outch);
|
||||
}
|
||||
|
||||
void
|
||||
delay(t)
|
||||
int t;
|
||||
{
|
||||
int k, j;
|
||||
|
||||
k = (ospeed * t + 100) / 200;
|
||||
for (j = 0; j < k; j++) {
|
||||
putchar(PC);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
done()
|
||||
{
|
||||
cook();
|
||||
exit(0);
|
||||
}
|
||||
|
||||
void
|
||||
cook()
|
||||
{
|
||||
delay(1);
|
||||
putpad(TE);
|
||||
putpad(KE);
|
||||
fflush(stdout);
|
||||
tcsetattr(0, TCSADRAIN, &orig);
|
||||
}
|
||||
|
||||
void
|
||||
my_raw()
|
||||
{
|
||||
tcsetattr(0, TCSADRAIN, &new);
|
||||
}
|
||||
|
||||
struct point *
|
||||
point(ps, x, y)
|
||||
struct point *ps;
|
||||
int x, y;
|
||||
{
|
||||
ps->col = x;
|
||||
ps->line = y;
|
||||
return (ps);
|
||||
}
|
||||
|
||||
char *ap;
|
||||
|
||||
void
|
||||
getcap()
|
||||
{
|
||||
char *term;
|
||||
char *xPC;
|
||||
#ifdef TIOCGWINSZ
|
||||
struct winsize win;
|
||||
#endif
|
||||
|
||||
term = getenv("TERM");
|
||||
if (term == 0)
|
||||
errx(1, "No TERM in environment");
|
||||
switch (tgetent(tbuf, term)) {
|
||||
case -1:
|
||||
errx(2, "Cannot open termcap file");
|
||||
case 0:
|
||||
errx(3, "unknown terminal `%s'", term);
|
||||
}
|
||||
|
||||
ap = tcapbuf;
|
||||
|
||||
#ifdef TIOCGWINSZ
|
||||
if (ioctl(0, TIOCGWINSZ, (char *) &win) < 0 ||
|
||||
(LINES = win.ws_row) == 0 || (COLUMNS = win.ws_col) == 0) {
|
||||
#endif
|
||||
LINES = tgetnum("li");
|
||||
COLUMNS = tgetnum("co");
|
||||
#ifdef TIOCGWINSZ
|
||||
}
|
||||
#endif
|
||||
if (!lcnt)
|
||||
lcnt = LINES - 2;
|
||||
if (!ccnt)
|
||||
ccnt = COLUMNS - 3;
|
||||
|
||||
AM = tgetflag("am");
|
||||
BW = tgetflag("bw");
|
||||
|
||||
ND = tgetstr("nd", &ap);
|
||||
UP = tgetstr("up", &ap);
|
||||
|
||||
DO = tgetstr("do", &ap);
|
||||
if (DO == 0)
|
||||
DO = "\n";
|
||||
|
||||
BS = tgetstr("le", &ap);
|
||||
if (BS == 0) {
|
||||
/* try using obsolete capabilities */
|
||||
BS = tgetstr("bc", &ap);
|
||||
if (BS == 0 && tgetflag("bs"))
|
||||
BS = "\b";
|
||||
}
|
||||
TA = tgetstr("ta", &ap);
|
||||
if (TA == 0 && tgetflag("pt"))
|
||||
TA = "\t";
|
||||
|
||||
HO = tgetstr("ho", &ap);
|
||||
CL = tgetstr("cl", &ap);
|
||||
CM = tgetstr("cm", &ap);
|
||||
LL = tgetstr("ll", &ap);
|
||||
|
||||
KL = tgetstr("kl", &ap);
|
||||
KR = tgetstr("kr", &ap);
|
||||
KU = tgetstr("ku", &ap);
|
||||
KD = tgetstr("kd", &ap);
|
||||
if (KL && KR && KU && KD)
|
||||
Klength = strlen(KL);
|
||||
else
|
||||
Klength = 0;
|
||||
/* NOTE: If KL, KR, KU, and KD are not all the same length, some
|
||||
* problems may arise, since tests are made on all of them together. */
|
||||
|
||||
TI = tgetstr("ti", &ap);
|
||||
TE = tgetstr("te", &ap);
|
||||
KS = tgetstr("ks", &ap);
|
||||
KE = tgetstr("ke", &ap);
|
||||
|
||||
xPC = tgetstr("pc", &ap);
|
||||
if (xPC)
|
||||
PC = *xPC;
|
||||
|
||||
if ((CM == 0) &&
|
||||
(HO == 0 || UP == 0 || BS == 0 || ND == 0))
|
||||
errx(5, "Terminal must have addressible cursor or home + 4 local motions");
|
||||
if (ND == 0)
|
||||
errx(5, "Terminal must have `nd' capability");
|
||||
NDlength = strlen(ND);
|
||||
if (BS == 0)
|
||||
errx(5, "Terminal must have 'le' or `bs' or `bc' capability");
|
||||
BSlength = strlen(BS);
|
||||
|
||||
if (tgetflag("os"))
|
||||
errx(5, "Terminal must not overstrike");
|
||||
if (LINES <= 0 || COLUMNS <= 0)
|
||||
errx(5, "Must know the screen size");
|
||||
tcgetattr(0, &orig);
|
||||
new = orig;
|
||||
new.c_lflag &= ~(ECHO | ICANON);
|
||||
new.c_oflag &= ~(ONLCR | OXTABS);
|
||||
signal(SIGINT, stop);
|
||||
ospeed = cfgetospeed(&orig);
|
||||
new.c_cc[VSUSP] = _POSIX_VDISABLE;
|
||||
#ifdef VDSUSP
|
||||
new.c_cc[VDSUSP] = _POSIX_VDISABLE;
|
||||
#endif
|
||||
my_raw();
|
||||
|
||||
if (orig.c_oflag & OXTABS)
|
||||
TA = 0;
|
||||
putpad(KS);
|
||||
putpad(TI);
|
||||
point(&cursor, 0, LINES - 1);
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
/* $NetBSD: snake.h,v 1.10 1998/09/13 15:27:30 hubertf 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.
|
||||
*
|
||||
* @(#)snake.h 8.1 (Berkeley) 5/31/93
|
||||
*/
|
||||
|
||||
# include <sys/types.h>
|
||||
# include <sys/ioctl.h>
|
||||
# include <assert.h>
|
||||
# include <err.h>
|
||||
# include <math.h>
|
||||
# include <signal.h>
|
||||
# include <stdio.h>
|
||||
# include <stdlib.h>
|
||||
# include <string.h>
|
||||
# include <termcap.h>
|
||||
# include <termios.h>
|
||||
|
||||
#define ESC '\033'
|
||||
|
||||
struct tbuffer {
|
||||
long t[4];
|
||||
} tbuffer;
|
||||
|
||||
char *CL, *UP, *DO, *ND, *BS,
|
||||
*HO, *CM,
|
||||
*TA, *LL,
|
||||
*KL, *KR, *KU, *KD,
|
||||
*TI, *TE, *KS, *KE;
|
||||
int LINES, COLUMNS; /* physical screen size. */
|
||||
int lcnt, ccnt; /* user's idea of screen size */
|
||||
char PC;
|
||||
int AM, BW;
|
||||
char tbuf[1024], tcapbuf[128];
|
||||
int Klength; /* length of KX strings */
|
||||
int chunk; /* amount of money given at a time */
|
||||
#ifndef NCURSES_VERSION
|
||||
speed_t ospeed;
|
||||
#endif
|
||||
#ifdef debug
|
||||
#define cashvalue (loot-penalty)/25
|
||||
#else
|
||||
#define cashvalue chunk*(loot-penalty)/25
|
||||
#endif
|
||||
|
||||
struct point {
|
||||
int col, line;
|
||||
};
|
||||
struct point cursor;
|
||||
struct termios orig, new;
|
||||
|
||||
#define same(s1, s2) ((s1)->line == (s2)->line && (s1)->col == (s2)->col)
|
||||
|
||||
|
||||
void apr __P((struct point *, const char *, ...));
|
||||
void bs __P((void));
|
||||
void chase __P((struct point *, struct point *));
|
||||
int chk __P((struct point *));
|
||||
void clear __P((void));
|
||||
void cook __P((void));
|
||||
void cr __P((void));
|
||||
void delay __P((int));
|
||||
void done __P((void)) __attribute__((__noreturn__));
|
||||
void down __P((void));
|
||||
void drawbox __P((void));
|
||||
void flushi __P((void));
|
||||
void getcap __P((void));
|
||||
void gto __P((struct point *));
|
||||
void home __P((void));
|
||||
void length __P((int));
|
||||
void ll __P((void));
|
||||
void logit __P((const char *));
|
||||
void mainloop __P((void));
|
||||
void move __P((struct point *));
|
||||
void nd __P((void));
|
||||
int outch __P((int));
|
||||
void pch __P((int));
|
||||
void pchar __P((struct point *, char));
|
||||
struct point *point __P((struct point *, int, int));
|
||||
int post __P((int, int));
|
||||
void pr __P((const char *, ...));
|
||||
void pstring __P((const char *));
|
||||
int pushsnake __P((void));
|
||||
void putpad __P((char *));
|
||||
void my_raw __P((void));
|
||||
void right __P((struct point *));
|
||||
void setup __P((void));
|
||||
void snap __P((void));
|
||||
void snap __P((void));
|
||||
void snrand __P((struct point *));
|
||||
void spacewarp __P((int));
|
||||
void stop __P((int)) __attribute__((__noreturn__));
|
||||
int stretch __P((struct point *));
|
||||
int stretch __P((struct point *));
|
||||
void surround __P((struct point *));
|
||||
void suspend __P((void));
|
||||
void up __P((void));
|
||||
void win __P((struct point *));
|
||||
void winnings __P((int));
|
||||
Reference in New Issue
Block a user