Deeangband/GameWorld.cpp

   1 /*!
   2 * @file GameWorld.cpp
   3 * @brief \83Q\81[\83\80\90¢\8aE\82ð\92è\8b`\82·\82é
   4 * @date 2013/12/22
   5 * @author Deskull
   6 * 2013 Sikabane Works.
   7 */
   8
   9 #include "stdafx.h"
  10 #include "GameWorld.h"
  11 #include "Deeangband.h"
  12
  13 #include "Coordinates.h"
  14 #include "HaveGameTime.h"
  15
  16 #include "Air.h"
  17 #include "Ability.h"
  18 #include "Authority.h"
  19 #include "Building.h"
  20 #include "Camp.h"
  21 #include "CreatureTrait.h"
  22
  23 #include "Creature.h"
  24 #include "Dungeon.h"
  25 #include "Effect.h"
  26 #include "Floor.h"
  27
  28 #include "HaveGameTime.h"
  29
  30 #include "FixedArtifact.h"
  31 #include "GameMessage.h"
  32 #include "ItemBase.h"
  33 #include "ItemEgo.h"
  34 #include "ItemTrait.h"
  35 #include "Karma.h"
  36 #include "Lore.h"
  37 #include "Quest.h"
  38 #include "Race.h"
  39 #include "Space.h"
  40 #include "Skill.h"
  41 #include "Species.h"
  42 #include "StartingClass.h"
  43 #include "TrapBase.h"
  44
  45 #include "Item.h"
  46 #include "Field.h"
  47 #include "Trap.h"
  48
  49 namespace Deeangband
  50 {
  51
  52         GameWorld::GameWorld(void)
  53         {
  54                 XMLLoad();
  55
  56                 this->itemID = 0;
  57                 this->trapID = 0;
  58                 this->creatureID = 0;
  59                 this->fieldID = 0;
  60                 this->gameTime = 0;
  61
  62         }
  63
  64         void GameWorld::Initialize(void)
  65         {
  66                 int i;
  67                 std::map<ID, std::shared_ptr<Field>>::iterator fieldIt;
  68                 std::map<TAG, std::shared_ptr<Species>>::iterator speciesIt;
  69                 fieldList.emplace(0, std::make_shared<Field>(dungeonList.find("VANILLA_WOMB"), 1));
  70                 fieldIt = fieldList.find(0);
  71
  72                 speciesIt = speciesList.find("VANILLA_STIGMATIC");
  73                 GameWorld::GenerateCreature(speciesIt, fieldIt, 10, 10);
  74
  75                 speciesIt = speciesList.find("VANILLA_RAVING_LUNATIC");
  76                 GameWorld::GenerateCreature(speciesIt, fieldIt, 5, 5);
  77
  78                 for(i = 0; i < MAX_KARMAS; i++)
  79                 {
  80                         karmaList.emplace("VANILLA_", std::make_shared<Karma>());
  81                 }
  82                 playerIt = creatureList.begin()++;
  83         }
  84
  85
  86         GameWorld::~GameWorld(void)
  87         {
  88         }
  89
  90         bool GameWorld::GenerateCreature(std::map<TAG, std::shared_ptr<Species>>::iterator& speciesIt)
  91         {
  92                 creatureList.emplace(this->creatureID, std::make_shared<Creature>(speciesIt));
  93                 do
  94                 {
  95                         this->creatureID++;
  96                 } while(creatureList.find(this->creatureID) != creatureList.end());
  97                 return true;
  98         }
  99
 100         bool GameWorld::GenerateCreature(std::map<TAG, std::shared_ptr<Species>>::iterator& speciesIt, std::map<ID, std::shared_ptr<Field>>::iterator& fieldIt, MAP_LENGTH x, MAP_LENGTH y)
 101         {
 102                 std::map<ID, std::shared_ptr<Creature>>::iterator creatureIt;
 103                 HaveGameTime *test;
 104                 creatureList.emplace(this->creatureID, std::make_shared<Creature>(speciesIt, fieldIt, x, y));
 105                 creatureIt = creatureList.find(this->creatureID);
 106                 creatureIt->second->PlusWait(100, TRUE);
 107                 creatureIt->second->UpdateFieldLore();
 108                 actionList2.push_back(creatureIt->second.get());
 109                 test = creatureIt->second.get();
 110                 //actionList3.push_back(test);
 111                 do
 112                 {
 113                         this->creatureID++;
 114                 } while(creatureList.find(this->creatureID) != creatureList.end());
 115                 return true;
 116         }
 117
 118         bool GameWorld::xmlSaveAir(void)
 119         {
 120                 std::ofstream ofs("lib-Vanilla\\Air.xml");
 121                 assert(ofs);
 122                 //boost::archive::xml_oarchive oa(ofs);
 123                 //oa << boost::serialization::make_nvp("Airs", this->airList);
 124                 ofs.close();
 125                 return true;
 126         }
 127
 128         bool GameWorld::xmlSaveAbility(void)
 129         {
 130                 std::ofstream ofs("lib-Vanilla\\Ability.xml");
 131                 assert(ofs);
 132                 //boost::archive::xml_oarchive oa(ofs);
 133                 //oa << boost::serialization::make_nvp("Abilities", this->abilityList);
 134                 ofs.close();
 135                 return true;
 136         }
 137
 138         bool GameWorld::xmlSaveAuthority(void)
 139         {
 140                 std::ofstream ofs("lib-Vanilla\\Authority.xml");
 141                 assert(ofs);
 142                 //boost::archive::xml_oarchive oa(ofs);
 143                 //oa << boost::serialization::make_nvp("Authorities", this->authorityList);
 144                 ofs.close();
 145                 return true;
 146         }
 147
 148         bool GameWorld::xmlSaveBuilding(void)
 149         {
 150                 std::ofstream ofs("lib-Vanilla\\Building.xml");
 151                 assert(ofs);
 152                 //boost::archive::xml_oarchive oa(ofs);
 153                 //oa << boost::serialization::make_nvp("Buildings", this->buildingList);
 154                 ofs.close();
 155                 return true;
 156         }
 157
 158         bool GameWorld::xmlSaveCamp(void)
 159         {
 160                 std::ofstream ofs("lib-Vanilla\\Camp.xml");
 161                 assert(ofs);
 162                 //boost::archive::xml_oarchive oa(ofs);
 163                 //oa << boost::serialization::make_nvp("Camps", this->campList);
 164                 ofs.close();
 165                 return true;
 166         }
 167
 168         bool GameWorld::xmlSaveCreatureTrait(void)
 169         {
 170                 std::ofstream ofs("lib-Vanilla\\CreatureTrait.xml");
 171                 assert(ofs);
 172                 //boost::archive::xml_oarchive oa(ofs);
 173                 //oa << boost::serialization::make_nvp("CreatureTraits", this->creatureTraitList);
 174                 ofs.close();
 175                 return true;
 176         }
 177
 178         bool GameWorld::xmlSaveDungeon(void)
 179         {
 180                 std::ofstream ofs("lib-Vanilla\\Dungeon.xml");
 181                 assert(ofs);
 182                 //boost::archive::xml_oarchive oa(ofs);
 183                 //oa << boost::serialization::make_nvp("Dungeons", this->dungeonList);
 184                 ofs.close();
 185                 return true;
 186         }
 187
 188         bool GameWorld::xmlSaveEffect(void)
 189         {
 190                 std::ofstream ofs("lib-Vanilla\\Effect.xml");
 191                 assert(ofs);
 192                 //boost::archive::xml_oarchive oa(ofs);
 193                 //oa << boost::serialization::make_nvp("Effects", this->effectList);
 194                 ofs.close();
 195                 return true;
 196         }
 197
 198         bool GameWorld::xmlSaveFloor(void)
 199         {
 200                 std::ofstream ofs("lib-Vanilla\\Floor.xml");
 201                 assert(ofs);
 202                 //boost::archive::xml_oarchive oa(ofs);
 203                 //oa << boost::serialization::make_nvp("Floors", this->floorList);
 204                 ofs.close();
 205                 return true;
 206         }
 207
 208         bool GameWorld::xmlSaveFixedArtifact(void)
 209         {
 210                 std::ofstream ofs("lib-Vanilla\\FixedArtifact.xml");
 211                 assert(ofs);
 212                 //boost::archive::xml_oarchive oa(ofs);
 213                 //oa << boost::serialization::make_nvp("FixedArtifacts", this->fixedArtifactList);
 214                 ofs.close();
 215                 return true;
 216         }
 217
 218         bool GameWorld::xmlSaveItemBase(void)
 219         {
 220                 std::ofstream ofs("lib-Vanilla\\ItemBase.xml");
 221                 assert(ofs);
 222                 //boost::archive::xml_oarchive oa(ofs);
 223                 //oa << boost::serialization::make_nvp("ItemBases", this->itemBaseList);
 224                 ofs.close();
 225                 return true;
 226         }
 227
 228         bool GameWorld::xmlSaveItemEgo(void)
 229         {
 230                 std::ofstream ofs("lib-Vanilla\\ItemEgo.xml");
 231                 assert(ofs);
 232                 //boost::archive::xml_oarchive oa(ofs);
 233                 //oa << boost::serialization::make_nvp("ItemEgos", this->itemEgoList);
 234                 ofs.close();
 235                 return true;
 236         }
 237
 238         bool GameWorld::xmlSaveItemTrait(void)
 239         {
 240                 std::ofstream ofs("lib-Vanilla\\ItemTrait.xml");
 241                 assert(ofs);
 242                 //boost::archive::xml_oarchive oa(ofs);
 243                 //oa << boost::serialization::make_nvp("ItemTraits", this->itemTraitList);
 244                 ofs.close();
 245                 return true;
 246         }
 247
 248         bool GameWorld::xmlSaveKarma(void)
 249         {
 250                 std::ofstream ofs("lib-Vanilla\\Karma.xml");
 251                 assert(ofs);
 252                 //boost::archive::xml_oarchive oa(ofs);
 253                 //oa << boost::serialization::make_nvp("Karmas", this->karmaList);
 254                 ofs.close();
 255                 return true;
 256         }
 257
 258         bool GameWorld::xmlSaveQuest(void)
 259         {
 260                 std::ofstream ofs("lib-Vanilla\\Quest.xml");
 261                 assert(ofs);
 262                 //boost::archive::xml_oarchive oa(ofs);
 263                 //oa << boost::serialization::make_nvp("Quests", this->questList);
 264                 ofs.close();
 265                 return true;
 266         }
 267
 268         bool GameWorld::xmlSaveRace(void)
 269         {
 270                 std::ofstream ofs("lib-Vanilla\\Race.xml");
 271                 assert(ofs);
 272                 //boost::archive::xml_oarchive oa(ofs);
 273                 //oa << boost::serialization::make_nvp("Races", this->raceList);
 274                 ofs.close();
 275                 return true;
 276         }
 277
 278         bool GameWorld::xmlSaveSpace(void)
 279         {
 280                 std::ofstream ofs("lib-Vanilla\\Space.xml");
 281                 assert(ofs);
 282                 //boost::archive::xml_oarchive oa(ofs);
 283                 //oa << boost::serialization::make_nvp("Spaces", this->spaceList);
 284                 ofs.close();
 285                 return true;
 286         }
 287
 288         bool GameWorld::xmlSaveSkill(void)
 289         {
 290                 std::ofstream ofs("lib-Vanilla\\Skill.xml");
 291                 assert(ofs);
 292                 //boost::archive::xml_oarchive oa(ofs);
 293                 //oa << boost::serialization::make_nvp("Skills", this->skillList);
 294                 ofs.close();
 295                 return true;
 296         }
 297
 298         bool GameWorld::xmlSaveSpecie(void)
 299         {
 300                 std::ofstream ofs("lib-Vanilla\\Specie.xml");
 301                 assert(ofs);
 302                 //boost::archive::xml_oarchive oa(ofs);
 303                 //oa << boost::serialization::make_nvp("Species", this->speciesList);
 304                 ofs.close();
 305                 return true;
 306         }
 307
 308         bool GameWorld::xmlSaveStartingClass(void)
 309         {
 310                 std::ofstream ofs("lib-Vanilla\\StartingClass.xml");
 311                 assert(ofs);
 312                 //boost::archive::xml_oarchive oa(ofs);
 313                 //oa << boost::serialization::make_nvp("StartingClasses", this->startingClassList);
 314                 ofs.close();
 315                 return true;
 316         }
 317
 318         bool GameWorld::xmlSaveTrapBase(void)
 319         {
 320                 std::ofstream ofs("lib-Vanilla\\TrapBase.xml");
 321                 assert(ofs);
 322                 //boost::archive::xml_oarchive oa(ofs);
 323                 //oa << boost::serialization::make_nvp("TrapBases", this->trapBaseList);
 324                 ofs.close();
 325                 return true;
 326         }
 327
 328         bool GameWorld::XMLSave(void)
 329         {
 330                 this->xmlSaveAir();
 331                 this->xmlSaveAbility();
 332                 this->xmlSaveAuthority();
 333                 this->xmlSaveBuilding();
 334                 this->xmlSaveCamp();
 335                 this->xmlSaveCreatureTrait();
 336                 this->xmlSaveDungeon();
 337                 this->xmlSaveEffect();
 338                 this->xmlSaveFloor();
 339                 this->xmlSaveFixedArtifact();
 340                 this->xmlSaveItemBase();
 341                 this->xmlSaveItemEgo();
 342                 this->xmlSaveItemTrait();
 343                 this->xmlSaveKarma();
 344                 this->xmlSaveQuest();
 345                 this->xmlSaveRace();
 346                 this->xmlSaveSpace();
 347                 this->xmlSaveSkill();
 348                 this->xmlSaveSpecie();
 349                 this->xmlSaveStartingClass();
 350                 this->xmlSaveTrapBase();
 351                 return true;
 352         }
 353
 354         bool GameWorld::xmlLoadAir()
 355         {
 356                 std::ifstream ifs("lib-Vanilla\\Air.xml");
 357                 assert(ifs);
 358                 //boost::archive::xml_iarchive ia(ifs);
 359                 //ia >> BOOST_SERIALIZATION_NVP(airList);
 360                 return true;
 361         }
 362
 363         bool GameWorld::xmlLoadAbility()
 364         {
 365                 std::ifstream ifs("lib-Vanilla\\Ability.xml");
 366                 assert(ifs);
 367                 //boost::archive::xml_iarchive ia(ifs);
 368                 //ia >> BOOST_SERIALIZATION_NVP(abilityList);
 369                 return true;
 370         }
 371
 372         bool GameWorld::xmlLoadAuthority()
 373         {
 374                 std::ifstream ifs("lib-Vanilla\\Authority.xml");
 375                 assert(ifs);
 376                 //boost::archive::xml_iarchive ia(ifs);
 377                 //ia >> BOOST_SERIALIZATION_NVP(authorityList);
 378                 return true;
 379         }
 380
 381         bool GameWorld::xmlLoadBuilding()
 382         {
 383                 std::ifstream ifs("lib-Vanilla\\Building.xml");
 384                 assert(ifs);
 385                 //boost::archive::xml_iarchive ia(ifs);
 386                 //ia >> BOOST_SERIALIZATION_NVP(buildingList);
 387                 return true;
 388         }
 389
 390         bool GameWorld::xmlLoadCamp()
 391         {
 392                 std::ifstream ifs("lib-Vanilla\\Camp.xml");
 393                 assert(ifs);
 394                 //boost::archive::xml_iarchive ia(ifs);
 395                 //ia >> BOOST_SERIALIZATION_NVP(campList);
 396                 return true;
 397         }
 398
 399         bool GameWorld::xmlLoadCreatureTrait()
 400         {
 401                 std::ifstream ifs("lib-Vanilla\\CreatureTrait.xml");
 402                 assert(ifs);
 403                 //boost::archive::xml_iarchive ia(ifs);
 404                 //ia >> BOOST_SERIALIZATION_NVP(creatureTraitList);
 405                 return true;
 406         }
 407
 408         bool GameWorld::xmlLoadDungeon()
 409         {
 410                 std::ifstream ifs("lib-Vanilla\\Dungeon.xml");
 411                 assert(ifs);
 412                 //boost::archive::xml_iarchive ia(ifs);
 413                 //ia >> BOOST_SERIALIZATION_NVP(dungeonList);
 414                 return true;
 415         }
 416
 417         bool GameWorld::xmlLoadEffect()
 418         {
 419                 std::ifstream ifs("lib-Vanilla\\Effect.xml");
 420                 assert(ifs);
 421                 //boost::archive::xml_iarchive ia(ifs);
 422                 //ia >> BOOST_SERIALIZATION_NVP(effectList);
 423                 return true;
 424         }
 425
 426         bool GameWorld::xmlLoadFloor()
 427         {
 428                 std::ifstream ifs("lib-Vanilla\\Floor.xml");
 429                 assert(ifs);
 430                 //boost::archive::xml_iarchive ia(ifs);
 431                 //ia >> BOOST_SERIALIZATION_NVP(floorList);
 432                 return true;
 433         }
 434
 435         bool GameWorld::xmlLoadFixedArtifact()
 436         {
 437                 std::ifstream ifs("lib-Vanilla\\FixedArtifact.xml");
 438                 assert(ifs);
 439                 //boost::archive::xml_iarchive ia(ifs);
 440                 //ia >> BOOST_SERIALIZATION_NVP(fixedArtifactList);
 441                 return true;
 442         }
 443
 444         bool GameWorld::xmlLoadItemBase()
 445         {
 446                 std::ifstream ifs("lib-Vanilla\\ItemBase.xml");
 447                 assert(ifs);
 448                 //boost::archive::xml_iarchive ia(ifs);
 449                 //ia >> BOOST_SERIALIZATION_NVP(itemBaseList);
 450                 return true;
 451         }
 452
 453         bool GameWorld::xmlLoadItemEgo()
 454         {
 455                 std::ifstream ifs("lib-Vanilla\\ItemEgo.xml");
 456                 assert(ifs);
 457                 //boost::archive::xml_iarchive ia(ifs);
 458                 //ia >> BOOST_SERIALIZATION_NVP(itemEgoList);
 459                 return true;
 460         }
 461
 462         bool GameWorld::xmlLoadItemTrait()
 463         {
 464                 std::ifstream ifs("lib-Vanilla\\ItemTrait.xml");
 465                 assert(ifs);
 466                 //boost::archive::xml_iarchive ia(ifs);
 467                 //ia >> BOOST_SERIALIZATION_NVP(itemTraitList);
 468                 return true;
 469         }
 470
 471         bool GameWorld::xmlLoadKarma()
 472         {
 473                 std::ifstream ifs("lib-Vanilla\\Karma.xml");
 474                 assert(ifs);
 475                 //boost::archive::xml_iarchive ia(ifs);
 476                 //ia >> BOOST_SERIALIZATION_NVP(karmaList);
 477                 return true;
 478         }
 479
 480         bool GameWorld::xmlLoadQuest()
 481         {
 482                 std::ifstream ifs("lib-Vanilla\\Quest.xml");
 483                 assert(ifs);
 484                 //boost::archive::xml_iarchive ia(ifs);
 485                 //ia >> BOOST_SERIALIZATION_NVP(questList);
 486                 return true;
 487         }
 488
 489         bool GameWorld::xmlLoadRace()
 490         {
 491                 std::ifstream ifs("lib-Vanilla\\Race.xml");
 492                 assert(ifs);
 493                 //boost::archive::xml_iarchive ia(ifs);
 494                 //ia >> BOOST_SERIALIZATION_NVP(raceList);
 495                 return true;
 496         }
 497
 498         bool GameWorld::xmlLoadSpace()
 499         {
 500                 std::ifstream ifs("lib-Vanilla\\Space.xml");
 501                 assert(ifs);
 502                 //boost::archive::xml_iarchive ia(ifs);
 503                 //ia >> BOOST_SERIALIZATION_NVP(spaceList);
 504                 return true;
 505         }
 506
 507         bool GameWorld::xmlLoadSkill()
 508         {
 509                 std::ifstream ifs("lib-Vanilla\\Skill.xml");
 510                 assert(ifs);
 511                 //boost::archive::xml_iarchive ia(ifs);
 512                 //ia >> BOOST_SERIALIZATION_NVP(skillList);
 513                 return true;
 514         }
 515
 516         bool GameWorld::xmlLoadSpecie()
 517         {
 518                 std::ifstream ifs("lib-Vanilla\\Specie.xml");
 519                 assert(ifs);
 520                 //boost::archive::xml_iarchive ia(ifs);
 521                 //ia >> BOOST_SERIALIZATION_NVP(speciesList);
 522                 return true;
 523         }
 524
 525         bool GameWorld::xmlLoadStartingClass()
 526         {
 527                 std::ifstream ifs("lib-Vanilla\\StartingClass.xml");
 528                 assert(ifs);
 529                 //boost::archive::xml_iarchive ia(ifs);
 530                 //ia >> BOOST_SERIALIZATION_NVP(startingClassList);
 531                 return true;
 532         }
 533
 534         bool GameWorld::xmlLoadTrapBase()
 535         {
 536                 std::ifstream ifs("lib-Vanilla\\TrapBase.xml");
 537                 assert(ifs);
 538                 //boost::archive::xml_iarchive ia(ifs);
 539                 //ia >> BOOST_SERIALIZATION_NVP(trapBaseList);
 540                 return true;
 541         }
 542
 543         void GameWorld::XMLLoad(void)
 544         {
 545                 this->xmlLoadAir();
 546                 this->xmlLoadAbility();
 547                 this->xmlLoadAuthority();
 548                 this->xmlLoadBuilding();
 549                 this->xmlLoadCamp();
 550                 this->xmlLoadCreatureTrait();
 551                 this->xmlLoadDungeon();
 552                 this->xmlLoadEffect();
 553                 this->xmlLoadFloor();
 554                 this->xmlLoadFixedArtifact();
 555                 this->xmlLoadItemBase();
 556                 this->xmlLoadItemEgo();
 557                 this->xmlLoadItemTrait();
 558                 this->xmlLoadKarma();
 559                 this->xmlLoadQuest();
 560                 this->xmlLoadRace();
 561                 this->xmlLoadSpace();
 562                 this->xmlLoadSkill();
 563                 this->xmlLoadSpecie();
 564                 this->xmlLoadStartingClass();
 565                 this->xmlLoadTrapBase();
 566         }
 567
 568         Authority *GameWorld::GetAuthority(TAG tag)
 569         {
 570                 return &(*authorityList[tag]);
 571         }
 572
 573         CreatureTrait *GameWorld::GetCreatureTrait(TAG tag)
 574         {
 575                 return &(*creatureTraitList[tag]);
 576         }
 577
 578         Effect *GameWorld::GetEffect(TAG tag)
 579         {
 580                 return &(*effectList[tag]);
 581         }
 582
 583         FixedArtifact *GameWorld::GetFixedArtifact(TAG tag)
 584         {
 585                 return &(*fixedArtifactList[tag]);
 586         }
 587
 588         Floor *GameWorld::GetFloor(TAG tag)
 589         {
 590                 return &(*floorList[tag]);
 591         }
 592
 593         ItemBase *GameWorld::GetItemBase(TAG tag)
 594         {
 595                 return &(*itemBaseList[tag]);
 596         }
 597
 598         ItemEgo *GameWorld::GetItemEgo(TAG tag)
 599         {
 600                 return &(*itemEgoList[tag]);
 601         }
 602
 603         ItemTrait *GameWorld::GetItemTrait(TAG tag)
 604         {
 605                 return &(*itemTraitList[tag]);
 606         }
 607
 608         Karma *GameWorld::GetKarma(TAG tag)
 609         {
 610                 return &(*karmaList[tag]);
 611         }
 612
 613         Skill *GameWorld::GetSkill(TAG tag)
 614         {
 615                 return &(*skillList[tag]);
 616         }
 617
 618         Species *GameWorld::GetSpecies(TAG tag)
 619         {
 620                 return &(*speciesList[tag]);
 621         }
 622
 623         TrapBase *GameWorld::GetTrapBase(TAG tag)
 624         {
 625                 return &(*trapBaseList[tag]);
 626         }
 627
 628         Building *GameWorld::GetBuilding(TAG tag)
 629         {
 630                 return &(*buildingList[tag]);
 631         }
 632
 633         Camp *GameWorld::GetCamp(TAG tag)
 634         {
 635                 return &(*campList[tag]);
 636         }
 637
 638         Dungeon *GameWorld::GetDungeon(TAG tag)
 639         {
 640                 return &(*dungeonList[tag]);
 641         }
 642
 643         Item *GameWorld::GetItem(ID id)
 644         {
 645                 return &(*itemList[id]);
 646         }
 647
 648         Field *GameWorld::GetField(ID id)
 649         {
 650                 return &(*fieldList[id]);
 651         }
 652
 653         Creature *GameWorld::GetCreature(ID id)
 654         {
 655                 return &(*creatureList[id]);
 656         }
 657
 658         std::map<TAG, std::shared_ptr<Ability>> *GameWorld::GetAbilityList(void)
 659         {
 660                 return &(this->abilityList);
 661         }
 662
 663         Quest *GameWorld::GetQuest(TAG tag)
 664         {
 665                 return &(*questList[tag]);
 666         }
 667
 668         GAME_TIME GameWorld::GetGameTime(void)
 669         {
 670                 return this->gameTime;
 671         }
 672
 673         void GameWorld::WipeCreature(ID id)
 674         {
 675                 creatureList.erase(id);
 676         }
 677
 678         CREATURE_IT GameWorld::GetPlayerCreature(void)
 679         {
 680                 return this->playerIt;
 681         }
 682
 683         Creature *GameWorld::GetCreatureFromPosition(ID fieldID, Coordinates *positionPtr)
 684         {
 685                 CREATURE_IT creatureIt;
 686                 creatureIt = this->creatureList.begin();
 687                 while(creatureIt != this->creatureList.end())
 688                 {
 689                         if(creatureIt->second->GetPosition() == *positionPtr && fieldID == creatureIt->second->GetFieldID()) return (creatureIt->second.get());
 690                         creatureIt++;
 691                 }
 692                 return NULL;
 693
 694         }
 695
 696         Floor *GameWorld::GetFloorFromPosition(ID fieldID, Coordinates *positionPtr)
 697         {
 698                 Square *square = fieldList[fieldID].get()->GetSquare(positionPtr->GetX(), positionPtr->GetY());
 699                 if(!square) return NULL;
 700                 TAG tag = square->GetFloorTag();
 701                 return &(*floorList[tag]);
 702         }
 703
 704         std::map<TAG, std::shared_ptr<Floor>> *GameWorld::GetFloorList(void)
 705         {
 706                 return &floorList;
 707         }
 708
 709         std::map<TAG, std::shared_ptr<Species>> *GameWorld::GetSpeciesList(void)
 710         {
 711                 return &speciesList;
 712         }
 713
 714         CREATURE_LIST *GameWorld::GetCreatureList(void)
 715         {
 716                 return &creatureList;
 717         }
 718
 719         ACTION_LIST* GameWorld::GetActionList(void)
 720         {
 721                 return &(this->actionList);
 722         }
 723
 724         HaveGameTime *GameWorld::GetNextActionObject(void)
 725         {
 726                 //this->gameTime++;
 727                 return this->playerIt->second.get();
 728         }
 729
 730
 731 }