//-----------------------------------------------------------------------------
// Name : Render()
//-----------------------------------------------------------------------------
void CSliderUI::Render( CAssetManager& assetManger )
{
if (!m_bVisible)
return;
//HRESULT hr;
LPDIRECT3DTEXTURE9 pTexTrack, pTexButton;
//no texture was given abort rendering
if (m_elementsGFX.size() < 2 ||m_elementsGFX[TRACK].iTexture == -1 || m_elementsGFX[BUTTON].iTexture == -1)
return;
// acquire the sprite needed for rendering
CMySprite* sprite = assetManger.getMySprite();
//acquire a pointers for the textures of the Track and the button
pTexTrack = assetManger.getTexturePtr(m_elementsGFX[TRACK].iTexture);
pTexButton = assetManger.getTexturePtr(m_elementsGFX[BUTTON].iTexture);
POINT dialogPos = m_pParentDialog->getLocation();
if (m_bMouseOver)
{
renderRect(m_elementsGFX[TRACK].rcTexture, m_rcBoundingBox, sprite, pTexTrack, d3d::WHITE,HiGHLIGHT, dialogPos);
renderRect(m_elementsGFX[BUTTON].rcTexture, m_rcButton, sprite, pTexButton, d3d::WHITE, HiGHLIGHT,dialogPos);
}
else
{
renderRect(m_elementsGFX[TRACK].rcTexture, m_rcBoundingBox, sprite, pTexTrack, D3DCOLOR_ARGB( 255, 200, 200, 200 ), REGLUAR, dialogPos);
renderRect(m_elementsGFX[BUTTON].rcTexture, m_rcButton, sprite, pTexButton, D3DCOLOR_ARGB( 255, 200, 200, 200 ), REGLUAR, dialogPos);
}
}
void UINode::renderDebug (int x, int y, int textY) const
{
const int panelX = getRenderX();
const int panelY = getRenderY();
const int w = getRenderWidth(false);
const int h = getRenderHeight(false);
const Color* color[5];
color[0] = &colorGreen;
color[1] = &colorBlue;
color[2] = &colorRed;
color[3] = &colorYellow;
color[4] = &colorCyan;
const int index = (panelX * 22 * h + panelY * 23 * w) % 5;
renderRect(x + getRenderX(false), y + getRenderY(false), w, h, *color[index]);
if (!fequals(_padding, 0.0f)) {
renderRect(x + panelX, y + panelY, getRenderWidth(), getRenderHeight(), *color[index]);
}
renderFilledRect(x + getRenderCenterX(), y + getRenderCenterY(), 4, 4, colorRed);
renderFilledRect(x + panelX, y + panelY, 4, 4, colorBlue);
const BitmapFontPtr& font = getFont(MEDIUM_FONT);
int panelTextY = textY;
for (UINodeListConstIter i = _nodes.begin(); i != _nodes.end(); ++i) {
const UINode* nodePtr = *i;
if (!nodePtr->hasFocus())
continue;
nodePtr->renderDebug(x + panelX, y + panelY, panelTextY);
const std::string debugInfo = "[id=" + nodePtr->getId() + "]";
_frontend->renderFilledRect(x - 1, panelTextY + 1, font->getTextWidth(debugInfo) + 2, font->getTextHeight(debugInfo) + 2, colorGrayAlpha);
font->print(debugInfo, colorCyan, x, panelTextY);
panelTextY += font->getTextHeight(debugInfo);
}
}
void MapperRoomRender::renderCursor(int dc_x, int dc_y, int color)
{
RECT p = { dc_x-3, dc_y-3, dc_x+m_size+3, dc_y+m_size+3 };
HPEN old = (color == 0) ? m_hdc.SelectPen(m_exit) : m_hdc.SelectPen(m_yellow);
renderRect(dc_x-3, dc_y-3, m_size+6, m_size+6);
renderRect(dc_x-2, dc_y-2, m_size+4, m_size+4);
m_hdc.SelectPen(old);
}
bool Text::doRender() {
// Font-Resource locken.
FontResource *fontPtr = lockFontResource();
if (!fontPtr)
return false;
// Charactermap-Resource locken.
ResourceManager *rmPtr = getResourceManager();
BitmapResource *charMapPtr;
{
Resource *pResource = rmPtr->requestResource(fontPtr->getCharactermapFileName());
if (!pResource) {
BS_LOG_ERRORLN("Could not request resource \"%s\".", fontPtr->getCharactermapFileName().c_str());
return false;
}
if (pResource->getType() != Resource::TYPE_BITMAP) {
BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", fontPtr->getCharactermapFileName().c_str());
return false;
}
charMapPtr = static_cast<BitmapResource *>(pResource);
}
// Framebufferobjekt holen.
GraphicEngine *gfxPtr = Kernel::getInstance()->getGfx();
BS_ASSERT(gfxPtr);
bool result = true;
Common::Array<Line>::iterator iter = _lines.begin();
for (; iter != _lines.end(); ++iter) {
// Feststellen, ob überhaupt Buchstaben der aktuellen Zeile vom Update betroffen sind.
Common::Rect checkRect = (*iter).bbox;
checkRect.translate(_absoluteX, _absoluteY);
// Jeden Buchstaben einzeln Rendern.
int curX = _absoluteX + (*iter).bbox.left;
int curY = _absoluteY + (*iter).bbox.top;
for (uint i = 0; i < (*iter).text.size(); ++i) {
Common::Rect curRect = fontPtr->getCharacterRect((byte)(*iter).text[i]);
Common::Rect renderRect(curX, curY, curX + curRect.width(), curY + curRect.height());
int renderX = curX + (renderRect.left - renderRect.left);
int renderY = curY + (renderRect.top - renderRect.top);
renderRect.translate(curRect.left - curX, curRect.top - curY);
result = charMapPtr->blit(renderX, renderY, Image::FLIP_NONE, &renderRect, _modulationColor);
if (!result)
break;
curX += curRect.width() + fontPtr->getGapWidth();
}
}
// Charactermap-Resource freigeben.
charMapPtr->release();
// Font-Resource freigeben.
fontPtr->release();
return result;
}
void GuiSwatchButtonCtrl::onRender( Point2I offset, const RectI &updateRect )
{
bool highlight = mMouseOver;
ColorI borderColor = mActive ? ( highlight ? mProfile->mBorderColorHL : mProfile->mBorderColor ) : mProfile->mBorderColorNA;
RectI renderRect( offset, getExtent() );
if ( !highlight )
renderRect.inset( 1, 1 );
GFXDrawUtil *drawer = GFX->getDrawUtil();
drawer->clearBitmapModulation();
// Draw background transparency grid texture...
if ( mGrid.isValid() )
drawer->drawBitmapStretch( mGrid, renderRect );
// Draw swatch color as fill...
if (!mUseSRGB)
drawer->drawRectFill( renderRect, mSwatchColor.toGamma() );
else
drawer->drawRectFill(renderRect, mSwatchColor);
// Draw any borders...
drawer->drawRect( renderRect, borderColor );
}
void Render_SW_SDL::renderTextureCur(float x, float y, float w, float h, float ani_top, float ani_bottom, float ani_left, float ani_right)
{
if(!m_currentTexture)
{
renderRect(x, y, w, h,
(unsigned char)(255.f*color_binded_texture[0]),
(unsigned char)(255.f*color_binded_texture[1]),
(unsigned char)(255.f*color_binded_texture[2]),
(unsigned char)(255.f*color_binded_texture[3]) );
return;
}
SDL_Rect sourceRect = {
(int)roundf((float)m_currentTextureRect.width()*ani_left),
(int)roundf((float)m_currentTextureRect.height()*ani_top),
abs((int)roundf((float)m_currentTextureRect.width()*ani_right)-(int)roundf((float)m_currentTextureRect.width()*ani_left)),
abs((int)roundf((float)m_currentTextureRect.height()*ani_bottom)-(int)roundf((float)m_currentTextureRect.height()*ani_top))
};
SDL_Rect destRect = scaledRect(x, y, w, h);
SDL_SetTextureColorMod( m_currentTexture,
(unsigned char)(255.f*color_binded_texture[0]),
(unsigned char)(255.f*color_binded_texture[1]),
(unsigned char)(255.f*color_binded_texture[2]));
SDL_SetTextureAlphaMod( m_currentTexture, (unsigned char)(255.f*color_binded_texture[3]));
SDL_RenderCopy( m_gRenderer, m_currentTexture, &sourceRect, &destRect );
}
void Render_SW_SDL::renderTexture(PGE_Texture *texture, float x, float y, float w, float h, float ani_top, float ani_bottom, float ani_left, float ani_right)
{
if(!texture) return;
setRenderTexture( texture->texture );
m_currentTextureRect.setRect( 0, 0, texture->w, texture->h );
if(!m_currentTexture)
{
renderRect(x, y, w, h,
(unsigned char)(255.f*color_binded_texture[0]),
(unsigned char)(255.f*color_binded_texture[1]),
(unsigned char)(255.f*color_binded_texture[2]),
(unsigned char)(255.f*color_binded_texture[3]) );
return;
}
SDL_Rect sourceRect = { (int)roundf((float)texture->w*ani_left), (int)roundf((float)texture->h*ani_top),
(int)roundf((float)texture->w*ani_right)-(int)roundf((float)texture->w*ani_left),
(int)roundf((float)texture->h*ani_bottom)-(int)roundf((float)texture->h*ani_top)
};
SDL_Rect destRect = scaledRect(x, y, w, h);
SDL_SetTextureColorMod( m_currentTexture,
(unsigned char)(255.f*color_binded_texture[0]),
(unsigned char)(255.f*color_binded_texture[1]),
(unsigned char)(255.f*color_binded_texture[2]));
SDL_SetTextureAlphaMod( m_currentTexture, (unsigned char)(255.f*color_binded_texture[3]));
SDL_RenderCopy( m_gRenderer, m_currentTexture, &sourceRect, &destRect );
setUnbindTexture();
}
void Render_SW_SDL::renderTexture(PGE_Texture *texture, float x, float y)
{
if(!texture) return;
setRenderTexture( texture->texture );
m_currentTextureRect.setRect( 0, 0, texture->w, texture->h );
if(!m_currentTexture)
{
renderRect(x, y, texture->w, texture->h,
(unsigned char)(255.f*color_binded_texture[0]),
(unsigned char)(255.f*color_binded_texture[1]),
(unsigned char)(255.f*color_binded_texture[2]),
(unsigned char)(255.f*color_binded_texture[3]) );
return;
}
SDL_Rect aRect = scaledRectIS(x, y, texture->w, texture->h);
SDL_SetTextureColorMod( m_currentTexture,
(unsigned char)(255.f*color_binded_texture[0]),
(unsigned char)(255.f*color_binded_texture[1]),
(unsigned char)(255.f*color_binded_texture[2]));
SDL_SetTextureAlphaMod( m_currentTexture, (unsigned char)(255.f*color_binded_texture[3]));
SDL_RenderCopy( m_gRenderer, m_currentTexture, NULL, &aRect );
setUnbindTexture();
}
void Sun::Render(const CameraSpectator &camera)
{
if (!program)
initShaders();
glm::mat4 biasMVP = biasMatrix * camera.GetCameraMatrix();
glm::vec4 biassedPosition = biasMVP * glm::vec4(position,1.0);
biassedPosition /= biassedPosition.w;
//copy existing depth buffer to depth texture
glBindTexture(GL_TEXTURE_2D, texIdDepth[0]);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, camera.GetScreenWidth(), camera.GetScreenHeight());
//draw sun
glBindFramebuffer(GL_FRAMEBUFFER, fboId);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texIdColor[0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texIdDepth[1], 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderSun(camera);
//apply depth test
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texIdColor[1], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texIdColor[0]);
glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texIdDepth[1]);
glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, texIdDepth[0]);
depthTestProgram->Use();
renderRect();
depthTestProgram->UnUse();
//apply radial blur and render to screen
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
glEnable(GL_BLEND);
glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texIdColor[1]);
radialBlurProgram->Use();
glUniform2f(radialBlurProgram->GetUniformLocation("sourcePos"), biassedPosition.x, biassedPosition.y);
glDisable(GL_DEPTH_TEST);
renderRect();
glDisable(GL_DEPTH_TEST);
radialBlurProgram->UnUse();
glDisable(GL_BLEND);
}
bool Text::doRender(RectangleList *updateRects) {
// lock Font Resource
FontResource *fontPtr = lockFontResource();
if (!fontPtr)
return false;
// lock Character map resource
ResourceManager *rmPtr = getResourceManager();
BitmapResource *charMapPtr;
{
Resource *pResource = rmPtr->requestResource(fontPtr->getCharactermapFileName());
if (!pResource) {
warning("Could not request resource \"%s\".", fontPtr->getCharactermapFileName().c_str());
return false;
}
if (pResource->getType() != Resource::TYPE_BITMAP) {
error("Requested resource \"%s\" is not a bitmap.", fontPtr->getCharactermapFileName().c_str());
return false;
}
charMapPtr = static_cast<BitmapResource *>(pResource);
}
// Getting frame buffer object
GraphicEngine *gfxPtr = Kernel::getInstance()->getGfx();
assert(gfxPtr);
bool result = true;
Common::Array<Line>::iterator iter = _lines.begin();
for (; iter != _lines.end(); ++iter) {
// Determine whether any letters of the current line are affected by the update.
Common::Rect checkRect = (*iter).bbox;
checkRect.translate(_absoluteX, _absoluteY);
// Render each letter individually.
int curX = _absoluteX + (*iter).bbox.left;
int curY = _absoluteY + (*iter).bbox.top;
for (uint i = 0; i < (*iter).text.size(); ++i) {
Common::Rect curRect = fontPtr->getCharacterRect((byte)(*iter).text[i]);
Common::Rect renderRect(curX, curY, curX + curRect.width(), curY + curRect.height());
renderRect.translate(curRect.left - curX, curRect.top - curY);
result = charMapPtr->blit(curX, curY, Graphics::FLIP_NONE, &renderRect, _modulationColor, -1, -1, updateRects);
if (!result)
break;
curX += curRect.width() + fontPtr->getGapWidth();
}
}
// Free Character map resource
charMapPtr->release();
// Free Font resource
fontPtr->release();
return result;
}
void HudGaugeThrottle::renderMatchSpeedIcon(int x, int y)
{
if (Match_speed_draw_background)
{
// One pixel boundary
renderRect(x, y, Match_speed_icon_width + 2, gr_get_font_height() + 2);
gr_set_color_fast(&Color_black);
renderPrintf(x + 1, y + 1, "%c", Match_speed_icon);
setGaugeColor();
}
else
{
renderPrintf(x, y, "%c", Match_speed_icon);
}
}
void UINode::renderTop (int x, int y) const
{
const int childX = x + getRenderX();
const int childY = y + getRenderY();
if (_renderBorder) {
const int w = getRenderWidth(false);
const int h = getRenderHeight(false);
renderRect(x + getRenderX(false), y + getRenderY(false), w, h, _borderColor);
}
int textYOffset = 0;
for (DelayedTextsConstIter i = _texts.begin(); i != _texts.end(); ++i) {
const UINodeDelayedText& t = *i;
const int fontX = t.pos.x > 0.00001f ? (t.pos.x * _frontend->getWidth()) : (getRenderCenterX() - t.font->getTextWidth(t.text) / 2.0f);
int fontY;
if (t.pos.y > 0.00001f) {
fontY = t.pos.y * _frontend->getHeight();
} else {
const int textHeight = t.font->getTextHeight(t.text);
fontY = textYOffset + getRenderCenterY() - textHeight / 2.0f;
textYOffset += textHeight;
}
t.font->print(t.text, colorWhite, fontX, fontY);
}
const bool debug = Config.isDebugUI();
const bool focus = hasFocus();
if (debug && focus)
renderDebug(x, y, y + 20);
for (UINodeListConstIter i = _nodes.begin(); i != _nodes.end(); ++i) {
const UINode* nodePtr = *i;
if (!nodePtr->isVisible())
continue;
nodePtr->render(childX, childY);
}
}
void CCxImageCtrl::OnPaint()
{
CPaintDC dc(this); // device context for painting
CRect ClipRect;
GetClientRect(&ClipRect);
if(m_hImage.IsValid())
{
if(GetStretchMode())
{
m_hImage.Stretch(dc,ClipRect);
if(m_bCaptureWasSet&&GetState()==CCxImageCtrl::IS_Crop)
{
dc.Draw3dRect(CRect(m_RefPoint,m_CropActivePoint),RGB(255, 0, 0), RGB(0, 255, 0));
}
}
else
{
CRect renderRect(-m_nHScrollPos,-m_nVScrollPos,m_dwWidth-m_nHScrollPos,m_dwHeight-m_nVScrollPos);
m_hImage.Draw(dc,renderRect);
if(m_bCaptureWasSet&&GetState()==CCxImageCtrl::IS_Crop)
{
dc.Draw3dRect(CRect(m_RefPoint,m_CropActivePoint),RGB(255, 0, 0), RGB(0, 255, 0));
}
dc.SetBkColor(0xEEEEEE);
dc.ExcludeClipRect(renderRect);
dc.FillRect(ClipRect,&m_brHatch);
}
}
// Do not call CWnd::OnPaint() for painting messages
}
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;
}
// rendering functions
void renderEntity(Entity& e, SDL_Renderer *destination) {
renderRect( e.x - (e.width / 2), e.y - (e.height / 2), e.width, e.height, e.color, destination );
}
void Draw::writePng(char * name)
{
renderRect();
image.write(name);
}
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;
}
void MapperRoomRender::renderRoom(int x, int y, const Room *r)
{
CRect rp( x, y, x+m_size, y+m_size );
//CRect base(rp);
int cs = m_csize; // corridor size to draw (included)
int ds = 2; // doors offset to draw (included) - x= lefx - ds, len = cs + ds + ds
int rs = (cs- m_roomsizeDeflate) * 2;
rp.DeflateRect(cs, cs, rs, rs);
CRect bk(rp);
bk.DeflateRect(2,2,0,0);
HPEN old1 = m_hdc.SelectPen(m_black);
rp.OffsetRect(1, 1);
renderRect(rp.left,rp.top,rp.right-rp.left,rp.bottom-rp.top);
rp.OffsetRect(-1, -1);
m_hdc.SelectPen(m_white);
renderRect(rp.left,rp.top,rp.right-rp.left,rp.bottom-rp.top);
int offset = (rp.right - rp.left - cs) / 2;
// start points for corridors - top, bottom, left, right
int leftx = rp.left + offset;
int topy = rp.top + offset;
POINT ct = { leftx, rp.top };
POINT cb = { leftx, rp.bottom };
POINT cl = { rp.left, topy };
POINT cr = { rp.right, topy };
if (r->dirs[RD_NORTH].exist)
{
if (anotherZone(r, RD_NORTH))
{
int x0 = ct.x;
int x = ct.x - ds;
int y = ct.y - 1;
int len = cs + ds + ds;
m_hdc.SelectPen(m_exit);
renderLine(x,y,len,0);
renderLine(x,y+1,len,0);
renderLine(x,y+2,len,0);
m_hdc.SelectPen(m_exitL);
renderLine(x0,y+1,cs,0);
}
else if (neighbor(r, RD_NORTH))
{
int x = ct.x;
int x2 = x + cs;
int y = ct.y;
int len = -(cs+2);
m_hdc.SelectPen(m_black);
renderLine(x+1, y, 0, len);
renderLine(x2, y, 0, len);
m_hdc.SelectPen(m_white);
renderLine(x, y, 0, len);
renderLine(x2-1, y, 0, len);
renderLine(x2, y, 1, 1);
m_hdc.SelectPen(m_bkg);
renderLine(x2-1, y+1, 1, 1);
len = -(cs + 3);
fillBkg(x + 2, y + 2, cs - 3, len); // затираем стенку
}
else
{
m_hdc.SelectPen(m_white);
int x = ct.x + cs / 2;
int y = ct.y;
int dx = 0; int dy = 0;
if (!calcDestOffset(dx, dy, r, RD_NORTH))
{
renderLine(x, y, 0, -3);
renderLine(x+1, y, 0, -3);
}
else {
dy = dy + rp.bottom-rp.top;
renderArrow(x+dx, y+dy, -5, 5, 5, 4, 1, 0);
renderLine(x, y, dx, dy);
renderLine(x+1, y, dx, dy);
}
}
if (r->dirs[RD_NORTH].door)
{
int x = ct.x - ds;
int y = ct.y;
int len = cs + ds + ds;
m_hdc.SelectPen(m_door);
renderLine(x, y, len, 0);
m_hdc.SelectPen(m_black);
renderLine(x,y+1,len,0);
}
}
if (r->dirs[RD_SOUTH].exist)
{
if (anotherZone(r, RD_SOUTH))
{
int x0 = cb.x;
int x = cb.x - ds;
int y = cb.y + 1;
int len = cs + ds + ds;
m_hdc.SelectPen(m_exit);
renderLine(x, y, len, 0);
renderLine(x, y - 1, len, 0);
renderLine(x, y - 2, len, 0);
m_hdc.SelectPen(m_exitL);
renderLine(x0, y - 1, cs, 0);
}
else if (neighbor(r, RD_SOUTH))
{
int x = cb.x;
int x2 = x + cs;
int y = cb.y;
int len = cs + 2;
m_hdc.SelectPen(m_black);
renderLine(x + 1, y, 0, len);
renderLine(x2, y, 0, len);
m_hdc.SelectPen(m_white);
renderLine(x, y, 0, len);
renderLine(x2 - 1, y, 0, len);
m_hdc.SelectPen(m_bkg);
renderLine(x+1, y-1, 1, 1);
len = cs + 3;
fillBkg(x + 2, y - 2, cs-3, len); // затираем стенку
}
else
{
m_hdc.SelectPen(m_white);
int x = cb.x + cs / 2;
int y = cb.y;
int dx = 0; int dy = 0;
if (!calcDestOffset(dx, dy, r, RD_SOUTH))
{
renderLine(x, y, 0, 3);
renderLine(x+1, y, 0, 3);
}
else {
dy = dy - (rp.bottom-rp.top);
renderArrow(x+dx, y+dy, -5, -5, 5, -4, 1, 0);
renderLine(x, y, dx, dy);
renderLine(x+1, y, dx, dy);
}
}
if (r->dirs[RD_SOUTH].door)
{
int x = cb.x - ds;
int y = cb.y ;
int len = cs + ds + ds;
m_hdc.SelectPen(m_door);
renderLine(x, y, len, 0);
m_hdc.SelectPen(m_black);
renderLine(x, y-1, len, 0);
}
}
if (r->dirs[RD_WEST].exist)
{
if (anotherZone(r, RD_WEST))
{
int y0 = cl.y;
int y = cl.y - ds;
int x = cl.x + 1;
int len = cs + ds + ds;
m_hdc.SelectPen(m_exit);
renderLine(x, y, 0, len);
renderLine(x-1 , y, 0, len);
renderLine(x-2, y, 0, len);
m_hdc.SelectPen(m_exitL);
renderLine(x-1, y0, 0, cs);
}
else if (neighbor(r, RD_WEST))
{
int x = cl.x;
int y = cl.y;
int y2 = cl.y + cs;
int len = -(cs + 2);
m_hdc.SelectPen(m_black);
renderLine(x, y+1, len, 0);
renderLine(x, y2, len, 0 );
m_hdc.SelectPen(m_white);
renderLine(x, y, len, 0);
renderLine(x, y2-1, len, 0);
renderLine(x, y2, 1, 1);
m_hdc.SelectPen(m_bkg);
renderLine(x + 1, y2 - 1, 1, 1);
len = -(cs + 3);
fillBkg(x+2, y + 2, len, cs - 3); // затираем стенку
}
else
{
m_hdc.SelectPen(m_white);
int x = cl.x;
int y = cl.y + cs / 2;
int dx = 0; int dy = 0;
if (!calcDestOffset(dx, dy, r, RD_WEST))
{
renderLine(x, y, -3, 0);
renderLine(x, y+1, -3, 0);
}
else {
dx = dx + rp.right-rp.left;
renderArrow(x+dx, y+dy, 5, -5, 4, 5, -1, 0);
renderLine(x, y, dx, dy);
renderLine(x, y+1, dx, dy);
}
}
if (r->dirs[RD_WEST].door)
{
int x = cl.x;
int y = cl.y - ds;
int len = cs + ds + ds;
m_hdc.SelectPen(m_door);
renderLine(x, y, 0, len);
m_hdc.SelectPen(m_black);
renderLine(x+1, y, 0, len);
}
}
if (r->dirs[RD_EAST].exist)
{
if (anotherZone(r, RD_EAST))
{
int y0 = cr.y;
int y = cr.y - ds;
int x = cr.x - 1;
int len = cs + ds + ds;
m_hdc.SelectPen(m_exit);
renderLine(x, y, 0, len);
renderLine(x + 1, y, 0, len);
renderLine(x + 2, y, 0, len);
m_hdc.SelectPen(m_exitL);
renderLine(x + 1, y0, 0, cs);
}
else if (neighbor(r, RD_EAST))
{
int x = cr.x;
int y = cr.y;
int y2 = cr.y + cs;
int len = cs + 2;
m_hdc.SelectPen(m_black);
renderLine(x, y + 1, len, 0);
renderLine(x, y2, len, 0);
m_hdc.SelectPen(m_white);
renderLine(x, y, len, 0);
renderLine(x, y2 - 1, len, 0);
m_hdc.SelectPen(m_bkg);
renderLine(x-1 , y+1, 1, 1);
len = cs + 3;
fillBkg(x - 2, y + 2, len, cs - 3); // затираем стенку
}
else
{
m_hdc.SelectPen(m_white);
int x = cr.x;
int y = cr.y + cs / 2;
int dx = 0; int dy = 0;
if (!calcDestOffset(dx, dy, r, RD_EAST))
{
renderLine(x, y, 3, 0);
renderLine(x, y+1, 3, 0);
}
else {
dx = dx - (rp.right-rp.left);
renderArrow(x+dx, y+dy, -5, -5, -4, 5, 0, 1);
renderLine(x, y, dx, dy);
renderLine(x, y+1, dx, dy);
}
}
if (r->dirs[RD_EAST].door)
{
int x = cr.x;
int y = cr.y - ds;
int len = cs + ds + ds;
m_hdc.SelectPen(m_door);
renderLine(x, y, 0, len);
m_hdc.SelectPen(m_black);
renderLine(x - 1, y, 0, len);
}
}
int bkw = bk.Width()-1; int bkh = bk.Height()-1;
if (!r->selected) {
if (!r->use_color)
fillBkg(bk.left, bk.top, bkw, bkh );
else
fillColor(bk.left, bk.top, bkw, bkh, r->color);
}
else {
fillColor(bk.left, bk.top, bkw, bkh, RGB(255, 255, 255));
}
if (r->icon > 0)
{
int icons_count = m_plist->GetImageCount();
int icon_size = m_icons_size;
int x = bk.left + (bk.Width() - icon_size) / 2 - 1;
int y = bk.top + (bk.Height() - icon_size) / 2 - 1;
if (r->icon <= icons_count)
{
HICON icon = m_plist->GetIcon(r->icon - 1);
::DrawIconEx(m_hdc, x, y, icon, icon_size, icon_size, 1, NULL, DI_NORMAL);
}
}
int de = cs + 1; // size up/down corridor
if (r->dirs[RD_UP].exist)
{
int x = rp.left + 3;
int y = rp.top + 3;
int x2 = x + de;
int y2 = y + de;
m_hdc.SelectPen(m_black);
renderLine(x2, y, 0, de);
renderLine(x2, y2, -de, 0);
m_hdc.SelectPen(m_white);
renderLine(x,y2,0,-de);
renderLine(x,y,de+1,0);
if (r->dirs[RD_UP].door)
{
fillWhite(x+1,y+1,de-1,de-1);
}
else if (!r->dirs[RD_UP].next_room) // unknown room
{
fillBlack(x+1,y+1,de-1,de-1);
}
if (anotherZone(r, RD_UP))
{
fillExit(x+1,y+1,de-1,de-1);
m_hdc.SelectPen(m_exitL);
renderLine(x2, y, 0, de);
renderLine(x2, y2, -de, 0);
renderLine(x,y2,0,-de);
renderLine(x,y,de+1,0);
}
}
if (r->dirs[RD_DOWN].exist)
{
int x = rp.right - 3;
int y = rp.bottom - 3;
int x2 = x - de;
int y2 = y - de;
m_hdc.SelectPen(m_black);
renderLine(x2, y, 0, -de);
renderLine(x2, y2, de, 0);
m_hdc.SelectPen(m_white);
renderLine(x,y2,0,de);
renderLine(x,y,-de-1,0);
if (r->dirs[RD_DOWN].door)
{
fillWhite(x,y,-de+1,-de+1);
}
else if (!r->dirs[RD_DOWN].next_room) // unknown room
{
fillBlack(x,y,-de+1,-de+1);
}
if (anotherZone(r, RD_DOWN))
{
fillExit(x,y,-de+1,-de+1);
m_hdc.SelectPen(m_exitL);
renderLine(x2, y, 0, -de);
renderLine(x2, y2, de, 0);
renderLine(x,y2,0,de);
renderLine(x,y,-de-1,0);
}
}
m_hdc.SelectPen(old1);
}
