Guide to programming modules for BlitzBlank 2.50
================================================

 0. Preface
 1. Requirements for modules
 2. Introduction
 3. Construction of the GUI
 4. Description of the GUI objects
 5. Communication with BlitzBlank/BlitzBlankPrefs
 6. Description of the flags
 7. Description of the BlitzBlank structures and flags
 8. Description of the global definitions of a module (example)
 9. Exact description of the main program (example)
10. Exact description of blank()
11. Advice to support the locale.library
12. AmigaGuide documentation for the modules
13. Tips and tricks


0. Preface
----------

Because I can't program everything alone I have tried to make the
programming of modules as easy as possible. But I have to ask the potential
programmers to tell me if they start to work on a module. So I can make
sure that not two people work on a similar module at the same time.
On the other hand they also get the number of the locale strings from me.
I also don't want anybody to publish a module on their own but to send me
the module. I will then implement the necessary text in the
BlitzBlank.catalog and the documentation in the BlitzBlank.guide and
release it with the next BlitzBlank version or as an update.

Due to BlitzBlank being no shareware the modules can't be shareware also.
They can only be card- or giftware.

What a module author writes in his info requester (eg. address, etc.) is up
to him/her but should be similar to my own modules.

I'd really like to have the following modules (at least ;-) ):
- Flying something (Toaster etc.)
- Something with 3D graphic
- Maze
- Starfield
- ASwarm
- Fractals
- Anything else that's funny

Have fun,
          Thomas Börkel


1. Requirements for the modules
-------------------------------

- OS 2.x/3.x compatible
- Minimum OS: V2.04
- Don't turn off the multitasking
- AGA compatible
- Compatible with graphic cards (if possible)
- Should not rely on a special screen mode and depth (if possible)
- Comply with the described guidelines
- If you use double buffering do it on ONE screen but with several BitMaps
- Don't try to open your own screen but get one from BB (if possible)
- Use the blitzblank.library

- if the module uses graphic or similar data it should read it from the
  harddisk (using Read() or the iff.library), so that the module itself
  will be as small as possible (e.g. during configuration this data isn't
  needed)


2. Introduction
---------------

It's quite easy to write modules for BlitzBlank because BlitzBlank offers
very much for the modules. Because of this the programmer can concentrate
on the module itself.

BlitzBlank/BlitzBlankPrefs administers the GUI, the configuration and the
screen for the module.

Module names have to start with "BB." and mustn't have another "." in its
name. Datafiles for the modules (if they require any) have to follow
the format "BB.Modulename.*".

BlitzBlank modules are essentially ordinary CLI programs which get started
from BlitzBlank or BlitzBlankPrefs. If they are running they will be
stopped with a CTRL-C.

A module has to have at least 2 functions:
- main program (determines the programs behaviour with the 1. argument)
- blank() routine (the essential blank routine)

The modules are communicating with BlitzBlank and BlitzBlankPrefs through
the blitzblank.library. The instructions in the library all start with
"BBL_".

The modules get up to 3 command line parameters at start:
- Action key word (BLANK|CONFIG|INFO)
- Name of the module's communication port
- Address of BlitzBlank's screen info structure

The key word determines what the module has to do. Example of such a
routine in C:

if (strcmp (argv[1],"BLANK")==0)
{
  StrToLong (argv[3],(long *) &screeninfo);
  BBL_SendMessage (&message,argv[2]);
  if (screeninfo->bbscreen)
    blank ();
  BBL_ModuleDone ();
}
else
  if (strcmp (argv[1],"CONFIG")==0)
  {
    BBL_SendMessage (&message,argv[2]);
  }
  else
  {
    message.first=NULL;
    BBL_SendMessage (&message,argv[2]);
  }

The first argument is checked for BLANK|CONFIG|INFO and proceeds as
follows:

BLANK:
Argument 3 will be changed to a numeral with the OS routine StrToLong() and
is assigned to a pointer to a BB_Screeninfo structure. Then BBL_SendMessage
(&message,argv[2]) is called. Afterwards the blank() function is called
which contains the essentail module routines. If a screen was requested
prior to the call it has to be checked if screeninfo->bbscreen isn't zero
(could happen if low on memory). Just before the main routine in the blank()
function CTRL-C has to be checked and then BBL_ModuleRunning() is started.
After blanking BBL_ModuleDone() must be called in ANY case.

CONFIG:
Argument 3 can be changed to a numeral with the OS routine StrToLong() and
is assigned to a pointer to a BB_Screeninfo structure.
BBL_SendMessage (&message,argv[2]) is called.
If a module sets BBF_Screenmode, doesn't set BBF_Colors and sets depth in
Screeninfo then only those modes will be displayed in the screenmode
requester of BBPrefs which have at least the requested depth.

INFO:
The pointer to the first GUI object is set to NULL. Then BBL_SendMessage
(&message,argv[2]) is called.


3. Construction of the GUI
--------------------------

The graphic user interface a a BB module is described with GUI objects.
The administration af the GUI and the saving and loading of the
configuration is done by BlitzBlank and BlitzBlankPrefs. The module doesn't
have to think about this. GUI objects do describe the structure of the GUI
and also represent the memory for the parameters (configuration of the
module).

Available GUI objects are checkmark, stringgadget, filegadget, slider,
cycle gadget, VGroup and PGroup.

The GUI objects are compiled in VGroups and maybe in PGroups. A VGroup is
started via a GUI object of the BB_VGroup type and ends via a
BB_VGroup_End. VGroups can be compiled in PGroups. A module GUI must have
at least one VGroup. VGroups and PGroups may NOT(!) be placed in groups
of the same type.

The GUI objects (BB_Object) are a single-chained list and are terminated with
a NULL.
Because right now all GUI objects are of the same size, one can simply
create an array of the type BB_Object and chain the array elements
appropriately (field <next> points to the next object or to NULL if it is
the last).

The individual fields of the objects (eg. <set>, <contents>...) have to be
reset by the module with default values prior to sending the message.
If the message is sent back (BLANK) the module can read the really selected
parameters from the GUI objects.

A VGroup is a vertical group of Gadgets. The Gadgets are displayed below
each other in the GUI. If a module GUI has several VGroups then the
vertical Groups will be displayed beside one another.

A PGroup contains several VGroups. They can be switched with a cycle or
register gadget (depends on how MUI is configured).

A GUI could have this structure:
BB_VGroup->BB_Slider->BB_Slider->BB_VGroup_End->BB_VGroup->BB_Check->
BB_Check->BB_VGroup_End

This GUI would have 2 columns. There would be 2 sliders In the left column
and 2 checkmarks in the right. You can find more examples in the supplied
module sourcecodes.


4. Description of the GUI objects
---------------------------------

You can attach or insert an underscore "_" to the lables of the
GUI-objects. The following letter will then be the one to be used for the
selection via keyboard. The letters A, C, I, P, S, T can not be used since
they are needed for the lower row of buttons.

What follows is the description of the possible GUI objects. Names in <>
are constants or fields within BB_Object.

Pagegroup:
Started via <BB_PGroup> and ends via <BB_PGroup_End>.
The default page number is in <set>, <label> points to the NULL terminated
stringarray with the pages's headlines.

Verticalgroup:
Started via <BB_VGroup> and ends via <BB_VGroup_End>.
If <label> does not equal NULL it has to point to a string. In this case
the VGroup has a headline and a frame.

Checkmark-Gadget:
Recognized by <BB_Check>.
<set> describes the status and <label> points to the label text

Stringgadget:
Recognized by <BB_String>
<max> is the maximum number of characters allowed for the stringgadget,
<contents> points to a associated string buffer that has to be allocated BY
THE MODULE, <label> points to the label text.

Filegadget:
Recognized by <BB_File>.
<max> is the maximum number of characters allowed for the stringgadget,
<contents> points to a associated string buffer that has to be allocated BY
THE MODULE, <label> points to the label text. Beside the stringgadget,
there is a popbutton for the filerequester.

Directorygadget:
Recognized by <BB_Dir>.
This is the same, as BB_File, but it only allows selection of directories.

Fontgadget:
Recognized by <BB_Font>.
<max> is the maximum number of characters allowed for the stringgadget,
<contents> points to a associated string buffer that has to be allocated BY
THE MODULE, <label> points to the label text. Beside the stringgadget,
there is a popbutton for the fontrequester.

Slider:
Recognized by <BB_Slider>
<min> and <max> describe the slider's boundaries, <set> is the default
value, <label> points to the label text.

Cyclegadget:
Recognized by <BB_Cycle>.
<set> describes the selected option, <contents> points to the NULL
terminated stringarray containing the options, <label> points to the label
text.

Dummyobject:
Recognized by <BB_Dummy>.
This object is the sole used object if the module doesn't offer any
preferences through GUI onjects.


5. Communication with BlitzBlank/BlitzBlankPrefs
-----------------------------------------------

When the module is started it gets a pointer to the BlitzBlank Screeninfo
structure. Here the module can set diffs for the screen parameters. For
instance a module could set <width> to 100. This way it would get a screen
100 pixels wider than the screen the user selected. The module can preset
the <xpos>, <ypos>, <width> and <height> values in the Screeninfo
structure. These values are added to the values selected by the user.
NORMALLY a module won't have to write anything in this structure unless
for instance it wants to have a screen from BlitzBlank but wants to set the
depth on its own (BBF_Color would then be unset). In this case the module
would write the depth to screeninfo->depth BEFORE calling
BBL_SendMessage(). The module can set a minimum depth and/or maximum
depth in <mindepth> and/or <maxdepth>, if it wants to. BlitzBlank
and BPrefs's screenmode-requester will use these boundaries then.

The module then sends a Message via BBL_SendMessage() to BlitzBlank/BBPrefs,
after it set the flags in <flags>, the infotext in <infotext> and (if
keyword!=INFO) the pointer to the very first GUI object in <first>.
The GUI objects have to be set with the default parameters. After the
function returns the fields <modpri> and <path> are set. <modpri> is the
selected module taskpriority (will later be used in blank()) and <path> is
the path where the modules can be found. If a module wants to load own data
it will find the data there too (Name convention for extra module data
"BB.Modulename.*"). Also the Screeninfo structure will be set and a screen
has been assigned for the module (only if it requested one) after
BBL_SendMessage(). The GUI objects are then set with the values the user
selected and can be read.

The following will then happen entierly in blank():
The module should then make all its precalculations, load neccessary data,
allocate memory, etc. Then it puts its own screen with ScreenToFront
(screeninfo->bbscreen) to front, checks if a CTRL-C arrived in the meantime
and then calls BBL_ModuleRunning().
Then the main routine of the module can be started. Now the selected
parameters are read from the GUI objects. The module must be able to react
to a CTRL-C break signal. In this case the module frees all used resources
(except the screen if it wasn't its own) and calls BBL_ModuleDone(). Now
the module has ended. If the module didn't get a screen from BlitzBlank
although it requested one (screeninfo->bbscreen==NULL) or it couldn't set
its variables due to insufficent memory the module should call
BBL_ModuleDone() at once and shut down afterwards.


6. Description of the flags
---------------------------

BBF_Screenmode    : The module supports screenmode selection
BBF_Colors        : The module supports depth selection
BBF_Sample        : Not yet implemented
BBF_NoWatch       : The module doesn't use any(!) CPU time
BBF_NoScreen      : The module doesn't want a screen from BlitzBlank
BBF_FirstScreen   : The module wants the data of the frontmost screen
BBF_CloneScreen   : The module wants a copy of the frontmost screen
BBF_AmigaOnly     : The module is not compatible with graphic cards
BBF_NoMouseBlank  : The module doesn't want the mouse to be blanked
BBF_NoKeyPass     : The module doesn't use a screen and doesn't use a window
BBF_BigWindow     : The blankwindow fills the whole screen
BBF_Interleaved   : BlitzBlank TRIES to give you a screen with an Interleaved BitMap

If a module wants its own screen (like BB.Pyro) it will set the BBF_Screenmode
and BBF_Colors flags.

If the module directly manipulates the frontmost screen (like BB.Fade) it
will set the BBF_FirstScreen flag. You should be VERY careful with this
kind of modules.

If the module manipulates an exact copy of the frontmost screen (like BB.Melt)
it will set the BBF_CloneScreen flag.

If BBF_NoMouseBlank isn't set BlitzBlank opens a window on the
associated screen, puts a blank mouse pointer in it (SetPointer()) and
activates it.

Advice:
-------

If a module wants to open and administer its screen on its own
(BBF_NoScreen) it should use the BBL_BlankMouse() and BBL_UnBlankMouse()
functions to blank the mouse on its screen. 

To close its screen it should use BBL_CloseScreenSafe().

The screen should be opened with the "SA_Behind,TRUE" tag and should be
brought forward just before BBL_ModuleRunning() with ScreenToFront().

Additionally is should set the borders of its screen to black with
VideoControlTags(screen->ViewPort.ColorMap,VTAG_BORDERBLANK_SET,-1,TAG_DONE);.

The module MUST write it's self-opened screen into screeninfo->bbscreen!

Modules that work with a copy of the frontmost screen (BBF_CloneScreen) can
use a screen with a higher depth than the original screen if they set
screeninfo->depth to the difference.


7. Description of the BlitzBlank structures and flags
-----------------------------------------------------

#ifndef BLITZBLANK_H
#define BLITZBLANK_H

#include <exec/ports.h>
#include <exec/tasks.h>


/****************************************/
/* $VER: BlitzBlank.h 2.50 (01.03.95)   */
/****************************************/

/********************************/
/* Stuff for blitzblank.library */
/********************************/

#define BLITZBLANKLIB_VER 6

extern struct BitMap   *BBL_AllocBitMap        (ULONG width,ULONG height,ULONG depth,ULONG flags);
extern struct BitMap   *BBL_AllocDBufBitMap    (struct Screen *screen);
extern struct RastPort *BBL_AllocRastPort      (ULONG width,ULONG height,ULONG depth,ULONG flags);
extern void             BBL_BlankDone          (void);
extern struct Window   *BBL_BlankMouse         (struct Screen *screen,UBYTE mode);
extern void             BBL_CloseScreenSafe    (struct Screen *screen);
extern BOOL             BBL_CopyOriginalColors (struct Screen *screen);
extern BOOL             BBL_CopyOriginalScreen (struct Screen *screen);
extern void             BBL_EndDBuf            (ULONG handle);
extern BOOL             BBL_FadeDown           (struct Screen *screen,UBYTE final,UBYTE delay);
extern void             BBL_FreeBitMap         (struct BitMap *bitmap);
extern void             BBL_FreeRastPort       (struct RastPort *rastport);
extern long             BBL_GetDarkestPen      (struct Screen *screen);
extern char*            BBL_GetString          (UWORD num,char *text);
extern ULONG            BBL_InitDBuf           (struct Screen *screen,struct BitMap *bitmap);
extern void             BBL_ModuleRunning      (void);
extern BOOL             BBL_ScreenAvailable    (struct Screen *screen);
extern BOOL             BBL_SendMessage        (struct BB_Message *bbmessage,char *portname);
extern void             BBL_ShowBitMap         (struct Screen *screen,struct BitMap *bitmap,ULONG handle);
extern void             BBL_UnBlankMouse       (struct Window *window);


/*******************************************************************/
/* The different kinds of GUI-objects for a module's config-window */
/*******************************************************************/

#define BB_PGroup     1 /* Indicates the start of a new page group */
#define BB_PGroup_End 2 /* Indicates the end of the page group */
#define BB_VGroup     3 /* Indicates the start of a new vertical group */
#define BB_VGroup_End 4 /* Indicates the end of the vertical group */
#define BB_Check      5 /* Checkmark, uses set field in BB_Object */
#define BB_String     6 /* Textgadget, uses max/contents fields in BB_Object */
#define BB_File       7 /* Stringgadget with attached filerequester */
#define BB_Slider     8 /* Slidergadget, uses min/max/set fields in BB_Object */
#define BB_Cycle      9 /* Cyclegadget, uses set/contents in BB_Object */
#define BB_Dummy     10 /* Dummy, if you want no gadgets at all */
#define BB_Font      11 /* Stringgadget with attached fontrequester */
#define BB_Dir       12 /* Stringgadget with attached filerequester, Dirs only */

/*****************************************/
/* Flags used in BB_Message's flag-field */
/*****************************************/

#define BBF_Screenmode   (1L <<  0)  /* Allows screenmode-selection */
#define BBF_Colors       (1L <<  1)  /* Allows screendepth-selection */
#define BBF_Sample       (1L <<  2)  /* Not supported yet */
#define BBF_NoWatch      (1L <<  3)  /* Eats no CPU-time, so needs no checking */
#define BBF_NoScreen     (1L <<  4)  /* Wants no screen from BlitzBlank */
#define BBF_FirstScreen  (1L <<  5)  /* Wants pointer to screen in front, be CAREFUL with this! */
#define BBF_CloneScreen  (1L <<  6)  /* Wants a clone from the FrontScreen */
#define BBF_AmigaOnly    (1L <<  7)  /* Not supported yet */
#define BBF_NoMouseBlank (1L <<  8)  /* No mouseblanking from BlitzBlank wanted */
#define BBF_NoKeyPass    (1L <<  9)  /* No keypassing necessary (no mouseblanking, no own active window */
#define BBF_BigWindow    (1L << 10)  /* The blankwindow fills the whole screen */
#define BBF_Interleaved  (1L << 11)  /* BlitzBlank TRIES to give you a screen with an Interleaved BitMap */


/*****************************************/
/* The structure, that holds config-data */
/*****************************************/

struct BB_Object
{
  struct BB_Object* next;     /* Pointer to next object or NULL if last object */
  WORD              type;     /* What kind of GUI-object this is */
  long              min;      /* Minimum value for BB_Slider */
  long              max;      /* Maximum value for BB_Slider, max length of BB_String */
  long              set;      /* Value of BB_Slider, state of BB_Checkmark, BB_Cycle */
  char             *contents; /* Pointer to buffer for BB_String, pointer to stringarray for BB_Cycle */
  char             *label;    /* Label for ALL objects */
};


/*****************************************************/
/* The message to send to BlitzBlank/BlitzBlankPrefs */
/*****************************************************/

struct BB_Message
{
  struct Message    msg;        /* Normal Exec-Message-structure */
  long              flags;      /* Flags for this module */
  char             *infotext;   /* Pointer to infotext for this module */
  struct BB_Object *first;      /* Pointer to first BB_Object or NULL for Info-action */
  WORD              modpri;     /* not of use, if you use the library */
  char             *path;       /* Path to directory for module-data */
  struct Task      *blitzblank; /* not of use, if you use the library */
};


/***************************************/
/* The BlitzBlank-Screeninfo-structure */
/***************************************/

struct BB_Screeninfo
{
  WORD             xpos;       /* should be 0 */
  WORD             ypos;       /* should be 0 */
  WORD             width;      /* User-selected screen-width */
  WORD             height;     /* User-selected screen-height */
  WORD             depth;      /* User-selected screen-depth */
  long             mode;       /* User-selected screen-mode */
  struct Screen   *bbscreen;   /* module screen */
  struct Window   *bbwindow;   /* blank window */
  WORD             mindepth;   /* desired minimum depth or 0 */
  WORD             maxdepth;   /* desired maximum depth or 0 */
};


/************************************************************/
/* Flag-definition for BBL_AllocBitMap()/BBL_AllocRastPort, */
/* if you don't have the V39-includes                       */
/************************************************************/

#ifndef BMB_CLEAR
#define BMB_CLEAR 0
#define BMB_DISPLAYABLE 1
#define BMB_INTERLEAVED 2
#define BMF_CLEAR (1l<<BMB_CLEAR)
#define BMF_DISPLAYABLE (1l<<BMB_DISPLAYABLE)
#define BMF_INTERLEAVED (1l<<BMB_INTERLEAVED)
#endif

#endif


8. Description of the global definitions of a module (example)
--------------------------------------------------------------

/* Inclusion of the BlitzBlank definitions */

#include <pragmas/blitzblank_pragmas.h>
#include <BlitzBlank.h>

/* Definition of the BlitzBlankBase */

struct Library *BlitzBlankBase;

/* Versionstring */

static const char version[]="$VER: BB.Melt 2.50 (26.12.94)";

/* Definition of the texts (in english) */

char *text[]={"\33c\33uMelt\33n\n\nModule for BlitzBlank\n\nCopyright1994\nby\nThomas Börkel",
              "_Speed:",
              "S_ize:"};

/* Definition of the GUI objects with the default parameters */

struct BB_Object object[]={ {&object[1],BB_VGroup    ,0,  0,  0,NULL,NULL},
                            {&object[2],BB_Slider    ,1,150,100,NULL,NULL},
                            {&object[3],BB_Slider    ,1,100, 30,NULL,NULL},
                            {NULL      ,BB_VGroup_End,0,  0,  0,NULL,NULL} };


/* Definition of the BB_Message */

struct BB_Message message;

/* Definition of the pointer to BB_Screeninfo */

struct BB_Screeninfo *screeninfo;


9. Exact definition of the main program (example)
-------------------------------------------------

The main program should look like this (example in C):

void main (int argc,char **argv)
{
  int i;

/* Open the blitzblank.library */

  if (!(BlitzBlankBase=OpenLibrary ("blitzblank.library",BLITZBLANKLIB_VER)))
    exit (0);

/* Set the flags */

  message.flags=BBF_CloneScreen;
  message.first=&object[0];

/* BLANK/CONFIG/INFO? */

  if (strcmp (argv[1],"BLANK")==0)
  {

/* get screeninfo */

    StrToLong (argv[3],(long *) &screeninfo);

/* Set message and GUI objects */

    BBL_SendMessage (&message,argv[2]);

/* Screen open? */

    if (screeninfo->bbscreen)

/* Blank */

      blank ();

/* Stop blank routine */

    BBL_BlankDone ();
  }
  else
  {

/* Get locale texts (200=number you get from the BB-Author) */

    message.infotext=BBL_GetString (200,text[0]);

    for (i=1;i<=5;i++)
      object[i].label=BBL_GetString (200+i,text[i]);

    if (strcmp (argv[1],"CONFIG")==0)
    {
      BBL_SendMessage (&message,argv[2]);
    }
    else
    {
      message.first=NULL;
      BBL_SendMessage (&message,argv[2]);
    }
  }

/* Close library */

  CloseLibrary (BlitzBlankBase);
  exit (0);
}


10. Exact description of blank()
--------------------------------

void blank (void)
{

/* Make all preparetions (allocate memory etc.) */

/* if you've opened the screen yourself, put it in screeninfo->bbscreen */

  if (!CheckSignal (SIGBREAKF_CTRL_C))
  {

/* Get the screen to front */

     ScreenToFront (screeninfo->bbscreen);

     BBL_ModuleRunning (); /* your screen must be already in front here */

/* Main program with break possibility via SIGBREAKF_CTRL_C */
/* Read selected parameters from the GUI objects            */

  }

/* Clean up */

  return;
}


11. Advice for supporting the locale.library
--------------------------------------------

BlitzBlank/BlitzBlankPrefs use ONE catalog "blitzblank.catalog". Within are
all localized strings for BlitzBlank, BlitzBlankPrefs and all modules.
Which strings correspond to which program is determined by the BlitzBlank
author. The module programmers should incorporate the english text into
their module and submit a corresponding german text to the author. He will
then put the texts into the catalog.
Until now these numbers are used for texts:

001-199: BlitzBlank/BlitzBlankPrefs
200-209: BB.Melt
210-219: BB.Fade
220-229: BB.Pyro
230-239: BB.Crumble
240-249: BB.Mosaic
250-259: BB.Aquarium
260-269: BB.Flash
270-279: BB.Lines
280-289: BB.Butterfly
290-299: BB.Slideshow
300-309: BB.Starfield
310-319: BB.Splines
320-329: BB.AmigaSign
330-339: BB.PatternCycling
340-349: BB.Execute
350-359: BB.Worms
360-379: BB.Tiles
380-399: BB.Clock
400-409: BB.Mandel
410-419: BB.Electric
420-429: BB.Fountain
430-439: BB.Guru
440-449: BB.Noise
450-459: BB.Radar
460-469: BB.Snow
470-479: BB.Worms2
480-499: BB.Spot
500-509: BB.Life
510-519: BB.Dissolve
520-539: BB.Tunnel
540-549: BB.Gravity
550-559: BB.Skyline
560-589: BB.Text
590-599: BB.FlyingToaster
600-629: BB.Plasma
630-639: BB.TicTacToe
640-649: BB.Maze
650-659: BB.ARose
660-669: BB.Fractal
670-699: Reserved
700-709: BB.Goats
710-729: BB.ASwarm


12. AmigaGuide documentation for the modules
--------------------------------------------

The documentation for the modules will be incorporated into the global
AmigaGuide document BlitzBlank.Guide and will be displayed by
BlitzBlankPrefs if the HELP-key is pressed inside the modules prefs window.
The module's documentation with copyright and address of the author should
be submitted to the BlitzBlank author in english and german (if possible)
so they can be build into the guide.


13. Tips & tricks
-----------------

- If BlitzBlank is started from a shell all CON output of the modules are
  displayed in this shell (very good for debugging). If BlitzBlank is
  started from the WB and the module attempts CON output Enforcer hits will
  occur. This is normal because the modules don't get an output channel if
  they are started from WB. CON output may only be used for debugging
  purposes.

- The ARexx DEBUG instruction makes it possible to start a module that then
  can only be stopped through the ARexx UNBLANK instruction. This gives the
  oppurtunity to test the module without watching what the mouse is doing
  all the time.

- The best way to understand how to program a module is to look at the
  supplied source codes.

- The name convention for additional data is: "BB.Modulename.xyz"

- Not only the neccessary functions are in the blitzblank.library but also
  some very useful ones (eg for double-buffering!).

- If a module should use the randomizer one shouldn't forget to set the
  seed (for instance with the current time, look at BB.Lines for an
  example).
- Normally, you will draw into &screeninfo->bbscreen->RastPort, which is
  pretty fast. But with this, you get no clipping. To have clipping,
  set the flag BBF_BigWindow and draw into screeninfo->bbwindow->RPort.