;"***************************************************************************"
; "game : Abyss"
; "file : VERBS.ZIL"
; "auth :   $Author:   DEB  $"
; "date :     $Date:   20 Mar 1989  8:46:08  $"
; "rev  : $Revision:   1.16  $"
; "vers : 1.0"
;"---------------------------------------------------------------------------"
; "Verbs"
; "Copyright (C) 1988 Infocom, Inc.  All rights reserved."
;"***************************************************************************"
 
<INCLUDE "BASEDEFS">
 
<GLOBAL VERBOSITY 1>
 
;<ROUTINE V-FOO ()
	<TELL "You can't do that." CR>
>
 
<ROUTINE V-DESC-LEVEL ()
	<TELL "[">
	<COND
		(<EQUAL? ,P-PRSA-WORD ,W?SUPER ,W?SUPERBRIEF>
		;	<SETG VERBOSITY 0>
			<TELL "Super brief is not supported">
		)
		(T
			<COND
				(<EQUAL? ,P-PRSA-WORD ,W?BRIEF>
					<SETG VERBOSITY 1>
					<TELL "Brief">
				)
				(T
					<SETG VERBOSITY 2>
					<TELL "Verbose">
				)
			>
			<TELL " descriptions">
		)
	>
	<TELL ".]" CR>
>
 
<ROUTINE V-SCRIPT ()
	<COND
		(<EQUAL? ,P-PRSA-WORD ,W?SCRIPT>
			<DIROUT ,K-D-PRT-ON>
			<TELL "Transcript: Begin" CR>
		)
		(T
			<TELL "Transcript: End" CR>
			<DIROUT ,K-D-PRT-OFF>
		)
	>
	<RTRUE>
>
 
<ROUTINE V-VERIFY ()
	<COND
		(,PRSO
			<COND
				(<AND <EQUAL? ,PRSO ,INTNUM>
						<EQUAL? ,P-NUMBER 105>
					>
					<TELL N ,SERIAL CR>
				)
				(T
					<DONT-UNDERSTAND>
				)
			>
		)
		(T
			<TELL "[Verifying... ">
			<COND
				(<VERIFY>
					<TELL "Correct">
				)
				(T
					<TELL "Error">
				)
			>
			<TELL ".]" CR>
			<RFATAL>
		)
	>
>
 
%<DEBUG-CODE <ROUTINE V-COMMAND () <DIRIN 1> <RTRUE>>>
%<DEBUG-CODE <ROUTINE V-RECORD () <DIROUT ,D-RECORD-ON> <RTRUE>>>
%<DEBUG-CODE <ROUTINE V-UNRECORD () <DIROUT ,D-RECORD-OFF> <RTRUE>>>
 
<ROUTINE V-INVENTORY ()
	<RT-MOVE-ALL-WORN ,WINNER ,PSEUDO-OBJECT>
	<TELL The+verb ,WINNER "are" " holding">
	<COND
		(<NOT <RT-PRINT-CONTENTS ,WINNER T>>
			<TELL " nothing">
		)
	>
	<COND
		(<RT-SEE-ANYTHING-IN? ,PSEUDO-OBJECT>
			<TELL ". " He+verb ,WINNER "are" " wearing">
			<RT-PRINT-CONTENTS ,PSEUDO-OBJECT>
			<RT-MOVE-ALL-WORN ,PSEUDO-OBJECT ,WINNER>
		)
	>
	<TELL "." CR>
>
 
<ROUTINE V-QUIT ("OPT" (ASK? T))
	<COND
		(.ASK?
			<TELL "Are you sure you want to quit?|">
			<COND
				(<Y?>
					<QUIT>
				)
				(T
					<TELL "Continuing..." CR>
				)
			>
		)
		(T
			<QUIT>
		)
	>
>
 
<ROUTINE RT-FAILED-MSG (STR)
	<TELL "[" .STR " failed.]" CR>
>
 
<ROUTINE V-RESTART ()
	<RESTART>
	<RT-FAILED-MSG "Restart">
>
 
<ROUTINE V-SAVE ("AUX" X)
	<PUTB ,G-INBUF 1 0>
	<SETG P-CONT <>> ; "flush anything on input line after SAVE"
	<SET X <SAVE>>
	<COND
		(<OR	<EQUAL? .X 2>
				<FLAG-ON? ,F-REFRESH>
			>
			<COLOR ,GL-F-COLOR ,GL-B-COLOR>
			<V-$REFRESH <EQUAL? .X 2>>
		)
	>
	<COND
		(<ZERO? .X>
			<RT-FAILED-MSG "Save">
		)
		(T
			<TELL "[Okay.]" CR>
		)
	>
	<RFATAL>
>
 
<ROUTINE V-RESTORE ()
	<COND
		(<NOT <RESTORE>>
			<RT-FAILED-MSG "Restore">
			<RFALSE>
		)
	>
>
 
"SUBTITLE - GENERALLY USEFUL ROUTINES & CONSTANTS"
 
<ROUTINE RT-PRINT-CONTENTS (CONT "OPT" (RECUR? <>) (CNT 0) "AUX" OBJ (1ST? T))
	<SET OBJ <FIRST? .CONT>>
	<COND
		(.OBJ
			<REPEAT ()
				<COND
					(<NOT .OBJ>
						<RETURN>
					)
					(<OR	<FSET? .OBJ ,FL-INVISIBLE>
							<FSET? .OBJ ,FL-NO-DESC>
							<EQUAL? .OBJ ,WINNER>
						>
					)
					(T
						<COND
							(.1ST?
								<INC CNT>
								<SET 1ST? <>>
							)
							(T
								<TELL comma <NEXT? .OBJ>>
							)
						>
						<TELL a .OBJ>
						<THIS-IS-IT .OBJ>
						<FSET .OBJ ,FL-SEEN>
					)
				>
				<SET OBJ <NEXT? .OBJ>>
			>
			<COND
				(.RECUR?
					<SET OBJ <FIRST? .CONT>>
					<REPEAT ()
						<COND
							(<NOT .OBJ>
								<RETURN>
							)
							(<OR	<FSET? .OBJ ,FL-INVISIBLE>
									<FSET? .OBJ ,FL-NO-DESC>
									<EQUAL? .OBJ ,WINNER>
								>
							)
							(<OR	<FSET? .OBJ ,FL-SURFACE>
									<AND
										<FSET? .OBJ ,FL-CONTAINER>
										<OR
											<FSET? .OBJ ,FL-OPEN>
											<FSET? .OBJ ,FL-TRANSPARENT>
										>
									>
								>
								<COND
									(<RT-SEE-ANYTHING-IN? .OBJ>
										<TELL ". " In .OBJ the .OBJ the+verb ,WINNER "see">
										<SET CNT <RT-PRINT-CONTENTS .OBJ T .CNT>>
									)
								>
							)
						>
						<SET OBJ <NEXT? .OBJ>>
					>
				)
			>
		)
	>
	.CNT
>
 
<ROUTINE RT-DESCRIBE-OBJECTS ("OPT" (CONT ,HERE) (CNT 0) (LVL 0) "AUX" OBJ NXT (1ST? T) (P-CNT 0) (P-PL? <>))
	<SET OBJ <FIRST? .CONT>>
	<REPEAT ()
		<COND
			(<NOT .OBJ>
				<RETURN>
			)
			(<OR	<FSET? .OBJ ,FL-NO-DESC>
					<FSET? .OBJ ,FL-INVISIBLE>
				>
				<SET OBJ <NEXT? .OBJ>>
				<AGAIN>
			)
			(<FSET? .OBJ ,FL-PERSON>
				<INC P-CNT>
				<SET OBJ <NEXT? .OBJ>>
				<AGAIN>
			)
			(.1ST?
				<COND
					(<G? .CNT 0>
						<TELL " ">
					)
					(T
					;	<CRLF>
						<TELL TAB>
					)
				>
				<SET 1ST? <>>
				<COND
					(<IN? .CONT ,ROOMS>
						<TELL "Y">
					)
					(T
						<TELL In .CONT the .CONT " y">
					)
				>
				<TELL "ou see">
			)
		>
		<TELL a .OBJ>
		<THIS-IS-IT .OBJ>
		<FSET .OBJ ,FL-SEEN>
		<INC CNT>
		<SET OBJ <NEXT? .OBJ>>
		<REPEAT ()
			<COND
				(<NOT .OBJ>
					<RETURN>
				)
				(<FSET? .OBJ ,FL-NO-DESC>)
				(<FSET? .OBJ ,FL-INVISIBLE>)
				(<FSET? .OBJ ,FL-PERSON>
					<INC P-CNT>
				)
				(T
					<RETURN>
				)
			>
			<SET OBJ <NEXT? .OBJ>>
		>
		<COND
			(.OBJ
				<SET NXT <NEXT? .OBJ>>
				<REPEAT ()
					<COND
						(<NOT .NXT>
							<RETURN>
						)
						(<AND <NOT <FSET? .NXT ,FL-NO-DESC>>
								<NOT <FSET? .NXT ,FL-INVISIBLE>>
								<NOT <FSET? .NXT ,FL-PERSON>>
							>
							<RETURN>
						)
					>
					<SET NXT <NEXT? .NXT>>
				>
				<COND
					(<NOT .NXT>
						<TELL " and">
					)
					(T
						<TELL ",">
					)
				>
			)
			(T
				<COND
					(<IN? .CONT ,ROOMS>
						<TELL " here">
					)
				>
				<TELL ".">
			)
		>
	>
	<COND
		(<G? .P-CNT 0>
			<COND
				(<G? .CNT 0>
					<TELL " ">
				)
				(T
				;	<CRLF>
					<TELL TAB>
				)
			>
			<SET CNT <+ .CNT .P-CNT>>
			<COND
				(<G? .P-CNT 1>
					<SET P-PL? T>
				)
			>
			<SET OBJ <FIRST? .CONT>>
			<SET 1ST? T>
			<REPEAT ()
				<COND
					(<OR	<FSET? .OBJ ,FL-NO-DESC>
							<FSET? .OBJ ,FL-INVISIBLE>
						>
					)
					(<FSET? .OBJ ,FL-PERSON>
						<COND
							(.1ST?
								<TELL A .OBJ>
							)
							(T
								<TELL a .OBJ>
							)
						>
						<SET 1ST? <>>
						<COND
							(<FSET? .OBJ ,FL-PLURAL>
								<SET P-PL? T>
							)
						>
						<COND
							(<DLESS? P-CNT 1>
								<COND
									(.P-PL?
										<TELL " are">
									)
									(T
										<TELL " is">
									)
								>
								<TELL " here.">
								<RETURN>
							)
							(<EQUAL? .P-CNT 1>
								<TELL " and">
							)
							(T
								<TELL ",">
							)
						>
					)
				>
				<SET OBJ <NEXT? .OBJ>>
			>
		)
	>
	<SET OBJ <FIRST? .CONT>>
	<REPEAT ()
		<COND
			(<NOT .OBJ>
				<RETURN>
			)
			(<FSET? .OBJ ,FL-INVISIBLE>)
			(<OR	<FSET? .OBJ ,FL-SURFACE>
					<AND
						<FSET? .OBJ ,FL-CONTAINER>
						<FSET? .OBJ ,FL-TRANSPARENT>
					>
				>
				<SET CNT <RT-DESCRIBE-OBJECTS .OBJ .CNT <+ .LVL 1>>>
			)
		>
		<SET OBJ <NEXT? .OBJ>>
	>
	<COND
		(<ZERO? .LVL>
			<COND
				(<G? .CNT 0>
					<CRLF>
				)
			>
		)
	>
	<RETURN .CNT>
>
 
<ROUTINE RT-DESCRIBE-ROOM ("OPT" (LOOK? <>) "AUX" VAL P)
	<COND
		(<ZERO? ,LIT>
			<TELL ,K-TOO-DARK-MSG CR>
			<FSET ,HERE ,FL-TOUCHED>
			<RFALSE>
		)
		(<NOT <EQUAL? ,LIT ,HERE ,CH-PLAYER>>
			<TELL TAB "Light comes from" the ,LIT ".|">
		)
	>
	<COND
		(<SET P <GETP ,HERE ,P?ACTION>>
			<COND
				(.LOOK?
					<SET VAL <APPLY .P ,M-LOOK>>
				)
				(<NOT <FSET? ,HERE ,FL-TOUCHED>>
					<SET VAL <APPLY .P ,M-F-LOOK>>
				)
				(<EQUAL? ,VERBOSITY 2>
					<SET VAL <APPLY .P ,M-V-LOOK>>
				)
				(T
					<SET VAL <APPLY .P ,M-B-LOOK>>
				)
			>
		)
	>
	<FSET ,HERE ,FL-TOUCHED>
	<FSET ,HERE ,FL-SEEN>
	<RETURN <NOT .VAL>>
>
 
"Lengths:"
<CONSTANT REXIT 0>
<CONSTANT UEXIT <VERSION? (ZIP 1) (T 2)>>
	"Uncondl EXIT:	(dir TO rm)		 = rm"
<CONSTANT NEXIT <VERSION? (ZIP 2) (T 3)>>
	"Non EXIT:	(dir ;SORRY string)	 = str-ing"
<CONSTANT FEXIT <VERSION? (ZIP 3) (T 4)>>
	"Fcnl EXIT:	(dir PER rtn)		 = rou-tine, 0"
<CONSTANT CEXIT <VERSION? (ZIP 4) (T 5)>>
	"Condl EXIT:	(dir TO rm IF f)	 = rm, f, str-ing"
<CONSTANT DEXIT <VERSION? (ZIP 5) (T 6)>>
	"Door EXIT:	(dir TO rm IF dr IS OPEN)= rm, dr, str-ing, 0"
 
<CONSTANT NEXITSTR 0>
<CONSTANT FEXITFCN 0>
<CONSTANT CEXITFLAG <VERSION? (ZIP 1) (T 4)>>	"GET/B"
<CONSTANT CEXITSTR 1>		"GET"
<CONSTANT DEXITOBJ 1>		"GET/B"
<CONSTANT DEXITSTR <VERSION? (ZIP 1) (T 2)>>	"GET"
 
<ROUTINE NOT-HOLDING? (OBJ)
	<COND
		(<AND <NOT <IN? .OBJ ,WINNER>>
				<NOT <IN? <LOC .OBJ> ,WINNER>>
			>
			<SETG CLOCK-WAIT T>
			<TELL
"[" He+verb ,WINNER "are" "n't holding" him .OBJ ".]" CR
			>
		)
	>
>
 
<ROUTINE HELD? (OBJ "OPT" (CONT <>) "AUX" L)
	<COND
		(<ZERO? .CONT>
			<SET CONT ,PLAYER>
		)
	>
	<REPEAT ()
		<SET L <LOC .OBJ>>
		<COND
			(<NOT .L>
				<RFALSE>
			)
			(<EQUAL? .L .CONT>
				<RTRUE>
			)
			(<EQUAL? .CONT ,PLAYER ,WINNER>
				<COND
				;	(<EQUAL? .OBJ ,TH-HANDS ,TH-HEAD ,TH-EYES>
						<RTRUE>
					)
					(T
						<SET OBJ .L>
					)
				>
			)
			(<EQUAL? .L ,ROOMS ,GLOBAL-OBJECTS>
				<RFALSE>
			)
			(T
				<SET OBJ .L>
			)
		>
	>
>
 
;<ROUTINE ROOM-CHECK ("AUX" P PA)
	<SET P ,PRSO>
	<COND
		(<EQUAL? .P ,ROOMS>
			<RFALSE>
		)
		(<IN? .P ,ROOMS>
			<COND
				(<EQUAL? ,HERE .P>
					<RFALSE>
				)
				(<NOT <SEE-INTO? .P>>
					<RTRUE>
				)
				(T
					<RFALSE>
				)
			>
		)
		(<EQUAL? <META-LOC .P> ,HERE ,GLOBAL-OBJECTS ,LOCAL-GLOBALS>
			<RFALSE>
		)
		(<NOT <VISIBLE? .P>>
			<NOT-HERE .P>
		)
	>
>
 
<ROUTINE TOO-DARK ()
	<TELL "It's too dark to see." CR>
>
 
;"---------------------------------------------------------------------------"
; "A"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-ASK-ABOUT ()
	<RT-NO-RESPONSE-MSG>
>
 
<ROUTINE V-ATTACH ()
	<TELL The ,WINNER " can't attach" the ,PRSO " to" the ,PRSI "." CR>
>
 
;"---------------------------------------------------------------------------"
; "C"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-CLOSE ()
	<COND
		(<NOT <FSET? ,PRSO ,FL-OPENABLE>>
			<RT-YOU-CANT-MSG>
		)
		(T
			<COND
				(<FSET? ,PRSO ,FL-OPEN>
					<FCLEAR ,PRSO ,FL-OPEN>
					<COND
						(<FSET? ,PRSO ,FL-DOOR>
							<RT-CHECK-ADJ ,PRSO>
						)
					>
					<COND
						(<G? ,P-MULT 1>
							<TELL "Closed">
						)
						(T
							<TELL The+verb ,WINNER "close" the ,PRSO>
						)
					>
					<TELL "." CR>
				)
				(T
					<RT-ALREADY-MSG ,PRSO "closed">
				)
			>
		)
	>
>
 
<ROUTINE V-CUT ()
	<TELL TAB The ,WINNER " can't cut" the ,PRSO " with" the ,PRSI "." CR>
>
 
;"---------------------------------------------------------------------------"
; "D"
;"---------------------------------------------------------------------------"
 
<ROUTINE IDROP ()
	<COND
		(<NOT-HOLDING? ,PRSO>
			<RFALSE>
		)
		(<AND <NOT <IN? ,PRSO ,WINNER>>
				<NOT <FSET? <LOC ,PRSO> ,FL-OPEN>>
			>
			<TELL The+verb <LOC ,PRSO> "are" " closed." CR>
			<RFALSE>
		)
		(T
			<COND
				(<FSET? ,PRSO ,FL-WORN>
					<RT-FIRST-YOU-MSG "take off" ,PRSO>
				)
			>
			<MOVE ,PRSO ,HERE>
			<FCLEAR ,PRSO ,FL-WORN>
			<FCLEAR ,PRSO ,FL-NO-DESC>
			<FCLEAR ,PRSO ,FL-INVISIBLE>
			<RTRUE>
		)
	>
>
 
<ROUTINE V-DROP ("AUX" L)
	<COND
		(<IDROP>
			<COND
				(<G? ,P-MULT 1>
					<TELL "Dropped">
				)
				(T
					<TELL The+verb ,WINNER "drop" the ,PRSO>
					<COND
						(<SET L <FIND-FLAG ,HERE ,FL-VEHICLE ,PRSO>>
							<MOVE ,PRSO .L>
							<TELL in .L "to" the .L>
						)
					>
				)
			>
			<TELL "." CR>
		)
	>
>
 
;"---------------------------------------------------------------------------"
; "E"
;"---------------------------------------------------------------------------"
 
<ROUTINE PRE-EMPTY ("AUX" L)
	<COND
		(<AND <NOT <FSET? ,PRSO ,FL-SURFACE>>
				<NOT <FSET? ,PRSO ,FL-CONTAINER>>
			>
			<SET L <LOC ,PRSO>>
			<COND
				(<AND .L
						<OR
							<FSET? .L ,FL-SURFACE>
							<FSET? .L ,FL-CONTAINER>
						>
					>
					<PERFORM ,V?EMPTY .L ,PRSI>
					<RTRUE>
				)
				(T
					<RT-YOU-CANT-MSG>
				)
			>
		)
		(<AND <FSET? ,PRSO ,FL-CONTAINER>
				<NOT <FSET? ,PRSO ,FL-OPEN>>
				<FSET? ,PRSO ,FL-OPENABLE>
			>
			<TELL The+verb ,PRSO "are" "n't open." CR>
		)
		(<NOT <EQUAL? ,PRSI <> ,ROOMS ,TH-HANDS>>
			<COND
				(<AND <NOT <FSET? ,PRSI ,FL-SURFACE>>
						<NOT <FSET? ,PRSI ,FL-CONTAINER>>
					>
					<TELL The ,WINNER " can't empty" the ,PRSO " into" the ,PRSI "." CR>
				)
			>
		)
	>
>
 
<ROUTINE V-EMPTY ()
	<RT-EMPTY-MSG ,PRSO ,PRSI>
>
 
<ROUTINE RT-EMPTY-MSG (CONT "OPT" (DEST <>) "AUX" OBJ NXT X OM)
	<SET OM ,P-MULT>
	<SETG P-MULT 0>
	<SET OBJ <FIRST? .CONT>>
	<REPEAT ()
		<COND
			(<NOT .OBJ>
				<RETURN>
			)
			(<AND	<NOT <FSET? .OBJ ,FL-INVISIBLE>>
					<FSET? .OBJ ,FL-TAKEABLE>
				>
				<INC P-MULT>
			)
		>
		<SET OBJ <NEXT? .OBJ>>
	>
	<COND
		(<ZERO? ,P-MULT>
			<TELL "There is nothing" in ,PRSO the ,PRSO "." CR>
			<SETG P-MULT .OM>
			<RTRUE>
		)
	>
	<SET OBJ <FIRST? .CONT>>
	<COND
		(<EQUAL? .DEST <> ,ROOMS ,TH-GROUND ,GLOBAL-HERE>
			<SET DEST ,HERE>
		)
		(<EQUAL? .DEST ,TH-HANDS>
			<SET DEST ,CH-PLAYER>
		)
	>
	<REPEAT ()
		<COND
			(<MC-F? .OBJ>
				<RETURN>
			)
			(<AND	<NOT <FSET? .OBJ ,FL-INVISIBLE>>
					<FSET? .OBJ ,FL-TAKEABLE>
				>
				<TELL The .OBJ ": ">
				<SET NXT <NEXT? .OBJ>>
				<COND
					(<EQUAL? .DEST ,CH-PLAYER>
						<SET X <RT-PERFORM ,V?TAKE .OBJ ,PRSO>>
						<COND
							(<EQUAL? .X ,M-FATAL>
								<RETURN>
							)
						>
					)
					(<EQUAL? .DEST ,HERE>
						<MOVE .OBJ ,HERE>
						<TELL He+verb .OBJ "land" " on" the ,TH-GROUND " nearby." CR>
					)
					(<RT-ROOM-IN-MSG? .OBJ .DEST>
						T
					)
					(<RT-CHECK-MOVE-MSG? .OBJ .DEST>
						<RETURN>
					)
					(T
						<MOVE .OBJ .DEST>
						<TELL "Done." CR>
					)
				>
				<SET OBJ .NXT>
			)
		>
	>
	<SETG P-MULT .OM>
	<RTRUE>
>
 
<ROUTINE V-EMPTY-FROM ()
	<COND
		(<NOT <IN? ,PRSO ,PRSI>>
			<TELL The+verb ,PRSO "are" "n't" in ,PRSI the ,PRSI "." CR>
		)
		(T
			<PERFORM ,V?EMPTY ,PRSI>
			<RTRUE>
		)
	>
>
 
<ROUTINE V-ENTER ("AUX" VEH DIR RM)
	<COND
		(<MC-PRSO? ,ROOMS>
			<COND
				(<SET VEH <FIND-FLAG ,HERE ,FL-VEHICLE>>
					<COND
						(<IN? ,WINNER .VEH>
							<RT-ALREADY-MSG ,WINNER>
							<TELL in .VEH the .VEH ".]" CR>
						)
						(<OR	<FSET? .VEH ,FL-SURFACE>
								<FSET? .VEH ,FL-OPEN>
							>
							<MOVE ,WINNER .VEH>
							<TELL The+verb ,WINNER "get" in .VEH the .VEH "." CR>
						)
						(<FSET? .VEH ,FL-OPENABLE>
							<TELL The+verb .VEH "are" " closed." CR>
						)
						(T
							<TELL The ,WINNER " can't get" in .VEH the .VEH "." CR>
						)
					>
				)
				(<EQUAL? <RT-DO-WALK ,P?IN> <> ,M-FATAL>
					<SETG CLOCK-WAIT T>
				)
			>
		)
		(<MC-PRSO? ,HERE ,GLOBAL-HERE>
			; "Enter the room you're in"
			<RT-ALREADY-MSG ,WINNER>
			<TELL in ,HERE the ,HERE ".]" CR>
		)
		(<IN? ,PRSO ,ROOMS>
			<COND
				(<AND <SET DIR <RT-FIND-DIR ,PRSO>>
						<RT-DO-WALK .DIR>
					>
				)
				(<FSET? ,PRSO ,FL-AUTO-ENTER>
					<RT-GOTO ,PRSO>
				)
				(T
					<TELL The ,WINNER " can't get there from here." CR>
				)
			>
		)
		(<FSET? ,PRSO ,FL-DOOR>
			<COND
				(<RT-OTHER-SIDE ,PRSO>
					<RT-DO-WALK ,GL-DOOR-DIR>
				)
				(T
					<TELL The+verb ,PRSO "do" "n't seem to go anywhere." CR>
				)
			>
		)
		(<FSET? ,PRSO ,FL-VEHICLE>		; "If it's a vehicle, move winner there."
			<COND
				(<OR	<FSET? ,PRSO ,FL-SURFACE>
						<FSET? ,PRSO ,FL-OPEN>
					>
					<MOVE ,WINNER ,PRSO>
					<TELL The+verb ,WINNER "get" in ,PRSO the ,PRSO "." CR>
				)
				(<FSET? ,PRSO ,FL-OPENABLE>
					<TELL The+verb ,PRSO "are" " closed." CR>
				)
				(T
					<TELL The ,WINNER " can't get" in ,PRSO the ,PRSO "." CR>
				)
			>
		)
		(T
			<RT-IMPOSSIBLE-MSG>
		)
	>
	<RTRUE>
>
 
<ROUTINE V-EXIT ("AUX" VEH L DIR)
	<COND
		(<MC-PRSO? ,ROOMS>
			<SET L <LOC ,WINNER>>
			<COND
				(<IN? .L ,ROOMS>
					<RT-DO-WALK ,P?OUT>
				)
				(<OR	<FSET? .L ,FL-VEHICLE>
						<FSET? .L ,FL-SURFACE>
						<FSET? .L ,FL-CONTAINER>
					>
					<COND
						(<OR	<FSET? .L ,FL-SURFACE>
								<FSET? .L ,FL-OPEN>
							>
							<MOVE ,WINNER <LOC .L>>
							<TELL The+verb ,WINNER "get" out .L " of" the .L "." CR>
						)
						(<FSET? .L ,FL-OPENABLE>
							<TELL The+verb .L "are" " closed." CR>
						)
						(T
							<TELL The ,WINNER " can't get" out .L " of" the .L "." CR>
						)
					>
				)
				(<SET VEH <FIND-FLAG ,HERE ,FL-VEHICLE>>
					<TELL The+verb ,WINNER "are" "n't" in .VEH the .VEH "." CR>
				)
			>
		)
		(<MC-PRSO? ,HERE ,GLOBAL-HERE>
			<RT-DO-WALK ,P?OUT>
		)
		(<IN? ,PRSO ,ROOMS>
			<RT-NOT-IN-ROOM-MSG>
		)
		(<FSET? ,PRSO ,FL-DOOR>
			<COND
				(<RT-OTHER-SIDE ,PRSO>
					<RT-DO-WALK ,GL-DOOR-DIR>
				)
				(T
					<TELL The+verb ,PRSO "do" "n't seem to go anywhere." CR>
				)
			>
		)
		(<OR	<FSET? ,PRSO ,FL-VEHICLE>
				<FSET? ,PRSO ,FL-CONTAINER>
				<FSET? ,PRSO ,FL-SURFACE>
			>
			<COND
				(<IN? ,WINNER ,PRSO>
					<COND
						(<OR	<FSET? ,PRSO ,FL-SURFACE>
								<FSET? ,PRSO ,FL-OPEN>
							>
							<MOVE ,WINNER <LOC <LOC ,WINNER>>>
							<TELL The+verb ,WINNER "get" out ,PRSO " of" the ,PRSO "." CR>
						)
						(<FSET? ,PRSO ,FL-OPENABLE>
							<TELL The+verb ,PRSO "are" " closed." CR>
						)
						(T
							<TELL The ,WINNER " can't get" out ,PRSO " of" the ,PRSO "." CR>
						)
					>
				)
				(T
					<TELL The+verb ,WINNER "are" "n't" in ,PRSO the ,PRSO "." CR>
				)
			>
		)
		(<FSET? <SET L <LOC ,PRSO>> ,FL-CONTAINER>
			<TELL "[from" the .L "]" CR>
			<RT-PERFORM ,V?TAKE ,PRSO>
		)
		(T
			<RT-IMPOSSIBLE-MSG>
		)
	>
	<RTRUE>
>
 
<ROUTINE RT-NOT-IN-ROOM-MSG ()
	<TELL The+verb ,WINNER "are" "n't" in ,PRSO the ,PRSO "." CR>
>
 
<ROUTINE RT-DO-WALK (DIR1 "OPT" (DIR2 <>) (DIR3 <>) "AUX" X)
	<SETG P-WALK-DIR .DIR1>
	<SET X <PERFORM ,V?WALK .DIR1>>
	<COND
		(<AND .DIR2
				<NOT <EQUAL? .X <> ,M-FATAL>>
			>
			<SETG P-WALK-DIR .DIR2>
			<SET X <PERFORM ,V?WALK .DIR2>>
			<COND
				(<AND .DIR3
						<NOT <EQUAL? .X <> ,M-FATAL>>
					>
					<SETG P-WALK-DIR .DIR3>
					<SET X <PERFORM ,V?WALK .DIR3>>
				)
			>
		)
	>
	<RETURN .X>
>
 
;<ROUTINE PRE-EXAMINE ()
	<ROOM-CHECK>
>
 
<ROUTINE V-EXAMINE ()
	<COND
		(<MC-PRSO? ,HERE ,GLOBAL-HERE>
			<PERFORM ,V?LOOK>
		)
		(<MC-PRSO? ,INTDIR>
			<SETG CLOCK-WAIT T>
			<TELL "[If you want to see what's there, go there.]" CR>
		)
		(<FSET? ,PRSO ,FL-DOOR>
			<FSET ,PRSO ,FL-SEEN>
			<TELL The+verb ,PRSO "are" open ,PRSO "." CR>
		)
		(<OR	<FSET? ,PRSO ,FL-CONTAINER>
				<FSET? ,PRSO ,FL-SURFACE>
			>
			<FSET ,PRSO ,FL-SEEN>
			<V-LOOK-IN>
		)
		(T
			<FSET ,PRSO ,FL-SEEN>
			<RT-NOTHING-SPECIAL-MSG>
		)
	>
>
 
<ROUTINE RT-NOTHING-SPECIAL-MSG ()
	<TELL
"You see nothing " <RT-PICK-NEXT ,K-UNUSUAL-TBL> " about" the ,PRSO "." CR
	>
>
 
<CONSTANT YOU-DIDNT-SAY-W "[You didn't say w">
 
<ROUTINE V-EXTINGUISH ()
	<TELL "['Extinguish' currently has no default handling.]|">
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "F"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-FOLLOW ()
	<TELL "['Follow' currently has no default handling.]|">
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "G"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-GIVE ()
	<TELL TAB The+verb ,PRSI "do" "n't seem interested in" the ,PRSO "." CR>
>
 
<ROUTINE V-GIVE-SWP ()
	<PERFORM ,V?GIVE ,PRSI ,PRSO>
	<RTRUE>
>
 
;"---------------------------------------------------------------------------"
; "H"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-HIT ()
	<TELL "['Hit' currently has no default handling.]|">
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "I"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-INFLATE ()
	<TELL ,K-HOW-INTEND-MSG CR>
>
 
;"---------------------------------------------------------------------------"
; "L"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-LIFT ()
	<TELL "['Lift' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-LISTEN ()
	<COND
		(<MC-PRSO? <> ,ROOMS>
			<TELL
The+verb ,WINNER "hear" "nothing " <RT-PICK-NEXT ,K-UNUSUAL-TBL> "." CR
			>
		)
		(T
			<TELL The+verb ,PRSO "are" " silent." CR>
		)
	>
>
 
<ROUTINE V-LOCK ()
	<COND
	;	(<EQUAL? ,P-PRSA-WORD ,W?BAR>
			<TELL The ,WINNER " can't bar" the ,PRSO !\. CR>
		)
		(<FSET? ,PRSO ,FL-LOCKED>
			<RT-ALREADY-MSG ,PRSO "locked">
		)
		(<NOT <RT-MATCH-KEY ,PRSO ,PRSI>>
			<TELL The ,WINNER " can't lock" the ,PRSO " with" the ,PRSI !\. CR>
		)
		(T
			<FSET ,PRSO ,FL-LOCKED>
			<COND
				(<FSET? ,PRSO ,FL-OPEN>
					<FCLEAR ,PRSO ,FL-OPEN>
					<COND
						(<FSET? ,PRSO ,FL-DOOR>
							<RT-CHECK-ADJ ,PRSO>
						)
					>
					<TELL
The+verb ,WINNER "close" the ,PRSO " and" verb ,WINNER "lock" him ,PRSO "." CR
					>
				)
				(T
					<RT-LOCK-MSG ,PRSO ,PRSI T>
					<TELL "." CR>
				)
			>
		)
	>
>
 
<ROUTINE V-LOOK ()
	<COND
		(<RT-DESCRIBE-ROOM T>
			<RT-DESCRIBE-OBJECTS>
		)
	>
	<RTRUE>
>
 
<ROUTINE V-LOOK-BEHIND ()
	; "Bob"
	<TELL TAB "You don't see anything " <RT-PICK-NEXT ,K-UNUSUAL-TBL> "." CR>
>
 
<ROUTINE V-LOOK-UNDER ()
	; "Bob"
	<TELL TAB "You don't see anything " <RT-PICK-NEXT ,K-UNUSUAL-TBL> "." CR>
>
 
;<ROUTINE PRE-LOOK-IN ()
	<ROOM-CHECK>
>
 
<ROUTINE V-LOOK-IN ("OPT" (DIR ,P?IN) "AUX" RM)
	<COND
		(<MC-PRSO? ,ROOMS>
			<COND
				(<OR	<FSET? <SET RM ,P-IT-OBJECT> ,FL-CONTAINER>
						<SET RM <FIND-FLAG-LG ,HERE ,FL-OPENABLE>>
					>
					<PERFORM ,PRSA .RM ,PRSI>
					<RTRUE>
				)
			>
		)
	>
	<COND
	;	(<AND <IN? ,PRSO ,ROOMS>
				<OR
					<GLOBAL-IN? ,PRSO ,HERE>
					<SEE-INTO? ,PRSO <>>
				>
			>
			<ROOM-PEEK ,PRSO>
		)
		(<AND <NOT <FSET? ,PRSO ,FL-OPEN>>
				<FSET? ,PRSO ,FL-OPENABLE>
			>
			<TELL The+verb ,PRSO "are" " closed." CR>
		)
		(<AND <OR
					<FSET? ,PRSO ,FL-CONTAINER>
					<FSET? ,PRSO ,FL-SURFACE>
				>
				<RT-SEE-INSIDE? ,PRSO>
			>
		;	<COND
				(<NOT <RT-SEE-INSIDE? ,PRSO>>
					<RT-FIRST-YOU-MSG "open" ,PRSO>
					<FSET ,PRSO ,FL-OPEN>
				)
			>
			<COND
				(<FIRST? ,PRSO>
					<TELL "You can see">
					<RT-PRINT-CONTENTS ,PRSO>
					<TELL in ,PRSO>
					<COND
						(<NOT <FSET? ,PRSO ,FL-SURFACE>>
							<TELL "side">
						)
					>
					<TELL the ,PRSO "." CR>
				)
				(T
					<TELL "There's nothing" in ,PRSO the ,PRSO "." CR>
				)
			>
		)
		(<==? .DIR ,P?IN>
			<RT-YOU-CANT-MSG "look inside">
		)
		(T
			<RT-YOU-CANT-MSG "look outside">
		)
	>
>
 
;<ROUTINE ROOM-PEEK (RM "OPT" (SAFE <>) "AUX" (X <>) OHERE OLIT TXT)
	<COND
		(<EQUAL? .RM ,HERE>
			<V-LOOK>
			<RTRUE>
		)
		(<OR	.SAFE
				<SEE-INTO? .RM>
			>
			<SET OHERE ,HERE>
			<SET OLIT ,LIT>
			<SETG HERE .RM>
			<SETG LIT <LIT?>>
			<TELL "You peer ">
			<COND
				(<FSET? .RM ,FL-SURFACE>
					<TELL "at">
				)
				(T
					<TELL "into">
				)
			>
			<TELL him .RM ":" CR>
			<COND
				(<RT-DESCRIBE-OBJECTS>
					<SET X T>
				)
			;	(<SET TXT <GETP .RM ,P?LDESC>>
					<SET X T>
					<TELL .TXT CR>
				)
			>
			<COND
				(<ZERO? .X>
					<TELL "You can't see anything suspicious." CR>
				)
			>
			<SETG HERE .OHERE>
			<SETG LIT .OLIT>
			<RTRUE>
		)
	>
>
 
;<ROUTINE SEE-INTO? (THERE "OPT" (TELL? T) (IGNORE-DOOR <>)"AUX" P L TBL O)
	<SET P 0>
	<REPEAT ()
		<COND
			(<OR	<0? <SET P <NEXTP ,HERE .P>>>
					<L? .P ,LOW-DIRECTION>
				>
				<COND
					(.TELL?
						<TELL-CANT-FIND>
					)
				>
				<RFALSE>
			)
		>
		<SET TBL <GETPT ,HERE .P>>
		<SET L <PTSIZE .TBL>>
		<COND
			(<==? .L ,UEXIT>
				<COND
					(<==? <GET/B .TBL ,REXIT> .THERE>
						<RTRUE>
					)
				>
			)
			(<==? .L ,DEXIT>
				<COND
					(<==? <GET/B .TBL ,REXIT> .THERE>
						<COND
							(<FSET? <GET/B .TBL ,DEXITOBJ> ,FL-OPEN>
								<RTRUE>
							)
							(<WALK-THRU-DOOR? .TBL <GET/B .TBL ,DEXITOBJ> <>>
								<RTRUE>
							)
							(.IGNORE-DOOR
								<RTRUE>
							)
							(T
								<COND
									(.TELL?
										<SETG CLOCK-WAIT T>
										<TELL "[The door to that room is closed.]" CR>
									)
								>
								<RFALSE>
							)
						>
					)
				>
			)
			(<==? .L ,CEXIT>
				<COND
					(<==? <GET/B .TBL ,REXIT> .THERE>
						<COND
							(<VALUE <GETB .TBL ,CEXITFLAG>>
								<RTRUE>
							)
							(T
								<COND
									(.TELL?
										<TELL-CANT-FIND>
									)
								>
								<RFALSE>
							)
						>
					)
				>
			)
		>
	>
>
 
<ROUTINE TELL-CANT-FIND ()
	<SETG CLOCK-WAIT T>
	<TELL "[That place isn't close enough.]" CR>
>
 
<ROUTINE V-LOOK-ON ()
	<COND
		(<FSET? ,PRSO ,FL-SURFACE>
			<V-LOOK-IN>
		)
		(T
			<TELL "There's no good surface on" the ,PRSO "." CR>
		)
	>
>
 
;"---------------------------------------------------------------------------"
; "M"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-MOVE ()
	<TELL "['Move' currently has no default handling.]|">
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "N"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-NO ()
	<TELL "[You seem sure of yourself.]" CR>
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "O"
;"---------------------------------------------------------------------------"
 
<ROUTINE RT-MATCH-KEY (DOOR "OPT" (KEY <>))
	<COND
		(<EQUAL? .DOOR ,TH-STEEL-BOX>
			<COND
				(<EQUAL? .KEY ,TH-STEEL-KEY>
					<RTRUE>
				)
			>
		)
		(<EQUAL? .DOOR ,TH-MISSILE-PANEL>
			<COND
				(<EQUAL? .KEY ,TH-MISSILE-ACCESS-KEY>
					<RTRUE>
				)
			>
		)
	>
>
 
<GLOBAL GL-DOOR-DIR <>>
 
<ROUTINE RT-OTHER-SIDE (DOOR "AUX" (RM <>) L)
	<SET L <LOC ,WINNER>>
	<REPEAT ((P 0) OBJ PT PTS)
		<COND
			(<OR	<ZERO? <SET P <NEXTP .L .P>>>
					<L? .P ,LOW-DIRECTION>
				>
				<RFALSE>
			)
			(<SET PT <GETPT .L .P>>
				<SET PTS <PTSIZE .PT>>
				<COND
					(<AND <==? .PTS ,DEXIT>
							<EQUAL? .DOOR <GET/B .PT ,DEXITOBJ>>
						>
						<SETG GL-DOOR-DIR .P>
						<SET RM <GET/B .PT ,REXIT>>
						<RETURN>
					)
				>
			)
		>
	>
	<RETURN .RM>
>
 
<ROUTINE RT-LOCK-MSG (DOOR KEY LOCK?)
	<TELL
The+verb ,WINNER "put" the .KEY " in the lock and" verb ,WINNER "give" " it a
turn"
	>
	<COND
		(.LOCK?
			<TELL ". " The .DOOR " locks with">
		)
		(T
			<TELL ", and" verb ,WINNER "hear">
		)
	>
	<TELL " a satisfying click">
>
 
<ROUTINE RT-OPEN-DOOR-MSG (DOOR "OPT" (KEY <>) "AUX" RM (LOCK? <>) TMP1 TMP2)
	<COND
		(<FSET? .DOOR ,FL-LOCKED>
			<SET LOCK? T>
			<FCLEAR .DOOR ,FL-LOCKED>
			<RT-LOCK-MSG .DOOR .KEY <>>
			<COND
				(<OR	<FSET? .DOOR ,FL-AUTO-OPEN>
						<VERB? OPEN>
					>
					<FSET .DOOR ,FL-OPEN>
					<COND
						(<FSET? .DOOR ,FL-DOOR>
							<RT-CHECK-ADJ .DOOR>
						)
					>
					<TELL ". " The+verb .DOOR "swing" " open">
				)
			>
		)
		(T
			<FSET .DOOR ,FL-OPEN>
			<COND
				(<FSET? .DOOR ,FL-DOOR>
					<RT-CHECK-ADJ .DOOR>
				)
			>
			<TELL The+verb ,WINNER "open" the .DOOR>
		)
	>
	<COND
		(<FSET? .DOOR ,FL-OPEN>
			<COND
				(<FSET? .DOOR ,FL-DOOR>
					<COND
						(<NOT <SET RM <RT-OTHER-SIDE .DOOR>>>)
						(<FSET? .DOOR ,FL-AUTO-ENTER>
							<TELL " and">
							<COND
								(.LOCK?
									<TELL the ,WINNER>
								)
							>
							<TELL verb ,WINNER "step" " through." CR CR>
							<RT-GOTO .RM>
							<RTRUE>
						)
						(<SET TMP2 <GETP ,HERE ,P?ADJACENT>>
							<COND
								(<SET TMP1 <INTBL? .RM <REST .TMP2 1> <GETB .TMP2 0> 1>>
									<COND
										(<GETB .TMP1 1>
											<COND
												(<RT-SEE-ANYTHING-IN? .RM>
													<TELL " and">
													<COND
														(.LOCK?
															<TELL the ,WINNER>
														)
													>
													<TELL verb ,WINNER "see">
													<RT-PRINT-CONTENTS .RM>
												)
											>
										)
									>
								)
							>
						)
					>
				)
				(<NOT <FSET? .DOOR ,FL-TRANSPARENT>>
					<COND
						(<RT-SEE-ANYTHING-IN? .DOOR>
							<TELL ". Inside you see">
							<RT-PRINT-CONTENTS .DOOR>
						)
					>
				)
			>
		)
	>
	<TELL "." CR>
	<COND
		(<NOT <FSET? .DOOR ,FL-TAKEABLE>>
			<COND
				(<FSET? .DOOR ,FL-OPEN>
					<RT-SCORE-OBJ .DOOR>
				)
			>
		)
	>
>
 
<ROUTINE V-OPEN ("AUX" F STR RM)
	<COND
		(<NOT <FSET? ,PRSO ,FL-OPENABLE>>
			<RT-YOU-CANT-MSG>
		)
		(<FSET? ,PRSO ,FL-OPEN>
			<RT-ALREADY-MSG ,PRSO "open">
		)
		(<AND <NOT ,PRSI>
				<FSET? ,PRSO ,FL-LOCKED>
			>
			<TELL The+verb ,PRSO "are" " locked." CR>
		)
		(<AND ,PRSI
				<NOT <RT-MATCH-KEY ,PRSO ,PRSI>>
			>
			<TELL The ,WINNER " can't open" the ,PRSO " with" the ,PRSI "." CR>
		)
		(T
			<RT-OPEN-DOOR-MSG ,PRSO ,PRSI>
		)
	>
>
 
;"---------------------------------------------------------------------------"
; "P"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-PLUG-IN ()
	<TELL TAB The ,WINNER " can't plug in" the ,PRSO "." CR>
>
 
<ROUTINE V-PULL ()
	<TELL "	You pull" the ,PRSO ", but nothing happens." CR>
>
 
<ROUTINE V-PUSH ()
	<TELL "	You push" the ,PRSO ", but nothing happens." CR>
>
 
<ROUTINE PRE-PUT ()
	<COND
	;	(<MC-PRSO? ,HEAD ,HANDS>
			<WONT-HELP>
			<RTRUE>
		)
		(<IN? ,PRSO ,GLOBAL-OBJECTS>
			<NOT-HERE ,PRSO>
			<RTRUE>
		)
		(<MC-PRSI? ,TH-GROUND ,GLOBAL-HERE <>>
			<RFALSE>
		)
		(<IN? ,PRSI ,GLOBAL-OBJECTS>
			<NOT-HERE ,PRSI>
			<RTRUE>
		)
		(<HELD? ,PRSI ,PRSO>
			<RT-YOU-CANT-MSG "put" ,PRSI "in it">
		)
	>
>
 
<ROUTINE V-PUT ()
	<COND
	;	(<FSET? ,PRSI ,FL-PERSON>
			<SETG WINNER ,PRSI>
			<PERFORM ,V?WEAR ,PRSO>
			<RTRUE>
		)
		(<NOT <FSET? ,PRSI ,FL-SURFACE>>
			<TELL "There's no good surface on" the ,PRSI "." CR>
		)
		(T
			<RT-PUT-ON-OR-IN>
		)
	>
>
 
<ROUTINE TELL-FIND-NONE (STR "OPT" (OBJ <>))
	<TELL "You search for " .STR>
	<COND
		(.OBJ
			<TELL a .OBJ>
		)
	>
	<TELL " but find none." CR>
>
 
<ROUTINE PRE-PUT-IN ()
	<COND
		(<MC-PRSI? ,PSEUDO-OBJECT>
			<RETURN <PRE-PUT>>
		)
	;	(<MC-PRSI? ,TH-EYES ,TH-HANDS>
			<WONT-HELP>
			<RFATAL>
		)
		(<FSET? ,PRSI ,FL-READABLE>
			<WONT-HELP>
			<RFATAL>
		)
		(<NOT <FSET? ,PRSI ,FL-CONTAINER>>
			<TELL-FIND-NONE "an opening in" ,PRSI>
			<RFATAL>
		)
	>
	<COND
		(<NOT <FSET? ,PRSI ,FL-OPEN>>
			<COND
				(<FSET? ,PRSI ,FL-OPENABLE>
					<RT-FIRST-YOU-MSG "open" ,PRSI>
					<FSET ,PRSI ,FL-OPEN>
				)
			>
		)
	>
	<PRE-PUT>
>
 
<ROUTINE V-PUT-IN ()
	<COND
		(<NOT <FSET? ,PRSI ,FL-OPEN>>
			<COND
				(<FSET? ,PRSI ,FL-OPENABLE>
					<TELL The+verb ,PRSI "are" " closed">
				)
				(T
					<TELL The ,WINNER " can't open" the ,PRSI>
				)
			>
			<TELL "." CR>
		)
		(T
			<RT-PUT-ON-OR-IN>
		)
	>
>
 
<CONSTANT NOT-ENOUGH-ROOM "There's not enough room.|">
 
<ROUTINE RT-PUT-ON-OR-IN ()
	<COND
		(<ZERO? ,PRSI>
			<RT-YOU-CANT-MSG>
		)
		(<MC-PRSO? ,PRSI>
			<HAR-HAR>
		)
		(<IN? ,PRSO ,PRSI>
			<RT-ALREADY-MSG ,PRSO>
			<TELL in ,PRSI the ,PRSI ".]" CR>
		)
		(<RT-ROOM-IN-MSG? ,PRSO ,PRSI>
			<RTRUE>
		)
		(<AND <NOT <HELD? ,PRSO>>
				<NOT <ITAKE>>
			>
			<RTRUE>
		)
		(T
			<COND
				(<FSET? ,PRSO ,FL-WORN>
					<FCLEAR ,PRSO ,FL-WORN>
					<RT-FIRST-YOU-MSG "take off" ,PRSO>
				)
			>
			<MOVE ,PRSO ,PRSI>
			<FSET ,PRSO ,FL-TOUCHED>
		;	<COND
				(<VERB? PUT>
					<FSET ,PRSO ,FL-ON>
				)
				(T
					<FCLEAR ,PRSO ,FL-ON>
				)
			>
			<COND
				(<AND <FSET? ,PRSI ,FL-PERSON>
						<FSET? ,PRSO ,FL-CLOTHING>
					>
					<FSET ,PRSO ,FL-WORN>
					<TELL The+verb ,WINNER "put" " on" the ,PRSO>
				)
				(<G? ,P-MULT 1>
					<TELL "Done">
				)
				(T
					<TELL The+verb ,WINNER "put" the ,PRSO " ">
					<COND
						(<OR	<FSET? ,PRSI ,FL-SURFACE>
								<FSET? ,PRSI ,FL-PERSON>
							;	<FSET? ,PRSO ,FL-ON>
							>
							<TELL "o">
						)
						(T
							<TELL "i">
						)
					>
					<TELL "nto" the ,PRSI>
				)
			>
			<TELL "." CR>
		)
	>
>
 
<ROUTINE RT-TOTAL-SIZE (OBJ1 "AUX" OBJ (TOTSIZ 0))
	<SET OBJ <FIRST? .OBJ1>>
	<REPEAT ()
		<COND
			(<MC-F? .OBJ>
				<RETURN>
			)
			(<FSET? .OBJ ,FL-WORN>
			)
			(T
				<SET TOTSIZ <+ .TOTSIZ <GETB <GETPT .OBJ ,P?SIZE> ,K-SIZ-SIZ>>>
			)
		>
		<SET OBJ <NEXT? .OBJ>>
	>
	<RETURN .TOTSIZ>
>
 
<ROUTINE RT-OBJ-TOO-LARGE? (OBJ1 OBJ2 "AUX" CAP)
	<SET CAP <GETB <GETPT .OBJ2 ,P?SIZE> ,K-SIZ-CAP>>
	<COND
		(<EQUAL? .CAP ,K-CAP-MAX>
			<RFALSE>
		)
		(<G?	<+ <GETB <GETPT .OBJ1 ,P?SIZE> ,K-SIZ-SIZ>	; "Size"
					<RT-TOTAL-SIZE .OBJ2>
				>
				.CAP
			>
			<RTRUE>
		)
	>
>
 
<ROUTINE RT-ROOM-IN-MSG? (OBJ1 OBJ2)
	<COND
		(<RT-OBJ-TOO-LARGE? .OBJ1 .OBJ2>
			<TELL "There is not enough room" in .OBJ2 the .OBJ2 "." CR>
		)
	>
>
 
<ROUTINE RT-CHECK-MOVE-MSG? (SRC DEST "AUX" PTR OLOC CNT)
	<COND
		(.DEST
			<SET PTR ,GL-LOC-TRAIL>
			<SET OLOC .DEST>
			<REPEAT ()
				<ZPUT .PTR 0 .OLOC>
				<INC CNT>
				<COND
					(<OR	<MC-F? .OLOC>
							<IN? .OLOC ,ROOMS>
							<IN? .OLOC ,LOCAL-GLOBALS>
							<IN? .OLOC ,GLOBAL-OBJECTS>
						>
						<RETURN>
					)
				>
				<SET OLOC <LOC .OLOC>>
				<SET PTR <ZREST .PTR 2>>
				<COND
					(<EQUAL? .OLOC .DEST>
						<RETURN>
					)
				>
			>
			<COND
				(<INTBL? .SRC ,GL-LOC-TRAIL .CNT>
					<TELL
The ,WINNER " can't put" the .SRC in .SRC him .SRC "self, or" in .SRC
"something that is already" in .SRC him .SRC "." CR
					>
					<RTRUE>
				)
			>
		)
	>
>
 
;"---------------------------------------------------------------------------"
; "R"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-REACH-BEHIND ()
	<TELL "['Reach behind' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-REACH-IN ()
	<TELL "['Reach in' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-REACH-UNDER ()
	<TELL "['Reach under' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-READ ()
	<TELL "['Read' currently has no default handling.]|">
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "S"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-SHOW ()
	<TELL The+verb ,PRSI "seem" " unimpressed by" the ,PRSO "." CR>
>
 
<ROUTINE V-SHOW-SWP ()
	<PERFORM ,V?SHOW ,PRSI ,PRSO>
>
 
<ROUTINE V-SIT ("AUX" (OBJ ,PRSO))
	<COND
		(<MC-PRSO? ,ROOMS>
			<SET OBJ ,TH-GROUND>
		)
	>
	<RT-NO-POINT-MSG "Sitting on" .OBJ>
>
 
;"---------------------------------------------------------------------------"
; "T"
;"---------------------------------------------------------------------------"
 
<ROUTINE ITAKE ("OPT" (OB <>) (V? T) "AUX" CNT OBJ L)
	<COND
		(<ZERO? .OB>
			<SET OB ,PRSO>
		)
	>
	<SET L <LOC .OB>>
	<COND
		(<OR	<NOT <FSET? .OB ,FL-TAKEABLE>>
			;	<NOT <ACCESSIBLE? .OB>>
			>
			<COND
				(.V?
					<RT-YOU-CANT-MSG "take">
				)
			>
			<RFALSE>
		)
		(<RT-OBJ-TOO-LARGE? .OB ,WINNER>
			<COND
			;	(.FORCED?
					<TELL "As" the+verb ,WINNER "reach" " for" the .OB>
					<SET CNT 0>
					<REPEAT ((1ST? T))
						<COND
							(<NOT <RT-OBJ-TOO-LARGE? .OB ,WINNER>>
								<RETURN>
							)
							(<SET OBJ <FIND-FLAG-NOT ,WINNER ,FL-WORN>>
								<MOVE .OBJ ,HERE>
								<INC CNT>
								<TELL "," the .OBJ>
							)
						>
					>
					<COND
						(<EQUAL? .CNT 1>
							<TELL verb .OBJ "slip">
						)
						(T
							<TELL " slip">
						)
					>
					<TELL " to" the ,TH-GROUND "." CR>
					<RT-DO-TAKE .OB>
				)
				(T
					<COND
						(.V?
							<TELL The+verb ,WINNER "are" " holding too much." CR>
						)
					>
					<RFALSE>
				)
			>
		)
	;	(<AND <G? <SET CNT <CCOUNT ,WINNER>> ,FUMBLE-NUMBER>
				<PROB <* .CNT ,FUMBLE-PROB>>
				<SET OBJ <FIND-FLAG-NOT ,WINNER ,FL-WORN>>
			>
			<TELL
The .OBJ " slips from" his ,WINNER " arms while" he+verb ,WINNER "are"
" taking" the .OB ", and both tumble to" the ,TH-GROUND ". "
The+verb ,WINNER "are" " carrying too many things." CR
			>
			<MOVE .OBJ ,HERE>
			<MOVE .OB ,HERE>
			<RFATAL>
		)
		(T
			<COND
				(<AND <NOT <VERB? TAKE>>
						<NOT <EQUAL? .L ,WINNER>>
					>
					<RT-FIRST-YOU-MSG "take" .OB .L>
				)
			>
			<RT-DO-TAKE .OB>
		)
	>
>
 
<ROUTINE RT-DO-TAKE (OBJ "OPT" (FORCED? <>) "AUX" L)
	<SET L <LOC .OBJ>>
	<MOVE .OBJ ,WINNER>
	<FSET .OBJ ,FL-SEEN>
	<FSET .OBJ ,FL-TOUCHED>
	<FCLEAR .OBJ ,FL-NO-DESC>
	<FCLEAR .OBJ ,FL-INVISIBLE>
	<FCLEAR .OBJ ,FL-WORN>
	<RTRUE>
>
 
<ROUTINE PRE-TAKE ("AUX" L)
	<COND
		(<MC-PRSO? ,TH-HANDS ,YOU>
			<RFALSE>
		)
		(<==? <SET L <LOC ,PRSO>> ,GLOBAL-OBJECTS>
			<NOT-HERE ,PRSO>
		)
		(<RT-META-IN? ,WINNER ,PRSO>
			<RT-ALREADY-MSG ,WINNER>
			<TELL in ,PRSO the ,PRSO ".]" CR>
		)
		(<AND .L
				<OR
					<NOT <FSET? .L ,FL-SURFACE>>
				;	<NOT <FSET? ,PRSO ,FL-ON>>
				>
				<FSET? .L ,FL-OPENABLE>
				<NOT <FSET? .L ,FL-OPEN>>
			>
			<TELL The+verb .L "are" " closed." CR>
			<RTRUE>
		)
		(<VERB? TAKE-WITH>
			<RFALSE>
		)
		(,PRSI
			<COND
				(<EQUAL? ,PRSI .L>
					<SETG PRSI <>>
					<RFALSE>
				)
				(<AND <OR
							<NOT <FSET? .L ,FL-SURFACE>>
						;	<NOT <FSET? ,PRSO ,FL-ON>>
						>
						<FSET? ,PRSI ,FL-OPENABLE>
						<NOT <FSET? ,PRSI ,FL-OPEN>>
					>
					<TELL The+verb ,PRSI "are" " closed." CR>
					<RTRUE>
				)
				(<NOT <==? ,PRSI .L>>
					<COND
						(<FSET? ,PRSI ,FL-PERSON>
							<TELL The+verb ,PRSI "do" "n't have" the ,PRSO>
						)
						(T
							<TELL The+verb ,PRSO "are" "n't" in ,PRSI the ,PRSI>
						)
					>
					<TELL "." CR>
				)
			>
		)
		(T
			<PRE-TAKE-WITH>
		)
	>
>
 
<ROUTINE PRE-TAKE-WITH ("AUX" X)
	<COND
		(<MC-PRSO? ,YOU>
			<RFALSE>
		)
		(<EQUAL? <META-LOC ,PRSO> ,GLOBAL-OBJECTS>
			<COND
				(<AND <NOT <HELD? ,PRSO>>
						<NOT <FSET? ,PRSO ,FL-PERSON>>
					>
					<NOT-HERE ,PRSO>
				)
			>
		)
		(<IN? ,PRSO ,WINNER>
			<RT-ALREADY-MSG ,PLAYER>
			<TELL " holding" the ,PRSO ".]" CR>
		)
		(<AND <FSET? <LOC ,PRSO> ,FL-CONTAINER>
				<OR
					<NOT <FSET? <LOC ,PRSO> ,FL-SURFACE>>
				;	<NOT <FSET? ,PRSO ,FL-ON>>
				>
				<NOT <FSET? <LOC ,PRSO> ,FL-OPEN>>
			>
			<RT-YOU-CANT-MSG "reach">
		)
		(<IN? ,WINNER ,PRSO>
			<SETG CLOCK-WAIT T>
			<TELL "[" The+verb ,WINNER "are" in ,PRSO the ,PRSO ".]" CR>
		)
	>
>
 
<ROUTINE V-TAKE ("AUX" L V)
	<SET L <LOC ,PRSO>>
	<SET V <ITAKE>>
	<COND
		(<EQUAL? .V ,M-FATAL>
			<RFATAL>
		)
		(.V
			<COND
				(<G? ,P-MULT 1>
					<TELL "Taken">
				)
				(T
					<TELL The+verb ,WINNER "take" the ,PRSO>
					<COND
						(<AND <NOT <IN? .L ,ROOMS>>
								<NOT <EQUAL? .L ,GLOBAL-OBJECTS ,LOCAL-GLOBALS>>
							>
							<TELL " from">
							<COND
								(<AND <EQUAL? .L ,PLAYER>
										<NOT <EQUAL? ,WINNER ,PLAYER>>
									>
									<TELL " you">
								)
								(T
									<TELL the .L>
								)
							>
						)
					>
				)
			>
			<TELL "." CR>
		)
	>
>
 
<ROUTINE V-TAKE-WITH ()
	<TELL "['Take with' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-TALK-TO ()
	<TELL "['Talk to' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-TELL ()
	<COND
		(<EQUAL? ,PRSO ,PLAYER>
			<COND
				(,QCONTEXT
					<SETG QCONTEXT <>>
					<COND
						(,P-CONT
							<SETG WINNER ,PLAYER>
						)
						(T
							<TELL "Okay, you're not talking to anyone else." CR>
						)
					>
				)
				(T
					<WONT-HELP-TO-TALK-TO ,PLAYER>
				;	<SETG QUOTE-FLAG <>>
					<SETG P-CONT <>>
					<RFATAL>
				)
			>
		)
		(<FSET? ,PRSO ,FL-ALIVE>
			<SETG QCONTEXT ,PRSO>
			<COND
				(,P-CONT
					<SETG CLOCK-WAIT T>
					<SETG WINNER ,PRSO>
					<RFALSE>
				)
				(T
					<TELL
The+verb ,PRSO "look" " at you expectantly, as if you seemed to be about to
talk." CR
					>
				)
			>
		)
		(T
			<WONT-HELP-TO-TALK-TO ,PRSO>
		;	<SETG QUOTE-FLAG <>>
			<SETG P-CONT <>>
			<RFATAL>
		)
	>
>
 
<ROUTINE WONT-HELP-TO-TALK-TO (OBJ)
	<TELL "Talking to" the .OBJ " won't help one bit." CR>
>
 
<ROUTINE V-TELL-ABOUT ("AUX" PERSON)
	<COND
		(<MC-PRSO? ,CH-PLAYER>
			<COND
				(<EQUAL? ,WINNER ,CH-PLAYER>
					<COND
						(<OR	<SET PERSON <FIND-FLAG ,HERE ,FL-PERSON ,CH-PLAYER>>
								<SET PERSON <FIND-FLAG ,HERE ,FL-ALIVE ,CH-PLAYER>>
							>
							<PERFORM ,V?ASK-ABOUT .PERSON ,PRSI>
						)
						(T
							<TELL ,K-TALK-TO-SELF-MSG CR>
						)
					>
				)
				(T
					<SET PERSON ,WINNER>
					<SETG WINNER ,CH-PLAYER>
					<PERFORM ,V?ASK-ABOUT .PERSON ,PRSI>
				)
			>
			<RTRUE>
		)
		(<NOT <FSET? ,PRSO ,FL-ALIVE>>
			<TELL The ,WINNER "can't tell anything to" the ,PRSO "." CR>
		)
		(<FSET? ,PRSO ,FL-ASLEEP>
			<TELL
"Talking to" the ,PRSO " in" his ,PRSO " current condition would be a waste
of time." CR
			>
		)
		(T
			<TELL The+verb ,PRSO "shrug" " indifferently." CR>
		)
	>
>
 
<ROUTINE V-THANK ()
	<COND
		(<EQUAL? ,WINNER ,CH-PLAYER>
			<COND
				(<MC-PRSO? ,CH-PLAYER>
					<TELL "Patting yourself on the back won't help." CR>
				)
				(<FSET? ,PRSO ,FL-ASLEEP>
					<TELL
The+verb ,PRSO "is" "n't in any condition to accept your thanks." CR
					>
				)
				(T
					<TELL "\"You're welcome.\"" CR>
				)
			>
		)
		(T
			<RT-FOOLISH-TO-TALK?>
			<RTRUE>
		)
	>
>
 
<ROUTINE V-TIE-TO ()
	<TELL "You can't tie" the ,PRSO " to" the ,PRSI "." CR>
>
 
<ROUTINE V-TURN ()
	<TELL "['Turn' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-TURN-OFF ()
	<TELL "['Turn off' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-TURN-ON ()
	<TELL "['Turn on' currently has no default handling.]|">
	<RFATAL>
>
 
<ROUTINE V-TURN-TO ()
	<TELL "['Turn to' currently has no default handling.]|">
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "U"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-UNDO ()
	<COND
		(,P-CAN-UNDO
			<SETG GL-SL-HERE <>>
			<COND
				(<ZERO? <IRESTORE>>
					<TELL "[UNDO failed.]" CR>
				)
				(T
					<TELL "[UNDO is not available.]" CR>
				)
			>
			<RTRUE>
		)
	>
>
 
<ROUTINE V-UNLOCK ()
	<COND
	;	(<EQUAL? ,P-PRSA-WORD ,W?UNBAR>
			<TELL The+verb ,PRSO "are" "n't barred." CR>
		)
		(<NOT <FSET? ,PRSO ,FL-OPENABLE>>
			<RT-YOU-CANT-MSG>
		)
		(<FSET? ,PRSO ,FL-OPEN>
			<RT-ALREADY-MSG ,PRSO "open">
		)
		(<NOT <FSET? ,PRSO ,FL-LOCKED>>
			<RT-ALREADY-MSG ,PRSO "unlocked">
		)
		(<NOT <RT-MATCH-KEY ,PRSO ,PRSI>>
			<TELL The ,WINNER " can't unlock" the ,PRSO " with" the ,PRSI !\. CR>
		)
		(T
			<RT-OPEN-DOOR-MSG ,PRSO ,PRSI>
		)
	>
>
 
<ROUTINE V-UNWEAR ()
	<COND
		(<IN? ,PRSO ,WINNER>
			<COND
				(<FSET? ,PRSO ,FL-WORN>
					<FCLEAR ,PRSO ,FL-WORN>
					<TELL The+verb ,WINNER "take" " off" the ,PRSO "." CR>
				)
				(T
					<TELL The+verb ,WINNER "are" "n't wearing" the ,PRSO "." CR>
				)
			>
		)
		(T
			<PERFORM ,V?TAKE ,PRSO>
		)
	>
>
 
;"---------------------------------------------------------------------------"
; "W"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-WAIT ("AUX" (N -1) (ABS? <>))
	<COND
		(<NOT ,PRSO>
			<SET N 20>
		)
		(<MC-PRSO? ,INTNUM>
			<COND
				(<G? ,P-NUMBER 0>
					<SET N <* ,P-NUMBER 2>>
				)
			>
		)
		(<MC-PRSO? ,TH-TIME>
			<COND
				(<NOUN-USED? ,PRSO ,W?TURN ,W?TURNS>
					<COND
						(<AND <ADJ-USED? ,PRSO ,W?INT.NUM>
								<G? ,P-NUMBER 0>
							>
							<SET N ,P-NUMBER>
						)
						(T
							<SET N 1>
						)
					>
				)
				(<NOUN-USED? ,PRSO ,W?MIN ,W?MINUTE ,W?MINUTES>
					<COND
						(<AND <ADJ-USED? ,PRSO ,W?INT.NUM>
								<G? ,P-NUMBER 0>
							>
							<SET N <* ,P-NUMBER 2>>
						)
						(T
							<SET N 2>
						)
					>
				)
				(<NOUN-USED? ,PRSO ,W?HOUR ,W?HOURS>
					<COND
						(<AND <ADJ-USED? ,PRSO ,W?INT.NUM>
								<G? ,P-NUMBER 0>
							>
							<SET N <* ,P-NUMBER 120>>
						)
						(T
							<SET N 120>
						)
					>
				)
			>
		)
		(T
			<TELL "[You can't wait for" the ,PRSO ".]|">
			<RFATAL>
		)
	>
	<COND
		(<G? .N 0>
			<SETG GL-MOVES <+ ,GL-MOVES <- .N 1>>>
			<TELL ,K-TIME-PASSES-MSG>
		)
		(.ABS?
			<TELL "[That time has already passed.]|">
			<RFATAL>
		)
		(T
			<TELL "[You can't wait for that.]|">
			<RFATAL>
		)
	>
>
 
<ROUTINE RT-FIND-DIR (RM "OPT" (L <LOC ,WINNER>) "AUX" (P 0) OD)
	<SET OD ,P-WALK-DIR>
	<REPEAT (OBJ PT PTS)
		<COND
			(<OR	<ZERO? <SET P <NEXTP .L .P>>>
					<L? .P ,LOW-DIRECTION>
				>
				<RFALSE>
			)
		>
		<SETG P-WALK-DIR .P>
		<COND
			(<SET PT <GETPT .L .P>>
				<SET PTS <PTSIZE .PT>>
				<COND
					(<EQUAL? .PTS ,UEXIT>
						<COND
							(<EQUAL? .RM <GET/B .PT ,REXIT>>
								<RETURN>
							)
						>
					)
					(<EQUAL? .PTS ,FEXIT>
						<COND
							(<EQUAL? .RM <APPLY <GET .PT ,FEXITFCN> T>>
								<RETURN>
							)
						>
					)
					(<EQUAL? .PTS ,CEXIT>
						<COND
							(<EQUAL? .RM <GET/B .PT ,REXIT>>
								<RETURN>
							)
						>
					)
					(<EQUAL? .PTS ,DEXIT>
						<COND
							(<EQUAL? .RM <GET/B .PT ,REXIT>>
								<COND
									(<SET OBJ <GET/B .PT ,DEXITOBJ>>
										<RETURN>
									)
								>
							)
						>
					)
				>
			)
		>
	>
	<SETG P-WALK-DIR .OD>
	<RETURN .P>
>
 
<ROUTINE RT-FIND-ROOM (DIR "OPT" (L <LOC ,WINNER>) "AUX" OD (RM <>) PT PTS)
	<COND
		(<SET PT <GETPT .L .DIR>>
			<SET PTS <PTSIZE .PT>>
			<COND
				(<EQUAL? .PTS ,UEXIT ,CEXIT ,DEXIT>
					<SET RM <GET/B .PT ,REXIT>>
				)
				(<EQUAL? .PTS ,FEXIT>
					<SET OD ,P-WALK-DIR>
					<SETG P-WALK-DIR .DIR>
					<SET RM <APPLY <GET .PT ,FEXITFCN> T>>
					<SETG P-WALK-DIR .OD>
				)
			>
		)
	>
	<RETURN .RM>
>
 
<GLOBAL GL-PUPPY:OBJECT <>>
 
<ROUTINE RT-SET-PUPPY (OBJ)
	<COND
		(,GL-PUPPY
			<FCLEAR ,GL-PUPPY ,FL-NO-DESC>
		)
	>
	<SETG GL-PUPPY .OBJ>
	<FSET ,GL-PUPPY ,FL-NO-DESC>
>
 
<ROUTINE RT-CLEAR-PUPPY ()
	<COND
		(,GL-PUPPY
			<FCLEAR ,GL-PUPPY ,FL-NO-DESC>
			<SETG GL-PUPPY <>>
		)
	>
	<RTRUE>
>
 
<ROUTINE V-WALK ("AUX" PT PTS STR RM)
	<COND
		(<ZERO? ,P-WALK-DIR>
			<V-WALK-AROUND>
			<RFATAL>
		)
	>
	<COND
		(<SET PT <GETPT <LOC ,WINNER> ,PRSO>>
			<COND
				(<==? <SET PTS <PTSIZE .PT>> ,UEXIT>
					<RT-GOTO <GET/B .PT ,REXIT>>
					<RTRUE>
				)
				(<==? .PTS ,NEXIT>
					<SETG CLOCK-WAIT T>
					<TELL <GET .PT ,NEXITSTR> CR>
					<RFATAL>
				)
				(<==? .PTS ,FEXIT>
					<COND
						(<SET RM <APPLY <GET .PT ,FEXITFCN>>>
							<RT-GOTO .RM>
							<RTRUE>
						)
						(T
							<RFATAL>
						)
					>
				)
				(<==? .PTS ,CEXIT>
					<COND
						(<VALUE <GETB .PT ,CEXITFLAG>>
							<RT-GOTO <GET/B .PT ,REXIT>>
							<RTRUE>
						)
						(<SET STR <GET .PT ,CEXITSTR>>
							<TELL .STR CR>
							<RFATAL>
						)
						(T
							<RT-YOU-CANT-MSG "go">
							<RFATAL>
						)
					>
				)
				(<==? .PTS ,DEXIT>
					<COND
						(<WALK-THRU-DOOR? .PT>
							<RT-GOTO <GET/B .PT ,REXIT>>
							<RTRUE>
						)
						(T
							<RFATAL>
						)
					>
				)
			>
		)
		(<EQUAL? ,PRSO ,P?IN ,P?OUT>
			<V-WALK-AROUND>
		)
		(T
			<RT-YOU-CANT-MSG "go">
			<RFATAL>
		)
	>
>
 
<ROUTINE WALK-THRU-DOOR? (PT "OPT" (OBJ 0) (TELL? T) "AUX" RM)
	<COND
		(<ZERO? .OBJ>
			<SET OBJ <GET/B .PT ,DEXITOBJ>>
		)
	>
	<COND
		(<FSET? .OBJ ,FL-OPEN>
			<RTRUE>
		)
		(<AND .PT
				<SET RM <GET .PT ,DEXITSTR>>
			>
			<COND
				(.TELL?
					<TELL .RM CR>
				)
			>
			<RFALSE>
		)
		(T
			<TELL The+verb .OBJ "are" "n't open." CR>
			<RFALSE>
		)
	>
>
 
<ROUTINE RT-GOTO (RM "OPT" (FORCED? <>))
	<COND
		(<IN? ,WINNER .RM>
			<RT-WALK-WITHIN-ROOM-MSG>
			<RFALSE>
		)
	>
	<COND
		(<APPLY <GETP ,HERE ,P?ACTION> ,M-EXIT>
			<COND
				(<NOT .FORCED?>
					<RFALSE>
				)
			>
		)
	>
	<MOVE ,WINNER .RM>
	<COND
		(<==? ,WINNER ,PLAYER>
			<COND
				(,GL-PUPPY
					<MOVE ,GL-PUPPY .RM>
				)
			>
			<SETG OHERE ,HERE>
			<SETG HERE .RM>
			<RT-ENTER-ROOM>
		)
	>
	<COND
		(,GL-PUPPY
			<TELL TAB The+verb ,GL-PUPPY "follow" " you." CR>
		)
	>
	<RTRUE>
>
 
<ROUTINE RT-ENTER-ROOM ("AUX" VAL CNT TBL)
	<SETG LIT <LIT?>>
	<DIROUT ,D-TABLE-ON ,K-DIROUT-TBL>
	<RT-ROOM-NAME-MSG>
	<DIROUT ,D-TABLE-OFF>
	<SET TBL <ZREST ,K-DIROUT-TBL 2>>
	<SET CNT <ZGET ,K-DIROUT-TBL 0>>
	<COND
		(<G? .CNT 0>
			<REPEAT ((I 0) C)
				<COND
					(<AND <G=? <SET C <GETB .TBL .I>> !\a>
							<L=? .C !\z>
						>
						<PUTB .TBL .I <- .C 32>>
					)
				>
				<COND
					(<IGRTR? I .CNT>
						<RETURN>
					)
				>
			>
		)
	>
	<HLIGHT ,H-BOLD>
	<PRINTT .TBL .CNT>
	<HLIGHT ,H-NORMAL>
	<CRLF>
;	<COND
		(<OR	<EQUAL? ,VERBOSITY 2>
				<AND
					<EQUAL? ,VERBOSITY 1>
					<NOT <FSET? ,HERE ,FL-TOUCHED>>
				>
			>
			<CRLF>
		)
	>
	<APPLY <GETP ,HERE ,P?ACTION> ,M-ENTER>
	<SET VAL
		<COND
			(<RT-DESCRIBE-ROOM>
				<RT-DESCRIBE-OBJECTS>
			)
		>
	>
	<APPLY <GETP ,HERE ,P?ACTION> ,M-ENTERED>
	.VAL
>
 
<ROUTINE RT-ROOM-NAME-MSG ()
	<COND
		(,LIT
			<TELL D ,HERE>
		)
		(T
			<TELL "darkness">
		)
	>
>
 
<ROUTINE V-WALK-AROUND ()
	<SETG CLOCK-WAIT T>
	<TELL "[" ,K-WHICH-DIR-MSG "]" CR>
	<RFATAL>
>
 
<ROUTINE V-WALK-TO ()
	<TELL "['Walk to' currently has no default handling.]|">
	<RFATAL>
>
 
<CONSTANT K-WHICH-DIR-MSG "Which direction do you want to go in?">
 
<ROUTINE RT-WALK-WITHIN-ROOM-MSG ()
	<NO-NEED "move around within" ,HERE>
>
 
<ROUTINE V-WEAR ()
	<COND
		(<NOT <IN? ,PRSO ,WINNER>>
			<TELL The+verb ,WINNER "do" "n't have" the ,PRSO "." CR>
		)
		(<FSET? ,PRSO ,FL-WORN>
			<RT-ALREADY-MSG ,WINNER>
			<TELL " wearing" the ,PRSO ".]" CR>
		)
		(<FSET? ,PRSO ,FL-CLOTHING>
			<FSET ,PRSO ,FL-WORN>
			<TELL The+verb ,WINNER "put" " on" the ,PRSO "." CR>
		)
		(T
			<RT-YOU-CANT-MSG "put on">
		)
	>
>
 
<ROUTINE V-WELD ()
	<TELL "['Weld' currently has no default handling.]|">
	<RFATAL>
>
 
;"---------------------------------------------------------------------------"
; "Y"
;"---------------------------------------------------------------------------"
 
<ROUTINE V-YES ()
	<TELL "[You seem sure of yourself.]" CR>
	<RFATAL>
>
 
;"***************************************************************************"
; "end of file"
;"***************************************************************************"