github.com/PDP-10.its
1
0
Fork 0
mirror of https://github.com/PDP-10/its.git synced 2026-02-03 15:22:48 +00:00
Code Issues Releases Wiki Activity

Added NGAME and games invoked by it.

Browse Source
This commit is contained in:
Eric Swenson
2018-05-19 22:26:29 -07:00
parent 94eb2a1810
commit 088ec2d6d9
53 changed files with 22974 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
src/games/animal.(init) Normal file
View File

@@ -0,0 +1,158 @@
;;; -*- LISP -*-
;;;
;;; KMP's ANIMAL Init File
;;;
;;; Created 2:14am Saturday, 23 September 1978
;;;
(COMMENT)
;; Temporary measures ...
(PROGN (CLOSE (PROG2 NIL INFILE (INPUSH -1)))
(CURSORPOS 'A TYO)
(PRINC '|The All-New ANIMAL program. (Old one temporarily out of order)|
TYO)
(TERPRI TYO)
(PRINC '|Please mention you're using ANIMAL version 2 in any bug notes.|
TYO)
(TERPRI TYO)
(PRINC '|End all input with a period!| TYO)
(TERPRI TYO)
(LOAD '((PIQUE) ANIMAL FASL))
(NOINTERRUPT T)
(SSTATUS TOPLEVEL '(ANIMAL))
(SETUP-FOR-ANIMAL))
(PROGN
;; Fix QUIT for KMP...
(COND ((MEMQ (STATUS UNAME) '(KMP TNP))
(DEFUN QUIT N
(CURSORPOS 'A TYO)
(PRINC '|Do you really want to kill this job? | TYO)
(CLEAR-INPUT TYI)
(COND ((MEMBER (TYI TYI) '(89. 121.))
(PRINC '| [Yes]| TYO)
(VALRET '|:KILL |))
(T
(PRINC '| [No]| TYO)
NIL))))
(T
(TERPRI TYO)
(PRINC '|There is an all new, very experimental Animal game| TYO)
(TERPRI TYO)
(PRINC '|by doing :KMP;ANIMAL. Please specify in any notes to| TYO)
(TERPRI TYO)
(PRINC '|BUG-ANIMAL which game you are using.| TYO)
(TERPRI TYO)))
;; Turn off interrupts while this loads
(NOINTERRUPT T)
;; Turn off load messages
(SSTATUS FEATURE NOLDMSG)
;; Send KMP a message if he's logged in.
(DEFPROP IOTA ((DSK LIBLSP) IOTA FASL) AUTOLOAD)
(COND ((AND (NOT (EQ (STATUS USERID) 'KMP))
(PROBEF '((USR *) KMP HACTRN)))
(LET ((BASE 10.) (*NOPOINT T) ((HOUR MIN) (STATUS DAYTIME)))
(ERRSET
(IOTA ((STREAM '((CLI *) KMP HACTRN) '(OUT)))
(MAPC (FUNCTION (LAMBDA (X) (PRINC X STREAM)))
(LIST
'|/[Message from The Animal Game at MIT-MC |
(COND ((ZEROP (\ HOUR 12.)) '|12|) (T (\ HOUR 12.)))
'/:
(COND ((< MIN 10.) (IMPLODE (LIST '/0 (+ MIN 48.))))
(T MIN))
(COND ((ZEROP (// HOUR 12.)) '|am|)
(T '|pm|))
'/] (ASCII 13.) (STATUS UNAME)
'| is gonna play against me!|))
(TERPRI STREAM))
NIL))))
;; Turn off ^S interrupt - trap it manually
(SSTATUS TTYINT 19. NIL)
;; Allocate core - load it in...
(ALLOC '(LIST 150000))
(LOAD '((DSK KMP) ANIMAL FASL))
;; <CR> to indicate we are doing something...
(TERPRI TYO)
;; Close this file
(CLOSE (PROG2 T INFILE (INPUSH -1)))
;; Is animal locked for some reason?
(COND ((PROBEF LOCK-DATA-FILE)
(PRINTC '|ANIMAL will not be available for a few minutes.| TYO)
(PRINTC '|I working on the data base. If you get this| TYO)
(PRINTC '|message and I am not logged in, please do :BUG ANIMAL| TYO)
(PRINTC '|Sorry for the inconvenience.| TYO)
(QUIT))
((PROBEF LOCK-PROGRAM-FILE)
(PRINTC '|ANIMAL will not be available for a few minutes.| TYO)
(PRINTC '|I am testing some new features. If you get this| TYO)
(PRINTC '|message and I am not logged in, please do :BUG ANIMAL| TYO)
(PRINTC '|Sorry for the inconvenience.| TYO)
(QUIT))
((PROBEF LOCK-RANDOM-FILE)
(PRINTC '|ANIMAL is out of service for an uncertain amount| TYO)
(PRINTC '|of time. Send mail to KMP@MC for explanation.| TYO)
(QUIT)))
;; Offer to print news if any...
(COND ((PROBEF NEWS-FILE)
(PROG (CHAR INFO *NOPOINT TIME DATE)
(SETQ *NOPOINT T)
TOP (TERPRI TYO)
(SETQ INFO (CAR (DIRECTORY (LIST NEWS-FILE) '(CREDATE CRETIME))))
(SETQ TIME (CADR (MEMQ 'CRETIME INFO)))
(SETQ DATE (CADR (MEMQ 'CREDATE INFO)))
(PRINC '|News last updated | TYO)
(DATE-AND-TIME-PRINC DATE TIME)
(PRINC '|.| TYO)
(TERPRI TYO)
(PRINC '|--Read News?-- (Y OR N)| TYO)
(CLEAR-INPUT TYI)
(SETQ CHAR (TYI TYI))
(COND ((MEMBER CHAR '(89. 121.))
(PRINTC '|(Type a <CONTROL-S>| TYO)
(PRINC '| to flush rest of output)| TYO)
(TERPRI TYO)
(CLEAR-INPUT TYI)
(APPLY 'PRINTFILE (NCONS NEWS-FILE)))
((= CHAR 12.)
(CURSORPOS 'C TYO)
(GO TOP))
((MEMBER CHAR '(2120. 63.))
(PRINTC '|Information about latest improvements.| TYO)
(GO TOP))
((MEMBER CHAR '(78. 110.))
(TERPRI TYO))
(T
(PRINC '| ?? Type "?" for help.|)
(GO TOP))))))
;; Run the game...
(ANIMAL))

2113
src/games/animal.133 Normal file
View File

File diff suppressed because it is too large Load Diff

1
src/games/animal.bare Normal file
View File

@@ -0,0 +1 @@
(SETQ MEMORY '(DOG (-> KMP)))

3474
src/games/animal.bugs Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
src/games/animal.info Normal file
View File

Binary file not shown.

9
src/games/animal.news Normal file
View File

@@ -0,0 +1,9 @@
KMP@MC 2:38am Monday, 28 June 1982 (Version 129)
Fixed certain obscure error messages that used to happen after you
apologize to the program for having offended it. The errors can still
happen sadly (not really something in my control to fix completely), but
I hope they'll happen less often.
That's about it. The game is essentially unchanged over the last two years.
Those interested in old news can print the file BMT1;ANIMAL ONEWS.

53
src/games/animal.onews Normal file
View File

@@ -0,0 +1,53 @@
KMP@MC 10:28pm Tuesday, 11 March 1980 (Version 122)
Someone accidentally clobbered the database by trying to load up the game
in a Lisp and run it from there. A very special environment must exist in
order for this game to function correctly -- do NOT attempt to manually
load this thing up in a lisp for whatever reason. As a result, some of the
most recently taught animals will have been lost. I will retrieve the most
recent version of the database from backup tape. Sorry about that.
(In the meantime, an itty bitty game will be left around for people to
play with ... it will go away when the old version is retrieved from tape.)
Some attempted fixes to the parser -- turns out they didn't work as expected
due to the nature of the pattern matcher.
KMP@MC 6:03am Saturday, 9 February 1980 (Version 120)
This version knows how to introspect a bit. Things like "How many animals
do you know?" and "What animals do you know?" will work.
KMP@MC 1:57am Sunday, 20 January 1980 (Version 107)
Used to be Animal couldn't grok names the sex of which was ambiguous.
This 'bug' has been fixed at LAUREN's request...
KMP@MC 4:20am Thursday, 10 January 1980 (Version 103)
In case people haven't noticed, the game should now call you by the
nickname you specified in :INQUIR ... I may do more fooling with names
later on. If it calls you by an improper subset of your name, please
let me know.
KMP@MC 3:56am Tuesday, 18 December 1979 (Version 83)
Bug fixes include:
(1) Changes better handling of foul languages. It is handled
at a very low level now and harder to get away with.
(2) The game should now handle hyphenated-words correctly (including hyphens
in the middle of words on continuation lines).
(3) Typing quoted text for noises (eg, It goes ``meow''.) will now work better
than it used to. Note that the "." has to go after the ''-marks since it
terminates the input string. (Naturally, saying: It goes "meow".
will also work.)
(4) Some typos in the database have been corrected.
KMP@MC 3:14pm Saturday, 15 December 1979
Animal now has a NEWS feature for keeping up on improvements
to the game.

105
src/games/animal.origin Normal file
View File

@@ -0,0 +1,105 @@
(SETQ MEMORY
'((IS THIS ANIMAL A REAL ANIMAL)
(((: HAS-ABILITY) FLY)
(((: HAS-PROPERTY) HORSE-LIKE)
(CYCLOPS)
(((: HAS-POSSESSION) MORE THAN ONE HEAD)
(((: HAS-POSSESSION) A HORN)
(CENTAUR)
(UNICORN))
(PUSHMEPULLYOU)))
(DRAGON))
(((: HAS-POSSESSION) WINGS)
(((: HAS-ABILITY) SWIM)
(((: HAS-CLASSIFICATION) MAMMAL)
(((: HAS-CLASSIFICATION) REPTILE)
(((: HAS-PROPERTY) MICROSCOPIC)
(((: HAS-CLASSIFICATION) MARSUPIAL)
(((: HAS-CLASSIFICATION) SPIDER)
(((: HAS-FUNCTION) MAKE PEARLS)
(CLAM)
(OYSTER))
(BLACKWIDOW))
(PLATYPUS))
(VIRUS))
(((: HAS-CLASSIFICATION) SNAKE)
(LIZARD)
(RATTLESNAKE)))
(((: HAS-PROPERTY) A FRIEND OF MAN)
(((: HAS-CLASSIFICATION) PREDATOR)
(((: HAS-POSSESSION) A LONG TAIL)
(((: HAS-ACTION) WALKS ON TWO LEGS)
(((: HAS-PROPERTY) STRIPED)
(((: HAS-POSSESSION) ANTLERS)
(DEER)
(ANTELOPE))
(ZEBRA))
(APE))
(MONKEY))
(((: HAS-PROPERTY) FELINE)
(WOLF)
(((: HAS-PROPERTY) STRIPED)
(((: HAS-POSSESSION) SPOTS)
(WILDCAT)
(LEOPARD))
(TIGER))))
(((: HAS-STATE) A COMMON HOUSE-PET)
(((: HAS-CLASSIFICATION) BEAST OF BURDEN)
(((: HAS-FUNCTION) GIVE MILK)
(((: HAS-FUNCTION) GIVE WOOL)
(PIG)
(SHEEP))
(((: HAS-POSSESSION) LEATHERY SKIN)
(GOAT)
(COW)))
(((: HAS-POSSESSION) TUSKS)
(((: HAS-POSSESSION) A HUMP)
(HORSE)
(CAMEL))
(ELEPHANT)))
(((: HAS-POSSESSION) CLAWS)
(DOG)
(CAT)))))
(((: HAS-HABITAT) IN AND OUT OF WATER)
(((: HAS-PROPERTY) AIR-BREATHING)
(((: HAS-CLASSIFICATION) PREDATOR)
(SEAHORSE)
(SHARK))
(((: HAS-CLASSIFICATION) PREDATOR)
(((: HAS-PROPERTY) USUALLY ENORMOUS)
(DOLPHIN)
(WHALE))
(KILLERWHALE)))
(((: HAS-CLASSIFICATION) REPTILE)
(FROG)
(CROCODILE))))
(((: HAS-POSSESSION) FEATHERS)
(((: HAS-FUNCTION) STING)
(FLY)
(((: HAS-ACTION) BUILDS A NEST)
(MOSQUITO)
(((: HAS-FUNCTION) MAKE HONEY)
(WASP)
(BEE))))
(((: HAS-FUNCTION) FLY)
(((: HAS-CLASSIFICATION) BARNYARD ANIMAL)
(OSTRICH)
(CHICKEN))
(((: HAS-CLASSIFICATION) PREDATOR)
(((: HAS-HABITAT) FLOATING ON WATER)
(((: HAS-HABITAT) IN A BIRD CAGE)
(((: HAS-FUNCTION) CARRY MESSAGES)
(((: HAS-ACTION) IS USED AS A SYMBOL OF PEACE)
(SPARROW)
(DOVE))
(PIGEON))
(PARAKEET))
(((: HAS-POSSESSION) LONG NECK)
(DUCK)
(((: HAS-PROPERTY) CONSIDERED VERY BEAUTIFUL)
(GOOSE)
(SWAN))))
(((: HAS-PROPERTY) NEARING EXTINCTION)
(HAWK)
(EAGLE))))))))

13
src/games/animal.rules Normal file
View File

@@ -0,0 +1,13 @@
You should think of an animal, and I will try to guess what it is. I
can accept multiple word responses, and I will read your input until I
see a period, exclam, or question mark (unless otherwise noted by the
'(Y OR N)' flag). I'll try to understand input in whatever form you
are comfortable with. As long as you use complete sentences, I should be
fine. Experiment if you want, I'm not as dumb as I may occasionally seem!
If you are not sure of what to do at any time, type a "?" or ask me a
question and I can probably help you.
This program was written by KMP@MC. Spring, 1978.
"To err is human -- the animals never err, except the smartest of them."
-- G.C. Lichtenberg

2
src/games/animal.save Normal file
View File

File diff suppressed because one or more lines are too long

4
src/games/chase.(init) Normal file
View File

@@ -0,0 +1,4 @@
(comment core 75.)
(progn
(fasload chase fasl dsk games)
(chase))

105
src/games/chase.info Executable file
View File

@@ -0,0 +1,105 @@
Copyright (C) 1978 William A. Kornfeld
CHASE - A Real Time game for VT52's
CHASE is real time game (e.g. space war, MAZE, etc.) with the distinction that
it is played on a VT52. The game is played by two players who must both be
present at the same physical terminal. It can in principle be used on other
character display terminals but may require redesignation of some of its
command characters to retain their current positional mnemonic significance.
CHASE can be played over phone lines with as little as a 300 baud modem or over
the net (though response may be somewhat unsatisfactory).
To setup a VT52 for CHASE make sure of the following:
1. CAPS LOCK is set!
2. The terminal is not in one of the VT52's special modes (i.e. graphics
or alternate keypad). This can be assured by momentarily turning off
power to the terminal.
After the game has begun you will notice a maze appear on the screen and
four characters: X,x,O, and o. The two X's are controlled by the person on
the left side of the terminal and the O's by the person on the right side.
The two large letters are known as "chasers" and the two small letters as
"chasees". The object of the game is to have your chaser "catch" (bump
into) the opponent's chasee. The game can be thought of as two simultaneous
chases happening concurrently in the maze. Each player plays both offense
and defense. Each player specifies directions for the two pieces under
his/her control. They may move anywhere in the maze as though they cannot
be moved through the wall of the maze. There is one additional constraint:
a chaser cannot move through the opponents chaser nor a chasee through the
opponents chasee. In addition to a pieces normal function it can also be
used to block. In this way the two chases interact and can lead to
sophisticated strategy with experienced players.
Pieces can be made to move in any of four directions (or held in place) by
appropriate keystrokes. Once a piece is put into motion it will remain in
motion at a constant velocity (same for all pieces at all times) until it is
explicitly told to stop or it reaches an obstruction which it cannot pass.
Each piece is controlled by a group of four keys (one for each direction)
arranged so that the players do not have to watch the keyboard as they enter
commands. In each group of four keys 3 are at the same level and 1 is directly
above the middle of the 3 keys. The lower 3 keys are respectively left, down,
and right. The upper key is up. The middle 3 fingers of each hand should be
placed on the 3 keys. In this way commands may be entered easily. As an
example the X piece is controlled by the four keys: A,S,D, and W. The middle 3
fingers of the left hand of the X-player should be placed on A, S, and D.
Hitting D once will start the X piece going right until it either hits
something or another command is given. Similarly for A, S, and W with left,
down, and up. The four command pads are:
BIG-X little-x
A T
S D W F G H
BIG-O little-o
[ 8
; ' { 4 5 6
^^^^^These four numbers are typed on
typed on the numeric keypad to the
right of the normal keypad.
If a piece is going in a direction, giving the command to travel in the
opposite direction once will stop the piece. Giving it twice will start the
character in the opposite direction. If a piece is going in a direction and
the command is given for it to go in an orthogonal direction it will
immediately start in that direction. Note that if a piece has been travelling
in a direction and hits an obstruction (usually the wall of the maze) it will
act as if it is still going in that direction with respect to future commands.
Games continue until a chaser has caught a chasee. The program pauses then for
a few seconds to report the victor and the score. When done it prints "READY".
Hitting RETURN will start a new game (with the initial positions of pieces
switched to be fair). If the display gets screwed up for any reason hitting
LINEFEED will freeze the game and do a redisplay. If the program screws up, it
may be started fresh from the top level LISP by typing (CHASE).
It doesn't take long to get reasonably comfortable with the controls. It is
easy however to get confused as you control the two pieces simultaneously.
Part of the skill to develop is in how to overcome this confusion. This also
enters into strategy. You can count on your opponent to get confused in
certain positions and can take advantage of that fact. This happens, for
example, when his/her 2 pieces cross paths or when they are both in opposite
parts of the maze and doing difficult manuevering. Strategy also includes
using your chaser to block the opponents chaser on defense and using your
chasee to block the opponents chasee on offense. It is important to always
remain on the offense. Beginners quickly give up offense when the going starts
getting rough. This only makes things worse in the end.
There is one unfortunate bug that I have not exorcised where the program
breakpoints just before restarting the game. If this happens just hit
CTRL-G and then type (CHASE) for a refresh.
This game is protected by US Copyright. No implementation may be undertaken
for any commercial purpose without prior consent from William A. Kornfeld.

1540
src/games/doc.(init) Normal file
View File

File diff suppressed because it is too large Load Diff

1547
src/games/doc.102 Normal file
View File

File diff suppressed because it is too large Load Diff

5
src/games/eliza.(init) Normal file
View File

@@ -0,0 +1,5 @@
(comment)
(progn
(load '|dsk:games;eliza fasl|)
(close infile)
(^g))

16
src/games/go.(init) Normal file
View File

@@ -0,0 +1,16 @@
(comment Setup for RKW's Go Program)
(progn
(sstatus features noldmsg)
(setq *nopoint t)
(load '|dsk: games; go1 fasl|)
(load '|dsk: games; go2 fasl|)
(setq fasload nil) ; So no Cautions for redefined functions.
(load '|dsk: games; gobrd fasl|)
(sstatus ttyint 26. (status ttyint 2)) ; ^Z does breakpoints
(sstatus ttyint 2 '(lambda (foo bar) (print-board))) ; ^B print-board.
(princ '|RKW's Go Program...|)
(setsyntax '/
'/ '/ )
(start)
'||)

105
src/games/guess.21 Normal file
View File

@@ -0,0 +1,105 @@
;;; -*- Midas -*- Game idea by RAE / Code by KMP
title Guess - Guess a number
a=:1
b=:2
c=:3
ttyo=:4
ttyi=:5
char=:6
where=:7
wins=:10
;;; Define some helpful macros
.insrt syseng;$call macro
define sysc3 op,val1,val2,val3
.call [ setz ? sixbit /op/ ? movem arg1 ? movem arg2 ? movem arg3 ((setz)) ]
termin
define type &string
movei a,<.length string>
move b,[440700,,[ascii string]]
$call siot,[#ttyo,b,a]
.lose %lsfil
termin
;;; Main program
guess: $call open,[#ttyo,[sixbit/tty/]][][#.uao\%tjdis]
.lose %lsfil
$call open,[#ttyi,[sixbit/tty/]][][#.uai]
.lose %lsfil
movei where,[ jrst death ]
setz wins,
;(SYSCALL 0 'TTYSET TYO ; bit 3.2 (%TSSII) of TTYSTS
; (CAR (STATUS TTY)) (CADR (STATUS TTY))
; (BOOLE 7 1_19. (CADDR (STATUS TTY))))
$call ttyget,[#ttyi][a,b,c]
jrst suicide
ior c,[2,,]
$call ttyset,[#ttyi,a,b,c]
jrst suicide
type "AAre you thinking of a number? "
jrst win2
askhim: type "AOk. Is your number 7? "
movei where,die
ask1: .iot ttyi,char ; Read a char
andi char,137 ; Uppercase
cain char,"Y ; If a y, ...
jrst win ; We win
cain char,"N ; If an n, ...
jrst askhim ; Loop
caie char,"Q ; If a q, ...
cain char,^Q ; or control-q
jrst [ type "AYou can't quit.AIs your number 7? "
jrst ask1 ]
cain char,^Z
jrst [ type "AYou can't Control-Z out!AIs your number 7? "
jrst ask1 ]
cain char,^G
jrst [ type "AYou can't ^G out ... I'm going to win.AIs your number 7? "
jrst ask1 ]
type " (Y or N) " ; Give help
jrst ask1 ; and loop
win: aos wins, ; Count wins
type "AI win..." ; Rub it in
win1: type "Want to play again? " ; Maybe new round
win2: .iot ttyi,char ; Read a char
andi char,137 ; Uppercase
cain char,"Y ; If a y, ...
jrst askhim ; Start over
cain char,"N ; If an n, ...
jrst @where ; Die
type " (Y or N) " ; Give help
jrst win2 ; and loop
die: cain wins,1
jrst [ type "ABeat you today, huh?"
jrst death ]
cain wins,2
jrst [ type "ATwo for me and *none* for you ..."
jrst death ]
cain wins,3
jrst [ type "AHey, I'm getting pretty good at this. Won 3 of 3"
jrst death ]
caig wins,5
jrst [ type "AYou're just not winning!"
jrst death ]
type "AYou'd probably win more if you didn't pick 7"
death: type "ABetter luck next time...A"
.logout 1, ; Kill job
suicid: type "AUnknown error. Please report this.A"
jrst death
end guess

140
src/games/lsrrtn.1 Normal file
View File

@@ -0,0 +1,140 @@
title LLSRTN - LISP interface to -*-MIDAS-*- inquir lookups
.fasl
.insrt sys:.fasl defs
;;Set up and include the inquire database hacking routines
lsrtns"$$ulnm==0 ;don't need last name search
lsrtns"$$ulnp==0 ;don't need abbrev l.name lookup
lsrtns"$$unam==0 ;don't need name permutation
;;define some acs for lsrtns use
lsrtns"a==t
lsrtns"b==tt
lsrtns"c==d
lsrtns"d==r
lsrtns"e==f
.insrt syseng;lsrtns
;;----------------------------------------------------------------
;;(LSRMAP <number of pages to use>)
;;opens up and maps in the inquir database for looking up people.
;;Returns a file object to be passed to other routines.
;;Uses GETCOR to reserve address space. Don't try this too many times
;;since the addr space isn't reused.
.entry LSRMAP SUBR 1+1
jsp t,fxnv1 ;get & save # pages to use, a->tt
push fxp,tt
;; (open '|inquir;lsr1 >| '(in))
movei a,.atom INQUIR/;LSR1/ >
movei b,.sx (IN)
call 2,.function OPEN
push p,a
;; extract I/O channel number from the file array, into TT
movei tt,f.chan
move tt,@ttsar(a)
push fxp,tt
;; get pages via getcor
move tt,-1(fxp) ;# pages
pushj p,getcor ;request addr space from Lisp
jumpe tt,corlos ;its addr is returned zero if none avbl
idivi tt,2000 ;cvt to page number
movn d,-1(fxp) ;get number of pages requested to construct
hrl tt,d ;aobjn to them
;; construct args for lsrmap
move lsrtns"b,tt ;aobjn to free page range
move lsrtns"a,(fxp) ;disk channel number
;; Get the INQUIR data base mapped in
pushj p,lsrtns"lsrmap ;try to map in the data base
jrst lsrluz ;no skip if it lost
;; I guess we won, clean up and return the file object.
opnbye: sub fxp,[2,,2]
pop p,a
popj p,
;; Random error routines, return () instead of file obj.
corlos:
lsrluz: move a,(p) ;get the file obj
call 1,.function CLOSE ;close it
setzm (p) ;return ()
jrst opnbye
;;----------------------------------------------------------------
;;(LSRUNM <file obj returned by LSRMAP> <uname>)
;;Returns a magic number to be passed to LSRITM, etc., or -1 if uname unknown.
;;Actually, the "magic number" is the entry's core address returned
;;by the lib subr.
.entry LSRUNM SUBR 2+1
push p,cfix1 ;NCALLable!
movei tt,f.chan ;pick up disk channel number
move tt,@ttsar(a)
push fxp,tt ;and save it
move a,b ;(car (pnget <uname> 6))
movei b,.atom #6.
call 2,.function PNGET
hlrz a,(a)
move lsrtns"b,(a) ;set up uname in 6bit for lsrunm
pop fxp,lsrtns"a ;the channel
pushj p,lsrtns"lsrunm ;get entry addr in lsrtns"b
movni lsrtns"b,1 ;-1 for loss
move tt,lsrtns"b ;move to where Lisp wants it.
popj p,
;;----------------------------------------------------------------
;;(LSRITM <item number> <magic number>)
;;returns the <item number> slot of the entry <magic number> returned
;;by LSRUNM.
;;This file sets the symbols I$UNAM etc to the correct values.
;;Look after this function, and in :INFO LIB LSRTNS .
.entry LSRITM SUBR 2+1
jsp t,fxnv1 ;item number, a->tt
jsp t,fxnv2 ;address, b->d
push fxp,d ;save so we don't have to worry about ac corres
movem tt,lsrtns"a
pop fxp,lsrtns"b
pushj p,lsrtns"lsritm ;returns bp in lsrtns"a
skipa d,[440700,,[0]] ;unless there was no skip: use null string then
move d,lsrtns"a ;d is input bp
setz b, ;start with ()
chlp: ildb tt,d ;get a char
jumpe tt,chlpx ;zero terminates
jsp t,fxcons ;turn into fixnum
call 2,.function CONS ;cons onto list
move b,a
jrst chlp ;go for another char
chlpx: move a,b ;reverse the list and atomify
call 1,.function NREVERSE
jcall 1,.function IMPLODE
.sxeva (SETQ I$UNAM #0 ) ;UNAME
.sxeva (SETQ I$NAME #1 ) ;FULL NAME
.sxeva (SETQ I$NICK #2 ) ;NICKNAME
.sxeva (SETQ I$SSN #3 ) ;SOC SEC NUMBER
.sxeva (SETQ I$MITA #4 ) ;MIT ADDRESS
.sxeva (SETQ I$MITT #5 ) ;MIT TELEPHONE NUMBER
.sxeva (SETQ I$HOMA #6 ) ;HOME ADDRESS
.sxeva (SETQ I$HOMT #7 ) ;HOME TELEPHONE NUMBER
.sxeva (SETQ I$SUPR #10 ) ;SUPERVISOR(S)
.sxeva (SETQ I$PROJ #11 ) ;PROJECT
.sxeva (SETQ I$DIR #12 ) ;FILE DIR NAMES
.sxeva (SETQ I$AUTH #13 ) ;AUTHORIZATION
.sxeva (SETQ I$GRP #14 ) ;GROUP AFFILIATION
.sxeva (SETQ I$REL #15 ) ;RELATION TO GROUP
.sxeva (SETQ I$BRTH #16 ) ;BIRTHDAY
.sxeva (SETQ I$REM #17 ) ;REMARKS
.sxeva (SETQ I$NETA #20 ) ;NETWORK ADDRESS
.sxeva (SETQ I$ALTR #21 ) ;USER AND TIME OF LAST ALTERATION
.sxeva (SETQ I$MACH #22 ) ;ITS-S TO BE KNOWN ON.
fasend

135
src/games/lsrrtn.insert Normal file
View File

@@ -0,0 +1,135 @@
;;; -*- LISP -*-
;;;
;;; Functions defined
;;;
;;; (OPEN-INQUIR-FILE)
;;; Must be done before these other things can happen
;;;
;;; (LOOKUP-INQUIR-INFO <evaluable-uname> <un-eval'd tag>)
;;; Macro to look up a certain tag in the INQUIR database
;;;
;;; (GET-USER-NAME <evaluable-uname>)
;;;
;;; SUBR returns something of the form
;;; ((last-name first-name middle-name) title lineage alias? nickname)
;;; or NIL if no such user.
;;;
;;; TITLE is one a word like [MR, MRS, ... DR, ...] (see code
;;; for currently used list)
;;;
;;; LINEAGE is one of II, III, or JR
;;;
;;; NIL is returned for unspecified elements. Alias's are tried to be
;;; traced through. If something was an alias, the ALIAS? flag is non-NIL
;;; all other info is as if it had been info about who it is an alias for.
;;; Multiple aliases should be traced through correctly.
;;;
;;; (CLOSE-INQUIR-FILE)
;;; Should be done after all LOOKUP-INQUIR-INFO's are done to
;;; close our INQUIR disk channel.
;;;
(DEFPROP LSRMAP ((DSK games) LSRRTN FASL) AUTOLOAD)
(DECLARE (SPECIAL *INQUIR-FILE-OBJECT*)
(*EXPR LSRMAP LSRITM LSRUNM))
(DEFUN OPEN-INQUIR-FILE () ; Allocate 15 pages for this map
(SETQ *INQUIR-FILE-OBJECT* (LSRMAP 15.))
T)
(DEFUN CLOSE-INQUIR-FILE ()
(CLOSE *INQUIR-FILE-OBJECT*)
T)
(DEFUN LOOKUP-INQUIR-INFO MACRO (FORM)
(LET (((UNAME DATA) (CDR FORM)))
`(LSRITM ',(OR (CDR (ASSQ DATA '((UNAME . 0.)
(FULL-NAME . 1.)
(NICKNAME . 2.)
(SOCIAL-SECURITY-NUMBER . 3.)
(MIT-ADDRESS . 4.)
(MIT-TELEPHONE-NUMBER . 5.)
(HOME-ADDRESS . 6.)
(HOME-TELEPHONE-NUMBER . 7.)
(SUPERVISOR . 8.)
(PROJECT . 9.)
(FILE-DIRECTORY-NAMES . 10.)
(AUTHORIZATION . 11.)
(GROUP-AFFILIATION . 12.)
(RELATION TO GROUP . 13.)
(BIRTHDAY . 14.)
(REMARKS . 15.)
(NETWORK-ADDRESS . 16.)
(LAST-ALTERATION . 17.)
(MACHINES-KNOWN-ON . 18.))))
(ERROR '|Unknown INQUIR Keyword| DATA))
(LSRUNM *INQUIR-FILE-OBJECT* ,UNAME))))
(DEFUN UNAME? (X) (AND (SYMBOLP X)
(PLUSP (LSRUNM *INQUIR-FILE-OBJECT* X))))
(DECLARE (*EXPR PARSE$MAKE-WORDS))
(DEFPROP PARSE$MAKE-WORDS ((games) PARSE FASL) AUTOLOAD)
(DEFUN GET-USER-NAME (WHO)
(COND ((NOT (UNAME? WHO)) NIL)
(T
(LET* ((DATA (LOOKUP-INQUIR-INFO WHO FULL-NAME))
(TOKENS (PARSE$MAKE-WORDS (EXPLODEC DATA)))
(LAST-NAME) (FIRST-NAME) (MIDDLE) (TITLE-ETC) (LINEAGE)
(ALIAS ()))
(DO ()
((NOT
(AND (EQ (CADR TOKENS) '/,)
(EQ (CAR (LAST TOKENS)) 'FOR)
(MEMQ (LOOKUP-INQUIR-INFO WHO GROUP-AFFILIATION)
'(/@ /O)))))
(SETQ ALIAS T)
(SETQ WHO (CAR TOKENS))
(SETQ TOKENS
(PARSE$MAKE-WORDS
(EXPLODEC
(SETQ DATA
(LOOKUP-INQUIR-INFO WHO FULL-NAME))))))
(SETQ TOKENS (DELETE '/. TOKENS))
(COND ((SETQ TITLE-ETC (CAR (OR (MEMQ 'MR TOKENS)
(MEMQ 'MRS TOKENS)
(MEMQ 'MISS TOKENS)
(MEMQ 'MS TOKENS)
(MEMQ 'DR TOKENS))))
(SETQ TOKENS (DELETE TITLE-ETC TOKENS))))
(COND ((SETQ LINEAGE (CAR (OR (MEMQ 'II TOKENS)
(MEMQ 'III TOKENS)
(MEMQ 'JR TOKENS))))
(SETQ TOKENS (DELETE LINEAGE TOKENS))))
(COND ((NOT (MEMQ '/, TOKENS)) ; What a loser...
(POP TOKENS FIRST-NAME)
(COND ((CDR TOKENS)
(POP TOKENS MIDDLE)
(POP TOKENS LAST-NAME))
(T
(POP TOKENS LAST-NAME))))
((EQ (CADR TOKENS) '/,)
(SETQ TOKENS (DELETE '/, TOKENS))
(POP TOKENS LAST-NAME)
(POP TOKENS FIRST-NAME)
(POP TOKENS MIDDLE))
(T
(SETQ FIRST-NAME (CADR (MEMQ '/, TOKENS)))
(SETQ LAST-NAME (DO ((L () (CONS (CAR TOKS) L))
(TOKS TOKENS (CDR TOKS)))
((EQ (CAR TOKS) '/,)
(IMPLODE
(MAPCAN 'EXPLODEC
(NREVERSE L))))))))
`( (,LAST-NAME
,FIRST-NAME
,@(COND (MIDDLE (NCONS MIDDLE))))
,TITLE-ETC
,LINEAGE
,ALIAS
,(LET ((NICKNAME (LOOKUP-INQUIR-INFO WHO NICKNAME)))
(COND ((EQ NICKNAME '||) NIL)
(T NICKNAME))))))))

226
src/games/parse.20 Normal file
View File

@@ -0,0 +1,226 @@
;;; -*- LISP -*-
;;; This is KMP's Word Parsing Package.
;;;
;;; The only user function is PARSE$MAKE-WORDS(Char-List) which
;;; will take a list of ascii characters and convert them into
;;; a list of words (each punctuating object being treated as a
;;; word.
;;;
;;; Supporting functions defined are:
;;;
;;; Definition Predicate Other
;;;
;;; PARSE$PUNCTUATION PARSE$PUNCTUATION?
;;; PARSE$DELIMITER PARSE$DELIMITER?
;;; PARSE$SPECIAL-CHAR PARSE$SPECIAL-CHAR?
;;; PARSE$STRAY-CHAR?
;;; PARSE$QUOTE PARSE$QUOTE?
;;; PARSE$CAPS
;;; PARSE$ALPHABETIC PARSE$ALPHABETIC?
;;; PARSE$NUMERIC?
;;; Turn of load messages
(SSTATUS FEATURE NOLDMSG)
;;;;;;;;;;;;;;;;;;;;;;;;;;; Standard Predicates ;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; PARSE$CAPS
;;; Returns ascii->ascii or numeric->numeric capitalized character.
(DEFUN PARSE$CAPS (X)
(COND ((NUMBERP X)
(COND ((AND (> X 96.) (< X 123.)) (- X 32.))
(T X)))
(T
(ASCII (PARSE$CAPS (GETCHARN X 1.))))))
;;; PARSE$ALPHABETIC?
;;; Predicate returns T if arg represents an alpha character. Accepts
;;; ascii or numeric arg.
(DEFUN PARSE$ALPHABETIC? (C)
(COND ((NUMBERP C) (AND (> C 64.) (< C 91.))) ; A <= C <= Z
(T (PARSE$ALPHABETIC? (GETCHARN C 1.)))))
;;; PARSE$DIGIT?
;;; Predicate returns T if arg represents a digital character. Accepts
;;; ascii or numeric arg.
(DEFUN PARSE$DIGIT? (N)
(COND ((NUMBERP N) (AND (> N 47.) (< N 58.))) ; 0 <= N <= 9
(T (PARSE$DIGIT? (GETCHARN N 1.)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Punctuation ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; PARSE$PUNCTUATION?
;;; Is [ascii] character punctuation?
(DEFUN PARSE$PUNCTUATION? (X) (GET X 'PARSE$PUNCTUATION))
;;; PARSE$PUNCTUATION
;;; Make [ascii] character into punctuation.
(DEFUN PARSE$PUNCTUATION (X) (PUTPROP X T 'PARSE$PUNCTUATION))
;;; PARSE$QUOTE?
;;; Is [ascii] character a quotation designator?
(DEFUN PARSE$QUOTE? (X) (GET X 'PARSE$QUOTE))
;;; PARSE$QUOTE
;;; Make [ascii] character into quotation designator.
(DEFUN PARSE$QUOTE (X) (PUTPROP X T 'PARSE$QUOTE))
;;; Make these chars into delimiters (single character objects)
(MAPC 'PARSE$PUNCTUATION
(LIST (ASCII 33.) ; <Exclamation Mark>
'|''| ; <Quote Marks> (Pseudo-punctuation generated below)
(ASCII 40.) ; <Left-Parenthesis>
(ASCII 41.) ; <Right-Parenthesis>
(ASCII 44.) ; <Comma>
'-- ; <Dash> (Pseudo-punctuation generated below)
(ASCII 46.) ; <Period>
(ASCII 58.) ; <Colon>
(ASCII 59.) ; <Semi-colon>
(ASCII 63.) ; <Question-mark>
(ASCII 91.) ; <Right-Bracket>
(ASCII 93.))); <Left-Bracket>
;;;;;;;;;;;;;;;;;;;;;;;;;;; Other Delimiters ;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; PARSE$DELIMITER?
;;; Is [ascii] character a delimiter?
(DEFUN PARSE$DELIMITER? (X)
(OR (PARSE$PUNCTUATION? X) (GET X 'PARSE$DELIMITER)))
;;; PARSE$DELIMITER
;;; Make [ascii] character a delimiter.
(DEFUN PARSE$DELIMITER (X) (PUTPROP X T 'PARSE$DELIMITER))
;;; Make these characters into delimiters (white space)
(MAPC 'PARSE$DELIMITER
(LIST (ASCII 9.) ; <Tab>
(ASCII 10.) ; <Linefeed>
(ASCII 13.) ; <Carriage Return>
(ASCII 32.))); <Space>
;;;;;;;;;;;;;;;;;;;;;;;;;;; Special Characters ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; PARSE$SPECIAL-CHAR?
;;; Is [ascii] character a special (legal) character?
(DEFUN PARSE$SPECIAL-CHAR? (X) (GET X 'PARSE$SPECIAL-CHAR))
;;; PARSE$SPECIAL-CHAR
;;; Make [ascii] character into a special character.
(DEFUN PARSE$SPECIAL-CHAR (X) (PUTPROP X T 'PARSE$SPECIAL-CHAR))
;;; Make <Single Quote> and <Hyphen> a speical char (to be treated like
;;; an alphabetic character).
(PARSE$SPECIAL-CHAR '/')
(PARSE$SPECIAL-CHAR '-)
;;; PARSE$FUNNY-CHAR?
;;; A printing ascii char, but not a commonly seen one.
(DEFUN PARSE$FUNNY-CHAR? (X) (GET X 'PARSE$FUNNY-CHAR))
;;; Set up FUNNY-CHAR definitions
(DO ((I 33. (1+ I)))
((> I 126.))
(LET ((X (ASCII I)))
(AND (NOT (GET X 'PARSE$FUNNY-CHAR))
(NOT (PARSE$PUNCTUATION? X))
(NOT (PARSE$DELIMITER? X))
(NOT (PARSE$ALPHABETIC? X))
(NOT (PARSE$DIGIT? X))
(NOT (PARSE$SPECIAL-CHAR? X))
(PUTPROP X T 'PARSE$FUNNY-CHAR))))
;;; PARSE$STRAY-CHAR?
;;; Is [ascii] character a random character of unknown type?
(DEFUN PARSE$STRAY-CHAR? (X)
(NOT (OR (PARSE$DELIMITER? X)
(PARSE$PUNCTUATION? X)
(PARSE$FUNNY-CHAR? X)
(PARSE$ALPHABETIC? X)
(PARSE$SPECIAL-CHAR? X)
(PARSE$DIGIT? X))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Main Word Parser ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; PARSE$MAKE-WORDS
;;; Take a list of [ascii] characters and return a list of atoms that can
;;; be made from those characters.
(DEFUN PARSE$MAKE-WORDS (CHAR-LIST)
(DO ((C CHAR-LIST (CDR C))
(CHAR)
(WORD NIL)
(SENT NIL))
((NULL C)
(COND (WORD (NREVERSE (CONS (IMPLODE (NREVERSE WORD)) SENT)))
(T (NREVERSE SENT))))
(SETQ CHAR (PARSE$CAPS (CAR C)))
(COND ((AND (EQ CHAR '-)
(EQ (CADR C) '-))
(SETQ C (CDR C)) ; Gobble second -
(SETQ CHAR '--)) ; Join hyphens to a dash
((AND (NOT WORD)
(PARSE$QUOTE? CHAR))
(DO () ((NOT (PARSE$QUOTE? (CAR C)))) (POP C)) ; Strip quotes
(DO () ((OR (NULL C) (PARSE$QUOTE? (CAR C))))
(PUSH (CAR C) WORD)
(POP C))
(DO () ((NOT (PARSE$QUOTE? (CADR C)))) (POP C)); Strip quotes
(PUSH '|``| SENT)
(PUSH (NCONS (IMPLODE
(SUBST '| | (ASCII 13.) (NREVERSE WORD))))
SENT)
(PUSH '|''| SENT)
(SETQ WORD NIL)
(SETQ CHAR '*DUMMY*))) ; This won't get cons'd in
(COND ((PARSE$STRAY-CHAR? CHAR)
(COMMENT IGNORE IT))
((AND (EQ CHAR '-)
(EQ (CADR C) (ASCII 13.)))
(COMMENT IGNORE HYPHEN -- GOBBLE <CR>)
(SETQ C (CDR C)))
((OR (PARSE$PUNCTUATION? CHAR)
(PARSE$FUNNY-CHAR? CHAR))
(COND (WORD
(SETQ SENT
(CONS CHAR
(CONS (IMPLODE (NREVERSE WORD))
SENT)))
(SETQ WORD NIL))
(T
(SETQ SENT (CONS CHAR SENT)))))
((PARSE$DELIMITER? CHAR)
(COND
(WORD (SETQ SENT (CONS (IMPLODE (NREVERSE WORD)) SENT))
(SETQ WORD NIL))))
((OR (PARSE$ALPHABETIC? CHAR)
(PARSE$SPECIAL-CHAR? CHAR)
(PARSE$DIGIT? CHAR))
(SETQ WORD (CONS CHAR WORD))))))

279
src/games/pattrn.7 Normal file
View File

@@ -0,0 +1,279 @@
;;; -*- LISP -*-
;;; PATTERN: A Library of Pattern Matching Routines
;;; MATCH
;;; This function allows the following syntax
;;;
;;; (MATCH <Pattern> <Thing>)
;;;
;;; Returns T iff <Thing> is of the form specified by <Pattern>
;;;
;;; <Pattern> is a list with the description...
;;;
;;; ( <Specifier> <Specifier> ...)
;;;
;;; <Specifier> is one of the following forms:
;;;
;;; <atom> Matches an atom that is EQ to it
;;;
;;; (?) Matches any single S-Expression
;;;
;;; (? <tag>) Matches any single S-Expression and assigns
;;; to tag the value of the thing matched
;;;
;;; (?= <pred>) Matches any single S-Expression for which
;;; <pred> is true
;;;
;;; (?= <pred> <tag>) Matches any single S-Expression for which
;;; <pred> is true, assigns matched thing to <tag>
;;;
;;; ($) Matches a single S-Expression or none.
;;;
;;; ($ <tag>) Matches a single S-Expression or none,
;;; assigning matched item to <tag>.
;;;
;;; ($= <pred>) Matches a single S-Expression if it makes
;;; <pred> true, or none.
;;;
;;; ($= <pred> <tag>) Matches a single S-Expression if it makes
;;; <pred> true, or none, assigns thing
;;; matched to <tag>
;;;
;;; (*) Matches any series of S-Expressions.
;;;
;;; (* <tag>) Matches any series of S-Expressions, assigning
;;; to <tag> a list of the matched things.
;;;
;;; (*= <pred>) Matches any series of things that return true
;;; for <pred>
;;;
;;; (*= <pred> <tag>) Matches any series of things that return true
;;; for <pred>; <tag> gets list of things matched
;;;
;;; <Thing> is a list
;;;
;;; MATCH
;;; This function looks at all constant terms in a pattern, and makes
;;; sure they at least occur in the same order in item being tested.
;;; If they don't, the match fails. If they do, the normal (hairy)
;;; matching scheme is attempted.
(DEFUN MATCH (PP XX)
(DO ((P PP (CDR P))
(X XX))
((NULL P) (MATCH1 PP XX))
(COND ((ATOM (CAR P))
(SETQ X (MEMQ (CAR P) X))
(COND ((NULL X) (RETURN NIL)))))))
;;; Macros needed for making my code size below a bit more compressed
;; (TAILSTRIP <expression>)
;; removes the last element of a list.
;; Equivalent to (DEFUN TAILSTRIP (X) (NREVERSE (CDR (REVERSE X))))
;; but a slight bit faster.
(DEFUN TAILSTRIP (X)
((LAMBDA (R)
(DO ((X X (CDR X))
(L (SETQ R (NCONS ())) (CDR L)))
((NULL (CDR X)) (CDR R))
(RPLACD L (NCONS (CAR X)))))
NIL))
;; (POP* <var1> <var2> ...)
;; Same as (PROGN (POP <var1>) (POP <var2>) ...)
(DEFUN POP* MACRO (X)
`(PROGN ,@(MAPCAR (FUNCTION (LAMBDA (X) `(SETQ ,X (CDR ,X))))
(CDR X))))
;;; MATCH1
;;; This is the real brains behind the matcher. It is called only from
;;; MATCH, however, which does some preprocessing.
(DEFUN MATCH1 (P X)
(DO ((PATTERN)
(FUNCTION-VALUE)
(STARFLAG))
((NULL P) (NULL X))
(COND ((ATOM (CAR P)) ; Atom must match exactly
(COND ((NULL X) (RETURN NIL))); This can't match a null list
(COND ((EQ (CAR P) (CAR X)) ; If matched...
(POP* P X) ; Pop pattern & test list
(SETQ STARFLAG NIL)) ; Terminate * search
(T ; Else (no atomic match)
(RETURN NIL)))) ; Match failed
((EQ (CAAR P) '?) ; ? may match any single thing
(COND ((NULL X) (RETURN NIL))); This can't match a null list
(COND ((CDAR P) ; Maybe assign match to a var
(SET (CADAR P) (CAR X))))
(POP* P X) ; Pop pattern & test list
(SETQ STARFLAG NIL)) ; Terminate * search
((EQ (CAAR P) '?=) ; Match w/ predication
(COND ((NULL X) (RETURN NIL))); This can't match a null list
(COND ((NOT (FUNCALL (CADAR P) (CAR X))) ; Try predicate
(RETURN NIL))) ; Fail if predicate loses
(COND ((CDDAR P) ; Maybe assign match to a var
(SET (CADDAR P) (CAR X))))
(POP* P X) ; Pop pattern & test list
(SETQ STARFLAG NIL)) ; Terminate * search
(T
(SETQ PATTERN (CAR (LAST P))) ; Work on last elements for
; a while...
(COND ((ATOM PATTERN) ; If last element is an atom
(COND ((NULL X) ; This can't match a null list
(RETURN NIL)))
(COND ((NOT (EQ (CAR (LAST X)) PATTERN))
(RETURN NIL))) ; Fail if doesn't match
(SETQ P (TAILSTRIP P)) ; Pop last element of pattern
(SETQ X (TAILSTRIP X)) ; Pop last element of test list
(SETQ STARFLAG NIL)) ; Terminate * search
((EQ (CAR PATTERN) '?) ; Last element of ? matches!
(COND ((NULL X) ; This can't match a null list
(RETURN NIL)))
(COND ((CDR PATTERN) ; Maybe assign match to a var
(SET (CADR PATTERN) (CAR (LAST X)))))
(SETQ P (TAILSTRIP P)) ; Pop last element of pattern
(SETQ X (TAILSTRIP X)) ; Pop last element of test list
(SETQ STARFLAG NIL)) ; Terminate * search
((EQ (CAR PATTERN) '?=) ; Predicated match last element
(COND ((NULL X) ; This can't match a null list
(RETURN NIL)))
(COND ((NOT (FUNCALL (CADR PATTERN) (CAR (LAST X))))
(RETURN NIL))) ; If pred fails, match fails
(COND ((CDDR PATTERN) ; Maybe assign match to a var
(SET (CADDR PATTERN) (CAR (LAST X)))))
(SETQ P (TAILSTRIP P)) ; Pop last element of pattern
(SETQ X (TAILSTRIP X)) ; Pop last of element test list
(SETQ STARFLAG NIL)) ; Terminate * search
((EQ (CAR (SETQ PATTERN (CAR P))) '$)
; $ can optionally match
(COND ((MATCH1 (CDR P) X) ; Test first ignoring $
(COND ((CDR PATTERN) ; Maybe set a variable
(SET (CADR PATTERN) NIL))) ; to match
(RETURN T))) ; We won without it
(COND ((CDR PATTERN) ; Maybe set a variable to
(SET (CADR PATTERN) (CAR X)))) ; thing matched
(POP* P X) ; Pop pattern and test list
(SETQ STARFLAG NIL)) ; Terminate * search
((EQ (CAR PATTERN) '$=) ; Match 1 or 0 with predication
(COND ((MATCH1 (CDR P) X) ; Try first without using $=
(COND ((CDDR PATTERN) ; Maybe set variable to
(SET (CADDR PATTERN) NIL))) ; match
(RETURN T))) ; We won
(COND ((NOT (FUNCALL (CADR PATTERN) (CAR X))) ; Apply
(RETURN NIL))) ; predicate - if NIL then fail
(COND ((CDDR PATTERN) ; Maybe set variable to
(SET (CADDR PATTERN) (CAR X)))) ; thing matched
(POP* P X) ; Pop pattern and test list
(SETQ STARFLAG NIL)) ; Terminate * search
((EQ (CAR PATTERN) '*) ; * matches any sequence
(COND ((NULL X) ; If no more elements,
(RETURN ; make sure no pending
(MATCH1 (CDR P) NIL))) ; patterns lose.
((MATCH1 (CDR P) X) ; Else match first without *
(COND ((AND (NOT STARFLAG)
(CDR PATTERN)) ;Maybe clear
(SET (CADR PATTERN) NIL))) ; variable
(RETURN T))) ; We won
(COND ((CDR PATTERN) ; If there's a var to set
(COND (STARFLAG ; add element to end of var
(SET (CADR PATTERN) ; add to var's val
(NCONC (EVAL (CADR PATTERN))
(NCONS (CAR X)))))
(T ; if var not initialized
(SET (CADR PATTERN) ;set to (<match>)
(NCONS (CAR X)))))))
(POP* X) ; Pop test list
(SETQ STARFLAG T)) ; Note * search in effect
((EQ (CAR PATTERN) '*=) ; Match any predicated sequence
(COND ((NULL X) ; If no more test list
(RETURN ; Insure no pending patterns
(MATCH1 (CDR P) NIL))) ; are violated
((MATCH1 (CDR P) X) ; Else try wihtout
(COND ((AND (NOT STARFLAG) (CDDR PATTERN))
(SET (CADDR PATTERN) NIL)))
(RETURN T)))
(SETQ FUNCTION-VALUE (FUNCALL (CADR PATTERN) (CAR X)))
(COND ((NOT FUNCTION-VALUE) (RETURN NIL)))
(COND ((CDDR PATTERN)
(COND (STARFLAG
(SET (CADDR PATTERN)
(NCONC (EVAL (CADDR PATTERN))
(NCONS (CAR X)))))
(T
(SET (CADDR PATTERN)
(NCONS (CAR X)))))))
(SETQ X (CDR X))
(SETQ STARFLAG T))
(T ; Unknown pattern form?
(RETURN NIL))))))) ; Fail
(DEFUN MATCH-VAR-GET (X)
(COND ((ATOM X) NIL)
((MEMQ (CAR X) '(* ?)) (AND (CDR X) (LIST (CADR X) NIL)))
(T (AND (CDDR X) (LIST (CADDR X) NIL)))))
(DEFUN ELIMINATE-REDUNDANCIES (X)
(DO ((L X (CDDR L))
(R NIL))
((NULL L) (NREVERSE R))
(COND ((NOT (MEMQ (CAR L) R))
(SETQ R (CONS (CADR L) (CONS (CAR L) R)))))))
(DEFUN MATCH-VARS (L)
(APPLY 'NCONC
(MAPCAR (FUNCTION (LAMBDA (P) (MAPCAN 'MATCH-VAR-GET P))) L)))
;;; MATCHES
;;; This is a convenience macro that takes the syntax:
;;;
;;; (MATCHES <form> <pattern1> <pattern2> <pattern3> ... <patternM>)
;;;
;;; <form> will be EVAL'ed
;;; <pattern>'s will not be EVAL'd
;;;
;;; It will expand to the following:
;;;
;;; (PROGN (SETQ <var1> NIL <var2> NIL <var3> NIL ... <varN> NIL)
;;; (OR (MATCH '<pattern1> <form>)
;;; (MATCH '<pattern2> <form>)
;;; (MATCH '<pattern3> <form>)
;;; ...
;;; (MATCH '<patternM> <form>)
;;; (SETQ <var1> NIL <var2> NIL ... <varN> NIL)))
;;;
;;; <var1> ... <varN> are the variables that may be set by the Matcher.
;;; The are initialized to NIL and if the Matches fail, they are
;;; re-initialized to NIL to avoid chance of getting garbage left over in
;;; them.
(DEFUN (MATCHES MACRO) (X)
(LET* (((OBJECT . PATTERNS) (CDR X))
(INITS (ELIMINATE-REDUNDANCIES (MATCH-VARS PATTERNS))))
(COND (INITS (PUSH 'SETQ INITS)))
(COND ((NULL PATTERNS) NIL)
((> (LENGTH PATTERNS) 1.)
`(OR ,@(MAPCAN
(FUNCTION
(LAMBDA (X)
(COND (INITS
`(,INITS (MATCH ',X ,OBJECT)))
(T
`((MATCH ',X ,OBJECT))))))
PATTERNS)
,@(COND (INITS (NCONS INITS)))))
(T
(COND (INITS
`(OR ,INITS
(MATCH ',(CAR PATTERNS) ,OBJECT)
,INITS))
(T
`(MATCH ',(CAR PATTERNS) ,OBJECT)))))))
;;; Note this package has loaded
(SSTATUS FEATURE PATTERN)

8
src/games/qb.(init) Normal file
View File

@@ -0,0 +1,8 @@
(comment)
(progn
(load '|dsk:games;qb fasl|)
(setq errlist '((gc)
(qubic)))
(setsyntax '/
'/ '/ )
(qubic))

359
src/games/sprout.rules Normal file
View File

@@ -0,0 +1,359 @@
THE RULES OF SPROUTS, THE ONLY TOPOLOGICAL GAME
INVENTED BY JOHN HORTON CONWAY AND MIKE PATERSON
PRESENTED ORIGINALLY IN SCI. AMER. MATH GAMES 1967.JUL
DESCRIBED HERE BY ROBERT MAAS 1977.AUG.01
Sprouts is a two-person game with alternating play. There can
be no draw, one person wins or the other does. The longest
game possible is 3*N-1 halfmoves and the typical game is 7*N/3
halfmoves (where N is the number of dots in the starting
situation, as described below), thus with N in the range 2:7
the typical game lasts between 4 and 16 moves (beginners start
at N=2 and work up, becoming experts when they have mastered
N=7) resulting in short snappy contests.
PLAYING SURFACE: The game is played on either a sphere or a
plane, at least in principle it is; actually the game is played
in the interior of some small playing area that has been marked
on a sheet of paper, 2" by 2" square is sufficient for a game
when N=2,3,4,5 and slightly larger squares for N=6 and N=7.
The only utensils needed are a pencil or pen for drawing
freehand dots and lines in the playing area.
INITIAL SITUATION: The game starts with N dots drawn somewhere
inside the playing area. It is preferable to arrange the dots
as far from each other and from the edges of the playing area as
possible, usually people arrange them in a circle about half the
diameter of the playing area centered in the playing area.
LEGAL MOVE, BASIC: A legal move consists of drawing a line from
some already-existing dot to another already-existing dot, subject
to the restrictions listed below, then placing a new dot on the
midpoint of the line (segment). The line drawn may curve in order
to connect back to its starting point or in order to go around
obstacles that block a staight path, or to cause certain dots and
lines to be on the left side separated from other dots and lines
on the right side of the new line drawn.
RESTRICTIONS: Each line (segment) drawn when making a move must
not touch itself (except at endpoints when connecting a dot back
to itself) nor cross or brush against any other dot or line, thus
it is impossible to cross a closed-curve in order to connect some
dot inside it to another dot outside it. -- Also, it is illegal
to make any move that causes any dot to have more than 3 (three)
connections to it. Note that drawing a loop from a dot back to
itself counts as two connections to that dot. Note also that
the new dot created during each move already has a line coming into
it from each side thus already has two connections at its birth,
thus allowing only one additional connection to it.
END OF GAME, WINNER: The game is over when there is no legal
move remaining. The last person who was able
to make a legal move is the winner.
NOTATION USED TO PLAY GAME OVER TELEPHONE AND/OR TERMINAL, AND
USED TO RECORD A GAME: The syntax is <p> <m>:<n1>-<n2> (<l>/<r>)<cr>
where <p> is the name of the player making the move, <m> is
the number of the move (each new move creates a new dot, the original
dots are numbered 1,2,..,N and the new dots are numbered N+1, N+2,
etc. -- each move is numbered according to the new dot created by
that move, thus the first move is numbered N+1 rather than 1),
<n1> and <n2> are the two dots connected by the line segment,
if the move is ambiguous then <l> and <r> are supplied listing the
dots that appear on the left and right of the new segment going
from <n1> to <n2> (thinking of the playing area as a roadmap,
with lines representing highways, dots representing intersections,
and unmarked areas representing city parks -- when <n1>-<n2>
completes a closed curve because <n1> and <n2> were already
connected by some other highway before the current move, to figure
out what <l> and <r> are you imagine letting your pet dog take a
walk out either your left window or right window respectively, with
the restriction that your dog may not cross a highway, the
intersections your dog can stick his nose into are listed in <l>
and <r> for the two walks he can take respectively -- when the
highways form a peninsula or isthmus so that a dot on the neck
(thin part) of the peninsula or isthmus can be sniffed by a dog
from opposite sides while remaining in the same city park (without
crossing any highway), and such a dot is <n1> or <n2>, then the
dots immediately adjacent on the left and right as <n1> is
departed or <n2> is reached, are included in <l> and <r>
respectively to remove the ambiguity as to the resultant
configuration), and <cr> denotes carriage-return with
accompanying linefeed. Note that the parenthesi and slash are
omitted when neither a closed curve nor a peninsula/isthmus
connection is made, or when no ambiguity is made by the omission
of <l> and <r> completely. When there is a choice between two
moves, one of which have an <l> and <r> and the other of which
doesn't, between exactly the same <n1> and <n2>, however, the
parenthesis must be supplied in both cases to avoid ambiguity
(note, some versions of the program, if you type in just <n1>-<n2>,
will assume you intend the (/) version i.e. null <l> and <r>,
however it is bad when playing a human to fail to specify in
this case).
EXAMPLES OF NOTATION FOR MAKING MOVES: Let us suppose that
FOO and BAZ are playing a game with N=2, with FOO playing first.
FOO may open the game by connecting dot#1 to dot#2, thus
FOO 3: 1-2
or FOO may connect dot#1 to itself either making a small loop, or
making a loop clockwise around dot#2, or making a loop CCW around
dot#2, but all these three moves are equivalent strategically
hence can be denoted by either
FOO 3: 1-1 (2/)
or by
FOO 3: 1-1 (/2)
(technically these moves are different in that 1-3-1 was traced
in the reverse direction in one from the other, thus with car
moving in reverse direction left and right are reversed so that
dot#2 changes apparant sides, but due to symmetry the resultant
situations are identical hence the user can be sloppy in notation
in this case)
or FOO may connect dot#2 to itself, denoted by
FOO 3: 2-2 (1/)
or by
FOO 3: 2-2 (/1)
Note that although 1-1 (2/) and 2-2 (1/) are equivalent strategically,
the notation used for subsequent moves is different, thus the
player must specify which move he is making in order for play of
the game by notation to proceed. Thus there are two totally
different opening moves, one of which has 2 ways to do it with
numbered dots.
Let us suppose player FOO makes this opening move:
FOO 3: 1-2
Player BAZ now has three totally different replies:
BAZ 4: 1-2 (both ways to draw it are equivalent)
BAZ 4: 1-3 (2/) or 1-3 (/2) or 2-3 (1/) or 2-3 (/1)
all of which are strategically equivalent but notationally
different hence must be correctly typed one of four ways
BAZ 4: 1-1 or 2-2 (unnecessary to specify 1-1 (3/) or 1-1 (/3)
because the resulting situations are identical)
Let us suppose player BAZ makes the reply:
BAZ 4: 1-3 (2/)
now player FOO has the choice of
FOO 5: 1-4 (/)
FOO 5: 1-4 (2/)
FOO 5: 2-2
FOO 5: 1-2 (equivalent to 4-2 strategically but must be
specified correctly because notation would be different in
that case)
Let us suppose player FOO makes the move:
FOO 5: 1-4 (2/)
now player BAZ has the choice of
BAZ 6: 2-5
BAZ 6: 2-2
Let us suppose player BAZ makes the move:
BAZ 6: 2-5
now player FOO has the choice of
FOO 7: 2-6 (4/)
FOO 7: 2-6 (/1)
but both moves are equivalent, and normally <l>/<r> is omitted
for dots that can't be connected to anything because they
already have three connections, thus the notation for both moves is
FOO 7: 2-6 (/)
which may be abbreviated to
FOO 7: 2-6
After playe FOO makes the move
FOO 7: 2-6
there is no legal move, so FOO wins the game. The complete record
of the game is:
SPROUTS GAME, 2 DOTS
FOO 3: 1-2
BAZ 4: 1-3 (2/)
FOO 5: 1-4 (2/)
BAZ 6: 2-5
FOO 7: 2-6
NOTATION FOR SITUATIONS: Note that the above notation is for
describing a half-move to be made, not the complete situations that
result between half-moves, just like in Chess the notation N-B5
denotes a half-move not the complete board situation. Sprouts also
has a way to represent a complete situation just like Chess
has its notation rnb1kbnr/ppppqppp/8/8/3Pp2N/8/PPP1PPPP/RNBQKB1R.
to represent a complete board position. In fact the LISP
internal representation of this notation is actually used by
Sprouts-playing programs to keep track of the situation during
the course of a game or during analysis. A Sprouts situation
is represented by a 3-level list, which is presented externally
by merely calling the LISP function PRINT or by a more fancy
variation of PRINT written specially for Sprouts, together with
a table of how many connections remain to be made to each dot.
People who have never programmed in LISP will probably find this
notation difficult to understand, in which case this section
should be omitted when reading this file.
The table of lives is the easy part. It is simply a list
of how many lives each dot has remaining, thus after the first
two half-moves in the example game, the table of lives would be
(1 2 0 1) which means dot#1 has 1 life, dot#2 has 2 lives, dot#3
has 0 lives, and dot#4 has 1 life.
The three-level list is more complicated. The top level
is a list of regions (city parks) altogether. Each second level
is the list of separate pieces of highway adjoining the park
(in the top-level list) that points to it, thus to get between
the various pieces of highway one must drive across the park.
Each third level is a list of intersections on that piece of
highay adjoining that park, however the intersections are listed
in sequence from left to right as one would read off the numbers
while standing in the park and facing the highway segment.
Note that arbitrary permutation of regions doesn't change
the situation, also that within each region arbitrary permutation
of highway segments doesn't change the situation, also that rotation
of the numbers of intersections on a highway segment doesn't change
the situation but that any other permutation of numbers of
intersections on a highway segment will result in a different
situation, or more commonly an impossible configuration.
Below are listed the life table and the 3-level list which
denote the situations that occur in the example game above, together
with the moves (same as shown above) which transform each situation
into the next. Each situation is shown in fully-verbose mode (all
dots shown even though they have no connections remaining to make
hence are irrelevant to the later game) and in terse mode (all
fully-dead dots deleted from the notation, and all regions where
no further connections can be made deleted from the notation):
INITIAL SITUATION: (3 3) (((1) (2)))
MOVE: FOO 3: 1-2
RESULTANT SITUATION: (2 2 1) (((1 3 2 3)))
MOVE: BAZ 4: 1-3 (2/)
VERBOSE SITUATION: (1 2 0 1) (((1 4 3)) ((1 3 2 3 4)))
TERSE SITUATION: (1 2 0 1) (((1 4)) ((1 2 4)))
MOVE: FOO 5: 1-4 (2/)
VERBOSE SITUATION: (0 2 0 0 1) (((1 4 3)) ((1 5 4)) ((1 3 2 3 4 5)))
TERSE SITUATION: (0 2 0 0 1) (((2 5)))
MOVE: BAZ 6: 2-5
VERBOSE SITUATION: (0 1 0 0 0 1) (((1 4 3)) ((1 5 4)) ((2 3 4 5 6)) ((1 3 2 6 5)))
TERSE SITUATION: (0 1 0 0 0 1) (((2 6)) ((2 6)))
MOVE: FOO 7: 2-6
VERBOSE SITUATION DEPENDS ON WHICH OF TWO EQUIVALENT MOVES WAS DONE.
TERSE SITUATION: (0 0 0 0 0 0 1) ()
Note that at the end of the game the terse situation 3-level
list is always exactly NIL (the empty list).
There are two reasons for having notation for a situation.
One reason is to describe a situation without repeating all the moves
that led up to it, in order to resolve a dispute in the middle of
a game when somehow one player or the other has screwed up his
playing area and wants to know what the other's looks like. The
other is when using a program to analyze a situation there must be
some way to type in the desired situation.
When a program types out a situation, instead of using
PRINT or PRINC to type out its internal representation as shown
above, usually a more human-readable version is used, shown here:
(after the second move)
SPROUTS SITUATION:
REGION #1:
BOUNDARY #1: 1[1],4[1]
REGION #2:
BOUNDARY #1: 1[1],2[2],4[1]
Note that the numbers inside brackets are the numbers of lives
taken from the life table. The numbers outside brackets are
the numbers identifying the dots which appear as elements in the
third level of the 3-level list. Here's a more complicated
example from a game with N=4:
SPROUTS GAME, 4 DOTS
FOO 5: 1-1 (2/3,4)
BAZ 6: 3-5
FOO 7: 3-6 (4/)
SPROUTS SITUATION:
REGION #1:
BOUNDARY #1: 2[3]
BOUNDARY #2: 1[1]
REGION #2:
BOUNDARY #1: 4[3]
BOUNDARY #2: 1[1],7[1],3[1]
REGION #3:
BOUNDARY #1: 3[1],7[1]
CANONICAL NOTATION FOR SPROUTS SITUATIONS: When analyzing Sprouts
it is useful to identify situations that are equivalent so as to
avoid analyzing both versions of it and thus doubling ones work.
One way to do this is to find some canonical form of notation to
represent situations and to alphabetize or hash these representations
to make it easy to determine whether a situation that turns up is
one that has already been indexed and possibly analyzed. The
notation that I have adopted for this purpose involves replacing
the number that designates a dot by the number that designates the
number of lives it has remaining (thus eliminating duplicate entries
due to different names for a dot that plays exactly the same role
in equivalent situations), except that when a dot is shared between
two regions or between two sides of an isthmus or peninsula it is
necessary to handle it in a unique way. A minute's thought makes
it apparant that the only way a dot can still be alive while appearing
in two different places in the TERSE notation given above is if it
has exactly one life. Even a dot with exactly one life (which
always lies across a peninsula or isthmus or is shared between two
regions in the VERBOSE notation above) can occur just once if
it adjoins two regions one of which is dead in the sense of no
chance to connect to anything else alive in that region. Thus four
cases exist for each dot, unshared dots with 1 2 or 3 lives each,
which can be replaced by the number of lives, and shared dots with
exactly 1 life each, which are handled specially. What is done for
1-life shared dots is to number them 4,5,6,... After choosing the
numbering for 1-life shared dots, a recursive short of the 3-level
structure is done, sorting rotationally-only at the third level,
and sorting fully at the top level and the second level. One
additional symmetry is present, namely that reversing the third
level lists throughout any top level (region) element doesn't
change the situation strategically. Thus the complete brute-force
algorithm for finding canonical form is to replace shared 1-life
dots in all k factorial ways (where k is the number of them) and
performing the following algorithm on each way:
In each region, try reversing and not reversing all
third-level lists, performing the following algorithm
on each:
Sort each third-level cyclically.
Sort the second-level list of third-level
lists completely.
Sort the list of two elements you get from the two
calls to the sub-algorithm you just did, and select
the first element.
Now make a list out of the results for each region
and sort it completely.
Now make a list of length k factorial of the results from all the
permutations on names 4,5,6,... for shared 1-life dots and sort
them completely, then select the first element as the answer,
the result that is returned from the canonical-form routine. Here
are the canonical forms that result from the sample game above:
CANONICAL FORM: (((3) (3)))
MOVE: FOO 3: 1-2
CANONICAL FORM: (((2 4 2 4)))
MOVE: BAZ 4: 1-3 (2/)
CANONICAL FORM: (((2 4 5)) ((4 5)))
MOVE: FOO 5: 1-4 (2/)
CANONICAL FORM: (((1 2)))
MOVE: BAZ 6: 2-5
CANONICAL FORM: (((4 5)) ((4 5)))
MOVE: FOO 7: 2-6
CANONICAL FORM: ()
The only reason I can think of you would want to use this
canonical notation is when looking at output from my computer
program, or when describing an abstract situation to someone without
bothering him with the details of how it was arrived at in a game.
Here's the 4-dot situation mentionned earlier, using
canonical notation:
(((3) (4)) ((3) (4 5 6)) ((5 6)))
The major disadvantage of canonical notation is the large
amount of compute time it takes to perform k factorial recursive
sorts when k is large. For example when given the situation in
terse notation:
(1 1 1 1 1 1) (((1 4) (2 6)) ((2 6)) ((1 4) (3 5)) ((3 5)))
it takes seven hundred and twenty recursive sorts to determine
that the canonical notation is:
(((4 5)) ((6 7)) ((4 5) (8 9)) ((6 7) (8 9)))
(actually "8" would come out "10" and "9" would come out "11"
because my program currently uses base eight rather than
base ten) which would take several minutes on the SU-AI KL-10
machine using compiled UCI-LISP (I haven't tried it in compiled
MACLISP yet).
It is an unsolved problem how to find the canonical form
in fewer than k factorial recursive sorts; as far as I know
nobody has found a faster way to do it and nobody has proven it
impossible. A solution to the general problem of finding the
canonical numbering of vertices of a graph would have important
applications in Dendral (classifying molecules), Macsyma (finding
canonical forms for tensors and other formulas so that like terms
can be combined and their coefficients added), and of course
Sprouts and other game-playing programs that want to store away
situations they've already analyzed to avoid re-analyzing them
when an equivalent situation occurs under different circumstances.
I have some techniques that might minimize average-time, but
haven't fully checked them out.

7
src/games/stone.(init) Normal file
View File

@@ -0,0 +1,7 @@
(COMMENT)
(PROGN (LOAD '((dsk games) STONE FASL))
(setq errlist '((gc)
(stone-game)))
(STONE-GAME)
(VALRET '|:KILL/
| ) )

8
src/games/think.(init) Normal file
View File

@@ -0,0 +1,8 @@
;;; -*- LISP -*-
;;; Think-A-Dot Init file
(COMMENT)
(PROGN
(CLOSE (PROG2 T INFILE (INPUSH -1.)))
(LOAD '|DSK:games;THINK FASL|))

491
src/games/think.2 Normal file
View File

@@ -0,0 +1,491 @@
;;; -*- LISP -*-
;;; A B C
;;; D E
;;; F G H
(COND ((NOT (MEMQ 'CURSORPOS (STATUS FILEM TYO)))
(CURSORPOS 'A TYO)
(PRINC '|Sorry, THINK-A-DOT currently only works on display terminals.|)
(TERPRI TYO)
(QUIT)))
(SSTATUS RANDOM (APPLY '* (APPEND (STATUS DATE) (STATUS DAYTIME))))
(EVAL-WHEN (EVAL COMPILE)
(SSTATUS MACRO /# '(LAMBDA () ((LAMBDA (IBASE) (READ)) 2.))))
(EVAL-WHEN (EVAL COMPILE)
(DO ((C (TYI) (TYI))
(L () (CONS C L)))
((= C 31.) (SETQ LONG-RULES (MAKNAM (NREVERSE L))))))
Think-a-dot is sold as a children's game, but can be played by
people of all ages. It allows as much or as little planning as you want
to put into it.
The equipment needed is a plastic box with colored dots on the
side of it and 5 holes (three on top, one on each side), as shown on the
next screen. (Note: A well-designed think-a-dot simulator running on a PDP-10
may substitute for the plastic box.)
A B C
___ ___ ___
----------------------------
| |
| (A) (B) (C) |
| Blue Yellow Blue |
| |
| |
| (D) (E) |
| Yellow Yellow |
| |
| |
| (F) (G) (H) |
| Blue Yellow Blue |
| |
|| ||
P1 || || P2
------------------------------
Balls are dropped into the holes depending on which side of the
board they come out on, that player plays next. (It is deterministic
which side of the board they will come out on, as will be seen in a
minute).
When a ball falls into a hole, it will strike the dot just
below it, changing its color from blue to yellow or yellow to blue
as appropriate. Depending on the resulting color, the ball will then
fall to either the right or the left and strike the next dot below it.
When it reaches the bottom dot, it will roll out of the box and it will
be the player's turn whose side it rolled out on.
In this version of think we use "/" and "\" to represent the two
states of the `dots.' This makes it easier to tell what the internal
state of the machine is. If you are unsure of what happens when a ball
is dropped, play around with the game before starting a game.
For example, note that when you start with state 11111111 and then
drop a ball into "A" what happens is that it hits node "A" and falls to the
right (complementing "A"). It then hits node "D" and falls to the right
(complementing it) and finally hits "G" falling to the right (complementing
it).
If the ball falls out to the left or the right of node "F", or to
the left of node "G", it will be player 1's turn. If it falls to the
right of node "G" or either side of node "H" it will be player 2's turn.
If you get stuck, ask a 6-year-old or a mathemetician to help you.
(Note that this box can be viewed as a finite state machine with 256 states,
only 128 of which are reachable from any given state (parity of the
initial situation is a factor)). Good luck!

(EVAL-WHEN (EVAL COMPILE)
(DO ((C (TYI) (TYI))
(L () (CONS C L)))
((= C 31.) (SETQ SHORT-RULES (MAKNAM (NREVERSE L))))))
[A,B,C] will drop a ball in the hole above corresponding location.
For scored games... <CR> starts. "Q" quits. <LF> restarts game.
Just for fun... "R" randomize board (conserving parity). <Alt>
complements a single switch (reading a switch name). "^S" stores
the current state for later recall. "^R" recalls a previously
stored state. The characters "/", "\", "-", and "+" initialize
the board in various interesting ways.
And finally... "H" gives full documentation, "^Q" quits program.

(DEFUN -*-SHORT-RULES-*- MACRO (()) `',SHORT-RULES)
(DEFUN -*-LONG-RULES-*- MACRO (()) `',LONG-RULES)
(SETQ SHORT-RULES (-*-SHORT-RULES-*-) LONG-RULES (-*-LONG-RULES-*-))
(DEFUN LAMBDA MACRO (X) (LIST 'FUNCTION X))
(NOINTERRUPT T)
(DECLARE (*FEXPR *DROP *INIT)
(SPECIAL OBJECT-LIST PARITY-LIST
TTY-SPEC-INFO \ // MODE REMEMBER
SHORT-RULES LONG-RULES))
(SETQ OBJECT-LIST '(A B C D E F G H))
(SETQ PARITY-LIST '(A B C F G H))
(DEFPROP A (F . D) POINTER)
(DEFPROP B (D . E) POINTER)
(DEFPROP C (E . H) POINTER)
(DEFPROP D (F . G) POINTER)
(DEFPROP E (G . H) POINTER)
;;; Display locations
(DEFPROP A (2 . 6.) WHERE)
(DEFPROP B (2 . 10.) WHERE)
(DEFPROP C (2 . 14.) WHERE)
(DEFPROP D (4 . 8.) WHERE)
(DEFPROP E (4 . 12.) WHERE)
(DEFPROP F (6 . 6.) WHERE)
(DEFPROP G (6 . 10.) WHERE)
(DEFPROP H (6 . 14.) WHERE)
;;; State
(DEFUN *INIT FEXPR (DIR)
(COND ((INIT (CAR DIR))
(TERPRI TYO)
(PRINC '|(Initialized)| TYO)
(WASH))))
(DEFUN INIT (DIR)
(COND ((GET 'GAME 'BEING-PLAYED)
(TERPRI TYO)
(PRINC '|(Game in progress. Can't quit now!)| TYO)
())
(T
(LET ((STATE (CASEQ DIR (+ '\) (- '//))))
(MAPC (LAMBDA (X) (PUTPROP X STATE 'STATE))
OBJECT-LIST)
T))))
(INIT '+)
(DEFUN INVERT (X) (CDR (ASSQ X '((// . \) (\ . //)))))
(DEFUN STATE (X) (GET X 'STATE))
(DEFUN *COMPLEMENT (X)
(LET ((STATE (INVERT (STATE X))))
(PUTPROP X STATE 'STATE)
STATE))
(DEFUN COMPLEMENT FEXPR (X) (*COMPLEMENT (CAR X)))
(DEFUN DISPLAY ()
(CURSORPOS 0. 0. TYO)
(CURSORPOS 'L TYO)
(COND (MODE
(PRINC '|Score is | TYO)
(PRINC // TYO)
(PRINC '| to | TYO)
(PRINC \ TYO)
(PRINC '|. | TYO)
(PRINC MODE TYO))
(T
(PRINC '|State= | TYO)
(LET ((BASE 2.))
(MAPCAR 'PRINC
(EXTEND
(MAPCAR (FUNCTION (LAMBDA (X) (- X 48.)))
(EXPLODEN (SGET))))))))
(MAPC 'DISPLAY-STATE OBJECT-LIST)
(CURSORPOS 'A TYO)
(TERPRI TYO)
(COND ((GET 'GAME 'BEING-PLAYED)
(COND ((EQ (GET 'GAME 'WHOSE-TURN) '//)
(PRINC '| <- You play next.| TYO))
(T
(PRINC '| You play next. ->| TYO))))))
(DEFUN DISPLAY-STATE (X)
(LET (((H . V) (GET X 'WHERE))
(STATE (STATE X)))
(CURSORPOS H V TYO)
(PRINC X)
(CURSORPOS 'D TYO)
(CURSORPOS 'B TYO)
(PRINC '| | TYO)
(CURSORPOS 'B TYO)
(PRINC (OR (GET X STATE) STATE) TYO)))
(DEFUN PROMPT ()
(GAME-END-CHECK)
(DISPLAY)
(TERPRI TYO)
(TERPRI TYO)
(TYI TYI))
(DEFUN WASH () (CURSORPOS 'E TYO))
(DEFUN EXECUTE ()
(UNWIND-PROTECT (PROGN (TTY-OFF) (EXECUTE1)) (TTY-ON)))
(SETQ DIAMOND-1 #01011010)
(SETQ DIAMOND-2 #10100101)
(DEFUN EXECUTE1 ()
(CURSORPOS 'C TYO)
(DO ((C (PROMPT) (PROMPT)))
((= C 17.) (PRINC '|Quit.| TYO) (QUIT) T)
(COND ((OR (= C 65.) (= C 97.)) (*DROP A))
((OR (= C 66.) (= C 98.)) (*DROP B))
((OR (= C 67.) (= C 99.)) (*DROP C))
((OR (= C 82.) (= C 114.)) (*RANDOMIZE))
((OR (= C 81.) (= C 113.))
(TERPRI TYO)
(COND ((GET 'GAME 'BEING-PLAYED)
(TYO 7. TYO)
(SETQ MODE '|(Game Halted)|)
(REMPROP 'GAME 'BEING-PLAYED)
(PRINC '|(Game Halted)| TYO))
(T
(PRINC '|(No game to halt?)| TYO)))
(WASH))
((= C 92.) (*INIT +))
((= C 47.) (*INIT -))
((= C 43.)
(TERPRI TYO)
(COND ((NOT (GET 'GAME 'BEING-PLAYED))
(SRESET DIAMOND-2)
(PRINC '|(Diamond 2)| TYO))
(T
(PRINC '|(Game in progress?)| TYO)))
(WASH))
((= C 45.)
(TERPRI TYO)
(COND ((NOT (GET 'GAME 'BEING-PLAYED))
(SRESET DIAMOND-1)
(PRINC '|(Diamond 1)| TYO))
(T
(PRINC '|(Game in progress?)| TYO)))
(WASH))
((= C 12.) (CURSORPOS 'C TYO))
((= C 13.) (GAME-BEGIN))
((= C 10.) (GAME-RESTART))
((OR (= C 32.) (= C 9.)))
((= C 19.) (SREMEMBER))
((= C 18.) (SRECALL))
((= C 27.) (ALTER))
((OR (= C 63.) (= C 2120.))
(SHORT-RULES))
((OR (= C 72.) (= C 104.))
(LONG-RULES))
(T
(TYO 7. TYO)
(TERPRI TYO)
(PRINC '|(Type "?" for help)| TYO)
(WASH)))))
(DEFUN *DROP FEXPR (X)
(SETQ X (CAR X))
(TERPRI TYO)
(PRINC `(|Drop| ,X) TYO)
(WASH)
(DROP X))
(DEFUN DROP (X)
(LET* ((STATE (STATE X))
(POINTER (GET X 'POINTER))
(NEXT (CASEQ STATE (// (CAR POINTER)) (\ (CDR POINTER)))))
(*COMPLEMENT X)
(COND (NEXT (DROP NEXT))
((EQ X 'F) (DEFPROP GAME // WHOSE-TURN))
((EQ X 'G) (PUTPROP 'GAME STATE 'WHOSE-TURN))
(T (DEFPROP GAME \ WHOSE-TURN)))))
(DEFUN INIT-TURN ()
(PUTPROP 'GAME (COND ((MAYBE) '//) (T '\)) 'WHOSE-TURN))
(DEFUN ALTER ()
(COND ((NOT (GET 'GAME 'BEING-PLAYED))
(CURSORPOS NIL 0. TYO)
(CURSORPOS 'L TYO)
(PRINC '|Complement: | TYO)
(LET ((C (TYI TYI)))
(SETQ C (ASCII (COND ((AND (> C 96.) (< C 123.))
(SETQ C (- C 32.)))
(T C))))
(TERPRI TYO)
(COND ((MEMQ C OBJECT-LIST)
(*COMPLEMENT C)
(PRINC `(,C |has been complemented|) TYO))
(T
(PRINC `(|No node | ,C |... Request ignored|) TYO)))
(WASH)))
(T
(TERPRI TYO)
(PRINC '|(Game in progress. Don't try to cheat!)| TYO)
(WASH))))
(DEFUN MAYBE () (ZEROP (RANDOM 2.)))
(DEFUN *RANDOMIZE ()
(COND ((GET 'GAME 'BEING-PLAYED)
(TERPRI TYO)
(PRINC '|(Can't Randomize. Game in progress)| TYO))
(T
(RANDOMIZE)
(PARITY-CHECK)
(TERPRI TYO)
(PRINC '|(Randomized)| TYO)))
(WASH))
(DEFUN RANDOMIZE ()
(MAPC (LAMBDA (X) (COND ((MAYBE) (*COMPLEMENT X))))
OBJECT-LIST))
(SETQ MODE () // 0. \ 0.)
(DEFUN GAME-END-CHECK ()
(COND ((GET 'GAME 'BEING-PLAYED)
(DO ((S (STATE (CAR OBJECT-LIST)))
(X (CDR OBJECT-LIST) (CDR X)))
((NULL X)
(TYO 7. TYO)
(SET S (1+ (EVAL S)))
(SETQ MODE '|(Game Over)|)
(REMPROP 'GAME 'BEING-PLAYED))
(COND ((NOT (EQ S (STATE (CAR X))))
(RETURN ())))))))
(DEFUN GAME-BEGIN ()
(COND ((GET 'GAME 'BEING-PLAYED)
(TERPRI TYO)
(PRINC '|(Game already going?)| TYO))
(T
(SETQ MODE '|(Game in Progress)|)
(INIT-TURN)
(PUTPROP 'GAME T 'BEING-PLAYED)
(COND ((ZEROP (RANDOM 2.))
(SRESET DIAMOND-1))
(T
(SRESET DIAMOND-2)))
(PRINC '|(Game started)| TYO)
(WASH))))
(DEFUN GAME-RESTART ()
(COND ((GET 'GAME 'BEING-PLAYED)
(TERPRI TYO)
(PRINC '|(Game already going?)| TYO))
(T
(SETQ MODE '|(Game in Progress)|)
(PUTPROP 'GAME T 'BEING-PLAYED)
(PRINC '|(Game started)| TYO)
(WASH))))
(DEFUN PARITY-CHECK ()
(LET ((P PARITY-LIST))
(DO ((X P (CDR X))
(I 0.))
((NULL X)
(COND ((ODDP (+ I)) (*COMPLEMENT (NTH (RANDOM 6.) P)))))
(COND ((EQ (STATE (CAR X)) '//) (SETQ I (1+ I)))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;; TTY On/Off Functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; This section of code written by RWK.
;;; If this is the first time loading the file, save out info on tty
;;; initial specifications.
(COND ((NOT (BOUNDP 'TTY-SPEC-INFO))
(SETQ TTY-SPEC-INFO (SYSCALL 3. 'TTYGET TYI))))
;;; TTY-OFF
;;; Turns off automatic echo of input chars on the tty.
(DEFUN TTY-OFF ()
(SYSCALL 0 'TTYSET TYI
(BOOLE 1 (CAR TTY-SPEC-INFO) 3272356035.)
(BOOLE 1 (CADR TTY-SPEC-INFO) 3272356035.)))
;;; TTY-ON
;;; Re-enable automatic echo of input-chars on the tty.
(DEFUN TTY-ON ()
(SYSCALL 0 'TTYSET TYI
(CAR TTY-SPEC-INFO)
(CADR TTY-SPEC-INFO)))
(DEFUN SGET ()
(LET ((IBASE 2.))
(READLIST (APPEND (MAPCAR 'SGET1 OBJECT-LIST) '(32.)))))
(DEFUN SGET1 (X)
(COND ((EQ (STATE X) '//) '/0)
(T '/1)))
(DEFUN SRESET (X)
(LET ((BASE 2.))
(MAPC 'SRESET1
(EXTEND (MAPCAR (FUNCTION (LAMBDA (X) (- X 48.))) (EXPLODEN X)))
OBJECT-LIST)))
(DEFUN EXTEND (X)
(COND ((= (LENGTH X) (LENGTH OBJECT-LIST)) X)
(T (EXTEND (CONS 0. X)))))
(DEFUN SRESET1 (STATE OBJECT)
(PUTPROP OBJECT
(COND ((ZEROP STATE) '//)
(T '\))
'STATE))
(DEFUN SRECALL ()
(TERPRI TYO)
(COND ((NOT (GET 'GAME 'BEING-PLAYED))
(SRESET REMEMBER)
(PRINC '|(State Recalled)| TYO))
(T
(PRINC '|(Game in progress. Can't hack states.)| TYO)))
(WASH))
(DEFUN SREMEMBER ()
(TERPRI TYO)
(SETQ REMEMBER (SGET))
(PRINC '|(State Stored)| TYO)
(WASH))
(DEFUN SHORT-RULES ()
(PRINC SHORT-RULES TYO)
(WASH))
(DEFUN LONG-RULES ()
(CURSORPOS 'C TYO)
(*CATCH 'MORE-FLUSH
(PROGN
(DO ((I 1. (1+ I))
(END (FLATC LONG-RULES))
(C))
((> I END))
(SETQ C (GETCHARN LONG-RULES I))
(COND ((= C 12.)
(TERPRI TYO)
(CURSORPOS 'E TYO)
(CLEAR-INPUT TYI)
(PRINC '|--Type a Space to See More--| TYO)
(COND ((NOT (= (TYI TYI) 32.))
(*THROW 'MORE-FLUSH T)))
(CURSORPOS 0. 0. TYO))
((= C 13.)
(CURSORPOS 'L TYO)
(TYO C TYO))
(T
(TYO C TYO))))
(TERPRI TYO)
(PRINC '|--Pause--| TYO)
(CURSORPOS 'E TYO)
(TYI TYI)))
(CURSORPOS 'C TYO))
(DO ((I 0. (1+ I)))
((> I 127.))
(SSTATUS TTYINT I NIL))
(SSTATUS TOPLEVEL '(PROGN (CLEAR-INPUT TYI) (EXECUTE)))
(SETQ TTY-RETURN '(LAMBDA N (CURSORPOS 'C TYO)
(DISPLAY)
(TERPRI TYO)
(TERPRI TYO)))
(LET ((INIT-FILE (PROBEF `((DSK ,(STATUS HSNAME)) ,(STATUS USERID) THINK))))
(COND (INIT-FILE (LOAD INIT-FILE))))
(INIT '+)
(SETQ REMEMBER 0.)
(NOINTERRUPT NIL)

349
src/games/wa.(init) Normal file
View File

@@ -0,0 +1,349 @@
(comment)
(progn ;don't print out stuff
(princ '|Please wait while I get ready|)
(alloc '(REGPDL 120000.))
(alloc '(SPECPDL 48000.))
(alloc '(FIXPDL 24000.))
(alloc '(LIST 75000.))
(alloc '(SYMBOL 48000.))
(alloc '(FIXNUM 75000.))
(alloc '(FLONUM 75000.))
(alloc '(BIGNUM 12000.))
(alloc '(ARRAY 12000.))
(setsyntax '/
'/ '/ )
(defprop debug ((dsk rwk) debug fasl) autoload)
(defprop bt ((dsk rwk) debug fasl) autoload)
(setq *rset t)
;;; SC-HELP calls for human intervention when appropriate.
(defun g-*uwrite (name mode newdefault)
(DECLARE (SPECIAL UWRITE OUTFILES))
(cond (uwrite
(setq outfiles (delq uwrite outfiles))
(close uwrite)
(setq uwrite nil)))
((lambda (file)
(setq outfiles
(cons (setq uwrite file)
outfiles))
(car (defaultf newdefault)))
(open name mode)))
(DEFUN G-TERPRI NIL
(DECLARE (SPECIAL GV-CURSORPOS G-SILENT *SS-ACTIVE))
(SETQ GV-CURSORPOS 0.)
(COND ((AND G-SILENT
(OR *SS-ACTIVE
(NOT (CURSORPOS))
(= (CDR (CURSORPOS)) 0.)))
(SETQ ^W T)
(TYO 13.)
(SETQ ^W NIL))
(T (TYO 13.))))
(DEFUN SC-HELP (CAUSE)
(G-TSAY '(|****** This student's model is beyond my limitations. ******|))
(COND ((< SL-REPEAT 0.0)
(SETQ SL-REPEAT 0.9)
(SC-UPDATE-MODEL)))
(SETQ SC-NOTEST CAUSE))
(DEFUN GCI-CREATE NARGS
(CONS (ARG 1.)
(GCI-WCREATE (ARG 1.)
NIL
(COND ((> (ARG NIL) 1.) (ARG 2.))))))
;;; GCI-WCREATE does the actual work of WGI-CREAT.
(DEFUN GCI-WCREATE (NUM LIST VALS)
(COND ((< NUM 1.) (RPLACD (LAST LIST) LIST))
(T (GCI-WCREATE (1- NUM)
(CONS (GCI-VAL VALS) LIST)
(CDR VALS)))))
;;; GCI-VAL returns the appropriate value.
(DEFUN GCI-VAL (VALS) (COND ((ATOM VALS) NIL) (T (CAR VALS))))
(ENDPAGEFN TYO NIL)
(SETSYNTAX 46. 128. NIL)
(SETQ IBASE 10.
BASE 10.
*NOPOINT T
*SS-ACTIVE nil
*SS-VERSION NIL
WE-VERSION '|eight|
WEV-RECREATE NIL
WE-GAME-HIST NIL
DB-NUM-CRULES 6.
DB-NUM-RULES 19.
DB-NUM-PROP 7.
DB-NUM-DPROP 18.
DB-DATE 0.
WAV-TOLD-RULE NIL
CX-WHY-BETTER NIL
CX-WHY-WORSE NIL
EGV-PLURAL 'EGV-PLURAL
EGV-BECAUSE '(|, because|)
EG-SPEC 'EG-SPEC
SC-LREPEAT 0.0
SC-UREPEAT 5.0
SC-LFORGET 2.0
SC-UFORGET 30.0
LEG-THEREFORE (GCI-CREATE 3.
'((|, and so|)
(|. Therefore|)
(|. Hence|)))
LEG-ALSO (GCI-CREATE 3.
'((|. Also,|)
(|, and|)
(|. Likewise,|)))
LEG-CONVERSELY (GCI-CREATE 2.
'((|. Conversely,|)
(|. In contrast,|)))
LEG-HOWEVER (GCI-CREATE 2.
'((|. However|) (|, but|)))
LWA-TELL-C4 (GCI-CREATE 3.
'((LIST '|I don't know,|
DB-NAME
'|, but|)
(LIST '|Well,|
DB-NAME
'|, I think that|)
(LIST '|You know,|
DB-NAME
'|,|)))
LWAW-TELL-WANDER (GCI-CREATE 3.
'((LIST DB-NAME
'|, we seem to be going in circles|)
(LIST '|I seem to remember just|
'|coming from that cave,|
DB-NAME)
(LIST '|We seem to be wandering aimlessly,|
DB-NAME)))
G-DOUBLESPACE NIL
G-LAST 32.
G-BLAST 32.
G-BBLAST 46.
G-SILENT nil
G-READ-NUM 1.
GV-CURSORPOS 0.
XP-P12-CHANGED NIL
SC-INCREASE-FORGET NIL
SC-DECREASE-FORGET NIL
SC-INCREASE-REPEAT NIL
SC-DECREASE-REPEAT NIL
SF-VAR-LIST '(DB-UNAME DB-NAME
DB-LAST-DATE
DB-NUMWINS
DB-NUMLOSSES
DB-MOVES
DB-DEBUG
DB-COMMENT
SL-REPEAT
SL-FORGET
SL-RECEPTIVITY
SL-HEARD-OF
WA-CAN-BACKTRACK
WA-TOLD-BACKTRACK
WE-MOVE-NUM
SL-LAST-LEARNED
SC-INITIALIZED
SL-TUTOR
DB-GAME-NUM
DB-HISTORY))
(ARRAY ADB-CAVE T 1. DB-NUM-PROP)
(ARRAY ADB-DCAVE T 1. DB-NUM-DPROP 1.)
(ARRAY AEG-TELL-AVOID T 3. 3.)
(ARRAY ADB-TELL-WARNING T 3. 3.)
(ARRAY ADB-TELL-DANGER T 3. 3.)
(ARRAY ASK-WDRULES FIXNUM (1+ DB-NUM-RULES) 2. 3.)
(ARRAY ASK-DRULES FLONUM (1+ DB-NUM-RULES) 2. 3.)
(ARRAY AWE-EXPL-RULES T 16.)
(ARRAY ASL-PHASE-RULES T 5. 3.)
(ARRAY ASL-NEXT-RULES T 5. 3.)
(ARRAY ASL-PNUM-DANGERS T 5. 3.)
(ARRAY ASKC-RULES T 8. 3.)
(ARRAY AEG-NUMBER T 10.)
(MAPC (FUNCTION (LAMBDA (X) (*ARRAY X T 3.)))
'(AXS-CHANGED-SETS AEG-DANGER-SING AEG-DANGER-PLUR
ASL-WORK-ON-RULES AXR-FOUND-N AXS-EXACT-CAVES
AXS-PARTIAL-SETS AXS-COMPLETE-SETS
APS-RULE-ARRAY AEG-WARNING-PRES AEG-WARNING-PAST
ASC-INITIALIZED AEG-ENCOUNTER AWA-TOLD-RULES))
(MAPC (FUNCTION (LAMBDA (X) (*ARRAY X 'FIXNUM 3.)))
'(ADB-NUM-DANGERS ADB-WARNING-DIST AXR-NUM-IDENTIFIED
ASL-PHASE ADB-DIST-START))
(MAPC (FUNCTION (LAMBDA (X) (*ARRAY X 'FLONUM 3.)))
'(AXX-EST-NUM-DANGERS AXP-PROB12))
(MAPC (FUNCTION (LAMBDA (X Y)
(DECLARE (SPECIAL EGV-PLURAL))
(PUTPROP EGV-PLURAL Y X)))
'(|is cave| |is| |can| |could| |is rule|)
'(|are caves| |are| |can| |could| |are rules|))
(MAPC (FUNCTION (LAMBDA (X Y)
(DECLARE (SPECIAL EG-SPEC))
(PUTPROP EG-SPEC Y X)))
'(|were| |fell|)
'(|would have been| |would have fallen|))
(MAPC (FUNCTION (LAMBDA (X Y) (STORE (ASKC-RULES X 1.) Y)))
'(7. 6. 5. 4. 3. 2. 1. 0.)
'(0. 2. 1. 2. 0. 0. 0. 0.))
(MAPC (FUNCTION (LAMBDA (X A B C D E F G H I)
(STORE (ASL-PHASE-RULES X 0.) A)
(STORE (ASL-PHASE-RULES X 1.) B)
(STORE (ASL-PHASE-RULES X 2.) C)
(STORE (ASL-NEXT-RULES X 0.) D)
(STORE (ASL-NEXT-RULES X 1.) E)
(STORE (ASL-NEXT-RULES X 2.) F)
(STORE (ASL-PNUM-DANGERS X 0.) G)
(STORE (ASL-PNUM-DANGERS X 1.) H)
(STORE (ASL-PNUM-DANGERS X 2.) I)))
'(4. 3. 2. 1. 0.)
'((14.) (6. 10. 12. 13.) (4. 7. 11.) (0. 3. 5.) (1.))
'((14.) (6. 9. 10. 12. 13.) (4. 7. 11.) (0. 3. 5.)
(1.))
'((12. 13.) (6. 8. 9. 10. 11. 15.) (4. 7.)
(0. 2. 3. 5. 19.) (1.))
'((14.) (12. 13.) (4. 7. 11.) (3. 5.) (1.))
'((14.) (12. 13.) (4. 7. 11.) (3. 5.) (1.))
'((12. 13.) (11.) (4. 7.) (3. 5. 19.) (1.))
'(4. 3. 3. 2. 1.)
'(2. 3. 3. 2. 1.)
'(2. 1. 1. 1. 1.))
(MAPC (FUNCTION (LAMBDA (W A B C D E)
(STORE (ASL-PHASE W) 0.)
(STORE (ASL-WORK-ON-RULES W)
(ASL-PHASE-RULES 0. W))
(STORE (AEG-ENCOUNTER W) A)
(STORE (AEG-WARNING-PRES W) B)
(STORE (AEG-WARNING-PAST W) C)
(STORE (AEG-DANGER-SING W) D)
(STORE (AEG-DANGER-PLUR W) E)))
'(0. 1. 2.)
'((|were| |picked up by|) (|fell| |into|)
(|were| |eaten by|))
'((|hear squeaking|) (|feel a breeze|)
(|smell the Wumpus|))
'((|heard squeaking|) (|felt a breeze|)
(|smelled the Wumpus|))
'((|bats|) (|a pit|) (|the Wumpus|))
'((|bats|) (|pits|) (|the Wumpus|)))
(MAPC (FUNCTION (LAMBDA (X Y) (STORE (AEG-NUMBER X) Y)))
'(9. 8. 7. 6. 5. 4. 3. 2. 1. 0.)
'((|ten|) (|nine|) (|eight|) (|seven|) (|six|)
(|five|) (|four|) (|three|) (|two|) (|one|)))
(MAPC (FUNCTION (LAMBDA (X Y) (STORE (AWE-EXPL-RULES X) Y)))
'(15. 14. 13. 12. 11. 10. 9. 8. 7. 6. 5. 4. 3. 2. 1. 0.)
'((|P15, Shooting Principle, Whenever the probability of|
|the Wumpus being in a cave exceeds 0.25, it is safer to|
|shoot into the cave before visitng it. Hence, the more|
|likely it is that the Wumpus is in the cave, the less|
|likely it is that the player will be killed.|)
(|P14, Adjust For Multiple Evidence Principle, In cases|
|where P13 is applied, the other members of said|
|cave-set are less likely to contain the danger.|)
(|P13, Multiple Evidence Principle, if there is multiple|
|evidence that a given cave contains a danger (i.e. it|
|is a member of two cave-sets), then it is more likely|
|that the given cave contains the danger.|)
(|P12, Explain Away Evidence Principle, When it is noted|
|that there are two cave-sets, one of which is a subset|
|of the other, there is no evidence that those caves|
|in the superset and not in the subset whether or|
|not said caves contain a danger (as the caves in the|
|subset completely explain the warning) so the|
|probability is reduced to some consistent value.|)
(|P11, Equal Likelihood Principle, An estimation of|
|the probability for a given cave is 1N, where N|
|is the number of caves in the smallest cave-set|
|of which said cave is a member.|)
(|L10, Certain caves can be marked as "more than zero|
|away" based on consideration of the different|
|complete cave-sets and the number of dangers. |)
(|L9, If the player encountered a danger in a cave,|
|then the cave does not contain a danger of higher|
|priority, i.e. the Wumpus eats the player before|
|he can fall into a pit, and he will fall into a|
|pit before he is picked up by bats.|)
(|L8, When the algorithm is creating cave-sets and|
|it encounters a cave which would be N caves away|
|but which is also "more than N away", then that cave|
|can not have any contributions to the cave-set. |)
(|L7, If a cave is "more than (N-1) away" and|
|"less than (N+1) away", then it is "N away". |)
(|L6, If all of a caves neighbors are "more than|
|(N-1) away", then it can be marked "more than N away". |)
(|L5, If a cave is marked "more than N away" then all|
|of its neighbors can be marked as "more than (N-1) away". |)
(|L4, If a cave is visited and there is a warning,|
|then that cave is "less than (N-1) away". |)
(|L3, If a cave is visited and there is not a warning,|
|then that cave is "more than N away" where N|
|is the distance that the warning propagates. |)
(|L2, If the player shoots an arrow into a cave|
|and does not kill the Wumpus, then that cave can|
|be marked as "more than zero away" (Wumpus). |)
(|L1, A cave can be marked as "more than zero|
|away" if it was safely visited. |)
(|L0, A cave can be marked as "zero away" if it|
|was visited and found to contain a danger. |)))
;;; The other dangers are set when it is known how many there are.
(MAPC (FUNCTION (LAMBDA (W A X Y Z)
(STORE (AEG-TELL-AVOID W Z) A)
(STORE (ADB-TELL-WARNING W Z) X)
(STORE (ADB-TELL-DANGER W Z) Y)))
'(0. 1. 2. 0. 1. 2. 0. 1. 2.)
'((APPEND '(|it is not wise to visit caves with bats|
|because while THEY will not harm us|
|they will carry us to another cave which|
|could contain|) (AEG-DANGER-SING 1.) '(|or|) (AEG-DANGER-SING 2.))
(APPEND
'(|we should avoid bats because they|
|could drop us in a cave with|)
(AEG-DANGER-SING 1.)
'(|or|)
(AEG-DANGER-SING 2.))
'(|it is best to avoid bats as they could carry us to a fatal cave|)
(APPEND '(|we should try not to stumble into|)
(AEG-DANGER-SING 1.)
'(|as it would be fatal|))
'(|we should avoid pits as they are fatal|)
'(|pits are dangerous as falling into one is fatal|)
(APPEND '(|it is best to avoid|)
(AEG-DANGER-PLUR 2.)
'(|as|)
(AEG-DANGER-PLUR 2.)
'(|eats unwary players who stumble into his lair|))
'(|we should avoid Wumpii as they eat unwary players|)
'(|Wumpii are dangerous as they have insatiable|
|appetites for bumbling players|))
'((|Squeak. I hear bats, they must be in one of the neighboring caves. |)
(|Squeak. I hear bats. |) (|Squeak. |)
(|Brrrr. I feel a breeze! We must be next to a pit. |)
(|Brrrr. I feel a breeze. |) (|Brrrr. |)
(|Whew, what a stench! That is the smell of the Wumpus. |
|It means that we are within two caves of the Wumpus. |)
(|What a stench! The Wumpus is near. |)
(|What a stench! |))
'((|Bon Voyage! We have been picked up by bats! |)
(|Bon Voyage! Bats have picked us up. |)
(|Bon Voyage! |)
(|So Loonnngggggggg. We have fallen into a pit. |)
(|So Loonnngggggggg. We have fallen in a pit. |)
(|So Loonnngggggggg. |)
(|Oh no, the Wumpus is in here! Chomp Chomp Chomp. |)
(|Oh no, it's the Wumpus! Chomp Chomp Chomp. |)
(|Chomp Chomp Chomp. |))
'(0. 0. 0. 1. 1. 1. 2. 2. 2.))
(terpri)
(load '((dsk games) wa fasl))
(princ '|thanks for waiting, we are about to begin|)
(restart))

6901
src/games/wa.10 Normal file
View File

File diff suppressed because it is too large Load Diff

703
src/games/wa.plyrs8 Normal file
View File

@@ -0,0 +1,703 @@
(((((0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.84 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0)) (0.0 0.0 0.0 0.0 0.0 0.0 0.0)) (DARTH VADER)
|Darth| 138 0 0 0 NIL NIL 1.13680507 7.81603 6.0 0.136805072
1.63680507 NIL 4 0 (NIL NIL NIL) T NIL NIL) ((((0.0 0 0.0 0)
(3.56623667 5 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (3.56623667 5 0.0 0) (0.0 0
0.0 0) (1.0 0 3.0 5) (0.0 0 0.0 0) (1.0 0 3.0 5) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 3 0.0 0) (0.0 0 0.0 0)) ((0.0 0
0.0 0) (3.56623667 5 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 7) (0.0 0
0.0 0) (1.0 0 1.0 7) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 1 0.0 0) (1.0 0 1.0 7)) (1.0 0.0 0.0 0.0 0.0 0.0 0.0)) (ERIC SWENSON)
|Eric| 127 0 1 10 NIL NIL 1.06623666 8.3333305 6.0 0.06623666
4.5662367 NIL 8 5 (A 5 7) T NIL (0)) ((((0.0 0 0.0 0) (27.5895429 5
0.0 0) (0.0 0 0.0 0) (5.58954275 5 1.0 15) (1.0 0 0.0 0) (5.58954275 5
1.0 15) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (1.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 1 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (15.5895427 5 0.0 0) (0.0 0 0.0 0)
(5.58954275 6 0.0 0) (1.0 0 0.0 0) (5.58954275 6 0.0 0) (0.0 0
0.0 0) (1.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(1.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (14.5895427 5 0.0 0) (0.0 0 0.0 0) (1.58954272 8
0.0 0) (1.0 0 1.0 10) (1.58954272 8 0.0 0) (0.0 0 0.0 0) (1.0 0
1.0 10) (1.0 0 1.0 10) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.58954272 8 0.0 0)) (4.0
1.0 1.0 0.0 1.0 1.0 0.0)) (HOWARD CANNON) |Howard| 59 1 2 34 NIL NIL
1.08954272 8.155075 4.0 0.089542717 10.5895427 NIL 25 8 (15 21 10) T NIL (0 0
1)) ((((0.0 0 0.0 0) (11.0 0 11.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (11.0 0 11.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (11.0 0 11.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0)) (2.0 0.0 0.0 0.0 0.0 0.0 0.0)) (JOHN FIX) |John|
315 0 0 0 NIL NIL 1.08507021 8.1886891 6.0 0.085070208 1.58507021 NIL 4 0
(NIL NIL NIL) T NIL NIL) ((((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) (0.0 0.0 0.0
0.0 0.0 0.0 0.0)) (ROGER SLYK) |Roger| 300 0 0 0 NIL T 1.08954272
8.155075 6.0 0.089542717 0.58954272 NIL 4 0 (NIL NIL NIL) T NIL NIL)
((((1.0 0 1.0 0) (34.0 0 34.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)) ((1.0 0 1.0 0) (34.0 0 34.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (2.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0)
(1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (34.0 0 34.0 0) (0.0 0 0.0 0) (5.0 0 5.0 0) (4.0 0
4.0 0) (5.0 0 5.0 0) (0.0 0 0.0 0) (4.0 0 4.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 2 0.0 0) (3.0 0 3.0 0)) (2.0 1.0 1.0 0.0 0.0 4.0 0.0)) (FOO BAR) |Foo|
275 0 3 0 NIL NIL 1.01096886 8.7888983 6.0 0.010968864 1.51096886 NIL 8 0
(NIL NIL NIL) T NIL (0 0 0)) ((((0.0 0 0.0 0) (12.0 0 11.0 0)
(0.0 0 0.0 0) (1.0 0 2.0 0) (0.0 0 0.0 0) (1.0 0 2.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (12.0 0 11.0 0) (0.0 0 0.0 0) (0.65710546 10 2.0 0)
(0.0 0 0.0 0) (0.65710546 10 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (12.0 0
11.0 0) (0.0 0 0.0 0) (1.0 0 2.0 0) (0.0 0 0.0 0) (1.0 0 2.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(1.0 0 1.0 6) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (1.0 0
2.0 0)) (3.0 0.0 0.0 0.0 1.0 0.0 0.0)) (DAVID P) |David| 227 0 1 8 NIL NIL
1.15710546 7.67890465 9.0 0.15710546 2.65710548 NIL 14 5 (B 10 B) T NIL (0))
((((1.0 0 1.0 0) (35.0 0 34.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)) ((1.0 0 1.0 0) (35.0 0 34.0 0)
(0.0 0 0.0 0) (1.0 0 3.0 0) (2.0 0 2.0 0) (1.0 0 3.0 0) (0.0 0
0.0 0) (2.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0)
(1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 3 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (35.0 0 34.0 0) (0.0 0 0.0 0) (6.0 0 5.0 0) (5.0 0
4.0 0) (6.0 0 5.0 0) (0.0 0 0.0 0) (5.0 0 4.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 2 0.0 0) (3.0 0 3.0 0)) (2.0 1.0 1.0 0.0 0.0 5.0 0.0)) (ROBERT KERNS)
|Robert| 185 0 1 7 NIL NIL 1.02740864 8.6482654 8.0 0.0274086446
2.52740866 NIL 10 0 (NIL B NIL) T NIL (0)) ((((2.0 59 1.0 0)
(169.0 0 34.0 0) (0.0 0 0.0 0) (3.0 22 2.0 0) (2.0 0 2.0 0)
(5.0 22 2.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (2.0 0 2.0 0) (1.0 55 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3
0.0 0) (0.0 0 0.0 0)) ((1.0 59 1.0 0) (153.0 0 34.0 0) (0.0 0
0.0 0) (0.53058654 103 3.0 0) (0.36058645 102 3.0 0) (0.53058654 103
3.0 0) (0.0 0 0.0 0) (1.0 0 3.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(1.0 0 2.0 0) (1.0 101 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (155.0 0 34.0 0) (0.0 0 0.0 0)
(1.0 0 6.0 0) (8.0 0 4.0 0) (1.0 0 6.0 0) (0.0 0 0.0 0) (8.0 0
10.0 0) (3.0 30 6.0 9) (0.0 0 0.0 0) (2.0 30 2.0 26) (2.0 81
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 81 0.0 0)
(0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3 0.0 0) (0.0 101 4.0 0)) (9.0
3.0 3.0 1.0 0.0 6.0 0.0)) (BOB KERNS) |Bob| 173 5 17 204 T T
0.69058645 7.8594385 15.0 -0.30941355 41.530587 NIL 119 81 (22 60 30) T NIL
(0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1)) ((((2.5623142 40
1.0 0) (163.0 0 34.0 0) (0.0 0 0.0 0) (21.5623143 19 1.0 0)
(20.0 0 2.0 0) (21.5623143 19 1.0 0) (0.0 0 0.0 0) (18.0 0 2.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (15.5623143 29 1.0 0)
(4.5623142 71 0.0 0) (7.5623142 35 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0))
((2.5623142 40 1.0 0) (134.0 0 34.0 0) (0.0 0 0.0 0) (10.5623143 20
1.0 0) (4.0 0 2.0 0) (10.5623143 20 1.0 0) (0.0 0 0.0 0) (20.0 0
2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (17.5623143 29
1.0 0) (1.5623142 71 0.0 0) (2.5623142 35 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (141.0 0 34.0 0) (0.0 0 0.0 0) (21.0 0
6.0 0) (17.0 0 4.0 0) (21.0 0 6.0 0) (0.0 0 0.0 0) (17.0 0 5.0 0)
(11.0 13 1.0 9) (0.0 0 0.0 0) (1.0 0 0.0 0) (8.0 17 0.0 0) (0.0 0
0.0 0) (2.0 87 0.0 0) (0.0 0 0.0 0) (10.0 17 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0) (0.0 3 0.0 0) (8.0 0 4.0 0)) (15.0 17.0 11.0 1.0
0.0 7.0 0.0)) (MARK STILES) |Mark| 156 10 6 199 NIL T 1.0623142
8.3641003 5.0 0.062314197 55.5623145 NIL 121 87 (13 A A) NIL NIL (1 0 1 1 1 0
1 1 1 0 0 1 0 0 1 1)) ((((0.0 0 0.0 0) (22.0 0 11.0 0) (0.0 0
0.0 0) (1.55659358 7 1.0 0) (0.0 0 0.0 0) (1.55659358 7 1.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (22.0 0 11.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (22.0 0 11.0 0)
(0.0 0 0.0 0) (1.55659358 11 1.0 0) (0.0 0 0.0 0) (1.55659358 11
1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(1.0 0 1.0 0)) (4.0 0.0 0.0 0.0 1.0 0.0 0.0)) (DAVE ANDERSON) |Dave| 155 1 0
25 NIL T 1.05659358 8.4093853 5.0 0.056593582 4.5565936 NIL 18 11 (A NIL A)
T NIL (1)) ((((7.5338274 41 0.0 0) (107.0 0 11.0 0) (0.0 0 0.0 0)
(31.5338275 5 1.0 0) (12.5338274 37 0.0 0) (31.5338275 5 1.0 0)
(0.0 0 0.0 0) (10.5338274 37 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(5.5338274 66 0.0 0) (6.5338274 37 0.0 0) (0.0 0 0.0 0) (1.53382736 78
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0)) ((2.53382736 41 0.0 0) (86.0 0 11.0 0)
(0.0 0 0.0 0) (12.5338274 12 1.0 0) (3.53382736 37 0.0 0) (12.5338274 12
1.0 0) (0.0 0 0.0 0) (12.5338274 37 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (6.5338274 66 0.0 0) (7.5338274 37 0.0 0) (0.0 0 0.0 0)
(1.53382736 78 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0)
(0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (83.0 0
11.0 0) (0.0 0 0.0 0) (4.5338274 12 1.0 0) (1.0 0 1.0 50) (4.5338274 12
1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 50) (1.0 0 1.0 50) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(2.53382736 31 1.0 0)) (25.0 6.0 11.0 0.0 0.0 1.0 0.0)) (LARRY ALLEN) |Larry|
153 10 6 161 NIL T 1.03382736 8.5945709 6.0 0.033827364 40.533828 NIL 108 78
(A A 50) T NIL (1 0 1 0 0 1 0 1 0 1 1 0 1 1 1 1)) ((((0.0 0 0.0 0)
(3.5702502 7 0.0 0) (0.0 0 0.0 0) (1.0 0 2.0 7) (0.0 0 0.0 0)
(1.0 0 2.0 7) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 2
0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (3.5702502 7 0.0 0) (0.0 0
0.0 0) (1.0 0 1.0 15) (0.0 0 0.0 0) (1.0 0 1.0 15) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0)) ((0.0 0
0.0 0) (3.5702502 7 0.0 0) (0.0 0 0.0 0) (1.0 0 2.0 9) (0.0 0
0.0 0) (1.0 0 2.0 9) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (1.0 0 2.0 9)) (1.0 0.0 0.0 0.0 0.0 0.0 0.0)) (DAN TAPPAN)
|Dan| 170 1 2 15 NIL NIL 1.07025018 8.30208 5.0 0.070250183 4.5702502 NIL 20
7 (7 15 9) T NIL (1 0 0)) ((((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) (0.0 0.0 0.0
0.0 0.0 0.0 0.0)) (RICK MILLER) |Rick| 164 0 0 0 NIL NIL 1.0850702
8.188689 6.0 0.085070205 0.58507021 NIL 4 0 (NIL NIL NIL) T NIL NIL)
((((0.0 0 0.0 0) (3.5807073 5 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (3.5807073 5
0.0 0) (0.0 0 0.0 0) (1.58070727 5 0.0 0) (0.0 0 0.0 0) (1.58070727 5
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (3.5807073 5 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) (1.0 0.0 0.0
0.0 0.0 0.0 0.0)) (ROB FRYE) |Rob| 158 1 1 14 NIL T 1.08070727
8.2217478 6.0 0.080707266 3.5807073 NIL 16 5 (A A A) T NIL (0 1))
((((1.0 0 1.0 0) (108.0 0 34.0 0) (0.0 0 0.0 0) (6.5305865 7
1.0 0) (5.0 0 2.0 0) (6.5305865 7 1.0 0) (0.0 0 0.0 0) (4.0 0
2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (2.5305865 9
1.0 0) (0.0 0 0.0 0) (1.53058647 34 1.0 18) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0))
((1.0 0 1.0 0) (72.0 0 34.0 0) (0.0 0 0.0 0) (3.5305865 7 1.0 0)
(3.0 0 2.0 0) (3.5305865 7 1.0 0) (0.0 0 0.0 0) (5.0 0 2.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (3.5305865 9 1.0 0)
(0.0 0 0.0 0) (1.53058647 34 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)) ((0.0 0
0.0 0) (75.0 0 34.0 0) (3.0 24 1.0 24) (10.0 0 5.0 0) (8.0 0
4.0 0) (10.0 0 5.0 0) (0.0 0 0.0 0) (8.0 0 6.0 0) (5.0 12 2.0 8)
(0.0 0 0.0 0) (2.0 32 1.0 24) (4.0 25 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (4.0 25 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 2 0.0 0) (4.0 0 3.0 0)) (7.0 3.0 2.0 0.0 0.0 4.0 0.0)) (DAVE RED) |Dave|
156 4 0 71 NIL NIL 1.03058647 8.6215984 6.0 0.030586466 18.5305865 NIL 43 34
(18 A 12) T NIL (1 1 1 1)) ((((0.0 0 0.0 0) (11.0 0 11.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (11.0 0 11.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (11.0 0 11.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0))
(2.0 0.0 0.0 0.0 0.0 0.0 0.0)) (AL WEGER) A/l 310 0 0 0 NIL NIL
1.28187819 6.9314718 6.0 0.28187819 1.78187819 NIL 4 0 (NIL NIL NIL) T NIL
NIL) ((((1.0 0 1.0 0) (35.0 0 34.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)) ((1.0 0 1.0 0) (35.0 0 34.0 0)
(0.0 0 0.0 0) (1.0 0 3.0 0) (2.0 0 2.0 0) (1.0 0 3.0 0) (0.0 0
0.0 0) (2.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0)
(1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 3 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (35.0 0 34.0 0) (0.0 0 0.0 0) (4.0 0 6.0 0) (4.0 0
4.0 0) (4.0 0 6.0 0) (0.0 0 0.0 0) (4.0 0 4.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 3 0.0 0) (2.0 0 4.0 0)) (2.0 1.0 1.0 0.0 0.0 4.0 0.0)) (STEPHEN WRIGHT)
|Stephen| 299 1 0 8 NIL NIL 1.11373001 7.97796816 6.0 0.113730013
2.61373 NIL 9 0 (NIL B B) T NIL (1)) ((((0.0 0 0.0 0) (41.0 0
11.0 0) (0.0 0 0.0 0) (1.11711437 6 4.0 0) (1.84 0 0.0 0) (0.84 6
4.0 0) (0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (38.0 0 11.0 0) (0.0 0 0.0 0)
(3.0 0 1.0 0) (2.84 0 0.0 0) (3.0 0 1.0 0) (0.0 0 0.0 0) (2.84 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.84 0 0.0 0) (0.84 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0)
(36.0 0 11.0 0) (0.0 0 0.0 0) (2.0 0 1.0 0) (0.84 0 0.0 0) (2.0 0
1.0 0) (0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(1.0 0 1.0 0)) (5.0 1.0 0.0 1.0 0.0 1.0 0.0)) (SAM LEWIS) |Sam| 241 1 0 13
NIL NIL 1.61711437 5.4945418 7.0 0.617114365 4.11711437 NIL 12 0 (B NIL NIL)
T NIL (1)) ((((0.0 0 0.0 0) (13.0 0 11.0 0) (0.0 0 0.0 0) (1.0 0
1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (13.0 0
11.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (13.0 0 11.0 0) (1.0 0 1.0 9) (1.0 0 1.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 9) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)) (2.0 0.0 0.0 0.0 1.0 0.0
0.0)) (ROBERT ABRAMSON) |Robert| 227 1 0 7 NIL NIL 1.15710546
7.67890465 6.0 0.15710546 3.65710548 NIL 11 0 (NIL NIL B) T NIL (1))
((((0.0 0 0.0 0) (2.4922531 7 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (2.4922531 7
0.0 0) (0.0 0 0.0 0) (1.4922531 7 0.0 0) (0.0 0 0.0 0) (1.4922531 7
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (2.4922531 7 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) (1.0 0.0 0.0
0.0 0.0 0.0 0.0)) (DAVID SPEAR) |David| 176 1 0 7 NIL T 0.99225309
8.9546736 6.0 -7.74691254E-3 1.4922531 NIL 10 7 (A A A) T NIL (1))
((((6.0 709 0.0 0) (922.88124 6 0.0 0) (0.0 0 0.0 0) (89.88124 6
1.0 720) (37.63674 290 0.0 0) (89.88124 6 1.0 720) (0.0 0 0.0 0)
(19.636739 290 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.91229226 795
1.0 795) (31.6367395 290 1.0 660) (1.0 0 0.0 0) (18.6367393 364
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(0.0 3 0.0 0) (0.0 0 0.0 0)) ((1.0 720 0.0 0) (495.88123 6 0.0 0)
(0.0 0 0.0 0) (88.30895 119 0.0 -1) (37.549032 337 0.0 0) (88.30895 119
0.0 -1) (0.0 0 0.0 0) (37.549032 337 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (1.91229226 720 0.0 0) (32.549032 337 0.0 0) (0.0 0 0.0 0)
(7.6367392 364 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0)
(0.0 2 0.0 0) (0.0 3 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (553.88123 6
0.0 0) (17.308948 247 0.0 0) (110.30894 69 3.3089479 623) (106.30894 75
0.0 0) (110.30894 69 3.3089479 623) (8.308948 254 0.0 0) (106.30894 75
0.0 0) (68.30895 112 0.0 0) (0.0 -1 0.0 0) (3.0 753 0.0 0) (53.3089485 88
0.0 0) (0.0 0 0.0 0) (10.308948 254 0.0 0) (0.0 0 0.0 0) (70.30895 88
1.0 796) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3 0.0 0) (29.308948 225
4.3089479 23)) (84.30895 35.63674 13.308948 1.11411278 0.0 32.3089485
0.114112772)) (BRADFORD MILLER) |Bradford| 164 85 48 1179 NIL T
1.41229226 6.3116903 -4.0 0.41229226 278.0 NIL 841 753 (408 119 443) T 12 (1
1 1 0 0 0 1 1 1 1 1 0 0 1 1 1 1 0 1 1 1 1 0)) ((((0.0 0 0.0 0)
(437.78307 5 0.0 0) (0.0 0 0.0 0) (27.7830713 30 0.0 0) (1.0 0
1.0 0) (27.7830713 30 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (235.78307 5
0.0 0) (0.0 0 0.0 0) (33.7830715 5 0.0 0) (1.0 0 0.0 0) (33.7830715 5
0.0 0) (0.0 0 0.0 0) (1.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (1.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (235.78307 5 0.0 0) (0.0 0 0.0 0)
(8.7830713 9 0.0 0) (3.78307113 174 0.0 0) (8.7830713 9 0.0 0)
(0.0 0 0.0 0) (3.78307113 174 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(2.78307113 133 0.0 0)) (26.0 1.0 3.0 0.0 0.0 2.0 0.0)) (SYNDI 2PHASE)
|Syndi| 0 4 17 412 NIL T 2.28307113 3.8918203 14.0 1.28307113
55.0 NIL 207 174 (A A 176) T NIL (0)) ((((2.78307113 77 0.0 0)
(130.78307 5 0.0 0) (0.0 0 0.0 0) (21.7830713 14 0.0 0) (8.7830713 70
0.0 0) (21.7830713 14 0.0 0) (0.0 0 0.0 0) (3.78307113 70 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (3.78307113 77 0.0 0) (6.7830712 70
0.0 0) (1.0 0 0.0 0) (4.7830712 97 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
((2.78307113 77 0.0 0) (92.78307 5 0.0 0) (0.0 0 0.0 0) (24.7830713 5
0.0 0) (8.7830713 70 0.0 0) (24.7830713 5 0.0 0) (0.0 0 0.0 0)
(8.7830713 70 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (3.78307113 77
0.0 0) (6.7830712 70 0.0 0) (1.0 0 1.0 0) (4.7830712 97 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (95.78307 5 0.0 0) (4.7830712 106
0.0 0) (21.7830713 10 0.0 0) (15.7830713 38 0.0 0) (21.7830713 10
0.0 0) (4.7830712 106 0.0 0) (15.7830713 38 0.0 0) (8.7830713 45
0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (8.7830713 45 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (8.7830713 45 0.0 0) (0.0 2
0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (8.7830713 35 0.0 0)) (17.0
5.0 3.0 0.0 0.0 7.0 0.0)) (SYNDI 3PHASE) |Syndi| 0 17 9 177 NIL T
2.28307113 3.8918203 13.0 1.28307113 37.0 NIL 153 138 (82 149 A) T NIL (0))
((((0.0 0 0.0 0) (79.0 0 79.0 0) (0.0 0 0.0 0) (7.0 0 7.0 0)
(3.0 0 3.0 0) (7.0 0 7.0 0) (0.0 0 0.0 0) (3.0 0 3.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (3.0 0 3.0 0) (1.0 0 1.0 0)
(1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)) ((1.0 0 1.0 0) (79.0 0 79.0 0)
(0.0 0 0.0 0) (7.0 0 7.0 0) (3.0 0 3.0 0) (7.0 0 7.0 0) (0.0 0
0.0 0) (3.0 0 3.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(3.0 0 3.0 0) (1.0 0 1.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (79.0 0 79.0 0) (0.0 0 0.0 0) (10.0 0 10.0 0)
(8.0 0 8.0 0) (10.0 0 10.0 0) (0.0 0 0.0 0) (8.0 0 8.0 0) (2.0 0
2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (3.0 0 3.0 0)) (11.0 3.0 1.0 0.0 1.0 6.0
1.0)) EXPERT NIL 0 0 0 0 NIL NIL 0.34 5000.0 4.0 0.0 1.0 T 1 1 (NIL NIL
NIL)) ((((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0)) (0.0 0.0 0.0 0.0 0.0 0.0 0.0)) SUPER NIL 0 0 0 0
NIL NIL 0.34 5000.0 2.0 0.0 1.0 T 1 1 (NIL NIL NIL)) ((((5.7830713 0
0.0 0) (352.78307 0 0.0 0) (0.0 0 0.0 0) (57.7830715 0 5.0 233)
(3.7830713 0 0.0 0) (57.7830715 0 5.0 233) (0.0 0 0.0 0) (1.78307128 427
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.7830712 427 1.0 0) (5.7830713 0
8.0 265) (1.61307114 424 1.0 0) (1.78307113 423 5.0 229) (1.61307114 423
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3 0.0 0)
(0.0 0 0.0 0)) ((2.78307113 0 0.0 0) (350.78307 0 0.0 0) (0.0 0
0.0 0) (70.78307 0 0.0 0) (23.7830713 0 0.0 0) (70.78307 0 0.0 0)
(0.0 0 0.0 0) (23.7830713 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(2.7830712 264 0.0 0) (24.7830713 0 0.0 0) (2.78307113 0 0.0 0)
(2.78307113 0 0.0 0) (2.78307113 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0)
(361.78307 0 0.0 0) (0.0 0 0.0 0) (51.7830715 0 0.0 0) (30.7830715 0
0.0 0) (51.7830715 0 0.0 0) (7.7830712 0 0.0 0) (30.7830715 0
0.0 0) (3.78307113 378 0.0 0) (0.0 0 0.0 0) (1.78307113 184 0.0 0)
(1.7830713 431 0.0 0) (1.0 0 0.0 0) (6.7830712 0 0.0 0) (0.0 0
0.0 0) (6.7830713 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (30.7830715 0 0.0 0)) (65.0 28.0 11.0 1.0 0.0 21.0 0.0)) (SYNDI
BACK1) |Syndi| 0 24 22 723 NIL T 2.11307114 2.8973233 8.0 1.11307114
154.0 NIL 435 398 (257 NIL 359)) ((((17.0 149 1.0 109) (829.0 3
1.0 3) (0.0 0 0.0 0) (212.0 12 0.0 0) (90.0 73 1.0 59) (212.0 12
0.0 0) (0.0 0 0.0 0) (58.0 73 2.0 59) (0.0 0 0.0 0) (0.0 0 0.0 0)
(23.0 163 1.0 109) (67.0 73 1.0 59) (1.0 0 0.0 0) (17.0 150 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 1
0.0 0) (0.0 0 0.0 0)) ((7.0 149 0.0 0) (708.0 3 1.0 3) (0.0 0
0.0 0) (214.0 12 1.0 9) (91.0 73 0.0 0) (214.0 12 1.0 9) (0.0 0
0.0 0) (91.0 73 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (23.0 163
0.0 0) (68.0 73 0.0 0) (0.0 0 0.0 0) (7.0 150 1.0 136) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (762.0 3 1.0 3) (13.0 134 1.0 134)
(149.0 15 2.0 4) (118.0 91 1.0 36) (149.0 15 2.0 4) (7.0 319
0.0 0) (118.0 91 6.0 36) (86.0 99 6.0 36) (0.0 0 0.0 0) (13.0 227
3.0 215) (76.0 110 4.0 295) (0.0 0 0.0 0) (5.0 290 0.0 0) (0.0 0
0.0 0) (81.0 110 1.0 686) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 1
0.0 0) (42.0 33 2.0 4)) (168.0 49.0 52.0 5.0 0.0 33.0 1.0)) (SYNDI LEARN)
|Syndi| 0 91 42 1557 NIL T 1.17 5.0 -16.0 0.17 343.84 0.0 1083 319 (3 3 3) T
NIL (1 0 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 0 0 0 1 1 1 0 0 0 1 1 1 1 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 1 1 0 1 0 1 1 0 1 0
1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 0 1 0 1 1 1 0 1 1 1 0 0 1 1 0 0 0 0 0 1 1 1 0 0
1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0)) ((((1.0 0 1.0 0) (34.0 0
34.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (2.0 0 2.0 0) (1.0 0 1.0 0)
(0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0
2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0)) ((1.0 0 1.0 0) (34.0 0 34.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (34.0 0 34.0 0)
(0.0 0 0.0 0) (5.0 0 5.0 0) (4.0 0 4.0 0) (5.0 0 5.0 0) (0.0 0
0.0 0) (4.0 0 4.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (3.0 0 3.0 0))
(2.0 1.0 1.0 0.0 0.0 4.0 0.0)) ADVANCED NIL 0 0 0 0 NIL NIL 0.34
5000.0 4.0 0.0 1.0 T 1 1 (NIL NIL NIL)) ((((0.0 0 0.0 0) (35.0 0
11.0 0) (0.0 0 0.0 0) (1.84 0 2.0 0) (1.84 0 0.0 0) (1.84 0 2.0 0)
(0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (33.0 0 11.0 0) (0.0 0 0.0 0) (3.0 0 1.0 0)
(2.84 0 0.0 0) (3.0 0 1.0 0) (0.0 0 0.0 0) (2.84 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (1.84 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (31.0 0 11.0 0)
(0.0 0 0.0 0) (2.0 0 1.0 0) (0.84 0 0.0 0) (2.0 0 1.0 0) (0.0 0
0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0))
(4.0 1.0 0.0 1.0 0.0 1.0 0.0)) MODERATE NIL 0 0 0 0 NIL NIL 0.34
5000.0 4.0 0.0 1.0 T 1 1 (NIL NIL NIL)) ((((0.0 0 0.0 0) (11.0 0
11.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (11.0 0 11.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (11.0 0 11.0 0)
(0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0))
(2.0 0.0 0.0 0.0 0.0 0.0 0.0)) AMATEUR NIL 0 0 0 0 NIL NIL 0.34
5000.0 4.0 0.0 1.0 T 1 1 (NIL NIL NIL)) ((((0.0 0 0.0 0) (0.84 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.84 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
(0.0 0.0 0.0 0.0 0.0 0.0 0.0)) NOVICE NIL 0 0 0 0 NIL NIL 0.34
5000.0 4.0 0.0 0.0 NIL 0 0 (NIL NIL NIL)) ((((0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
(0.0 0.0 0.0 0.0 0.0 0.0 0.0)) BEGINNER NIL 0 0 0 0 NIL NIL 0.34
5000.0 4.0 0.0 0.0 NIL 1 1 (NIL NIL NIL)) ((((6.7830712 137 0.0 0)
(386.78307 5 0.0 0) (0.0 0 0.0 0) (79.78307 10 0.0 0) (27.7830713 88
0.0 0) (79.78307 10 0.0 0) (0.0 0 0.0 0) (22.7830713 88 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (8.7830713 190 0.0 0) (18.7830713 88
0.0 0) (3.78307113 93 0.0 0) (5.7830712 88 0.0 0) (2.78307113 290
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0)) ((2.78307113 137 0.0 0) (278.78307 5 0.0 0) (0.0 0
0.0 0) (80.78307 5 0.0 0) (27.7830713 88 0.0 0) (80.78307 5 0.0 0)
(0.0 0 0.0 0) (27.7830713 88 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(8.7830713 190 0.0 0) (18.7830713 88 0.0 0) (2.78307113 93 0.0 0)
(3.78307113 88 0.0 0) (2.78307113 290 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0)
(305.78307 5 0.0 0) (4.7830712 178 0.0 0) (100.78307 8 0.0 0)
(62.7830715 21 0.0 0) (100.78307 8 0.0 0) (9.7830712 22 0.0 0)
(62.7830715 21 0.0 0) (31.7830713 31 0.0 0) (0.0 0 0.0 0) (4.7830712 31
0.0 0) (24.7830713 22 0.0 0) (0.0 0 0.0 0) (7.7830712 172 0.0 0)
(0.0 0 0.0 0) (25.7830713 22 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0) (29.7830713 11 0.0 0)) (84.0 22.0 12.0 0.0 0.0
30.0 0.0)) (SYNDI SUPER2) |Syndi| 0 26 12 587 NIL T 2.28307113
3.8918203 6.0 1.28307113 144.0 NIL 372 324 (A A A) T NIL (0))
((((8.7830713 137 0.0 0) (437.78307 5 0.0 0) (0.0 0 0.0 0) (93.78307 10
1.0 67) (27.7830713 88 0.0 0) (93.78307 10 1.0 67) (0.0 0 0.0 0)
(22.7830713 88 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (8.7830713 190
0.0 0) (18.7830713 88 0.0 0) (2.78307113 93 0.0 0) (6.7830712 88
0.0 0) (1.34 72 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(0.0 1 0.0 0) (0.0 0 0.0 0)) ((2.78307113 137 0.0 0) (328.78307 5
0.0 0) (0.0 0 0.0 0) (95.78307 5 0.0 0) (28.7830713 88 0.0 0)
(95.78307 5 0.0 0) (0.0 0 0.0 0) (28.7830713 88 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (7.7830713 190 0.0 0) (20.7830713 88 0.0 0)
(2.78307113 93 0.0 0) (3.78307113 88 0.0 0) (2.78307113 290 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (359.78307 5 0.0 0) (4.7830712 178 0.0 0)
(112.78307 8 0.0 0) (65.78307 21 0.0 0) (112.78307 8 0.0 0)
(9.7830712 22 0.0 0) (65.78307 21 0.0 0) (34.7830715 31 0.0 0)
(0.0 0 0.0 0) (4.7830712 31 0.0 0) (24.7830713 22 0.0 0) (0.0 0
0.0 0) (9.7830713 172 1.0 72) (0.0 0 0.0 0) (26.7830713 22 0.0 0)
(0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (34.7830715 11 0.0 0))
(98.0 24.0 16.0 0.0 0.0 30.0 0.0)) (SYNDI BACK3) |Syndi| 0 6 1 121 NIL T
1.84 5.0 0.0 0.84 40.34 0.0 75 0 (B NIL B) T NIL (0 1 1 1 1 1 1))
((((3.0 15 1.0 0) (136.0 0 34.0 0) (0.0 0 0.0 0) (19.663026 8
2.0 0) (5.0 0 3.0 0) (23.663026 8 2.0 0) (0.0 0 0.0 0) (3.0 113
3.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 3.0 0) (4.0 113 1.0 0)
(0.0 0 0.0 0) (1.0 130 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 2 0.0 0) (0.0 3 0.0 0) (0.0 0 0.0 0)) ((2.0 15 1.0 0)
(132.0 0 34.0 0) (0.0 0 0.0 0) (14.0 7 2.0 0) (5.0 0 2.0 0)
(14.0 7 2.0 0) (0.0 0 0.0 0) (8.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (3.0 0 3.0 0) (6.0 13 1.0 0) (0.0 0 0.0 0) (1.0 130 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3
0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (136.0 0 34.0 0) (2.0 116
0.0 0) (13.0 0 6.0 0) (11.0 0 4.0 0) (13.0 0 6.0 0) (1.0 113
0.0 0) (11.0 0 6.0 0) (8.0 24 2.0 10) (0.0 0 0.0 0) (1.0 113
0.0 0) (7.0 24 1.0 19) (0.0 0 0.0 0) (1.0 113 1.0 0) (0.0 0 0.0 0)
(8.0 42 3.0 48) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (4.0 113
4.0 0)) (24.0 6.0 6.0 0.0 1.0 4.0 1.0)) (THADDEUS BEIER) |Thaddeus| 172 12 11
234 NIL T 0.9930258 7.6398154 -6.0 -6.9742054E-3 56.663026 NIL 160 130 (37 7
24) T NIL (0 1 0 1 0 0 0 0 0 1 1 1 1 1 1 1 0 1 0 1 0 0 1))
((((0.84 0 0.0 0) (120.0 0 79.0 0) (0.0 0 0.0 0) (3.0 0 11.0 0)
(3.0 0 3.0 0) (3.0 0 11.0 0) (0.0 0 0.0 0) (3.0 0 3.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 0) (3.0 0 3.0 0) (1.0 0 1.0 0)
(1.0 0 1.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2
0.0 0) (0.0 3 0.0 0) (0.0 0 0.0 0)) ((1.0 0 1.0 0) (112.0 0 79.0 0)
(0.0 0 0.0 0) (0.34 128 16.0 0) (2.0 0 3.0 0) (0.0 128 16.0 0)
(0.0 0 0.0 0) (2.0 0 3.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0
1.0 0) (2.0 0 3.0 0) (1.0 0 1.0 0) (0.0 67 1.0 0) (0.34 67 1.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 3 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (113.0 0 79.0 0) (0.0 0 0.0 0) (0.34 13
24.0 0) (3.0 0 3.0 0) (0.34 13 24.0 0) (0.0 0 0.0 0) (3.0 0 3.0 0)
(2.0 0 2.0 0) (1.0 0 0.0 0) (0.0 0 0.0 0) (0.0 80 2.0 0) (0.0 80
1.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 80 2.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 13 17.0 0)) (11.0 3.0 2.0 0.0
1.0 6.0 1.0)) (SYNDI BACK2) |Syndi| 0 16 15 104 NIL T 0.84 5.0
-4.5 0.0 1.34 5.5 178 168 (B B B) T NIL (0)) ((((2.0 67 1.0 0)
(131.0 0 34.0 0) (0.0 0 0.0 0) (17.5850704 9 2.0 0) (6.0 0 2.0 0)
(17.5850704 9 2.0 0) (0.0 0 0.0 0) (5.0 0 2.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (2.0 0 2.0 0) (4.0 64 1.0 0) (1.0 0 0.0 0) (1.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(0.0 3 0.0 0) (0.0 0 0.0 0)) ((5.0 67 1.0 0) (98.0 0 34.0 0)
(0.0 0 0.0 0) (11.5850703 13 1.0 0) (3.0 0 2.0 0) (11.5850703 13
1.0 0) (0.0 0 0.0 0) (6.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(2.0 0 2.0 0) (5.0 64 1.0 0) (1.0 0 1.0 107) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(0.0 0 0.0 0)) ((0.0 0 0.0 0) (107.0 0 34.0 0) (2.5850702 18
0.0 0) (15.0 0 5.0 0) (15.0 0 4.0 0) (15.0 0 5.0 0) (0.0 0 0.0 0)
(15.0 0 4.0 0) (10.5850703 17 0.0 0) (0.0 0 0.0 0) (1.0 0 0.0 0)
(8.5850703 17 0.0 0) (0.0 0 0.0 0) (2.0 120 0.0 0) (0.0 0 0.0 0)
(10.5850703 17 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0)
(7.0 0 3.0 0)) (21.0 4.0 3.0 0.0 0.0 5.0 1.0)) (DAN DOAN) |Dan| 150 10 10 177
NIL T 1.0850702 8.188689 3.0 0.085070204 41.585071 NIL 128 120 (25 107 25) T
NIL (0 1 1 0 0 1 1 0 1 0 1)) ((((1.62004 22 1.0 0) (65.0 0 34.0 0)
(0.0 0 0.0 0) (7.62004 11 2.0 0) (2.0 0 2.0 0) (7.62004 11 2.0 0)
(0.0 0 0.0 0) (2.0 0 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0
2.0 0) (1.0 0 1.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 3 0.0 0) (0.0 0
0.0 0)) ((2.62004 22 1.0 0) (61.0 0 34.0 0) (0.0 0 0.0 0) (5.62004 13
1.0 0) (2.0 0 2.0 0) (5.62004 13 1.0 0) (0.0 0 0.0 0) (2.0 0
2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (2.0 0 2.0 0) (1.0 0 1.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2
0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0)
(66.0 0 34.0 0) (1.0 0 1.0 72) (15.0 0 6.0 0) (10.0 0 4.0 0)
(15.0 0 6.0 0) (1.62004 33 0.0 0) (10.0 0 5.0 0) (6.0 16 1.0 11)
(0.0 0 0.0 0) (1.62004 33 0.0 0) (3.62004 33 0.0 0) (0.0 0 0.0 0)
(1.0 0 0.0 0) (0.0 0 0.0 0) (4.62004 33 0.0 0) (0.0 2 0.0 0)
(0.0 1 0.0 0) (0.0 3 0.0 0) (9.0 0 4.0 0)) (11.0 2.0 4.0 1.0
0.0 5.0 0.0)) (MIKE PATTON) |Mike| 152 5 4 86 NIL T 1.12004 7.9330224
5.0 0.120040014 16.62004 NIL 74 33 (37 A 16) T NIL (1 1 0 1 0 1 0 0 1))
((((0.0 0 0.0 0) (124.0 0 11.0 0) (0.0 0 0.0 0) (19.5850704 16
2.0 0) (1.5850702 72 1.0 21) (19.5850704 16 2.0 0) (0.0 0 0.0 0)
(1.5850702 72 1.0 21) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(1.5850702 72 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (70.0 0 11.0 0) (0.0 0 0.0 0) (10.5850703 7
1.0 0) (1.5850702 72 0.0 0) (10.5850703 7 1.0 0) (0.0 0 0.0 0)
(1.5850702 72 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(1.5850702 72 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (69.0 0 11.0 0) (0.0 0 0.0 0) (3.0 56
2.0 0) (0.0 0 0.0 0) (3.0 56 2.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0)
(0.0 1 0.0 0) (0.0 0 0.0 0) (1.0 0 2.0 0)) (21.0 1.0 1.0 0.0
0.0 0.0 0.0)) (CHRIS HIBBERT) |Chris| 314 7 2 138 NIL T 1.0850702
8.188689 6.0 0.085070204 31.5850704 NIL 91 72 (B A 21) T NIL (1 1 1 1 1 0 1 0
1)) ((((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
((0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0)) (0.0 0.0 0.0 0.0 0.0 0.0 0.0)) (RON SPAINHOUR)
|Ron| 328 0 0 0 NIL NIL 1.14516084 7.75899965 6.0 0.145160839
0.0 NIL 4 0 (NIL NIL NIL) T NIL NIL) ((((0.0 0 0.0 0) (0.84 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (0.84 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (0.84 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0))
(0.0 0.0 0.0 0.0 0.0 0.0 0.0)) (KENT PITMAN) |Kent| 115 0 0 0 NIL NIL
1.06623666 8.3333305 6.0 0.06623666 1.56623666 NIL 4 0 (NIL NIL NIL) T NIL
NIL) ((((0.0 0 0.0 0) (8.6299207 5 0.0 0) (0.0 0 0.0 0) (1.0 0
1.0 16) (0.0 0 0.0 0) (1.0 0 1.0 16) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 2 0.0 0)
(0.0 2 0.0 0) (0.0 1 0.0 0) (0.0 0 0.0 0)) ((0.0 0 0.0 0) (8.6299207 5
0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 12) (0.0 0 0.0 0) (1.0 0 1.0 12)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 2 0.0 0) (0.0 0 0.0 0) (0.0 1 0.0 0) (0.0 0
0.0 0)) ((0.0 0 0.0 0) (8.6299207 5 0.0 0) (0.0 0 0.0 0) (1.0 0
2.0 18) (0.0 0 0.0 0) (1.0 0 2.0 18) (0.0 0 0.0 0) (0.0 0 0.0 0)
(0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (0.0 0
0.0 0) (0.0 0 0.0 0) (0.0 0 0.0 0) (1.0 0 1.0 18) (0.0 2 0.0 0)
(0.0 0 0.0 0) (0.0 1 0.0 0) (1.0 0 2.0 18)) (1.0 0.0 0.0 0.0
1.0 0.0 0.0)) (JOHN HENGEVELD) |John| 129 3 1 27 NIL T 1.12992072
7.8636513 6.0 0.129920721 8.6299207 NIL 31 5 (16 12 18) T NIL (1 1 0 1)))

151
src/games/word.3 Normal file
View File

@@ -0,0 +1,151 @@
;;; -*- LISP -*-
;;;
;;; Library WRDLIB
;;;
;;; This file contains useful functions for manipulating atoms
;;; conceptually as text ('letters' and 'words') in MacLISP.
;;;
;;; Functions defined are:
;;;
;;; Ascii/Numeric Conversions
;;;
;;; CVTN - Convert to Numeric
;;; CVTA - Convert to Ascii
;;;
;;; Upper/Lower Case Conversions
;;;
;;; Name Input Output
;;; ---- ----- ------
;;; CAPS Generic Same as input, Capitalized
;;; SMALLS Generic Same as input, Lowercasified
;;; CAPS-A2A Ascii Capitalized Ascii
;;; SMALLS-A2A Ascii Lowercasified Ascii
;;; CAPS-A2N Ascii Capitalized Numeric
;;; SMALLS-A2N Ascii Lowercasified Numeric
;;; CAPS-N2A Numeric Capitalized Ascii
;;; SMALLS-N2A Numeric Lowercasified Ascii
;;; CAPS-N2N Numeric Capitalized Numeric
;;; SMALLS-N2N Numeric Lowercasified Numeric
;;;
;;; Typing Predicates
;;;
;;; CONTROL? - Returns T if arg is control char
;;; ALPHABETIC? - Returns T if arg is an alphabetic char
;;; DIGIT? - Returns T if arg is a digital char
;;;
;;; Word Operations
;;;
;;; UPPERCASIFY - Convert a word to all upper case
;;; LOWERCASIFY - Convert a word to all lower case
;;; CAPITALIZE - Convert a word to all lower case except first char
;;;
;;; BUILD - Merge several atoms into a single atom
;;;
;;;;;;;;;;;;;;;;;;;;;;;;; Numeric/Ascii Conversion ;;;;;;;;;;;;;;;;;;;;;;;;;
;;; CVTN: Convert to Numeric (from Ascii)
(DEFUN CVTN (X) (GETCHARN X 1.))
;;; CVTA: Convert to Ascii (from Numeric)
(DEFUN CVTA (X) (ASCII X))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Case Conversion ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Generic Functions
(DEFUN SMALLS (X)
(COND ((NUMBERP X) (SMALLS-N2N X))
(T (SMALLS-A2A X))))
(DEFUN CAPS (X)
(COND ((NUMBERP X) (CAPS-N2N X))
(T (CAPS-A2A X))))
;;; Specialized Functions
(DEFUN CAPS-A2A (X) (CVTA (CAPS-N2N (CVTN X))))
(DEFUN SMALLS-A2A (X) (CVTA (SMALLS-N2N (CVTN X))))
(DEFUN CAPS-A2N (X) (CAPS-N2N (CVTN X)))
(DEFUN SMALLS-A2N (X) (SMALLS-N2N (CVTN X)))
(DEFUN CAPS-N2A (X) (CVTA (CAPS-N2N X)))
(DEFUN SMALLS-N2A (X) (CVTA (SMALLS-N2N X)))
(DEFUN CAPS-N2N (X)
(COND ((AND (> X 96.) (< X 123.)) (- X 32.))
(T X)))
(DEFUN SMALLS-N2N (X)
(COND ((AND (> X 64.) (< X 91.)) (+ X 32.))
(T X)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Character Type ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; CONTROL?
;;; Predicate returns T if arg represents a control-character. Accepts
;;; string or numeric arg. Control-chars are defined here as any char
;;; with an ascii value lower than a SPACE.
(DEFUN CONTROL? (C)
(COND ((NUMBERP C) (< C 32.))
(T (CONTROL? (GETCHARN C 1.)))))
;;; ALPHABETIC?
;;; Predicate returns T if arg represents an alpha character. Accepts
;;; string or numeric arg.
(DEFUN ALPHABETIC? (C)
(COND ((NUMBERP C)
(OR
(AND (> C 64.) (< C 91.)) ; A <= C <= Z
(AND (> C 96.) (< C 123.))))
(T (ALPHABETIC? (GETCHARN C 1.)))))
;;; DIGIT?
;;; Predicate returns T if arg represents a digital character. Accepts
;;; string or numeric arg.
(DEFUN DIGIT? (N)
(COND ((NUMBERP N) (AND (> N 47.) (< N 58.))) ; 0 <= N <= 9
(T (DIGIT? (GETCHARN N 1.)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Word Commands ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; UPPERCASIFY
;;; Uppercasify a word. (put all letters in upper case)
(DEFUN UPPERCASIFY (X) (IMPLODE (MAPCAR 'CAPS (EXPLODEC X))))
;;; LOWERCASIFY
;;; Lowercasify a word. (put all letters in lower case)
(DEFUN LOWERCASIFY (X) (IMPLODE (MAPCAR 'SMALLS (EXPLODEC X))))
;;; CAPITALIZE
;;; Capitalize a word. (put first char in upper case, all others
;;; in lower case)
(DEFUN CAPITALIZE (X)
((LAMBDA (CHARS)
(IMPLODE (CONS (CAPS (CAR CHARS))
(MAPCAR 'SMALLS (CDR CHARS)))))
(EXPLODEC X)))
;;; BUILD
;;; Takes an arbitrary number of arguments. Returns an atom that has
;;; the same printname as all of the args pushed together.
(DEFUN BUILD N (IMPLODE (APPLY 'APPEND (MAPCAR 'EXPLODEN (LISTIFY N)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Tag the library as having been loaded once successfully
(PUTPROP 'WRDLIB T 'LOADED)

1463
src/games/words.50 Normal file
View File

File diff suppressed because it is too large Load Diff

11
src/games/yahtze.(init) Normal file
View File

@@ -0,0 +1,11 @@
(comment)
(progn
(setq ^W t)
(load '((dsk games) yahtze fasl))
(setq errlist '((gc)
(yahtze)))
(setsyntax '/
'/ '/ )
(setq ^W nil)
(cursorpos 'c)
(yahtze))

241
src/games/yahtze.27 Normal file
View File

@@ -0,0 +1,241 @@
;-*-lisp-*-
(declare (eval (read)))
(load '((sca) mode))
(scachar)
(declare (mapex t)
(special *nbonus*)
(fixnum i j k *nbonus* top-half bottom-half nroll))
(defun yahtze ()
(bind ((^w <- t))
(sort (list 1) (function <))) ;to load SORT package early
(terpri)
(terpri)
(princ '|Rules? |)
(cond ((memq (read) '(y yes sure ok))
(cursorpos 'c)
(princ '|/
This is the game of Yahtze./
/
It is a game played with 5 dice. You get thirteen turns. Each turn you roll/
all 5 dice, then pick up and roll any or all of them again, and then pick up/
and roll any or all of them a third time. You then score your roll in one of/
the thirteen scoring slots - one slot for each turn. Slots may be used only/
once per game. The slots are:/
/
1 - Aces (Ones)/
2 - Twos/
3 - Threes/
4 - Fours/
5 - Fives/
6 - Sixes/
/
T - Three of a Kind/
F - Four of a Kind/
H - Full House [Three of one kind, and two of another]/
S - Small Straight [Four numbers in a row]/
L - Large Straight [Five numbers in a row]/
Y - Yahtze [Five of a Kind]/
C - Chance/
/
The first 6 slots form the top half, and the last 7 make up the bottom half./
In the top half, a score is the sum of the dice of the appropriate number./
Thus (2 3 4 4 4) would score 2 if scored in the 2 slot, 3 if scored in the 3/
slot, 12 if scored in the 4 slot, and 0 if scored in any of the 1, 5, or 6/
slots. Also, if at the end of the game you have at least 63 points in the top/
half [for example, 3 of everything gives you exactly 63], you get a 35 point/
bonus. Scoring in T is the total of all the dice, provided there is a three/
of a kind [the score is 0 otherwise]. Scoring in F is similar. H scores 25,/
S 30, L 40, and Y 50, provided of course that your roll meets the appropriate/
prerequisite. If you have 50 in Y already, you get 100 bonus points for each/
additional yahtze rolled. Any yahtze may be used as a "joker" and scored/
anywhere in the lower half. C scores the total of all the dice, for any roll./
/
Note: when a roll is printed out, enter the numbers of the dice you wish to/
KEEP, followed by a space. [If you wish to roll them all again, type 0.]/
When "Score?" is printed, type the character corresponding to the slot you/
wish to score the roll in, followed by a space./
/
P.S.: If you are on a display console and this output gets lost [in which/
case you probably won't have time to read this], try :print drb;yahtze >, at/
least for the first page or two./
|)
(sleep 10.0)))
(do ((scorecard (array nil t 13) (array nil t 13)) (roll) (*nbonus* 0 0)
(top-half) (bottom-half) (base 10.) (ibase 10.) (*nopoint t) (ans))
(nil)
(sstatus random (fix (time)))
(terpri)
(terpri)
(repeat i 13
(cursorpos 'c)
(princ '|Scorecard:|)
(print-scorecard scorecard)
(setq roll (fill-roll nil))
(repeat i 2
loop (print roll)
(princ '| |)
(setq ans (list-nums (read)))
(if (subset? ans roll)
(setq roll (fill-roll ans))
(go loop)))
(print roll)
(score roll scorecard)
(terpri))
(terpri)
(terpri)
(princ '|Final Scorecard:|)
(print-scorecard scorecard)
(setq top-half (sum-array scorecard 0 5))
(terpri)
(princ '|Top Half: |)
(princ top-half)
(cond ((> top-half 62)
(terpri)
(princ '|Plus a Bonus of 35|)
(setq top-half (+ top-half 35))))
(setq bottom-half (sum-array scorecard 6 12))
(terpri)
(princ '|Bottom Half: |)
(princ bottom-half)
(cond ((= *nbonus* 1)
(terpri)
(princ '|Plus 1 Bonus Yahtze, for 100 Points|))
((> *nbonus* 1)
(terpri)
(princ '|Plus |)
(princ *nbonus*)
(princ '| Bonus Yahtzes, for |)
(princ (* *nbonus* 100))
(princ '| Points|)))
(terpri)
(princ '|Total Score: |)
(princ (+ top-half bottom-half (* 100 *nbonus*)))
(terpri)
(terpri)
(princ '|Again? |)
(cond ((not (memq (read) '(y yes sure ok)))
(terpri)
(quit)))))
(defun score (roll scorecard)
(prog (ans nroll)
(setq nroll (num-kind roll))
(cond ((and (= nroll 5) (equal (arraycall t scorecard 11) 50))
(setq *nbonus* (1+ *nbonus*))
(terpri)
(princ '|A|)
(if (> *nbonus* 1) (princ '|nother|))
(princ '| Bonus Yahtze !!!|)))
loop (terpri)
(princ '|Score? |)
(setq ans (read))
(cond ((numberp ans)
(if (or (not (fixp ans)) (< ans 1) (> ans 6)
(arraycall t scorecard (1- ans)))
(go loop)
(store (arraycall t scorecard (1- ans))
(sum-num ans roll))))
((eq ans 't)
(if (arraycall t scorecard 6) (go loop)
(store (arraycall t scorecard 6)
(if (> nroll 2) (sum-roll roll) 0))))
((eq ans 'f)
(if (arraycall t scorecard 7) (go loop)
(store (arraycall t scorecard 7)
(if (> nroll 3) (sum-roll roll) 0))))
((eq ans 'h)
(if (arraycall t scorecard 8) (go loop)
(store (arraycall t scorecard 8)
(if (full-house? roll) 25 0))))
((eq ans 's)
(if (arraycall t scorecard 9) (go loop)
(store (arraycall t scorecard 9)
(if (or (= nroll 5) (> (nrow roll) 3)) 30 0))))
((eq ans 'l)
(if (arraycall t scorecard 10) (go loop)
(store (arraycall t scorecard 10)
(if (or (= nroll 5) (> (nrow roll) 4)) 40 0))))
((eq ans 'y)
(if (arraycall t scorecard 11) (go loop)
(store (arraycall t scorecard 11)
(if (= nroll 5) 50 0))))
((eq ans 'c)
(if (arraycall t scorecard 12) (go loop)
(store (arraycall t scorecard 12)
(sum-roll roll))))
(t (go loop)))))
(defun fill-roll (roll)
(do ((roll roll (cons (1+ (random 6)) roll)))
((= (length roll) 5) roll)))
(defun list-nums (x)
(if (not (eq (typep x) 'fixnum)) (list 0)
(do ((out nil (cons (\ i 10) out))
(i x (// (- i (\ i 10)) 10)))
((= i 0) out))))
(defun subset? (s1 s2)
(setq s1 (sort (lcopy1 s1) (function <))
s2 (sort (lcopy1 s2) (function <)))
(do ()
(nil)
(cond ((null s1) (return t))
((null s2) (return nil))
((= (car s1) (car s2)) (setq s1 (cdr s1))))
(setq s2 (cdr s2))))
(defun sum-array (arr i j)
(do ((k 0 (+ k (arraycall t arr i)))
(i i (1+ i)))
((> i j) k)))
(defun print-scorecard (scorecard)
(terpri)
(terpri)
(princ '| 1 2 3 4 5 6 T F H S L Y C|)
(terpri)
(repeat i 6 (princ-/. (arraycall t scorecard i)))
(princ '| |)
(do i 6 (1+ i) (= i 13) (princ-/. (arraycall t scorecard i)))
(terpri))
(defun princ-/. (frob)
(cond ((null frob) (princ '| .|))
((< frob 10) (princ '| |) (princ frob))
(t (princ '| |) (princ frob))))
(defun sum-num (i roll) (* i (number-of i roll)))
(defun num-kind (roll)
(do ((i 1 (1+ i))
(j 0 (max (number-of i roll) j)))
((> i 6) j)))
(defun number-of (i roll)
(bind ((j <- 0))
(mapc (fn (k) (if (= i k) (setq j (1+ j)))) roll)
j))
(defun nrow (roll)
(prog (i j k)
(setq i 1 j 0 k 0)
loop (setq j (if (= (number-of i roll) 0) 0 (1+ j)))
(setq k (max j k))
(setq i (1+ i))
(if (> i 6) (return k) (go loop))))
(defun sum-roll (roll) (apply (function +) roll))
(defun full-house? (roll) ;returns T for a YAHTZE.
(prog (i j)
(setq i 1 j 0)
loop (if (= (number-of i roll) 1) (return nil))
(if (> (number-of i roll) 0) (setq j (1+ j)))
(setq i (1+ i))
(if (> i 6) (return (< j 3)) (go loop))))