     MAREN Associates Inc. is proud to announce an exciting
     new product for students, parents and educators which is
     both FUN and EDUCATIONAL  . . . .

*************************************************************
***                      "GAMEBASIC"                      ***
*************************************************************

    CONTENTS
    ---------

1.  WHAT IS GAMEBASIC?
2.  HOW DO YOU MAKE GAMES WITH GAMEBASIC?
3.  GAMEBASIC ROUTINES
4.  WHAT DO YOU GET WHEN YOU REGISTER GAMEBASIC?
5.  MAREN ASSOCIATES COMMISSION INCENTIVE PLAN - (CIP)
6.  GAMEBASIC SYSTEM REQUIREMENTS
7.  WHAT DOES GAMEBASIC COST?
8.  HOW TO ORDER GAMEBASIC.




    -----------------------------------------------------------------
1.  WHAT IS GAMEBASIC ?
    -----------------------------------------------------------------

     GAMEBASIC is a program which enables students to create
     their own exciting animated computer games incorporating both
     sound and colour, using very simple commands in Basic.

     The objective of GAMEBASIC is to make it FUN to learn
     computers and Basic programming, to de-mystify computers and
     to provide an environment which will encourage an enthusiasm
     for further computer studies, in this way preparing students for
     the new work-place where computer knowledge is essential.

     With GAMEBASIC, students can develop their own versions of
     games like Alien Invaders, HackMan, Racquet-Ball, Question
     and Answer games with animation, and two-player keyboard
     games like Tank Battle.

     Run program GBDEMO.EXE on this disk to see examples of the
     types of games that GAMEBASIC can create. The
     GAMEBASIC code for the games is included in file
     GBCODE.TXT, which includes a version of Alien Invaders that
     was coded in only 57 instructions to demonstrate the POWER of
     GAMEBASIC!



     ----------------------------------------------------------------
2.   HOW DO YOU MAKE GAMES WITH GAMEBASIC ?
     ----------------------------------------------------------------

     GAMEBASIC has been developed using the concept of
     SPRITES.  A SPRITE is a graphic-character (maybe a spaceship
     or an alien) that students define to GAMEBASIC. Once they
     have defined their sprites, and told GAMEBASIC where to put
     them and how they move, GAMEBASIC then handles all the
     movement for them, thus allowing them to concentrate on the
     logic of their game rather than the technical complexities of
     moving graphical characters in Basic.

     GAMEBASIC comes with many powerful routines that make
     programming sophisticated games very easy.

     A game character in GAMEBASIC is defined in a 16 by 12
     array. The following is the GameBasic definition for the
     cannon used in the Alien Invaders demonstration game:

     char$(1, 1) = "                "
     char$(1, 2) = "                "
     char$(1, 3) = "
     char$(1, 4) = "                "
     char$(1, 5) = "        F       "
     char$(1, 6) = "        F       "
     char$(1, 7) = "       3F3      "
     char$(1, 8) = " 33333333333333 "
     char$(1, 9) = "33  3 3 3 3 3 33"
     char$(1,10) = "3333333333333333"
     char$(1,11) = "  6 6      6 6  "
     char$(1,12) = "   6        6   "

     Numbers 0 to 9 and letters A to F represent different coloured
     pixels; the colour for each number or letter can be user-defined
     from over 262,000 colours.  There can be up to 20 different
     characters in any one game.

     GAMEBASIC allows up to 100 SPRITES in a game. A sprite is
     created using one of the 20 characters that have been defined.
     One single character definition can be used to create multiple
     sprites. For example, if character #1 was a space-alien character,
     that one character definition could be used to create 30 alien
     sprites coming down the screen.

     You create sprites by using CREATE command.
     This command assigns a "sprite number" to the sprite, tells
     GAMEBASIC which character to display the sprite as, and puts
     it on the screen at the row and column you specify. The
     CREATE command also tells GAMEBASIC what speed and in
     which direction the sprite should move, as well as what should
     happen to the Sprite when it hits a screen border - ie the top,
     bottom or either side of the screen.
     When it hits a screen border, you have the following options:
          a) The sprite can wrap around the screen
          b) The sprite can be deleted.
          c) The sprite can stay where it is.
          d) The sprite can bounce off the edge, like a ball.

     GAMEBASIC's CONTROL command defines which Sprite
     numbers are controlled by the keyboard, whether they can move
     up, down, left or right, which keys will move them in a
     particular direction and,  when a "Fire" key is pressed,  what
     character should be fired (maybe a missile you've defined) and in
     which direction. This is a very powerful command, saving you a
     lot of programming time.

     GAMEBASIC's CHECKHIT command is used to check if one
     Sprite has hit another one, or one of a range of Sprites. For
     example, one CHECKHIT instruction could be used to see if a
     Missile sprite has hit any of our 30 invading Aliens!

     Using GAMEBASIC's SHOOT command, your program can
     literally shoot a specific Character from one Sprite to another
     Sprite at a given speed. This is used in some of the
     demonstration games where the Aliens are firing fireballs directly
     at the cannon.

     There are many other powerful GAMEBASIC routines that come
     with the system.  Each of them is outlined in detail below.




    -------------------------------------------------------------------
3.  GAMEBASIC ROUTINES
    -------------------------------------------------------------------


     CALL  CREATE          (sprite.no,  char.no,  col,  row,  speed,
          pixspermove, direction,  horiz$,  vert$, track.no)

          Use the CREATE command to create a sprite in your
          game. You tell GAMEBASIC which character the sprite
          should be displayed as, where it should be initially
          placed on the screen, what speed and in which direction
          it should move, what should happen to the sprite when
          it reaches a screen border and whether it is a sprite that
          should follow a track that's been laid down (see TRACK
          command later).



     CALL CONTROL        (sprite.no, horiz$,  vert$,  pixspermove,
          "u", keyup,   charup,    shootdirectup,    shootcharup,
          "d", keydown,chardown,shootdirectdown,shootchardown,
          "l", keyleft,   charleft,   shootdirectleft,  shootcharleft,
          "r", keyright, charright, shootdirectright, shootcharright)

          This command tells GAMEBASIC that a specific sprite
          number is to be controlled by the keyboard. For that
          sprite number, it also tells GAMEBASIC whether the
          sprite can move horizontally and/or vertically, the
          number of pixels it should move each time, which keys
          control the sprite movement, the character the sprite
          should be shown as when it's moving in a particular
          direction (ie a spaceship pointing up the screen as
          opposed to pointing to the left) and, when the SHOOT
          command is issued for this sprite (see next), which
          character to shoot (ie a missile pointing up rather than a
          missile pointing to the left) and in which direction it
          should move.



     CALL SHOOT     (sprite.no, charno, from.spriteno,
            to.spriteno, speed, pixspermove, horiz$, vert$)

          When this command is issued, a sprite is created using
          the character number in charno, starting at the location
          of the sprite referenced in from.spriteno aimed towards
          the sprite referenced in to.spriteno at the given speed
          and pixelspermove. If the from.spriteno is a keyboard-
          controlled sprite (like a cannon) and to.sprite is entered
          as 0 (zero), then the direction for the shoot sprite to
          move in will be taken from the CALL CONTROL
          parameters coded.



     CALL  ACTIVE     ( sprite.no1, sprite.no2, return-value)

          This is a GAMEBASIC command that will tell us
          whether one or more sprites are currently active on the
          screen. Return value will contain the total number of
          active sprites in the range specified.



     CALL  CHECKHIT   (sprite.no,   target.sprite1, target.sprite2,
                  tolerance, return-value)

          CHECKHIT tells us if a specific sprite has collided with
          any other sprites in our game (ie has a missile hit an
          alien?). Non-moving sprites, like rocks or land mines,
          will be checked if they fall within the sprite number
          range you specify. Non-active sprites (ie sprites that
          have previously been deleted) will be ignored. You can
          check if
               a) One sprite has hit one other sprite
               b) One sprite has hit any of a range of sprites
               c) One sprite has hit ANY other sprite.

          You can specify a tolerance for the check. Return value
          will contain the first sprite number that has hit the
          specified sprite.



     CALL   DELETE    (sprite.no1, sprite.no2)

          We use this GAMEBASIC command to delete active
          sprites. You can delete a single sprite or a range of
          sprites.



     CALL  INFO ( sprite.no, col, row, speed, direction, char.no,
          hit.edge$, pixspermove)

          This GAMEBASIC command returns information (that
          you may want to use in your program) relating to a
          specific sprite. You can find out what row or column
          the sprite is on, what speed and in which direction it is
          moving, which character it is being displayed as and
          which screen border it has just reached.



     CALL   RAND     ( rand1,  rand2,  return-value )

          The  RAND GAMEBASIC routine will return in the
          variable entered for return-value, a random number
          between the two numbers entered in rand1 and rand2.



     CALL  CHANGECHAR   ( sprite.no,  char.no )

          Use the CHANGECHAR routine to change the character
          that a sprite is being displayed as.



     CALL MOTION    (sprite.no, speed,  direction, pixspermove)

          The MOTION command lets us change how a sprite is
          moving. We can change its speed, direction and number
          of pixels per move.



     CALL GETANGLE   ( sprite.no1, sprite.no2,  return-value)

          This command will return the angle between two sprites.



     CALL MUSIC    (type$,  length$,  tempo$,  octave$,  notes$)

          Introduce a new dimension to your games by adding
          music and sounds. You can specify either a series of
          notes that are continually played while your game is
          playing or a single series of notes that are to be played
          once when a specific condition occurs (for example, the
          launch of a missile).  Single series of notes interrupt
          continuous sounds.



     CALL TEXTSCREEN   (Screen.mode, Clear.screen$, Choice$)

          Use this GAMEBASIC routine to display a menu or text
          screen from which the player may select a choice. The
          routine uses a GAMEBASIC array called gb.line$()
          which has 25 entries, each entry representing the text
          that you want printed at that line number. Before calling
          TEXTSCREEN, enter all the valid keys that the player
          can press into the Choice$ variable you will be passing
          to the routine. The routine will then check that a valid
          key was pressed  before returning back to your program.
          To accept ANY key, put a null value ( "" ) in Choice$.



     CALL QUESTION   (Question.row,  Question.col,  Answer.row,
                   Answer.col, Question.no, Result$)

          GAMEBASIC lets you make question and answer
          games very easily, also incorporating animated
          characters to enhance your game. To make these types
          of games, you enter your questions into an array called
          gb.question$, the correct answer into an array called
          gb.answer$, then issue the CALL QUESTION
          command.  You control where on the screen the
          question is asked and where the answer is displayed as
          the player enters it. GAMEBASIC handles all keyboard
          entry of answers. When the player hits the enter key,
          GAMEBASIC checks the answer for you and returns a
          Y or N in Result$.



     CALL TRACK    (Row.or.Col$, start.row.or.col.no, start.no,
            end.no, width, track$)

          With GAMEBASIC, you can make sprites follow one of
          7 tracks (tracks A to F - corresponding to colour codes
          A to F;  and track 0 - the background track). You lay
          down TRACKS on the screen by using this TRACK
          routine.  If you want a sprite to follow a track then the
          CALL CREATE command which creates the sprite must
          specify which track it is to follow. Tracks can have
          intersections so that when a sprite following a track
          comes to a junction, it will randomly decide which path
          to follow.



     CALL COLOUR   (Colour.code$, colour.name$,
                           blue,  green,  red )

          Each colour code used in your character definitions
          (0 to 9 and A to F) can be changed to any of 262,144
          colours by this command.



     CALL DISTANCE   ( sprite.no1, sprite.no2, distance )

          The DISTANCE routine returns the distance in pixels
          between two active sprites.



     CALL PAUSE   ( number )

          The PAUSE routine stops your program for a number of
          seconds.  If you press any key on the keyboard before
          the pause-time has expired, your program will start up
          again. If you want to stop your program indefinitely
          until any key is pressed, regardless of the time, then use
          0 for the number.



     CALL COLOURRESET

          COLOURRESET resets all custom colours you have
          defined, including the background colour (0) and text-
          colour (15),  back to their original QBasic colours.



     CALL MOVEBACK   ( sprite.no )

          MOVEBACK moves a sprite back to the screen position
          it was in just before its last move.



     CALL PIXELCOLOUR   ( sprite.no, top.left, top.right,
                       bottom.left, bottom.right)

          The PIXELCOLOUR routine returns the colour codes of
          the pixels at the four extreme corners of the specified
          sprite on the screen.




     MISCELLANEOUS GAMEBASIC FEATURES
     --------------------------------

     SCREEN MODES :  GAMEBASIC allows games to be
          programmed in two screen modes - mode 1 and 2.

          In screen mode 1, you define characters 16 pixels wide
          and 12 pixels deep. In screen mode 2 your characters
          will be about the same size as in mode 1, but you get better
          character definition since your characters can be 32
          pixels wide and 30 deep. However, game speed will be
          slightly slower.



     SPLIT-SCREEN FEATURE.  With GAMEBASIC, you can
          program your game so that specific sprites only move
          within certain screen boundaries.

          Set GAMEBASIC variables gb.screen.start.row,
          gb.screen.start.col, gb.screen.end.row  and
          gb.screen.end.col to be the screen limits you want
          before creating the sprites that should move within these
          limits.

          Any sprites you CREATE after these variables have
          been set will then wrap, stay or bounce etc.. within
          these limits. Using this feature, you can program a two-
          player game where each player plays in his own
          "window" with his own sprites.



     -----------------------------------------------------------------
4.   WHAT DO YOU GET WHEN YOU REGISTER GAMEBASIC?
     -----------------------------------------------------------------


     GAMEBASIC comes with a professionally printed 100 page
     User Manual that uses simple language to explain to students the
     basic issues of PC file structures, the QBasic programming
     environment, Basic programming, programming 'Style' and how
     to use the GAMEBASIC routines to develop their own games.
     The manual is supported throughout by Basic program examples
     and the development of one of the demo games is explained
     step-by-step with program examples.

     Registered users have access to a business-hours HELP desk and
     a 24 hour voice/fax line.  Registered users will also get upgrade
     releases of GAMEBASIC for a nominal fee covering shipping
     and handling.

     To enable as many students as possible to benefit from the
     learning advantages of GAMEBASIC, registered users are
     entitled to make demonstration disks of GAMEBASIC, through
     the GBMENU.EXE program provided by MAREN Associates,
     and pass disks on to their friends and/or place on Bulletin Board
     systems for review. MAREN Associates will pay a commission
     to registered users on all sales originating from their demo-disks.
     Depending upon sales, you could earn income in the thousands.
     Full details are explained in the following.



     ------------------------------------------------------------------
5.   MAREN ASSOCIATES COMMISSION INCENTIVE PLAN - CIP
     ------------------------------------------------------------------


     1. Your registration of GAMEBASIC allows you distribute
     demonstration copies of GAMEBASIC.

                          NOTE
            DEMONSTRATION COPIES MUST ONLY BE
            MADE THROUGH THE "Make Demo" OPTION IN
            PROGRAM GBMENU.EXE.   NO PROGRAMS CONTAINING
            THE SOURCE CODE OF ANY GAMEBASIC SUBROUTINES
            MAY BE INCLUDED.

     2. When you register GAMEBASIC, you will be given a
     Registration Number which you will be asked to enter when you
     install the program. When you make demonstration copies of
     GAMEBASIC through GBMENU.EXE, your Registration
     Number will be included on the demo disks as the Reference
     Number, which will be printed on all Registration Forms printed
     from your copies.

     3. Through this method, we will keep track of all sales we get
     from the copies you make, as well as all sales that your friends
     make after registering from your demo disks.

     4. MAREN Associates have developed a Multi-Level Sales
     commission structure to make it very profitable for you to make
     copies and distribute.

          For each sale we get from a demo disk containing your
          Reference Number, we will pay you a commission of $5
          Cdn.

          When someone registers from your demo disk and they
          subsequently make a sale, we will pay them $5 Cdn and
          also pay you $2.50 Cdn.

          When the person they sell to registers and then makes a
          sale, we will pay them $5 Cdn, the person you sold it to
          $2.50 Cdn and you $1.25 Cdn.  And so on . . .

          So, if you sold GAMEBASIC to 15 friends (for
          example) and they each sold to 15 friends who again
          each sold to 15 friends, your commission would be

          15           x $5.00 Cdn =   $    75
          15 x 15      x $2.50 Cdn =   $   562
          15 x 15 x 15 x $1.25 Cdn =   $ 4,219
                                       ---------
                                       $ 4,856  Cdn
                                       ---------

          . . . . all for the cost of about 15 disks and a small
          amount of time.



     5. Please note the following details:

          1. Commissions will be paid by cheque in Canadian
          funds once every three months.

          2. Total Commission amounts payable of less than $10
          will be paid once every 6 months.

          3. You can call Maren Associates at any time to query
          the commission status of your account.

          4. You will be responsible for any taxable situation on
          the income you make.

          5.  You MUST NOT make any financial guarantees or
          promises of any kind to anyone when distributing the
          demo disks.

          6.  You are not authorised to charge or accept any
          monies for GAMEBASIC or demonstration disks.
          Your commission is your payment.


     ----------------------------------------------------------------
6.   GAMEBASIC SYSTEM REQUIREMENTS
     ----------------------------------------------------------------


     To run GAMEBASIC you must have the following:

     a)   QBasic  (QBasic comes with DOS versions 5 and higher and
                   will be found in your DOS directory).

     b)   a 386 computer or better  (GAMEBASIC will run on 286
                computers, but game speed may not be satisfactory)

     c)  VGA monitor

     d)  Hard disk drive with 1.4 mbytes free.


     -----------------------------------------------------------------
7.   WHAT DOES GAMEBASIC COST?
     -----------------------------------------------------------------

     GAMEBASIC PRICE
     -------------------------
     GAMEBASIC license            :     $ 34.95 Cdn
     Shipping and Handling        :     $  4.50 Cdn
     PST (Ontario residents only) :     $  3.16 Cdn
     GST (Canadian residents only):     $  2.76 Cdn


     PAYMENT METHODS
     ----------------------------

     Payments are accepted by Cheque, Money Order or Visa in
     Canadian funds.



     ------------------------------------------------------------------
8.   HOW TO ORDER GAMEBASIC.
     ------------------------------------------------------------------


     1.  Run program GBMENU.EXE and select option "P" - Print
     Registration Form. Complete the details on the screen and print
     the Registration Form.

     2. If you are paying by VISA, please make sure that you include
     your VISA Account Number, CardHolder Name and Card Expiry Date
     and sign the Registration Form under Card Holder Signature.

     3. If you are paying by other than VISA, please make cheques or
     money orders payable to MAREN Associates Inc.

     4. Mail Registration Form, with cheque or money order where
     applicable, to

               MAREN Associates Inc,
               1848 Liverpool Road,
               Unit #9, Suite 306
               PICKERING,
               ONTARIO,    L1V 6M3
               CANADA

     5. For payments by VISA only, MAREN Associates can accept
     registrations by phone in three ways:

          1. Call Maren Associates' Order Desk at
           (905)-839-7721 during regular business hours (9am
          to 5pm EST, Monday to Friday).

          2. Call Maren Associates FAX/VOICE line at
          (905)-839-5652 at any time and FAX your completed
          Registration Form to us.

          3. Call MAREN Associates FAX/VOICE line on the
          number above at any time and leave a VOICE MAIL
          Registration.  Please have the following information ready:

               1. Name and Address, including Post/ZIP code,
               and country.

               2. Your home phone number.

               3. VISA Account Number, Card Holder Name
               and Expiry Date.

               4. Reference Number.
               The Reference Number is automatically
               included on the Registration Form you print
               from the GBMENU program, and tells us who
               should receive commission payments on your
               purchase, as it will do for you if you distribute
               demo disks to your friends and they register
               with us.

               To find out the Reference Number on your
               demo disk, please select option "D" from
               GBMENU.EXE.



     6. Please allow 2 weeks delivery for US/Canadian orders and 3
     to 4 weeks for International orders.

     7. Volume discounts are available for schools and other
     educational establishments. Please contact MAREN Associates
     for details.

     8. Dealer enquiries welcome.
