File content as of revision 12:d68c757d829a:

#include "Engine.h"

#define LEVEL_ONE 2
#define LEVEL_TWO 3
#define LEVEL_THREE 4
#define LEVEL_FOUR 5
#define LEVEL_FIVE 6

Engine::Engine()
{
    collisions = 0;
    wave_counter = 0;
    star = true;
    ammo = 3;
    pauses = 3;
}

Engine::~Engine()
{
}


// Initialization function:

void Engine::init(int speed, N5110 &lcd, Gamepad &pad)
{
    _speed = speed;

    _friendly.init();       // friendly ship initialization
    _enemy1.init(_speed);    // enemy ships initialization
    _enemy2.init(_speed);
    _enemy3.init(_speed);
    _enemy4.init(_speed);
    _enemy5.init(_speed);
    _enemy6.init(_speed);
}

void Engine::read_input(Gamepad &pad)
{
    _d = pad.get_direction();
    _mag = pad.get_mag();
}


// ::: DRAWING FUNCTIONS :::

void Engine::draw_all(N5110 &lcd)
{
    _stats.draw_grid(lcd);                  // initial grid and border generation
    _stats.draw_health(lcd);                // health counter generation (initial state)
    _stats.check_health(lcd, collisions);   // health counter generation (later states)
    _stats.check_star(lcd, star);           // star generation
    _stats.check_rocket(lcd, ammo);         // rocket generation
    _stats.draw_wave_counter(lcd, wave_counter);    // wave counter generation 
    _friendly.draw(lcd);                    // friendly ship generation
    _enemy1.draw(lcd);
    _enemy2.draw(lcd);
    _enemy3.draw(lcd);
    _enemy4.draw(lcd);
    _enemy5.draw(lcd);
    _enemy6.draw(lcd);                        // enemy ships generation
}

// State change checker:

void Engine::check_all(N5110 &lcd, Gamepad &pad)
{
    check_enemy_pass(pad);            // checks if enemy passed screen border and generates another
    check_death_all(lcd, pad);          // checks for collisions and eventual friendly death
    check_rocket();             // checks if rockets should be replenished
    check_star();               // checks if star should be replenished
    check_level_two(lcd, pad);        // checks if level two has been reached, same for below
    check_level_three(lcd, pad);
    check_level_four(lcd, pad);
    check_level_five(lcd, pad);
    check_pause(lcd, pad);
    check_mode_toggle(lcd, pad); 
}


// Dynamic object position/velocity updater:

void Engine::update_all(N5110 &lcd, Gamepad &pad)
{
    _friendly.update(_d,_mag);
    _friendly.check_pos();  
    _enemy1.update();
    _enemy2.update();
    _enemy3.update();
    _enemy4.update();
    _enemy5.update();
    _enemy6.update();
}


// Function to enable shooting and eliminating enemy ships:

void Engine::shoot_rocket(N5110 &lcd, Gamepad &pad)
{
    Vector2D friendly_pos = _friendly.get_pos();
    int _x = friendly_pos.x+6;
    int _y = friendly_pos.y+3;
    _rocket.init(_x, _y);
    
    if ((pad.check_event(Gamepad::B_PRESSED) == true) &&
        (ammo > 0))
    {    
        rocket_shot_trigger = true;
    }
    
    if (rocket_shot_trigger == true) 
    {   
        _rocket.draw(lcd);
        check_enemy_death(pad);
        pad.tone(1500.0,0.1);
        ammo = ammo - 1;
        rocket_shot_trigger = false;
    }
}


void Engine::shoot_star(N5110 &lcd, Gamepad &pad)
{   
    if ((pad.check_event(Gamepad::A_PRESSED) == true) &&
        (star == true))
    {    
        _enemy1.init(_speed);
        _enemy2.init(_speed);
        _enemy3.init(_speed);
        _enemy4.init(_speed);
        _enemy5.init(_speed);
        _enemy6.init(_speed);
        wave_counter = wave_counter + 1;
        pad.tone(2000.0,0.5);
        star = false;
    }
}


// Checks if (each) enemy ship passed off screen and re-initializes ones that have: (Wave counter associated with enemy1)

void Engine::check_enemy_pass(Gamepad &pad)
{
    Vector2D enemy1_pos = _enemy1.get_pos();
    
    if (enemy1_pos.x < 0) 
    {
        _enemy1.init(_speed);
        wave_counter = wave_counter + 1;
        rocket_regen_trigger = false;
        star_regen_trigger = false;
    }
    
    Vector2D enemy2_pos = _enemy2.get_pos();
    
    if (enemy2_pos.x < 0) 
    {
        _enemy2.init(_speed);
    }
    
    Vector2D enemy3_pos = _enemy3.get_pos();
    
    if (enemy3_pos.x < 0) 
    {
        _enemy3.init(_speed);
    }
    
    Vector2D enemy4_pos = _enemy4.get_pos();
    
    if (enemy4_pos.x < 0) 
    {
        _enemy4.init(_speed);
    }
    
    Vector2D enemy5_pos = _enemy5.get_pos();
    
    if (enemy5_pos.x < 0) 
    {
        _enemy5.init(_speed);
    }
    
    Vector2D enemy6_pos = _enemy6.get_pos();
    
    if (enemy6_pos.x < 0) 
    {
        _enemy6.init(_speed);
    }
}


// Checks if enemy ship has been destroyed:

void Engine::check_enemy_death(Gamepad &pad)
{
    Vector2D friendly_pos = _friendly.get_pos();
    
    if (friendly_pos.y < 5) 
    {
        _enemy1.init(_speed);
    } 
    else if ((friendly_pos.y < 11) &&
            (friendly_pos.y > 4))
    {
        _enemy2.init(_speed);
    }
    else if ((friendly_pos.y < 17) &&
            (friendly_pos.y > 10))
    {
        _enemy3.init(_speed);
    }
    else if ((friendly_pos.y < 25) &&
            (friendly_pos.y > 16))
    {
        _enemy4.init(_speed);
    }
    else if ((friendly_pos.y < 31) &&
            (friendly_pos.y > 24))
    {
        _enemy5.init(_speed);
    }
    else
    {
        _enemy6.init(_speed);
    }    
}


// Checks for collisions between friendly and enemy ship: (Associates collisions counter)

void Engine::check_friendly_death(Gamepad &pad, Vector2D enemy_pos)
{
    Vector2D friendly_pos = _friendly.get_pos();
    
    if ((friendly_pos.y >= enemy_pos.y-5) && // change 5 to friendly size and 6 to ship size
        (friendly_pos.y <= enemy_pos.y+5) && 
        (friendly_pos.x+6 >= enemy_pos.x) && 
        (friendly_pos.x+6 <= enemy_pos.x+5)) 
    {
        pad.tone(800.0,0.1);
        collisions = collisions + 1;
    }
}


// Checks for collisions between friendly and each enemy ship:

void Engine::check_death_all(N5110 &lcd, Gamepad &pad)
{
    Vector2D enemy1_pos = _enemy1.get_pos();
    Vector2D enemy2_pos = _enemy2.get_pos();
    Vector2D enemy3_pos = _enemy3.get_pos();
    Vector2D enemy4_pos = _enemy4.get_pos();
    Vector2D enemy5_pos = _enemy5.get_pos();
    Vector2D enemy6_pos = _enemy6.get_pos();
    
    check_friendly_death(pad, enemy1_pos);
    check_friendly_death(pad, enemy2_pos);
    check_friendly_death(pad, enemy3_pos);
    check_friendly_death(pad, enemy4_pos);
    check_friendly_death(pad, enemy5_pos);
    check_friendly_death(pad, enemy6_pos);
    check_gameover(lcd, pad);    // game over sequence, if health subzero
}

// 

void Engine::check_rocket()
{
    if ((ammo < 3) &&
        (rocket_regen_trigger == false)) 
    {    
            if ((wave_counter == 5) ||
                (wave_counter == 10) ||
                (wave_counter == 15) ||
                (wave_counter == 20) ||
                (wave_counter == 25) ||
                (wave_counter == 30) ||
                (wave_counter == 40) ||
                (wave_counter == 50) ||
                (wave_counter == 75) ||
                (wave_counter == 100) ||
                (wave_counter == 150) ||
                (wave_counter == 200)) 
            {        
            ammo = ammo + 1;
            rocket_regen_trigger = true;    
            }     
    }
}

void Engine::check_star()
{
    if ((star == false) &&
        (star_regen_trigger == false)) 
    {    
            if ((wave_counter == 5) ||
                (wave_counter == 25) ||
                (wave_counter == 50) ||
                (wave_counter == 100) ||
                (wave_counter == 150) ||
                (wave_counter == 200)) 
            {        
            star = true;
            star_regen_trigger = true;    
            }     
    }
}



// Level two sequence, occurs if wave 5 is reached:

void Engine::check_level_two(N5110 &lcd, Gamepad &pad)
{
    if (wave_counter == 5) 
    {
        lcd.drawRect(0,0,84,48,FILL_WHITE);
        lcd.printString(" Nice! Level 2",0,1);
        lcd.printString("  Press Back!  ",0,4);
        lcd.refresh();
        wait(1);
        
        while (pad.check_event(Gamepad::BACK_PRESSED) == false) {
            wait(0.1);
        }
        
        init(LEVEL_TWO, lcd, pad);
        wave_counter = 6;
    }
}


// Level three sequence, occurs if wave 25 is reached:

void Engine::check_level_three(N5110 &lcd, Gamepad &pad)
{
    if (wave_counter == 25) 
    {
        lcd.drawRect(0,0,84,48,FILL_WHITE);
        lcd.printString(" Nice! Level 3",0,1);
        lcd.printString("  Press Back!  ",0,4);
        lcd.refresh();
        wait(1);
        
        while (pad.check_event(Gamepad::BACK_PRESSED) == false) {
            wait(0.1);
        }
        
        init(LEVEL_THREE, lcd, pad);
        wave_counter = 26;
    }
}


// Level three sequence, occurs if wave 50 is reached:

void Engine::check_level_four(N5110 &lcd, Gamepad &pad)
{
    if (wave_counter == 50) 
    {
        lcd.drawRect(0,0,84,48,FILL_WHITE);
        lcd.printString(" Nice! Level 4",0,1);
        lcd.printString("  Press Back!  ",0,4);
        lcd.refresh();
        wait(1);
        
        while (pad.check_event(Gamepad::BACK_PRESSED) == false) {
            wait(0.1);
        }
        
        init(LEVEL_FOUR, lcd, pad);
        wave_counter = 51;
    }
}


// Level five sequence, occurs if wave 100 is reached:

void Engine::check_level_five(N5110 &lcd, Gamepad &pad)
{
    if (wave_counter == 100) 
    {
        lcd.drawRect(0,0,84,48,FILL_WHITE);
        lcd.printString(" 5. Good Luck!",0,1);
        lcd.printString("  Press Back!  ",0,4);
        lcd.refresh();
        wait(1);
        
        while (pad.check_event(Gamepad::BACK_PRESSED) == false) {
            wait(0.1);
        }
        
        init(LEVEL_FIVE, lcd, pad);
        wave_counter = 101;
    }
}


// Pause sequence, checks if the game has been paused/unpaused

void Engine::check_pause(N5110 &lcd, Gamepad &pad)
{   
    if ((pad.check_event(Gamepad::START_PRESSED) == true) &&
        (pauses > 0)) 
    {       
        while (pad.check_event(Gamepad::START_PRESSED) == false) {
            pad.leds_on();
            lcd.inverseMode();
            wait(0.5);
            pad.leds_off();
            lcd.normalMode();
            wait(0.5);
        }
    pauses = pauses - 1;
    }
}


void Engine::check_mode_toggle(N5110 &lcd, Gamepad &pad)
{
    if (pad.check_event(Gamepad::R_PRESSED) == true) {
            lcd.normalMode();
            pad.tone(1000.0,0.2);
    }
    
    if (pad.check_event(Gamepad::L_PRESSED) == true) {
            lcd.inverseMode();
            pad.tone(1000.0,0.2);
    }
}


// Game over sequence, ends game if health is below zero:

void Engine::check_gameover(N5110 &lcd, Gamepad &pad)
{
    if (collisions >= 6) 
    {
        lcd.drawRect(0,0,84,48,FILL_WHITE);
        char buffer[14];
        int length = sprintf(buffer,"  Score: %2d",wave_counter);
        lcd.printString(buffer,0,2);
        lcd.printString("  You Lose! ",0,1);
        lcd.printString("  Press Back! ",0,4);
        lcd.refresh();
        wait(1);
        while (pad.check_event(Gamepad::BACK_PRESSED) == false) {
            wait(0.1);
        }
        init(LEVEL_ONE, lcd, pad);
        collisions = 0;
        wave_counter = 0;
        ammo = 3;
        pauses = 3;
        star = true;
    }
}