VEHBIT (IN PROGRESS)

[KVonGit]

;----------------------------------------------------------------------
;"###################### DIRTY HACKS ######################"
;----------------------------------------------------------------------
<ROUTINE DESCRIBE-ROOM (RM "OPT" LONG "AUX" P)
    <COND (<AND <==? .RM ,HERE> <NOT ,HERE-LIT>>
           <DARKNESS-F ,M-LOOK>
           <RFALSE>)>
    ;"Print the room's real name."
    <VERSION? (ZIP) (ELSE <HLIGHT ,H-BOLD>)>
    <TELL D .RM>
    <COND
      (<IN? ,PLAYER ,VEHICLE>
        <TELL " (">
        <COND
          (<FSET? ,VEHICLE ,SURFACEBIT>
            <TELL "o">)
          (T
            <TELL "i" >)>
        <TELL "n " T, VEHICLE ")" >)>
    <CRLF>
    <VERSION? (ZIP) (ELSE <HLIGHT ,H-NORMAL>)>
    ;"If this is an implicit LOOK, check briefness."
    <COND (<NOT .LONG>
           <COND (<EQUAL? ,MODE ,SUPERBRIEF>
                  <RFALSE>)
                 (<AND <FSET? .RM ,TOUCHBIT>
                       <NOT <EQUAL? ,MODE ,VERBOSE>>>
                  ;"Call the room's ACTION with M-FLASH even in brief mode."
                  <APPLY <GETP .RM ,P?ACTION> ,M-FLASH>
                  <RTRUE>)>)>
    ;"The room's ACTION can print a description with M-LOOK.
      Otherwise, print the LDESC if present."
    <COND (<APPLY <GETP .RM ,P?ACTION> ,M-LOOK>)
          (<SET P <GETP .RM ,P?LDESC>>
           <TELL .P CR>)>
    ;"Call the room's ACTION again with M-FLASH for important descriptions."
    <APPLY <GETP .RM ,P?ACTION> ,M-FLASH>
    ;"Mark the room visited."
    <FSET .RM ,TOUCHBIT>
    <RTRUE>>


<ROUTINE V-WALK ("AUX" PT PTS RM D)
    <COND (<NOT ,PRSO-DIR>
           <PRINTR "You must give a direction to walk in.">)
          (<0? <SET PT <GETPT ,HERE ,PRSO>>>
           <COND (<OR ,HERE-LIT <NOT <DARKNESS-F ,M-DARK-CANT-GO>>>
                  <TELL ,CANT-GO-THAT-WAY CR>)>
           <SETG P-CONT 0>
           <RTRUE>)
          (<==? <SET PTS <PTSIZE .PT>> ,UEXIT>
           <SET RM <GET/B .PT ,EXIT-RM>>)
          (<==? .PTS ,NEXIT>
           <TELL <GET .PT ,NEXIT-MSG> CR>
           <SETG P-CONT 0>
           <RTRUE>)
          (<==? .PTS ,FEXIT>
           <COND (<0? <SET RM <APPLY <GET .PT ,FEXIT-RTN>>>>
                  <SETG P-CONT 0>
                  <RTRUE>)>)
          (<==? .PTS ,CEXIT>
           <COND (<VALUE <GETB .PT ,CEXIT-VAR>>
                  <SET RM <GET/B .PT ,EXIT-RM>>)
                 (ELSE
                  <COND (<SET RM <GET .PT ,CEXIT-MSG>>
                         <TELL .RM CR>)
                        (<AND <NOT ,HERE-LIT> <DARKNESS-F ,M-DARK-CANT-GO>>
                         ;"DARKNESS-F printed a message")
                        (ELSE
                         <TELL ,CANT-GO-THAT-WAY CR>)>
                  <SETG P-CONT 0>
                  <RTRUE>)>)
          (<==? .PTS ,DEXIT>
           <COND (<FSET? <SET D <GET/B .PT ,DEXIT-OBJ>> ,OPENBIT>
                  <SET RM <GET/B .PT ,EXIT-RM>>)
                 (<SET RM <GET .PT ,DEXIT-MSG>>
                  <TELL .RM CR>
                  <SETG P-CONT 0>
                  <RTRUE>)
                 (ELSE
                  <THIS-IS-IT .D>
                  <TELL "You'll have to open " T .D
                        " first." CR>
                  <SETG P-CONT 0>
                  <RTRUE>)>)
          (ELSE
           <TELL "Broken exit (" N .PTS ")." CR>
           <SETG P-CONT 0>
           <RTRUE>)>
    <COND
      (<IN? ,PLAYER ,VEHICLE>
        <MOVE ,VEHICLE .RM>
        <SET HERE .RM>
        <DESCRIBE-ROOM .RM>)
      (T
        <GOTO .RM>)>>

<ROUTINE RESTORE-PARSER-RESULT (SRC "AUX" L (OW ,WINNER))
    <SETG P-V-WORD <PST-V-WORD .SRC>>
    <SETG P-P1 <PST-P1 .SRC>>
    <SETG P-P2 <PST-P2 .SRC>>
    <SETG P-SYNTAX <PST-SYNTAX .SRC>>
    <COPY-PRSTBL <PST-PRSOS .SRC> ,P-PRSOS>
    <COPY-PRSTBL <PST-PRSIS .SRC> ,P-PRSIS>
    <SETG P-NUMBER <PST-NUMBER .SRC>>
    <COPY-LEXBUF <PST-LEXBUF .SRC> ,LEXBUF>
    <COPY-READBUF <PST-READBUF .SRC> ,READBUF>
    <SETG WINNER <PST-WINNER .SRC>>
    <SETG P-LEN <PST-LEN .SRC>>
    <SETG P-V <PST-V .SRC>>
    <SETG P-V-WORDN <PST-V-WORDN .SRC>>
    <SETG P-NOBJ <PST-NOBJ .SRC>>
    <SETG PRSO-DIR <PST-PRSO-DIR .SRC>>
    <SETG PRSA <PST-PRSA .SRC>>
    ;"Set variables calculated from these"
    <COND (,PRSO-DIR
           <SETG PRSO ,PRSO-DIR>
           <SETG PRSO-DIR T>)
          (<OR <L? ,P-NOBJ 1>
               <0? <SET L <GETB ,P-PRSOS 0>>>>
           <SETG PRSO <>>)
          (<1? .L>
           <SETG PRSO <GET/B ,P-PRSOS 1>>)
          (ELSE <SETG PRSO ,MANY-OBJECTS>)>
    <COND (<OR <L? ,P-NOBJ 2>
               <0? <SET L <GETB ,P-PRSIS 0>>>>
           <SETG PRSI <>>)
          (<1? .L>
           <SETG PRSI <GET/B ,P-PRSIS 1>>)
          (ELSE <SETG PRSI ,MANY-OBJECTS>)>
    <COND (<N=? ,WINNER .OW <>>
           <COND (<NOT <FSET? <LOC ,WINNER> ,VEHBIT>>
		          <SETG HERE <LOC ,WINNER>>)>
           <SETG HERE-LIT <SEARCH-FOR-LIGHT>>)>>

<DEFAULT-DEFINITION MAIN-LOOP-END-OF-COMMAND
    <DEFMAC MAIN-LOOP-END-OF-COMMAND ()
        '<BIND ()
            <COND (<NOT <FSET? <LOC ,WINNER> ,VEHBIT>>
		          <SETG HERE <LOC ,WINNER>>)>
            <HOOK-END-OF-COMMAND>>>>

<ROUTINE PARSER ("AUX" NOBJ VAL DIR DIR-WN O-R KEEP OW OH OHL)
    ;"Need to (re)initialize locals here since we use AGAIN"
    <SET OW ,WINNER>
    <SET OH ,HERE>
    <SET OHL ,HERE-LIT>
    <SET NOBJ <>>
    <SET VAL <>>
    <SET DIR <>>
    <SET DIR-WN <>>
    ;"Fill READBUF and LEXBUF"
    <COND (<L? ,P-CONT 0> <SETG P-CONT 0>)>
    <COND (,P-CONT
           <TRACE 1 "[PARSER: continuing from word " N ,P-CONT "]" CR>
           <ACTIVATE-BUFS "CONT">
           <COND (<1? ,P-CONT> <SETG P-CONT 0>)
                 (<N=? ,MODE ,SUPERBRIEF>
                  ;"Print a blank line between multiple commands"
                  <COND (<NOT <VERB? TELL>> <CRLF>)>)>)
          (ELSE
           <TRACE 1 "[PARSER: fresh input]" CR>
           <RESET-WINNER>
           <COND (<NOT <FSET? <LOC ,WINNER> ,VEHBIT>>
		          <SETG HERE <LOC ,WINNER>>)>
           <SETG HERE-LIT <SEARCH-FOR-LIGHT>>
           <READLINE T>)>

    <IF-DEBUG <SETG TRACE-INDENT 0>>
    <TRACE-DO 1 <DUMPBUFS> ;<DUMPLINE>>
    <TRACE-IN>

    <SETG P-LEN <GETB ,LEXBUF 1>>
    <COND (<0? ,P-LEN>
           <TELL "..." CR>
           <SETG P-CONT 0>
           <RFALSE>)>

    ;"Save undo state unless this looks like an undo command"
    <IF-UNDO
        <COND (<AND <G=? ,P-LEN 1>
                    <=? <GETWORD? 1> ,W?UNDO>
                    <OR <1? ,P-LEN>
                        <=? <GETWORD? 2> ,W?\. ,W?THEN>>>)
              (ELSE
               <TRACE 4 "[saving for UNDO]" CR>
               <BIND ((RES <ISAVE>))
                   <COND (<=? .RES 2>
                          <TELL "Previous turn undone." CR CR>
                          <SETG WINNER .OW>
                          <SETG HERE .OH>
                          <SETG HERE-LIT .OHL>
                          <V-LOOK>
                          <SETG P-CONT 0>
                          <AGAIN>)
                         (ELSE
                          <SETG USAVE .RES>)>>)>>

    <COND (<0? ,P-CONT>
           ;"Handle OOPS"
           <COND (<AND ,P-LEN <=? <GETWORD? 1> ,W?OOPS>>
                  <COND (<=? ,P-LEN 2>
                         <COND (<P-OOPS-WN>
                                <TRACE 2 "[handling OOPS]" CR>
                                <HANDLE-OOPS 2>
                                <SETG P-LEN <GETB ,LEXBUF 1>>
                                <TRACE-DO 1 <DUMPLINE>>)
                               (ELSE
                                <TELL "Nothing to correct." CR>
                                <RFALSE>)>)
                        (<=? ,P-LEN 1>
                         <TELL "It's OK." CR>
                         <RFALSE>)
                        (ELSE
                         <TELL "You can only correct one word at a time." CR>
                         <RFALSE>)>)>)>

    <SET KEEP 0>
    <P-OOPS-WN 0>
    <P-OOPS-CONT 0>
    <P-OOPS-O-REASON ,P-O-REASON>

    <COND (<0? ,P-CONT>
           ;"Save command in edit buffer for OOPS"
           <COND (<N=? ,READBUF ,EDIT-READBUF>
                  <COPY-TO-BUFS "EDIT">
                  <ACTIVATE-BUFS "EDIT">)>
           ;"Handle an orphan response, which may abort parsing or ask us to skip steps"
           <COND (<ORPHANING?>
                  <SET O-R <HANDLE-ORPHAN-RESPONSE>>
                  <COND (<N=? .O-R ,O-RES-NOT-HANDLED>
                         <SETG WINNER .OW>
                         <SETG HERE .OH>
                         <SETG HERE-LIT .OHL>)>
                  <COND (<=? .O-R ,O-RES-REORPHANED>
                         <TRACE-OUT>
                         <RFALSE>)
                        (<=? .O-R ,O-RES-FAILED>
                         <SETG P-O-REASON <>>
                         <TRACE-OUT>
                         <RFALSE>)
                        (<=? .O-R ,O-RES-SET-NP>
                         ;"TODO: Set the P-variables somewhere else? Shouldn't we fill in what
                           we know about the command-to-be when we ask the orphaning question, not
                           when we get the response?"
                         <SETG P-P1 <GETB ,P-SYNTAX ,SYN-PREP1>>
                         <COND (<ORPHANING-PRSI?>
                                <SETG P-P2 <GETB ,P-SYNTAX ,SYN-PREP2>>
                                <SETG P-NOBJ 2>
                                ;"Don't re-match P-NP-DOBJ when we've just orphaned PRSI. Use the saved
                                  match results. There won't be a NP to match if we GWIMmed PRSO."
                                <SET KEEP 1>)
                               (ELSE <SETG P-NOBJ 1>)>)
                        (<=? .O-R ,O-RES-SET-PRSTBL>
                         <COND (<ORPHANING-PRSI?> <SET KEEP 2>)
                               (ELSE <SET KEEP 1>)>)>
                  <SETG P-O-REASON <>>)>
           ;"If we aren't handling this command as an orphan response, convert it if needed
             and copy it to CONT bufs"
           <COND (<NOT .O-R>
                  ;"Translate order syntax (HAL, OPEN THE POD BAY DOOR or
                    TELL HAL TO OPEN THE POD BAY DOOR) into multi-command syntax
                    (\,TELL HAL THEN OPEN THE POD BAY DOOR)."
                  <COND (<CONVERT-ORDER-TO-TELL?>
                         <SETG P-LEN <GETB ,LEXBUF 1>>)>)>)>

    ;"Identify parts of speech, parse noun phrases"
    <COND (<N=? .O-R ,O-RES-SET-NP ,O-RES-SET-PRSTBL>
           <SETG P-V <>>
           <SETG P-NOBJ 0>
           <CLEAR-NOUN-PHRASE ,P-NP-DOBJ>
           <CLEAR-NOUN-PHRASE ,P-NP-IOBJ>
           <SETG P-P1 <>>
           <SETG P-P2 <>>
           ;"Identify the verb, prepositions, and noun phrases"
           <REPEAT ((I <OR ,P-CONT 1>) W V)
               <COND (<G? .I ,P-LEN>
                      ;"Reached the end of the command"
                      <SETG P-CONT 0>
                      <RETURN>)
                     (<NOT <OR <SET W <GETWORD? .I>>
                               <AND <PARSE-NUMBER? .I> <SET W ,W?\,NUMBER>>>>
                      ;"Word not in vocabulary"
                      <STORE-OOPS .I>
                      <SETG P-CONT 0>
                      <TELL "I don't know the word \"" WORD .I "\"." CR>
                      <RFALSE>)
                     (<=? .W ,W?THEN ,W?\.>
                      ;"End of command, maybe start of a new one"
                      <TRACE 3 "['then' word " N .I "]" CR>
                      <SETG P-CONT <+ .I 1>>
                      <COND (<G? ,P-CONT ,P-LEN> <SETG P-CONT 0>)
                            (ELSE <COPY-TO-BUFS "CONT">)>
                      <RETURN>)
                     (<AND <NOT ,P-V>
                           <SET V <WORD? .W VERB>>
                           <OR <NOT .DIR> <=? .V ,ACT?WALK>>>
                      ;"Found the verb"
                      <SETG P-V-WORD .W>
                      <SETG P-V-WORDN .I>
                      <SETG P-V .V>
                      <TRACE 3 "[verb word " N ,P-V-WORDN " '" B ,P-V-WORD "' = " N ,P-V "]" CR>)
                     (<AND <NOT .DIR>
                           <EQUAL? ,P-V <> ,ACT?WALK>
                           <SET VAL <WORD? .W DIRECTION>>>
                      ;"Found a direction"
                      <SET DIR .VAL>
                      <SET DIR-WN .I>
                      <TRACE 3 "[got a direction]" CR>)
                     (<SET VAL <CHKWORD? .W ,PS?PREPOSITION 0>>
                      ;"Found a preposition"
                      ;"Only keep the first preposition for each object"
                      <COND (<AND <==? .NOBJ 0> <NOT ,P-P1>>
                             <TRACE 3 "[P1 word " N .I " '" B .W "' = " N .VAL "]" CR>
                             <SETG P-P1 .VAL>)
                            (<AND <==? .NOBJ 1> <NOT ,P-P2>>
                             <TRACE 3 "[P2 word " N .I " '" B .W "' = " N .VAL "]" CR>
                             <SETG P-P2 .VAL>)>)
                     (<STARTS-NOUN-PHRASE? .W>
                      ;"Found a noun phrase"
                      <SET NOBJ <+ .NOBJ 1>>
                      <TRACE 3 "[NP start word " N .I ", now NOBJ=" N .NOBJ "]" CR>
                      <TRACE-IN>
                      <COND (<==? .NOBJ 1>
                             ;"If we found a direction earlier, try it as a preposition instead"
                             ;"This fixes GO IN BUILDING (vs. GO IN)"
                             <COND (<AND .DIR
                                         ,P-V
                                         <NOT ,P-P1>
                                         <SET V <GETWORD? .DIR-WN>>
                                         <SET VAL <CHKWORD? .V ,PS?PREPOSITION 0>>>
                                    <TRACE 3 "[revising direction word " N .DIR-WN
                                             " as P1: '" B .V "' = " N .VAL "]" CR>
                                    <SETG P-P1 .VAL>
                                    <SET DIR <>>
                                    <SET DIR-WN <>>)>
                             <SET VAL <PARSE-NOUN-PHRASE .I ,P-NP-DOBJ>>)
                            (<==? .NOBJ 2>
                             <SET VAL <PARSE-NOUN-PHRASE .I ,P-NP-IOBJ>>)
                            (ELSE
                             <SETG P-CONT 0>
                             <TELL "That sentence has too many objects." CR>
                             <RFALSE>)>
                      <TRACE 3 "[PARSE-NOUN-PHRASE returned " N .VAL "]" CR>
                      <TRACE-OUT>
                      <COND (.VAL
                             <SET I .VAL>
                             <AGAIN>)
                            (ELSE
                             <SETG P-CONT 0>
                             <RFALSE>)>)
                     (ELSE
                      ;"Unexpected word type"
                      <STORE-OOPS .I>
                      <SETG P-CONT 0>
                      <TELL "I didn't expect the word \"" WORD .I "\" there." CR>
                      <TRACE-OUT>
                      <RFALSE>)>
               <SET I <+ .I 1>>>

           <SETG P-NOBJ .NOBJ>

           <TRACE-OUT>
           <TRACE 1 "[sentence: V=" MATCHING-WORD ,P-V ,PS?VERB ,P1?VERB "(" N ,P-V ") NOBJ=" N ,P-NOBJ
                 " P1=" MATCHING-WORD ,P-P1 ,PS?PREPOSITION 0 "(" N ,P-P1
                 ") DOBJS=+" N <NP-YCNT ,P-NP-DOBJ> "-" N <NP-NCNT ,P-NP-DOBJ>
                 " P2=" MATCHING-WORD ,P-P2 ,PS?PREPOSITION 0 "(" N ,P-P2
                 ") IOBJS=+" N <NP-YCNT ,P-NP-IOBJ> "-" N <NP-NCNT ,P-NP-IOBJ> "]" CR>
           <TRACE-IN>

           ;"If we have a direction and nothing else except maybe a WALK verb, it's
             a movement command."
           <COND (<AND .DIR
                       <EQUAL? ,P-V <> ,ACT?WALK>
                       <0? .NOBJ>
                       <NOT ,P-P1>
                       <NOT ,P-P2>>
                  <SETG PRSO-DIR T>
                  <SETG PRSA ,V?WALK>
                  <SETG PRSO .DIR>
                  <SETG PRSI <>>
                  <COND (<NOT <VERB? AGAIN>>
                         <TRACE 4 "[saving for AGAIN]" CR>
                         <SAVE-PARSER-RESULT ,AGAIN-STORAGE>)>
                  <TRACE-OUT>
                  <RTRUE>)>
           ;"Otherwise, a verb is required and a direction is forbidden."
           <COND (<NOT ,P-V>
                  <SETG P-CONT 0>
                  <TELL "That sentence has no verb." CR>
                  <TRACE-OUT>
                  <RFALSE>)
                 (.DIR
                  <STORE-OOPS .DIR-WN>
                  <SETG P-CONT 0>
                  <TELL "I don't understand what \"" WORD .DIR-WN "\" is doing in that sentence." CR>
                  <TRACE-OUT>
                  <RFALSE>)>
           <SETG PRSO-DIR <>>)>
    ;"Match syntax lines and objects"
    <COND (<NOT .O-R>
           <TRACE 2 "[matching syntax and finding objects, KEEP=" N .KEEP "]" CR>
           <COND (<NOT <AND <MATCH-SYNTAX> <FIND-OBJECTS .KEEP>>>
                  <TRACE-OUT>
                  <SETG P-CONT 0>
                  <RFALSE>)>)
          (<L? .KEEP 2>
           ;"We already found a syntax line last time, but we need FIND-OBJECTS to
             match at least one noun phrase."
           <TRACE 2 "[only finding objects, KEEP=" N .KEEP "]" CR>
           <COND (<NOT <FIND-OBJECTS .KEEP>>
                  <TRACE-OUT>
                  <SETG P-CONT 0>
                  <RFALSE>)>)>
    ;"Save command for AGAIN"
    <COND (<NOT <VERB? AGAIN>>
           <TRACE 4 "[saving for AGAIN]" CR>
           <SAVE-PARSER-RESULT ,AGAIN-STORAGE>)>
    ;"If successful PRSO, back up PRSO for IT"
    <SET-PRONOUNS ,PRSO ,P-PRSOS>
    <TRACE-OUT>
    <RTRUE>>

[KVonGit]

<ROUTINE VISIBLE? (OBJ "AUX" P M PL)
  <TELL "VISIBLE?" CR>
  <COND 
    (<=? .OBJ ,PSEUDO-OBJECT>
      <RETURN <=? ,HERE ,PSEUDO-LOC>>)>
  <SET P <LOC .OBJ>>
  <COND
    (<0? .P>
      <RFALSE>)>
  <SET M <META-LOC .OBJ>>
  <SET PL <LOC ,WINNER>> ;"Get player's container if any"
  <COND
    (<NOT <=? .M ,HERE>>
      <COND
        (<AND .PL ;"If player is in something"
           <TELL "IN SOMETHING" CR>
              <OR <FSET? .PL ,TRANSBIT> 
                  <FSET? .PL ,OPENBIT>
                  <FSET? .PL ,SURFACEBIT>>
              <=? .M .PL>>
          <RTRUE>) ;"Can see into player's container"
        (<OR <AND <=? .P ,LOCAL-GLOBALS> <GLOBAL-IN? .OBJ ,HERE>> 
             <=? .P ,GLOBAL-OBJECTS ,GENERIC-OBJECTS>>
            <RTRUE>)
        (ELSE
          <RFALSE>)>)>
  <REPEAT ()
    <COND
      (<EQUAL? .P ,HERE ,WINNER>
        <RTRUE>)
      (<NOT <SEE-INSIDE? .P>>
        <RFALSE>)
      (ELSE
        <SET P <LOC .P>>)>>>

;"TODO - Check out UNTOUCHABLE? instead!!!"
<ROUTINE ACCESSIBLE? (OBJ "AUX" L PL)
  <TELL "ACCESSIBLE?" CR>
  <TELL "OBJ: " T .OBJ "" CR>
  <TELL "META-LOC: " T <META-LOC .OBJ> "" CR>
  <TELL "HERE: " D ,HERE CR>
  <TELL "WINNER: " T ,WINNER CR>
  <TELL "WINNER-LOC: " D <LOC ,WINNER> CR>
  <SET L <LOC .OBJ>>
  <SET PL <LOC ,WINNER>>
  
  ;"First check if player is in something"
  <COND (<AND .PL ;"Player is in a container"
              <NOT <OR <FSET? .PL ,SURFACEBIT>  ;"Not a surface"
                      <AND <FSET? .PL ,CONTBIT>  ;"Not an open container"
                           <FSET? .PL ,OPENBIT>>>>>
         <TELL "DEBUG: Can't reach outside container" CR>
         <RFALSE>)>
         
  ;"Then do the normal container checks"
  <REPEAT ()
    <COND (<AND <FSET? .L ,CONTBIT> 
                <NOT <FSET? .L ,OPENBIT>> 
                <NOT <FSET? .L ,SURFACEBIT>>>
           <RFALSE>)
          (<EQUAL? .L ,HERE ,WINNER>
           <RTRUE>)
          (ELSE
           <SET L <LOC .L>>)>>>

[KVonGit]

<SYNTAX BOARD OBJECT = V-BOARD>
<VERB-SYNONYM BOARD RIDE MOUNT>

<ROUTINE V-BOARD ()
  <COND
    (<NOT <FSET? ,PRSO ,VEHBIT>>
     <TELL T ,PRSO " can't be boarded." CR>
     <RETURN T>)
    (<==? ,PRSO ,VEHICLE>
     <TELL "You're already on " T ,PRSO "." CR>
     <RETURN T>)
    (<IN? ,PRSO ,PLAYER>
     <TELL "You can't ride something you're already holding." CR>
     <RETURN T>)
    (<NOT <ACCESSIBLE? ,PRSO>>
     <TELL "You can't reach " T ,PRSO "." CR>
     <RETURN T>)
    (T
     <MOVE ,PLAYER ,PRSO>
     <SETG VEHICLE ,PRSO>
     <FSET ,VEHICLE ,NDESCBIT>
     <TELL "Done." CR>
     <V-LOOK>)>>

<SYNTAX EXIT = V-EXIT>
<SYNTAX EXIT OBJECT = V-EXIT>
<VERB-SYNONYM EXIT DEPART WITHDR DISMOUNT>


<ROUTINE V-EXIT ()
     <COND
       (<OR <AND <NOT ,PRSO> <IN? ,PLAYER ,VEHICLE>> <FSET? ,PRSO ,VEHBIT>>
         <MOVE ,PLAYER ,HERE>
          <FCLEAR ,PRSO ,NDESCBIT>
          <V-LOOK>
          <RTRUE>)
      (T
        <DO-WALK ,P?OUT>)>>

[KVonGit]

<GLOBAL VEHICLE <>>

<OBJECT HORSE
  (DESC "horse")
  (IN NMEADOW)
  (FLAGS VEHBIT CONTBIT SURFACEBIT SEARCHBIT OPENBIT)
  (SYNONYM HORSE)
  (ACTION HORSE-R)>

<ROUTINE HORSE-R ()
  <COND 
    (<VERB? TAKE OPEN CLOSE LOCK UNLOCK PUSH PULL SEARCH>
      <COND
        (<PRSO? ,HORSE><SILLY>)
        (<AND <IN? ,PLAYER ,HORSE> <NOT <IN? ,PRSO ,HORSE>>>
          <TELL "You can't reach " T ,PRSO " from the horse." CR>)>)
    (<VERB? EXAMINE>
        <TELL "A perfectly ordinary horse." CR>)
    (<VERB? PET>
      <TELL "You pet the horse, and he seems just a ">
      <ITALICIZE "little">
      <TELL " bit happier with you now." CR>)
    (<VERB? BOARD>
      <COND
        (<IN? ,PLAYER ,HORSE>
          <TELL "You're already on it!" CR>)
        (T
          <TELL "You mount the horse." CR>
        <MOVE ,PLAYER ,PRSO>
        <FSET ,HORSE ,NDESCBIT>
        <SETG VEHICLE ,PRSO>)>)>>

[KVonGit]

<ROUTINE ENTER-SALOON-R ()
  <COND
    (<IN? ,PLAYER ,VEHICLE>
      <TELL "\"You can't enter while on horseback!\" says the barman." CR CR>
      <SETG P-CONT 0>
      <RETURN ,HERE>)
    (T
      <RETURN ,SALOON>)>>

<OBJECT SALOON
  (DESC "Saloon")
  (IN ROOMS)
  (FLAGS LIGHTBIT OUTSIDEBIT)
  (IN PER ENTER-SALOON-R)
  (SOUTH MAIN-STREET)
  (ACTION SALOON-R)>

[KVonGit]

;"-----------------------------------------------------------------------------"
;"                                TODO                                         "
;"-----------------------------------------------------------------------------"

;"V-DROP (or PRE-DROP?) needs to check for the player's LOC, not HERE"

;"V-EXAMINE needs to add NDESCBIT to the player before examining something the "
;"  player is in, then remove NDESCBIT after"

;"V-LOOK needs to do the same."

;"DESCRIBE-OBJECT needs to check if things HERE are in/outside of the player's "
;" LOC, and add '(outside' T, LOC ')' to their DESC when printing."