home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 577a.lha / Bomber_v1.2 / Sources.LZH / Sources / display.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-21  |  16.7 KB  |  790 lines
  1. /*
  2.  *     display.c
  3.  *
  4.  */
  5.  
  6. #include "Bomber.h"
  7. #include <exec/memory.h>
  8. #include "sound.h"
  9.  
  10.  
  11. #ifdef DEBUG
  12. # define D(debug) debug
  13. #else
  14. # define D(debug)
  15. #endif
  16.  
  17.  
  18. #define BUTTON_SIZE 12
  19.  
  20.  
  21. /*------------------------- Externe Daten...*/
  22.  
  23.  
  24. extern struct ExecBase    *SysBase;
  25. extern struct Library    *DOSBase;
  26.  
  27. extern long                fenster;
  28.  
  29. extern int                size_x, size_y, spiel_level, practice_mode;
  30.  
  31.  
  32. /*------------------------- Daten dieses Moduls...*/
  33.  
  34.  
  35. struct IntuitionBase    *IntuitionBase = NULL;
  36. struct GfxBase            *GfxBase = NULL;
  37. struct Library            *GadToolsBase = NULL;
  38.  
  39. struct TextAttr         topaz8 =
  40.                         {
  41.                             "topaz.font", 8, 0,    0
  42.                         };
  43.  
  44. struct TextFont            *font = NULL;
  45. struct Screen            *screen = NULL;
  46. struct Window            *window = NULL;
  47. void                    *vi = NULL;
  48. struct Gadget            *glist = NULL;
  49.  
  50. int                        minimal_width, minimal_height,
  51.                         spielfeld_links, spielfeld_oben,
  52.                         spielfeld_rechts, spielfeld_unten;
  53.  
  54. char                    *texte_level[] =
  55.                         { "Easy", "Medium", "Hard", "Alien" };
  56.  
  57. enum {
  58.     GAD_NEU = 0, GAD_FLAGS_REMAINING, GAD_COUNT_DOWN,
  59.     GAD_PRACTICE, GAD_LEVEL, GAD_ABOUT, GAD_HIGHSCORE,
  60.     GAD_ANZAHL };
  61.  
  62. struct Gadget            *mgg[ GAD_ANZAHL ];
  63.  
  64. int                        time_counter = 0,
  65.                         flag_counter = 0;
  66.  
  67.  
  68. /*------------------------- Images...*/
  69.  
  70.  
  71. USHORT ImageData_flag[] = {
  72.     /* Plane 0... */
  73.     0x0000,0x0010,0x0810,0x0fd0,0x0810,0x0810,0x0810,0x0810,
  74.     0x1c10,0x3e10,0x0010,0xfff0,
  75.     /* Plane 1... */
  76.     0xfff0,0x8000,0x87c0,0x87c0,0x87c0,0x8000,0x8000,0x8000,
  77.     0x8000,0x8000,0x8000,0x0000
  78. };
  79.  
  80. struct Image Image_flag = {
  81.     0, 0,
  82.     12, 12, 2,
  83.     ImageData_flag,
  84.     0x0003, 0x0000,
  85.     NULL
  86. };
  87.  
  88.  
  89. USHORT ImageData_clock[] = {
  90.     /* Plane 0... */
  91.     0x71c0,0xeee0,0xb5a0,0x4440,0x4440,0x8420,0xe7e0,0x8020,
  92.     0x4040,0x4440,0x75c0,0xeee0,
  93.     /* Plane 1... */
  94.     0x0000,0x0000,0x0e00,0x3b80,0x3b80,0x7bc0,0x78c0,0x7fc0,
  95.     0x3f80,0x3f80,0x0e00,0x0000,
  96. };
  97.  
  98. struct Image Image_clock = {
  99.     0, 0,
  100.     11, 12, 2,
  101.     ImageData_clock,
  102.     0x0003, 0x0000,
  103.     NULL
  104. };
  105.  
  106.  
  107. USHORT ImageData_bomb[] = {
  108.     /* Plane 0... */
  109.     0x0000,0x16b0,0x4910,0x2f50,0x0610,0x1f90,0x37d0,0x3fd0,
  110.     0x3fd0,0x1f90,0x0010,0xfff0,
  111.     /* Plane 1... */
  112.     0xfff0,0x96a0,0xcf00,0xa040,0x8000,0x8000,0x8c00,0x9000,
  113.     0x8000,0x8000,0x8000,0x0000
  114. };
  115.  
  116. struct Image Image_bomb = {
  117.     0, 0,
  118.     12, 12, 2,
  119.     ImageData_bomb,
  120.     0x0003, 0x0000,
  121.     NULL
  122. };
  123.  
  124.  
  125. USHORT ImageData_cover[] = {
  126.     /* Plane 0... */
  127.     0x0000,0x2ab0,0x5550,0x2ab0,0x5550,0x2ab0,0x5550,0x2ab0,
  128.     0x5550,0x2ab0,0x5550,0xfff0,
  129.     /* Plane 1... */
  130.     0xfff0,0xaaa0,0xd540,0xaaa0,0xd540,0xaaa0,0xd540,0xaaa0,
  131.     0xd540,0xaaa0,0xd540,0x0000
  132. };
  133.  
  134. struct Image Image_cover = {
  135.     0, 0,
  136.     12, 12, 2,
  137.     ImageData_cover,
  138.     0x0003, 0x0000,
  139.     NULL
  140. };
  141.  
  142.  
  143. USHORT ImageData_field[] = {
  144.     /* Plane 0... */
  145.     0x0000,0x0010,0x0010,0x0010,0x0010,0x0010,0x0010,0x0010,
  146.     0x0010,0x0010,0x0010,0xfff0,
  147.     /* Plane 1... */
  148.     0xfff0,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,
  149.     0x8000,0x8000,0x8000,0x0000
  150. };
  151.  
  152. struct Image Image_field = {
  153.     0, 0,
  154.     12, 12, 2,
  155.     ImageData_field,
  156.     0x0003, 0x0000,
  157.     NULL
  158. };
  159.  
  160.  
  161. typedef struct {
  162.     USHORT *id;
  163.     long size;
  164.     struct Image *im; } CIliste;
  165.  
  166. #define ELEMENT(a,b) a, sizeof(a), b
  167. #define ENDE NULL, NULL, NULL
  168.  
  169. CIliste images[] = {
  170.     ELEMENT( ImageData_flag , &Image_flag  ),
  171.     ELEMENT( ImageData_clock, &Image_clock ),
  172.     ELEMENT( ImageData_bomb , &Image_bomb  ),
  173.     ELEMENT( ImageData_cover, &Image_cover ),
  174.     ELEMENT( ImageData_field, &Image_field ),
  175.     ENDE };
  176.  
  177. struct Remember *ChipImages = NULL;
  178.  
  179.  
  180. void InitChipImages( CIliste list[] )
  181. {
  182.     char *memblock;
  183.     long sum = 0;
  184.     int i;
  185.     
  186.     for( i=0; list[i].id; i++ )
  187.         sum += list[i].size;
  188.  
  189.     memblock = AllocRemember( &ChipImages, sum, MEMF_CHIP );
  190.     
  191.     for( i=0; list[i].id; i++ )
  192.     {
  193.         CopyMem( list[i].id, memblock, list[i].size );
  194.         list[i].im->ImageData = memblock;
  195.         memblock += list[i].size;
  196.     }
  197. }
  198.  
  199.  
  200. void FreeChipImages( void )
  201. {
  202.     FreeRemember( &ChipImages, TRUE );
  203. }
  204.  
  205.  
  206. /*------------------------- Code-Deklarationen...*/
  207.  
  208.  
  209. extern void sendtimereq( long s, long m );
  210. extern void quit( char * );
  211.  
  212. extern void neues_spiel( void );
  213. extern void spielende( void );
  214. extern void free_spielfeld( void );
  215. extern void set_flag( int x, int y );
  216. extern void uncover_field( int x, int y );
  217.  
  218. extern void highscore_show( void );
  219.  
  220. extern void sound_play( int );
  221.  
  222.  
  223. static void resize_spielfeld( void );
  224.  
  225.  
  226. /*------------------------- Stub-Code...*/
  227.  
  228.  
  229. struct Gadget *CreateGadget( unsigned long kind, struct Gadget *gad,
  230.     struct NewGadget *ng, Tag tag1, ... )
  231. {
  232.     return CreateGadgetA( kind, gad, ng, (struct TagItem *)&tag1 );
  233. }
  234.  
  235. APTR GetVisualInfo( struct Screen *screen, Tag tag1, ... )
  236. {
  237.     return GetVisualInfoA( screen, (struct TagItem *)&tag1 );
  238. }
  239.  
  240. struct Window *OpenWindowTags( struct NewWindow *newWindow,
  241.     unsigned long tag1Type, ... )
  242. {
  243.     return OpenWindowTagList( newWindow, (struct TagItem *)&tag1Type );
  244. }
  245.  
  246. void DrawBevelBox( struct RastPort *rp,
  247.     long l, long t, long w, long h,
  248.     Tag tag1, ... )
  249. {
  250.     DrawBevelBoxA( rp, l, t, w, h, (struct TagItem *)&tag1 );
  251. }
  252.  
  253. void GT_SetGadgetAttrs( struct Gadget *gad, struct Window *win,
  254.     struct Requester *req, Tag tag1, ... )
  255. {
  256.     GT_SetGadgetAttrsA( gad, win, req, (struct TagItem *)&tag1 );
  257. }
  258.  
  259.  
  260. void PutChProc( void )
  261. {
  262.     #asm
  263.     move.b    d0,(a3)+
  264.     rts
  265.     #endasm
  266. }
  267.  
  268.  
  269. void SPrintf( UBYTE *dst, UBYTE *fmt, ... )
  270. {
  271.     RawDoFmt( fmt, (APTR)((long)&fmt + 4L), PutChProc, dst );
  272. }
  273.  
  274.  
  275. /*------------------------- Code-Definitionen...*/
  276.  
  277.  
  278. static struct Gadget *create_gadgets(
  279.     struct Gadget **glistptr, void *vi )
  280. {
  281.     struct NewGadget    ng;
  282.     struct Gadget        *gad;
  283.     struct RastPort        *rp;
  284.     int                    topborder,
  285.                         leftborder;
  286.     long                tl; /* wg. cc-Fehler */
  287.     
  288.     
  289.     // Erste Reihe...
  290.     
  291.     topborder  = screen->WBorTop + screen->Font->ta_YSize + 1;
  292.     leftborder = screen->WBorLeft;
  293.     rp  = & screen->RastPort;
  294.     gad = CreateContext(glistptr);
  295.     
  296.     ng.ng_TopEdge  = topborder + INTERHEIGHT;
  297.     ng.ng_Height = screen->Font->ta_YSize + 4;
  298.     if( ng.ng_Height < 12 ) ng.ng_Height=12;
  299.     ng.ng_VisualInfo = vi;
  300.     ng.ng_TextAttr = screen->Font;
  301.     ng.ng_UserData = 0;
  302.     ng.ng_Flags = 0;
  303.     
  304.     ng.ng_GadgetID = GAD_PRACTICE;
  305.     ng.ng_GadgetText = "Practice";
  306.     tl = TextLength( rp, "Practice", 8 );
  307.     ng.ng_LeftEdge = leftborder + 2*INTERWIDTH + tl;
  308.     ng.ng_Width = ng.ng_Height;
  309.     
  310.     mgg[GAD_PRACTICE] = gad = CreateGadget( CHECKBOX_KIND, gad, &ng,
  311.         GTCB_Checked, FALSE,
  312.         TAG_DONE );
  313.     
  314.     ng.ng_GadgetID = GAD_LEVEL;
  315.     ng.ng_GadgetText = NULL;
  316.     ng.ng_LeftEdge += mgg[GAD_PRACTICE]->Width + 2*INTERWIDTH;
  317.     tl = TextLength( rp, " Medium ", 8 );
  318.     ng.ng_Width = tl + 28;
  319.     
  320.     mgg[GAD_LEVEL] = gad = CreateGadget( CYCLE_KIND, gad, &ng,
  321.         GTCY_Labels, &texte_level,
  322.         TAG_DONE );
  323.     
  324.     ng.ng_GadgetID = GAD_ABOUT;
  325.     ng.ng_GadgetText = "About";
  326.     ng.ng_LeftEdge += mgg[GAD_LEVEL]->Width + 2*INTERWIDTH;
  327.     tl = TextLength( rp, " About ", 7 );
  328.     ng.ng_Width = tl + 4;
  329.     
  330.     mgg[GAD_ABOUT] = gad = CreateGadget( BUTTON_KIND, gad, &ng,
  331.         TAG_DONE );
  332.     
  333.     
  334.     // Zweite Reihe...
  335.     
  336.     ng.ng_TopEdge += ng.ng_Height + INTERHEIGHT;
  337.     
  338.     
  339.     ng.ng_GadgetID = GAD_NEU;
  340.     ng.ng_GadgetText = "New";
  341.     ng.ng_LeftEdge = leftborder + INTERWIDTH;
  342.     tl = TextLength( rp, " New ", 5 );
  343.     ng.ng_Width = tl + 4;
  344.     
  345.     mgg[GAD_NEU] = gad = CreateGadget( BUTTON_KIND, gad, &ng,
  346.         TAG_DONE );
  347.     
  348.     ng.ng_GadgetText = NULL;
  349.     tl = TextLength( rp, "00000", 5 );
  350.     ng.ng_Width = tl + 8;
  351.     
  352.     ng.ng_GadgetID = GAD_FLAGS_REMAINING;
  353.     ng.ng_LeftEdge += gad->Width + 12 + 3*INTERWIDTH;
  354.     
  355.     mgg[GAD_FLAGS_REMAINING] = gad = CreateGadget( NUMBER_KIND, gad, &ng,
  356.         GTNM_Number, 0,
  357.         GTNM_Border, TRUE,
  358.         GTBB_Recessed, TRUE,
  359.         TAG_DONE );
  360.     
  361.     ng.ng_GadgetID = GAD_COUNT_DOWN;
  362.     ng.ng_LeftEdge += gad->Width + 12 + 2*INTERWIDTH;
  363.     
  364.     mgg[GAD_COUNT_DOWN] = gad = CreateGadget( NUMBER_KIND, gad, &ng,
  365.         GTNM_Number, 0,
  366.         GTNM_Border, TRUE,
  367.         GTBB_Recessed, TRUE,
  368.         TAG_DONE );
  369.     
  370.     ng.ng_GadgetID = GAD_HIGHSCORE;
  371.     ng.ng_GadgetText = "HiSc";
  372.     tl = TextLength( rp, " HiSc ", 6 );
  373.     ng.ng_Width = tl + 4;
  374.     ng.ng_LeftEdge = mgg[GAD_ABOUT]->LeftEdge
  375.                     + mgg[GAD_ABOUT]->Width - ng.ng_Width;
  376.     
  377.     mgg[GAD_HIGHSCORE] = gad = CreateGadget( BUTTON_KIND, gad, &ng,
  378.         TAG_DONE );
  379.     
  380.     return( gad );
  381. }
  382.  
  383.  
  384. void window_sizing( BOOL possible )
  385. {
  386.     if( possible )
  387.     {
  388.         /* Window-Sizing lösen */
  389.         WindowLimits( window, minimal_width, minimal_height,
  390.                               -1,             -1 );
  391.         
  392.         /* Gadgets einschalten */
  393.         GT_SetGadgetAttrs( mgg[GAD_PRACTICE], window, NULL,
  394.             GA_DISABLED, FALSE, TAG_DONE );
  395.         GT_SetGadgetAttrs( mgg[GAD_LEVEL], window, NULL,
  396.             GA_DISABLED, FALSE, TAG_DONE );
  397.         GT_SetGadgetAttrs( mgg[GAD_ABOUT], window, NULL,
  398.             GA_DISABLED, FALSE, TAG_DONE );
  399.         GT_SetGadgetAttrs( mgg[GAD_HIGHSCORE], window, NULL,
  400.             GA_DISABLED, FALSE, TAG_DONE );
  401.     }
  402.     else
  403.     {
  404.         /* Window fixieren */
  405.         WindowLimits( window, window->Width, window->Height,
  406.                               window->Width, window->Height );
  407.         
  408.         /* Gadgets ausschalten */
  409.         GT_SetGadgetAttrs( mgg[GAD_PRACTICE], window, NULL,
  410.             GA_DISABLED, TRUE, TAG_DONE );
  411.         GT_SetGadgetAttrs( mgg[GAD_LEVEL], window, NULL,
  412.             GA_DISABLED, TRUE, TAG_DONE );
  413.         GT_SetGadgetAttrs( mgg[GAD_ABOUT], window, NULL,
  414.             GA_DISABLED, TRUE, TAG_DONE );
  415.         GT_SetGadgetAttrs( mgg[GAD_HIGHSCORE], window, NULL,
  416.             GA_DISABLED, TRUE, TAG_DONE );
  417.     }
  418. }
  419.  
  420.  
  421. void init_display( void )
  422. // Libs, Fenster öffnen etc.
  423. {
  424.     if( !(GfxBase = (struct GfxBase *)
  425.             OpenLibrary("graphics.library", 36L)) )
  426.         quit( "No graphics.library >= V36!\n" );
  427.     
  428.     if( !(IntuitionBase = (struct IntuitionBase *)
  429.             OpenLibrary("intuition.library", 36L)) )
  430.         quit( "No intuition.library >= V36!\n" );
  431.     
  432.     if( !(GadToolsBase = OpenLibrary("gadtools.library", 36L)) )
  433.         quit( "No gadtools.library >= V36!\n" );
  434.     
  435.     if( !(font = OpenFont(&topaz8)) )
  436.         quit( "Can't open topaz.font!\n" );
  437.     
  438.     if( !(screen = LockPubScreen(NULL)) )
  439.         quit( "Can't lock pubscreen!\n" );
  440.     
  441.     if( !(vi = GetVisualInfo(screen,TAG_DONE)) )
  442.         quit( "No VisualInfo!\n" );
  443.     
  444.     InitChipImages( images );
  445.     
  446.     if( !create_gadgets(&glist,vi) )
  447.         quit( "Can't create gadgets!\n" );
  448.     
  449.     window = OpenWindowTags( NULL,
  450.         WA_Title,            "Bomber 1.2",
  451.         WA_Width,            100,
  452.         WA_Height,            50,
  453.         WA_MinWidth,        100,
  454.         WA_MinHeight,        50,
  455.         WA_MaxWidth,        -1,
  456.         WA_MaxHeight,        -1,
  457.         WA_PubScreen,        screen,
  458.         
  459.         WA_SizeGadget,        TRUE,
  460.         WA_DragBar,            TRUE,
  461.         WA_DepthGadget,        TRUE,
  462.         WA_CloseGadget,        TRUE,
  463.         WA_RMBTrap,            TRUE,
  464.         WA_SmartRefresh,    TRUE,
  465.         WA_Activate,        TRUE,
  466.         
  467.         WA_IDCMP, CLOSEWINDOW | REFRESHWINDOW |
  468.                   BUTTONIDCMP | NEWSIZE | MOUSEBUTTONS,
  469.         TAG_DONE );
  470.     
  471.     if( !window )
  472.         quit( "Unable to open window!\n" );
  473.     
  474.     spielfeld_links = mgg[GAD_NEU]->LeftEdge;
  475.     
  476.     minimal_width  = mgg[GAD_ABOUT]->LeftEdge + mgg[GAD_ABOUT]->Width +
  477.                      INTERWIDTH + window->BorderRight;
  478.     
  479.     spielfeld_oben = mgg[GAD_NEU]->TopEdge + mgg[GAD_NEU]->Height +
  480.                      INTERHEIGHT;
  481.     
  482.     minimal_height = spielfeld_oben + 2*BUTTON_SIZE+2 +
  483.                      INTERHEIGHT + window->BorderBottom;
  484.     
  485.     /* Fenster verändern (Auftrag an Intuition!) */
  486.     ChangeWindowBox( window,
  487.         (screen->Width - minimal_width ) / 2,
  488.         (screen->Height - minimal_height - 6*BUTTON_SIZE) / 2,
  489.         minimal_width, minimal_height + 6*BUTTON_SIZE );
  490.     
  491.     /* Fensterveränderungen abwarten! */
  492.     Delay( 8 );
  493.     
  494.     WindowLimits( window, minimal_width, minimal_height, -1, -1 );
  495.     
  496.     /* Fensterveränderungen abwarten! */
  497.     Delay( 8 );
  498.     
  499.     fenster = 1 << window->UserPort->mp_SigBit;
  500.     
  501.     AddGList( window, glist, 0, -1, NULL );
  502.     RefreshGList( glist, window, NULL, -1 );
  503.     GT_RefreshWindow( window, NULL );
  504.     
  505.     DrawImage( window->RPort, &Image_flag,
  506.         mgg[GAD_FLAGS_REMAINING]->LeftEdge - 12 - INTERWIDTH,
  507.         mgg[GAD_FLAGS_REMAINING]->TopEdge +
  508.             (mgg[GAD_FLAGS_REMAINING]->Height - 12) / 2 );
  509.     DrawImage( window->RPort, &Image_clock,
  510.         mgg[GAD_COUNT_DOWN]->LeftEdge - 12 - INTERWIDTH,
  511.         mgg[GAD_COUNT_DOWN]->TopEdge +
  512.             (mgg[GAD_COUNT_DOWN]->Height - 12) / 2 );
  513.     
  514.     resize_spielfeld();
  515. }
  516.  
  517.  
  518. void close_display( void )
  519. {
  520.     if(window) CloseWindow(window);
  521.  
  522.     if(GadToolsBase)
  523.     {
  524.         FreeGadgets(glist);
  525.         FreeVisualInfo(vi);
  526.         CloseLibrary(GadToolsBase);
  527.     }
  528.  
  529.     FreeChipImages();
  530.     if(screen) UnlockPubScreen(NULL, screen);
  531.     if(font) CloseFont(font);
  532.  
  533.     if(IntuitionBase) CloseLibrary(IntuitionBase);
  534.     if(GfxBase) CloseLibrary(GfxBase);
  535. }
  536.  
  537.  
  538. void draw_field( int x, int y, UBYTE inhalt )
  539. {
  540.     static struct IntuiText zahl = {
  541.         1,0, JAM1, 2,2, &topaz8, "0", NULL
  542.     };
  543.     
  544.     x *= BUTTON_SIZE; x += spielfeld_links + 1;
  545.     y *= BUTTON_SIZE; y += spielfeld_oben  + 1;
  546.     
  547.     if( inhalt & 64 )
  548.     {
  549.         DrawImage( window->RPort, &Image_flag, x, y );
  550.     }
  551.     else if( inhalt & 128 )
  552.     {
  553.         DrawImage( window->RPort, &Image_cover, x, y );
  554.     }
  555.     else if( inhalt & 32 )
  556.     {
  557.         DrawImage( window->RPort, &Image_bomb, x, y );
  558.     }
  559.     else
  560.     {
  561.         DrawImage( window->RPort, &Image_field, x, y );
  562.         
  563.         if( inhalt & 31 )
  564.         {
  565.             *zahl.IText = '0' + inhalt;
  566.             PrintIText( window->RPort, &zahl, x, y );
  567.         }
  568.     }
  569. }
  570.  
  571.  
  572. void clear_spielfeld( void )
  573. {
  574.     SetAPen( window->RPort, 0 );
  575.     RectFill( window->RPort,
  576.         spielfeld_links  + 1, spielfeld_oben  + 1,
  577.         spielfeld_rechts - 1, spielfeld_unten - 1 );
  578. }
  579.  
  580.  
  581. static void handle_button( struct Gadget *gad, UWORD code )
  582. {
  583.     static struct EasyStruct aboutreq = {
  584.         sizeof (struct EasyStruct), 0,
  585.         "About Bomber 1.2",
  586.         "Amiga Version by Michael Balzer, October 1991\n\n"
  587.         "Find all bombs! Use right button to flag bombs,\n"
  588.         "left button to uncover fields / remove flags.\n"
  589.         "Click right button over flag to reveal a field\n" 
  590.         "(attention: time punishment of 5 percent).\n"
  591.         "Uncovered fields will show the number of bombs\n"
  592.         "next to them (up to 8)...\n\n"
  593.         "This software is »HappyWare« - if you use it,\n"
  594.         "remember to smile!   :-)\n\n"
  595.         "        Have fun!",
  596.         " I'll do! " };
  597.     
  598.     
  599.     switch( gad->GadgetID )
  600.     {
  601.         case GAD_NEU:
  602.             neues_spiel();
  603.             break;
  604.         
  605.         case GAD_LEVEL:
  606.             spiel_level = code;
  607.             break;
  608.         
  609.         case GAD_PRACTICE:
  610.             practice_mode = gad->Flags & SELECTED;
  611.             break;
  612.         
  613.         case GAD_ABOUT:
  614.             EasyRequestArgs( window, &aboutreq, NULL, NULL );
  615.             break;
  616.         
  617.         case GAD_HIGHSCORE:
  618.             highscore_show();
  619.             break;
  620.     }
  621. }
  622.  
  623.  
  624. static void handle_click( int x, int y, UWORD code )
  625. {
  626.     if( time_counter || practice_mode )
  627.     {
  628.         if( code==SELECTDOWN )
  629.         {
  630.             uncover_field( x, y );
  631.         }
  632.         else if( code==MENUDOWN )
  633.         {
  634.             set_flag( x, y );
  635.         }
  636.     }
  637. }
  638.  
  639.  
  640. static void resize_spielfeld( void )
  641. {
  642.     /* size_x/y neu berechnen, Spielfeldrahmen zeichnen */
  643.     static char sizetext[10];
  644.     static struct IntuiText sizeitext = {
  645.         1,0, JAM1, 0,0, &topaz8, sizetext, NULL
  646.     };
  647.         
  648.     
  649.     // Speicher freigeben
  650.     free_spielfeld();
  651.     
  652.     SetAPen( window->RPort, 0 );
  653.     RectFill( window->RPort, spielfeld_links, spielfeld_oben,
  654.         window->Width  - window->BorderRight  - 1,
  655.         window->Height - window->BorderBottom - 1 );
  656.     
  657.     spielfeld_rechts = window->Width - window->BorderRight - INTERWIDTH;
  658.     size_x = spielfeld_rechts - spielfeld_links - 1;
  659.     spielfeld_rechts -= size_x % BUTTON_SIZE;
  660.     size_x /= BUTTON_SIZE;
  661.     
  662.     spielfeld_unten = window->Height - window->BorderBottom - INTERHEIGHT;
  663.     size_y = spielfeld_unten - spielfeld_oben - 1;
  664.     spielfeld_unten -= size_y % BUTTON_SIZE;
  665.     size_y /= BUTTON_SIZE;
  666.     
  667.     DrawBevelBox( window->RPort,
  668.         spielfeld_links, spielfeld_oben,
  669.         spielfeld_rechts - spielfeld_links + 1,
  670.         spielfeld_unten - spielfeld_oben + 1,
  671.         GTBB_Recessed, TRUE,
  672.         GT_VisualInfo, vi,
  673.         TAG_DONE );
  674.     
  675.     SPrintf( sizetext, "%ld*%ld", size_x, size_y );
  676.     sizeitext.LeftEdge = (spielfeld_rechts - spielfeld_links
  677.                          - 8*strlen(sizetext)) / 2;
  678.     sizeitext.TopEdge  = (spielfeld_unten  - spielfeld_oben - 4) / 2;
  679.     PrintIText( window->RPort, &sizeitext,
  680.                 spielfeld_links, spielfeld_oben );
  681. }
  682.  
  683.  
  684. BOOL handle_window_event( void )
  685. {
  686.     struct IntuiMessage    *imsg;
  687.     struct Gadget        *gad;
  688.     ULONG                class;
  689.     UWORD                code;
  690.     WORD                x, y;
  691.     
  692.     
  693.     while( imsg = GT_GetIMsg(window->UserPort) )
  694.     {
  695.         class = imsg->Class;
  696.         code  = imsg->Code;
  697.         gad = (struct Gadget *)imsg->IAddress;
  698.             // ^^^ natürlich nur bei Gadgets gültig
  699.         x = imsg->MouseX;
  700.         y = imsg->MouseY;
  701.         GT_ReplyIMsg( imsg );
  702.         
  703.         switch( class )
  704.         {
  705.             case MOUSEBUTTONS:
  706.                 if( x>spielfeld_links && x<spielfeld_rechts
  707.                  && y>spielfeld_oben  && y<spielfeld_unten )
  708.                 {
  709.                     handle_click(
  710.                         (x-spielfeld_links-1) / BUTTON_SIZE,
  711.                         (y-spielfeld_oben-1 ) / BUTTON_SIZE,
  712.                         code );
  713.                 }
  714.                 break;
  715.             
  716.             case GADGETUP:
  717.                 handle_button( gad, code );
  718.                 break;
  719.             
  720.             case NEWSIZE:
  721.                 if( time_counter == 0 )
  722.                 {
  723.                     resize_spielfeld();
  724.                 }
  725.                 break;
  726.             
  727.             case CLOSEWINDOW:
  728.                 return( TRUE );
  729.                 break;
  730.             
  731.             case REFRESHWINDOW:
  732.                 GT_BeginRefresh( window );
  733.                 GT_EndRefresh( window, TRUE );
  734.                 break;
  735.         }
  736.     }
  737.     
  738.     return( FALSE );
  739. }
  740.  
  741.  
  742. void count_down( void )
  743. {
  744.     D(printf("count_down: time=%d\n", time_counter));
  745.     
  746.     if( ! time_counter ) return;
  747.     
  748.     --time_counter;
  749.     
  750.     /* Zeit auch während graf. Lock weiterzählen */
  751.     if( AttemptLockLayerRom(window->RPort->Layer) )
  752.     {
  753.         UnlockLayerRom( window->RPort->Layer );
  754.         GT_SetGadgetAttrs( mgg[GAD_COUNT_DOWN], window, NULL,
  755.             GTNM_Number, time_counter,
  756.             TAG_DONE );
  757.     }
  758.     
  759.     if( time_counter )
  760.     {
  761.         sendtimereq( 1, 0 );
  762.     }
  763.     else
  764.     {
  765.         sound_play( SOUND_EXPLOSION );
  766.         window_sizing( TRUE );
  767.         
  768.         if( !practice_mode )
  769.         {
  770.             /* GAME OVER durch TimeOut */
  771.             spielende();
  772.         }
  773.     }
  774. }
  775.  
  776.  
  777. void change_flagcounter( int wert )
  778. {
  779.     flag_counter += wert;
  780.     
  781.     // s.o.
  782.     if( AttemptLockLayerRom(window->RPort->Layer) )
  783.     {
  784.         UnlockLayerRom( window->RPort->Layer );
  785.         GT_SetGadgetAttrs( mgg[GAD_FLAGS_REMAINING], window, NULL,
  786.             GTNM_Number, flag_counter,
  787.             TAG_DONE );
  788.     }
  789. }
  790.