summaryrefslogtreecommitdiff
path: root/noncore
Side-by-side diff
Diffstat (limited to 'noncore') (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/decorations/flat/flat.cpp4
-rw-r--r--noncore/games/bounce/game.cpp17
-rw-r--r--noncore/games/kbill/Game.cc14
-rw-r--r--noncore/games/kbill/Game.h2
-rw-r--r--noncore/games/kbill/field.cpp2
-rw-r--r--noncore/games/kbill/inputbox.cpp10
-rw-r--r--noncore/games/kbill/kbill.h42
-rw-r--r--noncore/games/zsame/ZSameWidget.cpp12
8 files changed, 53 insertions, 50 deletions
diff --git a/noncore/decorations/flat/flat.cpp b/noncore/decorations/flat/flat.cpp
index a2f12be..9a670cc 100644
--- a/noncore/decorations/flat/flat.cpp
+++ b/noncore/decorations/flat/flat.cpp
@@ -193,170 +193,170 @@ static QImage scaleButton( const QImage &img, int height )
static void colorize( QImage &img, const QColor &c, bool rev )
{
for ( int i = 0; i < img.numColors(); i++ ) {
bool sc = (img.color(i) & 0xff000000);
if ( rev ) sc = !sc;
img.setColor(i, sc ? c.rgb() : 0x00000000 );
}
}
FlatDecoration::FlatDecoration() : buttonCache(16)
{
buttonCache.setAutoDelete(TRUE);
}
FlatDecoration::~FlatDecoration()
{
}
int FlatDecoration::metric( Metric m, const WindowData *wd ) const
{
switch ( m ) {
case TopBorder:
return 1;
break;
case LeftBorder:
case RightBorder:
return 2;
case BottomBorder:
return 4;
case TitleHeight:
if ( QApplication::desktop()->height() > 320 )
return 20;
else
return 18;
case OKWidth:
case CloseWidth:
case HelpWidth:
case MaximizeWidth:
return metric(TitleHeight,wd);
break;
default:
return WindowDecorationInterface::metric( m, wd );
break;
}
return 0;
}
void FlatDecoration::drawArea( Area a, QPainter *p, const WindowData *wd ) const
{
int th = metric( TitleHeight, wd );
QRect r = wd->rect;
switch ( a ) {
case Border:
{
const QColorGroup &cg = wd->palette.active();
if ( wd->flags & WindowData::Active ) {
p->setBrush( cg.color(QColorGroup::Highlight) );
} else {
p->setBrush( cg.color(QColorGroup::Background) );
}
p->setPen( cg.foreground() );
int lb = metric(LeftBorder,wd);
int rb = metric(RightBorder,wd);
int tb = metric(TopBorder,wd);
int bb = metric(BottomBorder,wd);
p->drawRect( r.x()-lb, r.y()-tb-th, r.width()+lb+rb,
r.height()+th+tb+bb );
}
break;
case Title:
if ( r.height() < 2 ) {
WindowDecorationInterface::drawArea( a, p, wd );
} else {
const QColorGroup &cg = wd->palette.active();
QColor c;
if ( wd->flags & WindowData::Active )
c = cg.color(QColorGroup::Highlight);
else
c = cg.color(QColorGroup::Background);
p->fillRect( QRect(r.x(),r.y()-th,r.width(),th), c );
}
break;
case TitleText:
p->drawText( r.left()+3+metric(HelpWidth,wd), r.top()-th,
r.width()-metric(HelpWidth,wd)-metric(CloseWidth,wd), th,
Qt::AlignVCenter, wd->caption );
break;
default:
FlatDecoration::drawArea( a, p, wd );
break;
}
}
-void FlatDecoration::drawButton( Button b, QPainter *p, const WindowData *wd, int x, int y, int w, int h, QWSButton::State state ) const
+void FlatDecoration::drawButton( Button b, QPainter *p, const WindowData *wd, int x, int y, int, int, QWSButton::State state ) const
{
QColor c;
const QColorGroup &cg = wd->palette.active();
if ( wd->flags & WindowDecorationInterface::WindowData::Active )
c = cg.color(QColorGroup::HighlightedText);
else
c = cg.color(QColorGroup::Foreground);
bool r = (state & QWSButton::MouseOver) && (state & QWSButton::Clicked);
int th = metric(TitleHeight, wd);
QString key( "%1-%2-%3-%4" );
key = key.arg(b).arg(th).arg(c.name()).arg(r ? "1" : "0");
QImage *img = buttonCache.find( key );
if ( !img ) {
QImage tmp;
switch ( b ) {
case OK:
tmp = QImage( ok_xpm );
break;
case Close:
tmp = QImage( close_xpm );
break;
case Help:
tmp = QImage( help_xpm );
break;
case Maximize:
tmp = QImage( maximize_xpm );
break;
}
colorize( tmp, c, r );
img = new QImage( scaleButton(tmp,th) );
FlatDecoration *that = (FlatDecoration *)this;
that->buttonCache.insert( key, img, 1 );
}
-
+
p->drawImage( x, y, *img );
}
QRegion FlatDecoration::mask( const WindowData *wd ) const
{
return WindowDecorationInterface::mask( wd );
}
QString FlatDecoration::name() const
{
return qApp->translate( "Decoration", "Flat" );
}
QPixmap FlatDecoration::icon() const
{
return QPixmap();
}
QRESULT FlatDecoration::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
{
*iface = 0;
if ( uuid == IID_QUnknown )
*iface = this;
else if ( uuid == IID_WindowDecoration )
*iface = this;
else
return QS_FALSE;
if ( *iface )
(*iface)->addRef();
return QS_OK;
}
Q_EXPORT_INTERFACE()
{
Q_CREATE_INSTANCE( FlatDecoration )
}
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
@@ -1,512 +1,513 @@
/*
* Copyright (C) 2000 Stefan Schimanski <1Stein@gmx.de>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* 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;
case Right: m_dx = 1; break;
}
m_x = m_startX;
m_y = m_startY;
m_field->setTile( m_x, m_y, m_tile );
}
void Wall::finish()
{
m_active = false;
}
bool Wall::isFree( int x, int y )
{
if ( m_field->tile(x, y)==TILE_FREE )
{
// check whether there is a ball at the moment
QCanvasItemList cols = m_field->collisions( QRect(x*TILE_SIZE, y*TILE_SIZE,
TILE_SIZE, TILE_SIZE) );
if ( cols.count()==0 )
return true;
}
return false;
}
void Wall::update()
{
}
void Wall::advance()
{
update();
// move wall
if ( m_active )
{
m_delay--;
if ( m_delay<=0 )
{
m_delay = MS2TICKS(WALL_DELAY);
// set previous tile
m_field->setTile( m_x, m_y, m_tile );
// check whether next place is still free
if ( isFree(m_x+m_dx, m_y+m_dy) )
{
// move ball
m_x += m_dx;
m_y += m_dy;
// set tile
m_field->setTile( m_x, m_y, TILE_WALLEND );
} else
{
finish();
emit finished( this, m_field->tile( m_x+m_dx, m_y+m_dy ) );
}
}
}
}
void Wall::fill( bool black )
{
if ( m_dx )
{
for ( int x=m_startX ; x!=m_x; x+=m_dx )
if ( m_field->tile(x, m_startY)==m_tile )
m_field->setGameTile( x, m_startY, black );
m_field->setGameTile( m_x, m_startY, black );
} else
{
for ( int y=m_startY ; y!=m_y; y+=m_dy )
if ( m_field->tile(m_startX, y)==m_tile )
m_field->setGameTile( m_startX, y, black );
m_field->setGameTile( m_startX, m_y, black );
}
}
/*************************************************************************/
JezzField::JezzField( QPixmap tiles, QObject* parent, const char* name )
: QCanvas( parent, name ), m_tiles( tiles )
{
setPixmaps( tiles );
}
void JezzField::setGameTile( int x, int y, bool black )
{
setTile( x, y, black ? TILE_BORDER : TILE_FREE );
}
void JezzField::setPixmaps( QPixmap tiles )
{
// create new tiles
QPixmap allTiles( TILE_SIZE*(FIELD_WIDTH-2), TILE_SIZE*(FIELD_HEIGHT-1) );
// handle default tiles
bitBlt( &allTiles, 0, TILE_SIZE*(FIELD_HEIGHT-2),
&tiles, 0, 0, tiles.width(), tiles.height() );
// load tiles into canvas
setTiles( allTiles, FIELD_WIDTH, FIELD_HEIGHT, TILE_SIZE, TILE_SIZE );
}
/*************************************************************************/
JezzView::JezzView(QCanvas* viewing, QWidget* parent, const char* name, WFlags f)
: QCanvasView( viewing, parent, name, f ), m_vertical( false )
{
setResizePolicy( AutoOne );
setHScrollBarMode( AlwaysOff );
setVScrollBarMode( AlwaysOff );
setCursor( sizeHorCursor );
}
void JezzView::viewportMouseReleaseEvent( QMouseEvent *ev )
{
if ( ev->button() & LeftButton )
{
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;
for ( int y=1; y<FIELD_HEIGHT-1; y++ )
for ( int x=1; x<FIELD_WIDTH-1; x++ )
{
if ( m_field->tile(x,y)!=TILE_FREE )
notFree++;
}
return 100 * notFree / ( (FIELD_WIDTH-1) * (FIELD_HEIGHT-1) );
}
void JezzGame::fill( int x, int y )
{
if ( m_buf[x][y]!=TILE_FREE) return;
// go left
int _x=x;
for ( ; m_buf[_x][y]==TILE_FREE; _x-- )
m_buf[_x][y] = TILE_BORDER;
int stopx = _x;
// fill above
for ( _x=x; _x>stopx; _x-- )
if ( m_buf[_x][y-1]==TILE_FREE ) fill( _x, y-1 );
// fill below
for ( _x=x; _x>stopx; _x-- )
if ( m_buf[_x][y+1]==TILE_FREE ) fill( _x, y+1 );
// go right
for ( _x=x+1; m_buf[_x][y]==TILE_FREE; _x++ )
m_buf[_x][y] = TILE_BORDER;
stopx = _x;
// fill above
for ( _x=x+1; _x<stopx; _x++ )
if ( m_buf[_x][y-1]==TILE_FREE ) fill( _x, y-1 );
// fill below;
for ( _x=x+1; _x<stopx; _x++ )
if ( m_buf[_x][y+1]==TILE_FREE ) fill( _x, y+1 );
}
void JezzGame::ballCollision( Ball*, int, int, int tile )
{
if ( tile!=TILE_BORDER && tile>TILE_FREE && tile!=TILE_WALLEND )
{
// stop walls
if ( (tile==TILE_WALLUP || tile==TILE_WALLLEFT) && m_wall1 )
{
m_wall1->finish();
m_wall1->fill( false );
delete m_wall1;
m_wall1 = 0;
}
if ( (tile==TILE_WALLDOWN || tile==TILE_WALLRIGHT) && m_wall2 )
{
m_wall2->finish();
m_wall2->fill( false );
delete m_wall2;
m_wall2 = 0;
}
// update view
m_field->update();
m_view->repaint();
// send death msg
emit died();
}
}
diff --git a/noncore/games/kbill/Game.cc b/noncore/games/kbill/Game.cc
index 624b50b..4cd5322 100644
--- a/noncore/games/kbill/Game.cc
+++ b/noncore/games/kbill/Game.cc
@@ -1,246 +1,246 @@
#include "objects.h"
Horde bill;
Network net;
Library OS;
Bucket bucket;
Spark spark;
//Scorelist scores;
Game game;
UI ui;
int Game::RAND(int lb, int ub) {
return (rand()%(ub-lb+1) + lb);
}
int Game::MAX(int x, int y) {
return (x>y ? x : y);
}
int Game::MIN(int x, int y) {
return (x<y ? x : y);
}
int Game::INTERSECT(int x1, int y1, int w1, int h1, int x2, int y2, int w2,
int h2)
{
return (((x2-x1<=w1 && x2-x1>=0) || (x1-x2<=w2 && x1-x2>=0))
&& ((y2-y1<=h1 && y2-y1>=0) || (y1-y2<=h2 && y1-y2>=0)));
}
void Game::setup_level (unsigned int lev) {
level = lev;
bill.setup();
grabbed = EMPTY;
ui.set_cursor(DEFAULTC);
net.setup();
iteration = efficiency = 0;
}
void Game::start(unsigned int lev) {
state = PLAYING;
score = 0;
ui.restart_timer();
ui.set_pausebutton(true);
setup_level(lev);
}
void Game::quit() {
exit(0);
}
void Game::update_info() {
static char str[80];
sprintf (str, "Bill:%d/%d System:%d/%d/%d Level:%d Score:%d",
bill.on_screen, bill.off_screen, net.base, net.off,
net.win, level, score);
ui.draw_str(str, 5, scrheight-5);
efficiency += ((100*net.base-10*net.win)/net.units);
}
-
+
void Game::update_score (int action) {
switch (action){
case ENDLEVEL: score+=(level*efficiency/iteration); break;
default: score+=(action*action*BILLPOINTS);
}
}
void Game::warp_to_level (unsigned int lev) {
if (state==PLAYING) {
if (lev <= level) return;
setup_level(lev);
}
else {
- if (lev<=0) return;
+ if (lev <=0) return;
start(lev);
}
}
void Game::button_press(int x, int y) {
int i, counter=0, flag=0;
if (state != PLAYING) return;
ui.set_cursor(DOWNC);
if (bucket.clicked(x, y)) {
ui.set_cursor(BUCKETC);
grabbed = BUCKET;
}
for (i=0; i < bill.MAX_BILLS && !flag; i++) {
if (bill.list[i].state == bill.list[i].OFF
|| bill.list[i].state == bill.list[i].DYING)
continue;
if (bill.list[i].state == bill.list[i].STRAY &&
bill.list[i].clickedstray(x, y))
{
ui.set_cursor (bill.list[i].cargo);
grabbed = i;
flag = 1;
}
else if (bill.list[i].state != bill.list[i].STRAY &&
bill.list[i].clicked(x, y))
{
- if (bill.list[i].state == bill.list[i].AT)
+ if (bill.list[i].state == bill.list[i].AT)
net.computers[bill.list[i].target_c].busy=0;
bill.list[i].index = -1;
bill.list[i].cels = bill.dcels;
bill.list[i].x_offset = -2;
bill.list[i].y_offset = -15;
bill.list[i].state = bill.list[i].DYING;
counter++;
}
}
if (counter) update_score(counter);
}
void Game::button_release(int x, int y) {
int i;
ui.set_cursor (DEFAULTC);
if (state != PLAYING || grabbed == EMPTY)
return;
if (grabbed == BUCKET) {
grabbed = EMPTY;
for (i=0; i<net.ncables; i++)
if (net.cables[i].onspark(x, y)) {
net.cables[i].active=0;
net.cables[i].delay = spark.delay(level);
}
return;
}
for (i=0; i<net.units; i++)
if (net.computers[i].oncomputer(x, y)
&&
net.computers[i].compatible (bill.list[grabbed].cargo)
&&
- (net.computers[i].os == OS.WINGDOWS ||
+ (net.computers[i].os == OS.WINGDOWS ||
net.computers[i].os == OS.OFF))
{
- net.base++;
+ net.base++;
if (net.computers[i].os == OS.WINGDOWS)
net.win--;
else
net.off--;
net.computers[i].os = bill.list[grabbed].cargo;
bill.list[grabbed].state = bill.list[grabbed].OFF;
grabbed = EMPTY;
return;
}
grabbed = EMPTY;
-}
+}
void Game::update() {
switch (state) {
case PLAYING:
- ui.clear();
+ ui.clear();
bucket.draw();
net.update();
net.draw();
bill.update();
bill.draw();
update_info();
if (!(bill.on_screen+bill.off_screen)) {
update_score(ENDLEVEL);
state = BETWEEN;
}
if ((net.base+net.off)<=1) state = END;
break;
case END:
ui.clear();
net.toasters();
net.draw();
ui.refresh();
ui.popup_dialog(ENDGAME);
/* if (score > scores.score[9]) ui.popup_dialog(ENTERNAME);
scores.update();*/
ui.popup_dialog(HIGHSCORE);
ui.clear();
ui.draw_centered(logo);
ui.kill_timer();
ui.set_pausebutton (false);
state = WAITING;
break;
case BETWEEN:
ui.update_scorebox(level, score);
ui.popup_dialog (SCORE);
state = PLAYING;
setup_level(++level);
break;
}
ui.refresh();
iteration++;
}
void Game::main(int argc, char **argv) {
int c;
extern char *optarg;
level = 0;
ui.initialize(&argc, argv);
while (argv && argv[0] && (c = getopt(argc, argv, "l:L:")) != -1)
switch(c) {
case 'l':
case 'L': level = MAX (1, atoi(optarg)); break;
}
srand(time(NULL));
ui.make_mainwin();
ui.graph_init();
ui.clear();
logo.load("logo");
ui.draw_centered(logo);
ui.refresh();
ui.make_windows();
// scores.read();
// scores.update();
bill.load_pix();
OS.load_pix();
net.load_pix();
bucket.load_pix();
spark.load_pix();
ui.load_cursors();
state = WAITING;
if (level) start(level);
else ui.set_pausebutton(false);
ui.MainLoop();
exit(0);
}
int main(int argc, char **argv) {
if (argc>1 && !strcmp(argv[1], "-v")) {
printf ("XBill version 2.0\n\n");
exit(0);
}
if (argc>1 && !strcmp(argv[1], "-h")) {
printf ("XBill version 2.0\n");
printf ("Options:\n");
printf ("-l n, -L n\tStart at level n.\n");
printf ("-v\t\tPrint version number and exit.\n");
printf ("-h\t\tPrint help and exit.\n");
printf ("leaves the window.\n");
printf ("All standard X Intrinsics options are also ");
printf ("supported.\n\n");
exit(0);
}
game.main(argc, argv);
}
diff --git a/noncore/games/kbill/Game.h b/noncore/games/kbill/Game.h
index 4473936..5c9c497 100644
--- a/noncore/games/kbill/Game.h
+++ b/noncore/games/kbill/Game.h
@@ -1,55 +1,55 @@
#ifndef GAME_H
#define GAME_H
#include "objects.h"
class Game {
- unsigned state;
+ int state;
int efficiency;
public:
unsigned score, level, iteration;
Picture logo;
int grabbed;
static const unsigned short scrwidth = 240;
static const unsigned short scrheight = 290;
static const int PLAYING = 1;
static const int BETWEEN = 2;
static const int END = 3;
static const int WAITING = 4;
static const int DEFAULTC = 0; /* cursors */
static const int DOWNC = -1;
static const int BUCKETC = -2;
static const int ENDGAME = 200; /* dialog window IDs */
static const int ENTERNAME = 201;
static const int HIGHSCORE = 202;
static const int SCORE = 203;
static const int ENDLEVEL = -1; /* Codes for updating score */
static const int BILLPOINTS = 5;
static const int EMPTY = -2; /* Grabbed object */
static const int BUCKET = -1;
int RAND(int lb, int ub);
int MAX(int x, int y);
int MIN(int x, int y);
int INTERSECT(int x1, int y1, int w1, int h1, int x2, int y2, int w2,
int h2);
void setup_level (unsigned int lev);
void start(unsigned int lev);
void quit();
void update_info();
void update_score (int action);
void warp_to_level (unsigned int lev);
void button_press(int x, int y);
void button_release(int x, int y);
void update();
void main(int argc, char **argv);
};
#endif
diff --git a/noncore/games/kbill/field.cpp b/noncore/games/kbill/field.cpp
index a974ab2..0dd8d72 100644
--- a/noncore/games/kbill/field.cpp
+++ b/noncore/games/kbill/field.cpp
@@ -1,83 +1,83 @@
/***************************************************************************
field.cpp - description
-------------------
begin : Thu Dec 30 1999
copyright : (C) 1999 by Jurrien Loonstra
email : j.h.loonstra@st.hanze.nl
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "objects.h"
#include "field.h"
Field::Field(QWidget *parent, const char *name ) : QWidget(parent,name) {
setFixedSize(game.scrwidth, game.scrheight);
setBackgroundColor(white);
timer = new QTimer(this);
playing = false;
connect(timer, SIGNAL(timeout()), SLOT(Timer()));
}
Field::~Field(){
delete timer;
}
void Field::setPixmap(QPixmap *pix) {
this->pix = pix;
}
// --------------------------------------------------------
void Field::mousePressEvent(QMouseEvent *e){
game.button_press(e->x(), e->y());
}
void Field::mouseReleaseEvent(QMouseEvent *e){
game.button_release(e->x(), e->y());
}
void Field::enterEvent(QEvent *) {
if (playing && !timer->isActive()) {
playing = true;
timer->start(250, FALSE);
}
}
void Field::leaveEvent(QEvent *) {
if (timer->isActive() && playing) {
playing = true;
timer->stop();
}
}
void Field::stopTimer() {
playing = false;
if (timer->isActive())
timer->stop();
}
void Field::startTimer() {
playing = true;
if (!timer->isActive())
timer->start(250, FALSE);
}
void Field::Timer(){
game.update();
}
void Field::paintEvent(QPaintEvent *) {
bitBlt(this, 0, 0, pix);
-} \ No newline at end of file
+}
diff --git a/noncore/games/kbill/inputbox.cpp b/noncore/games/kbill/inputbox.cpp
index 5087fbb..7aaebe7 100644
--- a/noncore/games/kbill/inputbox.cpp
+++ b/noncore/games/kbill/inputbox.cpp
@@ -1,50 +1,50 @@
/***************************************************************************
inputbox.cpp - description
-------------------
begin : Sat Jan 1 2000
copyright : (C) 2000 by Jurrien Loonstra
email : j.h.loonstra@st.hanze.nl
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "inputbox.h"
-InputBox::InputBox(QWidget *parent, const char *name, const char *caption, const char *text) : QDialog(parent, name, TRUE) {
+InputBox::InputBox(QWidget *parent, const char *name, const char *, const char *) : QDialog(parent, name, TRUE) {
// setCaption(caption);
-//
+//
// question = new QLabel(this);
// question->setText(text);
// question->setGeometry(10, 10, 240, 50);
-//
+//
// input = new QLineEdit(this);
// input->setGeometry(10, 60, 240, 30);
// input->setFocus();
// input->setMaxLength(19);
-//
+//
// ok = new QPushButton( "Ok", this );
// ok->setGeometry(10, 100, 100,30 );
// ok->setDefault(TRUE);
// connect( ok, SIGNAL(clicked()), SLOT(accept()) );
-//
+//
// cancel = new QPushButton( "Cancel", this );
// cancel->setGeometry(150, 100, 100,30 );
// connect( cancel, SIGNAL(clicked()), SLOT(reject()) );
}
InputBox::~InputBox(){
delete ok;
delete cancel;
delete question;
delete input;
}
QString InputBox::getText() const{
return input->text();
}
diff --git a/noncore/games/kbill/kbill.h b/noncore/games/kbill/kbill.h
index fbc0c6c..da1a111 100644
--- a/noncore/games/kbill/kbill.h
+++ b/noncore/games/kbill/kbill.h
@@ -1,54 +1,56 @@
/***************************************************************************
kbill.h - description
-------------------
begin : Thu Dec 30 16:55:55 CET 1999
copyright : (C) 1999 by Jurrien Loonstra
email : j.h.loonstra@st.hanze.nl
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef KBILL_H
#define KBILL_H
#include <qmainwindow.h>
#include <qwidget.h>
#include <qpopupmenu.h>
#include "field.h"
class KBill : public QMainWindow
{
- Q_OBJECT
- public:
+ Q_OBJECT
+public:
KBill();
- ~KBill();
- Field* getField();
- private:
- QMenuBar *menu;
- QPopupMenu *file, *help;
- Field *field;
- int pauseid;
- protected slots:
- void Quit();
- void About();
- void NewGame();
- void Pause();
- void WarpTo();
- void Story();
- void Rules();
- void ViewHighScores();
-
- friend class UI;
+ ~KBill();
+ Field* getField();
+private:
+ QMenuBar *menu;
+ QPopupMenu *file, *help;
+ Field *field;
+ int pauseid;
+
+protected slots:
+ void Quit();
+ void About();
+ void NewGame();
+ void Pause();
+ void WarpTo();
+ void Story();
+ void Rules();
+ void ViewHighScores();
+
+protected:
+ friend class UI;
};
#endif
diff --git a/noncore/games/zsame/ZSameWidget.cpp b/noncore/games/zsame/ZSameWidget.cpp
index 4fab0f6..04ad825 100644
--- a/noncore/games/zsame/ZSameWidget.cpp
+++ b/noncore/games/zsame/ZSameWidget.cpp
@@ -16,229 +16,229 @@
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
#include <stdio.h>
#include <opie2/oapplicationfactory.h>
#include <qpe/resource.h>
#include <qtoolbar.h>
#include <qmenubar.h>
#include <qapplication.h>
#include <qaction.h>
#include <qmessagebox.h>
#include <kapplication.h>
#include "ZSameWidget.h"
static int default_colors=3;
#define i18n tr
using namespace Opie::Core;
OPIE_EXPORT_APP( OApplicationFactory<ZSameWidget> )
ZSameWidget::ZSameWidget( QWidget* parent, const char* name, WFlags fl )
: QMainWindow( parent, name, fl )
{
setCaption(tr("ZSame"));
setToolBarsMovable( false );
QToolBar* con = new QToolBar( this );
con->setHorizontalStretchable( true );
QMenuBar* mb = new QMenuBar( con );
QToolBar* tb = new QToolBar( this );
QPopupMenu* fileMenu = new QPopupMenu( this );
QAction* a = new QAction(tr("New Game"), Resource::loadIconSet("new") ,
QString::null, 0, this, "new_icon");
a->addTo( fileMenu );
a->addTo( tb );
connect(a, SIGNAL(activated()), this, SLOT(m_new()));
a = new QAction(tr("Restart This Board"), Resource::loadIconSet("redo"),
QString::null, 0, this, "restart_board" );
a->addTo( fileMenu );
connect( a, SIGNAL(activated()), this, SLOT(m_restart()));
restart = a;
a = new QAction( tr("Undo"), Resource::loadIconSet("undo"),
QString::null, 0, this, "undo_action" );
a->addTo( fileMenu );
a->addTo( tb );
connect( a, SIGNAL(activated()), this, SLOT(m_undo()));
a = new QAction(tr("Quit"), Resource::loadIconSet("quit_icon"),
QString::null, 0, this, "quit_action");
a->addTo( fileMenu );
a->addTo( tb );
connect(a, SIGNAL(activated()), this, SLOT(m_quit()));
mb->insertItem(tr("Game" ), fileMenu );
int foo[2];
desktop_widget(foo);
stone = new StoneWidget(this,foo[0],foo[1]);
connect( stone, SIGNAL(s_gameover()), this, SLOT(gameover()));
connect( stone, SIGNAL(s_colors(int)), this, SLOT(setColors(int)));
connect( stone, SIGNAL(s_board(int)), this, SLOT(setBoard(int)));
connect( stone, SIGNAL(s_marked(int)), this, SLOT(setMarked(int)));
connect( stone, SIGNAL(s_score(int)), this, SLOT(setScore(int)));
connect( stone, SIGNAL(s_remove(int,int)), this, SLOT(stonesRemoved(int,int)));
connect(stone, SIGNAL(s_sizechanged()), this, SLOT(sizeChanged()));
sizeChanged();
setCentralWidget(stone);
setScore(0);
}
ZSameWidget::~ZSameWidget() {
}
-void ZSameWidget::readProperties(Config *conf) {
+void ZSameWidget::readProperties(Config *) {
/*
Q_ASSERT(conf);
stone->readProperties(conf);
*/
}
-void ZSameWidget::saveProperties(Config *conf) {
+void ZSameWidget::saveProperties(Config *) {
/*
Q_ASSERT(conf);
stone->saveProperties(conf);
conf->sync();
*/
}
void ZSameWidget::sizeChanged() {
// stone->setFixedSize(stone->sizeHint());
}
void ZSameWidget::newGame(unsigned int board,int colors) {
while (board>=1000000) board-=1000000;
// kdDebug() << "newgame board " << board << " colors " << colors << endl;
stone->newGame(board,colors);
setScore(0);
}
bool ZSameWidget::confirmAbort() {
return stone->isGameover() ||
stone->isOriginalBoard() ||
(QMessageBox::warning(this, i18n("Resign"), i18n("<qt>Do you want to resign?</qt>"),
QMessageBox::Yes,
QMessageBox::No|QMessageBox::Default|QMessageBox::Escape, 0) == QMessageBox::Yes );
}
void ZSameWidget::m_new() {
if (confirmAbort())
newGame(_random(),default_colors);
}
void ZSameWidget::m_restart() {
if (confirmAbort())
newGame(stone->board(),default_colors);
}
void ZSameWidget::m_load() {
// kdDebug() << "menu load not supported" << endl;
}
void ZSameWidget::m_save() {
// kdDebug() << "menu save not supported" << endl;
}
void ZSameWidget::m_undo() {
// Q_ASSERT(stone);
stone->undo();
}
void ZSameWidget::m_showhs() {
/* Q_ASSERT(stone);
stone->unmark();
KScoreDialog d(KScoreDialog::Name | KScoreDialog::Score, this);
d.addField(Board, i18n("Board"), "Board");
d.exec();
*/
}
void ZSameWidget::m_quit() {
// Q_ASSERT(stone);
stone->unmark();
qApp->quit();
// delete this;
}
void ZSameWidget::m_tglboard() {
// kdDebug() << "toggled" << endl;
}
-void ZSameWidget::setColors(int colors) {
+void ZSameWidget::setColors(int ) {
// status->changeItem(i18n("%1 Colors").arg(colors),1);
}
-void ZSameWidget::setBoard(int board) {
+void ZSameWidget::setBoard(int ) {
// status->changeItem(i18n("Board: %1").arg(board, 6), 2);
}
-void ZSameWidget::setMarked(int m) {
+void ZSameWidget::setMarked(int ) {
// status->changeItem(i18n("Marked: %1").arg(m, 6),3);
}
void ZSameWidget::stonesRemoved(int,int) {
// KNotifyClient::event("stones removed",
// i18n("%1 stones removed.").arg(stone->marked()));
}
-void ZSameWidget::setScore(int score) {
+void ZSameWidget::setScore(int ) {
// status->changeItem(i18n("Score: %1").arg(score, 6),4);
// undo->setEnabled(stone->undoPossible());
// restart->setEnabled(!stone->isOriginalBoard());
}
void ZSameWidget::gameover() {
// kdDebug() << "GameOver" << endl;
if (stone->hasBonus()) {
QMessageBox::information(this,i18n("Game won"),
i18n("<qt>You even removed the last stone, great job! "
"This gave you a score of %1 in total.</qt>").arg(stone->score()));
} else {
QMessageBox::information(this,i18n("Game over"),
i18n("<qt>There are no more removeable stones. "
"You got a score of %1 in total.</qt>").arg(stone->score()));
}
stone->unmark();
}
void ZSameWidget::desktop_widget(int *f)const{
QWidget* wid = QApplication::desktop();
/* width > height landscape mode */
if ( wid->width() > wid->height() ) {
f[0]=15;
f[1]=9;
}
/* normal */
else{
f[0]=12;
f[1]=13;
}
}