Maxint R&D / Mbed 2 deprecated RETRO_BallAndHoles

Retro game that let's the player steer a ball through a hole filled maze. Has multiple levels of increasing difficulty.

Dependencies:   LCD_ST7735 MusicEngine RETRO_BallsAndThings mbed

Ball and Holes

In this game I attempted to create somewhat natural movement of the ball by implementing gravity and friction which combined over time determine the speed of the ball. Playing with the settings (aka. the magic numbers) that are spread out all over game.cpp, gives different effects, such as an icy, rough or liquid-like surface.

It took some time to figure out how to post my very first youtube video. Sorry for the shaky recording. Trying to record the video with my phone while playing the game in one hand was quite challenging, but here it is;

The left and right buttons are used to cheat: restart the current or go to the next level. Up and down control the game-tick. During game-play the robot-button shows the accelerator graph and the ship-button mutes the sound.

BTW. If your ball happens to get stuck, tilting the console in the opposite direction will set it free. For sake of argument: these magnetic wall-ends are in the words of Bob Ross "a happy accident". Since there is no specific code for it, others might call it a bug. As it results in more interesting game-play, I didn't attempt to fix it, but left a comment for those who dare to look at the mess I call code.

Game.cpp

Committer:
maxint
Date:
2015-02-03
Revision:
2:d4de5a5866fe
Parent:
1:c1ee4c699517
Child:
3:ca8b21da67dc

File content as of revision 2:d4de5a5866fe:

#include "Game.h"

const char* Game::LOSE_1 = "You lose.";
const char* Game::LOSE_2 = "Press ship to restart.";
const char* Game::SPLASH_1 = "-*- Balls and paddle -*-";
const char* Game::SPLASH_2 = "Press ship to start.";
const char* Game::SPLASH_3 = "Made by Maxint";


#define WHITE Color565::White
#define BLACK Color565::Black
#define BLUE Color565::Blue
#define RED Color565::Red
#define YELLOW Color565::Yellow

#define CHAR_WIDTH 8
#define CHAR_HEIGHT 8
#define HEIGHT this->disp.getHeight()
#define WIDTH this->disp.getWidth()



Game::Game() : left(P0_14, PullUp), right(P0_11, PullUp), down(P0_12, PullUp), up(P0_13, PullUp), square(P0_16, PullUp), circle(P0_1, PullUp), led1(P0_9), led2(P0_8), 
    ain(P0_15), i2c(P0_5, P0_4), disp(P0_19, P0_20, P0_7, P0_21, P0_22, P1_15, P0_2, LCD_ST7735::RGB), accel(this->I2C_ADDR, &disp), vGravity(0, 0.1), ball(&disp), paddle(&disp)
{
    this->disp.setOrientation(LCD_ST7735::Rotate270, false);
    this->disp.setForegroundColor(WHITE);
    this->disp.setBackgroundColor(BLACK);
    this->disp.clearScreen();

    srand(this->ain.read_u16());
    
    this->lastUp = false;
    this->lastDown = false;
    this->mode = true;


    //this->aBalls[2]={ Ball(&disp),  Ball(&disp) };
    for(int i=0; i<NUM_BALLS; i++)
        this->aBalls[i]=Ball(&(this->disp));

    //this->initialize();
}

void Game::printDouble(double value, int x, int y)
{
    char buffer[10];
    int len = sprintf(buffer, "%.1f ", value);
    
    this->disp.drawString(font_oem, x, y, buffer);
}

void Game::initialize()
{
    this->disp.clearScreen();

//    this->initializeBall();     // start first ball
//    this->initializeBalls();     // start first ball

    this->setNoBalls();     // reset all balls
    this->newBall();     // start first ball
    this->initializePaddle();
    //this->paddle.draw();

       
//    this->paddleX = WIDTH / 2 - Game::PADDLE_WIDTH / 2;
    this->snd.reset();
    this->nLives = 4;
    this->nScore = 0;
    
    this->tWait.start();      // start the timer
    
}


void Game::initializePaddle()
{
    this->paddle.initialize(WIDTH / 2 - Game::PADDLE_WIDTH/2, HEIGHT - Game::PADDLE_HEIGHT, Game::PADDLE_WIDTH, Game::PADDLE_HEIGHT);
    this->paddle.draw();
}


void Game::updatePaddle()
{
    if (!this->left.read())  // note: read is LOW (0) when button pressed
        this->paddle.move(Vector(-1 * Game::PADDLE_SPEED, 0));
    else if (!this->right.read())
        this->paddle.move(Vector(Game::PADDLE_SPEED, 0));
    else
    {
        int i=this->checkTilt();
        if(i>0)
            this->paddle.move(Vector(Game::PADDLE_SPEED, 0));
        else if(i<0)
            this->paddle.move(Vector(-1 * Game::PADDLE_SPEED, 0));
        else if(this->paddle.hasChanged())
            paddle.move(Vector(0, 0));  // move to same place to restrict redraws
    }
}




/*
void Game::initializeBall()
{
    this->ball.initialize(WIDTH / 2 - Game::BALL_RADIUS, HEIGHT / 4 - Game::BALL_RADIUS, Game::BALL_RADIUS, Color565::fromRGB(0xFF, 0x33, 0x33));
    this->ball.setSpeed(rand() % 2 ? 1 : -1, rand() % 2 ? 1 : -1);
}
*/

/*
void Game::initializeBalls()
{
    for(int i=0; i<NUM_BALLS; i++)
    {
        this->aBalls[i].initialize(WIDTH / 2 - Game::BALL_RADIUS, HEIGHT / 4 - Game::BALL_RADIUS, Game::BALL_RADIUS, Color565::fromRGB(i==0?0xFF:0x33, i==1?0xFF:0x33, i==2?0xFF:0x33));
        //float ftRandX=rand() % 2 ? 1 : -1;
        float ftRandX=((rand() % 20) - 10)/10 ;
        float ftRandY=rand() % 2 ? 1 : -1;
        this->aBalls[i].setSpeed(ftRandX, ftRandY);
    }
}
*/

void Game::setNoBalls()
{
    for(int i=0; i<NUM_BALLS; i++)
        this->aBalls[i].fActive=false;
}

void Game::newBall()
{
    for(int i=0; i<NUM_BALLS; i++)
    {
        if(this->aBalls[i].fActive)
            continue;
        else
        {
            this->aBalls[i].initialize(WIDTH / 2 - Game::BALL_RADIUS, HEIGHT / 4 - Game::BALL_RADIUS, Game::BALL_RADIUS, Color565::fromRGB(i==0?0xFF:0x33, i==1?0xFF:0x33, i==2?0xFF:0x33));
            //float ftRandX=rand() % 2 ? 1 : -1;
            //float ftRandY=rand() % 2 ? 1 : -1;
            float ftRandX=((rand() % 20) - 10)/5.0;
            float ftRandY=((rand() % 10) - 10)/5.0;
            //this->aBalls[i].setSpeed(ftRandX, ftRandY);
            this->aBalls[i].vSpeed.set(ftRandX, ftRandY);
            this->aBalls[i].fActive=true;
            break;
        }
    }
}

void Game::updateBalls()
{
    for(int i=0; i<NUM_BALLS; i++)
    {
        if(!this->aBalls[i].fActive)
            continue;

        this->aBalls[i].update();                    // update the ball position 

        // add downward gravity
        if(this->aBalls[i].vSpeed.getSize() != 0 && this->aBalls[i].vSpeed.getSize()<10.0)            // TODO: added if statement to allow zero speed pause of ball
            this->aBalls[i].vSpeed.add(this->vGravity);    // add some gravity

    }
}

void Game::redrawBalls()
{
    for(int i=0; i<NUM_BALLS; i++)
    {
        if(!this->aBalls[i].fActive)
            continue;
        this->aBalls[i].redraw();                    // update the ball position 
    }
}

int Game::countBalls()
{
    int nResult=0;
    for(int i=0; i<NUM_BALLS; i++)
    {
        if(this->aBalls[i].fActive)
            nResult++;
    }
    return(nResult);
}





void Game::tick()
{  
    this->checkButtons();
    
    if (this->mode) {
/*
        if(this->tWait.read_ms()>100)
        {
            this->updatePaddle();
            this->tWait.reset();
        }
*/

/*
        if(this->ball.vSpeed.getSize() != 0)            // TODO: added if statement to allow zero speed pause of ball
            this->ball.vSpeed.add(this->vGravity);    // add some gravity
            //this->ball.vSpeed.add(Vector(0, 0.1));    // add some gravity
        this->ball.update();                    // update the ball position 
*/

        this->updateBalls();                    // update the ball positions

        this->updatePaddle();
    
//        this->checkCollision();
        this->checkPaddle();
        this->checkBallsCollision();
//        this->ball.redraw();
        this->redrawBalls();
        this->paddle.redraw();
        
        this->snd.checkPwm();
        //this->checkScore(); 
        this->checkLives(); 
        
        wait_ms(25);
    }
    else {
        this->accel.updateGraph();
        wait_ms(100);
    } 
}

int Game::checkTilt()
{    // move the paddle by tilting the board left or righr
    double x, y, z;
    //int nStart=this->tWait.read_ms();
    this->accel.getXYZ(x, y, z);

    //printDouble((double)this->tWait.read_ms()-nStart, 10, 10);
/*
printDouble(x, 0, 0);
char buf[256];
sprintf(buf,"tilt:%0.1f", x);
this->drawString(buf, DisplayN18::HEIGHT / 2 - DisplayN18::CHAR_HEIGHT / 2 + 4*DisplayN18::CHAR_HEIGHT ); 
*/

    if(x<-0.1) return(-1);
    else if(x>0.1) return(1);
    else return(0);
}

void Game::checkButtons()
{
    if (!this->square.read())
    {
        this->mode = !this->mode;
        
        //this->disp.clear();
        this->disp.clearScreen();
        
        if (!this->mode)
        {
            this->accel.resetGraph();
        }
        
        this->led1.write(this->mode);
        this->led2.write(!this->mode);
    }
    else
    {  
        bool isUp = !this->up.read();
        bool isDown = !this->down.read();
        
        if (isUp && isDown) goto end;
        if (!isUp && !isDown) goto end;
        
        if (isUp && this->lastUp) goto end;
        if (isDown && this->lastDown) goto end;
        
        if (isUp)
        {
            this->ball.changeSpeed(true);
        }
        else if (isDown)
        {
            this->ball.changeSpeed(false);
        }
    
end:
        this->lastUp = isUp;
        this->lastDown = isDown;
    }
}

void Game::drawString(const char* str, int y)
{
    uint8_t width;
    uint8_t height;
    
    this->disp.measureString(font_oem, str, width, height);
    this->disp.drawString(font_oem, WIDTH / 2 - width / 2, y, str);
    
}

void Game::showSplashScreen() {
    this->drawString(Game::SPLASH_1, HEIGHT / 2 - CHAR_HEIGHT / 2);  
    this->drawString(Game::SPLASH_2, HEIGHT / 2 + CHAR_HEIGHT / 2); 
    this->drawString(Game::SPLASH_3, HEIGHT / 2 + CHAR_HEIGHT / 2 + 2*(8)); 
           
    while (this->circle.read())
    {
int i=this->checkTilt();
char buf[256];
sprintf(buf,"  tilt:%d  ", i);
this->drawString(buf, HEIGHT / 2 - CHAR_HEIGHT / 2 + (4*CHAR_HEIGHT) ); 

        wait_ms(1);
    }
        
    //this->disp.clearScreen();
    this->initialize();     // start a new game
}



void Game::checkBallsCollision()
{
    Rectangle rTop=Rectangle(0, -10, WIDTH, 0);                // Rectangle(0, 0, WIDTH, 1);       // top wall
    Rectangle rBottom=Rectangle(0, HEIGHT, WIDTH, HEIGHT+10);  // Rectangle(0, HEIGHT, WIDTH, HEIGHT);       // bottom gap
    Rectangle rLeft=Rectangle(-10, 0, 0, HEIGHT);              // Rectangle(0, 0, 0, HEIGHT);       // left wall
    Rectangle rRight=Rectangle(WIDTH, 0, WIDTH+10, HEIGHT);       // Rectangle(WIDTH, 0, WIDTH, HEIGHT);       // right wall
    Rectangle rPaddle=Rectangle(paddle.pos.getX(), paddle.pos.getY(), paddle.pos.getX() + Game::PADDLE_WIDTH, HEIGHT+10);       // Rectangle(this->paddleX, HEIGHT - Game::PADDLE_HEIGHT, this->paddleX + Game::PADDLE_WIDTH, HEIGHT);       // paddle
    Rectangle rPaddleLeft=Rectangle(paddle.pos.getX(), paddle.pos.getY(), paddle.pos.getX() + Game::PADDLE_WIDTH/3, HEIGHT+10);      // paddle left part
    Rectangle rPaddleRight=Rectangle(paddle.pos.getX()+ Game::PADDLE_WIDTH/3 + Game::PADDLE_WIDTH/3, paddle.pos.getY(), paddle.pos.getX() + Game::PADDLE_WIDTH, HEIGHT+10);      // paddle right part
    //Rectangle rScreen=Rectangle(0,0, WIDTH, HEIGHT);            // screen boundary

    Ball* pBall;
    for(int i=0; i<NUM_BALLS; i++)
    {
        if(!this->aBalls[i].fActive)
            continue;

        pBall=&(this->aBalls[i]);

        if(pBall->collides(rTop) && pBall->vSpeed.isUp())      // top wall
        {
            pBall->Bounce(Vector(1,-1));        // bounce vertical
            this->snd.beepShort();
        }
        if(pBall->collides(rRight) && pBall->vSpeed.isRight())      // right wall
        {
            pBall->Bounce(Vector(-1,1));        // bounce horizontal
            this->snd.beepShort();
        }
        if(pBall->collides(rLeft) && pBall->vSpeed.isLeft())      // left wall
        {
            pBall->Bounce(Vector(-1,1));        // bounce horizontal
            this->snd.beepShort();
        }
        if(pBall->collides(rPaddle) && pBall->vSpeed.isDown())      // paddle
        {
            if(pBall->collides(rPaddleLeft))   pBall->vSpeed.add(Vector(-1,0));       // left side of paddle has bias to the left
            if(pBall->collides(rPaddleRight))  pBall->vSpeed.add(Vector(1,0));       // right side of paddle has bias to the right
    
            
            // increase the speed of the ball when hitting the paddle to increase difficulty
            //pBall->Bounce(Vector(1,-1));        // bounce vertical at same speed
            float ftSpeedMax=3.0;
            if(this->nScore>50)
                ftSpeedMax=5.0;
            if(this->nScore>100)
                ftSpeedMax=10.0;
            if(this->nScore>150)
                ftSpeedMax=999.0;
            if(pBall->vSpeed.getSize()<ftSpeedMax)            // TODO: added if statement to allow zero speed pause of ball
                pBall->Bounce(Vector(1,-1.02));        // bounce from paddle at higher speed
            else
                pBall->Bounce(Vector(1,-1));        // bounce vertical at same speed
    
            this->snd.beepLong();
            this->nScore++;
            this->printf(100, 0, "Score: %d ", this->nScore);   

            if(this->nScore>0 && this->nScore%10==0)
            {
                this->newBall();
                this->nLives++;
            }
        }
        if(pBall->collides(rBottom) && pBall->vSpeed.isDown())      // bottom gap
        {
            pBall->clearPrev();   // clear the ball from its previous position
            pBall->clear();   // clear the ball from its current position
            pBall->vSpeed.set(0,0);
            pBall->fActive=false;
            this->nLives--;
            //this->initializeBall();     // start a new ball
            if(countBalls()==0)
            {
                this->newBall();     // start a new ball
                this->snd.beepLow();
            }
        }
    }
}

void Game::checkPaddle()
{
    Rectangle rScreen=Rectangle(0,0, WIDTH, HEIGHT);            // screen boundary

    this->paddle.checkBoundary(rScreen);
}

/*
void Game::checkCollision()
{
    Rectangle rTop=Rectangle(0, -10, WIDTH, 0);                // Rectangle(0, 0, WIDTH, 1);       // top wall
    Rectangle rBottom=Rectangle(0, HEIGHT, WIDTH, HEIGHT+10);  // Rectangle(0, HEIGHT, WIDTH, HEIGHT);       // bottom gap
    Rectangle rLeft=Rectangle(-10, 0, 0, HEIGHT);              // Rectangle(0, 0, 0, HEIGHT);       // left wall
    Rectangle rRight=Rectangle(WIDTH, 0, WIDTH+10, HEIGHT);       // Rectangle(WIDTH, 0, WIDTH, HEIGHT);       // right wall
    Rectangle rPaddle=Rectangle(paddle.pos.getX(), paddle.pos.getY(), paddle.pos.getX() + Game::PADDLE_WIDTH, HEIGHT+10);       // Rectangle(this->paddleX, HEIGHT - Game::PADDLE_HEIGHT, this->paddleX + Game::PADDLE_WIDTH, HEIGHT);       // paddle
    Rectangle rPaddleLeft=Rectangle(paddle.pos.getX(), paddle.pos.getY(), paddle.pos.getX() + Game::PADDLE_WIDTH/3, HEIGHT+10);      // paddle left part
    Rectangle rPaddleRight=Rectangle(paddle.pos.getX()+ Game::PADDLE_WIDTH/3 + Game::PADDLE_WIDTH/3, paddle.pos.getY(), paddle.pos.getX() + Game::PADDLE_WIDTH, HEIGHT+10);      // paddle right part
    Rectangle rScreen=Rectangle(0,0, WIDTH, HEIGHT);            // screen boundary

    this->paddle.checkBoundary(rScreen);
   
    if(ball.collides(rTop) && this->ball.vSpeed.isUp())      // top wall
    {
        this->ball.Bounce(Vector(1,-1));        // bounce vertical
        this->snd.beepShort();
    }
    if(ball.collides(rRight) && this->ball.vSpeed.isRight())      // right wall
    {
        this->ball.Bounce(Vector(-1,1));        // bounce horizontal
        this->snd.beepShort();
    }
    if(ball.collides(rLeft) && this->ball.vSpeed.isLeft())      // left wall
    {
        this->ball.Bounce(Vector(-1,1));        // bounce horizontal
        this->snd.beepShort();
    }
    if(ball.collides(rPaddle) && this->ball.vSpeed.isDown())      // paddle
    {
        if(ball.collides(rPaddleLeft))   ball.vSpeed.add(Vector(-1,0));       // left side of paddle has bias to the left
        if(ball.collides(rPaddleRight))  ball.vSpeed.add(Vector(1,0));       // right side of paddle has bias to the right

        ball.Bounce(Vector(1,-1));        // bounce vertical at same speed
        //ball.Bounce(Vector(1,-1.05));        // bounce from paddle at higher speed

        this->snd.beepLong();
        this->nScore++;
        this->printf(100, 0, "Score: %d ", this->nScore);   
    }
    if(ball.collides(rBottom) && this->ball.vSpeed.isDown())      // bottom gap
    {
        ball.clearPrev();   // clear the ball from its previous position
        this->nLives--;
        this->initializeBall();     // start a new ball
    }
}
*/

void Game::printf(int x, int y, const char *szFormat, ...)
{
    char szBuffer[256];
    va_list args;

    va_start(args, szFormat);
    vsprintf(szBuffer, szFormat, args);
    va_end(args);
    this->disp.drawString(font_oem, x, y, szBuffer);
}


void Game::checkLives() {
    if (this->nLives == 0) {
        this->disp.clearScreen();
        
        this->drawString(Game::LOSE_1, HEIGHT / 2 - CHAR_HEIGHT); 
        this->drawString(Game::LOSE_2, HEIGHT / 2);  
        
        this->snd.playTune();
        while (this->circle.read())
            wait_ms(1);
            
        this->initialize();
    }
    else {
        this->printf(0, 0, "%d", this->nLives);   
    }
}