ELEC2645 (2019/20) / Mbed 2 deprecated ELEC2645_Project_el19tb

Dependencies:   mbed

Frogger/Frogger.cpp

Committer:
el19tb
Date:
2020-05-23
Revision:
47:29c4796a49e5
Parent:
46:e39abe665271
Child:
48:8ccfc74b60a5

File content as of revision 47:29c4796a49e5:

#include "Frogger.h"

// level one initiailization has already been done
Frogger::Frogger(Frog *frog, int grid, int w, int h)
{
    this->frog = frog; // one frog object per run
    
    current_level = 1;
    initializeParams(w, h, grid); // initialize the software parameters
    initializeEmbeddedSystem(); // initialize the hardware paramaters
    setupLevelOne();
}

GraphicEngine graphics;

void Frogger::initializeParams(int w, int h, int grid)
{
    // screen sizes
    lcd_w = w; // width
    lcd_h = h; // height
    state_frog = 0 ;
    
    // grid values
    grid = 4; // size of game grid system
    grid_width = 22; // size of screen width in grid units
}

void Frogger::initializeLevelTwo()
{
    setupLevelTwo();
}

void Frogger::initializeEmbeddedSystem()
{
    //game setup
    graphics.init(); // initialize the LCD object
    graphics.contrast(); // set the contrast to 0.4
    graphics.backLightOn(); // turn on the backlight

    gamepad.init();  // initialize the actual embedded system 
}

void Frogger::setupLevelOne()
{
    // vehicle objects
    setupLevelOneRow();
    setupLevelOneXPos();
    setupLevelOneSprites();    
    setupLevelOneDir();
   
    // log objects
    setupLogsLevelOne();
}

// called by frogger engine
void Frogger::setupLevelTwo()
{
    // setup vehicles
    setupLevelTwoRows();
    setupLevelTwoXPos();
    setupLevelTwoSprites();  
    setupLevelTwoDir();

    //log objects    
    setupLogLevelTwo();
}

/* SETUP CALLS */
void Frogger::setupLogsLevelOne()
{
    setLogLevelOneXPos();
    setLogLevelOneRow();
    setLogLevelOneDir();
    setLogLevelOneSprites();
}

void Frogger::setupLogLevelTwo()
{
    setLogLevelTwoXPos();
    setLogLevelTwoRow();
    setLogLevelTwoSprite();
    setLogLevelTwoDir();
}
/* SETUP CALLS */

//main function that starts the game
void Frogger::start()
{     
    //keep reading and processing user input
    while(1) {
        graphics.clear(); // clear the lcd screen

        runCurrentLevel(); // add velocity to level vehicles and logs

        graphics.drawSafetyLanes();
        
        graphics.showFrog(frog->x, frog->y, frog->width, frog->height, state_frog); // display current position of frog
        process_input(); // user controls the frog object   
        
        checkFrogOnWater(); // check if the frog is in the water level
            
        graphics.refresh(); // refresh the lcd screen
        
        wait_ms(85); // fpms
    } 
}

void Frogger::process_input() 
{
    //determine the input 
    if(gamepad.A_pressed()){
        state_frog = 1;
        moveFrog(1,0);
        frogOnLog = false;
    } else if(gamepad.X_pressed()){
        state_frog = 0;
        moveFrog(0,-1);
        frogOnLog = false;
    } else if(gamepad.B_pressed()){
        state_frog = 3;
        moveFrog(0,1);
        frogOnLog = false;
    } else if(gamepad.Y_pressed()){
        state_frog = 2;
        moveFrog(-1,0);
        frogOnLog = false;
    } 
}

void Frogger::drawFrogStates()
{
    //graphics.showFrog(frog->x, frog->y, frog->width, frog->height, state_frog); // display current position of frog
    state_frog++;
    graphics.showFrog(frog->x, frog->y, frog->width, frog->height, state_frog); // display current position of frog
    state_frog--;
}

//moves the frog around the grid
void Frogger::moveFrog(int xWay, int yWay)
{
    //increment the left side of the chicken by a value of the grid size
    frog->x += xWay * 4;
    
    //increment the top side by a value of grid sizw
    frog->y += yWay * 4;
    
    // update rect parameters
    frog->left_side = frog->x;
    frog->right_side = 6 + frog->x;
    frog->up = frog->y;
    frog->down = 4 + frog->y;
}

/* ENGINE CALLS */
void Frogger::runCurrentLevel()
{
    switch (current_level)
    {
        case 1:
            runLevelOne();
            break;
        case 2:
            runLevelTwo();
            break;
    }
}

void Frogger::runLevelOne()
{
    moveVehiclesLevelOne(); // increment the x pos and display
    moveLogsLevelOne();  
    checkFrogOnWater(); // check if the frog needs to jump on log/turtles  
}

void Frogger::runLevelTwo()
{
    moveVehiclesLevelTwo();
    moveLogsLevelTwo();
    checkFrogOnWater(); // check if it is above a certain height
}
/* ENGINE CALLS */

/* ENGINE RUN */
void Frogger::moveVehiclesLevelOne()
{
    moveVehicle(car_row_one_one, 'S', 3);
    moveVehicle(car_row_two_one, 'M', 2);
    moveVehicle(car_row_three_one, 'S', 3);
    moveVehicle(car_row_four_one, 'M', 4);    
}

void Frogger::moveVehiclesLevelTwo()
{
    moveVehicle(car_row_one_two, 'M', 4);
    moveVehicle(car_row_two_two, 'M', 3);
    moveVehicle(car_row_three_two, 'F', 4);
    moveVehicle(car_row_four_two, 'F', 3);      
}

void Frogger::moveLogsLevelOne()
{
    moveVehicle(row_one_log, 'S', 3);
    moveVehicle(row_two_log, 'M', 2);
    moveVehicle(row_three_log, 'S', 3);    
}

void Frogger::moveLogsLevelTwo()
{
    moveVehicle(level_row_one, 'F', 2);
    moveVehicle(level_row_two, 'M', 2);
    moveVehicle(level_row_two, 'F', 3);
}
/* ENGINE RUN */

void Frogger::checkFrogOnWater()
{
    if(frog->y < 84 - 4*6) // if the frog is past the safety lane
    {
        frogWater = true; // frog will die if not on turtle/log
    }
}

void Frogger::moveVehicle(Object *row, char c, int array_size)
{
    for(int i = 0; i < array_size; i++)
    {
        moveIndividualObject(&row[i], c);
        checkCollison(row[i]); // check if the frog has crashed/on log       
    }
}

void Frogger::moveIndividualObject(Object *vehicle, char c){
    switch(c)
    {
        case 'S':
            vehicle->speedSlow(vehicle->object.dir);
            break;
        case 'M':
            vehicle->speedMedium(vehicle->object.dir);
            break;  
        case 'F':
            vehicle->speedFast(vehicle->object.dir);
            break;
    }

    checkOutOfBounds(vehicle);
    checkFrogOutOfBounds();
    graphics.showObj(vehicle);  // display to screen
}
/* ENGINE RUN */

/* CHECKERS */
void Frogger::checkOutOfBounds(Object *obj)
{
    if(obj->object.x > 84 + randCars()){
        obj->object.x = -4;

    } else if(obj->object.x < (-4)) {
        obj->object.x = 84 + 4;
    }
}

void Frogger::checkFrogOutOfBounds(){
    if(frog->x > 84){
        frog->reset(); // set the frog back to the start
        graphics.printLoser();

    } else if(frog->x < 0) {
        frog->reset();
        graphics.printLoser();
    }
}

/*
void Frogger::checkCurrentLevelCollision()
{
    switch (current_level)
    {
        case 1:
            level->levelOneCollision();
            break;
        case 2:
            level->levelTwoCollision();
            break;
    }
}
*/

void Frogger::checkCollison(Object object)
{
    if(!(frog->up >= object.rectangle.bottom ||
    (frog->right_side <= object.rectangle.left_side)  ||
    (frog->down <= object.rectangle.up) ||
    (frog->left_side >= object.rectangle.right_side))) {
        checkFrogAction(object);
        graphics.print();

    }
}

void Frogger::checkFrogAction(Object log)
{
    if(frog->y < 48-4*6) {
        //frogOnLog = true;
        //moveFrogWithLog(log);
        graphics.printTest();

    } else { // frog is on the road 
        //frog->reset(); // crashed with car so reset
    }
}

void Frogger::moveFrogWithLog(Object *log)
{
    switch (log->object.dir)
    {
        case 1:
            frog->x += log->speed;
            break;
            
        case 2:
            frog->x -= log->speed;
            break;
    }
}

/* CHECKERS */

/* X POS */
void Frogger::setupLevelOneXPos()
{
    setupRowDistance(car_row_one_one, 20 , 3);
    setupRowDistance(car_row_two_one, 25, 2);
    setupRowDistance(car_row_three_one, 30, 3);
    setupRowDistance(car_row_four_one, 25, 4);  
}

void Frogger::setLogLevelOneXPos()
{
    setupRowDistance(row_one_log, 20, 3);
    setupRowDistance(row_two_log, 30, 2);
    setupRowDistance(row_three_log, 25, 3);
}

void Frogger::setLogLevelTwoXPos()
{
    setupRowDistance(level_row_one, 20, 2);
    setupRowDistance(level_row_two, 30, 2);
    setupRowDistance(level_row_three, 25, 3);
}

void Frogger::setupLevelTwoXPos()
{
    setupRowDistance(car_row_one_two, 15, 4);
    setupRowDistance(car_row_two_two, 20, 3);
    setupRowDistance(car_row_three_two, 25, 4);
    setupRowDistance(car_row_four_two, 25, 3);  
}

void Frogger::setupRowDistance(Object *objects, int dis, int array_size)
{
    for(int i = 0; i < array_size; i++)
    {
        setDistance(&objects[i], dis);
        dis += dis; // ensure that each object has appropriate seperation        
    }  
}

void Frogger::setDistance(Object *object, int dis)
{
    object->setSeperation(dis);
}
/* X POS */

/* ROW */

void Frogger::setupLevelOneRow()
{
    setRowObjects(car_row_one_one, 2, 3);
    setRowObjects(car_row_two_one, 3, 2);
    setRowObjects(car_row_three_one, 4, 3);
    setRowObjects(car_row_four_one, 5, 4);
}

void Frogger::setupLevelTwoRows()
{
    setRowObjects(car_row_one_two, 2, 4);
    setRowObjects(car_row_two_two, 3, 3);
    setRowObjects(car_row_three_two, 4, 4);
    setRowObjects(car_row_four_two, 5, 3);
}

void Frogger::setLogLevelOneRow()
{
    setRowObjects(row_one_log, 7, 3);
    setRowObjects(row_two_log, 8, 2);
    setRowObjects(row_three_log, 9, 3);
}

void Frogger::setLogLevelTwoRow()
{
    setRowObjects(level_row_one, 7, 2);
    setRowObjects(level_row_two, 8, 2);
    setRowObjects(level_row_three, 9, 3);
}

void Frogger::setRowObjects(Object *objects, int row, int array_size)
{
    for(int i = 0; i < array_size; i++)
    {
        createRow(&objects[i], row);        
    }  
}

void Frogger::createRow(Object *object, int row)
{
    object->setRow(row);  
}
/* ROW */

/* SPRITES */
void Frogger::setupLevelOneSprites()
{
    setSpriteObjects(car_row_one_one, 'X', 3);
    setSpriteObjects(car_row_two_one, 'N', 2);
    setSpriteObjects(car_row_three_one, 'B', 3);
    setSpriteObjects(car_row_four_one, 'R', 4);  
}

void Frogger::setupLevelTwoSprites()
{
    setSpriteObjects(car_row_one_two, 'R', 4);
    setSpriteObjects(car_row_two_two, 'L', 3);
    setSpriteObjects(car_row_three_two, 'N', 4);
    setSpriteObjects(car_row_four_two, 'X', 3);  
}

void Frogger::setLogLevelOneSprites()
{
    setSpriteObjects(row_one_log, 'G',3);
    setSpriteObjects(row_two_log, 'M', 2);
    setSpriteObjects(row_three_log, 'G', 3);
}

void Frogger::setLogLevelTwoSprite()
{
    setSpriteObjects(level_row_one, 'G', 2);
    setSpriteObjects(level_row_two, 'M', 2);
    setSpriteObjects(level_row_three, 'G', 3);
}

void Frogger::setSpriteObjects(Object *objects, char c, int array_size)
{
    for(int i = 0; i < array_size; i++)
    {
        setSprite(&objects[i], c);
    }    
}

void Frogger::setSprite(Object *object, char c)
{
   object->setSprite(c);  
}
/* SPRITES */

/* DIR */
void Frogger::setupLevelOneDir()
{
    setDirObjects(car_row_one_one, 2, 3);
    setDirObjects(car_row_two_one, 1, 2);
    setDirObjects(car_row_three_one, 2, 3);
    setDirObjects(car_row_four_one, 1, 4);  
}

void Frogger::setupLevelTwoDir()
{
    setDirObjects(car_row_one_two, 1, 4);
    setDirObjects(car_row_two_two, 2, 3);
    setDirObjects(car_row_three_two, 1, 4);
    setDirObjects(car_row_four_two, 2, 3);  
}

void Frogger::setLogLevelOneDir()
{
    setDirObjects(row_one_log, 1, 3);
    setDirObjects(row_two_log, 2, 2);
    setDirObjects(row_three_log, 1, 3);
}

void Frogger::setLogLevelTwoDir()
{
    setDirObjects(level_row_one, 1, 2);
    setDirObjects(level_row_two, 2, 2);
    setDirObjects(level_row_three, 1, 3);
}

void Frogger::setDirObjects(Object *objects, int dir, int array_size)
{
   for(int i = 0; i < array_size; i++)
    {
        setDir(&objects[i], dir);
    }    
}

void Frogger::setDir(Object *object, int dir)
{
    object->setDir(dir);  
}
/* DIR */

// so the user does not predict when the next car is coming
int Frogger::randCars()
{
    return (rand() % 4) + 1;
}

void Frogger::createMultipleSafetyLane()
{

}

void Frogger::createSafetyObject()
{
     
}

void Frogger::drawSafety()
{
    //graphics.drawSafetyLanes(safety_lane);   
}


void Frogger::createMultipleRoadLane()
{
   
}

// every level is going to have the same amount of blocks
void Frogger::createRoadLane()
{       
    
}

void Frogger::drawRoadObjects()
{
    //graphics.getRoadObjects(roads);
}

void Frogger::createMultipleLanesWater()
{ 
 
  
}

void Frogger::createWaterLane(){
 
}

// moves the water based on the velocity
void Frogger::moveWater()
{
   
    //loopWater(water_lanes); 
}


void Frogger::loopWater()
{ 
  
}

void Frogger::drawWater()
{
   // graphics.drawWater(water);         
}

void Frogger::drawEndPost()
{
    //graphics.drawGoal(84/2)-grid/2, 48-grid*11);     
}