rnd-20040822-1-src

diff --git a/src/conftime.h b/src/conftime.h
index 5271831554c075b7e794bdd1db3842b2b326f58c..26dc228fd647526c5671a2a89af3da8bad589173 100644 (file)
--- a/src/conftime.h
+++ b/src/conftime.h
@@ -1 +1 @@
-#define COMPILE_DATE_STRING "[2004-08-21 22:13]"
+#define COMPILE_DATE_STRING "[2004-08-22 00:42]"

diff --git a/src/game_em/display.h b/src/game_em/display.h
index 9a6ca203217c2aa1ff0c9128e75f461697f0cce0..b9dbb590641c4acf0f7728826b7d44c1c4f92056 100644 (file)
--- a/src/game_em/display.h
+++ b/src/game_em/display.h
@@ -26,9 +26,23 @@
 #define MENUFONTX              (ORIG_MENUFONTX         * ZOOM_FACTOR)
 #define MENUFONTY              (ORIG_MENUFONTY         * ZOOM_FACTOR)
 
+#define ORIG_SCR_MENUX         20
+#define ORIG_SCR_MENUY         12
+#define SCR_MENUX              17
+#define SCR_MENUY              12
+#define SCR_FIELDX             17
+#define SCR_FIELDY             17
+#define MAX_BUF_XSIZE          (SCR_FIELDX + 2)
+#define MAX_BUF_YSIZE          (SCR_FIELDY + 2)
+
 /* often used screen positions */
+#define ORIG_MENU_SX           ((ORIG_SCR_MENUX - SCR_MENUX) * TILEX / 2)
+#define ORIG_MENU_SY           0
+#define SY                     8
 #define SX                     8
 #define SY                     8
+#define SXSIZE                 (SCR_FIELDX * TILEX)
+#define SYSIZE                 (SCR_FIELDY * TILEY)
 
 #if 0
 

diff --git a/src/game_em/graphics.c b/src/game_em/graphics.c
index 483d63b5044a43be5cbcb29c414a0b2a004bf68e..70c45c5393c897cdbce907ec87d7defc02cbc936 100644 (file)
--- a/src/game_em/graphics.c
+++ b/src/game_em/graphics.c
@@ -19,7 +19,8 @@ unsigned int frame; /* current frame */
 unsigned int screen_x; /* current scroll position */
 unsigned int screen_y;
 
-static unsigned short screentiles[14][22]; /* tiles currently on screen */
+/* tiles currently on screen */
+static unsigned short screentiles[MAX_BUF_YSIZE][MAX_BUF_XSIZE];
 
 static unsigned int colours[8];
 static unsigned int colour_anim;
@@ -49,62 +50,85 @@ static void colour_shuffle(void)
   }
 }
 
+
 /* copy the entire screen to the window at the scroll position
  *
  * perhaps use mit-shm to speed this up
  */
+
 void blitscreen(void)
 {
-  unsigned int x = screen_x % (22 * TILEX);
-  unsigned int y = screen_y % (14 * TILEY);
+  unsigned int x = screen_x % (MAX_BUF_XSIZE * TILEX);
+  unsigned int y = screen_y % (MAX_BUF_YSIZE * TILEY);
 
   xdebug("blitscreen");
 
+  if (em_game_status == EM_GAME_STATUS_MENU)
+  {
+    ClearRectangle(screenBitmap, 0, SCR_MENUY * TILEY,
+                  SCR_FIELDX * TILEX, (17 - SCR_MENUY) * TILEY);
+    BlitBitmap(scoreBitmap, screenBitmap, 0, 0, SCR_MENUX * TILEX, SCOREY,
+              0, SCR_MENUY * TILEY);
+  }
+
   if (x < 2 * TILEX && y < 2 * TILEY)
   {
     BlitBitmap(screenBitmap, window, x, y,
-              20 * TILEX, 12 * TILEY, SX, SY);
+              SCR_FIELDX * TILEX, SCR_FIELDY * TILEY, SX, SY);
   }
   else if (x < 2 * TILEX && y >= 2 * TILEY)
   {
     BlitBitmap(screenBitmap, window, x, y,
-              20 * TILEX, 14 * TILEY - y, SX, SY);
+              SCR_FIELDX * TILEX, MAX_BUF_YSIZE * TILEY - y,
+              SX, SY);
     BlitBitmap(screenBitmap, window, x, 0,
-              20 * TILEX, y - 2 * TILEY, SX, SY + 14 * TILEY - y);
+              SCR_FIELDX * TILEX, y - 2 * TILEY,
+              SX, SY + MAX_BUF_YSIZE * TILEY - y);
   }
   else if (x >= 2 * TILEX && y < 2 * TILEY)
   {
     BlitBitmap(screenBitmap, window, x, y,
-              22 * TILEX - x, 12 * TILEY, SX, SY);
+              MAX_BUF_XSIZE * TILEX - x, SCR_FIELDY * TILEY,
+              SX, SY);
     BlitBitmap(screenBitmap, window, 0, y,
-              x - 2 * TILEX, 12 * TILEY, SX + 22 * TILEX - x, SY);
+              x - 2 * TILEX, SCR_FIELDY * TILEY,
+              SX + MAX_BUF_XSIZE * TILEX - x, SY);
   }
   else
   {
     BlitBitmap(screenBitmap, window, x, y,
-              22 * TILEX - x, 14 * TILEY - y, SX, SY);
+              MAX_BUF_XSIZE * TILEX - x, MAX_BUF_YSIZE * TILEY - y,
+              SX, SY);
     BlitBitmap(screenBitmap, window, 0, y,
-              x - 2 * TILEX, 14 * TILEY - y, SX + 22 * TILEX - x, SY);
+              x - 2 * TILEX, MAX_BUF_YSIZE * TILEY - y,
+              SX + MAX_BUF_XSIZE * TILEX - x, SY);
     BlitBitmap(screenBitmap, window, x, 0,
-              22 * TILEX - x, y - 2 * TILEY, SX, SY + 14 * TILEY - y);
+              MAX_BUF_XSIZE * TILEX - x, y - 2 * TILEY,
+              SX, SY + MAX_BUF_YSIZE * TILEY - y);
     BlitBitmap(screenBitmap, window, 0, 0,
               x - 2 * TILEX, y - 2 * TILEY,
-              SX + 22 * TILEX - x, SY + 14 * TILEY - y);
+              SX + MAX_BUF_XSIZE * TILEX - x, SY + MAX_BUF_YSIZE * TILEY - y);
   }
 
-  BlitBitmap(scoreBitmap, window, 0, 0,
-            20 * TILEX, SCOREY, SX, SY + 12 * TILEY);
+  /* draw either the main menu footer or the in-game time/gems/score values */
+
+  if (em_game_status == EM_GAME_STATUS_PLAY)
+    BlitBitmap(scoreBitmap, window, 0, 0, SCR_FIELDX * TILEX, SCOREY,
+              SX, SY + SCR_FIELDY * TILEY - SCOREY);
+
   XFlush(display);
 
   xdebug("blitscreen - done");
 }
 
+
 /* draw differences between game tiles and screen tiles
  *
  * implicitly handles scrolling and restoring background under the sprites
  *
  * perhaps use mit-shm to speed this up
  */
+
 static void animscreen(void)
 {
   unsigned int x, y, dx, dy;
@@ -114,12 +138,12 @@ static void animscreen(void)
 
   xdebug("animscreen");
 
-  for (y = top; y < top + 14; y++)
+  for (y = top; y < top + MAX_BUF_YSIZE; y++)
   {
-    dy = y % 14;
-    for (x = left; x < left + 22; x++)
+    dy = y % MAX_BUF_YSIZE;
+    for (x = left; x < left + MAX_BUF_XSIZE; x++)
     {
-      dx = x % 22;
+      dx = x % MAX_BUF_XSIZE;
       obj = map_obj[frame][Draw[y][x]];
 
       if (screentiles[dy][dx] != obj)
@@ -133,10 +157,12 @@ static void animscreen(void)
   }
 }
 
+
 /* blit players to the screen
  *
  * handles transparency and movement
  */
+
 static void blitplayer(struct PLAYER *ply)
 {
   unsigned int x, y, dx, dy;
@@ -151,14 +177,14 @@ static void blitplayer(struct PLAYER *ply)
     dx = x + TILEX - 1;
     dy = y + TILEY - 1;
 
-    if ((unsigned int)(dx - screen_x) < (21 * TILEX - 1) &&
-       (unsigned int)(dy - screen_y) < (13 * TILEY - 1))
+    if ((unsigned int)(dx - screen_x) < ((MAX_BUF_XSIZE - 1) * TILEX - 1) &&
+       (unsigned int)(dy - screen_y) < ((MAX_BUF_YSIZE - 1) * TILEY - 1))
     {
       spr = map_spr[ply->num][frame][ply->anim];
-      x %= 22 * TILEX;
-      y %= 14 * TILEY;
-      dx %= 22 * TILEX;
-      dy %= 14 * TILEY;
+      x  %= MAX_BUF_XSIZE * TILEX;
+      y  %= MAX_BUF_YSIZE * TILEY;
+      dx %= MAX_BUF_XSIZE * TILEX;
+      dy %= MAX_BUF_YSIZE * TILEY;
 
       if (objmaskBitmap)
       {
@@ -170,7 +196,8 @@ static void blitplayer(struct PLAYER *ply)
        obj = screentiles[dy / TILEY][dx / TILEX];
        XCopyArea(display, objmaskBitmap, spriteBitmap, spriteGC,
                  (obj / 512) * TILEX, (obj % 512) * TILEY / 16, TILEX, TILEY,
-                 (22 * TILEX - x) % TILEX, (14 * TILEY - y) % TILEY);
+                 (MAX_BUF_XSIZE * TILEX - x) % TILEX,
+                 (MAX_BUF_YSIZE * TILEY - y) % TILEY);
       }
       else if (sprmaskBitmap)
       {
@@ -197,15 +224,17 @@ static void blitplayer(struct PLAYER *ply)
                       (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
                       x, y);
 
-      SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc, x - 22 * TILEX, y);
+      SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc,
+                   x - MAX_BUF_XSIZE * TILEX, y);
       BlitBitmapMasked(sprBitmap, screenBitmap,
                       (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
-                      x - 22 * TILEX, y);
+                      x - MAX_BUF_XSIZE * TILEX, y);
 
-      SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc, x, y - 14 * TILEY);
+      SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc,
+                   x, y - MAX_BUF_YSIZE * TILEY);
       BlitBitmapMasked(sprBitmap, screenBitmap,
                       (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
-                      x, y - 14 * TILEY);
+                      x, y - MAX_BUF_YSIZE * TILEY);
 
       SetClipMask(sprBitmap, sprBitmap->stored_clip_gc, None);
 
@@ -219,17 +248,19 @@ static void blitplayer(struct PLAYER *ply)
                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
                x, y);
 
-      XSetClipOrigin(display, sprBitmap->stored_clip_gc, x - 22 * TILEX, y);
+      XSetClipOrigin(display, sprBitmap->stored_clip_gc,
+                    x - MAX_BUF_XSIZE * TILEX, y);
       XCopyArea(display, sprBitmap->drawable, screenBitmap->drawable,
                sprBitmap->stored_clip_gc,
                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
-               x - 22 * TILEX, y);
+               x - MAX_BUF_XSIZE * TILEX, y);
 
-      XSetClipOrigin(display, sprBitmap->stored_clip_gc, x, y - 14 * TILEY);
+      XSetClipOrigin(display, sprBitmap->stored_clip_gc,
+                    x, y - MAX_BUF_YSIZE * TILEY);
       XCopyArea(display, sprBitmap->drawable, screenBitmap->drawable,
                sprBitmap->stored_clip_gc,
                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
-               x, y - 14 * TILEY);
+               x, y - MAX_BUF_YSIZE * TILEY);
 
       XSetClipMask(display, sprBitmap->stored_clip_gc, None);
 
@@ -242,14 +273,14 @@ static void blitplayer(struct PLAYER *ply)
       XCopyArea(display, sprPixmap, screenPixmap, screenGC,
                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
                x, y);
-      XSetClipOrigin(display, screenGC, x - 22 * TILEX, y);
+      XSetClipOrigin(display, screenGC, x - MAX_BUF_XSIZE * TILEX, y);
       XCopyArea(display, sprPixmap, screenPixmap, screenGC,
                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
-               x - 22 * TILEX, y);
-      XSetClipOrigin(display, screenGC, x, y - 14 * TILEY);
+               x - MAX_BUF_XSIZE * TILEX, y);
+      XSetClipOrigin(display, screenGC, x, y - MAX_BUF_YSIZE * TILEY);
       XCopyArea(display, sprPixmap, screenPixmap, screenGC,
                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
-               x, y - 14 * TILEY);
+               x, y - MAX_BUF_YSIZE * TILEY);
       XSetClipMask(display, screenGC, None);
 
 #endif
@@ -257,6 +288,9 @@ static void blitplayer(struct PLAYER *ply)
   }
 }
 
+
+/* draw static text for time, gems and score counter */
+
 void game_initscreen(void)
 {
   unsigned int x,y;
@@ -267,8 +301,8 @@ void game_initscreen(void)
   screen_x = 0;
   screen_y = 0;
 
-  for (y = 0; y < 14; y++)
-    for (x = 0; x < 22; x++)
+  for (y = 0; y < MAX_BUF_YSIZE; y++)
+    for (x = 0; x < MAX_BUF_XSIZE; x++)
       screentiles[y][x] = -1;
 
   colour_shuffle();
@@ -277,18 +311,21 @@ void game_initscreen(void)
   colours[2] += 16;
   colour_anim = 0;
 
-  ClearRectangle(scoreBitmap, 0, 0, 20 * TILEX, SCOREY);
+  ClearRectangle(scoreBitmap, 0, 0, SCR_FIELDX * TILEX, SCOREY);
   BlitBitmap(botBitmap, scoreBitmap,
             11 * SCOREX, colours[0] * SCOREY, 3 * SCOREX, SCOREY,
             1 * SCOREX, 0);                            /* 0-63 time */
   BlitBitmap(botBitmap, scoreBitmap,
             18 * SCOREX, colours[0] * SCOREY, 6 * SCOREX, SCOREY,
-            15 * SCOREX, 0);                           /* 112-207 diamonds */
+            11 * SCOREX, 0);                           /* 112-207 diamonds */
   BlitBitmap(botBitmap, scoreBitmap,
             14 * SCOREX, colours[0] * SCOREY, 4 * SCOREX, SCOREY,
-            32 * SCOREX, 0);                           /* 256-319 score */
+            24 * SCOREX, 0);                           /* 256-319 score */
 }
 
+
+/* draw current values for time, gems and score counter */
+
 void game_blitscore(void)
 {
   unsigned int i;
@@ -312,16 +349,16 @@ void game_blitscore(void)
   i = lev.score;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            39 * SCOREX, 0); i /= 10;
+            31 * SCOREX, 0); i /= 10;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            38 * SCOREX, 0); i /= 10;
+            30 * SCOREX, 0); i /= 10;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            37 * SCOREX, 0); i /= 10;
+            29 * SCOREX, 0); i /= 10;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            36 * SCOREX, 0);
+            28 * SCOREX, 0);
 
   if (lev.home == 0)
   {
@@ -363,16 +400,19 @@ void game_blitscore(void)
   i = lev.required;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            24 * SCOREX, 0); i /= 10;
+            20 * SCOREX, 0);
+  i /= 10;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            23 * SCOREX, 0); i /= 10;
+            19 * SCOREX, 0);
+  i /= 10;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            22 * SCOREX, 0); i /= 10;
+            18 * SCOREX, 0);
+  i /= 10;
   BlitBitmap(botBitmap, scoreBitmap,
             (i % 10) * SCOREX, colours[1] * SCOREY, SCOREX, SCOREY,
-            21 * SCOREX, 0);
+            17 * SCOREX, 0);
 
  done:
 }
@@ -384,21 +424,22 @@ void game_animscreen(void)
   xdebug("game_animscreen");
 
   x = (frame * ply1.oldx + (8 - frame) * ply1.x) * TILEX / 8
-    + (19 * TILEX) / 2;
+    + ((SCR_FIELDX - 1) * TILEX) / 2;
   y = (frame * ply1.oldy + (8 - frame) * ply1.y) * TILEY / 8
-    + (11 * TILEY) / 2;
+    + ((SCR_FIELDY - 1) * TILEY) / 2;
 
   if (x > lev.width * TILEX)
     x = lev.width * TILEX;
   if (y > lev.height * TILEY)
     y = lev.height * TILEY;
-  if (x < 20 * TILEX)
-    x = 20 * TILEY;
-  if (y < 12 * TILEY)
-    y = 12 * TILEY;
 
-  screen_x = x - 19 * TILEX;
-  screen_y = y - 11 * TILEY;
+  if (x < SCR_FIELDX * TILEX)
+    x = SCR_FIELDX * TILEY;
+  if (y < SCR_FIELDY * TILEY)
+    y = SCR_FIELDY * TILEY;
+
+  screen_x = x - (SCR_FIELDX - 1) * TILEX;
+  screen_y = y - (SCR_FIELDY - 1) * TILEY;
 
   animscreen();
   blitplayer(&ply1);
@@ -410,6 +451,9 @@ void game_animscreen(void)
   Random = Random * 129 + 1;
 }
 
+
+/* draw main menu background and copyright note */
+
 void title_initscreen(void)
 {
   xdebug("title_initscreen");
@@ -423,36 +467,40 @@ void title_initscreen(void)
 
 #if 1
 
-  BlitBitmap(ttlBitmap, screenBitmap,
-            0, 0, 20 * TILEX, 12 * TILEY, 0, 0);
+  /* draw title screen on menu background */
+
+  BlitBitmap(ttlBitmap, screenBitmap, ORIG_MENU_SX, ORIG_MENU_SY,
+            SCR_MENUX * TILEX, SCR_MENUY * TILEY, 0, 0);
+
+  /* draw copyright note at footer */
 
   if (botmaskBitmap)
   {
-    BlitBitmap(botBitmap, scoreBitmap,
-             0, colours[1] * SCOREY, 20 * TILEX, SCOREY, 0, 0);
+    BlitBitmap(botBitmap, scoreBitmap, 0, colours[1] * SCOREY,
+              SCR_MENUX * TILEX, SCOREY, 0, 0);
 
     SetClipOrigin(botBitmap, botBitmap->stored_clip_gc,
                  0, 0 - colours[0] * SCOREY);
   }
 
-  BlitBitmapMasked(botBitmap, scoreBitmap,
-                  0, colours[0] * SCOREY, 20 * TILEX, SCOREY, 0, 0);
+  BlitBitmapMasked(botBitmap, scoreBitmap, 0, colours[0] * SCOREY,
+                  SCR_MENUX * TILEX, SCOREY, 0, 0);
 
 #else
 
   XCopyArea(display, ttlPixmap, screenPixmap, screenGC,
-           0, 0, 20 * TILEX, 12 * TILEY, 0, 0);
+           0, 0, SCR_MENUX * TILEX, SCR_MENUY * TILEY, 0, 0);
 
   if (botmaskBitmap)
   {
     XCopyArea(display, botPixmap, scorePixmap, scoreGC,
-             0, colours[1] * SCOREY, 20 * TILEX, SCOREY, 0, 0);
+             0, colours[1] * SCOREY, SCR_MENUX * TILEX, SCOREY, 0, 0);
     XSetClipMask(display, scoreGC, botmaskBitmap);
     XSetClipOrigin(display, scoreGC, 0, 0 - colours[0] * SCOREY);
   }
 
   XCopyArea(display, botPixmap, scorePixmap, scoreGC,
-           0, colours[0] * SCOREY, 20 * TILEX, SCOREY, 0, 0);
+           0, colours[0] * SCOREY, SCR_MENUX * TILEX, SCOREY, 0, 0);
 
   if (botmaskBitmap)
     XSetClipMask(display, scoreGC, None);
@@ -460,6 +508,9 @@ void title_initscreen(void)
 #endif
 }
 
+
+/* draw bouncing ball on main menu footer */
+
 void title_blitscore(void)
 {
   unsigned int x, y, i;
@@ -514,7 +565,7 @@ void title_blitants(unsigned int y)
 
   XSetDashes(display, antsGC, colour_anim, ants_dashes, 2);
   XDrawRectangle(display, screenPixmap, antsGC,
-                0, y * TILEY, 20 * TILEX - 1, TILEY - 1);
+                0, y * TILEY, SCR_MENUX * TILEX - 1, TILEY - 1);
 }
 
 void title_animscreen(void)
@@ -550,11 +601,12 @@ void title_string(unsigned int y, unsigned int left, unsigned int right,
   right *= SCOREX;
 
   x = (left + right - strlen(string) * MENUFONTX) / 2;
-  if (x < left || x >= right) x = left;
+  if (x < left || x >= right)
+    x = left;
 
   /* restore background graphic where text will be drawn */
-  BlitBitmap(ttlBitmap, screenBitmap,
-            left, y, right - left, MENUFONTY, left, y);
+  BlitBitmap(ttlBitmap, screenBitmap, ORIG_MENU_SX + left, ORIG_MENU_SY + y,
+            right - left, MENUFONTY, left, y);
 
 #if 1
 #else
@@ -576,10 +628,10 @@ void title_string(unsigned int y, unsigned int left, unsigned int right,
 
 #if 1
     SetClipOrigin(ttlBitmap, ttlBitmap->stored_clip_gc,
-                 x - ch_x, y - ch_y);
+                 x - ORIG_MENU_SX - ch_x, y - ORIG_MENU_SY - ch_y);
 
-    BlitBitmapMasked(ttlBitmap, screenBitmap,
-                    ch_x, ch_y, MENUFONTX, MENUFONTY, x, y);
+    BlitBitmapMasked(ttlBitmap, screenBitmap, ch_x, ch_y, MENUFONTX, MENUFONTY,
+                    x - ORIG_MENU_SX, y - ORIG_MENU_SY);
 #else
     if (ttlmaskBitmap)
       XSetClipOrigin(display, screenGC, x - ch_x, y - ch_y);

diff --git a/src/game_em/init.c b/src/game_em/init.c
index 64d734ccb382fce18131199b986a9764982d3838..55b9d177a70da21f656c4020188e8626fb07a6de 100644 (file)
--- a/src/game_em/init.c
+++ b/src/game_em/init.c
@@ -558,11 +558,13 @@ int open_all(void)
 #endif
 
 #if 1
-  screenBitmap = CreateBitmap(22 * TILEX, 14 * TILEY, DEFAULT_DEPTH);
+  screenBitmap = CreateBitmap(MAX_BUF_XSIZE * TILEX, MAX_BUF_YSIZE * TILEY,
+                             DEFAULT_DEPTH);
   scoreBitmap = CreateBitmap(20 * TILEX, SCOREY, DEFAULT_DEPTH);
 #endif
 
-  screenPixmap = XCreatePixmap(display, xwindow, 22 * TILEX, 14 * TILEY,
+  screenPixmap = XCreatePixmap(display, xwindow,
+                              MAX_BUF_XSIZE * TILEX, MAX_BUF_YSIZE * TILEY,
                               screenDepth);
   if (screenPixmap == 0)
   {

diff --git a/src/game_em/input.c b/src/game_em/input.c
index 385588c52cc00a0367b0ecc61fce355819b57843..207a80baf74f71c9810aa52e23aa871144d64d23 100644 (file)
--- a/src/game_em/input.c
+++ b/src/game_em/input.c
@@ -94,18 +94,18 @@ static void drawmenu(int pos)
       break;
 
     case 5:
-      title_string(10, 1, 13, "played");
+      title_string(10, 3, 13, "played");
       title_string(10, 14, 26, "score");
-      title_string(10, 27, 39, "won");
+      title_string(10, 27, 37, "won");
       break;
 
     case 6:
       sprintf(buffer, "%d", 0);
-      title_string(11, 1, 13, buffer);
+      title_string(11, 3, 13, buffer);
       sprintf(buffer, "%d", 0);
       title_string(11, 14, 26, buffer);
       sprintf(buffer, "%d", 0);
-      title_string(11, 27, 39, buffer);
+      title_string(11, 27, 37, buffer);
       break;
   }
 }
@@ -320,8 +320,9 @@ int game_loop(byte action)
     {
       /* start playing */
 
-      if (game_play_init(player_level) == 0)
-       em_game_status = EM_GAME_STATUS_PLAY;
+      em_game_status = EM_GAME_STATUS_PLAY;
+      if (game_play_init(player_level) != 0)
+       em_game_status = EM_GAME_STATUS_MENU;
     }
   }
   else if (em_game_status == EM_GAME_STATUS_PLAY)
@@ -330,8 +331,8 @@ int game_loop(byte action)
     {
       /* stop playing */
 
-      game_menu_init();
       em_game_status = EM_GAME_STATUS_MENU;
+      game_menu_init();
     }
   }
 

diff --git a/src/game_em/main.c b/src/game_em/main.c
index 6f50f84aa442ab2be2d1b421207aa88e471b8af3..a9701d6955711887254b0489b03a69a7b1ce94eb 100644 (file)
--- a/src/game_em/main.c
+++ b/src/game_em/main.c
@@ -53,8 +53,8 @@ void em_close_all()
 
 void em_main_init_game()
 {
-  game_menu_init();
   em_game_status = EM_GAME_STATUS_MENU;
+  game_menu_init();
 }
 
 int em_main_handle_game(byte action)