Resource -> OResource

4 files changed, 10 insertions, 13 deletions

diff --git a/noncore/games/snake/interface.cpp b/noncore/games/snake/interface.cpp
index 9d9550a..1eeb337 100644
--- a/noncore/games/snake/interface.cpp
+++ b/noncore/games/snake/interface.cpp
@@ -1,219 +1,219 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "interface.h"
 
-#include <qpe/resource.h>
+#include <opie2/oresource.h>
 
 #include <qtoolbar.h>
 #include <qtoolbutton.h>
 
 SnakeGame::SnakeGame(QWidget* parent, const char* name, WFlags f) :
     QMainWindow(parent,name,f),
     canvas(232, 258)
 {
     setCaption( tr("Snake") );
     QPEApplication::setInputMethodHint(this, QPEApplication::AlwaysOff );
-    QPixmap bg = Resource::loadPixmap("snake/grass");
+    QPixmap bg = Opie::Core::OResource::loadPixmap("snake/grass");
     canvas.setBackgroundPixmap(bg);
     canvas.setUpdatePeriod(100);
     snake = 0;
 
     cv = new QCanvasView(&canvas, this);
 
     pauseTimer = new QTimer(this);
     connect(pauseTimer, SIGNAL(timeout()), this, SLOT(wait()) );
 
     setToolBarsMovable( FALSE );
 
     QToolBar* toolbar = new QToolBar( this);
     toolbar->setHorizontalStretchable( TRUE );
 
-    QPixmap newicon = Resource::loadPixmap("ksnake");
+    QPixmap newicon = Opie::Core::OResource::loadPixmap("ksnake");
     setIcon(newicon);
     (void)new QToolButton(newicon, tr("New Game"), 0,
                             this, SLOT(newGame()), toolbar, "New Game");
 
     scorelabel = new QLabel(toolbar);
     showScore(0);
     scorelabel->setBackgroundMode( PaletteButton );
     scorelabel->setAlignment( AlignRight | AlignVCenter | ExpandTabs );
     toolbar->setStretchableWidget( scorelabel );
 
     setFocusPolicy(StrongFocus);
 
     setCentralWidget(cv);
 
     QTimer::singleShot( 16, this, SLOT(welcomescreen()) );
     gamestopped = true;
     waitover = true;
 }
 
 SnakeGame::~SnakeGame()
 {
    delete snake;
 }
 
 void SnakeGame::resizeEvent(QResizeEvent *)
 {
     QSize s = centralWidget()->size();
     int fw = style().defaultFrameWidth();
     canvas.resize( s.width() - fw - 2, s.height() - fw - 2);
 }
 
 void SnakeGame::welcomescreen()
 {
    QCanvasText* title = new QCanvasText(tr("SNAKE!"), &canvas);
    title->setColor(yellow);
    title->setFont( QFont("times", 18, QFont::Bold) );
    int w = title->boundingRect().width();
    title->move(canvas.width()/2 -w/2, canvas.height()/2-110);
    title->show();
-   QCanvasPixmapArray* titlearray = new QCanvasPixmapArray(Resource::findPixmap("snake/title"));
+   QCanvasPixmapArray* titlearray = new QCanvasPixmapArray(Opie::Core::OResource::findPixmap("snake/title"));
    QCanvasSprite* titlepic = new QCanvasSprite(titlearray, &canvas);
    titlepic->move(canvas.width()/2 - 33, canvas.height()/2-85);
    titlepic->show();
    QCanvasText* instr = new QCanvasText(tr("Use the arrow keys to guide the\n"
 				  "snake to eat the mouse. You must not\n"
 			          "crash into the walls, edges or its tail."),
 					&canvas);
    w = instr->boundingRect().width();
    instr->move(canvas.width()/2-w/2, canvas.height()/2-20);
    instr->setColor(white);
    instr->show();
    QCanvasText* cont = new QCanvasText(tr("Press any key to start"), &canvas);
    w = cont->boundingRect().width();
    cont->move(canvas.width()/2-w/2, canvas.height()-20);
    cont->setColor(yellow);
    cont->show();
 
 }
 
 void SnakeGame::newGame()
 {
     clear();
     snake = new Snake(&canvas);
     connect(snake, SIGNAL(dead()), this, SLOT(gameOver()) );
     connect(snake, SIGNAL(targethit()), this, SLOT(levelUp()) );
     connect(snake, SIGNAL(scorechanged()), this, SLOT(scoreInc()) );
     connect(this, SIGNAL(moveFaster()), snake, SLOT(increaseSpeed()) );
     last = 0;
     targetamount = 1;
     notargets = 1;
     level = 1;
     stage = 1;
     showScore(0);
     gamestopped = false;
     waitover = true;
     int y = canvas.height()-50;
     (void)new Obstacle(&canvas, 32);
     (void)new Obstacle(&canvas, y);
     createTargets();
 }
 
 
 void SnakeGame::showScore(int score)
 {
     scorelabel->setText(tr("     Score :    %1   ").arg(score) );
 }
 
 
 void SnakeGame::scoreInc()
 {
    showScore( snake->getScore() );
 }
 
 void SnakeGame::levelUp()
 {
    notargets--;
    if (notargets == 0) {
         stage++;
        if (stage == 3) {
           level++;
           emit moveFaster();
           targetamount++;
           stage = 0;
        }
        createTargets();
    }
 }
 
 void SnakeGame::createTargets()
 {
    for (int i = 0; i < targetamount; i++)
        (void)new Target(&canvas);
    notargets = targetamount;
 }
 
 void SnakeGame::clear()
 {
    delete snake;
    snake = 0;
    QCanvasItemList l = canvas.allItems();
    for (QCanvasItemList::Iterator it=l.begin(); it!=l.end(); ++it) {
         delete *it;
    }
 }
 
 void SnakeGame::gameOver()
 {
    int score = snake->getScore();
    QString scoreoutput="";
    scoreoutput.setNum(score);
    QCanvasText* gameover = new QCanvasText(tr("GAME OVER!\n Your Score: %1").arg( scoreoutput), &canvas);
 
    gameover->setZ(100);
    gameover->setColor(yellow);
    gameover->setFont( QFont("times", 18, QFont::Bold) );
    int w = gameover->boundingRect().width();
    gameover->move(canvas.width()/2 -w/2, canvas.height()/2 -50);
    gameover->show();
    gamestopped = true;
    waitover = false;
    pauseTimer->start(1500);
 }
 
 void SnakeGame::wait()
 {
    waitover = true;
    pauseTimer->stop();
    QCanvasText* cont = new QCanvasText(tr("Press any key to begin a new game."),
                                        &canvas);
    cont->setZ(100);
    cont->setColor(white);
    int w = cont->boundingRect().width();
    cont->move(canvas.width()/2 -w/2, canvas.height()/2);
    cont->show();
 }
 
 void SnakeGame::keyPressEvent(QKeyEvent* event)
 {
    if (gamestopped) {
         if (waitover)
            newGame();
         else
            return;
    }
    else {
        int newkey = event->key();
        snake->go(newkey);
    }
 }
 
diff --git a/noncore/games/snake/obstacle.cpp b/noncore/games/snake/obstacle.cpp
index 4bdefa5..4639f5c 100644
--- a/noncore/games/snake/obstacle.cpp
+++ b/noncore/games/snake/obstacle.cpp
@@ -1,70 +1,68 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "obstacle.h"
 #include "codes.h"
 
-#include <qpe/resource.h>
-
-
+#include <opie2/oresource.h>
 
 Obstacle::Obstacle(QCanvas* canvas, int y)
          : QCanvasSprite(0,canvas)
 {
     newObstacle(y);
 } 
 
 void Obstacle::newObstacle(int y)
 {
-   QPixmap obstaclePix( Resource::findPixmap("snake/wall.png") );
+   QPixmap obstaclePix( Opie::Core::OResource::findPixmap("snake/wall") );
    
    if ( obstaclePix.width() > canvas()->width()*3/5 ) {
        int w = canvas()->width()*3/5;
        w = w - w % 16;
        obstaclePix.resize( w, obstaclePix.height() );
    }
 
    QList<QPixmap> pixl;
    pixl.append( &obstaclePix );
 
    QPoint nullp;
    QList<QPoint> pl;
    pl.append( &nullp );
    
    QCanvasPixmapArray* obstaclearray = new QCanvasPixmapArray(pixl, pl);
    setSequence(obstaclearray);
    
    int x = ( canvas()->width() - obstaclePix.width() )/2;
    x = x - x % 16;
    y = y - y % 16;
    move(x, y);
    setZ( -100 );
    show();
    canvas()->update();
 }
  
 int Obstacle::rtti() const
 {
    return obstacle_rtti;
 }
 
 Obstacle::~Obstacle()
 {
 }
diff --git a/noncore/games/snake/snake.cpp b/noncore/games/snake/snake.cpp
index 8a683ab..802951c 100644
--- a/noncore/games/snake/snake.cpp
+++ b/noncore/games/snake/snake.cpp
@@ -1,234 +1,233 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "snake.h"
 #include "target.h"
 
-#include <qpe/resource.h>
-
+#include <opie2/oresource.h>
 
 static int Piecekey[4][4] = { {6, 0, 4, 3 }, {0, 6, 2, 1 }, { 1, 3, 5, 0 }, {2, 4, 0, 5 } };
 
 Snake::Snake(QCanvas* c)
 {
    canvas = c; 
    score = 0;
    snakelist.setAutoDelete(true);
    autoMoveTimer = new QTimer(this);
    connect( autoMoveTimer, SIGNAL(timeout()), this, SLOT(moveSnake()) );
    createSnake();
 }
 
 void Snake::createSnake()
 {
    snakeparts = new QCanvasPixmapArray();
-   QString s0 = Resource::findPixmap("snake/s0001");
+   QString s0 = Opie::Core::OResource::findPixmap("snake/s0001");
    s0.replace(QRegExp("0001"),"%1");
    snakeparts->readPixmaps(s0, 15);
  
    grow = 0;
    last = Key_Right;
  
    QCanvasSprite* head = new QCanvasSprite(snakeparts, canvas );
    head->setFrame(7);
    snakelist.insert(0, head);
    head->show();
    head->move(34, 16);
  
    QCanvasSprite* body = new QCanvasSprite(snakeparts, canvas );
    body->setFrame(6);
    snakelist.append( body );
    body->show();
    body->move(18, 16);
  
    QCanvasSprite* end = new QCanvasSprite(snakeparts, canvas );
    end->setFrame(11);
    snakelist.append( end );
    end->show();
    end->move(2, 16);
  
    currentdir = right; 
    speed = 250;
    autoMoveTimer->start(speed);
    moveSnake();
 }
 
 void Snake::increaseSpeed()
 {
    if (speed > 150) 
        speed = speed - 5;
    autoMoveTimer->start(speed);
 }
 
 void Snake::go(int newkey)
 {
    // check key is a direction
    if (!( (newkey == Key_Up) || (newkey == Key_Left) || 
           (newkey == Key_Right) || (newkey == Key_Down) ))
         return;
    // check move is possible   
    if ( ((currentdir == left) && ((newkey == Key_Right) || (newkey == Key_Left)) ) ||
         ((currentdir == right) && ((newkey == Key_Left) || (newkey == Key_Right)) ) ||
         ((currentdir == up) && ((newkey == Key_Down) || (newkey == Key_Up)) ) ||
         ((currentdir == down) && ((newkey == Key_Up) || (newkey == Key_Down)) ) )
        return;
    else {
        Snake::changeHead(newkey);
        Snake::moveSnake();
    }
 }   
 
 void Snake::move(Direction dir)
 {
    autoMoveTimer->start(speed);
    int x = 0;
    int y = 0;
    newdir = dir;
    switch (dir) {
       case right: x = 16; break;
       case left: x = -16; break;
       case down: y = 16; break;
       case up: y = -16; break;
    }
    int index = lookUpPiece(currentdir, newdir);
    QCanvasSprite* sprite = new QCanvasSprite(snakeparts, canvas );
    sprite->setFrame(index);
    snakelist.insert(1, sprite);
    sprite->move(snakelist.first()->x(), snakelist.first()->y() );
 
    snakelist.first()->moveBy(x, y);
    if (grow <= 0)
       changeTail();
    else
       grow--;
    sprite->show();
  
    currentdir = dir;
 }                
 
 void Snake::changeTail()
 {
    snakelist.removeLast();
  
    double lastx = snakelist.last()->x();
    double prevx = snakelist.prev()->x();
    int index = 0;
  
      if ( prevx == lastx ) {  //vertical
          if ( snakelist.prev()->y() > snakelist.last()->y() )
               index = 13;
          else
               index = 14;
      } else {  //horizontal
          if (snakelist.prev()->x() > snakelist.last()->x() )
               index = 11;
          else
               index = 12;
      }
  
      snakelist.last()->setFrame(index);
 }
  
 void Snake::changeHead(int lastkey)
 {
    int index = 0;
    last = lastkey;
  
    switch (last)
    {
       case Key_Up: index = 10; break;
       case Key_Left: index = 8;  break;
       case Key_Right: index = 7; break;
       case Key_Down: index = 9;  break;
    }
  
     if (index) {
        snakelist.first()->setFrame(index);
     }
 }
 
 // returns an integer corresponding to a particular type of snake piece
 int Snake::lookUpPiece(Direction currentdir, Direction newdir)
 {
    return Piecekey[currentdir][newdir];
 }
  
 void Snake::extendSnake()
 {
    grow++;
 }         
 
 void Snake::moveSnake()
 {
    switch (last)
    {
       case Key_Up: move(up); break;
       case Key_Left: move(left);  break;
       case Key_Right: move(right); break;
       case Key_Down: move(down);  break;
     }
     detectCrash();
 }
 
 void Snake::detectCrash()
 {
     QCanvasSprite* head = snakelist.first();
     QCanvasItem* item;
     QCanvasItemList l=head->collisions(FALSE);
     for (QCanvasItemList::Iterator it=l.begin(); it!=l.end(); ++it) {
        item = *it;
        // check if snake hit target
        if ( (item->rtti()== 1500 ) && (item->collidesWith(head)) ) {
               Target* target = (Target*) item;
               target->done();
               emit targethit();
               extendSnake();
               setScore(5); 
               return;
        }
        // check if snake hit obstacles
        if ( (item->rtti()==1600) && (item->collidesWith(head)) ) {
              emit dead();
              autoMoveTimer->stop();
              return;
        }
     }
     //check if snake hit itself
     for (uint i = 3; i < snakelist.count(); i++) {
        if (head->collidesWith(snakelist.at(i)) ) {
             emit dead(); 
             autoMoveTimer->stop();
             return;
        }
    }
    //check if snake hit edge
    if ( (head->x() > canvas->width()-5) || (head->y() > canvas->height()-10)
          || (head->x() <2) || (head->y() <-5) ) {
         emit dead(); 
         autoMoveTimer->stop();
         return; 
    }
 } 
 
 void Snake::setScore(int amount)
 { 
    score = score + amount;
    emit scorechanged();
 }
diff --git a/noncore/games/snake/target.cpp b/noncore/games/snake/target.cpp
index a09af69..f20eb93 100644
--- a/noncore/games/snake/target.cpp
+++ b/noncore/games/snake/target.cpp
@@ -1,77 +1,77 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "target.h"
 #include "codes.h"
 
-#include <qpe/resource.h>
+#include <opie2/oresource.h>
 
 #include <stdlib.h>
 
 Target::Target(QCanvas* canvas) 
        : QCanvasSprite(0, canvas)
 {
-   mouse = new QCanvasPixmapArray(Resource::findPixmap("snake/mouse"));
+   mouse = new QCanvasPixmapArray(Opie::Core::OResource::findPixmap("snake/mouse"));
    setSequence(mouse);
    newTarget();
 }
 
 void Target::newTarget()
 {
    static bool first_time = TRUE;
    if (first_time) {
          first_time = FALSE;
          QTime midnight(0, 0, 0);
          srand(midnight.secsTo(QTime::currentTime()) );
     }
    do {
      int x = rand() % (canvas()->width()-10);
      x = x - (x % 16) + 2;
      int y = rand() % (canvas()->height()-10);
      y = y - (y % 16) + 2;
      move(x, y);
    } while (onTop());  
    show();
 }
 
 bool Target::onTop()
 {
    QCanvasItem* item;
    QCanvasItemList l= canvas()->allItems(); //collisions(FALSE);
    for (QCanvasItemList::Iterator it=l.begin(); it!=l.end(); ++it) {
           item = *it; 
           if (item != this && item->collidesWith(this)) return true;
       }
    return false;
 }
 
 void Target::done()
 {
    delete this;
 }
 
 int Target::rtti() const
 {
    return target_rtti;
 }
 
 Target::~Target()
 {
 }