Index: apps/plugins/brickmania.c
===================================================================
--- apps/plugins/brickmania.c	(revision 22178)
+++ apps/plugins/brickmania.c	(working copy)
@@ -222,25 +222,25 @@
 #define SCROLL_BACK(x) (0)
 #endif
 
-#include "pluginbitmaps/brickmania_pads.h"
-#include "pluginbitmaps/brickmania_short_pads.h"
-#include "pluginbitmaps/brickmania_long_pads.h"
+#include "pluginbitmaps/brickmania_left_pads.h"
+#include "pluginbitmaps/brickmania_right_pads.h"
+#include "pluginbitmaps/brickmania_middle_pads.h"
 #include "pluginbitmaps/brickmania_bricks.h"
 #include "pluginbitmaps/brickmania_powerups.h"
 #include "pluginbitmaps/brickmania_ball.h"
 #include "pluginbitmaps/brickmania_gameover.h"
 
-#define PAD_WIDTH        BMPWIDTH_brickmania_pads
-#define PAD_HEIGHT       (BMPHEIGHT_brickmania_pads/3)
-#define SHORT_PAD_WIDTH  BMPWIDTH_brickmania_short_pads
-#define LONG_PAD_WIDTH   BMPWIDTH_brickmania_long_pads
+#define PAD_EDGE         BMPWIDTH_brickmania_left_pads
+#define PAD_UNIT         BMPWIDTH_brickmania_middle_pads
+#define PAD_HEIGHT       (BMPHEIGHT_brickmania_middle_pads/3)
 #define BRICK_HEIGHT     (BMPHEIGHT_brickmania_bricks/7)
 #define BRICK_WIDTH      BMPWIDTH_brickmania_bricks
 #define LEFTMARGIN       ((LCD_WIDTH-10*BRICK_WIDTH)/2)
-#define POWERUP_HEIGHT   (BMPHEIGHT_brickmania_powerups/9)
+#define POWERUP_NUM      9
+#define POWERUP_HEIGHT   (BMPHEIGHT_brickmania_powerups/POWERUP_NUM)
 #define POWERUP_WIDTH    BMPWIDTH_brickmania_powerups
 #define BALL             BMPHEIGHT_brickmania_ball
-#define HALFBALL         ((BALL+1)/2)
+#define HALFBALL         (BALL/2)
 #define GAMEOVER_WIDTH   BMPWIDTH_brickmania_gameover
 #define GAMEOVER_HEIGHT  BMPHEIGHT_brickmania_gameover
 
@@ -272,7 +272,7 @@
 #define PAD_POS_Y           (GAMESCREEN_HEIGHT - PAD_HEIGHT - 1)
 
 
-int levels_num = 29;
+#define LEVELS_NUM 29
 
 static unsigned char levels[29][8][10] = {
     { /* level1 */
@@ -568,6 +568,11 @@
 };
 
 #define MAX_BALLS 10
+#define MAX_FIRES 30
+#define MAX_POWERUPS 10
+#define DEF_UNITS 3
+#define MIN_UNITS 1
+#define MAX_UNITS 5
 
 enum difficulty_options {
     EASY, NORMAL
@@ -576,27 +581,25 @@
 int pad_pos_x;
 int life;
 enum { ST_READY, ST_START, ST_PAUSE } game_state = ST_READY;
-int pad_type;
+int pad_type=0;
 int score=0,vscore=0;
 bool flip_sides=false;
 int level=0;
 int brick_on_board=0;
 int used_balls=1;
 int difficulty = NORMAL;
-int pad_width;
+int pad_units=DEF_UNITS;
+int pad_width=2*PAD_EDGE+DEF_UNITS*PAD_UNIT;
 int num_count;
 bool resume = false;
 
 typedef struct cube {
-    int powertop;
-    int power;
-    char poweruse;
     char used;
     int color;
     int hits;
     int hiteffect;
 } cube;
-cube brick[80];
+cube brick[8][10];
 
 typedef struct balls {
     int pos_x;
@@ -614,8 +617,16 @@
     int top;
     int left;
 } sfire;
-sfire fire[30];
+sfire fire[MAX_FIRES];
 
+typedef struct power {
+    int type;
+    int top;
+    int left;
+} power;
+
+power powerup[MAX_POWERUPS];
+
 #define CONFIG_FILE_NAME "brickmania.cfg"
 #define SAVE_FILE  PLUGIN_GAMES_DIR "/brickmania.save"
 #define HIGH_SCORE PLUGIN_GAMES_DIR "/brickmania.score"
@@ -630,9 +641,10 @@
 static void brickmania_init_game(int new_game)
 {
     int i,j;
+    pad_units=DEF_UNITS;
+    pad_width=2*PAD_EDGE+DEF_UNITS*PAD_UNIT;
+    pad_pos_x=LCD_WIDTH/2-pad_width/2;
 
-    pad_pos_x=LCD_WIDTH/2-PAD_WIDTH/2;
-
     for(i=0;i<MAX_BALLS;i++) {
         ball[i].x=0;
         ball[i].y=0;
@@ -646,7 +658,6 @@
     used_balls=1;
     game_state=ST_READY;
     pad_type=0;
-    pad_width=PAD_WIDTH;
     flip_sides=false;
     num_count=10;
 
@@ -658,22 +669,21 @@
             life++;
         }
     }
-    for(i=0;i<30;i++) {
+
+    for (i=0;i<MAX_FIRES;i++)
         fire[i].top=-8;
-    }
+
+    for (i=0;i<MAX_POWERUPS;i++)
+        powerup[i].type=POWERUP_NUM;
+
     for(i=0;i<=7;i++) {
         for(j=0;j<=9;j++) {
-            brick[i*10+j].poweruse=(levels[level][i][j]==0?0:1);
             if (new_game==1) {
-                brick[i*10+j].power=rb->rand()%25;
-                /* +8 make the game with less powerups */
-
-                brick[i*10+j].hits=levels[level][i][j]>=10?
+                brick[i][j].hits=levels[level][i][j]>=10?
                     levels[level][i][j]/16-1:0;
-                brick[i*10+j].hiteffect=0;
-                brick[i*10+j].powertop=TOPMARGIN+i*BRICK_HEIGHT+BRICK_HEIGHT;
-                brick[i*10+j].used=(levels[level][i][j]==0?0:1);
-                brick[i*10+j].color=(levels[level][i][j]>=10?
+                brick[i][j].hiteffect=0;
+                brick[i][j].used=(levels[level][i][j]==0?0:1);
+                brick[i][j].color=(levels[level][i][j]>=10?
                                      levels[level][i][j]%16:
                                      levels[level][i][j])-1;
                 if (levels[level][i][j]!=0)
@@ -709,6 +719,8 @@
         if(rb->read(fd, &brick, sizeof(brick)) <= 0) break;
         if(rb->read(fd, &ball, sizeof(ball)) <= 0) break;
         if(rb->read(fd, &fire, sizeof(fire)) <= 0) break;
+        if(rb->read(fd, &pad_units, sizeof(pad_units)) <= 0) break;
+        pad_width=2*PAD_EDGE+pad_units*PAD_UNIT;
         vscore = score;
         resume = true;
         break;
@@ -741,6 +753,7 @@
     rb->write(fd, &brick, sizeof(brick));
     rb->write(fd, &ball, sizeof(ball));
     rb->write(fd, &fire, sizeof(fire));
+    rb->write(fd, &pad_units, sizeof(pad_units));
     rb->close(fd);
 }
 
@@ -761,7 +774,7 @@
         } else {
             if (vscore<score)
                 vscore++;
-            if (vscore>score)
+            else
                 vscore--;
             rb->snprintf(s, sizeof(s), "%d", vscore);
             rb->lcd_getstringsize(s, &sw, &w);
@@ -823,8 +836,8 @@
         "G", "Glue:", "ball", "sticks", "to", "paddle", "",
         "B", "Ball:", "generates", "another", "ball", "",
         "FL", "Flip:", "flips", "left / right", "movement", "",
-        "<->", "or", "<E>:", "enlarges", "the", "paddle", "",
-        ">-<", "or", ">S<:", "shrinks", "the", "paddle", "",
+        "<->", "or", "<E>", ":", "enlarges", "the", "paddle", "",
+        ">-<", "or", ">S<", ":", "shrinks", "the", "paddle", "",
     };
     static struct style_text formation[]={
         { 0, TEXT_CENTER|TEXT_UNDERLINE },
@@ -838,6 +851,10 @@
         { 67, C_GREEN },
         { 74, C_YELLOW },
         { 80, C_RED },
+        { 86, C_GREEN },
+        { 88, C_GREEN },
+        { 94, C_BLUE },
+        { 96, C_BLUE },
         { -1, 0 }
     };
     int button;
@@ -929,50 +946,57 @@
     }
 }
 
-static int brickmania_pad_check(int ballxc, int mode, int pon ,int ballnum)
-{
-    /* pon: positive(1) or negative(0) */
-
-    if (mode==0) {
-        if (pon == 0)
-            return -ballxc;
-        else
-            return ballxc;
-    } else {
-        if (ball[ballnum].x > 0)
-            return ballxc;
-        else
-           return ballxc*-1;
-    }
-}
-
 static int brickmania_fire_space(void)
 {
     int t;
-    for(t=0;t<30;t++)
+    for(t=0;t<MAX_FIRES;t++)
         if (fire[t].top+7 < 0)
             return t;
 
-    return 0;
+    return MAX_FIRES;
 }
 
+static void brickmania_brick_hit(int i,int j)
+{
+    if (brick[i][j].hits > 0) {
+        brick[i][j].hits--;
+        brick[i][j].hiteffect++;
+        score+=2;
+    }
+    else {
+        int t,k;
+        t=rb->rand()%25;
+        if (t<POWERUP_NUM) {
+            k=0;
+            while (k!=MAX_POWERUPS && powerup[k].type!=POWERUP_NUM)
+                k++;
+            if (k!=MAX_POWERUPS) {
+                powerup[k].type=t;
+                powerup[k].top=TOPMARGIN+i*BRICK_HEIGHT+BRICK_HEIGHT;
+                powerup[k].left=LEFTMARGIN+j*BRICK_WIDTH+(BRICK_WIDTH-POWERUP_WIDTH)/2;
+            }
+        }
+        brick[i][j].used=0;
+        brick_on_board--;
+        score+=8;
+    }
+}
+
 static int brickmania_game_loop(void)
 {
-    int j,i,k,bricky,brickx;
+    int j,i,k;
     int sw;
     char s[30];
     int sec_count=0;
     int end;
 
-    if (brickmania_menu()!=0) {
+    if (brickmania_menu()!=0)
         return 1;
-    }
     resume = false;
-
+    end = *rb->current_tick;
     while(true) {
         /* Convert CYCLETIME (in ms) to HZ */
-        end = *rb->current_tick + (CYCLETIME * HZ) / 1000;
-
+        end+=(CYCLETIME * HZ) / 1000;
         if (life >= 0) {
 #ifdef HAVE_LCD_COLOR
             rb->lcd_set_background(LCD_BLACK);
@@ -991,7 +1015,7 @@
 
             if (flip_sides) {
                 if (*rb->current_tick>=sec_count) {
-                    sec_count=*rb->current_tick+HZ;
+                    sec_count+=HZ;
                     if (num_count!=0)
                         num_count--;
                     else
@@ -1022,11 +1046,7 @@
             if (vscore<score) vscore++;
             rb->snprintf(s, sizeof(s), "%d", vscore);
             rb->lcd_getstringsize(s, &sw, NULL);
-#if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
             rb->lcd_putsxy(LCD_WIDTH/2-sw/2, 0, s);
-#else
-            rb->lcd_putsxy(LCD_WIDTH/2-sw/2, 0, s);
-#endif
 
             /* continue game */
             if (game_state==ST_PAUSE) {
@@ -1053,39 +1073,35 @@
             if (brick_on_board==0)
                 brick_on_board--;
 
-            /* if the pad is fire */
-            for(i=0;i<30;i++) {
-                if (fire[i].top+7>0) {
+            /* check fires */
+            for(k=0;k<MAX_FIRES;k++) {
+                if (fire[k].top+7>0) {
                     if (game_state!=ST_PAUSE)
-                        fire[i].top-=4;
-                    rb->lcd_vline(fire[i].left, fire[i].top, fire[i].top+7);
+                        fire[k].top-=4;
+                    i=(fire[k].top-TOPMARGIN)/BRICK_HEIGHT;
+                    j=(fire[k].left-LEFTMARGIN)/BRICK_WIDTH;
+                    if (fire[k].top>=TOPMARGIN && fire[k].top<TOPMARGIN+BRICK_HEIGHT*8 &&
+                        fire[k].left>=LEFTMARGIN && fire[k].left<LEFTMARGIN+BRICK_WIDTH*10 &&
+                        brick[i][j].used==1) {
+                        score+=8;
+                        fire[k].top=-16;
+                        brickmania_brick_hit(i,j);
+                    }
+                    else
+                        rb->lcd_vline(fire[k].left, fire[k].top, fire[k].top+7);
                 }
             }
 
-            /* the bricks */
-            for (i=0;i<=7;i++) {
-                for (j=0;j<=9;j++) {
-                    if (brick[i*10+j].power<9) {
-                        if (brick[i*10+j].poweruse==2) {
-                            if (game_state!=ST_PAUSE)
-                                brick[i*10+j].powertop+=2;
-                            rb->lcd_bitmap_part(brickmania_powerups,0,
-                                                POWERUP_HEIGHT*brick[i*10+j
-                                                    ].power,
-                                                POWERUP_WIDTH,
-                                                LEFTMARGIN+j*BRICK_WIDTH+
-                                                (BRICK_WIDTH/2-POWERUP_WIDTH/2),
-                                                brick[i*10+j].powertop,
-                                                POWERUP_WIDTH,
-                                                POWERUP_HEIGHT);
-                        }
-                    }
-
-                    if ((pad_pos_x<LEFTMARGIN+j*BRICK_WIDTH+5 &&
-                         pad_pos_x+pad_width>LEFTMARGIN+j*BRICK_WIDTH+5) &&
-                        brick[i*10+j].powertop+6>=PAD_POS_Y &&
-                        brick[i*10+j].poweruse==2) {
-                        switch(brick[i*10+j].power) {
+            /* the powerups */
+            for(i=0;i<MAX_POWERUPS;i++) {
+                if (powerup[i].type<POWERUP_NUM) {
+                    if (game_state!=ST_PAUSE)
+                        powerup[i].top+=2;
+                    rb->lcd_bitmap_part(brickmania_powerups,0,POWERUP_HEIGHT*powerup[i].type,POWERUP_WIDTH,
+                    powerup[i].left,powerup[i].top,POWERUP_WIDTH,POWERUP_HEIGHT);
+                    if ((pad_pos_x<powerup[i].left+POWERUP_WIDTH && pad_pos_x+pad_width>powerup[i].left) &&
+                        powerup[i].top+POWERUP_HEIGHT>=PAD_POS_Y) {
+                        switch(powerup[i].type) {
                             case 0:
                                 life++;
                                 score+=50;
@@ -1095,6 +1111,7 @@
                                 if (life>=0) {
                                     brickmania_init_game(0);
                                     brickmania_sleep(2);
+                                    end = *rb->current_tick;
                                 }
                                 break;
                             case 2:
@@ -1110,11 +1127,22 @@
                             case 4:
                                 score+=23;
                                 pad_type=0;
+                                flip_sides=false;
+                                pad_pos_x+=PAD_UNIT*(pad_units-DEF_UNITS)/2;
+                                pad_units=DEF_UNITS;
+                                pad_width=2*PAD_EDGE+DEF_UNITS*PAD_UNIT;
+                                if (pad_pos_x < 0)
+                                    pad_pos_x = 0;
+                                else if(pad_pos_x+pad_width > LCD_WIDTH)
+                                    pad_pos_x = LCD_WIDTH-pad_width;
+                                    for (k=0;k<used_balls;k++) if (ball[k].glue) {
+                                        if (ball[k].pos_x+BALL<=pad_pos_x)
+                                            ball[k].pos_x=pad_pos_x-BALL+1;
+                                        else if (ball[k].pos_x>=pad_pos_x+pad_width)
+                                            ball[k].pos_x=pad_pos_x+pad_width-1;
+                                    }
                                 for(k=0;k<used_balls;k++)
                                     ball[k].glue=false;
-                                flip_sides=false;
-                                pad_pos_x+=(pad_width-PAD_WIDTH)/2;
-                                pad_width=PAD_WIDTH;
                                 break;
                             case 5:
                                 score+=23;
@@ -1124,251 +1152,99 @@
                                 break;
                             case 6:
                                 score+=23;
-                                if(used_balls<MAX_BALLS) {
-                                    ball[used_balls].x= rb->rand()%2 == 0 ?
-                                        -1 : 1;
-                                    ball[used_balls].y= -4;
-                                    ball[used_balls].glue= false;
+                                if (used_balls<MAX_BALLS) {
+                                    ball[used_balls].x=rb->rand()%2==0?-1:1;
+                                    ball[used_balls].y=-4;
+                                    ball[used_balls].tempy=0;
+                                    ball[used_balls].tempx=0;
+                                    ball[used_balls].pos_y=PAD_POS_Y-BALL;
+                                    ball[used_balls].pos_x=pad_pos_x+(pad_width/2)-2;
+                                    ball[used_balls].glue=false;
                                     used_balls++;
                                 }
                                 break;
                             case 7:
                                 score+=23;
-                                if (pad_width==PAD_WIDTH) {
-                                    pad_width=LONG_PAD_WIDTH;
-                                    pad_pos_x-=(LONG_PAD_WIDTH-PAD_WIDTH)/2;
+                                if (pad_units<MAX_UNITS) {
+                                    pad_units++;
+                                    pad_width+=PAD_UNIT;
+                                    pad_pos_x-=PAD_UNIT/2;
                                 }
-                                else if (pad_width==SHORT_PAD_WIDTH) {
-                                    pad_width=PAD_WIDTH;
-                                    pad_pos_x-=(PAD_WIDTH-SHORT_PAD_WIDTH)/2;
-                                }
                                 if (pad_pos_x < 0)
                                     pad_pos_x = 0;
                                 else if(pad_pos_x+pad_width > LCD_WIDTH)
                                     pad_pos_x = LCD_WIDTH-pad_width;
                                 break;
                             case 8:
-                                if (pad_width==PAD_WIDTH) {
-                                    pad_width=SHORT_PAD_WIDTH;
-                                    pad_pos_x+=(PAD_WIDTH-SHORT_PAD_WIDTH)/2;
+                                if (pad_units>MIN_UNITS) {
+                                    pad_units--;
+                                    pad_width-=PAD_UNIT;
+                                    pad_pos_x+=PAD_UNIT/2;
+                                    for (k=0;k<used_balls;k++) if (ball[k].glue) {
+                                        if (ball[k].pos_x+BALL<=pad_pos_x)
+                                            ball[k].pos_x=pad_pos_x-BALL+1;
+                                        else if (ball[k].pos_x>=pad_pos_x+pad_width)
+                                            ball[k].pos_x=pad_pos_x+pad_width-1;
+                                    }
                                 }
-                                else if (pad_width==LONG_PAD_WIDTH) {
-                                    pad_width=PAD_WIDTH;
-                                    pad_pos_x+=(LONG_PAD_WIDTH-PAD_WIDTH)/2;
-                                }
                                 break;
                         }
-                        brick[i*10+j].poweruse=1;
+                        powerup[i].type=POWERUP_NUM;
                     }
 
-                    if (brick[i*10+j].powertop>PAD_POS_Y)
-                        brick[i*10+j].poweruse=1;
+                    if (powerup[i].top>PAD_POS_Y)
+                        powerup[i].type=POWERUP_NUM;
+                }
+            }
 
-                    brickx=LEFTMARGIN+j*BRICK_WIDTH;
-                    bricky=TOPMARGIN+i*BRICK_HEIGHT;
-                    if (pad_type==2) {
-                        for (k=0;k<30;k++) {
-                            if (fire[k].top+7>0) {
-                                if (brick[i*10+j].used==1 &&
-                                    (fire[k].left+1 >= brickx &&
-                                     fire[k].left+1 <= brickx+BRICK_WIDTH) &&
-                                    (bricky+BRICK_HEIGHT>fire[k].top)) {
-                                    score+=13;
-                                    fire[k].top=-16;
-                                    if (brick[i*10+j].hits > 0) {
-                                        brick[i*10+j].hits--;
-                                        brick[i*10+j].hiteffect++;
-                                        score+=3;
-                                    }
-                                    else {
-                                        brick[i*10+j].used=0;
-                                        if (brick[i*10+j].power!=10)
-                                            brick[i*10+j].poweruse=2;
-                                        brick_on_board--;
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    if (brick[i*10+j].used==1) {
+            /* the bricks */
+            for (i=0;i<=7;i++) {
+                for (j=0;j<=9;j++) {
+                    if (brick[i][j].used==1) {
                         rb->lcd_bitmap_part(brickmania_bricks,0,
-                                            BRICK_HEIGHT*brick[i*10+j].color,
+                                            BRICK_HEIGHT*brick[i][j].color,
                                             BRICK_WIDTH,
                                             LEFTMARGIN+j*BRICK_WIDTH,
                                             TOPMARGIN+i*BRICK_HEIGHT,
                                             BRICK_WIDTH, BRICK_HEIGHT);
 #ifdef HAVE_LCD_COLOR  /* No transparent effect for greyscale lcds for now */
-                        if (brick[i*10+j].hiteffect>0)
+                        if (brick[i][j].hiteffect>0)
                             rb->lcd_bitmap_transparent_part(brickmania_break,0,
-                                                            BRICK_HEIGHT*brick[i*10+j].hiteffect,
+                                                            BRICK_HEIGHT*brick[i][j].hiteffect,
                                                             BRICK_WIDTH,
                                                             LEFTMARGIN+j*BRICK_WIDTH,
                                                             TOPMARGIN+i*BRICK_HEIGHT,
                                                             BRICK_WIDTH, BRICK_HEIGHT);
 #endif
                     }
-                    /* Somewhere in here collision checking is done b/w ball and
-                     *  brick.
-                     */
-                    for(k=0;k<used_balls;k++) {
-                        if (ball[k].pos_y < PAD_POS_Y) {
-                            if (brick[i*10+j].used==1) {
-                                if ((ball[k].pos_x+ball[k].x+HALFBALL >=
-                                     brickx &&
-                                     ball[k].pos_x+ball[k].x+HALFBALL <=
-                                     brickx+BRICK_WIDTH) &&
-                                    ((bricky-4<ball[k].pos_y+BALL &&
-                                      bricky>ball[k].pos_y+BALL) ||
-                                     (bricky+4>ball[k].pos_y+BALL+BALL &&
-                                      bricky<ball[k].pos_y+BALL+BALL)) &&
-                                    (ball[k].y >0)) {
-                                    ball[k].tempy=bricky-ball[k].pos_y-BALL;
-                                }
-                                else if ((ball[k].pos_x+ball[k].x+HALFBALL >=
-                                          brickx &&
-                                          ball[k].pos_x+ball[k].x+HALFBALL <=
-                                          brickx+BRICK_WIDTH) &&
-                                         ((bricky+BRICK_HEIGHT+4>ball[k].pos_y &&
-                                           bricky+BRICK_HEIGHT<ball[k].pos_y) ||
-                                          (bricky+BRICK_HEIGHT-4<ball[k].pos_y-BALL &&
-                                           bricky+BRICK_HEIGHT>ball[k].pos_y-BALL)) &&
-                                         (ball[k].y <0)) {
-                                    ball[k].tempy=
-                                        -(ball[k].pos_y-(bricky+BRICK_HEIGHT));
-                                }
-
-                                if ((ball[k].pos_y+HALFBALL >=
-                                     bricky &&
-                                     ball[k].pos_y+HALFBALL <=
-                                     bricky+BRICK_HEIGHT) &&
-                                    ((brickx-4<ball[k].pos_x+BALL &&
-                                      brickx>ball[k].pos_x+BALL) ||
-                                     (brickx+4>ball[k].pos_x+BALL+BALL &&
-                                      brickx<ball[k].pos_x+BALL+BALL)) &&
-                                    (ball[k].x >0)) {
-                                    ball[k].tempx=brickx-ball[k].pos_x-BALL;
-                                }
-                                else if ((ball[k].pos_y+ball[k].y+HALFBALL >=
-                                          bricky &&
-                                          ball[k].pos_y+ball[k].y+HALFBALL <=
-                                          bricky+BRICK_HEIGHT) &&
-                                         ((brickx+BRICK_WIDTH+4>ball[k].pos_x &&
-                                           brickx+BRICK_WIDTH<ball[k].pos_x) ||
-                                          (brickx+BRICK_WIDTH-4<ball[k].pos_x-
-                                           BALL &&
-                                           brickx+BRICK_WIDTH>ball[k].pos_x-
-                                           BALL)) && (ball[k].x <0)) {
-                                    ball[k].tempx=
-                                        -(ball[k].pos_x-(brickx+BRICK_WIDTH));
-                                }
-
-                                if ((ball[k].pos_x+HALFBALL >= brickx &&
-                                     ball[k].pos_x+HALFBALL <=
-                                     brickx+BRICK_WIDTH) &&
-                                    ((bricky+BRICK_HEIGHT==ball[k].pos_y) ||
-                                     (bricky+BRICK_HEIGHT-6<=ball[k].pos_y &&
-                                      bricky+BRICK_HEIGHT>ball[k].pos_y)) &&
-                                    (ball[k].y <0)) { /* bottom line */
-                                    if (brick[i*10+j].hits > 0) {
-                                        brick[i*10+j].hits--;
-                                        brick[i*10+j].hiteffect++;
-                                        score+=2;
-                                    }
-                                    else {
-                                        brick[i*10+j].used=0;
-                                        if (brick[i*10+j].power!=10)
-                                            brick[i*10+j].poweruse=2;
-                                    }
-
-                                    ball[k].y = ball[k].y*-1;
-                                }
-                                else if ((ball[k].pos_x+HALFBALL >= brickx &&
-                                          ball[k].pos_x+HALFBALL <=
-                                          brickx+BRICK_WIDTH) &&
-                                         ((bricky==ball[k].pos_y+BALL) ||
-                                          (bricky+6>=ball[k].pos_y+BALL &&
-                                           bricky<ball[k].pos_y+BALL)) &&
-                                         (ball[k].y >0)) { /* top line */
-                                    if (brick[i*10+j].hits > 0) {
-                                        brick[i*10+j].hits--;
-                                        brick[i*10+j].hiteffect++;
-                                        score+=2;
-                                    }
-                                    else {
-                                        brick[i*10+j].used=0;
-                                        if (brick[i*10+j].power!=10)
-                                            brick[i*10+j].poweruse=2;
-                                    }
-
-                                    ball[k].y = ball[k].y*-1;
-                                }
-
-                                if ((ball[k].pos_y+HALFBALL >= bricky &&
-                                     ball[k].pos_y+HALFBALL <=
-                                     bricky+BRICK_HEIGHT) &&
-                                    ((brickx==ball[k].pos_x+BALL) ||
-                                     (brickx+6>=ball[k].pos_x+BALL &&
-                                      brickx<ball[k].pos_x+BALL)) &&
-                                    (ball[k].x > 0)) { /* left line */
-                                    if (brick[i*10+j].hits > 0) {
-                                        brick[i*10+j].hits--;
-                                        brick[i*10+j].hiteffect++;
-                                        score+=2;
-                                    }
-                                    else {
-                                        brick[i*10+j].used=0;
-                                        if (brick[i*10+j].power!=10)
-                                            brick[i*10+j].poweruse=2;
-                                    }
-                                    ball[k].x = ball[k].x*-1;
-
-                                }
-                                else if ((ball[k].pos_y+HALFBALL >= bricky &&
-                                          ball[k].pos_y+HALFBALL <=
-                                          bricky+BRICK_HEIGHT) &&
-                                         ((brickx+BRICK_WIDTH==
-                                           ball[k].pos_x) ||
-                                          (brickx+BRICK_WIDTH-6<=
-                                           ball[k].pos_x &&
-                                           brickx+BRICK_WIDTH>
-                                           ball[k].pos_x)) &&
-                                         (ball[k].x < 0)) { /* Right line */
-                                    if (brick[i*10+j].hits > 0) {
-                                        brick[i*10+j].hits--;
-                                        brick[i*10+j].hiteffect++;
-                                        score+=2;
-                                    }
-                                    else {
-                                        brick[i*10+j].used=0;
-                                        if (brick[i*10+j].power!=10)
-                                            brick[i*10+j].poweruse=2;
-                                    }
-
-                                    ball[k].x = ball[k].x*-1;
-                                }
-
-                                if (brick[i*10+j].used==0) {
-                                    brick_on_board--;
-                                    score+=8;
-                                }
-                            }
-                        }
-                    } /* for k */
                 } /* for j */
             } /* for i */
 
             /* draw the pad */
-            rb->lcd_bitmap_part(pad_width==PAD_WIDTH?brickmania_pads:
-                                pad_width==LONG_PAD_WIDTH?brickmania_long_pads:
-                                                          brickmania_short_pads,
-                                0,pad_type*PAD_HEIGHT,pad_width,
-                                pad_pos_x, PAD_POS_Y, pad_width, PAD_HEIGHT);
+            rb->lcd_bitmap_part(brickmania_left_pads,0,pad_type*PAD_HEIGHT,PAD_EDGE,pad_pos_x,PAD_POS_Y,PAD_EDGE,PAD_HEIGHT);
+            for (k=0;k<pad_units;k++)
+                rb->lcd_bitmap_part(brickmania_middle_pads,0,pad_type*PAD_HEIGHT,PAD_UNIT,pad_pos_x+PAD_EDGE+k*PAD_UNIT,PAD_POS_Y,PAD_UNIT,PAD_HEIGHT);
+            rb->lcd_bitmap_part(brickmania_right_pads,0,pad_type*PAD_HEIGHT,PAD_EDGE,pad_pos_x+PAD_EDGE+pad_units*PAD_UNIT,PAD_POS_Y,PAD_EDGE,PAD_HEIGHT);
 
+            /* the balls */
             if (game_state!=ST_PAUSE) {
                 for(k=0;k<used_balls;k++) {
+                    i=(ball[k].pos_y+ball[k].y-TOPMARGIN+BRICK_HEIGHT+(ball[k].y>0?BALL-1:0))/BRICK_HEIGHT-1;
+                    j=(ball[k].pos_x+HALFBALL-LEFTMARGIN+BRICK_WIDTH)/BRICK_WIDTH-1;
+                    if (i>=0 && i<=7 && j>=0 && j<=9 && brick[i][j].used==1) {
+                            ball[k].tempy = TOPMARGIN+BRICK_HEIGHT*i+(ball[k].y>0?-BALL:BRICK_HEIGHT)-ball[k].pos_y;
+                            brickmania_brick_hit(i,j);
+                            ball[k].y *= -1;
+                    }
+                    i=(ball[k].pos_y+HALFBALL-TOPMARGIN+BRICK_HEIGHT)/BRICK_HEIGHT-1;
+                    j=(ball[k].pos_x+ball[k].x-LEFTMARGIN+BRICK_WIDTH+(ball[k].x>0?BALL-1:0))/BRICK_WIDTH-1;
+                    if (i>=0 && i<=7 && j>=0 && j<=9 && brick[i][j].used==1) {
+                            ball[k].tempx = LEFTMARGIN+BRICK_WIDTH*j+(ball[k].x>0?-BALL:BRICK_WIDTH)-ball[k].pos_x;
+                            brickmania_brick_hit(i,j);
+                            ball[k].x *= -1;
+                    }
 
-                    if ((ball[k].pos_x >= pad_pos_x &&
+                    if ((ball[k].pos_x + BALL > pad_pos_x &&
                          ball[k].pos_x <= pad_pos_x+pad_width) &&
                         (PAD_POS_Y-4<ball[k].pos_y+BALL &&
                          PAD_POS_Y>ball[k].pos_y+BALL) && (ball[k].y >0))
@@ -1382,10 +1258,11 @@
                     else if ((4>ball[k].pos_x && 0<ball[k].pos_x) &&
                              (ball[k].x <0))
                         ball[k].tempx=-ball[k].pos_x;
-
                     /* top line */
-                    if (ball[k].pos_y<= 0)
-                        ball[k].y = ball[k].y*-1;
+                    if (ball[k].pos_y<= 0) {
+                        ball[k].y *= -1;
+                        ball[k].pos_y = 0;
+                    }
                     /* bottom line */
                     else if (ball[k].pos_y+BALL >= GAMESCREEN_HEIGHT) {
                         if (used_balls>1) {
@@ -1397,14 +1274,6 @@
                             ball[k].x = ball[used_balls].x;
                             ball[k].tempx = ball[used_balls].tempx;
                             ball[k].glue = ball[used_balls].glue;
-
-                            ball[used_balls].x=0;
-                            ball[used_balls].y=0;
-                            ball[used_balls].tempy=0;
-                            ball[used_balls].tempx=0;
-                            ball[used_balls].pos_y=PAD_POS_Y-BALL;
-                            ball[used_balls].pos_x=pad_pos_x+(pad_width/2)-2;
-
                             k--;
                             continue;
                         } else {
@@ -1412,6 +1281,7 @@
                             if (life>=0) {
                                 brickmania_init_game(0);
                                 brickmania_sleep(2);
+                                end = *rb->current_tick;
                             }
                         }
                     }
@@ -1424,78 +1294,54 @@
                     }
 
                     if ((ball[k].pos_y+BALL >= PAD_POS_Y &&
-                         (ball[k].pos_x >= pad_pos_x &&
-                          ball[k].pos_x <= pad_pos_x+pad_width)) &&
+                         (ball[k].pos_x+BALL > pad_pos_x &&
+                          ball[k].pos_x < pad_pos_x+pad_width)) &&
                         game_state!=ST_READY && !ball[k].glue) {
-
-                        if ((ball[k].pos_x+HALFBALL >= pad_pos_x &&
-                             ball[k].pos_x+HALFBALL <=
-                             pad_pos_x+(pad_width/2/4)) ||
-                            (ball[k].pos_x +HALFBALL>=
-                             pad_pos_x+(pad_width-(pad_width/2/4)) &&
-                             ball[k].pos_x+HALFBALL <= pad_pos_x+pad_width)) {
-
-                            ball[k].y = -2;
-                            if (ball[k].pos_x != 0 &&
-                                ball[k].pos_x+BALL!=LCD_WIDTH)
-                                ball[k].x = brickmania_pad_check(6,0,
-                                                    ball[k].pos_x+2<=pad_pos_x+
-                                                    (pad_width/2)?0:1,k);
-
+                        switch (((ball[k].pos_x+HALFBALL-(pad_pos_x+PAD_EDGE))*7+3+(pad_units*PAD_UNIT))/
+                            (pad_units*PAD_UNIT)) {
+                            case 1:
+                                ball[k].y=-3;
+                                i=-4;
+                                break;
+                            case 2:
+                                ball[k].y=-4;
+                                i=-3;
+                                break;
+                            case 3:
+                                ball[k].y=-4;
+                                i=ball[k].x>0?2:-2;
+                                break;
+                            case 4:
+                                ball[k].y=-4;
+                                i=ball[k].x;
+                                break;
+                            case 5:
+                                ball[k].y=-4;
+                                i=ball[k].x>0?2:-2;
+                                break;
+                            case 6:
+                                ball[k].y=-4;
+                                i=3;
+                                break;
+                            case 7:
+                                ball[k].y=-3;
+                                i=4;
+                                break;
+                            default:
+                                /* left edge */
+                                if (ball[k].pos_x+HALFBALL < pad_pos_x+PAD_EDGE) {
+                                    ball[k].y=-2;
+                                    i=-6;
+                                }
+                                /* right edge */
+                                else {
+                                    ball[k].y=-2;
+                                    i=6;
+                                }
                         }
-                        else if ((ball[k].pos_x+HALFBALL >=
-                                  pad_pos_x+(pad_width/2/4) &&
-                                  ball[k].pos_x+HALFBALL <=
-                                  pad_pos_x+2*(pad_width/2/4)) ||
-                                 (ball[k].pos_x+HALFBALL >=
-                                  pad_pos_x+(pad_width-2*(pad_width/2/4)) &&
-                                  ball[k].pos_x+HALFBALL <=
-                                  pad_pos_x+(pad_width-(pad_width/2/4)) )) {
-
-                            ball[k].y = -3;
-                            if (ball[k].pos_x != 0 &&
-                                ball[k].pos_x+BALL!=LCD_WIDTH)
-                                ball[k].x = brickmania_pad_check(4,0,
-                                                    ball[k].pos_x+2<=pad_pos_x+
-                                                    (pad_width/2)?0:1,k);
-
-                        }
-                        else if ((ball[k].pos_x+HALFBALL >=
-                                  pad_pos_x+2*(pad_width/2/4) &&
-                                  ball[k].pos_x+HALFBALL <=
-                                  pad_pos_x+3*(pad_width/2/4)) ||
-                                 (ball[k].pos_x+2 >=
-                                  pad_pos_x+(pad_width-3*(pad_width/2/4)) &&
-                                  ball[k].pos_x+2 <=
-                                  pad_pos_x+ ((pad_width/2)-2*(pad_width/2/4)) )) {
-
-                            ball[k].y = -4;
-                            if (ball[k].pos_x != 0 &&
-                                ball[k].pos_x+BALL!=LCD_WIDTH)
-                                ball[k].x = brickmania_pad_check(3,0,
-                                                    ball[k].pos_x+2<=pad_pos_x+
-                                                    (pad_width/2)?0:1,k);
-
-                        }
-                        else if ((ball[k].pos_x+HALFBALL >=
-                                  pad_pos_x+3*(pad_width/2/4) &&
-                                  ball[k].pos_x+HALFBALL <=
-                                  pad_pos_x+4*(pad_width/2/4)-2) ||
-                                 (ball[k].pos_x+2 >= pad_pos_x+(pad_width/2+2) &&
-                                  ball[k].pos_x+2 <=
-                                  pad_pos_x+(pad_width-3*(pad_width/2/4)) )) {
-
-                            ball[k].y = -4;
-                            if (ball[k].pos_x != 0 &&
-                                ball[k].pos_x+BALL!=LCD_WIDTH)
-                                ball[k].x = brickmania_pad_check(2,1,0,k);
-
-                        }
-                        else {
-                            ball[k].y = -4;
-                        }
+                        if (ball[k].pos_x != 0 && ball[k].pos_x != LCD_WIDTH)
+                            ball[k].x = i;
                     }
-
                     if (!ball[k].glue) {
                         ball[k].pos_x+=ball[k].tempx!=0?ball[k].tempx:ball[k].x;
                         ball[k].pos_y+=ball[k].tempy!=0?ball[k].tempy:ball[k].y;
@@ -1506,8 +1352,8 @@
 
                     if (ball[k].pos_y+5 >= PAD_POS_Y &&
                         (pad_type==1 && !ball[k].glue) &&
-                        (ball[k].pos_x >= pad_pos_x &&
-                         ball[k].pos_x <= pad_pos_x+pad_width)) {
+                        (ball[k].pos_x + BALL > pad_pos_x &&
+                         ball[k].pos_x < pad_pos_x+pad_width)) {
                         ball[k].y=0;
                         ball[k].pos_y=PAD_POS_Y-BALL;
                         ball[k].glue=true;
@@ -1518,12 +1364,12 @@
             rb->lcd_update();
 
             if (brick_on_board < 0) {
-                if (level+1<levels_num) {
-                    level++;
+                if (++level<LEVELS_NUM) {
                     if (difficulty==NORMAL)
                         score+=100;
                     brickmania_init_game(1);
                     brickmania_sleep(2);
+                    end = *rb->current_tick;
                 }
                 else {
                     rb->lcd_getstringsize("Congratulations!", &sw, NULL);
@@ -1555,26 +1401,16 @@
             if (rb->button_hold())
                 button = QUIT;
 #endif
-
+            i=0;
 #ifdef HAVE_TOUCHSCREEN
             if(button & BUTTON_TOUCHSCREEN)
             {
                 short touch_x, touch_y;
                 touch_x = rb->button_get_data() >> 16;
                 touch_y = rb->button_get_data() & 0xffff;
-                if(touch_y >= PAD_POS_Y && touch_y <= PAD_POS_Y+PAD_HEIGHT)
-                {
-                    pad_pos_x += (flip_sides ? -1 : 1) * ( (touch_x-pad_pos_x-pad_width/2) / 4 );
+                if(touch_y >= PAD_POS_Y && touch_y < PAD_POS_Y+PAD_HEIGHT)
+                    i =(touch_x-pad_pos_x-pad_width/2) / 4;
 
-                    if(pad_pos_x < 0)
-                        pad_pos_x = 0;
-                    else if(pad_pos_x+pad_width > LCD_WIDTH)
-                        pad_pos_x = LCD_WIDTH-pad_width;
-                    for(k=0;k<used_balls;k++)
-                        if (game_state==ST_READY || ball[k].glue)
-                            ball[k].pos_x = pad_pos_x+pad_width/2;
-                }
-
                 if(button & BUTTON_REL)
                     button = SELECT;
             }
@@ -1589,43 +1425,23 @@
                 button_right=((move_button & RIGHT) || (SCROLL_FWD(button)));
                 button_left=((move_button & LEFT) || (SCROLL_BACK(button)));
                 #endif
-                if ((game_state==ST_PAUSE) && (button_right || button_left))
-                    continue;
-                if ((button_right && flip_sides==false) ||
-                    (button_left && flip_sides==true)) {
-                    if (pad_pos_x+8+pad_width > LCD_WIDTH) {
-                        for(k=0;k<used_balls;k++)
-                            if (game_state==ST_READY || ball[k].glue)
-                                ball[k].pos_x+=LCD_WIDTH-pad_pos_x-pad_width;
-                        pad_pos_x+=LCD_WIDTH-pad_pos_x-pad_width;
-                    }
-                    else {
-                        for(k=0;k<used_balls;k++)
-                            if ((game_state==ST_READY || ball[k].glue))
-                                ball[k].pos_x+=8;
-                        pad_pos_x+=8;
-                    }
-                }
-                else if ((button_left && flip_sides==false) ||
-                         (button_right && flip_sides==true)) {
-                    if (pad_pos_x-8 < 0) {
-                        for(k=0;k<used_balls;k++)
-                            if (game_state==ST_READY || ball[k].glue)
-                                ball[k].pos_x-=pad_pos_x;
-                        pad_pos_x-=pad_pos_x;
-                    }
-                    else {
-                        for(k=0;k<used_balls;k++)
-                            if (game_state==ST_READY || ball[k].glue)
-                                ball[k].pos_x-=8;
-                        pad_pos_x-=8;
-                    }
-                }
+                if (button_right)
+                    i=8;
+                else if (button_left)
+                    i=-8;
 #ifdef HAVE_TOUCHSCREEN
             }
 #endif
-
-
+            if (flip_sides)
+                i*=-1;
+            if(pad_pos_x+i < 0)
+                i = -pad_pos_x;
+            else if(pad_pos_x+pad_width+i > LCD_WIDTH)
+                i = LCD_WIDTH-pad_width-pad_pos_x;
+            pad_pos_x+=i;
+            for(k=0;k<used_balls;k++)
+                if ((game_state==ST_READY || ball[k].glue))
+                    ball[k].pos_x += i;
             switch(button) {
                 case UP:
                 case SELECT:
@@ -1641,18 +1457,19 @@
                         game_state=ST_START;
                     }
                     else if (pad_type==1) {
-                        for(k=0;k<used_balls;k++) {
+                        for(k=0;k<used_balls;k++)
                             if (ball[k].glue)
                                 ball[k].glue=false;
-                        }
                     }
                     else if (pad_type==2) {
-                        k=brickmania_fire_space();
-                        fire[k].top=PAD_POS_Y-7;
-                        fire[k].left=pad_pos_x+1;
-                        k=brickmania_fire_space();
-                        fire[k].top=PAD_POS_Y-7;
-                        fire[k].left=pad_pos_x+pad_width-1;
+                        if ((k=brickmania_fire_space())!=MAX_FIRES) {
+                            fire[k].top=PAD_POS_Y-7;
+                            fire[k].left=pad_pos_x;
+                        }
+                        if ((k=brickmania_fire_space())!=MAX_FIRES) {
+                            fire[k].top=PAD_POS_Y-7;
+                            fire[k].left=pad_pos_x+pad_width-1;
+                        }
                     }
                     break;
 #ifdef RC_QUIT