Deeangband/GameSurfaceSDL.cpp

   1 /*!
   2 * @file GameSurfaceSDL.cpp
   3 * @brief \83Q\81[\83\80\82Ì\83\81\83C\83\93\83C\83\93\83^\81[\83t\83F\83C\83X(SDL2.0\8eÀ\91\95)
   4 * @date 2014/02/19
   5 * @author Deskull
   6 * 2014 Sikabane Works.
   7 */
   8
   9 #include <vector>
  10 #include <string>
  11 #include "stdafx.h"
  12 #include "GameSurfaceSDL.h"
  13
  14 #include "GameEngine.h"
  15
  16 #include "Creature.h"
  17 #include "Field.h"
  18
  19 namespace Deeangband
  20 {
  21
  22         std::string toUTF8(LPCSTR str)
  23         {
  24                 const int cchWideChar = ::MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  25                 std::vector<WCHAR> lpw(cchWideChar);
  26
  27                 const int nUnicodeCount = ::MultiByteToWideChar(CP_ACP, 0, str, -1, &lpw[0], cchWideChar);
  28                 if(nUnicodeCount <= 0)
  29                 {
  30                         return "";
  31                 }
  32
  33                 const int cchMultiByte = ::WideCharToMultiByte(CP_UTF8, 0, &lpw[0], -1, NULL, 0, NULL, NULL);
  34                 std::vector<CHAR> lpa(cchMultiByte);
  35
  36                 const int nMultiCount = ::WideCharToMultiByte(CP_UTF8, 0, &lpw[0], -1, &lpa[0], cchMultiByte, NULL, NULL);
  37                 if(nMultiCount <= 0)
  38                 {
  39                         return "";
  40                 }
  41                 return std::string(&lpa[0]);
  42         }
  43
  44         GameSurfaceSDL::GameSurfaceSDL(GameWorld *gameWorld) : GameSurface(gameWorld)
  45         {
  46                 if(SDL_Init(SDL_INIT_VIDEO) < 0) return;
  47                 window = SDL_CreateWindow(GAME_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_RESIZABLE);
  48                 SDL_GetWindowSurface(window);
  49                 renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
  50                 if(!window) return;
  51
  52                 if(TTF_Init() == -1) return;
  53                 if(IMG_Init(IMG_INIT_PNG) != IMG_INIT_PNG) return;
  54
  55                 initInterfaces(gameWorld);
  56
  57                 viewCreaturePtr = NULL;
  58                 viewFieldPtr = NULL;
  59
  60                 windowSurface = SDL_GetWindowSurface(window);
  61
  62                 gameMessageTexture = NULL;
  63                 systemMessageTexture = NULL;
  64
  65                 frameTime = 0;
  66                 frameCount = 0;
  67                 framesPerSecond = 0;
  68                 frameDeltaTimeLast = frameTimeLast = SDL_GetTicks();
  69
  70                 SDL_SetRenderDrawBlendMode(this->renderer, SDL_BLENDMODE_NONE);
  71
  72                 this->rectTitleDst.Set(10, 10, 266, 266);
  73                 this->rectTitleSrc.Set(0, 0, 256, 256);
  74                 this->rectFpsDst.Set(0, 0, 50, 20);
  75                 this->rectFpsSrc.Set(0, 0, 50, 20);
  76
  77                 return;
  78         }
  79
  80         GameSurfaceSDL::~GameSurfaceSDL(void)
  81         {
  82                 IMG_Quit();
  83                 TTF_Quit();
  84                 SDL_Quit();
  85                 return;
  86         }
  87
  88         void GameSurfaceSDL::fpsProcess()
  89         {
  90                 SDL_Surface *surface;
  91                 char fpsBuf[12];
  92         int getTicks;
  93
  94                 frameCount++;
  95                 getTicks = SDL_GetTicks();
  96                 frameDeltaTime = getTicks - frameDeltaTimeLast;
  97                 frameDeltaTimeLast = getTicks;
  98         if (frameCount >= FPS_UPDATE)
  99                 {
 100                         frameCount = 0;
 101                         frameTime = getTicks - frameTimeLast;
 102                         frameTimeLast = getTicks;
 103                         framesPerSecond = (int)(1000.f * FPS_UPDATE / frameTime);
 104                         sprintf_s(fpsBuf, 8, "fps:%d", framesPerSecond);
 105                         surface = TTF_RenderUTF8_Blended(fontSmall, fpsBuf, color);
 106                         fpsTexture = SDL_CreateTextureFromSurface(renderer, surface);
 107                         SDL_FreeSurface(surface);
 108                 }
 109
 110                 SDL_RenderCopy(renderer, fpsTexture, &rectFpsSrc, &rectFpsDst);
 111
 112         }
 113
 114         void GameSurfaceSDL::pushAnyKey(const CREATURE_IT& subjectCreatureIt)
 115         {
 116                 SDL_Event event;
 117                 do
 118                 {
 119                         this->Draw(subjectCreatureIt);
 120                         SDL_PollEvent(&event);
 121                 } while(event.type != SDL_KEYDOWN);
 122         }
 123
 124         void GameSurfaceSDL::pushAnyKey(void)
 125         {
 126                 SDL_Event event;
 127                 do
 128                 {
 129                         SDL_Rect rect = {0, 0, 0, 0};
 130                         this->drawSystemMessage();
 131                         SDL_UpdateWindowSurfaceRects(window, &rect, 1);
 132                         SDL_UpdateWindowSurface(window);
 133
 134                         SDL_PollEvent(&event);
 135                 } while(event.type != SDL_KEYDOWN);
 136         }
 137
 138
 139         void GameSurfaceSDL::initInterfaces(GameWorld *gameWorld)
 140         {
 141                 std::map<TAG, boost::shared_ptr<Floor>>::iterator floorIt;
 142                 std::map<TAG, boost::shared_ptr<Species>>::iterator speciesIt;
 143                 SDL_Surface *surface, *tempSurface, *symbolSurface;
 144
 145                 //! @note TTF\83t\83H\83\93\83g\82Ì\93Ç\82Ý\8d\9e\82Ý
 146
 147                 font = TTF_OpenFont("ttf\\ipam.ttf", 14);
 148                 fontSmall = TTF_OpenFont("ttf\\ipag.ttf", 9);
 149                 src.x = 0;
 150                 src.y = 0;
 151                 src.w = 300;
 152                 src.h = 200;
 153                 title.x = 0;
 154                 title.y = 0;
 155                 title.w = 256;
 156                 title.h = 256;
 157                 color.r = 255;
 158                 color.g = 223;
 159                 color.b = 200;
 160                 color.a = 255;
 161
 162                 if(!font || !fontSmall)
 163                 {
 164                         OutputDebugString(L"Failed: loading .ttf files.\n");
 165                         exit(1);
 166                 }
 167
 168                 //! @note \83V\83X\83e\83\80\83O\83\89\83t\83B\83b\83N\82Ì\93Ç\82Ý\8d\9e\82Ý
 169                 rwop = SDL_RWFromFile("img\\Title.png", "rb");
 170                 error = IMG_GetError();
 171                 tempSurface = IMG_LoadPNG_RW(rwop);
 172                 titleTexture = SDL_CreateTextureFromSurface(renderer, tempSurface);
 173                 SDL_FreeSurface(tempSurface);
 174
 175                 //! @note \96¢\92m\92n\8c`\83O\83\89\83t\83B\83b\83N\82Ì\93Ç\82Ý\8d\9e\82Ý
 176                 rwop = SDL_RWFromFile("img\\UnknownField.png", "rb");
 177                 error = IMG_GetError();
 178                 tempSurface = IMG_LoadPNG_RW(rwop);
 179                 unknownFieldTexture = SDL_CreateTextureFromSurface(renderer, tempSurface);
 180                 SDL_FreeSurface(tempSurface);
 181
 182                 //! @note \8e\8b\8aE\8aO\92n\8c`\83O\83\89\83t\83B\83b\83N\82Ì\93Ç\82Ý\8d\9e\82Ý
 183                 rwop = SDL_RWFromFile("img\\UnseenField.png", "rb");
 184                 error = IMG_GetError();
 185                 tempSurface = IMG_LoadPNG_RW(rwop);
 186                 unseenFieldTexture = SDL_CreateTextureFromSurface(renderer, tempSurface);
 187                 SDL_FreeSurface(tempSurface);
 188
 189                 //! @note \8f°\92n\8c`\83O\83\89\83t\83B\83b\83N\82Ì\90Ý\92è
 190                 for(floorIt = gameWorld->GetFloorList()->begin(); floorIt != gameWorld->GetFloorList()->end(); floorIt++)
 191                 {
 192                         Color symColor = floorIt->second->GetSymbolColor();
 193                         Color backColor = floorIt->second->GetBackColor();
 194                         SDL_Color sdlSymCol = {(Uint8)symColor.GetRed(), (Uint8)symColor.GetGreen(), (Uint8)symColor.GetBlue(), (Uint8)symColor.GetAlpha()};
 195                         SDL_Rect blitRect = {0, 0, squareGraphicWidth, squareGraphicHeight};
 196                         SDL_Rect symbolRect = {0, 0, 30, 30};
 197                         char symBuf[80];
 198
 199                         surface = SDL_CreateRGBSurface(0, squareGraphicWidth, squareGraphicHeight, 32, 0, 0, 0, 0);
 200
 201                         SDL_FillRect(surface, &blitRect, SDL_MapRGBA(surface->format, (Uint8)backColor.GetRed(), (Uint8)backColor.GetGreen(), (Uint8)backColor.GetBlue(), (Uint8)backColor.GetAlpha()));
 202                         sprintf_s(symBuf, 5, "%s", floorIt->second->GetSymbol().c_str());
 203                         symbolSurface = TTF_RenderUTF8_Blended(font, toUTF8(symBuf).c_str(), sdlSymCol);
 204                         blitRect.x += (24 - symbolSurface->w) / 2;
 205                         blitRect.y += (24 - symbolSurface->h) / 2;
 206                         SDL_BlitSurface(symbolSurface, &symbolRect, surface, &blitRect);
 207                         SDL_FreeSurface(symbolSurface);
 208
 209                         floorTextures.insert(std::map<TAG, SDL_Texture*>::value_type(floorIt->first, SDL_CreateTextureFromSurface(renderer, surface)));
 210                 }
 211
 212                 SDL_GetWindowSurface(this->window);
 213                 this->windowSurface = SDL_GetWindowSurface(this->window);
 214         }
 215
 216         void GameSurfaceSDL::Draw(const CREATURE_IT& subjectCreatureIt)
 217         {
 218                 SDL_Rect rectTemp = {0, 0, 0, 0};
 219
 220                 SDL_RenderClear(renderer);
 221                 SDL_GetWindowSize(window, &rectTemp.w, &rectTemp.h);
 222
 223                 SDL_RenderCopy(renderer, titleTexture, &rectTitleSrc, &rectTitleDst);
 224
 225                 this->rectMainMapDst.Set(240, 30, rectTemp.w - 260, rectTemp.h - 60);
 226                 SDL_SetRenderDrawColor(renderer, 50, 20, 0, 255);
 227
 228                 if(this->viewFieldPtr)
 229                 {
 230                         this->drawField(subjectCreatureIt, gameWorld, viewFieldPtr, rectMainMapDst);
 231                 }
 232                 if(this->sideStatusCreatutePtr) this->drawSideCreatureStatus();
 233                 if(this->viewCreaturePtr) this->drawCreatureStatus(viewCreaturePtr);
 234                 if(this->currentSystemMessage.size() > 0) this->drawSystemMessage();
 235                 if(this->gameMessageTexture) this->drawGameMessage();
 236                 this->drawTimeStatus();
 237
 238                 this->fpsProcess();
 239                 SDL_Delay(WAIT_MSEC - frameDeltaTime > 0 ? WAIT_MSEC - frameDeltaTime : 0);
 240
 241                 SDL_RenderPresent(renderer);
 242
 243                 return;
 244         }
 245
 246         void GameSurfaceSDL::ViewCreatureStatus(Creature *creaturePtr)
 247         {
 248                 this->viewCreaturePtr = creaturePtr;
 249                 //pushAnyKey(NULL);
 250                 this->viewCreaturePtr = NULL;
 251         }
 252
 253         void GameSurfaceSDL::SetSideStatusCreature(Creature *creaturePtr)
 254         {
 255                 this->sideStatusCreatutePtr = creaturePtr;
 256                 if(creaturePtr) this->UpdateSideCreatureStatus(creaturePtr);
 257         }
 258
 259         void GameSurfaceSDL::SetField(Field *fieldPtr)
 260         {
 261                 this->viewFieldPtr = fieldPtr;
 262         }
 263
 264         void GameSurfaceSDL::drawCreatureStatus(Creature *creaturePtr)
 265         {
 266                 int id;
 267
 268                 enum CREATURE_STATUS_VIEW_POSITION
 269                 {
 270                         POS_NAME,
 271                         POS_LEVEL,
 272                         POS_HP,
 273                         POS_MP,
 274                         POS_AC,
 275                         POS_EV,
 276                         POS_VO,
 277                         POS_STR,
 278                         POS_INT,
 279                         POS_WIS,
 280                         POS_DEX,
 281                         POS_CON,
 282                         POS_CHA,
 283                         POS_SOUL,
 284                         POS_GOOD,
 285                         POS_EVIL,
 286                         POS_ORDER,
 287                         POS_CHAOS,
 288                         POS_BALANCE,
 289                         POS_HEIGHT,
 290                         POS_WEIGHT,
 291                         POS_BODY_SIZE,
 292                         POS_MAX
 293                 };
 294
 295                 SDL_Rect CreatureStatusViewPosition[POS_MAX] =
 296                 {
 297                         {10, 10, 0, 0},
 298                         {10, 30, 0, 0},
 299                         {10, 50, 0, 0},
 300                         {10, 70, 0, 0},
 301                         {10, 90, 0, 0},
 302                         {10, 110, 0, 0},
 303                         {10, 130, 0, 0},
 304                         {200, 30, 0, 0},
 305                         {200, 50, 0, 0},
 306                         {200, 70, 0, 0},
 307                         {200, 90, 0, 0},
 308                         {200, 110, 0, 0},
 309                         {200, 130, 0, 0},
 310                         {200, 150, 0, 0},
 311                         {200, 170, 0, 0},
 312                         {200, 190, 0, 0},
 313                         {200, 210, 0, 0},
 314                         {200, 230, 0, 0},
 315                         {200, 250, 0, 0},
 316                         {10, 150, 0, 0},
 317                         {10, 170, 0, 0},
 318                         {10, 190, 0, 0},
 319                 };
 320
 321                 SDL_Rect CreatureStatusViewRect[POS_MAX];
 322
 323                 const int STATUS_BUFSIZE = 100;
 324                 char statusBuf[POS_MAX][STATUS_BUFSIZE];
 325                 SDL_Surface *statusSurface[POS_MAX];
 326
 327                 SDL_Rect masterRect = {10, 10, 490, 450};
 328
 329                 sprintf_s(statusBuf[POS_NAME], STATUS_BUFSIZE, "\96¼\91O:%s", creaturePtr->GetName().c_str());
 330                 sprintf_s(statusBuf[POS_LEVEL], STATUS_BUFSIZE, "LV:%3d", creaturePtr->GetLevel());
 331                 sprintf_s(statusBuf[POS_HP], STATUS_BUFSIZE, "HP:%5d/%5d", creaturePtr->GetCurHP(), creaturePtr->GetMaxHP());
 332                 sprintf_s(statusBuf[POS_MP], STATUS_BUFSIZE, "MP:%5d/%5d", creaturePtr->GetCurMP(), creaturePtr->GetMaxMP());
 333                 sprintf_s(statusBuf[POS_AC], STATUS_BUFSIZE, "AC:%4d", creaturePtr->GetArmorSaving());
 334                 sprintf_s(statusBuf[POS_EV], STATUS_BUFSIZE, "EV:%4d", creaturePtr->GetEvasionSaving());
 335                 sprintf_s(statusBuf[POS_VO], STATUS_BUFSIZE, "VO:%4d", creaturePtr->GetVolitionSaving());
 336                 sprintf_s(statusBuf[POS_GOOD], STATUS_BUFSIZE, " \91P :%4d", creaturePtr->GetDiscipilneRank(DISCIPLINE_TYPE_GOOD));
 337                 sprintf_s(statusBuf[POS_EVIL], STATUS_BUFSIZE, " \88« :%4d", creaturePtr->GetDiscipilneRank(DISCIPLINE_TYPE_EVIL));
 338                 sprintf_s(statusBuf[POS_ORDER], STATUS_BUFSIZE, "\92\81\8f\98:%4d", creaturePtr->GetDiscipilneRank(DISCIPLINE_TYPE_ORDER));
 339                 sprintf_s(statusBuf[POS_CHAOS], STATUS_BUFSIZE, "\8d¬\93×:%4d", creaturePtr->GetDiscipilneRank(DISCIPLINE_TYPE_CHAOS));
 340                 sprintf_s(statusBuf[POS_BALANCE], STATUS_BUFSIZE, "\93V\94\89:%4d", creaturePtr->GetDiscipilneRank(DISCIPLINE_TYPE_BALANCE));
 341                 sprintf_s(statusBuf[POS_STR], STATUS_BUFSIZE, "\98r\97Í:%4d", creaturePtr->GetCurrentStatus(CS_STR));
 342                 sprintf_s(statusBuf[POS_INT], STATUS_BUFSIZE, "\92m\97Í:%4d", creaturePtr->GetCurrentStatus(CS_INT));
 343                 sprintf_s(statusBuf[POS_WIS], STATUS_BUFSIZE, "\8c«\82³:%4d", creaturePtr->GetCurrentStatus(CS_WIS));
 344                 sprintf_s(statusBuf[POS_DEX], STATUS_BUFSIZE, "\8aí\97p:%4d", creaturePtr->GetCurrentStatus(CS_DEX));
 345                 sprintf_s(statusBuf[POS_CON], STATUS_BUFSIZE, "\91Ï\8bv:%4d", creaturePtr->GetCurrentStatus(CS_CON));
 346                 sprintf_s(statusBuf[POS_CHA], STATUS_BUFSIZE, "\96£\97Í:%4d", creaturePtr->GetCurrentStatus(CS_CHA));
 347                 sprintf_s(statusBuf[POS_SOUL], STATUS_BUFSIZE, "\83\\83E\83\8b:%4d", creaturePtr->GetCurrentSoul());
 348                 sprintf_s(statusBuf[POS_HEIGHT], STATUS_BUFSIZE, "\90g\92·:%13s", GameElement::HeightFormat(creaturePtr->GetHeight()).c_str());
 349                 sprintf_s(statusBuf[POS_WEIGHT], STATUS_BUFSIZE, "\91Ì\8fd:%13s", GameElement::WeightFormat(creaturePtr->GetWeight()).c_str());
 350                 sprintf_s(statusBuf[POS_BODY_SIZE], STATUS_BUFSIZE, "\91Ì\8ai:%3d", creaturePtr->GetSize());
 351
 352                 for(id = 0; id < POS_MAX; id++)
 353                 {
 354                         statusSurface[id] = TTF_RenderUTF8_Blended(font, toUTF8(statusBuf[id]).c_str(), color);
 355                         CreatureStatusViewRect[id].x = 0;
 356                         CreatureStatusViewRect[id].y = 0;
 357                         CreatureStatusViewRect[id].w = statusSurface[id]->w;
 358                         CreatureStatusViewRect[id].h = statusSurface[id]->h;
 359                         CreatureStatusViewPosition[id].x += masterRect.x;
 360                         CreatureStatusViewPosition[id].y += masterRect.y;
 361                 }
 362
 363                 SDL_FillRect(windowSurface, &masterRect, SDL_MapRGBA(windowSurface->format, 0, 0, 0, 120));
 364
 365                 for(id = 0; id < POS_MAX; id++)
 366                 {
 367                         SDL_BlitSurface(statusSurface[id], &CreatureStatusViewRect[id], windowSurface, &CreatureStatusViewPosition[id]);
 368                 }
 369
 370                 for(id = 0; id < POS_MAX; id++)
 371                 {
 372                         SDL_FreeSurface(statusSurface[id]);
 373                 }
 374                 return;
 375         }
 376
 377         void GameSurfaceSDL::UpdateTimeStatus(GAME_TIME currentTime)
 378         {
 379
 380                 SDL_Rect rect = {0, 0, 200, 50};
 381                 SDL_Rect StatusViewRect = {0, 0, 200, 50};
 382                 SDL_Rect StatusViewPosition = {10, 10, 0, 0};
 383                 SDL_Surface *surface, *statusSurface;
 384                 const int STATUS_BUFSIZE = 100;
 385                 char statusBuf[STATUS_BUFSIZE];
 386                 if(gameTimeStatusTexture) SDL_DestroyTexture(gameTimeStatusTexture);
 387                 surface = SDL_CreateRGBSurface(0, 200, 50, 32, 0, 0, 0, 0);
 388                 SDL_FillRect(surface, &rect, SDL_MapRGBA(windowSurface->format, 0, 0, 0, 120));
 389                 sprintf_s(statusBuf, STATUS_BUFSIZE, "\83Q\81[\83\80\8e\9e\8aÔ:%d", currentTime);
 390                 statusSurface = TTF_RenderUTF8_Blended(font, toUTF8(statusBuf).c_str(), color);
 391                 SDL_BlitSurface(statusSurface, &StatusViewRect, surface, &StatusViewPosition);
 392                 gameTimeStatusTexture = SDL_CreateTextureFromSurface(renderer, surface);
 393                 SDL_FreeSurface(statusSurface);
 394                 SDL_FreeSurface(surface);
 395         }
 396
 397         void GameSurfaceSDL::UpdateSideCreatureStatus(Creature *creaturePtr)
 398         {
 399                 int id;
 400                 SDL_Surface *surface;
 401
 402                 enum CREATURE_SIDE_STATUS_VIEW_POSITION
 403                 {
 404                         POS_NAME,
 405                         POS_LEVEL,
 406                         POS_HP,
 407                         POS_MP,
 408                         POS_AC,
 409                         POS_EV,
 410                         POS_VO,
 411                         POS_STR,
 412                         POS_INT,
 413                         POS_WIS,
 414                         POS_DEX,
 415                         POS_CON,
 416                         POS_CHA,
 417                         POS_SOUL,
 418                         POS_X,
 419                         POS_Y,
 420                         POS_MAX
 421                 };
 422
 423                 SDL_Rect CreatureStatusViewPosition[POS_MAX] =
 424                 {
 425                         {10, 10, 0, 0},
 426                         {10, 30, 0, 0},
 427                         {10, 50, 0, 0},
 428                         {10, 70, 0, 0},
 429                         {10, 90, 0, 0},
 430                         {10, 110, 0, 0},
 431                         {10, 130, 0, 0},
 432                         {200, 30, 0, 0},
 433                         {200, 50, 0, 0},
 434                         {200, 70, 0, 0},
 435                         {200, 90, 0, 0},
 436                         {200, 110, 0, 0},
 437                         {200, 130, 0, 0},
 438                         {200, 150, 0, 0},
 439                         {10, 170, 0, 0},
 440                         {70, 170, 0, 0},
 441                 };
 442
 443                 SDL_Rect CreatureStatusViewRect[POS_MAX];
 444
 445                 const int STATUS_BUFSIZE = 100;
 446                 char statusBuf[POS_MAX][STATUS_BUFSIZE];
 447                 SDL_Surface *statusSurface[POS_MAX];
 448
 449                 SDL_Rect masterRect = {0, 0, 180, 350};
 450
 451                 surface = SDL_CreateRGBSurface(0, 180, 350, 32, 0, 0, 0, 0);
 452
 453                 sprintf_s(statusBuf[POS_NAME], STATUS_BUFSIZE, "\96¼\91O:%s", creaturePtr->GetName().c_str());
 454                 sprintf_s(statusBuf[POS_LEVEL], STATUS_BUFSIZE, "LV:%3d", creaturePtr->GetLevel());
 455                 sprintf_s(statusBuf[POS_HP], STATUS_BUFSIZE, "HP:%5d/%5d", creaturePtr->GetCurHP(), creaturePtr->GetMaxHP());
 456                 sprintf_s(statusBuf[POS_MP], STATUS_BUFSIZE, "MP:%5d/%5d", creaturePtr->GetCurMP(), creaturePtr->GetMaxMP());
 457                 sprintf_s(statusBuf[POS_AC], STATUS_BUFSIZE, "AC:%4d", creaturePtr->GetArmorSaving());
 458                 sprintf_s(statusBuf[POS_EV], STATUS_BUFSIZE, "EV:%4d", creaturePtr->GetEvasionSaving());
 459                 sprintf_s(statusBuf[POS_VO], STATUS_BUFSIZE, "VO:%4d", creaturePtr->GetVolitionSaving());
 460                 sprintf_s(statusBuf[POS_STR], STATUS_BUFSIZE, "\98r\97Í:%4d", creaturePtr->GetCurrentStatus(CS_STR));
 461                 sprintf_s(statusBuf[POS_INT], STATUS_BUFSIZE, "\92m\97Í:%4d", creaturePtr->GetCurrentStatus(CS_INT));
 462                 sprintf_s(statusBuf[POS_WIS], STATUS_BUFSIZE, "\8c«\82³:%4d", creaturePtr->GetCurrentStatus(CS_WIS));
 463                 sprintf_s(statusBuf[POS_DEX], STATUS_BUFSIZE, "\8aí\97p:%4d", creaturePtr->GetCurrentStatus(CS_DEX));
 464                 sprintf_s(statusBuf[POS_CON], STATUS_BUFSIZE, "\91Ï\8bv:%4d", creaturePtr->GetCurrentStatus(CS_CON));
 465                 sprintf_s(statusBuf[POS_CHA], STATUS_BUFSIZE, "\96£\97Í:%4d", creaturePtr->GetCurrentStatus(CS_CHA));
 466                 sprintf_s(statusBuf[POS_SOUL], STATUS_BUFSIZE, "\83\\83E\83\8b:%4d", creaturePtr->GetCurrentSoul());
 467                 sprintf_s(statusBuf[POS_X], STATUS_BUFSIZE, "X:%4d", creaturePtr->GetPosition().GetX());
 468                 sprintf_s(statusBuf[POS_Y], STATUS_BUFSIZE, "Y:%4d", creaturePtr->GetPosition().GetY());
 469
 470                 for(id = 0; id < POS_MAX; id++)
 471                 {
 472                         statusSurface[id] = TTF_RenderUTF8_Blended(font, toUTF8(statusBuf[id]).c_str(), color);
 473                         CreatureStatusViewRect[id].x = 0;
 474                         CreatureStatusViewRect[id].y = 0;
 475                         CreatureStatusViewRect[id].w = statusSurface[id]->w;
 476                         CreatureStatusViewRect[id].h = statusSurface[id]->h;
 477                         CreatureStatusViewPosition[id].x += masterRect.x;
 478                         CreatureStatusViewPosition[id].y += masterRect.y;
 479                 }
 480
 481                 SDL_FillRect(surface, &masterRect, SDL_MapRGBA(surface->format, 0, 0, 0, 120));
 482
 483                 for(id = 0; id < POS_MAX; id++)
 484                 {
 485                         SDL_BlitSurface(statusSurface[id], &CreatureStatusViewRect[id], surface, &CreatureStatusViewPosition[id]);
 486                 }
 487
 488                 for(id = 0; id < POS_MAX; id++)
 489                 {
 490                         SDL_FreeSurface(statusSurface[id]);
 491                 }
 492
 493                 creatureSideStatusTexture = SDL_CreateTextureFromSurface(renderer, surface);
 494                 SDL_FreeSurface(surface);
 495
 496                 return;
 497
 498         }
 499
 500         void GameSurfaceSDL::drawSideCreatureStatus(void)
 501         {
 502                 SDL_Rect masterRect = {0, 0, 180, 350};
 503                 SDL_Rect posRect = {10, 120, 180, 350};
 504                 SDL_RenderCopy(renderer, creatureSideStatusTexture, &masterRect, &posRect);
 505         }
 506
 507         GAME_COMMAND GameSurfaceSDL::GetCommand(const CREATURE_IT& subjectCreatureIt)
 508         {
 509                 SDL_Event event;
 510                 SDL_Keycode key;
 511
 512                 this->Draw(subjectCreatureIt);
 513                 while (SDL_PollEvent(&event))
 514                 {
 515
 516                         switch(event.type)
 517                         {
 518
 519                         case SDL_KEYDOWN:
 520                                 {
 521                                         key=event.key.keysym.sym;
 522
 523                                         switch(key)
 524                                         {
 525                                         case SDLK_ESCAPE:
 526                                                 return GAME_COMMAND_EXIT;
 527                                         case SDLK_c:
 528                                                 return GAME_COMMAND_VIEW_PLAYER_STATUS;
 529                                         case SDLK_F11:
 530                                                 return GAME_COMMAND_DEBUG_XML_SAVE;
 531                                         case SDLK_F12:
 532                                                 return GAME_COMMAND_DEBUG_XML_LOAD;
 533                                         case SDLK_k:
 534                                                 return GAME_COMMAND_NORTH;
 535                                         case SDLK_u:
 536                                                 return GAME_COMMAND_NORTH_EAST;
 537                                         case SDLK_l:
 538                                                 return GAME_COMMAND_EAST;
 539                                         case SDLK_n:
 540                                                 return GAME_COMMAND_SOUTH_EAST;
 541                                         case SDLK_j:
 542                                                 return GAME_COMMAND_SOUTH;
 543                                         case SDLK_b:
 544                                                 return GAME_COMMAND_SOUTH_WEST;
 545                                         case SDLK_h:
 546                                                 return GAME_COMMAND_WEST;
 547                                         case SDLK_y:
 548                                                 return GAME_COMMAND_NORTH_WEST;
 549                                         case SDLK_s:
 550                                                 return GAME_COMMAND_STAY;
 551                                         }
 552
 553                                 }
 554                                 break;
 555
 556                         case SDL_WINDOWEVENT:
 557                                 switch (event.window.event) {
 558                                 case SDL_WINDOWEVENT_SHOWN:
 559                                         break;
 560                                 case SDL_WINDOWEVENT_HIDDEN:
 561                                         break;
 562                                 case SDL_WINDOWEVENT_EXPOSED:
 563                                         break;
 564                                 case SDL_WINDOWEVENT_MOVED:
 565                                         break;
 566                                 case SDL_WINDOWEVENT_RESIZED:
 567                                         break;
 568                                 case SDL_WINDOWEVENT_MINIMIZED:
 569                                         break;
 570                                 case SDL_WINDOWEVENT_MAXIMIZED:
 571                                         break;
 572                                 case SDL_WINDOWEVENT_RESTORED:
 573                                         break;
 574                                 case SDL_WINDOWEVENT_ENTER:
 575                                         break;
 576                                 case SDL_WINDOWEVENT_LEAVE:
 577                                         break;
 578                                 case SDL_WINDOWEVENT_FOCUS_GAINED:
 579                                         break;
 580                                 case SDL_WINDOWEVENT_FOCUS_LOST:
 581                                         break;
 582                                 case SDL_WINDOWEVENT_CLOSE:
 583                                         break;
 584                                 default:
 585                                         break;
 586                                 }
 587                                 this->Draw(subjectCreatureIt);
 588                                 break;
 589
 590                         case SDL_QUIT:
 591                                 return GAME_COMMAND_EXIT;
 592                                 break;
 593
 594                 }
 595         }
 596
 597         return GAME_COMMAND_REDRAW;
 598 }
 599
 600 void GameSurfaceSDL::drawField(const CREATURE_IT &subjectCreatureIt, GameWorld *gameWorld, Field *fieldPtr, SDL_Rect_Dee &rectDraw)
 601 {
 602         SDL_Rect symbolRect = {0, 0, squareGraphicWidth, squareGraphicHeight};
 603         CREATURE_IT creatureIt;
 604         Creature *subJectCreaturePtr = subjectCreatureIt->second.get();
 605
 606         MAP_LENGTH fx = this->focusPoint.GetX();
 607         MAP_LENGTH fy = this->focusPoint.GetY();
 608
 609         MAP_LENGTH fieldw = this->viewFieldPtr->GetWidth();
 610         MAP_LENGTH fieldh = this->viewFieldPtr->GetHeight();
 611
 612         MAP_LENGTH w = rectDraw.w / this->squareGraphicWidth + 1;
 613         MAP_LENGTH h = rectDraw.h / this->squareGraphicHeight + 1;
 614         MAP_LENGTH x = fx - (w / 2);
 615         MAP_LENGTH y = fy - (h / 2);
 616
 617         MAP_LENGTH px, py, sx = 0, sy = 0;
 618
 619         //sx = - (rectDraw.w % (this->squareGraphicWidth / 2));
 620         //sy = - (rectDraw.h % (this->squareGraphicHeight / 2));
 621
 622         if(x > fieldw - w + this->fieldPadding) x = fieldw - w + this->fieldPadding;
 623         if(y > fieldh - h + this->fieldPadding) y = fieldh - h + this->fieldPadding;
 624         if(x < -this->fieldPadding) x = -this->fieldPadding;
 625         if(y < -this->fieldPadding) y = -this->fieldPadding;
 626
 627
 628         SDL_RenderSetViewport(this->renderer, &rectDraw);
 629
 630         for(py = y; py <= y + h; py++)
 631         {
 632                 for(px = x; px <= x + w; px++)
 633                 {
 634                         if(px >= 0 && py >= 0 && px < fieldPtr->GetWidth() && py < fieldPtr->GetHeight())
 635                         {
 636                                 SDL_Rect blitRect = {(px - x) * squareGraphicWidth - sx, (py - y) * squareGraphicHeight - sy, squareGraphicWidth, squareGraphicHeight};
 637
 638                                 /*
 639                                 SDL_Rect checkRect1 = {(px - x) * squareGraphicWidth - sx - 2 + 12, 30 + (py - y) * squareGraphicHeight - 2 - sy + 12, 4, 4};
 640                                 SDL_Rect checkRect2 = {(px - x) * squareGraphicWidth - sx - 2, 30 + (py - y) * squareGraphicHeight - 2 - sy , 4, 4};
 641                                 SDL_Rect checkRect3 = {(px - x) * squareGraphicWidth - sx - 6 + 12, 30 + (py - y) * squareGraphicHeight - 1 - sy , 12, 2};
 642                                 SDL_Rect checkRect4 = {(px - x) * squareGraphicWidth - sx - 1, 30 + (py - y) * squareGraphicHeight - 6 + 12 - sy , 2, 12};
 643                                 */
 644
 645                                 if(subJectCreaturePtr->InSight(px, py))
 646                                 {
 647                                         TAG tag = fieldPtr->GetSquare(px, py)->GetFloorTag();
 648                                         SDL_RenderCopy(renderer, floorTextures[tag], &symbolRect, &blitRect);
 649                                         if(!subJectCreaturePtr->InSight(px, py))
 650                                         {
 651                                                 SDL_Rect fieldRect = {blitRect.x % 128, blitRect.y % 128, squareGraphicWidth, squareGraphicHeight};
 652                                                 SDL_RenderCopy(this->renderer, unseenFieldTexture, &fieldRect, &blitRect);
 653                                         }
 654                                 }
 655                                 else
 656                                 {
 657                                         SDL_Rect fieldRect = {blitRect.x % 128, blitRect.y % 128, squareGraphicWidth, squareGraphicHeight};
 658                                         SDL_RenderCopy(this->renderer, unknownFieldTexture, &fieldRect, &blitRect);
 659                                 }
 660
 661                                 /*
 662                                 if(fieldPtr->GetSightPass(px * 2 + 1, py * 2 + 1))
 663                                         SDL_SetRenderDrawColor(this->renderer, 255, 255, 255, 255);
 664                                 else
 665                                         SDL_SetRenderDrawColor(this->renderer, 255, 0, 0, 255);
 666                                 SDL_RenderFillRect(this->renderer, &checkRect1);
 667
 668                                 if(fieldPtr->GetSightPass(px * 2, py * 2))
 669                                         SDL_FillRect(windowSurface, &checkRect2, SDL_MapRGBA(windowSurface->format, 255, 255, 255, 255));
 670                                 else
 671                                         SDL_FillRect(windowSurface, &checkRect2, SDL_MapRGBA(windowSurface->format, 255, 0, 0, 255));
 672
 673                                 if(fieldPtr->GetSightPass(px * 2 + 1, py * 2))
 674                                         SDL_FillRect(windowSurface, &checkRect3, SDL_MapRGBA(windowSurface->format, 255, 255, 255, 255));
 675                                 else
 676                                         SDL_FillRect(windowSurface, &checkRect3, SDL_MapRGBA(windowSurface->format, 255, 0, 0, 255));
 677
 678                                 if(fieldPtr->GetSightPass(px * 2, py * 2 + 1))
 679                                         SDL_FillRect(windowSurface, &checkRect4, SDL_MapRGBA(windowSurface->format, 255, 255, 255, 255));
 680                                 else
 681                                         SDL_FillRect(windowSurface, &checkRect4, SDL_MapRGBA(windowSurface->format, 255, 0, 0, 255));
 682                                 */
 683
 684                         }
 685                 }
 686         }
 687
 688         for(creatureIt = gameWorld->GetCreatureList()->begin(); creatureIt != gameWorld->GetCreatureList()->end(); creatureIt++)
 689         {
 690                 if(!creatureTextures[creatureIt->first])
 691                 {
 692                         updateCreatureGraphics(creatureIt);
 693                 }
 694
 695                 if(subJectCreaturePtr->InSight(creatureIt->second->GetPosition().GetX(), creatureIt->second->GetPosition().GetY()))
 696                 {
 697                         SDL_Rect blitRect = {(creatureIt->second->GetPosition().GetX() - x) * squareGraphicWidth - sx, (creatureIt->second->GetPosition().GetY()- y) * squareGraphicHeight - sy, squareGraphicWidth, squareGraphicHeight};
 698                         SDL_RenderCopy(renderer, creatureTextures[creatureIt->first], &symbolRect, &blitRect);
 699                 }
 700
 701                 /*
 702                 if(subjectCreatureIt->second->GetLore()->GetFieldLore(0, creatureIt->second->GetPosition().GetX(), creatureIt->second->GetPosition().GetY()) > 0)
 703                 {
 704                         SDL_Rect blitRect = {GameSurfaceSDL::sideBarWidth + (creatureIt->second->GetPosition().GetX() - x) * squareGraphicWidth, 30 + (creatureIt->second->GetPosition().GetY()- y) * squareGraphicHeight, squareGraphicWidth, squareGraphicHeight};
 705                         SDL_BlitSurface(creatureSurfaces[creatureIt->first], &symbolRect, windowSurface, &blitRect);
 706                 }
 707                 */
 708         }
 709
 710         SDL_RenderSetViewport(this->renderer, NULL);
 711
 712 }
 713
 714         void GameSurfaceSDL::FocusField(MAP_LENGTH x, MAP_LENGTH y)
 715         {
 716                 this->focusPoint.Set(x, y);
 717         }
 718
 719         void GameSurfaceSDL::FocusField(Coordinates coord)
 720         {
 721                 this->focusPoint.Set(coord.GetX(), coord.GetY());
 722         }
 723
 724         void GameSurfaceSDL::drawSystemMessage(void)
 725         {
 726                 SDL_Rect messageRect = {0, 0, 200, 200};
 727                 SDL_Rect messagePositon = {220, 180, 420, 380};
 728                 SDL_RenderCopy(renderer, systemMessageTexture, &messageRect, &messagePositon);
 729         }
 730
 731         void GameSurfaceSDL::drawGameMessage(void)
 732         {
 733                 SDL_Rect messageRect = {0, 0, 512, 20};
 734                 SDL_Rect messagePositon = {242, 4, 512, 20};
 735                 SDL_RenderCopy(renderer, gameMessageTexture, &messageRect, &messagePositon);
 736         }
 737
 738         void GameSurfaceSDL::drawTimeStatus(void)
 739         {
 740                 SDL_Rect messageRect = {0, 0, 200, 50};
 741                 SDL_Rect messagePositon = {10, 480, 200, 50};
 742                 SDL_RenderCopy(renderer, gameTimeStatusTexture, &messageRect, &messagePositon);
 743         }
 744
 745         void GameSurfaceSDL::SystemMessage(std::string message)
 746         {
 747                 SDL_Surface *surface;
 748                 this->currentSystemMessage = message;
 749                 surface = TTF_RenderUTF8_Blended(font, toUTF8(this->currentSystemMessage.c_str()).c_str(), color);
 750                 systemMessageTexture = SDL_CreateTextureFromSurface(renderer, surface);
 751                 pushAnyKey();
 752                 this->currentSystemMessage.erase();
 753                 SDL_FreeSurface(surface);
 754         }
 755
 756         void GameSurfaceSDL::GameMessage(std::string message)
 757         {
 758                 SDL_Surface *boxSurface, *textSurface;
 759                 SDL_Rect textPosition = {2, 2, 0, 0};
 760                 this->currentGameMessage = message;
 761                 if(gameMessageTexture) SDL_DestroyTexture(gameMessageTexture);
 762                 boxSurface = SDL_CreateRGBSurface(0, 512, 20, 32, 0, 0, 0, 0);
 763                 textSurface = TTF_RenderUTF8_Blended(font, toUTF8(this->currentGameMessage.c_str()).c_str(), color);
 764                 SDL_BlitSurface(textSurface, NULL, boxSurface, &textPosition);
 765                 gameMessageTexture = SDL_CreateTextureFromSurface(renderer, boxSurface);
 766                 SDL_FreeSurface(textSurface);
 767                 SDL_FreeSurface(boxSurface);
 768         }
 769
 770         void GameSurfaceSDL::updateCreatureGraphics(CREATURE_IT creatureIt)
 771         {
 772                 SDL_Rect symbolRect = {0, 0, squareGraphicWidth, squareGraphicHeight};
 773                 SDL_Surface *surface, *symbolSurface;
 774                 char symBuf[5];
 775
 776                 SDL_DestroyTexture(creatureTextures[creatureIt->first]);
 777                 creatureTextures.erase(creatureIt->first);
 778
 779                 surface = SDL_CreateRGBSurface(0, squareGraphicWidth, squareGraphicHeight, 32, 0, 0, 0, 0);
 780                 Color symColor = creatureIt->second->GetSymbolColor();
 781                 SDL_Color sdlSymCol = {(Uint8)symColor.GetRed(), (Uint8)symColor.GetGreen(), (Uint8)symColor.GetBlue(), (Uint8)symColor.GetAlpha()};
 782                 sprintf_s(symBuf, 5, "%s", creatureIt->second->GetSymbol().c_str());
 783                 SDL_Rect blitRect = {0, 0, squareGraphicWidth, squareGraphicHeight};
 784
 785                 symbolSurface = TTF_RenderUTF8_Blended(font, toUTF8(symBuf).c_str(), sdlSymCol);
 786
 787                 blitRect.x += (squareGraphicWidth - symbolSurface->w) / 2;
 788                 blitRect.y += (squareGraphicHeight - symbolSurface->h) / 2;
 789
 790                 SDL_BlitSurface(symbolSurface, &symbolRect, surface, &blitRect);
 791                 SDL_FreeSurface(symbolSurface);
 792
 793                 creatureTextures.insert(std::map<ID, SDL_Texture*>::value_type(creatureIt->first, SDL_CreateTextureFromSurface(renderer, surface)));
 794                 SDL_FreeSurface(surface);
 795         }
 796
 797
 798 }