示例#1
0
bool Enemy::CheckCollision(Vector3 pos)
{
	SDL_Rect* result = new SDL_Rect();

	Vector3 objPos = _transform.position;

	SDL_Rect objRect = SDL_Rect();
	objRect.x = objPos.x;
	objRect.y = objPos.y;
	objRect.w = 1;
	objRect.h = 1;

	SDL_Rect targetRect = SDL_Rect();
	targetRect.x = pos.x;
	targetRect.y = pos.y;
	targetRect.w = 1;
	targetRect.h = 1;

	bool enemyCollision = SDL_IntersectRect(&objRect, &targetRect, result);

	if (enemyCollision)
		return true;
	else
	{
		objPos = _projectile->GetTransform().position;

		objRect.x = objPos.x;
		objRect.y = objPos.y;
		objRect.w = 1;
		objRect.h = 1;

		return SDL_IntersectRect(&objRect, &targetRect, result);
	}

}
示例#2
0
    void Surface::blit(Surface *m_surface, Rectangle *src, Rectangle *dst)
    {
        SDL_Rect sdl_src = SDL_Rect();
        SDL_Rect sdl_dst = SDL_Rect();
        Rectangle::Copy(src, &sdl_src);
        Rectangle::Copy(dst, &sdl_dst);

        blit(m_surface, &sdl_src, &sdl_dst);
    }
示例#3
0
	void Surface::blit(Surface *m_surface, Rectangle *dst)
	{
	    SDL_Rect sdl_dst = SDL_Rect();
	    Rectangle::Copy(dst, &sdl_dst);
	    SDL_Rect src = SDL_Rect();
	    src.w = m_surface->getWidth();
	    src.h = m_surface->getHeight();

	    blit(m_surface, &src, &sdl_dst);
	}
示例#4
0
void RadioButton::Init(Gui &gui)
{
    setMode(normal);
    mPositionTex.push_back(SDL_Rect(ResourceManager::GetManagerResource()->GetResource()["RadioButton"]["UncheckedImage"]->GetSDLPart()));
    mPositionTex.push_back(SDL_Rect(ResourceManager::GetManagerResource()->GetResource()["RadioButton"]["CheckedImage"]->GetSDLPart()));
    mPositionTex.push_back(SDL_Rect(ResourceManager::GetManagerResource()->GetResource()["RadioButton"]["UncheckedHoverImage"]->GetSDLPart()));
    mPositionTex.push_back(SDL_Rect(ResourceManager::GetManagerResource()->GetResource()["RadioButton"]["CheckedHoverImage"]->GetSDLPart()));
    mColor.push_back(Vector3i(ResourceManager::GetManagerResource()->GetResource()["RadioButton"]["TextColorNormal"]->GetColor()));
    mColor.push_back(Vector3i(ResourceManager::GetManagerResource()->GetResource()["RadioButton"]["TextColorHover"]->GetColor()));
    SDL_Rect temp = mPositionTex[0];
    setSize(temp.w,temp.h);
}
示例#5
0
Sprite::Sprite() : tickTime(0.f),
					currentFrame(0),
					noRender(false),
					loop(true),
					animMode(ANIMATE_FRAMES),
					paused(false),
					stretch(false),
					velx(0),
					vely(0),
					pos(Vector2D()),
					imgRect(SDL_Rect()),
					startingRect(SDL_Rect())					
{
	tickTime = SDL_GetTicks();
	globalTime = tickTime;
}
示例#6
0
文件: Window.cpp 项目: vegaka/CPPLife
Window::Window(const int width, const int height, const int cellSize) {
    if (SDL_Init(SDL_INIT_EVERYTHING) == -1) {
        printError();
    }
    
    // Board needs to be setup before the window because I need the size of the board
    setupBoard(width, height, cellSize);
    
    window = SDL_CreateWindow("Game of life", 0, 0, boardBackground.w + 14, boardBackground.h + 57, SDL_WINDOW_SHOWN);
    if (window == NULL) {
        printError();
    }
    
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (renderer == NULL) {
        printError();
    }
    
    // Load UI image
    textures[UI] = IMG_LoadTexture(renderer, "../../../../../../../../dev/CPP/Life/StaticUI.png");
    dstRects[UI] = {(boardBackground.w / 2) - (463 / 2), boardBackground.y + boardBackground.h + 10, 463, 26};
    
    // Setup UI clip rects
    for (int i = 0; i < 4; i++) {
        UIClipRects.push_back(SDL_Rect());
        UIClipRects[i].x = dstRects[UI].x + i * 118;
        UIClipRects[i].y = dstRects[UI].y;
        UIClipRects[i].w = 110;
        UIClipRects[i].h = 26;
    }
}
示例#7
0
TGfxSprite::TGfxSprite()
{
    m_pTexture = nullptr;
    m_tCut = SDL_Rect();
    m_iPosX = 0;
    m_iPosY = 0;
}
示例#8
0
	void Surface::blit(Surface *m_surface, SDL_Rect *dst)
	{
        SDL_Rect src = SDL_Rect();
	    src.w = m_surface->getWidth();
	    src.h = m_surface->getHeight();

	    blit(m_surface, &src, dst);
	}
示例#9
0
	void Surface::fill(Uint32 c)
	{
		SDL_Rect region = SDL_Rect();
		region.x = 0;
		region.y = 0;
		region.w = width;
		region.h = height;

		int rs = SDL_FillRect(sdlSurface, &region, c);
	}
示例#10
0
Surface* ActionBind::render(void)
{
	Surface *buffer = new Surface(width, height);

	if(focus)
	{
		buffer->fill(highlightBackground);
	}
	else
	{
		buffer->fill(background);
	}

	SDL_Rect src = SDL_Rect();
	SDL_Rect dst = SDL_Rect();

	stringBuffer->updateSDLRect(&src);
	stringBuffer->updateSDLRect(&dst);

	dst.x = (width - dst.w) / 2;
	dst.y = (height - dst.h) / 2;

	buffer->blit(stringBuffer, &src, &dst);

	PRect border = PRect();

	border.setX(0);
	border.setY(0);
	border.setWidth(width - 1);
	border.setHeight(height - 1);

	Color *c_border = foreground;

	if(focus)
	{
		c_border = highlightForeground;
	}

	border.draw(buffer->getSDLSurface(), c_border);

	return buffer;
}
void Player::Render(SDL_Renderer* gRenderer, b2Vec2 offset) {

	rect.x = dynamicBody->GetPosition().x -(rect.w/2.0f)- offset.x;
	rect.y = dynamicBody->GetPosition().y -(rect.h/2.0f)+ offset.y;
	SDL_Rect h = SDL_Rect();
	h.x =0;
	h.y =0;
	h.w = 165;
	h.h = 230;
	SDL_RenderCopy( gRenderer, m_texture, &h, &rect );
}
示例#12
0
//-----------------
bool CBarrier::init( const TPoint2 & pos, const TPoint2 & size ) {
  m_texture.loadFromFile( "data/textures/blank.png" );
  m_texture.setPosition( pos );
  m_texture.setClip( SDL_Rect( 0, 0, size.x, size.y ) );

  colors[ 2 ] = SDL_Color( 0, 255, 0, 255 );
  colors[ 1 ] = SDL_Color( 255, 255, 0, 255 );
  colors[ 0 ] = SDL_Color( 255, 0, 0, 255 );

  reset( );

  return true;
}
示例#13
0
Sprite::Sprite(std::string filename, std::string name, GLfloat x, GLfloat y)
    : GameComponent(name),
      texture(0)
{
    this->filename = filename;
    positionX = x;
    positionY = y;
    scaleX = 1;
    scaleY = 1;
    rotation = 0;
    bounds = SDL_Rect();
    drawColor[0] = drawColor[1] = drawColor[2] = drawColor[3] = 1.0;
}
示例#14
0
CrabEnemy::CrabEnemy() : Enemy()
{
	velocity = 64.0f;
	sprite = new Sprite(GraphicsEngine::GetInstance());
	sprite->SetTexture("player.png");
	SDL_Rect r = SDL_Rect();
	r.x = 0;
	r.y = 0;
	r.w = 64;
	r.h = 64;
	sprite->SetBounds(r);
	r.x = (int)GetPosition().first;
	r.y = (int)GetPosition().second;
	sprite->SetPosition(r);
	Move(64 * 4, 64 * 5);
}
示例#15
0
//Draws the specified texture
//param:texture->the index given from load texture
//param:color->the tint to apply to the texture
//param:sourceRect->the rectangle to pull a smaller image from the texture with. NULL for the whole texture
//param:position->the point to draw to
//param:angle->the rotation to apply
//param:scale->the scale to apply. This is uniform across x and y
//param:flip->SDL_RendererFlip::None/FlipHorizontal/FlipVertical. If you want both Flip Horizontal and Flip Vertical,
//use the bitwise operator '|'
//param:origin->Origin to rotate around. If NULL, uses center of destRect created by position and scale
//param:layerDepth->The depth to draw the image at
//returns -1 on error, 0 for success
int SpriteBatch::DrawTexture(Uint32 texture, SDL_Color color, const SDL_Rect* sourceRect, const SDL_Point* position,
		float angle, float scale, SDL_RendererFlip flip, const SDL_Point* origin, float layerDepth)
{
	//Check if spritebatch.begin has been called
	if(!begun)
	{
		std::cout<<"Begin must be called before attempting to draw"<<std::endl;
		return -1;
	}

	///create a temporary point
	SDL_Point pos = SDL_Point();

	//if position is null, set our temp to 0,0
	if(!position)
	{
		pos = CreatePoint(0, 0);
	}
	else
	{
		//otherwise set with position
		pos = CreatePoint(position->x, position->y);
	}

	SDL_Rect destRect = SDL_Rect();

	//If we were given a source rectangle
	if(sourceRect)
	{
		//create a dest rectangle using position and source rectangle's dimensions
		destRect = CreateRect(pos.x, pos.y, (int)(sourceRect->w * scale), (int)(sourceRect->h * scale));
	}
	else
	{
		int w = 0;
		int h = 0;

		//get the width and height
		SDL_QueryTexture(textureList[texture], NULL, NULL, &w, &h);
		//create a dest rect using position and the image dimensions
		destRect = CreateRect(pos.x, pos.y, (int)(w * scale), (int)(h * scale));
	}

	//Call other DrawTexture to do the actual drawing
	return DrawTexture(texture, color, sourceRect, &destRect, angle, origin, flip, layerDepth);
}
示例#16
0
文件: Window.cpp 项目: vegaka/CPPLife
void Window::setupBoard(const int width, const int height, const int cellSize) {
    // Black background rectangle
    boardBackground.x = 7;
    boardBackground.y = 7;
    boardBackground.w = width * cellSize + width * 3 + 3;
    boardBackground.h = height * cellSize + height * 3 + 3;
    
    // Blue rectangles to show alive cells
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            boardCells.push_back(SDL_Rect());
            boardCells[j + i * width].x = (j * cellSize + j * 3) + 10;
            boardCells[j + i * width].y = (i * cellSize + i * 3) + 10;
            boardCells[j + i * width].w = cellSize;
            boardCells[j + i * width].h = cellSize;
        }
    }
}
Player::Player(b2World* world, SDL_Renderer* gRenderer, b2Vec2 position, b2Vec2 dimentions) : isSpaceDown(false) {
	myBodyDef.type = b2_dynamicBody;
	myBodyDef.position.Set(position.x , position.y );
	myBodyDef.userData = (void*)0;
	myBodyDef.angularDamping = 2;
	dynamicBody = world->CreateBody(&myBodyDef);
	playerShape.SetAsBox(dimentions.x, dimentions.y);
	fixtureDef.shape = &playerShape;
	fixtureDef.filter.groupIndex = -1;
	fixtureDef.density = 0.1;
	dynamicBody->CreateFixture(&fixtureDef);
	m_KeyboardMan = KeyboardManager::getKeys();
	m_texture = IMG_LoadTexture(gRenderer,"images/player.png");
	rect = SDL_Rect();
	rect.h = dimentions.x*2;
	rect.w = dimentions.y*2;
	sm = new SoundManager();
	sm->PlayBackground();
	count = 0;
}
示例#18
0
SDL_Rect Sprite::GetRect() const
{
	SDL_Rect ret = SDL_Rect();
	if(animMode == ANIMATE_SHEET)
	{
		ret.h = startingRect.h;
		ret.w = startingRect.w;
		ret.x = pos.x;
		ret.y = pos.y;
		return ret;
	}
	else if(!m_frames.empty())
	{
		ret.h = m_frames[currentFrame].Texture->h;
		ret.w = m_frames[currentFrame].Texture->w;
		ret.x = pos.x;
		ret.y = pos.y;
		return ret;
	}
	else return ret;
}
示例#19
0
SDL_Rect Font::textBounds(std::string text) {
	if (text.length() == 0) {
		return SDL_Rect();
	}
	Color c;
	SDL_Surface *surf = TTF_RenderText_Blended(font_, text.c_str(),
			c.getSDLColor());
	SDL_Rect r;

	if (surf == 0) {
		logSDLError(std::cout, "TTF_RenderText");
		r.x = 0;
		r.y = 0;
		r.w = 0;
		r.h = 0;
		return r;
	}
	r = surf->clip_rect;
	SDL_FreeSurface(surf);
	return r;
}
示例#20
0
/*
	Create Camera at ( x, y )
*/
Camera::Camera( double x, double y ) :
		_x( 0.0 ),
		_y( 0.0 ),
		_w( 0.0 ),
		_h( 0.0 ),

		_left( 0.0 ),
		_right( 0.0 ),
		_top( 0.0 ),
		_bottom( 0.0 ),
		_rect( SDL_Rect() ),

		_cache_half_screen_w( (double)( SCREEN_W/SCALE )/2.0 ),
		_cache_half_screen_h( (double)( SCREEN_H/SCALE )/2.0 ) {

	_w = _cache_half_screen_w;
	_h = _cache_half_screen_h;

	/* Move Camera to ( x, y ) */
	SetXY( x, y );
};
示例#21
0
int main( int argc, char* args[] )
{
    SDL_Color BACKGROUND_COLOR  = SDL_Color();  BACKGROUND_COLOR.r  = 0;    BACKGROUND_COLOR.g  = 0;    BACKGROUND_COLOR.b  = 0;     BACKGROUND_COLOR.a = 255;
    SDL_Color HUNTER_COLOR      = SDL_Color();  HUNTER_COLOR.r      = 255;  HUNTER_COLOR.g      = 0;    HUNTER_COLOR.b      = 0;     HUNTER_COLOR.a     = 255;
    SDL_Color BOUND_COLOR       = SDL_Color();  BOUND_COLOR.r       = 0;    BOUND_COLOR.g       = 255;  BOUND_COLOR.b       = 0;    BOUND_COLOR.a       = 255;
    SDL_Color PREY_COLOR        = SDL_Color();  PREY_COLOR.r        = 0;    PREY_COLOR.g        = 0;    PREY_COLOR.b        = 255;  PREY_COLOR.a        = 255;
    
    
    // Init GUI
    SDL_Window *screen = NULL;
    if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 ) {
        std::cout << "Error on SDL_Init:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }
    
    screen = SDL_CreateWindow(WINDOW_NAME, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
    if( screen == NULL ) {
        std::cout << "Error on SDL_CreateWindow:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }
    
    SDL_Renderer* bgRenderer = NULL;
    bgRenderer =  SDL_CreateRenderer( screen, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if( bgRenderer == NULL ) {
        std::cout << "Error on SDL_CreateRenderer:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }

    
    // Define neural network
    LinearNeuralNetwork nn = LinearNeuralNetwork( 0, { 1 }, NULL, NULL );
    if(std::ifstream(FILENAME)) { nn = LinearNeuralNetwork( FILENAME, Neuron::SIGMOID, Neuron::SIGMOID_DER ); }
    else                        { nn = LinearNeuralNetwork( ALPHA, NEURAL_NETWORK_DESCRIPTOR, Neuron::SIGMOID, Neuron::SIGMOID_DER ); }
    

    // Inizialization
    SDL_Rect bounds = SDL_Rect();
    bounds.x = BOUND_MIN_X;
    bounds.y = BOUND_MIN_Y;
    bounds.w = BOUND_MAX_X - BOUND_MIN_X;
    bounds.h = BOUND_MAX_Y - BOUND_MIN_Y;
    
    Entity hunter   = Entity( HUNTER_WIDTH, HUNTER_HEIGHT,  HUNTER_SPEED,   HUNTER_START_X, HUNTER_START_Y, bounds, HUNTER_COLOR );
    Entity prey     = Entity( PREY_WIDTH,   PREY_HEIGHT,    PREY_SPEED,     PREY_START_X,   PREY_START_Y,   bounds, PREY_COLOR );
    
    // Render
    clr(bgRenderer,BACKGROUND_COLOR);
    renderRect(bounds, BOUND_COLOR, bgRenderer, false);
    renderEntity(hunter, bgRenderer);
    renderEntity(prey, bgRenderer);
    SDL_RenderPresent(bgRenderer);



    // TIMERS
    SDL_TimerID renderTimerId = SDL_AddTimer(TIME_GAP_RENDER, render_callback, NULL);
    if( renderTimerId == 0 ) {
        std::cout << "Error on SDL_AddTimer:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }
    
    SDL_TimerID movementTimerId = SDL_AddTimer(TIME_GAP_MOVEMENT, movement_callback, NULL);
    if( movementTimerId == 0 ) {
        std::cout << "Error on SDL_AddTimer:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }


    // main cycle
    //// structure to read user events
    SDL_Event event;
    //// to check when the key is pressed or released
    bool isKeyPressed[4] = { false, false, false, false };
    
    bool quit = false;
    while( quit == false ) {
        
        bool matchIsOver = false;
        while(!matchIsOver) {
        
            // event handling
            while( SDL_PollEvent( &event ) ) {
                switch( event.type ) {
                    case SDL_QUIT:
                        quit = true;
                    break;
                    case SDL_KEYDOWN:
                        // Keyboard input handling - keydown
                        checkKeyPressed( event.key.keysym.sym, isKeyPressed, true );
                    break;
                    case SDL_KEYUP:
                        // Keyboard input handling - keyup
                        checkKeyPressed( event.key.keysym.sym, isKeyPressed, false );
                    break;
                    case SDL_USEREVENT:
                    
                        switch(event.user.code) {
                            case RENDER_CB:
                                // Render
                                clr(bgRenderer,BACKGROUND_COLOR);
                                renderRect(bounds, BOUND_COLOR, bgRenderer, false);
                                renderEntity(hunter, bgRenderer);
                                renderEntity(prey, bgRenderer);
                                SDL_RenderPresent(bgRenderer);
                            break;
                            case MOVEMENT_CB:
                                int initialDistance = dist(hunter,prey);
                                // Entities movement
                                hunter.move( actHunter(hunter,prey) );
                                //userMovement(prey, isKeyPressed);
                            
                                // DEBUG
                                std::vector<float> outputNn = outPrey( hunter, prey, nn );
                                Entity::Action preyAction   = actPrey( outputNn );
                                prey.move( preyAction );
                            
                                // check contact
                                if( checkContact( hunter, prey ) ) {
                                    std::vector<float> err (5, 0);
                                    err[preyAction] = - REWARD_CAPTURE * outputNn[preyAction];
                                    nn.learn( err );
                                    matchIsOver = true;
                                }
                                else {
                                    int distance = dist(hunter, prey);
                                    // std::cout << "distances" << distance << " " << initialDistance << std::endl;
                                    std::vector<float> err (5, 0);
                                    if( distance > initialDistance ) {
                                        err[preyAction] = ( 1 - outputNn[preyAction] ) * REWARD_DISTANCE;
                                    }
                                    else if( distance < initialDistance ) {
                                        err[preyAction] = - outputNn[preyAction] * REWARD_DISTANCE;
                                    }
                                    nn.learn( err );
                                }
                            break;
                            // default:
    //                             std::cout << "!!! UserEvent code not defined!!!" << std::endl;
    //                             return 1;
    //break;
                        }
                
                    
                    break;
                    default:
                    break;
                }
                
                
            }
        }
        
        hunter.reset();
        prey.reset();
        
    }

    SDL_Quit();
    return 0;
}
示例#22
0
int main( int argc, char* args[] )
{
    SDL_Color BACKGROUND_COLOR  = SDL_Color();  BACKGROUND_COLOR.r  = 0;    BACKGROUND_COLOR.g  = 0;    BACKGROUND_COLOR.b  = 0;     BACKGROUND_COLOR.a = 255;
    SDL_Color HUNTER_COLOR      = SDL_Color();  HUNTER_COLOR.r      = 255;  HUNTER_COLOR.g      = 0;    HUNTER_COLOR.b      = 0;     HUNTER_COLOR.a     = 255;
    SDL_Color BOUND_COLOR       = SDL_Color();  BOUND_COLOR.r       = 0;    BOUND_COLOR.g       = 255;  BOUND_COLOR.b       = 0;    BOUND_COLOR.a       = 255;
    SDL_Color PREY_COLOR        = SDL_Color();  PREY_COLOR.r        = 0;    PREY_COLOR.g        = 0;    PREY_COLOR.b        = 255;  PREY_COLOR.a        = 255;
    
    
    // Init GUI
    SDL_Window *screen = NULL;
    if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 ) {
        std::cout << "Error on SDL_Init:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }
    
    screen = SDL_CreateWindow(WINDOW_NAME, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
    if( screen == NULL ) {
        std::cout << "Error on SDL_CreateWindow:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }
    
    SDL_Renderer* bgRenderer = NULL;
    bgRenderer =  SDL_CreateRenderer( screen, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if( bgRenderer == NULL ) {
        std::cout << "Error on SDL_CreateRenderer:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }

    
    // Define QLAgent
    QLAgent<QLAction,QLState>::qlt table;
    if(std::ifstream(FILENAME)) { loadQLTable(table,FILENAME); }
    const std::vector<QLAction> actionVec { Entity::UP, Entity::DOWN, Entity::LEFT, Entity::RIGHT, Entity::IDLE };
    QLAgent<QLAction,QLState> preyAgent = QLAgent<QLAction,QLState>([&actionVec](QLState u){return actionVec;} , table);
    preyAgent.setQLParameters(CAP, LR, DF, GVR);

    // Inizialization
    SDL_Rect bounds = SDL_Rect();
    bounds.x = BOUND_MIN_X;
    bounds.y = BOUND_MIN_Y;
    bounds.w = BOUND_MAX_X - BOUND_MIN_X;
    bounds.h = BOUND_MAX_Y - BOUND_MIN_Y;
    
    Entity hunter   = Entity( HUNTER_WIDTH, HUNTER_HEIGHT,  HUNTER_SPEED,   HUNTER_START_X, HUNTER_START_Y, bounds, HUNTER_COLOR );
    Entity prey     = Entity( PREY_WIDTH,   PREY_HEIGHT,    PREY_SPEED,     PREY_START_X,   PREY_START_Y,   bounds, PREY_COLOR );
    
    preyAgent.setCurrentState(dataToQLState(hunter,prey));
    
    // Render
    clr(bgRenderer,BACKGROUND_COLOR);
    renderRect(bounds, BOUND_COLOR, bgRenderer, false);
    renderEntity(hunter, bgRenderer);
    renderEntity(prey, bgRenderer);
    SDL_RenderPresent(bgRenderer);



    // TIMERS
    SDL_TimerID renderTimerId = SDL_AddTimer(TIME_GAP_RENDER, render_callback, NULL);
    if( renderTimerId == 0 ) {
        std::cout << "Error on SDL_AddTimer:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }
    
    SDL_TimerID movementTimerId = SDL_AddTimer(TIME_GAP_MOVEMENT, movement_callback, NULL);
    if( movementTimerId == 0 ) {
        std::cout << "Error on SDL_AddTimer:" << std::endl << SDL_GetError() << std::endl;
        return 1;
    }


    // main cycle
    //// structure to read user events
    SDL_Event event;
    //// to check when the key is pressed or released
    bool isKeyPressed[4] = { false, false, false, false };
    
    bool quit = false;
    int matchCounter = 0;
    while( quit == false ) {
        
        bool matchIsOver = false;
        matchCounter++;
        // int moveCounter = 0;
        // int succesCounter = 0;
        while(!matchIsOver) {
        
            // event handling
            while( SDL_PollEvent( &event ) ) {
                switch( event.type ) {
                    case SDL_QUIT:
                        quit = true;
                    break;
                    case SDL_KEYDOWN:
                        // Keyboard input handling - keydown
                        checkKeyPressed( event.key.keysym.sym, isKeyPressed, true );
                    break;
                    case SDL_KEYUP:
                        // Keyboard input handling - keyup
                        checkKeyPressed( event.key.keysym.sym, isKeyPressed, false );
                    break;
                    case SDL_USEREVENT:

                        switch(event.user.code) {
                            case RENDER_CB:
                                // Render
                                clr(bgRenderer,BACKGROUND_COLOR);
                                renderRect(bounds, BOUND_COLOR, bgRenderer, false);
                                renderEntity(hunter, bgRenderer);
                                renderEntity(prey, bgRenderer);
                                SDL_RenderPresent(bgRenderer);
                            break;
                            case MOVEMENT_CB:
                                // Entities movement
                                hunter.move( actHunter(hunter,prey) );
                                //userMovement(prey, isKeyPressed);

                                prey.move( preyAgent.chooseAction() );

                                // check contact
                                if( checkContact( hunter, prey ) ) {
                                    hunter.reset();
                                    prey.reset();
                                    preyAgent.update(dataToQLState(hunter,prey), CATCH_REWARD);
                                    matchIsOver = true;
                                }
                                else {
                                    preyAgent.update(dataToQLState(hunter,prey), SURVIVE_REWARD);
                                }

                            break;
                        }


                    break;
                    default:
                    break;
                }
            }

            
            // 
// moveCounter++;
//
//             hunter.move( actHunter(hunter,prey) );
//             //userMovement(prey, isKeyPressed);
//
//             prey.move( preyAgent.chooseAction() );
//
//             // check contact
//             if( checkContact( hunter, prey ) ) {
//                 hunter.reset();
//                 prey.reset();
//                 preyAgent.update(dataToQLState(hunter,prey), CATCH_REWARD);
//                 matchIsOver = true;
//             }
//                else {
//                    preyAgent.update(dataToQLState(hunter,prey), SURVIVE_REWARD);
//                }
//
//             if(matchCounter%10000 == 0) { std::cout << matchCounter << std::endl; }
//             if(matchCounter%100000 == 0) { quit = true; }
//             if(moveCounter == 1000) { succesCounter++; matchIsOver = true; }
//             if(succesCounter == 100) { std::cout << "SUCCESS!!!" << std::endl; }
                
        }
        
    }
    
    std::cout << "states in table: " << table.size() << std::endl;
    saveQLTable(table,FILENAME);
    SDL_Quit();
    return 0;
}