void World::CreateParticle(const Position &pos, const Position &dir, int damage,
bool isEmittedFromHero)
{
std::shared_ptr<TransformComponent> particleTransform = std::make_shared<TransformComponent>(pos, pos, dir);
std::shared_ptr<StatComponent> particleStat = std::make_shared<StatComponent>(1, 0, damage, 1);
std::shared_ptr<CollidableComponent> particleCollidable = std::make_shared<CollidableComponent>();
particleCollidable->collisionInfo[INFOTYPE_LOGICAL_SPRITE] = TILE_PARTICLE;
particleCollidable->collisionInfo[INFOTYPE_SPRITE] = TILE_PARTICLE;
particleCollidable->SetOnCollision(Floyd::ScriptParticle_OnCollision, "particle");
std::shared_ptr<AIComponent> particleAI = std::make_shared<AIComponent>();
particleAI->SetOnUpdateAI(Floyd::ScriptParticle_OnUpdateAI, "particle");
particleAI->aiType = AITYPE_PARTICLE;
std::shared_ptr<DrawableComponent> particleDrawable = std::make_shared<DrawableComponent>();
particleDrawable->sprite = Sprite(1, 1);
particleDrawable->sprite.LoadTexture(ResolveFileName("particle_sprite", DIR_ENTITIES));
std::shared_ptr<ParticleComponent> particleParticle = std::make_shared<ParticleComponent>(isEmittedFromHero);
std::shared_ptr<Entity> particleEnt = std::make_shared<Entity>();
particleEnt->AddComponent(particleTransform);
particleEnt->AddComponent(particleCollidable);
particleEnt->AddComponent(particleAI);
particleEnt->AddComponent(particleDrawable);
particleEnt->AddComponent(particleParticle);
particleEnt->AddComponent(particleStat);
entities.push_back(particleEnt);
}
void World::InitShrinesForLevels()
{
shrinesForLevel.clear();
std::ifstream shrines(ResolveFileName(FILE_SHRINES_DEF, DIR_ENTITIES));
if (shrines.is_open())
{
std::string shrineDef;
while (std::getline(shrines, shrineDef, ';').good())
{
auto shrinePair = GetItemWithLevel(shrineDef);
auto placeToAddShrinePair = shrinesForLevel.find(shrinePair.first);
if (placeToAddShrinePair != shrinesForLevel.end())
{
placeToAddShrinePair->second.push_back(shrinePair.second);
}
else
{
std::vector<std::string> firstShrine;
firstShrine.push_back(shrinePair.second);
shrinesForLevel.insert(std::make_pair(shrinePair.first, firstShrine));
}
}
}
else
{
Report::UnexpectedError("Can't open shrines file", __LINE__, __FILE__);
}
shrines.close();
}
void World::InitLevels()
{
levels.clear();
std::ifstream world(ResolveFileName(FILE_WORLD_DEF, DIR_WORLD));
if (world.is_open())
{
std::string levelDef;
while (std::getline(world, levelDef, ';').good())
{
Level newLevel;
std::string levelName = GetLevelName(levelDef);
newLevel.Init(levelName + EXT_LEVEL);
std::vector<std::string> cutscenes = GetLevelArrayOfCutscenes(levelDef);
newLevel.InitCutscenes(cutscenes);
levels.push_back(newLevel);
}
}
else
{
Report::UnexpectedError("Can't open world file", __LINE__, __FILE__);
}
world.close();
}
void World::InitItemsForLevels()
{
itemsForLevel.clear();
std::ifstream items(ResolveFileName(FILE_ITEMS_DEF, DIR_ENTITIES));
if (items.is_open())
{
std::string itemDef;
while (std::getline(items, itemDef, ';').good())
{
auto itemPair = GetItemWithLevel(itemDef);
auto placeToAddItemPair = itemsForLevel.find(itemPair.first);
if (placeToAddItemPair != itemsForLevel.end())
{
placeToAddItemPair->second.push_back(itemPair.second);
}
else
{
std::vector<std::string> firstItem;
firstItem.push_back(itemPair.second);
itemsForLevel.insert(std::make_pair(itemPair.first, firstItem));
}
}
}
else
{
Report::UnexpectedError("Can't open items file", __LINE__, __FILE__);
}
items.close();
}
void World::Serialize() const
{
std::string saveFileName = ResolveFileName(FILE_WORLD_DEF, DIR_SAVE);
std::ofstream save(saveFileName, std::ios::binary);
if (save.is_open())
{
size_t itemsInCurrentLevelSize = itemsInCurrentLevel.size();
save.write((char*)&itemsInCurrentLevelSize, sizeof(size_t));
for (size_t idx = 0; idx < itemsInCurrentLevel.size(); ++idx)
{
itemsInCurrentLevel[idx].Serialize(save);
}
size_t entitiesCount = entities.size();
save.write((char*)&entitiesCount, sizeof(entitiesCount));
for (auto entity = entities.begin(); entity != entities.end(); ++entity)
{
(*entity)->Serialize(save);
}
save.write((char*)¤tLevelIdx, sizeof(currentLevelIdx));
levels[currentLevelIdx].Serialize(save);
}
else
{
std::stringstream error;
error << "Can't serialize world from '" << saveFileName << "'\n";
Report::UnexpectedError(error.str(), __LINE__, __FILE__);
}
save.close();
}
//************************************
// Method: GetDocument
// FullName: vtPhysics::pFactory::GetDocument
// Access: public
// Returns: TiXmlDocument*
// Qualifier:
// Parameter: XString filename
//************************************
TiXmlDocument* pFactory::getDocument(XString filename)
{
XString fname(filename.Str());
if ( fname.Length() )
{
XString fnameTest = ResolveFileName(fname.CStr());
if ( fnameTest.Length())
{
TiXmlDocument* result = new TiXmlDocument(fnameTest.Str());
result->LoadFile(fnameTest.Str());
result->Parse(fnameTest.Str());
TiXmlNode* node = result->FirstChild( "vtPhysics" );
if (!node)
{
GetPMan()->m_Context->OutputToConsoleEx("PFactory : Couldn't load Document : %s",filename.Str());
return NULL;
}else
{
return result;
}
}
}
return NULL;
}
void World::CreateBoss(const Position &pos)
{
std::shared_ptr<TransformComponent> bossTransform = std::make_shared<TransformComponent>();
bossTransform->position = pos;
bossTransform->prevPosition = pos;
bossTransform->direction = Position(0, 0);
std::shared_ptr<StatComponent> bossStat = std::make_shared<StatComponent>();
bossStat->InitFromFile(ResolveFileName(FILE_BOSS_DEF, DIR_ENTITIES));
std::shared_ptr<CollidableComponent> bossCollidable = std::make_shared<CollidableComponent>();
bossCollidable->collisionInfo[INFOTYPE_LOGICAL_SPRITE] = TILE_BOSS;
bossCollidable->collisionInfo[INFOTYPE_SPRITE] = TILE_BOSS;
bossCollidable->SetOnCollision(Floyd::ScriptBoss_OnCollision, "boss");
std::shared_ptr<AIComponent> bossAI = std::make_shared<AIComponent>();
bossAI->SetOnUpdateAI(Floyd::ScriptBoss_OnUpdateAI, "boss");
bossAI->aiType = AITYPE_BOSS;
std::shared_ptr<DrawableComponent> bossDrawable = std::make_shared<DrawableComponent>();
bossDrawable->sprite = Sprite(1, 1);
bossDrawable->sprite.LoadTexture(ResolveFileName("boss_sprite", DIR_ENTITIES));
std::shared_ptr<ParticleEmitterComponent> bossEmitter = std::make_shared<ParticleEmitterComponent>();
bossEmitter->particleEmitInterval_s = 3;
bossEmitter->particlesPerEmission = 4;
std::shared_ptr<AnimatedComponent> bossAnimated = std::make_shared<AnimatedComponent>();
bossAnimated->AddAnimPoint(Position(pos.x + 1, pos.y - 1));
bossAnimated->AddAnimPoint(Position(pos.x + 2, pos.y - 1));
bossAnimated->AddAnimPoint(Position(pos.x + 3, pos.y));
bossAnimated->AddAnimPoint(Position(pos.x + 2, pos.y + 1));
bossAnimated->AddAnimPoint(Position(pos.x + 1, pos.y + 1));
bossAnimated->AddAnimPoint(pos);
std::shared_ptr<Entity> bossEnt = std::make_shared<Entity>();
bossEnt->AddComponent(bossTransform);
bossEnt->AddComponent(bossStat);
bossEnt->AddComponent(bossCollidable);
bossEnt->AddComponent(bossAI);
bossEnt->AddComponent(bossDrawable);
bossEnt->AddComponent(bossEmitter);
bossEnt->AddComponent(bossAnimated);
entities.push_back(bossEnt);
}
// Configuration Functions
void HostMachine::ReadConfiguration( BasicConfigurationStore * store )
{
/* check out any device configuration options from config file */
char *t = store->ReadString( "ROMPath", "%EXECPATH%/roms" );
if(t)
{
ROMPath = ResolveFileName(t);
free(t);
}
t = store->ReadString( "GFXPath", NULL );
if(t)
{
GFXPath = ResolveFileName(t);
free(t);
}
}
void World::CreateMonster(const Position &pos)
{
std::shared_ptr<TransformComponent> monsterTransform = std::make_shared<TransformComponent>();
monsterTransform->position = pos;
monsterTransform->prevPosition = pos;
monsterTransform->direction = Position(0, 0);
std::shared_ptr<StatComponent> monsterStat = std::make_shared<StatComponent>();
monsterStat->InitFromFile(ResolveFileName(FILE_MONSTER_DEF, DIR_ENTITIES));
std::shared_ptr<CollidableComponent> monsterCollidable = std::make_shared<CollidableComponent>();
monsterCollidable->collisionInfo[INFOTYPE_LOGICAL_SPRITE] = TILE_MONSTER;
monsterCollidable->collisionInfo[INFOTYPE_SPRITE] = TILE_MONSTER;
monsterCollidable->SetOnCollision(Floyd::ScriptMonster_OnCollision, "monster");
std::shared_ptr<AIComponent> monsterAI = std::make_shared<AIComponent>();
monsterAI->SetOnUpdateAI(Floyd::ScriptMonster_OnUpdateAI, "monster");
monsterAI->aiType = AITYPE_MONSTER;
std::shared_ptr<DrawableComponent> monsterDrawable = std::make_shared<DrawableComponent>();
monsterDrawable->sprite = Sprite(1, 1);
monsterDrawable->sprite.LoadTexture(ResolveFileName("monster_sprite", DIR_ENTITIES));
std::shared_ptr<ParticleEmitterComponent> monsterEmitter = std::make_shared<ParticleEmitterComponent>();
monsterEmitter->particleEmitInterval_s = 3;
monsterEmitter->particlesPerEmission = 1;
std::shared_ptr<Entity> monsterEnt = std::make_shared<Entity>();
monsterEnt->AddComponent(monsterTransform);
monsterEnt->AddComponent(monsterStat);
monsterEnt->AddComponent(monsterCollidable);
monsterEnt->AddComponent(monsterAI);
monsterEnt->AddComponent(monsterDrawable);
monsterEnt->AddComponent(monsterEmitter);
entities.push_back(monsterEnt);
}
void World::Init()
{
InitLevels();
InitItemsForLevels();
InitShrinesForLevels();
startupMenu.Init(ResolveFileName(FILE_MENU_DEF, DIR_WORLD));
scripts.push_back(new LevelScript());
for (auto script = scripts.begin(); script != scripts.end(); ++script)
{
(*script)->OnStart(this);
}
Logger::Init();
Logger::Log("World initialized", LOW);
}
void World::CreateHero()
{
std::shared_ptr<TransformComponent> heroTransform = std::make_shared<TransformComponent>();
heroTransform->position = levels[currentLevelIdx].GetStartingPos();
heroTransform->prevPosition = heroTransform->position;
heroTransform->direction = Position(0, 0);
std::shared_ptr<ControllableComponent> heroControllable = std::make_shared<ControllableComponent>();
heroControllable->SetOnKeyPressed(Floyd::ScriptHero_OnKeyPressed, "hero");
std::shared_ptr<StatComponent> heroStat = std::make_shared<StatComponent>(30, 0, 5, 30);
std::shared_ptr<InventoryComponent> heroInventory = std::make_shared<InventoryComponent>();
std::shared_ptr<CollidableComponent> heroCollidable = std::make_shared<CollidableComponent>();
heroCollidable->collisionInfo[INFOTYPE_LOGICAL_SPRITE] = TILE_HERO;
heroCollidable->collisionInfo[INFOTYPE_SPRITE] = TILE_HERO;
heroCollidable->SetOnCollision(Floyd::ScriptHero_OnCollision, "hero");
std::shared_ptr<QuestInfoComponent> heroQuestInfo = std::make_shared<QuestInfoComponent>();
std::shared_ptr<DrawableComponent> heroDrawable = std::make_shared<DrawableComponent>();
heroDrawable->sprite = Sprite(1, 1);
heroDrawable->sprite.LoadTexture(ResolveFileName("hero_sprite", DIR_ENTITIES));
std::shared_ptr<Entity> heroEnt = std::make_shared<Entity>();
heroEnt->AddComponent(heroTransform);
heroEnt->AddComponent(heroControllable);
heroEnt->AddComponent(heroStat);
heroEnt->AddComponent(heroInventory);
heroEnt->AddComponent(heroCollidable);
heroEnt->AddComponent(heroQuestInfo);
heroEnt->AddComponent(heroDrawable);
heroInventory->UpdateInfoSprite();
entities.push_back(heroEnt);
}
void World::Deserialize()
{
std::string loadFileName = ResolveFileName(FILE_WORLD_DEF, DIR_SAVE);
std::ifstream load(loadFileName, std::ios::binary);
if (load.is_open())
{
size_t itemsCount = 0;
load.read((char*)&itemsCount, sizeof(size_t));
for (size_t idx = 0; idx < itemsCount; ++idx)
{
Item newItem;
newItem.Deserialize(load);
itemsInCurrentLevel.push_back(newItem);
}
size_t entitiesCount = 0;
load.read((char*)&entitiesCount, sizeof(entitiesCount));
for (size_t idx = 0; idx < entitiesCount; ++idx)
{
std::shared_ptr<Entity> newEntity = std::make_shared<Entity>();
newEntity->Deserialize(load);
entities.push_back(newEntity);
}
load.read((char*)¤tLevelIdx, sizeof(currentLevelIdx));
levels[currentLevelIdx].Deserialize(load);
}
else
{
std::stringstream error;
error << "Can't deserialize world from '" << loadFileName << "'\n";
Report::UnexpectedError(error.str(), __LINE__, __FILE__);
}
load.close();
}
CUEFChunkSelector * HostMachine::GetUEFSelector(const char *name, Uint16 version)
{
if(!strlen(name)) return NULL;
/* consider: is file open already? */
UEFList *It = UEFHead;
while(It)
{
if(!strcmp(It->Name, name))
{
It->References++;
return It->File->GetSelectorPtr();
}
It = It->Next;
}
/* if not, open it */
CUEFFile *Newfile = new CUEFFile;
char *ResolvedName = ResolveFileName(name);
if(Newfile->Open(ResolvedName, version, "rw"))
{
delete[] ResolvedName;
UEFHead = new UEFList(UEFHead, Newfile, name);
return UEFHead->File->GetSelectorPtr();
}
else
if(Newfile->Open(ResolvedName, version, "w"))
{
delete[] ResolvedName;
UEFHead = new UEFList(UEFHead, Newfile, name);
return UEFHead->File->GetSelectorPtr();
}
else
return NULL;
}
void World::InitItemFromFile(const std::string &fileName)
{
int itemDamage = 0;
int itemDefense = 0;
int itemHealth = 0;
ItemAttribute itemAttribute = ATTRIB_NONE;
std::string itemName;
Position itemPos(0, 0);
std::ifstream item(ResolveFileName(fileName, DIR_ENTITIES));
if (item.is_open())
{
std::string itemField;
while (std::getline(item, itemField).good())
{
auto statPair = GetItemStatPairFromField(itemField);
std::string statID = statPair.first;
std::string statVal = statPair.second;
if (statID == "damage")
{
SafeLexicalCast<int>(statVal, itemDamage);
}
else if (statID == "defense")
{
SafeLexicalCast<int>(statVal, itemDefense);
}
else if (statID == "health")
{
SafeLexicalCast<int>(statVal, itemHealth);
}
else if (statID == "name")
{
itemName = statVal;
}
else if (statID == "attrib")
{
if (statVal == "PARTICLE")
{
itemAttribute = ATTRIB_PARTICLE;
}
}
else if (statID == "position")
{
size_t delimPos = statVal.find(',');
SafeLexicalCast<int>(statVal.substr(0, delimPos), itemPos.x);
SafeLexicalCast<int>(statVal.substr(delimPos + 1), itemPos.y);
}
}
}
item.close();
assert(levels[currentLevelIdx].GetSpriteAtPosition(itemPos) == 'O' ||
levels[currentLevelIdx].GetSpriteAtPosition(itemPos) == 'I');
bool isBuff = levels[currentLevelIdx].GetSpriteAtPosition(itemPos) == 'I' ? true : false;
Item newItem(itemName, itemDefense, itemDamage, itemHealth, itemAttribute, itemPos, true, isBuff);
itemsInCurrentLevel.push_back(newItem);
}
