File content as of revision 8:52794de935b2:

#include "CrossyChicken.h"
#include "Menu.h"
#include "GraphicEngine.h"
#include <vector>
#include <stdio.h> 
#include <cstddef>

// start from the top (height)
Gamepad gamepad;

//create three class: CAR LANE, SAFETY LANE, OBSTACLE LANE(water)
//random
//algoritmic way of generating lanes

//size of each each tile in the game
int grid = 4;

//make one object of chicken
//use this to move around the lcd
Chicken chicken((84/2)-grid/2, 48-grid, grid);
Chicken *chickenptr= &chicken;

//there will be multiple cars       
Car firstLane[2];
Car secondLane[2];  
Car thirdLane[3];
Car fourthLane[3];
Car log1Lane[2];
Car lo[2];
Car logger[2];

int screenW = 84;
int screenH = 48;

//class that whill show objects
GraphicEngine graphics(chickenptr);

bool frogLog = false;
bool frogDie = false; // whenever the frog is above safety lane in the middle
bool attach = false;

//main function that starts the game
void CrossyChicken::start(){     
    //game setup
    graphics.init();
    graphics.contrast(); 
    graphics.backLightOn();
    gamepad.init();
    
    //first lane of left racers
    firstLane[0].setSeperation(0);
    firstLane[1].setSeperation(20);
    firstLane[0].setRow(2);
    firstLane[1].setRow(2);
    
    secondLane[0].setSeperation(0);
    secondLane[1].setSeperation(20);
    secondLane[0].setRow(3);
    secondLane[1].setRow(3);
    
    thirdLane[0].setSeperation(0);
    thirdLane[1].setSeperation(20);
    thirdLane[2].setSeperation(40);
    thirdLane[0].setRow(4);
    thirdLane[1].setRow(4);
    thirdLane[2].setRow(4);
    
    fourthLane[0].setSeperation(10);
    fourthLane[1].setSeperation(30);
    fourthLane[2].setSeperation(50);
    fourthLane[0].setRow(5);
    fourthLane[1].setRow(5);
    fourthLane[2].setRow(5);
    
    // log lane 1
    log1Lane[0].setSeperation(0);
    log1Lane[1].setSeperation(20);
    log1Lane[0].setRow(7);
    log1Lane[1].setRow(7);
    
    // log lane 2
    lo[0].setSeperation(10);
    lo[1].setSeperation(30);
    lo[0].setRow(8);
    lo[1].setRow(8);
    
    // log lane 3
    logger[0].setSeperation(0);
    logger[1].setSeperation(20);
    logger[0].setRow(9);
    logger[1].setRow(9);


    //keep reading and processing user input
    while(1) {
        graphics.clear();
          
        for(int i = 0; i < 2; i++){
            moveCar(&firstLane[i], 2, (-2)); // change x position (moving)
        }
        
        for(int x = 0; x < 2; x++){
            moveCar(&secondLane[x], 1, 1);
        }
        
        for(int t = 0; t < 3; t++){
            moveCar(&thirdLane[t], 2, 1);
        }
        
        for(int c = 0; c < 3; c++){
            moveCar(&fourthLane[c], 2, 1);
        }
        
        for(int v = 0; v < 2; v++){
            moveCar(&log1Lane[v], 1, 1);
        }
       
        for(int b = 0; b < 2; b++){
            moveCar(&lo[b], 2, 1);
            moveCar(&logger[b], 2, 2);

        }
        
        graphics.showCar(firstLane);
        graphics.showCar(secondLane);
        graphics.showCar(thirdLane);
        graphics.showCar(fourthLane);
        graphics.showCar(log1Lane);
        graphics.showCar(lo);
        //graphics.showCar(logger);
        
        graphics.showChicken(); 
        process_input();
        
        // now when the chicken is above the safety 
        // lane we need to ensure that it only can go on logs
        if(chicken.y < screenH - grid*6){
            frogDie = true;  // frog can die if it is in water  

            //if it is not in a log
            for(int x = 0; x < 2; x++){
                setCollision(&log1Lane[x]);
                
                if(attach){
                    frogOnLog(&log1Lane[x]);   
                }
            }
            
            if(!attach){
                graphics.print();    
            }
            
        }
                

        graphics.refresh();
        wait_ms(200);
    } 
}

// log intersects then frog.x = log[i].speed
// frog is attached function
// detach the frog when user goes up or down
// if the frog is back to the safe zone detatch also
// whenever the frog moves detach
//A moves right
//X moves upward
//B moves downward
//Y moves left
void CrossyChicken::process_input() {
    //determine the input 
    /* make this a switch statement */
    if(gamepad.A_pressed()){
        moveChicken(1,0);
        attach = false;
    } else if(gamepad.X_pressed()){
        moveChicken(0,-1);
        attach = false;
    } else if(gamepad.B_pressed()){
        moveChicken(0,1);
        attach = false;
    } else if(gamepad.Y_pressed()){
        moveChicken(-1,0);
        attach = false;
    } 
}

// make the frog move same speed as log
// if the frog moves then detach
void CrossyChicken::frogOnLog(Car *log) {
   // if(log->seperation != 0){
        chicken.x += 0.4;
   // }     
}

//moves the chicken around the grid
void CrossyChicken::moveChicken(int xWay, int yWay){
    //increment the left side of the chicken by a value of the grid size
    chicken.x += xWay * 4;
    
    //increment the top side by a value of grid sizw
    chicken.y += yWay * 4;
    
    chicken.left_side = chicken.x;
    chicken.right_side = grid + chicken.x;
    chicken.up = chicken.y;
    chicken.down = grid + chicken.y;
        
    //display the new state of the chicken
    graphics.showChicken();
    
    //wait_ms(30);
}

void CrossyChicken::moveCar(Car *car, int dir, int x) {
    car->speedMedium(dir, x);
    
    // check if car goes out of bounds
    if(car->vehicle.x > 84+grid){
        car->vehicle.x = -4;
        
    } else if(car->vehicle.x < -4){ 
        car->vehicle.x = 84 + grid;
    }
}

// debug
void CrossyChicken::setCollision(Car *car){
    
    float other_bottom = car->vehicle.height + car->vehicle.y;
    
    
    if(!(chicken.up >= other_bottom || 
    (chicken.right_side <= car->vehicle.x)  ||
    (chicken.down <= car->vehicle.y) ||
    chicken.left_side >= (car->vehicle.width + car->vehicle.x))){
        graphics.printTest();
        
        if(chicken.y < screenH - grid*6){
            attach = true;
        } else { 
            attach = false;
        } 
    }
}
 
bool CrossyChicken::returnCollision(Car* log){      
    
    float ob= log->vehicle.height + log->vehicle.y;
    
    if(!(chicken.up >= ob||
    (chicken.right_side <= log->vehicle.x)  ||
    (chicken.down <= log->vehicle.y) ||
    chicken.left_side >= (log->vehicle.width + log->vehicle.x))){
        return true;
    }
}