toffyrn

#include "monolith.h"



using namespace std;

SDL_Surface *screen;



//Initial video mode-----------------------------------------------------

int monolith::monoInitVideo( Uint32 flags, int width, int height )

{

    //Load SDL

    if( SDL_Init( SDL_INIT_VIDEO ) != 0 )

    { //straight forward stuff here

        cout << "Unable to start SDL: " << SDL_GetError() << "\n";

        return false;

    }

    atexit( SDL_Quit ); //And clean up.. apparently



    //get into full screen, specify flags, the usual

    screen = SDL_SetVideoMode( width, height, 16, flags );



    //check that screen has been set

    if( screen == NULL )

    {

        cout << "Unable to set video mode: " << SDL_GetError() << "\n";

        return false;

    }



    SDL_WM_SetCaption("Monolith","Monolith");



    //And finally, set mouse up

    SDL_ShowCursor( 0 );

    SDL_WarpMouse( width/2, height/2 );



    return true;

}



//Load image-------------------------------------------------------------

SDL_Surface *monolith::monoLoadImage( string imageName, int &exitState )

{

    SDL_Surface *temp; //EDIT: missing ";"

    exitState = 0;



    temp = IMG_Load( imageName.c_str() );

    //check if that worked

    if( temp == NULL )

    {

        cout << "Could not load Image \"" << imageName << "\": " << SDL_GetError() << "\n";

        return 0;

    }



    //Okay, we're good

    if( SDL_SetColorKey( temp, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB

        ( temp -> format, COLOURKEY )) == -1 ) //Or are we?

    {

        cout << "Colour key will not be used: " << SDL_GetError() << "\n";

    }

    exitState = 1; //EDIT: missing ";"



    return temp;

}



//Sets extra parameters for object collision detection

void monolith::monoPrepObject( image_coord_t object )

{

    object.w_col = object.w * 0.80;

    object.h_col = object.h * 0.80;



    object.x_offset = ( object.w - object.w_col )/2;

    object.y_offset = ( object.h - object.h_col )/2;



    object.radius = (( object.w + object.h )/4 );

}



//Display Image----------------------------------------------------------

void monolith::monoDrawImage( SDL_Surface *image, image_coord_t surface_param, image_coord_t dest_param )

{

    SDL_Rect surface, dest;



    //Set image properties (size, etc)

    surface.x = surface_param.x;

    surface.y = surface_param.y;

    surface.w = surface_param.w;

    surface.h = surface_param.h;



    dest.x = dest_param.x;

    dest.y = dest_param.y;

    dest.w = dest_param.w;

    dest.h = dest_param.h;



    SDL_BlitSurface( image, &surface, screen, &dest );

}



//Collision Check--------------------------------------------------------

// @ collision, angle (deg) of obj2 relative to obj1 is returned.

// 0 means no collision (360 is returned in place of 0deg collision angle)

int monolith::monoCheckCollision( image_coord_t obj1, image_coord_t obj2 )

{

    //Basic radius check

    int dx = obj2.x - obj1.x;

    int dy = obj2.y - obj1.y;

    int dradii = obj1.radius + obj2.radius;



    if((( dx*dx )+( dy*dy )) < ( dradii*dradii ))

    {

        //Possible collision, got to bounding box method

        if( monoCheckBoundingBox( obj1, obj2 ))

        {

            //Left return a rough angle of where the collision occured

            //from (relative to obj1)

            int angle = ( int )( atan2(( float )obj2.y, ( float )obj2.x )

                               - atan2(( float )obj1.y, ( float )obj1.x ));



            if( angle == 0 )

                return 360;

            else

                return angle;

        }

    }



    return 0;

}



int monolith::monoCheckBoundingBox( image_coord_t obj1, image_coord_t obj2 )

{

    int left1, left2;

    int right1, right2;

    int top1, top2;

    int bottom1, bottom2;



    //load @params

    left1 = obj1.x + obj1.x_offset;

    left2 = obj2.x + obj2.x_offset;



    right1 = left1 + obj1.w_col;

    right2 = left2 + obj2.w_col;



    top1 = obj1.y + obj1.y_offset;

    top2 = obj2.y + obj2.y_offset;



    bottom1 = top1 + obj1.h_col;

    bottom2 = top2 + obj2.h_col;



    //finally, lets check for collision

    //                                          relative to obj1

    if(( bottom1 <= top2 )&&( right1 >= left2 )) //bottom right

        return true;



    if(( bottom1 <= top2 )&&( left1 <= right2)) //bottom left

        return true;



    if(( top1 >= bottom2 )&&( right1 >= left2 )) //top right

        return true;



    if(( top1 >= bottom2 )&&( left1 <= right2 )) //top left

        return true;



    //no collisions occured

    return false;

}



//Move Image-------------------------------------------------------------



//AI---------------------------------------------------------------------



//Main program entry point-----------------------------------------------

int main( int argc, char* argv[] )

{

    //Process params

    if( argc != 5 )

    {

        cout << "Program usage: \n \t\tmonolith width height file_name1 file_name2 \n\n";

        return 0;

    }



    int result = 0;

    int width = atoi( argv[ 1 ]);

    int height = atoi( argv[ 2 ]);



    //EDIT: your functions are NOT static, and

    ////////and therefore need a object.

    ////////Not sure if this is how you want it to be...

    monolith my_obj;



    //Initialise video

    //EDIT: using my_obj's function

    if( my_obj.monoInitVideo( SDL_DOUBLEBUF | SDL_SWSURFACE, width, height ) == false )

        return 1; //counts as error returning from main



    //Cool, lets make that a string

    //string params = new string( argv[1] );



    //Load image

    //EDIT: using my_obj's function

    SDL_Surface *good_guy = my_obj.monoLoadImage( string( argv[3]), result );



    if( result == false )

        return 1;



    //EDIT: using my_obj's function

    SDL_Surface *bad_guy = my_obj.monoLoadImage( string( argv[4]), result );



    if( result == false )

        return 1;











    //Define display properties

    image_coord_t surface, on_screen;



    SDL_Flip( screen );

    SDL_Delay( 2500 );



    //Cleanup

    SDL_FreeSurface( good_guy );

    SDL_FreeSurface( bad_guy );

    SDL_ShowCursor( 1 );

    return 0;

}