/*  QUADROMANIA DELUXE V1.2
 * -------------------------
 *  programmiert in Aztec C
 *     von Tim Pietzcker
 * -------------------------
 * Das ganze Spiel wird mit
 * Gadgets gesteuert (ich
 * mußte schließlich mal
 * lernen,wie man die Dinger
 * programmiert.)
 * Änderungen seit 1.1 :
 * Bei Spielen mit 3 und mehr
 * Farbwechseln dreht der
 * Computer die Felder in
 * umgekehrter Reihenfolge um
 * -> weniger unnötige Züge
 * nötig;nun kann man das
 * Spiel immer mit höchstens
 * soviel Zügen schaffen, wie
 * es Permutationen gab.
 * -------------------------
 * Diese Version 3.Juni 1988
 * © 1988 Tim Pietzcker
 */

#include <intuition/intuition.h>
#include <graphics/gfxbase.h>
#include <exec/types.h>

#define START 1l              /* die Gadget-IDs */
#define MUST START+1l
#define AUFG MUST+1l
#define ENDE AUFG+1l
#define FAPL ENDE+1l
#define FAMI FAPL+1l
#define DRPL FAMI+1l
#define DRMI DRPL+1l
#define FERTIG DRMI+1l
#define S00 FERTIG+1l
#define S10 S00+1l
#define S20 S10+1l
#define S01 S20+1l
#define S11 S01+1l
#define S21 S11+1l
#define S02 S21+1l
#define S12 S02+1l
#define S22 S12+1l

struct IntuitionBase *IntuitionBase;   /* Zeiger auf Intuition */
struct GfxBase       *GfxBase;         /*   "     "  Graphics */
struct Library       *OpenLibrary();   /* für Aztec, 16 bits */
struct Window        *MyWindow,*OpenWindow();
struct Screen        *MyScreen,*OpenScreen();
struct RastPort      *rp;
struct ViewPort      *vp;
struct IntuiMessage  *msg,*GetMsg();
struct TextAttr      MyFont =
                     { (UBYTE *)"topaz.font",
                       TOPAZ_EIGHTY,FS_NORMAL,FPF_ROMFONT };
SHORT Request();

/* Texte für die Gadgets */

struct IntuiText TextFDPL =
   { 2,1,JAM2,0,0,&MyFont,(UBYTE *)"+",NULL };
struct IntuiText TextFDMI =
   { 2,1,JAM2,0,0,&MyFont,(UBYTE *)"-",NULL };
struct IntuiText TextENDE =
   { 2,1,JAM2,0,0,&MyFont,(UBYTE *)" Schluß ",NULL };
struct IntuiText TextAUFG =
   { 2,1,JAM2,0,0,&MyFont,(UBYTE *)"Aufgeben",NULL };
struct IntuiText TextMUST =
   { 2,1,JAM2,0,0,&MyFont,(UBYTE *)" Muster ",NULL };
struct IntuiText TextSTART =
   { 2,1,JAM2,0,0,&MyFont,(UBYTE *)" Start! ",NULL };

struct IntuiText TextFERTIG =
   { 2,1,JAM2,0,0,&MyFont,(UBYTE *)" Fertig ",NULL };

/* Borders für die Gadgets */

USHORT Koord1a[]  = { -1,-1, -1,8, 64,8, 64,-1, -1,-1 };
USHORT Koord1b[]  = { -2,-2, 65,-2, 65,9, -2,9, -2,-2,
                     -2,9, -1,10, 66,10, 66,-1 };
USHORT Koord2a[]  = { -1,-1, -1,8, 16,8, 16,-1, -1,-1 };
USHORT Koord2b[]  = { -2,-2, 17,-2, 17,9, -2,9, -2,-2,
                     -2,9, -1,10, 18,10, 18,-1 };
USHORT Koord3[]   = { -1,-1, -1,8, 8,8, 8,-1, -1,-1 };

USHORT Koord4[]   = { -1,-1, -1,16, 16,16, 16,-1, -1,-1 };

USHORT Koord5[]   = { 0,0, 79,0, 79,87, 0,87, 0,0, 0,12, 79,12 };

struct Border Border1b =
   { 0l,0l,2l,0l,JAM1,9l,(SHORT *)&Koord1b,NULL };
struct Border Border1a =
   { 0l,0l,1l,0l,JAM1,5l,(SHORT *)&Koord1a,&Border1b };

struct Border Border2b =
   { 0l,0l,2l,0l,JAM1,9l,(SHORT *)&Koord2b,NULL };
struct Border Border2a =
   { 0l,0l,1l,0l,JAM1,5l,(SHORT *)&Koord2a,&Border2b };

struct Border Border3 =
   { 0l,0l,2l,0l,JAM1,5l,(SHORT *)&Koord3,NULL };

struct Border Border4 =
   { 0l,0l,2l,0l,JAM1,5l,(SHORT *)&Koord4,NULL };

struct Border BorderRQ =
   { 0l,0l,6l,0l,JAM1,7l,(SHORT *)&Koord5,NULL };

/* Nun können die Gadgets selbst definiert werden ... */

struct Gadget DrMi =
   { NULL,276,244,8,8,GADGHCOMP,RELVERIFY,
     BOOLGADGET,NULL,NULL,&TextFDMI,NULL,NULL,DRMI,NULL };
struct Gadget DrPl =
   { &DrMi,268,244,8,8,GADGHCOMP,RELVERIFY,
     BOOLGADGET,(APTR)&Border2a,NULL,&TextFDPL,NULL,NULL,DRPL,NULL };
struct Gadget FaMi =
   { &DrPl,264,228,8,8,GADGHCOMP|GADGDISABLED,RELVERIFY,
     BOOLGADGET,NULL,NULL,&TextFDMI,NULL,NULL,FAMI,NULL };
struct Gadget FaPl =
   { &FaMi,256,228,8,8,GADGHCOMP,RELVERIFY,
     BOOLGADGET,(APTR)&Border2a,NULL,&TextFDPL,NULL,NULL,FAPL,NULL };
struct Gadget Ende =
   { &FaPl,96,243,64,8,GADGHCOMP,RELVERIFY,
     BOOLGADGET,(APTR)&Border1a,NULL,&TextENDE,NULL,NULL,ENDE,NULL };
struct Gadget Aufg =
   { &Ende,96,229,64,8,GADGHCOMP|GADGDISABLED,RELVERIFY,
     BOOLGADGET,(APTR)&Border1a,NULL,&TextAUFG,NULL,NULL,AUFG,NULL };
struct Gadget Must =
   { &Aufg,16,243,64,8,GADGHCOMP,RELVERIFY,
     BOOLGADGET,(APTR)&Border1a,NULL,&TextMUST,NULL,NULL,MUST,NULL };
struct Gadget Start =
   { &Must,16,229,64,8,GADGHCOMP,RELVERIFY,
     BOOLGADGET,(APTR)&Border1a,NULL,&TextSTART,NULL,NULL,START,NULL };

struct Gadget Sch22 =
   { NULL,51,51,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S22,NULL };
struct Gadget Sch12 =
   { &Sch22,33,51,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S12,NULL };
struct Gadget Sch02 =
   { &Sch12,15,51,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S02,NULL };
struct Gadget Sch21 =
   { &Sch02,51,33,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S21,NULL };
struct Gadget Sch11 =
   { &Sch21,33,33,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S11,NULL };
struct Gadget Sch01 =
   { &Sch11,15,33,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S01,NULL };
struct Gadget Sch20 =
   { &Sch01,51,15,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S20,NULL };
struct Gadget Sch10 =
   { &Sch20,33,15,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S10,NULL };
struct Gadget Sch00 =
   { &Sch10,15,15,16,16,GADGHCOMP|SELECTED,TOGGLESELECT|RELVERIFY,
     BOOLGADGET|REQGADGET,(APTR)&Border4,NULL,NULL,NULL,NULL,S00,NULL };

struct Gadget Fertig =
   { &Sch00,8,72,64,8,GADGHCOMP,RELVERIFY|ENDGADGET,BOOLGADGET|
     REQGADGET,(APTR)&Border1a,NULL,&TextFERTIG,NULL,NULL,FERTIG,NULL };

/* ...und das war der Rest der Gadgets . Jetzt kommen die IntuiText-structs,
   die ich zum Darstellen der ganzen Zahlen brauche ... */

char fstring[2],dstring[4],score[4];

struct IntuiText fTextb =
   { 1,0,JAM1,0,0,&MyFont,(UBYTE *)fstring,NULL };
struct IntuiText fTexta =
   { 6,0,JAM1,1,1,&MyFont,(UBYTE *)fstring,&fTextb };

struct IntuiText dTextb =
   { 1,0,JAM1,0,0,&MyFont,(UBYTE *)dstring,NULL };
struct IntuiText dTexta =
   { 6,0,JAM1,1,1,&MyFont,(UBYTE *)dstring,&dTextb };

struct IntuiText scoreTextb =
   { 1,0,JAM1,0,0,&MyFont,(UBYTE *)score,NULL };
struct IntuiText scoreText =
   { 6,0,JAM1,1,1,&MyFont,(UBYTE *)score,&scoreTextb };

struct IntuiText ReqText =
   { 1,0,JAM1,4,2,&MyFont,(UBYTE *)"Schablone",NULL };

struct NewScreen TheScreen =
{
   0,0,
   320,256,3,
   1,2,
   NULL,
   CUSTOMSCREEN,
   &MyFont,
   NULL,NULL,NULL,
};

struct NewWindow TheWindow =
{
   0,0,
   320,256,
   1,2,
   MOUSEBUTTONS|GADGETUP,
   BORDERLESS|ACTIVATE|RMBTRAP,
   &Start,
   NULL,
   (UBYTE *)"    QUADROMANIA © 1988 Tim Pietzcker",
   NULL,NULL,
   0,0,0,0,
   CUSTOMSCREEN,
};

struct Requester SchablonenRQ =
{
   NULL,
   32,160,80,88,
   0,0,
   &Fertig,&BorderRQ,
   &ReqText,NULL,
   4l,
   NULL,{NULL},{NULL},NULL,{NULL},
};

int feld[26][24],max=2,dreh=100,zuege=0;
int schab[3][3] = { 1,1,1, 1,1,1, 1,1,1 };
long spiel_laeuft=FALSE;

init()      /* alles aufmachen und,falls Speicher nicht reicht,aufräumen */
{
   if ((IntuitionBase=(struct IntuitionBase *)
      OpenLibrary("intuition.library",0l))==NULL) exit (FALSE);
   if ((GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",0l))==NULL)
      exit (FALSE);
   if ((MyScreen=OpenScreen(&TheScreen))==NULL)
      printf("Speicher reicht nicht für Screen...\n"),exit(FALSE);
   TheWindow.Screen=MyScreen;

   if ((MyWindow=OpenWindow(&TheWindow))==NULL)
      CloseScreen(MyScreen),printf("Speicher reicht nicht für Window...\n"),
      exit (FALSE);
   rp=MyWindow->RPort;
   vp=&(MyScreen->ViewPort);
   SetRGB4(vp,0l,0l,2l,4l);         /* meine Farben */
   SetRGB4(vp,1l,15l,15l,15l);
   SetRGB4(vp,2l,0l,0l,0l);
   SetRGB4(vp,3l,1l,12l,2l);
   SetRGB4(vp,4l,0l,5l,10l);
   SetRGB4(vp,5l,14l,14l,0l);
   SetRGB4(vp,6l,15l,0l,0l);
   SetRGB4(vp,7l,15l,15l,15l);
}

pruefe()                   /* ist wirklich alles abgeräumt ?? */
{
   int i,j,fertig=1;
   for (i=0;i<=25;i++)
   {
      for (j=0;j<=23;j++)
      {
         if (feld[i][j]) { fertig=0; goto test; }
      }
   }
   test:
   return(fertig);
}

initGadgets()              /* Kontrolleiste zeichnen */
{
   SetDrMd(rp,JAM1);
   SetAPen(rp,2l);

   Move(rp,0l,208l);
   Draw(rp,319l,208l);
   Draw(rp,319l,255l);
   Draw(rp,0l,255l);
   Draw(rp,0l,208l);

   Move(rp,0l,224l);
   Draw(rp,319l,224l);

   Move(rp,176l,208l);
   Draw(rp,176l,255l);

   Move(rp,176l,240l);
   Draw(rp,288l,240l);

   Move(rp,288l,224l);
   Draw(rp,228l,255l);

   SetAPen(rp,4l);

   RectFill(rp,2l,226l,174l,253l);
   RectFill(rp,178l,210l,318l,222l);
   RectFill(rp,178l,226l,286l,238l);
   RectFill(rp,178l,242l,286l,253l);
   RectFill(rp,290l,226l,318l,253l);

   RefreshGadgets(&Start,MyWindow,NULL);

   Move(rp,193l,219l);
   SetAPen(rp,6l);
   Text(rp,(UBYTE *)"Einstellungen:",14l);
   Move(rp,185l,235l);
   Text(rp,(UBYTE *)"FARBEN:",7l);
   Move(rp,185l,251l);
   Text(rp,(UBYTE *)"DREHEN:",7l);

   Move(rp,192l,218l);
   SetAPen(rp,1l);
   Text(rp,(UBYTE *)"Einstellungen:",14l);
   Move(rp,184l,234l);
   Text(rp,(UBYTE *)"FARBEN:",7l);
   Move(rp,184l,250l);
   Text(rp,(UBYTE *)"DREHEN:",7l);

}

zeichneZyklus(i)        /* Darstellen,in welcher Reihenfolge die Farben
                           aufeinanderfolgen */
int i;
{
   long j;
   SetAPen(rp,4l);
   RectFill(rp,2l,210l,174l,222l);
   SetAPen(rp,6l);
   SetDrMd(rp,JAM1);
   Move(rp,9l,219l);
   Text(rp,(UBYTE *)"Zyklus:",7l);
   SetAPen(rp,1l);
   Move(rp,8l,218l);
   Text(rp,(UBYTE *)"Zyklus:",7l);

   DrawBorder(rp,&Border3,64l,212l);
   SetAPen(rp,1l);
   RectFill(rp,64l,212l,71l,219l);

   Move(rp,73l,215l);
   Draw(rp,79l,215l);

   for(j=1l;j<i;j++)
   {
      DrawBorder(rp,&Border3,j*16l+64l,212l);
      SetAPen(rp,j+1l);
      RectFill(rp,j*16l+64l,212l,j*16l+71l,219l);
      SetAPen(rp,1l);
      Move(rp,j*16l+73l,215l);
      Draw(rp,j*16l+79l,215l);
   }
   DrawBorder(rp,&Border3,j*16l+64l,212l);
   SetAPen(rp,1l);
   RectFill(rp,j*16l+64l,212l,j*16l+71l,219l);
}

initSpielfeld()      /* Spielsteine zeichnen und Feld löschen */
{
   long i,j;

   SetAPen(rp,1l);
   for(i=0;i<=25;i++)
   {
      for(j=0;j<=23;j++)
      {
         feld[i][j]=0;
         RectFill(rp,i*12l+4l,j*8l+16l,i*12l+14l,j*8l+22l);
      }
   }
}

drehe(anzahl)                    /* Spiel vorbereiten */
int anzahl;
{
   ULONG seconds,micros;
   int i,x,y;
   CurrentTime(&seconds,&micros);
   srand((USHORT)seconds);

   for (i=0;i<anzahl;i++)
   {
      x=(rand()%24)+1;
      y=(rand()%22)+1;
      umdrehen(x,y);
   }
}

umdrehen(x,y)           /* ein 3*3-Feld umdrehen */
int x,y;
{
   feld[x-1][y-1]=(feld[x-1][y-1]+schab[0][0])%max;
   feld[x][y-1]=(feld[x][y-1]+schab[1][0])%max;
   feld[x+1][y-1]=(feld[x+1][y-1]+schab[2][0])%max;

   feld[x-1][y]=(feld[x-1][y]+schab[0][1])%max;
   feld[x][y]=(feld[x][y]+schab[1][1])%max;
   feld[x+1][y]=(feld[x+1][y]+schab[2][1])%max;

   feld[x-1][y+1]=(feld[x-1][y+1]+schab[0][2])%max;
   feld[x][y+1]=(feld[x][y+1]+schab[1][2])%max;
   feld[x+1][y+1]=(feld[x+1][y+1]+schab[2][2])%max;

   SetAPen(rp,(long)feld[x-1][y-1]+1l);
   zeichneRechteck(x-1,y-1);

   SetAPen(rp,(long)feld[x][y-1]+1l);
   zeichneRechteck(x,y-1);

   SetAPen(rp,(long)feld[x+1][y-1]+1l);
   zeichneRechteck(x+1,y-1);

   SetAPen(rp,(long)feld[x-1][y]+1l);
   zeichneRechteck(x-1,y);

   SetAPen(rp,(long)feld[x][y]+1l);
   zeichneRechteck(x,y);

   SetAPen(rp,(long)feld[x+1][y]+1l);
   zeichneRechteck(x+1,y);

   SetAPen(rp,(long)feld[x-1][y+1]+1l);
   zeichneRechteck(x-1,y+1);

   SetAPen(rp,(long)feld[x][y+1]+1l);
   zeichneRechteck(x,y+1);

   SetAPen(rp,(long)feld[x+1][y+1]+1l);
   zeichneRechteck(x+1,y+1);

}

zeichneRechteck(x,y)          /* tja,was wohl ? */
int x,y ;
{
   RectFill(rp,(long)(x*12+4),(long)(y*8+16),(long)(x*12+14),(long)(y*8+22));
}

process_Events()              /* Hier läuft das Spiel & die Gadgetabfrage */
{
   long x,y;
   int i,j;

   for (;;) {
   while(msg=GetMsg(MyWindow->UserPort))
   {

      switch(msg->Class)
      {
         case GADGETUP:
            switch(((struct Gadget *)(msg->IAddress))->GadgetID)
            {
               case START:
                  OffGadget(&FaMi,MyWindow,NULL);
                  OffGadget(&FaPl,MyWindow,NULL);
                  OffGadget(&DrMi,MyWindow,NULL);
                  OffGadget(&DrPl,MyWindow,NULL);
                  OffGadget(&Start,MyWindow,NULL);

                  OnGadget(&Aufg,MyWindow,NULL);
                  OffGadget(&Must,MyWindow,NULL);

                  for(i=0;i<3;i++)
                     for(j=0;j<3;j++)
                        schab[i][j]*=(max-1);
                  drehe(dreh);
                  for(i=0;i<3;i++)
                     for(j=0;j<3;j++)
                        schab[i][j]/=(max-1);

                  zuege=0;
                  score[0]='0',score[1]=0;
                  SetAPen(rp,4l);
                  RectFill(rp,292l,236l,317l,245l);
                  spiel_laeuft=TRUE;
                  break;
               case MUST:
                  Request(&SchablonenRQ,MyWindow);
                  break;
               case S22:
                  schab[2][2]=1-schab[2][2];
                  break;
               case S21:
                  schab[2][1]=1-schab[2][1];
                  break;
               case S20:
                  schab[2][0]=1-schab[2][0];
                  break;
               case S12:
                  schab[1][2]=1-schab[1][2];
                  break;
               case S11:
                  schab[1][1]=1-schab[1][1];
                  break;
               case S10:
                  schab[1][0]=1-schab[1][0];
                  break;
               case S02:
                  schab[0][2]=1-schab[0][2];
                  break;
               case S01:
                  schab[0][1]=1-schab[0][1];
                  break;
               case S00:
                  schab[0][0]=1-schab[0][0];
                  break;
               case AUFG:

                  if(max>2) OnGadget(&FaMi,MyWindow,NULL);
                  if(max<6) OnGadget(&FaPl,MyWindow,NULL);
                  if(dreh>50) OnGadget(&DrMi,MyWindow,NULL);
                  if(dreh<500) OnGadget(&DrPl,MyWindow,NULL);
                  OnGadget(&Start,MyWindow,NULL);
                  OffGadget(&Aufg,MyWindow,NULL);
                  OnGadget(&Must,MyWindow,NULL);
                  initSpielfeld();
                  spiel_laeuft=FALSE;
                  break;
               case ENDE:

                  CloseWindow(MyWindow);
                  CloseScreen(MyScreen);
                  CloseLibrary(IntuitionBase);
                  CloseLibrary(GfxBase);
                  exit (TRUE);
                  break;

               case FAPL:
                  max++;
                  if (max==6) OffGadget(&FaPl,MyWindow,NULL);
                  OnGadget(&FaMi,MyWindow,NULL);
                  ftoa((double)max,fstring,0,1);
                  fstring[1]=0;
                  SetAPen(rp,4l);
                  RectFill(rp,240l,228l,249l,237l);
                  PrintIText(rp,&fTexta,240l,228l);
                  zeichneZyklus(max);
                  break;

               case FAMI:
                  max--;
                  if(max==2) OffGadget(&FaMi,MyWindow,NULL);
                  OnGadget(&FaPl,MyWindow,NULL);
                  ftoa((double)max,fstring,0,1);
                  fstring[1]=0;
                  SetAPen(rp,4l);
                  RectFill(rp,240l,228l,249l,237l);
                  PrintIText(rp,&fTexta,240l,228l);
                  zeichneZyklus(max);
                  break;

               case DRPL:
                  dreh+=10;
                  if (dreh==500) OffGadget(&DrPl,MyWindow,NULL);
                  OnGadget(&DrMi,MyWindow,NULL);
                  ftoa((double)dreh,dstring,0,1);
                  dstring[3]=0;
                  SetAPen(rp,4l);
                  RectFill(rp,240l,244l,265l,253l);
                  PrintIText(rp,&dTexta,240l,244l);
                  break;

               case DRMI:
                  dreh-=10;
                  if (dreh==50) OffGadget(&DrMi,MyWindow,NULL);
                  OnGadget(&DrPl,MyWindow,NULL);
                  ftoa((double)dreh,dstring,0,1);
                  dstring[3]=0;
                  SetAPen(rp,4l);
                  RectFill(rp,240l,244l,265l,253l);
                  PrintIText(rp,&dTexta,240l,244l);
                  break;

               default:
                  break;
            } /* switch */
         break;

         case MOUSEBUTTONS:
            if (spiel_laeuft==TRUE)
            {
               switch(msg->Code)
               {
                  case SELECTUP:
                  case MENUUP:
                     if(MyWindow->MouseX > 15l && MyWindow->MouseX < 304l)
                        if(MyWindow->MouseY >23l && MyWindow->MouseY < 199l)
                        {
                           x=((MyWindow->MouseX)-4l)/12l;
                           y=((MyWindow->MouseY)-16l)/8l;
                           umdrehen((int)x,(int)y);
                           ++zuege;
                           ftoa((double)zuege,score,0,1);
                           score[3]=0;
                           SetAPen(rp,4l);
                           RectFill(rp,292l,236l,317l,245l);
                           PrintIText(rp,&scoreText,292l,236l);
                           if (pruefe())
                           {
                              gewonnen();

                              if(max>2) OnGadget(&FaMi,MyWindow,NULL);
                              if(max<6) OnGadget(&FaPl,MyWindow,NULL);
                              if(dreh>50) OnGadget(&DrMi,MyWindow,NULL);
                              if(dreh<500) OnGadget(&DrPl,MyWindow,NULL);
                              OnGadget(&Start,MyWindow,NULL);

                              OffGadget(&Aufg,MyWindow,NULL);
                              OnGadget(&Must,MyWindow,NULL);

                              spiel_laeuft=FALSE;
                           }
                        }
                     break;

                  default:
                     break;
               }
            }
            break;

         default:
            break;

      } /* switch */
      ReplyMsg(msg);
   } /* while */
   } /* for */
}


gewonnen()        /* wenn der User fertig ist ... */
{
   long i;
   SetWindowTitles(MyWindow,(UBYTE *)"Bravo! Du hast es geschafft!",NULL);
   for(i=0;i<100000;i++);
   SetWindowTitles(MyWindow,(UBYTE *)"   QUADROMANIA © 1988 Tim Pietzcker",NULL);
}

main()            /* Hauptprogramm */
{
   init();
   ShowTitle(MyScreen,FALSE);
   initGadgets();
   initSpielfeld();
   zeichneZyklus(2);
   fstring[0]='2',fstring[1]=0;
   dstring[0]='1',dstring[1]='0',dstring[2]='0',dstring[3]=0;
   score[0]='0',score[1]=0;

   PrintIText(rp,&fTexta,240l,228l);
   PrintIText(rp,&dTexta,240l,244l);
   PrintIText(rp,&scoreText,292l,236l);
   process_Events();
}