}* FREE TUTORIAL EXAMPLE PROGRAM IN LISA GJ2 FIC3 WRITTEN BY }*
}* ARISTO W.LAH, NORMAL YOGA4D CFDL,  2011:3:11              }*
}* BODYBOOK.TXT IS A SIMPLE GAME THAT TRAINS THE ARTISTIC    }* 
}* EYE AND CALLS ON ONE'S OWN POWERS OF ARRANGING ORDERS     }* 
}* OF ESTHETICS, WITH ONE OWN INNER SCORE. BE SURE TO HAVE   }* 
}* FOLDER BODYBOOK WITH ITS SIXTEEN GJP'S UNDER BOEHMIAN.    }* 
}* NEWCOMERS TO PROGRAMMING MAY DISCOVER HERE, AS THE        }* 
}* PROGRAM IS MADE ALSO SO AS TO SHOW SOME APPROACHES TO     }* 
}* PROGRAMMING, SUCH AS: HOW TO DO COUNT-LOOP WHICH COUNTS   }* 
}* BY ALSO SKIPPING ONE (SEE THE INCN1 INSIDE THEM), HOW TO  }*
}* EXIT FROM DOUBLE COUNT-LOOPS (SEE RMS RMS RMS RMS),       }* 
}* AND HOW USE SEVERAL LEVELS OF (MATCH .. )(OTHER ..        }* 
}* WITH GOOD SPACING, AND HOW TO SOMETIMES SKIP THE => &     }* 
}* IN FRONT OF SMALL ROUTINES, SEE THE PUSH-ONE-UP-.. AND    }* 
}* SUCH. IT COULD BE WRITTEN MORE COMPRESSED BUT             }* 
}* IT IS AFTER ALL FAIRLY EASY TO READ, AND SO IT IS         }* 
}* PSYCHOLOGICALLY FIRST-HAND AND THAT HAS A HIGHER PRIORITY }* 
}* THAN HOW MANY LINES YOUR PROGRAM IS.                      }* 
}* THE PROGRAM IS WRITTEN QUICKLY WITH MUCH USE OF           }* 
}* COPY AND PASTE ON THE B9 EDITOR!!! ;)                     }* 
((DATA GJP-IMAGE                  
  200 ; 200 => RAM-PM GJP-IMAGE <<ASSERT )) 
((DATA GAME-BOARD                   
  4 ; 4 => RAM-PM GAME-BOARD <<ASSERT )) 
((DATA PLAYER-POS-X 
  3 PLAYER-POS-X <<ASSERT ))
((DATA PLAYER-POS-Y 
  2 PLAYER-POS-Y <<ASSERT ))
(LET BODYBOOK-INTRO BE (( ))
  ((
    (( }F3'S BODYBOOK} ;
      750 ; 25 => B9-POP ))
    (( }HOW TO PLAY:} ;     
      750 ; 50 => B9-POP ))
    (( }YOU MAKE A NEW} ;     
      750 ; 75 => B9-POP ))
    (( }GOAL/PLAN FOR} ;     
      750 ; 100 => B9-POP ))
    (( }HOW TO ARRANGE} ;     
      750 ; 125 => B9-POP ))
    (( }EACH TIME, AND} ;     
      750 ; 150 => B9-POP ))
    (( }USE YOUR INNER} ;     
      750 ; 175 => B9-POP ))
    (( }SENSE OF BEAUTY.} ;     
      750 ; 200 => B9-POP ))
    (( }GIVE YOURSELF A} ; 
      750 ; 225 => B9-POP ))
    (( }SCORE IF YOU GET} ; 
      750 ; 250 => B9-POP ))
    (( }TO FULFILL YOUR} ; 
      750 ; 275 => B9-POP ))
    (( }GOAL QUICKLY. USE} ; 
      750 ; 300 => B9-POP ))
    (( }ARROWS AND ENTER!} ; 
      750 ; 325 => B9-POP ))
  )) OK)
(LET COMPRESSED BE (( & >N4 >N2 ))
  ((
    (( 200
      (COUNT
        (( 200
          (COUNT
            (( N6 ; N1 => DIV2 => ADD ;
              N8 ; N3 => DIV2 => ADD ;
              N1 ; N3 ; # => GM => PUTPIXEL ))
            (( INCN1 ))
          COUNTUP) ))
        (( INCN1 ))
      COUNTUP) ))
    (( && ))
  )) OK)
(( LOOKSTK ))
(LET COINCIDENCE-CONFIGURATION BE (( )) 
  ((
    (( GAME-BOARD >>> => & ))
    (( 4
      (COUNT
        (( 4
          (COUNT
            (( 16 => FUNNYRFFG ; N1 ; N3 ; # => PM ))
          COUNTUP) ))
      COUNTUP) ))
    (( 0 ; 3 ; 2 ; # => PM ))
    (( && ))
  )) OK)
(LET LOAD-THIS-IMAGE BE (( >N1 ))
  ((
    (( GJP-IMAGE >>> => & ))  
    (( # => CLEAR-MATRIX ))
    (( N1 => ISPRO
      (MATCHED
        (( }BODYBOOK/} ; N1 => CONCAT ;
          }.GJP} => CONCAT ; # =>
          GJPFILE2PM ; RM ))
      MATCHED) ))
    (( && ))
  )) OK)
(LET SHOW-ALL BE (( )) 
  ((
    (( GAME-BOARD >>> => & ))
    (( 4
      (COUNT
        (( 4
          (COUNT
            (( N1 ; N3 ; # => GM => LOAD-THIS-IMAGE ))
            (( N1 ; 130 => MUL ; 20 => ADD ;
              N3 ; 130 => MUL ; 20 => ADD ; GJP-IMAGE >>> =>
              COMPRESSED ))
          COUNTUP) ))
      COUNTUP) ))
    (( && ))
  )) OK)
(LET FIND-FREELY-THE-FREE BE (( ))                 
  ((
    (( GAME-BOARD >>> => & ))
    (( 4
      (COUNT
        (( 4
          (COUNT
            (( N1 ; N3 ; # => GM => ISBASIS 
              = N1 ; N3 ; RMS RMS RMS RMS ; && ; EXIT => => === ))
          COUNTUP) ))
      COUNTUP) ))
    (( && ))
  )) OK)
(LET VIEWS BE (( >N5 >N4 )) 
  ((
    (( N4 ; N5 ; # => GM => LOAD-THIS-IMAGE ))
    (( N4 ; 130 => MUL ; 20 => ADD ;
      N5 ; 130 => MUL ; 20 => ADD ; GJP-IMAGE >>> =>
      COMPRESSED ))
  )) OK)
(LET PUSH-TWO-TO-THE-RIGHT BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 INC ; N9 ; # => GM ; ; ))
    (( ; ; 0 ; N8 ; N9 ; # => PM ; ; ))
    (( ; ; N8 INC INC ; N9 ; # => PM ; ))
    (( ; N8 INC ; N9 ; # => PM ))
    (( N8 INC INC ; N9 => VIEWS ))
    (( N8 INC ; N9 => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-THREE-TO-THE-RIGHT BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 INC ; N9 ; # => GM ; ; ))
    (( ; ; N8 INC INC ; N9 ; # => GM ; ; ; ))
    (( ; ; ; 0 ; N8 ; N9 ; # => PM ; ; ; ))
    (( ; ; ; N8 INC INC INC ; N9 ; # => PM ; ; ))
    (( ; ; N8 INC INC ; N9 ; # => PM ; ))
    (( ; N8 INC ; N9 ; # => PM ))
    (( N8 INC INC INC ; N9 => VIEWS ))
    (( N8 INC INC ; N9 => VIEWS ))
    (( N8 INC ; N9 => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-ONE-TO-THE-RIGHT BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; N8 INC ; N9 ; # => PM ))
    (( 0 ; N8 ; N9 ; # => PM ))
    (( N8 INC ; N9 => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-TWO-UP BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 ; N9 DEC ; # => GM ; ; ))
    (( ; ; 0 ; N8 ; N9 ; # => PM ; ; ))
    (( ; ; N8 ; N9 DEC DEC ; # => PM ; ))
    (( ; N8 ; N9 DEC ; # => PM ))
    (( N8 ; N9 DEC DEC => VIEWS ))
    (( N8 ; N9 DEC => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-THREE-UP BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 ; N9 DEC ; # => GM ; ; ))
    (( ; N8 ; N9 DEC DEC ; # => GM ; ; ; ))
    (( ; ; ; 0 ; N8 ; N9 ; # => PM ; ; ; ))
    (( ; ; ; N8 ; N9 DEC DEC DEC ; # => PM ; ; ))
    (( ; ; N8 ; N9 DEC DEC ; # => PM ; ))
    (( ; N8 ; N9 DEC ; # => PM ))
    (( N8 ; N9 DEC DEC DEC => VIEWS ))
    (( N8 ; N9 DEC DEC => VIEWS ))
    (( N8 ; N9 DEC => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-ONE-UP BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; N8 ; N9 DEC ; # => PM ))
    (( 0 ; N8 ; N9 ; # => PM ))
    (( N8 ; N9 DEC => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-TWO-TO-THE-LEFT BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 DEC ; N9 ; # => GM ; ; ))
    (( ; ; 0 ; N8 ; N9 ; # => PM ; ; ))
    (( ; ; N8 DEC DEC ; N9 ; # => PM ; ))
    (( ; N8 DEC ; N9 ; # => PM ))
    (( N8 DEC DEC ; N9 => VIEWS ))
    (( N8 DEC ; N9 => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-THREE-TO-THE-LEFT BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 DEC ; N9 ; # => GM ; ; ))
    (( ; ; N8 DEC DEC ; N9 ; # => GM ; ; ; ))
    (( ; ; ; 0 ; N8 ; N9 ; # => PM ; ; ; ))
    (( ; ; ; N8 DEC DEC DEC ; N9 ; # => PM ; ; ))
    (( ; ; N8 DEC DEC ; N9 ; # => PM ; ))
    (( ; N8 DEC ; N9 ; # => PM ))
    (( N8 DEC DEC DEC ; N9 => VIEWS ))
    (( N8 DEC DEC ; N9 => VIEWS ))
    (( N8 DEC ; N9 => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-ONE-TO-THE-LEFT BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; N8 DEC ; N9 ; # => PM ))
    (( 0 ; N8 ; N9 ; # => PM ))
    (( N8 DEC ; N9 => VIEWS ))
    (( N8 ; N9 => VIEWS ))
   )) OK)
(LET PUSH-TWO-BENEATH BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 ; N9 INC ; # => GM ; ; ))
    (( ; ; 0 ; N8 ; N9 ; # => PM ; ; ))
    (( ; ; N8 ; N9 INC INC ; # => PM ; ))
    (( ; N8 ; N9 INC ; # => PM ))
    (( N8 ; N9 INC INC => VIEWS ))
    (( N8 ; N9 INC => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-THREE-BENEATH BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; ))
    (( ; N8 ; N9 INC ; # => GM ; ; ))
    (( ; N8 ; N9 INC INC ; # => GM ; ; ; ))
    (( ; ; ; 0 ; N8 ; N9 ; # => PM ; ; ; ))
    (( ; ; ; N8 ; N9 INC INC INC ; # => PM ; ; ))
    (( ; ; N8 ; N9 INC INC ; # => PM ; ))
    (( ; N8 ; N9 INC ; # => PM ))
    (( N8 ; N9 INC INC INC => VIEWS ))
    (( N8 ; N9 INC INC => VIEWS ))
    (( N8 ; N9 INC => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET PUSH-ONE-BENEATH BE (( >N9 >N8 )) 
  ((
    (( N8 ; N9 ; # => GM ; N8 ; N9 INC ; # => PM ))
    (( 0 ; N8 ; N9 ; # => PM ))
    (( N8 ; N9 INC => VIEWS ))
    (( N8 ; N9 => VIEWS ))
  )) OK)
(LET BOARD-SELECT BE (( ))
  ((
    (( GAME-BOARD >>> => & ))
    (( PLAYER-POS-X >>> => >N2 )) 
    (( PLAYER-POS-Y >>> => >N4 )) 
    (( N2 ; N4 ; # => GM => ISPRO 
      (MATCHED
        (( FIND-FREELY-THE-FREE => >N11 => >N10 ))
        (( N11 ; N4 => EQN 
          (MATCHED
            (( N10 ; N2 => SUB => ABS => ISDANCE
              (MATCHED
                (( N10 ; N2 => SUB => ISPRO                                   
                  = N2 ; N4 => PUSH-ONE-TO-THE-RIGHT
                  == N2 ; N4 => PUSH-ONE-TO-THE-LEFT === )) 
              )(OTHER
                (( N10 ; N2 => SUB => ISPRO                                   
                  = N10 ; N2 => SUB => ABS ; 3 => EQN                       
                    = N2 ; N4 => PUSH-THREE-TO-THE-RIGHT ==
                    N2 ; N4 => PUSH-TWO-TO-THE-RIGHT ===
                  == N10 ; N2 => SUB => ABS ; 3 => EQN                     
                    = N2 ; N4 => PUSH-THREE-TO-THE-LEFT ==
                    N2 ; N4 => PUSH-TWO-TO-THE-LEFT ===
                  === ))
              MATCHED) ))
          )(OTHER
            (( N10 ; N2 => EQN 
              (MATCHED
                (( N11 ; N4 => SUB => ABS => ISDANCE
                  (MATCHED
                    (( N4 ; N11 => SUB => ISPRO                           
                      = N2 ; N4 => PUSH-ONE-UP
                      == N2 ; N4 => PUSH-ONE-BENEATH === )) 
                  )(OTHER
                    (( N4 ; N11 => SUB => ISPRO                           
                      = N11 ; N4 => SUB => ABS ; 3 => EQN                     
                      = N2 ; N4 => PUSH-THREE-UP ==
                      N2 ; N4 => PUSH-TWO-UP ===
                    == N11 ; N4 => SUB => ABS ; 3 => EQN                      
                      = N2 ; N4 => PUSH-THREE-BENEATH ==
                      N2 ; N4 => PUSH-TWO-BENEATH ===
                    === ))
                  MATCHED) ))
              MATCHED) ))
          MATCHED) ))
      MATCHED) ))
    (( && ))
  )) OK)
(( LOOKSTK )) 
(LET REARRANGE-IN-GOOD-WAYS BE (( ))                  
  ((
    (( GOLABEL4: ))
      (( (( PLAYER-POS-X >>> ; 130 => MUL ; 15 => ADD )) ;
        (( PLAYER-POS-Y >>> ; 130 => MUL ; 15 => ADD )) ; 
        (( BRIDGE ; 110 => ADD )) ;
        (( BRIDGE ; 110 => ADD )) ; 128 ; 191 => DOTTED_RECT ))
      (( KEYNUM => >N1 ))
      (( FKEYNUM => >N2 ))
      (( (( PLAYER-POS-X >>> ; 130 => MUL ; 15 => ADD )) ;
        (( PLAYER-POS-Y >>> ; 130 => MUL ; 15 => ADD )) ; 
        (( BRIDGE ; 110 => ADD )) ;
        (( BRIDGE ; 110 => ADD )) ; 128 => RECT ))
      (( N1 ; KEY-ENTER >>> => EQN = BOARD-SELECT == ))
      (( N2 ; 84 => EQN = -1 ; PLAYER-POS-Y => ADDVAR == ))
      (( N2 ; 83 => EQN = PLAYER-POS-X => INCVAR == ))
      (( N2 ; 82 => EQN = -1 ; PLAYER-POS-X => ADDVAR == ))
      (( N2 ; 85 => EQN = PLAYER-POS-Y => INCVAR ))
      (( === === === === === ))
      (( PLAYER-POS-X >>> ; 1 ; 4 => SET-RANGE
        PLAYER-POS-X <<ASSERT ))
      (( PLAYER-POS-Y >>> ; 1 ; 4 => SET-RANGE
        PLAYER-POS-Y <<ASSERT ))
      (( N1 ; KEY-ESC >>> => EQN => NOT = GOUP4 === ))
  )) OK)
(LET PLAY-BODYBOOK BE (( ))         
  ((
    (( 10 ; 10 ; 710 ; 710 ; 1 => RECTFILL ))
    (( COINCIDENCE-CONFIGURATION )) 
    (( SHOW-ALL ))
    (( REARRANGE-IN-GOOD-WAYS ))
  )) OK)
(LET BODYBOOK BE (( )) 
  ((
    (( GJ-ON ))
    (( BODYBOOK-INTRO ))
    (( PLAY-BODYBOOK ))
    (( GJ-DONE ))
  )) OK)
(( LOOKSTK )) 
(LET AUTOSTART BE BODYBOOK OK)