File content as of revision 40:90c7a893d513:

#include "RosenEngine.h"

DigitalIn A(PTB9);

// Constructor
RosenEngine::RosenEngine()
{

}
// Destructor
RosenEngine::~RosenEngine()
{

}


void RosenEngine::init(int ship_width,int ship_height,int ship_speed,int ship_xpos,int ship_ypos)
{
    // initialise the game parameters
    _ship.init(ship_width,ship_height,ship_speed,ship_xpos,ship_ypos);
    _no_shooters = 0;
    _no_seekers = 0;
    _enemy.init(_no_shooters,_no_seekers);
    _menu.init(16);
    _health.init(_shipno);
    _times_run = 0;
    _score = 0;
    _dead = false;
    _intro = false;
    _wait_time = 10.25;

}
void RosenEngine::reset()
{
    _enemy.init(_no_shooters,_no_seekers);
    _health.init(_shipno);
    _wait_time = 10.25;
    _times_run = 0;
    _score = 0;
    _no_shooters = 0;
    _dead = false;
    _no_seekers = 0;
}

void RosenEngine::read_input(Gamepad &pad)
{
    Vector2D mapped_coord = pad.get_coord();
    _xjoystick = mapped_coord.x;
    _yjoystick = mapped_coord.y;
    _d = pad.get_direction();
    wait(0.1);
    // printf("_xjoystick ,_yjoystick = %f , %f\n",_xjoystick, _yjoystick);
}

void RosenEngine::draw(N5110 &lcd, Gamepad &pad)
{
    lcd.drawRect(0,0,78,48,FILL_TRANSPARENT);
    _health.draw_health(lcd,_shipno);
    _health.draw_shields(lcd);
    _enemy.draw_seeker(lcd);
    _enemy.draw_shooter(lcd);
    _enemy.draw_shw(lcd,pad);
    Vector2D inde = find_closest1();
    int index = inde.x;
    Vector2D closest = find_closest2(index);
    if(_shipno == 0) {
        _ship.set_dimensions(9,6);
        _ship.draw_ship(lcd,_shipno);
        _weapons.draw(lcd,pad,_shipno,closest);
    }
    if(_shipno == 1) {
        _ship.set_dimensions(7,10);
        _ship.draw_ship(lcd,_shipno);
        _weapons.draw(lcd,pad,_shipno,closest);
    }
    if(_shipno == 2) {
        _ship.set_dimensions(7,10);
        _ship.draw_ship(lcd,_shipno);
        _weapons.draw(lcd,pad,_shipno,closest);
    }
    if(_dead == true) {
        game_over(lcd);
    }
    disp_points(lcd);
}

void RosenEngine::update(Gamepad &pad)
{
    _enemy.update_seeker(ship_xpos, ship_ypos);
    _enemy.update_shooter(ship_xpos, ship_ypos);
    //printf("update_shooter\n");
    _enemy.update_shw();
    if(_shipno == 0) {
        _ship.update_ship(_xjoystick,_yjoystick);
        _weapons.update();
        kestrelw_seeker_collision(pad);
    }
    //printf("if shipno == 0\n");
    if(_shipno == 1 && A == false) {
        _ship.update_ship(_xjoystick,_yjoystick);
        _weapons.update();
    }
    //printf("if shipno == 1\n");
    if(_shipno == 2) {
        _ship.update_ship(_xjoystick,_yjoystick);
        _weapons.update();
    }
    // test();
    shooter_ship_collision(pad);
    seeker_ship_collision(pad);
    shooterw_ship_collision(pad);
    imperionw_seeker_collision(pad);
    kestrelw_shooter_collision(pad);
    imperionw_shooter_collision(pad);
    orionw_collision(pad);
    check_health();
    rand_no();
    scaling(timer(12));

}
void RosenEngine::get_pos()
{
    Vector2D ship_pos = _ship.get_pos();
    ship_xpos = ship_pos.x;
    ship_ypos = ship_pos.y;

    _seeker1_pos = _enemy.get_seekerpos(1);
    _seeker2_pos = _enemy.get_seekerpos(2);
    _seeker3_pos = _enemy.get_seekerpos(3);

    _shooter1_pos = _enemy.get_shooterpos(1);
    _shooter2_pos = _enemy.get_shooterpos(2);
    _shooter3_pos = _enemy.get_shooterpos(3);

    _weapons.init(ship_xpos, ship_ypos, ship_width);
    _ycursor = _menu.get_ycursor();

    if(_shipno == 0) {
        ship_width = 9;
        ship_height = 6;
    }
    if(_shipno == 1) {
        ship_width = 7;
        ship_height = 10;
    }
}
void RosenEngine::title(N5110 &lcd)
{
    _menu.title(lcd,_shipno);
    _menu.update(_d);
}
int RosenEngine::get_ycursor()
{
    _ycursor = _menu.get_ycursor();
    return _ycursor;
}
int RosenEngine::get_shipno()
{
    _shipno = _menu.get_xcursor();
    return _shipno;
}
void RosenEngine::ship_select(N5110 &lcd)
{
    _menu.update(_d);
    _menu.disp_ships(lcd);
}
bool RosenEngine::check_collision(int xpos1, int ypos1,int width1,int height1,int xpos2, int ypos2,int width2,int height2)
{
    // Create arrays of all positions with appropriate height and length
    int xpos1_array[width1];
    int ypos1_array[height1];
    int xpos2_array[width2];
    int ypos2_array[height2];
    bool xcol = false;
    bool ycol = false;
    bool col = false;
    //printf("variables declared\n");
    // Loop through both height and width to get a 2D aray of the sprites position
    for(int cx = 0; cx<width1; cx=cx+1) {
        xpos1_array[cx]= xpos1 + cx;
        for(int nx = 0; nx<width2; nx=nx+1) {
            xpos2_array[nx]= xpos2 + nx;
            if(xpos2_array[nx] == xpos1_array[cx]) {
                xcol = true;
            }
            // printf("xarray = %d,x2array = %d,xcol = %d\n",xpos2_array[nx],xpos1_array[cx],xcol);
        }
    }
    //printf("first loop done\n");
    for(int cy = 0; cy<height1; cy=cy+1) {
        ypos1_array[cy]= ypos1 + cy;
        for(int ny = 0; ny<height2; ny=ny+1) {
            ypos2_array[ny]= ypos2 + ny;
            if(ypos2_array[ny] == ypos1_array[cy]) {
                ycol = true;
            }
            // printf("yarray = %d,y2array = %d,ycol = %d\n",ypos2_array[ny],ypos1_array[cy],ycol);
        }
    }
    //printf("second loop done\n");
    // if both the hight and width position values are equal a collision has occured
    col = (xcol & ycol);
    //printf("col gotten, col = %d\n",col);
    return col;
}
bool RosenEngine::check_collision1(int xpos1,int width1,int xpos2,int width2)
{
    // Create arrays of all positions with appropriate height and length
    int xpos1_array[width1];
    int xpos2_array[width2];
    bool xcol = false;

    for(int cx = 0; cx<width1; cx=cx+1) {
        xpos1_array[cx]= xpos1 + cx;
        for(int nx = 0; nx<width2; nx=nx+1) {
            xpos2_array[nx]= xpos2 + nx;
            if(xpos2_array[nx] == xpos1_array[cx]) {
                xcol = true;
            }
            // printf("xarray = %d,x2array = %d,xcol = %d\n",xpos2_array[nx],xpos1_array[cx],xcol);
        }
    }
    return xcol;
}

void RosenEngine::test()
{
    bool test;
    test = check_collision(5,5,5,5,5,5,5,5);
    if (test == false) {
        printf("fail\n");
    } else {
        printf("pass\n");
    }
    test = check_collision(0,0,1,1,24,24,1,1);
    if (test == true) {
        printf("fail\n");
    } else {
        printf("pass\n");
    }
}
// make function resemble test

void RosenEngine::seeker_ship_collision(Gamepad &pad)
{
    bool col1,col2,col3;

    col1 = check_collision(ship_xpos,ship_ypos,9,6,_seeker1_pos.x, _seeker1_pos.y,10,7);
    col2 = check_collision(ship_xpos,ship_ypos,9,6,_seeker2_pos.x, _seeker2_pos.y,10,7);
    col3 = check_collision(ship_xpos,ship_ypos,9,6,_seeker3_pos.x, _seeker3_pos.y,10,7);
    int sel = 0;

    if (col1 == true && _no_seekers >= 1) {
        sel = 1;
    }
    if (col2 == true && _no_seekers >= 2) {
        sel = 2;
    }
    if (col3 == true && _no_seekers >= 3) {
        sel = 3;
    }
    // printf("col1 = %d, col2 = %d, col3 = %d, no_seekers = %d\n",col1,col2,col3,_no_seekers);
    if(sel != 0) {
        _health.update(5,pad);
        _health.seekerh_update(sel,10);
        pad.tone(500,0.05);
        wait(0.05);
    }
}
void RosenEngine::shooter_ship_collision(Gamepad &pad)
{
    bool col1,col2,col3;
    int sel = 0;
    col1 = check_collision(ship_xpos,ship_ypos,9,6,_shooter1_pos.x, _shooter1_pos.y,10,7);
    col2 = check_collision(ship_xpos,ship_ypos,9,6,_shooter2_pos.x, _shooter2_pos.y,10,7);
    col3 = check_collision(ship_xpos,ship_ypos,9,6,_shooter3_pos.x, _shooter3_pos.y,10,7);

    if(col1 == true && _no_shooters >= 1) {
        sel = 1;
    }
    if(col2 == true && _no_shooters >= 2) {
        sel = 2;
    }
    if(col3 == true && _no_shooters >= 3) {
        sel = 3;
    }
    if(sel != 0) {
        _health.update(1,pad);
        _health.shooterh_update(sel,10);
        pad.tone(500,0.05);
        wait(0.05);
    }
}
void RosenEngine::shooterw_ship_collision(Gamepad &pad)
{
    Vector2D _shooterw1_pos = _enemy.get_shwpos(1);
    Vector2D _shooterw2_pos = _enemy.get_shwpos(2);
    Vector2D _shooterw3_pos = _enemy.get_shwpos(3);

    bool col1,col2,col3;
    int sel = 0;
    col1 = check_collision(ship_xpos,ship_ypos,9,6,_shooterw1_pos.x, _shooterw1_pos.y,2,2);
    col2 = check_collision(ship_xpos,ship_ypos,9,6,_shooterw2_pos.x, _shooterw2_pos.y,2,2);
    col3 = check_collision(ship_xpos,ship_ypos,9,6,_shooterw3_pos.x, _shooterw3_pos.y,2,2);

    if(col1 == true && _no_shooters >= 1) {
        sel = 1;
    }
    if(col2 == true && _no_shooters >= 2) {
        sel = 2;
    }
    if(col3 == true && _no_shooters >= 3) {
        sel = 3;
    }
    if(sel != 0) {
        _health.update(1,pad);
        pad.tone(500,0.05);
        wait(0.05);
    }
}
void RosenEngine::kestrelw_seeker_collision(Gamepad &pad)
{
    bool col1, col2, col3;
    int sel = 0;
    Vector2D missle_pos = _weapons.get_pos(_shipno);
    col1 = check_collision(_seeker1_pos.x,_seeker1_pos.y,9,6,missle_pos.x,missle_pos.y,1,1);
    col2 = check_collision(_seeker2_pos.x,_seeker2_pos.y,9,6,missle_pos.x,missle_pos.y,1,1);
    col3 = check_collision(_seeker3_pos.x,_seeker3_pos.y,9,6,missle_pos.x,missle_pos.y,1,1);
    if (col1 == true && _no_seekers >= 1) {
        sel = 1;
    }
    if (col2 == true && _no_seekers >= 2) {
        sel = 2;
    }
    if (col3 == true && _no_seekers >= 3) {
        sel = 3;
    }
    if(sel != 0) {
        pad.tone(500,0.05);
        _health.seekerh_update(sel,5);
        wait(0.05);
    }
}
void RosenEngine::imperionw_seeker_collision(Gamepad &pad)
{
    bool col1,col2,col3;
    int sel = 0;
    if(_shipno == 1){
    if(ship_ypos > _seeker1_pos.y + 6) {
        col1 = check_collision1(_seeker1_pos.x,9,ship_xpos + 2,3);
        if (col1 == true && A == true && _no_seekers >= 1) {
            sel = 1;
        }
    }
    if(ship_ypos > _seeker2_pos.y + 6) {
        col2 = check_collision1(_seeker2_pos.x,9,ship_xpos + 2,3);
        if (col2 == true && A == true && _no_seekers >= 2) {
            sel = 2;
        }
    }
    if(ship_ypos > _seeker1_pos.y + 6) {
        col3 = check_collision1(_seeker3_pos.x,9,ship_xpos + 2,3);
        if (col3 == true && A == true && _no_seekers >= 3) {
            sel = 3;
        }
    }
    }
    if(sel != 0) {
        _health.seekerh_update(sel,10);
        pad.tone(500,0.05);
        wait(0.05);
    }
}
void RosenEngine::kestrelw_shooter_collision(Gamepad &pad)
{
    Vector2D missle_pos = _weapons.get_pos(_shipno);
    bool col1, col2, col3;
    int sel = 0;
    col1 = check_collision(_shooter1_pos.x,_shooter1_pos.y,9,6,missle_pos.x,missle_pos.y,1,1);
    col2 = check_collision(_shooter2_pos.x,_shooter2_pos.y,9,6,missle_pos.x,missle_pos.y,1,1);
    col3 = check_collision(_shooter3_pos.x,_shooter3_pos.y,9,6,missle_pos.x,missle_pos.y,1,1);
    if (col1 == true && _no_shooters >= 1) {
        sel = 1;
    }
    if (col2 == true && _no_shooters >= 2) {
        sel = 2;
    }
    if (col3 == true && _no_shooters >= 3) {
        sel = 3;
    }
    // printf("col1 = %d,col2 = %d,col3 = %d, no_shooters = %d\n",col1,col2,col3,_no_shooters);
    if(sel != 0) {
        pad.tone(500,0.05);
        _health.shooterh_update(sel,5);
        wait(0.05);
    }
}
void RosenEngine::imperionw_shooter_collision(Gamepad &pad)
{
    bool col1,col2,col3;
    int sel = 0;
    if(_shipno == 1) {
        if(ship_ypos > _shooter1_pos.y + 6) {
            col1 = check_collision1(_shooter1_pos.x,9,ship_xpos + 2,3);
            if (col1 == true && A == true && _no_shooters >= 1) {
                sel = 1;
            }
        }
        if(ship_ypos > _shooter2_pos.y + 6) {
            col2 = check_collision1(_shooter2_pos.x,9,ship_xpos + 2,3);
            if (col2 == true && A == true && _no_shooters >= 2) {
                sel = 2;
            }
        }
        if(ship_ypos > _shooter3_pos.y + 6) {
            col3 = check_collision1(_shooter3_pos.x,9,ship_xpos + 2,3);
            if (col3 == true && A == true && _no_shooters >= 3) {
                sel = 3;
            }
        }
    }
    if(sel != 0) {
        _health.shooterh_update(sel,10);
        pad.tone(500,0.05);
        wait(0.05);
    }
}
void RosenEngine::orionw_collision(Gamepad &pad)
{
    
    Vector2D inde = find_closest1();
    int index1 = inde.x;
    int index2 = inde.x - 3;
    int distance = inde.y;
    
    // enemy 0,1 and 2 are shooters
    if(_no_shooters >= index1 && A == true && distance < 15){
        _health.shooterh_update(index1,10);
        pad.tone(500,0.05);
        wait(0.05);
    }
    if(_no_seekers >= index2 && A == true && distance < 15){
        _health.seekerh_update(index2,10);
        pad.tone(500,0.05);
        wait(0.05);
    }
    
    
}
void RosenEngine::check_health()
{
    check_se_health();
    check_sh_health();

    Vector2D hp = _health.get_hp();
    if(hp.x <= 0) {
        // printf("player deaad\n");
        _dead = true;
    }

}
void RosenEngine::check_se_health()
{
    int sel = 0;
    int seeker1_health = _health.get_seekerh(1);
    int seeker2_health = _health.get_seekerh(2);
    int seeker3_health = _health.get_seekerh(3);
    // printf("seeker1_h = %d, seeker2_h = %d, seeker3_h = %d\n",seeker1_health,seeker2_health,seeker3_health);
    if(seeker1_health == 0) {
        sel = 1;
    }
    if(seeker2_health == 0) {
        sel = 2;
    }
    if(seeker3_health == 0) {
        sel = 3;
    }
    if(sel != 0) {
        _enemy.reset_seeker(sel);
        _health.reset_seekerh(sel);
        _score = _score + 10;
    }
}
void RosenEngine::check_sh_health()
{
    int sel = 0;
    int shooter1_health = _health.get_shooterh(1);
    int shooter2_health = _health.get_shooterh(2);
    int shooter3_health = _health.get_shooterh(3);

    if(shooter1_health == 0) {
        sel = 1;
    }
    if(shooter2_health == 0) {
        sel = 2;
    }
    if(shooter3_health == 0) {
        sel = 3;
    }
    if(sel != 0) {
        _enemy.reset_shooter(sel);
        _health.reset_shooterh(sel);
        _score = _score + 20;
    }
}
int RosenEngine::rand_no()
{
    srand(time(NULL));
    int rand_no = (rand() %45) + 1;
    // printf("random no = %d\n",rand_no);
    return rand_no;
}
float RosenEngine::timer(int fps)
{
    _times_run = _times_run + 1;
    float time_frame = 1.0f/fps;
    float time_elapsed = _times_run * time_frame;
    // printf("time elapsed = %f,time frame = %f, _times_run = %d\n",time_elapsed,time_frame,_times_run);
    return time_elapsed;
}
void RosenEngine::score(int points)
{
    _score = _score + points;
}
bool RosenEngine::dead()
{
    return _dead;
}

void RosenEngine::scaling(float time_elapsed)
{
    if(time_elapsed == _wait_time) {
        _no_shooters = _no_shooters + 1;
        _no_seekers = _no_seekers + 1;
        _enemy.sh_scaling(time_elapsed);
        _wait_time = _wait_time + 10.00;
    }
    if(_no_shooters > 3) {
        _no_shooters = 3;
    }
    if(_no_seekers > 3) {
        _no_seekers = 3;
    }
    _enemy.set_noshooters(_no_shooters);
    _enemy.set_noseekers(_no_seekers);
    // printf("time_elapsed = %f, no_shooters = %d, wait_time = %f\n",time_elapsed,_no_shooters,_wait_time);
}
void RosenEngine::game_over(N5110 &lcd)
{
    /*
    lcd.clear();
    lcd.refresh();
    lcd.printString("Game Over ",2,2);
    lcd.printString("Try dodging ",2,3);
    lcd.printString("next time",2,4);
    lcd.refresh();
    wait(2);
    */
    _lore.display(lcd);
}
void RosenEngine::intro(N5110 &lcd)
{
    if(_intro == false) {
        lcd.clear();
        lcd.refresh();
        lcd.printString("You're tasked",2,0);
        lcd.printString(" with holding",2,1);
        lcd.printString("   the line ",2,2);
        lcd.printString("   from an ",2,3);
        lcd.printString("invading army ",2,4);
        lcd.refresh();
        wait(2);
        lcd.clear();
        lcd.refresh();
        lcd.printString("    as an  ",2,0);
        lcd.printString(" expendable ",2,1);
        lcd.printString("    asset, ",2,2);
        lcd.printString(" you are not ",2,3);
        lcd.printString(" expected to",2,4);
        lcd.printString("   survive  ",2,5);
        lcd.refresh();
        wait(2);

    }
    _intro = true;
}
void RosenEngine::disp_points(N5110 &lcd)
{
    char buffer[10];
    sprintf(buffer,"%d",_score);
    lcd.printString(buffer,2,0);
}
Vector2D RosenEngine::get_enemynum()
{
    return{_no_shooters,_no_seekers};

}
int RosenEngine::range(int x1, int y1, float x2, float y2)
{
    float rangex = (abs(x1 - x2));
    float rangey = (abs(y1 - y2));
    int distance = floor((rangex+rangey)/2);
    // printf("distance = %d\n",distance);
    return distance;
}
Vector2D RosenEngine::find_closest1()
{
    // get the distance for all enemies
    int sh1 = range(ship_xpos,ship_ypos,_shooter1_pos.x,_shooter1_pos.y);
    int sh2 = range(ship_xpos,ship_ypos,_shooter2_pos.x,_shooter2_pos.y);
    int sh3 = range(ship_xpos,ship_ypos,_shooter3_pos.x,_shooter3_pos.y);
    int se1 = range(ship_xpos,ship_ypos,_seeker1_pos.x,_seeker1_pos.y);
    int se2 = range(ship_xpos,ship_ypos,_seeker2_pos.x,_seeker2_pos.y);
    int se3 = range(ship_xpos,ship_ypos,_seeker3_pos.x,_seeker3_pos.y);

    int close[6] = {sh1,sh2,sh3,se1,se2,se3};
    // find index of the smallest element
    int index = 0;
    int smallest = close[0];
    for(int i=0; i<6; i=i+1) {
        if(smallest>close[i]) {
            smallest=close[i];
            index = i;
        }
    }
    return {(index + 1),smallest};
}
Vector2D RosenEngine::find_closest2(int index)
{
    // printf("index = %d, _no_shooters = %d, _no_seekers = %d\n",index,_no_shooters,_no_seekers);
    // return the position of the closest enemy
    if(index == 1 && _no_shooters >= 1) {
        return {_shooter1_pos.x,_shooter1_pos.y};
    }
    if(index == 2 && _no_shooters >= 2) {
        return {_shooter2_pos.x,_shooter2_pos.y};
    }
    if(index == 3 && _no_shooters >= 3) {
        return {_shooter3_pos.x,_shooter3_pos.y};
    }
    if(index == 4 && _no_seekers >= 1 ) {
        return {_seeker1_pos.x,_seeker1_pos.y};
    }
    if(index == 5 && _no_seekers >= 2) {
        return {_seeker2_pos.x,_seeker2_pos.y};
    }
    if(index == 6 && _no_seekers >= 3) {
        return {_seeker3_pos.x,_seeker3_pos.y};
    }

}