Diff: Frogger/Frogger.cpp

Revision:

44:f02510eeb165

Parent:

43:2cd1cfe07770

Child:

45:e40c4f89ed7c

--- a/Frogger/Frogger.cpp	Mon May 18 06:34:53 2020 +0000
+++ b/Frogger/Frogger.cpp	Fri May 22 06:37:50 2020 +0000
@@ -1,26 +1,18 @@
 #include "Frogger.h"
-#include "Menu.h"
-#include "GraphicEngine.h"
-#include <vector>
-#include <stdio.h> 
-#include <cstddef>
-
-bool frogLog = false;
-bool frogDie = false; // whenever the frog is above safety lane in the middle
-bool attach = false;
 
 // level one initiailization has already been done
-Frogger::Frogger(GraphicEngine *engine, Level *levelptr, Frog *frog, int grid, int w, int h)
+Frogger::Frogger(Frog *frog, int grid, int w, int h)
 {
-    this->graphics = engine; // get the renderer in place
-    this->level = levelptr; // one level object per engine
     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
@@ -34,82 +26,99 @@
 
 void Frogger::initializeLevelTwo()
 {
-    level->setupLevelTwo();
+    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
+    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
+        graphics.clear(); // clear the lcd screen
 
         runCurrentLevel(); // add velocity to level vehicles and logs
 
-        graphics->drawSafetyLanes();
-        graphics->showFrog(frog->x, frog->y, frog->width, 4); // display current position of frog
+        graphics.drawSafetyLanes();
+        graphics.showFrog(frog->x, frog->y, frog->width, frog->height); // display current position of frog
         process_input(); // user controls the frog object   
         
-        checkCurrentLevelCollision(); // check if the frog is alive
-        level->checkFrogOnWater(); // check if the frog is in the water level
+        //checkCurrentLevelCollision(); // check if the frog is alive
+        checkFrogOnWater(); // check if the frog is in the water level
             
-        graphics->refresh(); // refresh the lcd screen
+        graphics.refresh(); // refresh the lcd screen
         
-        wait_ms(75); // fpms
+        wait_ms(50); // fpms
     } 
 }
 
-void Frogger::runCurrentLevel()
-{
-    switch (current_level)
-    {
-        case 1:
-            level->levelOne();
-            break;
-        case 2:
-            level->levelTwo();
-            break;
-    }
-}
-
-void Frogger::checkCurrentLevelCollision()
-{
-    switch (current_level)
-    {
-        case 1:
-            level->levelOneCollision();
-            break;
-        case 2:
-            level->levelTwoCollision();
-            break;
-    }
-}
-
 void Frogger::process_input() {
     //determine the input 
     /* make this a switch statement */
     if(gamepad.A_pressed()){
         moveFrog(1,0);
-        level->frogOnLog = false;
+        frogOnLog = false;
     } else if(gamepad.X_pressed()){
         moveFrog(0,-1);
-        level->frogOnLog = false;
+        frogOnLog = false;
     } else if(gamepad.B_pressed()){
         moveFrog(0,1);
-        level->frogOnLog = false;
+        frogOnLog = false;
     } else if(gamepad.Y_pressed()){
         moveFrog(-1,0);
-        level->frogOnLog = false;
+        frogOnLog = false;
     } 
 }
 
@@ -129,10 +138,437 @@
     frog->down = grid + frog->y;
 }
 
-void Frogger::createGoalPost()
+/* 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, 'S', 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 < (-1 * (randCars()))) {
+        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->object.x)  ||
+    (frog->down <= object->object.y) ||
+    (frog->left_side >= object->rectangle.right_side))) {
+        checkFrogAction(object);
+    }
+}
+
+void Frogger::checkFrogAction(Object *log)
+{
+    if(frogWater) {
+        frogOnLog = true;
+        moveFrogWithLog(log);
+
+    } else { // frog is on the road 
+        frog->reset(); // crashed with car so reset
+        graphics.printLoser();
+    }
+}
+
+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()
 {
-    //graphics->drawGoalPost();
+    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, 1, 3);
+    setRowObjects(car_row_two_one, 2, 2);
+    setRowObjects(car_row_three_one, 3, 3);
+    setRowObjects(car_row_four_one, 4, 4);
+}
+
+void Frogger::setupLevelTwoRows()
+{
+    setRowObjects(car_row_one_two, 1, 4);
+    setRowObjects(car_row_two_two, 2, 3);
+    setRowObjects(car_row_three_two, 3, 4);
+    setRowObjects(car_row_four_two, 4, 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);     
+}
+