summaryrefslogtreecommitdiff
path: root/noncore
authorimm <imm>2002-08-31 12:35:42 (UTC)
committer imm <imm>2002-08-31 12:35:42 (UTC)
commit59e182e32cff81c3b80a64b68fd727a2b6cd7971 (patch) (unidiff)
tree89d197bf582017f1c22ac3ada3331373ae914140 /noncore
parent82f9d26681268b0fc475eec91f408de8bd8568db (diff)
downloadopie-59e182e32cff81c3b80a64b68fd727a2b6cd7971.zip
opie-59e182e32cff81c3b80a64b68fd727a2b6cd7971.tar.gz
opie-59e182e32cff81c3b80a64b68fd727a2b6cd7971.tar.bz2
import
Diffstat (limited to 'noncore') (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/games/zbounce/game.cpp606
-rw-r--r--noncore/games/zbounce/game.h183
-rw-r--r--noncore/games/zbounce/kbounce.cpp302
-rw-r--r--noncore/games/zbounce/kbounce.h99
-rw-r--r--noncore/games/zbounce/main.cpp29
-rw-r--r--noncore/games/zbounce/opie-zbounce.control20
-rw-r--r--noncore/games/zbounce/zbounce.pro10
7 files changed, 1249 insertions, 0 deletions
diff --git a/noncore/games/zbounce/game.cpp b/noncore/games/zbounce/game.cpp
new file mode 100644
index 0000000..7a1a3cd
--- a/dev/null
+++ b/noncore/games/zbounce/game.cpp
@@ -0,0 +1,606 @@
1/*
2 * Copyright (C) 2000 Stefan Schimanski <1Stein@gmx.de>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this program; if not, write to the Free
16 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19
20#include <stdlib.h>
21#include <qtimer.h>
22#include <qpe/qpeapplication.h>
23#include <qimage.h>
24
25#include "game.h"
26
27#define TILE_SIZE 9
28
29#define TILE_FIRST ((FIELD_WIDTH-2)*(FIELD_HEIGHT-2))
30#define TILE_FREE (TILE_FIRST + 0)
31#define TILE_BORDER (TILE_FIRST + 1)
32#define TILE_WALLEND (TILE_FIRST + 2)
33#define TILE_WALLUP (TILE_FIRST + 3)
34#define TILE_WALLDOWN (TILE_FIRST + 4)
35#define TILE_WALLLEFT (TILE_FIRST + 5)
36#define TILE_WALLRIGHT (TILE_FIRST + 6)
37
38#define GAME_DELAY 15
39#define BALL_ANIM_DELAY 60
40#define WALL_DELAY 100
41
42#define MS2TICKS( ms ) ((ms)/GAME_DELAY)
43
44Arrow::Arrow(QCanvasPixmapArray* array, QCanvas* canvas)
45 : QCanvasSprite( array, canvas )
46{
47 m_vertical = true;
48 move(3,3);
49}
50
51void Arrow::update()
52{
53 if ( m_vertical )
54 setFrame( 0 );
55 else
56 setFrame( 1 );
57}
58
59void Arrow::changeDirection()
60{
61 m_vertical = ! m_vertical;
62 update();
63}
64
65
66Ball::Ball(QCanvasPixmapArray* array, QCanvas* canvas)
67 : QCanvasSprite( array, canvas ), m_animDelay( 0 ), m_soundDelay( MS2TICKS(BALL_ANIM_DELAY)/2 )
68{
69}
70
71void Ball::update()
72{
73 m_animDelay--;
74 if ( m_animDelay<=0 )
75 {
76 m_animDelay = MS2TICKS(BALL_ANIM_DELAY);
77 int frameNum = frame();
78 frameNum++;
79 if ( frameNum>=frameCount() )
80 frameNum = 0;
81 setFrame( frameNum );
82 }
83}
84
85void Ball::advance(int stage)
86{
87 bool reflectX = false;
88 bool reflectY = false;
89
90 // check for collisions
91 if ( collide(xVelocity(), 0) ) reflectX = true;
92 if ( collide(0, yVelocity()) ) reflectY = true;
93 if ( !reflectX && !reflectY && collide(xVelocity(), yVelocity()) ) reflectX = reflectY = true;
94
95 // emit collision
96 QRect r = boundingRect();
97 r.moveBy( xVelocity(), yVelocity() );
98 JezzField* field = (JezzField *)canvas();
99
100 int ul = field->tile( r.left() / TILE_SIZE, r.top() / TILE_SIZE );
101 int ur = field->tile( r.right() / TILE_SIZE, r.top() / TILE_SIZE );
102 int bl = field->tile( r.left() / TILE_SIZE, r.bottom() / TILE_SIZE );
103 int br = field->tile( r.right() / TILE_SIZE, r.bottom() / TILE_SIZE );
104
105 if ( ul!=TILE_FREE ) field->emitBallCollisiton( this, r.left() / TILE_SIZE, r.top() / TILE_SIZE, ul ); else
106 if ( ur!=TILE_FREE ) field->emitBallCollisiton( this, r.right() / TILE_SIZE, r.top() / TILE_SIZE, ur ); else
107 if ( bl!=TILE_FREE ) field->emitBallCollisiton( this, r.left() / TILE_SIZE, r.bottom() / TILE_SIZE, bl ); else
108 if ( br!=TILE_FREE ) field->emitBallCollisiton( this, r.right() / TILE_SIZE, r.bottom() / TILE_SIZE, br );
109
110 // apply reflection
111 if ( reflectX ) setXVelocity( -xVelocity() );
112 if ( reflectY ) setYVelocity( -yVelocity() );
113
114 // update field
115 update();
116 QCanvasSprite::advance( stage );
117}
118
119bool Ball::collide( double dx, double dy )
120{
121 QRect r = boundingRect();
122 r.moveBy( dx, dy );
123 JezzField* field = (JezzField *)canvas();
124
125 int ul = field->tile( r.left() / TILE_SIZE, r.top() / TILE_SIZE );
126 int ur = field->tile( r.right() / TILE_SIZE, r.top() / TILE_SIZE );
127 int bl = field->tile( r.left() / TILE_SIZE, r.bottom() / TILE_SIZE );
128 int br = field->tile( r.right() / TILE_SIZE, r.bottom() / TILE_SIZE );
129
130 return ( ul!=TILE_FREE || ur!=TILE_FREE || bl!=TILE_FREE || br!=TILE_FREE );
131}
132
133/*************************************************************************/
134
135Wall::Wall( JezzField *field, int x, int y, Direction dir, int tile, QObject *parent, const char *name )
136 : QObject( parent, name ), m_dir( dir ), m_field( field ), m_startX( x ), m_startY( y ),
137 m_tile( tile ), m_delay( MS2TICKS(WALL_DELAY)/2 ), m_active( true )
138{
139 // setup position and direction
140 m_dx = 0;
141 m_dy = 0;
142 switch ( m_dir )
143 {
144 case Up: m_dy = -1; break;
145 case Down: m_dy = 1; break;
146 case Left: m_dx = -1; break;
147 case Right: m_dx = 1; break;
148 }
149
150 m_x = m_startX;
151 m_y = m_startY;
152
153 m_field->setTile( m_x, m_y, m_tile );
154}
155
156void Wall::finish()
157{
158 m_active = false;
159}
160
161bool Wall::isFree( int x, int y )
162{
163 if ( m_field->tile(x, y)==TILE_FREE )
164 {
165 // check whether there is a ball at the moment
166 QCanvasItemList cols = m_field->collisions( QRect(x*TILE_SIZE, y*TILE_SIZE,
167 TILE_SIZE, TILE_SIZE) );
168 if ( cols.count()==0 )
169 return true;
170 }
171
172 return false;
173}
174
175void Wall::update()
176{
177}
178
179void Wall::advance()
180{
181 update();
182
183 // move wall
184 if ( m_active )
185 {
186 m_delay--;
187 if ( m_delay<=0 )
188 {
189 m_delay = MS2TICKS(WALL_DELAY);
190
191 // set previous tile
192 m_field->setTile( m_x, m_y, m_tile );
193
194 // check whether next place is still free
195 if ( isFree(m_x+m_dx, m_y+m_dy) )
196 {
197 // move ball
198 m_x += m_dx;
199 m_y += m_dy;
200
201 // set tile
202 m_field->setTile( m_x, m_y, TILE_WALLEND );
203 } else
204 {
205 finish();
206 emit finished( this, m_field->tile( m_x+m_dx, m_y+m_dy ) );
207 }
208 }
209 }
210}
211
212void Wall::fill( bool black )
213{
214 if ( m_dx )
215 {
216 for ( int x=m_startX ; x!=m_x; x+=m_dx )
217 if ( m_field->tile(x, m_startY)==m_tile )
218 m_field->setGameTile( x, m_startY, black );
219
220 m_field->setGameTile( m_x, m_startY, black );
221 } else
222 {
223 for ( int y=m_startY ; y!=m_y; y+=m_dy )
224 if ( m_field->tile(m_startX, y)==m_tile )
225 m_field->setGameTile( m_startX, y, black );
226
227 m_field->setGameTile( m_startX, m_y, black );
228 }
229}
230
231/*************************************************************************/
232
233JezzField::JezzField( QPixmap tiles, QObject* parent, const char* name )
234 : QCanvas( parent, name ), m_tiles( tiles )
235{
236 setPixmaps( tiles );
237}
238
239void JezzField::setGameTile( int x, int y, bool black )
240{
241 setTile( x, y, black ? TILE_BORDER : TILE_FREE );
242}
243
244void JezzField::setPixmaps( QPixmap tiles )
245{
246 // create new tiles
247 QPixmap allTiles( TILE_SIZE*(FIELD_WIDTH-2), TILE_SIZE*(FIELD_HEIGHT-1) );
248
249 // handle default tiles
250 bitBlt( &allTiles, 0, TILE_SIZE*(FIELD_HEIGHT-2),
251 &tiles, 0, 0, tiles.width(), tiles.height() );
252
253 // load tiles into canvas
254 setTiles( allTiles, FIELD_WIDTH, FIELD_HEIGHT, TILE_SIZE, TILE_SIZE );
255}
256
257/*************************************************************************/
258
259JezzView::JezzView(QCanvas* viewing, QWidget* parent, const char* name, WFlags f)
260 : QCanvasView( viewing, parent, name, f ), m_vertical( false )
261{
262 setResizePolicy( AutoOne );
263 setHScrollBarMode( AlwaysOff );
264 setVScrollBarMode( AlwaysOff );
265
266 setCursor( sizeHorCursor );
267}
268
269void JezzView::viewportMouseReleaseEvent( QMouseEvent *ev )
270{
271 if ( ev->button() & LeftButton )
272 {
273 emit buildWall( ev->x()/TILE_SIZE, ev->y()/TILE_SIZE, m_vertical );
274 }
275}
276
277void JezzView::changeCursor()
278{
279 m_vertical = !m_vertical;
280 if ( m_vertical )
281 {
282 setCursor( sizeVerCursor );
283 }
284 else
285 {
286 setCursor( sizeHorCursor );
287 }
288}
289
290/*************************************************************************/
291
292JezzGame::JezzGame( int ballNum, QWidget *parent, const char *name )
293 : QWidget( parent, name ), m_wall1( 0 ), m_wall2( 0 ),
294 m_text( 0 ), m_running( false ), m_percent( 0 ), m_pictured( false )
295{
296 QString path = QPEApplication::qpeDir()+"pics/zbounce/";
297
298 // load gfx
299 m_ballPixmaps = new QCanvasPixmapArray( path + "ball%1.png", 25 );
300 for ( unsigned n=0; n < m_ballPixmaps->count(); n++ )
301 m_ballPixmaps->image(n)->setOffset( 0, 0 );
302
303 m_arrowPixmaps = new QCanvasPixmapArray( path + "arrow%1.png", 2 );
304 for ( unsigned n=0; n < m_arrowPixmaps->count(); n++ )
305 m_arrowPixmaps->image(n)->setOffset( 0, 0 );
306
307 QPixmap tiles( path + "tiles.png" );
308
309 // create field
310 m_field = new JezzField( tiles, this, "m_field" );
311 m_field->resize( TILE_SIZE*FIELD_WIDTH, TILE_SIZE*FIELD_HEIGHT );
312
313 for ( int x=0; x<FIELD_WIDTH; x++ )
314 m_field->setTile( x, 0, TILE_BORDER );
315 for ( int y=1; y<FIELD_HEIGHT-1; y++ )
316 {
317 m_field->setTile( 0, y, TILE_BORDER );
318 for ( int x=1; x<FIELD_WIDTH-1; x++ )
319 m_field->setTile( x, y, TILE_FREE );
320 m_field->setTile( FIELD_WIDTH-1, y, TILE_BORDER );
321 }
322 for ( int x=0; x<FIELD_WIDTH; x++ )
323 m_field->setTile( x, FIELD_HEIGHT-1, TILE_BORDER );
324
325 connect( m_field, SIGNAL(ballCollision(Ball *, int, int, int)), this, SLOT(ballCollision(Ball *, int, int, int)) );
326
327 // create view
328 m_view = new JezzView( m_field, this, "m_view" );
329 m_view->move( 0, 0 );
330 m_view->adjustSize();
331 connect( m_view, SIGNAL(buildWall(int, int, bool)), this, SLOT(buildWall(int, int, bool)) );
332
333 // create balls
334 for ( int n=0; n<ballNum; n++ )
335 {
336 Ball *ball = new Ball( m_ballPixmaps, m_field );
337 m_balls.append( ball );
338 ball->setVelocity( ((rand() & 1)*2-1)*2, ((rand() & 1)*2-1)*2 );
339 ball->setFrame( rand() % 25 );
340 ball->move( 4*TILE_SIZE + ( rand() - 50 ) % ( (FIELD_WIDTH-8)*TILE_SIZE ),
341 4*TILE_SIZE + rand() % ( (FIELD_HEIGHT-8)*TILE_SIZE ) );
342 ball->show();
343 }
344
345 // create arrow
346 arrow = new Arrow( m_arrowPixmaps, m_field );
347 arrow->show();
348
349 // create text label
350 m_text = new QCanvasText( m_field );
351
352 // create game clock
353 m_clock = new QTimer( this );
354 connect( m_clock, SIGNAL(timeout()), this, SLOT(tick()) );
355 m_clock->start( GAME_DELAY );
356
357 // setup geometry
358 setFixedSize( m_view->size() );
359}
360
361JezzGame::~JezzGame()
362{
363 m_balls.clear();
364 delete m_view;
365 delete m_field;
366 delete m_ballPixmaps;
367}
368
369void JezzGame::display( QString text, int size )
370{
371 qDebug("This function \"display\" shouldn't be called!!!");
372 if ( !text.isEmpty() )
373 {
374 QFont font( "Helvetica", size, QFont::Bold );
375 font.setStyleHint( QFont::Helvetica );
376 m_text->setFont( font );
377 m_text->setText( text );
378
379 QRect size = m_text->boundingRect();
380 m_text->move( ( FIELD_WIDTH*TILE_SIZE - size.width() ) / 2,
381 ( FIELD_HEIGHT*TILE_SIZE - size.height() ) / 2 );
382
383 m_text->show();
384 } else
385 {
386 m_text->hide();
387 }
388}
389
390void JezzGame::start()
391{
392 m_running = true;
393}
394
395void JezzGame::stop()
396{
397 m_running = false;
398}
399
400
401void JezzGame::makeBlack()
402{
403 // copy current field into buffer
404 for ( int y=0; y<FIELD_HEIGHT; y++ )
405 for ( int x=0; x<FIELD_WIDTH; x++ )
406 m_buf[x][y] = m_field->tile( x, y );
407
408 // fill areas that contains a ball
409 for ( Ball *ball=m_balls.first(); ball!=0; ball=m_balls.next() )
410 fill( ball->x()/TILE_SIZE, ball->y()/TILE_SIZE );
411
412 // areas still free can be blacked now
413 for ( int y=0; y<FIELD_HEIGHT; y++ )
414 for ( int x=0; x<FIELD_WIDTH; x++ )
415 {
416 if ( m_buf[x][y]==TILE_FREE )
417 m_field->setGameTile( x, y, true );
418 }
419
420 m_field->update();
421 m_view->repaint();
422
423 // count percent value of occupied area
424 int p = percent();
425 if ( p!=m_percent )
426 {
427 m_percent = p;
428 emit newPercent( m_percent );
429 }
430}
431
432int JezzGame::percent()
433{
434 int notFree = 0;
435 for ( int y=1; y<FIELD_HEIGHT-1; y++ )
436 for ( int x=1; x<FIELD_WIDTH-1; x++ )
437 {
438 if ( m_field->tile(x,y)!=TILE_FREE )
439 notFree++;
440 }
441
442 return 100 * notFree / ( (FIELD_WIDTH-1) * (FIELD_HEIGHT-1) );
443}
444
445void JezzGame::fill( int x, int y )
446{
447 if ( m_buf[x][y]!=TILE_FREE) return;
448
449 // go left
450 int _x=x;
451 for ( ; m_buf[_x][y]==TILE_FREE; _x-- )
452 m_buf[_x][y] = TILE_BORDER;
453 int stopx = _x;
454
455 // fill above
456 for ( _x=x; _x>stopx; _x-- )
457 if ( m_buf[_x][y-1]==TILE_FREE ) fill( _x, y-1 );
458
459 // fill below
460 for ( _x=x; _x>stopx; _x-- )
461 if ( m_buf[_x][y+1]==TILE_FREE ) fill( _x, y+1 );
462
463 // go right
464 for ( _x=x+1; m_buf[_x][y]==TILE_FREE; _x++ )
465 m_buf[_x][y] = TILE_BORDER;
466 stopx = _x;
467
468 // fill above
469 for ( _x=x+1; _x<stopx; _x++ )
470 if ( m_buf[_x][y-1]==TILE_FREE ) fill( _x, y-1 );
471
472 // fill below;
473 for ( _x=x+1; _x<stopx; _x++ )
474 if ( m_buf[_x][y+1]==TILE_FREE ) fill( _x, y+1 );
475}
476
477void JezzGame::ballCollision( Ball*, int, int, int tile )
478{
479 if ( tile!=TILE_BORDER && tile>TILE_FREE && tile!=TILE_WALLEND )
480 {
481 // stop walls
482 if ( (tile==TILE_WALLUP || tile==TILE_WALLLEFT) && m_wall1 )
483 {
484 m_wall1->finish();
485 m_wall1->fill( false );
486 delete m_wall1;
487 m_wall1 = 0;
488 }
489
490 if ( (tile==TILE_WALLDOWN || tile==TILE_WALLRIGHT) && m_wall2 )
491 {
492 m_wall2->finish();
493 m_wall2->fill( false );
494 delete m_wall2;
495 m_wall2 = 0;
496 }
497
498 // update view
499 m_field->update();
500 m_view->repaint();
501
502 // send death msg
503 emit died();
504 }
505}
506
507void JezzGame::buildWall( int x, int y, bool vertical )
508{
509 if ( !m_running ) return;
510
511 if ( m_field->tile(x, y)==TILE_FREE )
512 {
513 // check whether there is a ball at the moment
514 QCanvasItemList cols = m_field->collisions( QRect(x*TILE_SIZE, y*TILE_SIZE, TILE_SIZE, TILE_SIZE) );
515 if ( cols.count()>0 )
516 {
517 //kdDebug() << "Direct collision" << endl;
518 emit ballCollision( (Ball*)cols.first(), x, y, TILE_WALLUP );
519 return;
520 }
521
522 // start walls
523 if ( !m_wall1 )
524 {
525 m_wall1 = new Wall( m_field, x, y,
526 vertical? Wall::Up : Wall::Left,
527 vertical? TILE_WALLUP : TILE_WALLLEFT,
528 this, "m_wall1" );
529 connect( m_wall1, SIGNAL(finished(Wall *, int)),
530 this, SLOT(wallFinished(Wall *, int)) ); }
531
532 if ( !m_wall2 )
533 {
534 m_wall2 = new Wall( m_field, x, y,
535 vertical? Wall::Down: Wall::Right,
536 vertical? TILE_WALLDOWN : TILE_WALLRIGHT,
537 this, "m_wall2" );
538 connect( m_wall2, SIGNAL(finished(Wall *, int)),
539 this, SLOT(wallFinished(Wall *, int)) );
540 }
541 }
542}
543
544void JezzGame::wallFinished( Wall *wall, int tile )
545{
546 if ( tile==TILE_WALLEND )
547 {
548 if ( m_wall1 )
549 {
550 m_wall1->fill( false );
551 delete m_wall1;
552 m_wall1 = 0;
553 }
554
555 if ( m_wall2 )
556 {
557 m_wall2->fill( false );
558 delete m_wall2;
559 m_wall2 = 0;
560 }
561 } else
562 {
563 if ( m_wall1==wall && m_wall1 )
564 {
565 m_wall1->fill( true );
566 delete m_wall1;
567 m_wall1 = 0;
568 }
569
570 if ( m_wall2==wall && m_wall2 )
571 {
572 m_wall2->fill( true );
573 delete m_wall2;
574 m_wall2 = 0;
575 }
576 }
577
578 m_field->update();
579 m_view->repaint();
580
581 makeBlack();
582}
583
584void JezzGame::tick()
585{
586 if ( m_running )
587 {
588 if ( m_field ) m_field->advance();
589 if ( m_wall1 ) m_wall1->advance();
590 if ( m_wall2 ) m_wall2->advance();
591 } else
592 {
593 for ( Ball *ball=m_balls.first(); ball!=0; ball=m_balls.next() )
594 ball->update();
595
596 if ( m_field ) m_field->update();
597 if ( m_wall1 ) m_wall1->update();
598 if ( m_wall2 ) m_wall2->update();
599 }
600}
601
602void JezzGame::changeCursor()
603{
604 arrow->changeDirection();
605 m_view->changeCursor();
606}
diff --git a/noncore/games/zbounce/game.h b/noncore/games/zbounce/game.h
new file mode 100644
index 0000000..ae0d4fa
--- a/dev/null
+++ b/noncore/games/zbounce/game.h
@@ -0,0 +1,183 @@
1/*
2 * Copyright (C) 2000 Stefan Schimanski <1Stein@gmx.de>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this program; if not, write to the Free
16 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19#ifndef GAME_H_INCLUDED
20#define GAME_H_INCLUDED
21
22#include <qwidget.h>
23#include <qcanvas.h>
24#include <qmemarray.h>
25
26class QTimer;
27class JezzField;
28
29#define FIELD_WIDTH 26
30#define FIELD_HEIGHT 26
31
32class Arrow : public QCanvasSprite
33{
34 public:
35 Arrow(QCanvasPixmapArray* array, QCanvas* canvas);
36
37 void update();
38 void changeDirection();
39
40 protected:
41 bool m_vertical;
42};
43
44class Ball : public QCanvasSprite
45{
46 public:
47 Ball(QCanvasPixmapArray* array, QCanvas* canvas);
48
49 void update();
50 void advance(int stage);
51 bool collide( double dx=0, double dy=0 );
52
53 protected:
54 int m_animDelay;
55 int m_soundDelay;
56};
57
58
59class Wall : public QObject
60{
61 Q_OBJECT
62public:
63 enum Direction { Up, Down, Left, Right };
64
65 Wall( JezzField *field, int x, int y, Direction dir, int tile,
66 QObject *parent=0, const char *name=0 );
67
68 void finish();
69 void fill( bool black );
70
71signals:
72 void finished( Wall *wall, int tile );
73
74public slots:
75 void advance();
76 void update();
77
78private:
79 bool isFree( int x, int y );
80
81 Direction m_dir;
82 JezzField *m_field;
83 int m_dx, m_dy;
84 int m_x, m_y;
85 int m_startX, m_startY;
86 int m_tile;
87 int m_delay;
88 bool m_active;
89};
90
91
92class JezzField : public QCanvas
93{
94 Q_OBJECT
95public:
96 JezzField( QPixmap tiles, QObject* parent = 0, const char* name = 0 );
97
98 void setGameTile( int x, int y, bool black );
99
100signals:
101 void ballCollision( Ball *ball, int x, int y, int tile );
102
103private:
104 friend class Ball;
105 QPixmap m_tiles;
106 QMemArray<QPixmap> m_backTiles;
107
108 void setPixmaps( QPixmap tiles );
109 void emitBallCollisiton( Ball *ball, int x, int y, int tile )
110 { emit ballCollision( ball, x, y, tile ); };
111
112};
113
114
115class JezzView : public QCanvasView
116{
117 Q_OBJECT
118public:
119 JezzView(QCanvas* viewing=0, QWidget* parent=0, const char* name=0, WFlags f=0);
120 void changeCursor();
121
122signals:
123 void buildWall( int x, int y, bool vertical );
124
125protected:
126 void viewportMouseReleaseEvent( QMouseEvent * );
127
128private:
129 bool m_vertical;
130};
131
132
133class JezzGame : public QWidget
134{
135 Q_OBJECT
136
137public:
138 JezzGame( int ballNum, QWidget *parent=0, const char *name=0 );
139 ~JezzGame();
140
141 int percent();
142 void display( QString text, int size=20 );
143 void changeCursor();
144
145signals:
146 void died();
147 void newPercent( int percent );
148
149public slots:
150 void start();
151 void stop();
152
153protected slots:
154 void tick();
155 void buildWall( int x, int y, bool vertical );
156 void wallFinished( Wall *wall, int tile );
157 void ballCollision( Ball *ball, int x, int y, int tile );
158
159protected:
160 void makeBlack();
161 void fill( int x, int y );
162 void fillLeft( int x, int y );
163 int m_buf[FIELD_WIDTH][FIELD_HEIGHT];
164
165 JezzField *m_field;
166 JezzView *m_view;
167
168 Wall *m_wall1, *m_wall2;
169
170 QList<Ball> m_balls;
171 QCanvasPixmapArray *m_ballPixmaps;
172 QCanvasPixmapArray *m_arrowPixmaps;
173 QCanvasText *m_text;
174 Arrow *arrow;
175
176 QTimer *m_clock;
177 bool m_running;
178 int m_percent;
179 bool m_pictured;
180
181};
182
183#endif
diff --git a/noncore/games/zbounce/kbounce.cpp b/noncore/games/zbounce/kbounce.cpp
new file mode 100644
index 0000000..c1c0f70
--- a/dev/null
+++ b/noncore/games/zbounce/kbounce.cpp
@@ -0,0 +1,302 @@
1/*
2 * Copyright (C) 2000 Stefan Schimanski <1Stein@gmx.de>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License,Life or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this program; if not, write to the Free
16 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19#include <qlayout.h>
20#include <qtimer.h>
21#include <qlcdnumber.h>
22#include <qmessagebox.h>
23#include <qmainwindow.h>
24#include <qpe/qpeapplication.h>
25
26#include "kbounce.h"
27#include "game.h"
28#include <qlabel.h>
29
30KJezzball::KJezzball() : QMainWindow(0), m_gameWidget( 0 )
31{
32 setCaption(tr("ZBounce"));
33 // setup variables
34 m_game.level = 1;
35 m_game.score = 0;
36 m_state = Idle;
37
38
39 menu = menuBar();
40 game = new QPopupMenu;
41 game->insertItem(tr("&New game"), this, SLOT(newGame()), Key_N );
42 game->insertItem(tr("&Pause game"), this, SLOT(pauseGame()), Key_P );
43 game->insertSeparator();
44 game->insertItem(tr("&About"), this, SLOT(about()));
45 menu->insertItem( tr("&Game"), game );
46
47 // create widgets
48 m_view = new QWidget( this, "m_view" );
49 setCentralWidget( m_view );
50
51 m_layout = new QGridLayout( m_view );
52 m_layout->setSpacing( 0 );
53 m_layout->setMargin( 0 );
54
55 ScoreLabel = new QLabel( m_view, "ScoreLabel" );
56 ScoreLabel->setText( tr( "Score: 00" ) );
57 ScoreLabel->setAlignment( int( QLabel::AlignCenter ) );
58
59 m_layout->addWidget( ScoreLabel, 1, 0 );
60
61 LivesLabel = new QLabel( m_view, "LivesLabel" );
62 LivesLabel->setText( tr( "Lives: 0%" ) );
63 LivesLabel->setAlignment( int( QLabel::AlignCenter ) );
64
65 m_layout->addWidget( LivesLabel, 1, 2 );
66
67 FilledLabel = new QLabel( m_view, "FilledLabel" );
68 FilledLabel->setText( tr( "Filled: 00%" ) );
69 FilledLabel->setAlignment( int( QLabel::AlignCenter ) );
70
71 m_layout->addWidget( FilledLabel, 1, 1 );
72
73 TimeLabel = new QLabel( m_view, "TimeLabel" );
74 TimeLabel->setText( tr( "Time: 00" ) );
75 TimeLabel->setAlignment( int( QLabel::AlignCenter ) );
76
77 m_layout->addWidget( TimeLabel, 1, 3 );
78
79 // create timers
80 m_nextLevelTimer = new QTimer( this, "m_nextLevelTimer" );
81 connect( m_nextLevelTimer, SIGNAL(timeout()), this, SLOT(switchLevel()) );
82
83 m_gameOverTimer = new QTimer( this, "m_gameOverTimer" );
84 connect( m_gameOverTimer, SIGNAL(timeout()), this, SLOT(gameOverNow()) );
85
86 m_timer = new QTimer( this, "m_timer" );
87 connect( m_timer, SIGNAL(timeout()), this, SLOT(second()) );
88
89 // create demo game
90 createLevel( 1 );
91}
92
93void KJezzball::newGame()
94{
95 // Check for running game
96 closeGame();
97 if ( m_state==Idle )
98 {
99 // update displays
100 m_game.level = 1;
101 m_game.score = 0;
102
103 setCaption(tr("ZBounce Level %1").arg(m_game.level));
104 ScoreLabel->setText( tr( "Score: %1" ).arg(m_game.score) );
105
106 // start new game
107 m_state = Running;
108
109 createLevel( m_game.level );
110 startLevel();
111 }
112}
113
114void KJezzball::about()
115{
116 QMessageBox::information( this, "About", "Written by: Stefan Schimanski\nPorted by: Martin Imobersteg\n\nThis program is distributed under\nthe terms of the GPL v2." );
117}
118
119void KJezzball::closeGame()
120{
121 if ( m_state!=Idle )
122 {
123 stopLevel();
124 m_state = Idle;
125 }
126}
127
128void KJezzball::pauseGame()
129{
130 switch ( m_state )
131 {
132 case Running:
133 m_state = Paused;
134 m_gameWidget->display( tr("Game paused.\nPress P to continue!") );
135 stopLevel();
136 break;
137
138 case Paused:
139 case Suspend:
140 m_state = Running;
141 m_gameWidget->display( QString::null );
142 startLevel();
143 break;
144
145 case Idle:
146 break;
147 }
148}
149
150void KJezzball::gameOver()
151{
152 stopLevel();
153 m_gameOverTimer->start( 100, TRUE );
154}
155
156
157void KJezzball::gameOverNow()
158{
159 m_state = Idle;
160
161 QString score;
162 score.setNum( m_game.score );
163 QMessageBox::information( this, "Game Over", tr("Game Over!\nScore: %1").arg(score) );
164}
165
166void KJezzball::focusOutEvent( QFocusEvent *ev )
167{
168 if ( m_state==Running )
169 {
170 stopLevel();
171 m_state = Suspend;
172 }
173
174 QMainWindow::focusOutEvent( ev );
175}
176
177void KJezzball::focusInEvent ( QFocusEvent *ev )
178{
179 if ( m_state==Suspend )
180 {
181 startLevel();
182 m_state = Running;
183 }
184
185 QMainWindow::focusInEvent( ev );
186}
187
188void KJezzball::second()
189{
190 m_level.time--;
191 TimeLabel->setText( tr( "Time: %1" ).arg(m_level.time) );
192 if ( m_level.time<=0 )
193 {
194 gameOver();
195 }
196}
197
198void KJezzball::died()
199{
200 m_level.lifes--;
201 LivesLabel->setText( tr( "Lives: %1" ).arg(m_level.lifes) );
202 if ( m_level.lifes==0 ) gameOver();
203}
204
205void KJezzball::newPercent( int percent )
206{
207 FilledLabel->setText( tr( "Filled: %1%" ).arg(percent) );
208 if ( percent>=75 )
209 {
210 m_level.score = m_level.lifes*15 + (percent-75)*2*(m_game.level+5);
211 nextLevel();
212 }
213}
214
215void KJezzball::createLevel( int level )
216{
217 // destroy old game
218 if ( m_gameWidget ) delete m_gameWidget;
219
220 m_gameWidget = new JezzGame( level+1, m_view, "m_gameWidget" );
221
222 m_gameWidget->show();
223 m_layout->addMultiCellWidget( m_gameWidget, 0, 0, 0, 3 );
224 connect( m_gameWidget, SIGNAL(died()), this, SLOT(died()) );
225 connect( m_gameWidget, SIGNAL(newPercent(int)), this, SLOT(newPercent(int)) );
226
227 // update displays
228 m_level.lifes = level+1;
229 LivesLabel->setText( tr( "Lives: %1" ).arg(m_level.lifes) );
230 FilledLabel->setText( tr( "Filled: 0%" ) );
231
232 m_level.time = (level+2)*30;
233 TimeLabel->setText( tr( "Time: %1" ).arg(m_level.time) );
234
235 m_level.score = 0;
236}
237
238void KJezzball::startLevel()
239{
240 if ( m_gameWidget )
241 {
242 m_timer->start( 1000 );
243 m_gameWidget->start();
244 }
245}
246
247void KJezzball::stopLevel()
248{
249 if ( m_gameWidget )
250 {
251 m_gameWidget->stop();
252 m_timer->stop();
253 }
254}
255
256void KJezzball::nextLevel()
257{
258 stopLevel();
259 m_nextLevelTimer->start( 100, TRUE );
260}
261
262void KJezzball::switchLevel()
263{
264 m_game.score += m_level.score;
265 ScoreLabel->setText( tr( "Score: %1" ).arg(m_game.score) );
266
267 QString score;
268 score.setNum( m_level.score );
269
270 QString level;
271 level.setNum( m_game.level );
272
273 QString foo = QString(
274 tr("Successfully cleared more than 75%.\n") +
275 tr("%1 points: 15 points per life\n").arg(m_level.lifes*15) +
276 tr("%1 points: Bonus\n").arg((m_gameWidget->percent()-75)*2*(m_game.level+5)) +
277 tr("%1 points: Total score\n").arg(score) +
278 tr("On to level %1.\nYou get %2 lives this time!")).arg(m_game.level+1).arg(m_game.level+2);
279
280 QMessageBox::information( this, "Success", foo );
281
282 m_game.level++;
283
284 createLevel( m_game.level );
285 startLevel();
286}
287
288void KJezzball::keyPressEvent( QKeyEvent *ev )
289{
290 if ( ev->key() == Key_Space ||
291 ev->key() == Key_Up ||
292 ev->key() == Key_Down ||
293 ev->key() == Key_Right ||
294 ev->key() == Key_Left )
295 {
296 m_gameWidget->changeCursor();
297 }
298 else
299 {
300 ev->ignore();
301 }
302}
diff --git a/noncore/games/zbounce/kbounce.h b/noncore/games/zbounce/kbounce.h
new file mode 100644
index 0000000..de41710
--- a/dev/null
+++ b/noncore/games/zbounce/kbounce.h
@@ -0,0 +1,99 @@
1/*
2 * Copyright (C) 2000 Stefan Schimanski <1Stein@gmx.de>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this program; if not, write to the Free
16 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19#ifndef KJEZZBALL_H_INCLUDED
20#define KJEZZBALL_H_INCLUDED
21
22#include <qmainwindow.h>
23#include <qmenubar.h>
24#include <qlabel.h>
25
26class JezzGame;
27class QLCDNumber;
28class QGridLayout;
29
30class KJezzball : public QMainWindow
31{
32 Q_OBJECT
33
34public:
35 KJezzball();
36
37public slots:
38 void newGame();
39 void pauseGame();
40 void closeGame();
41 void about();
42
43protected slots:
44 void died();
45 void newPercent( int percent );
46 void second();
47 void switchLevel();
48 void gameOverNow();
49
50protected:
51 void createLevel( int level );
52 void startLevel();
53 void stopLevel();
54 void nextLevel();
55 void gameOver();
56 void initXMLUI();
57
58 void focusOutEvent( QFocusEvent * );
59 void focusInEvent ( QFocusEvent * );
60 void keyPressEvent( QKeyEvent *ev );
61
62 JezzGame *m_gameWidget;
63 QWidget *m_view;
64 QGridLayout *m_layout;
65 QLCDNumber *m_levelLCD;
66 QLCDNumber *m_lifesLCD;
67 QLCDNumber *m_scoreLCD;
68 QLCDNumber *m_percentLCD;
69 QLCDNumber *m_timeLCD;
70
71 QTimer *m_timer;
72 QTimer *m_nextLevelTimer;
73 QTimer *m_gameOverTimer;
74
75 enum { Idle, Running, Paused, Suspend } m_state;
76
77 struct
78 {
79 int lifes;
80 int time;
81 int score;
82 } m_level;
83
84 struct
85 {
86 int level;
87 int score;
88 } m_game;
89private:
90 QMenuBar *menu;
91 QPopupMenu *game;
92 QLabel* ScoreLabel;
93 QLabel* LivesLabel;
94 QLabel* FilledLabel;
95 QLabel* TimeLabel;
96
97};
98
99#endif
diff --git a/noncore/games/zbounce/main.cpp b/noncore/games/zbounce/main.cpp
new file mode 100644
index 0000000..a6b7c1a
--- a/dev/null
+++ b/noncore/games/zbounce/main.cpp
@@ -0,0 +1,29 @@
1/*
2 * Copyright (C) 2000 Stefan Schimanski <schimmi@kde.org>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this program; if not, write to the Free
16 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19#include <qpe/qpeapplication.h>
20#include "kbounce.h"
21
22int main(int argc, char **argv)
23{
24 QPEApplication a( argc, argv );
25 KJezzball *top = new KJezzball;
26 a.showMainWidget(top);
27
28 return a.exec();
29}
diff --git a/noncore/games/zbounce/opie-zbounce.control b/noncore/games/zbounce/opie-zbounce.control
new file mode 100644
index 0000000..d419eaf
--- a/dev/null
+++ b/noncore/games/zbounce/opie-zbounce.control
@@ -0,0 +1,20 @@
1Files: bin/zbounce apps/Games/zbounce.desktop pics/zbounce/zbounce.png \
2pics/zbounce/arrow0000.png pics/zbounce/ball0008.png pics/zbounce/ball0018.png \
3pics/zbounce/arrow0001.png pics/zbounce/ball0009.png pics/zbounce/ball0019.png \
4pics/zbounce/ball0000.png pics/zbounce/ball0010.png pics/zbounce/ball0020.png \
5pics/zbounce/ball0001.png pics/zbounce/ball0011.png pics/zbounce/ball0021.png \
6pics/zbounce/ball0002.png pics/zbounce/ball0012.png pics/zbounce/ball0022.png \
7pics/zbounce/ball0003.png pics/zbounce/ball0013.png pics/zbounce/ball0023.png \
8pics/zbounce/ball0004.png pics/zbounce/ball0014.png pics/zbounce/ball0024.png \
9pics/zbounce/ball0005.png pics/zbounce/ball0015.png pics/zbounce/tiles.png \
10pics/zbounce/ball0006.png pics/zbounce/ball0016.png \
11pics/zbounce/ball0007.png pics/zbounce/ball0017.png \
12Version: 0.6
13Depends: opie-base ($QPE_VERSION)
14Priority: optional
15Section: opie/games
16Maintainer: Martin Imobersteg <imm@gmx.ch>
17Architecture: arm
18License: GPL
19Description: ZBounce
20 A JezzGame like game for Qtopia.
diff --git a/noncore/games/zbounce/zbounce.pro b/noncore/games/zbounce/zbounce.pro
new file mode 100644
index 0000000..4bf2058
--- a/dev/null
+++ b/noncore/games/zbounce/zbounce.pro
@@ -0,0 +1,10 @@
1 TEMPLATE= app
2 #CONFIG = qt warn_on debug
3 CONFIG = qt warn_on release
4 HEADERS = game.h kbounce.h
5 SOURCES = game.cpp kbounce.cpp main.cpp
6 INCLUDEPATH+= $(QPEDIR)/include
7 DEPENDPATH+= $(QPEDIR)/include
8LIBS += -lqpe
9DESTDIR = $(OPIEDIR)/bin
10 TARGET = zbounce