1 files changed, 9 insertions, 8 deletions

diff --git a/noncore/games/bounce/game.cpp b/noncore/games/bounce/game.cpp
index bbd3d0b..5ef9f15 100644
--- a/noncore/games/bounce/game.cpp
+++ b/noncore/games/bounce/game.cpp
@@ -9,144 +9,144 @@
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
  * License along with this program; if not, write to the Free
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 
 #include "game.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qtimer.h>
 
 /* STD */
 #include <stdlib.h>
 
-#define TILE_SIZE 9 
+#define TILE_SIZE 9
 
 #define TILE_FIRST ((FIELD_WIDTH-2)*(FIELD_HEIGHT-2))
 #define TILE_FREE (TILE_FIRST + 0)
 #define TILE_BORDER (TILE_FIRST + 1)
 #define TILE_WALLEND (TILE_FIRST + 2)
 #define TILE_WALLUP (TILE_FIRST + 3)
 #define TILE_WALLDOWN (TILE_FIRST + 4)
 #define TILE_WALLLEFT (TILE_FIRST + 5)
 #define TILE_WALLRIGHT (TILE_FIRST + 6)
 
 #define GAME_DELAY 15
 #define BALL_ANIM_DELAY 60
 #define WALL_DELAY 100
 
 #define MS2TICKS( ms ) ((ms)/GAME_DELAY)
 
 Arrow::Arrow(QCanvasPixmapArray* array, QCanvas* canvas)
     : QCanvasSprite( array, canvas )
 {
         m_vertical = true;
         move(3,3);
 }
 
 void Arrow::update()
 {
         if ( m_vertical )
                 setFrame( 0 );
         else
                 setFrame( 1 );
 }
 
 void Arrow::changeDirection()
 {
         m_vertical = ! m_vertical;
         update();
 }
-        
+
 
 Ball::Ball(QCanvasPixmapArray* array, QCanvas* canvas)
     : QCanvasSprite( array, canvas ), m_animDelay( 0 ), m_soundDelay( MS2TICKS(BALL_ANIM_DELAY)/2 )
 {
 }
 
 void Ball::update()
 {
    m_animDelay--;
    if ( m_animDelay<=0 )
    {
        m_animDelay =  MS2TICKS(BALL_ANIM_DELAY);
        int frameNum = frame();
        frameNum++;
        if ( frameNum>=frameCount() )
            frameNum = 0;
        setFrame( frameNum );
    }
 }
 
 void Ball::advance(int stage)
 {
    bool reflectX = false;
    bool reflectY = false;
 
    // check for collisions
    if ( collide(xVelocity(), 0) ) reflectX = true;
    if ( collide(0, yVelocity()) ) reflectY = true;
    if ( !reflectX && !reflectY && collide(xVelocity(), yVelocity()) ) reflectX = reflectY = true;
 
    // emit collision
    QRect r = boundingRect();
-   r.moveBy( xVelocity(), yVelocity() );
+   r.moveBy( static_cast<int>(xVelocity()), static_cast<int>( yVelocity() ) );
    JezzField* field = (JezzField *)canvas();
 
    int ul = field->tile( r.left() / TILE_SIZE, r.top() / TILE_SIZE );
    int ur = field->tile( r.right() / TILE_SIZE, r.top() / TILE_SIZE );
    int bl = field->tile( r.left() / TILE_SIZE, r.bottom() / TILE_SIZE );
    int br = field->tile( r.right() / TILE_SIZE, r.bottom() / TILE_SIZE );
 
    if ( ul!=TILE_FREE ) field->emitBallCollisiton( this, r.left() / TILE_SIZE, r.top() / TILE_SIZE, ul ); else
    if ( ur!=TILE_FREE ) field->emitBallCollisiton( this, r.right() / TILE_SIZE, r.top() / TILE_SIZE, ur ); else
    if ( bl!=TILE_FREE ) field->emitBallCollisiton( this, r.left() / TILE_SIZE, r.bottom() / TILE_SIZE, bl ); else
    if ( br!=TILE_FREE ) field->emitBallCollisiton( this, r.right() / TILE_SIZE, r.bottom() / TILE_SIZE, br );
 
    // apply reflection
    if ( reflectX ) setXVelocity( -xVelocity() );
    if ( reflectY ) setYVelocity( -yVelocity() );
 
    // update field
    update();
    QCanvasSprite::advance( stage );
 }
 
 bool Ball::collide( double dx, double dy )
 {
    QRect r = boundingRect();
-   r.moveBy( dx, dy );
+   r.moveBy( static_cast<int>( dx ), static_cast<int>( dy ) );
    JezzField* field = (JezzField *)canvas();
 
    int ul = field->tile( r.left() / TILE_SIZE, r.top() / TILE_SIZE );
    int ur = field->tile( r.right() / TILE_SIZE, r.top() / TILE_SIZE );
    int bl = field->tile( r.left() / TILE_SIZE, r.bottom() / TILE_SIZE );
    int br = field->tile( r.right() / TILE_SIZE, r.bottom() / TILE_SIZE );
 
    return ( ul!=TILE_FREE || ur!=TILE_FREE || bl!=TILE_FREE || br!=TILE_FREE );
 }
 
 /*************************************************************************/
 
 Wall::Wall( JezzField *field, int x, int y, Direction dir, int tile, QObject *parent, const char *name )
     : QObject( parent, name ), m_dir( dir ), m_field( field ), m_startX( x ), m_startY( y ),
       m_tile( tile ), m_delay( MS2TICKS(WALL_DELAY)/2 ), m_active( true )
 {
    // setup position and direction
    m_dx = 0;
    m_dy = 0;
    switch ( m_dir )
    {
       case Up: m_dy = -1; break;
       case Down: m_dy = 1; break;
       case Left: m_dx = -1; break;
@@ -278,163 +278,164 @@ void JezzView::viewportMouseReleaseEvent( QMouseEvent *ev )
    {
       emit buildWall( ev->x()/TILE_SIZE, ev->y()/TILE_SIZE, m_vertical );
    }
 }
 
 void JezzView::changeCursor()
 {
         m_vertical = !m_vertical;
         if ( m_vertical )
         {
                 setCursor( sizeVerCursor );
         }
         else
         {
                 setCursor( sizeHorCursor );
         }
 }
 
 /*************************************************************************/
 
 JezzGame::JezzGame( int ballNum, QWidget *parent, const char *name )
     : QWidget( parent, name ), m_wall1( 0 ), m_wall2( 0 ),
       m_text( 0 ), m_running( false ), m_percent( 0 ), m_pictured( false )
 {
-   QString path = QPEApplication::qpeDir()+"pics/bounce/"; 
+   QString path = QPEApplication::qpeDir()+"pics/bounce/";
 
    // load gfx
    m_ballPixmaps = new QCanvasPixmapArray( path + "ball%1.png", 25 );
    for ( unsigned n=0; n < m_ballPixmaps->count(); n++ )
        m_ballPixmaps->image(n)->setOffset( 0, 0 );
 
    m_arrowPixmaps = new QCanvasPixmapArray( path + "arrow%1.png", 2 );
    for ( unsigned n=0; n < m_arrowPixmaps->count(); n++ )
        m_arrowPixmaps->image(n)->setOffset( 0, 0 );
 
    QPixmap tiles( path + "tiles.png" );
 
    // create field
    m_field = new JezzField( tiles, this, "m_field" );
    m_field->resize( TILE_SIZE*FIELD_WIDTH, TILE_SIZE*FIELD_HEIGHT );
 
    for ( int x=0; x<FIELD_WIDTH; x++ )
          m_field->setTile( x, 0, TILE_BORDER );
    for ( int y=1; y<FIELD_HEIGHT-1; y++ )
    {
       m_field->setTile( 0, y, TILE_BORDER );
       for ( int x=1; x<FIELD_WIDTH-1; x++ )
          m_field->setTile( x, y, TILE_FREE );
       m_field->setTile( FIELD_WIDTH-1, y, TILE_BORDER );
    }
    for ( int x=0; x<FIELD_WIDTH; x++ )
          m_field->setTile( x, FIELD_HEIGHT-1, TILE_BORDER );
 
    connect( m_field, SIGNAL(ballCollision(Ball*,int,int,int)), this, SLOT(ballCollision(Ball*,int,int,int)) );
 
    // create view
    m_view = new JezzView( m_field, this, "m_view" );
    m_view->move( 0, 0 );
    m_view->adjustSize();
    connect( m_view, SIGNAL(buildWall(int,int,bool)), this, SLOT(buildWall(int,int,bool)) );
 
    // create balls
    for ( int n=0; n<ballNum; n++ )
    {
       Ball *ball = new Ball( m_ballPixmaps, m_field );
       m_balls.append( ball );
       ball->setVelocity( ((rand() & 1)*2-1)*2, ((rand() & 1)*2-1)*2 );
       ball->setFrame( rand() % 25 );
       ball->move( 4*TILE_SIZE + ( rand() - 50 ) % ( (FIELD_WIDTH-8)*TILE_SIZE ),
                   4*TILE_SIZE + rand() % ( (FIELD_HEIGHT-8)*TILE_SIZE ) );
       ball->show();
    }
-   
+
    // create arrow
    arrow = new Arrow( m_arrowPixmaps, m_field );
    arrow->show();
 
    // create text label
    m_text = new QCanvasText( m_field );
 
    // create game clock
    m_clock = new QTimer( this );
    connect( m_clock, SIGNAL(timeout()), this, SLOT(tick()) );
    m_clock->start( GAME_DELAY );
 
    // setup geometry
    setFixedSize( m_view->size() );
 }
 
 JezzGame::~JezzGame()
 {
     m_balls.clear();
     delete m_view;
     delete m_field;
     delete m_ballPixmaps;
 }
 
 void JezzGame::display( QString text, int size )
 {
-    odebug << "This function \"display\" shouldn't be called!!!" << oendl; 
+    odebug << "This function \"display\" shouldn't be called!!!" << oendl;
     if ( !text.isEmpty() )
     {
         QFont font( "Helvetica", size, QFont::Bold );
         font.setStyleHint( QFont::Helvetica );
         m_text->setFont( font );
         m_text->setText( text );
 
         QRect size = m_text->boundingRect();
         m_text->move( ( FIELD_WIDTH*TILE_SIZE - size.width() ) / 2,
                       ( FIELD_HEIGHT*TILE_SIZE - size.height() ) / 2 );
 
         m_text->show();
     } else
     {
         m_text->hide();
     }
 }
 
 void JezzGame::start()
 {
     m_running = true;
 }
 
 void JezzGame::stop()
 {
     m_running = false;
 }
 
 
 void JezzGame::makeBlack()
 {
    // copy current field into buffer
    for ( int y=0; y<FIELD_HEIGHT; y++ )
       for ( int x=0; x<FIELD_WIDTH; x++ )
          m_buf[x][y] = m_field->tile( x, y );
 
    // fill areas that contains a ball
    for ( Ball *ball=m_balls.first(); ball!=0; ball=m_balls.next() )
-      fill( ball->x()/TILE_SIZE, ball->y()/TILE_SIZE );
+      fill( static_cast<int>( ball->x()/TILE_SIZE ),
+            static_cast<int>( ball->y()/TILE_SIZE ) );
 
    // areas still free can be blacked now
    for ( int y=0; y<FIELD_HEIGHT; y++ )
       for ( int x=0; x<FIELD_WIDTH; x++ )
       {
          if ( m_buf[x][y]==TILE_FREE )
              m_field->setGameTile( x, y, true );
       }
 
    m_field->update();
    m_view->repaint();
 
    // count percent value of occupied area
    int p = percent();
    if ( p!=m_percent )
    {
        m_percent = p;
        emit newPercent( m_percent );
    }
 }
 
 int JezzGame::percent()
 {
    int notFree = 0;