Menu::Menu(const std::string& aXMLPath, int aLevelID)
: myButtons(8)
, myMainMenu(false)
, myRenderCenter(false)
, myLevelID(aLevelID)
, myIsOptionsMenu(false)
{
XMLReader reader;
reader.OpenDocument(aXMLPath);
std::string background;
std::string crosshair;
CU::Vector2<float> crosshairSize;
tinyxml2::XMLElement* menuElement = reader.FindFirstChild("menu");
reader.ReadAttribute(menuElement, "mainMenu", myMainMenu);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "path", background);
reader.ReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "sizeX", myBackgroundSize.x);
reader.ReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "sizeY", myBackgroundSize.y);
reader.ReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "renderCenter", myRenderCenter);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "crosshair"), "path", crosshair);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "crosshair"), "sizeX", crosshairSize.x);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "crosshair"), "sizeY", crosshairSize.y);
myCrosshair = new Prism::Sprite(crosshair, crosshairSize, crosshairSize / 2.f);
myScreenSize = { float(Prism::Engine::GetInstance()->GetWindowSize().x),
float(Prism::Engine::GetInstance()->GetWindowSize().y) };
if (myBackgroundSize.x != 0 && myBackgroundSize.y != 0)
{
myBackground = new Prism::Sprite(background, myBackgroundSize, myBackgroundSize / 2.f);
}
else
{
myBackground = new Prism::Sprite(background, myScreenSize, myScreenSize / 2.f);
}
tinyxml2::XMLElement* buttonElement = reader.FindFirstChild(menuElement, "button");
for (; buttonElement != nullptr; buttonElement = reader.FindNextElement(buttonElement))
{
Button* newButton = nullptr;
int id = -1;
reader.ReadAttribute(buttonElement, "ID", id);
if (id >= 0)
{
newButton = new LevelButton(reader, buttonElement, myLevelID);
}
else
{
newButton = new Button(reader, buttonElement, myLevelID);
}
myButtons.Add(newButton);
}
reader.CloseDocument();
}
void LevelFactory::ReadLevelSettings()
{
XMLReader reader;
std::string settingsPath = "Data/Level/Level0" + std::to_string(myCurrentID - 1) + "/L_level_0" + std::to_string(myCurrentID - 1) + "_settings.xml";
reader.OpenDocument(settingsPath);
myAmbientHue = { 0.f, 0.f, 0.f, 0.f };
std::string firstWeapon = "";
std::string secondWeapon = "";
std::string thirdWeapon = "";
reader.ReadAttribute(reader.FindFirstChild("startWeapon"), "first", firstWeapon);
reader.ReadAttribute(reader.FindFirstChild("startWeapon"), "second", secondWeapon);
reader.ReadAttribute(reader.FindFirstChild("startWeapon"), "third", thirdWeapon);
if (firstWeapon != "")
{
myCurrentLevel->myPlayer->GetComponent<ShootingComponent>()->UpgradeWeapon(myCurrentLevel->myWeaponFactory->GetWeapon(firstWeapon), 0); // replace these with UpgradeWeapon later
}
if (secondWeapon != "")
{
myCurrentLevel->myPlayer->GetComponent<ShootingComponent>()->UpgradeWeapon(myCurrentLevel->myWeaponFactory->GetWeapon(secondWeapon), 1);
}
if (thirdWeapon != "")
{
myCurrentLevel->myPlayer->GetComponent<ShootingComponent>()->UpgradeWeapon(myCurrentLevel->myWeaponFactory->GetWeapon(thirdWeapon), 2);
}
tinyxml2::XMLElement* skipableElement = reader.FindFirstChild("skipable");
if (skipableElement != nullptr)
{
myCurrentLevel->myIsSkipable = true;
}
reader.ReadAttribute(reader.FindFirstChild("Ambient"), "r", myAmbientHue.r);
reader.ReadAttribute(reader.FindFirstChild("Ambient"), "g", myAmbientHue.g);
reader.ReadAttribute(reader.FindFirstChild("Ambient"), "b", myAmbientHue.b);
myAmbientHue.r = myAmbientHue.r / 255.f;
myAmbientHue.g = myAmbientHue.g / 255.f;
myAmbientHue.b = myAmbientHue.b / 255.f;
myCurrentLevel->myPlayer->GetComponent<GUIComponent>()->UpdateWeapons();
reader.CloseDocument();
}
void LevelFactory::LoadPlayer()
{
myCurrentLevel->myPlayer = new Entity(eEntityType::PLAYER, *myCurrentLevel->myScene, Prism::eOctreeType::PLAYER);
myCurrentLevel->myPlayer->AddComponent<GUIComponent>();
myCurrentLevel->myPlayer->AddComponent<GraphicsComponent>()->Init("Data/Resource/Model/Player/SM_Cockpit.fbx"
, "Data/Resource/Shader/S_effect_pbl.fx", myCurrentLevel->myPlayer->GetComponent<GUIComponent>()->GetCockpitOrientation());
myCurrentLevel->myPlayer->AddComponent<InputComponent>()->Init(*myCurrentLevel->myInputWrapper);
myCurrentLevel->myPlayer->AddComponent<ShootingComponent>();
myCurrentLevel->myPlayer->AddComponent<CollisionComponent>()->Init(7.5f);
myCurrentLevel->myPlayer->AddComponent<PhysicsComponent>()->Init(1, { 0, 0, 0 });
myCurrentLevel->myPlayer->AddComponent<SoundComponent>();
//myCurrentLevel->myPlayer->GetComponent<ShootingComponent>()->AddWeapon(myCurrentLevel->myWeaponFactory->GetWeapon("W_gun_machine_level_1")); // replace these with UpgradeWeapon later
//myCurrentLevel->myPlayer->GetComponent<ShootingComponent>()->AddWeapon(myCurrentLevel->myWeaponFactory->GetWeapon("W_gun_shotgun_level_1"));
//myCurrentLevel->myPlayer->GetComponent<ShootingComponent>()->AddWeapon(myCurrentLevel->myWeaponFactory->GetWeapon("W_gun_rocket_launcher_level_1"));
XMLReader reader;
reader.OpenDocument("Data/Setting/SET_player.xml");
int health = 0;
bool invulnerable = false;
reader.ReadAttribute(reader.FindFirstChild("life"), "value", health);
reader.ReadAttribute(reader.FindFirstChild("life"), "invulnerable", invulnerable);
myCurrentLevel->myPlayer->AddComponent<HealthComponent>()->Init(health, invulnerable);
float timeBeforeRecharging = 0.f;
float chargeRate = 0.f;
reader.ReadAttribute(reader.FindFirstChild("shield"), "timeBeforeRecharching", timeBeforeRecharging);
reader.ReadAttribute(reader.FindFirstChild("shield"), "chargeRate", chargeRate);
myCurrentLevel->myPlayer->AddComponent<ShieldComponent>()->Init(timeBeforeRecharging, chargeRate);
myCurrentLevel->myCollisionManager->Add(myCurrentLevel->myPlayer->GetComponent<CollisionComponent>(), eEntityType::PLAYER);
//myCurrentLevel->myCamera = new Prism::Camera(myCurrentLevel->myPlayer->myOrientation);
float maxMetersToEnemies = 0;
reader.ReadAttribute(reader.ForceFindFirstChild("maxdistancetoenemiesinGUI"), "meters", maxMetersToEnemies);
myCurrentLevel->myPlayer->GetComponent<GUIComponent>()->Init(maxMetersToEnemies);
myCurrentLevel->myPlayer->SetName("player");
std::string particlePath;
reader.ReadAttribute(reader.FindFirstChild("particle"), "src", particlePath);
myCurrentLevel->myPlayer->AddComponent<ParticleEmitterComponent>()->Init(particlePath);
myCurrentLevel->myPlayer->GetComponent<ParticleEmitterComponent>()->GetEmitter()->ShouldLive(true);
reader.CloseDocument();
reader.OpenDocument("Data/Resource/Model/Player/SM_cockpit_glass_a.xml");
reader.ForceReadAttribute(reader.ForceFindFirstChild(reader.ForceFindFirstChild("root"), "radius")
, "value", myCurrentLevel->myCockpitRadius);
reader.CloseDocument();
Prism::ModelProxy* tempModel = Prism::Engine::GetInstance()->GetModelLoader()->LoadModel(
"Data/Resource/Model/Player/SM_cockpit_glass_a.fbx", "Data/Resource/Shader/S_effect_glass.fx");
myCurrentLevel->myGlassCockpit = new Prism::Instance(*tempModel, *myCurrentLevel->myPlayer->GetComponent<GUIComponent>()->GetCockpitOrientation()
, Prism::eOctreeType::PLAYER, myCurrentLevel->myCockpitRadius);
}
ConversationManager::ConversationManager(const std::string& aXmlPath)
: myCurrent(nullptr)
{
XMLReader reader;
reader.OpenDocument(aXmlPath);
tinyxml2::XMLElement* element = reader.ForceFindFirstChild("root");
tinyxml2::XMLElement* timeElement = reader.FindFirstChild(element, "conversationTime");
float conversationTime = 3.f;
if (timeElement != nullptr)
{
reader.ReadAttribute(timeElement, "value", conversationTime);
}
for (element = reader.FindFirstChild(element, "conversation"); element != nullptr;
element = reader.FindNextElement(element, "conversation"))
{
std::string name;
reader.ForceReadAttribute(element, "name", name);
name = CU::ToLower(name);
myConversations[name] = new Conversation(name, reader, element, conversationTime);
}
reader.CloseDocument();
//tinyxml2::XMLElement* element = aReader.ForceFindFirstChild(aElement, "conversation");
//for (tinyxml2::XMLElement* element = aReader.ForceFindFirstChild(aElement, "sentence"); element != nullptr;
// element = aReader.FindNextElement(aElement, "sentence"))
//{
// std::string text;
// aReader.ForceReadAttribute(element, "text", text);
// mySentences.Add(new Sentence(text));
//}
}
void EntityFactory::LoadEntity(const std::string& aEntityPath, float aDifficultScale)
{
XMLReader entityDocument;
entityDocument.OpenDocument(aEntityPath);
EntityData newEntity(*myDummyScene);
tinyxml2::XMLElement* entityElement;
tinyxml2::XMLElement* rootElement = entityDocument.FindFirstChild("root");
if (rootElement == nullptr)
{
entityElement = entityDocument.FindFirstChild("Entity");
}
else
{
entityElement = entityDocument.FindFirstChild(rootElement, "Entity");
}
std::string entityName = "";
entityDocument.ForceReadAttribute(entityElement, "name", entityName);
if (myEntities.find(entityName) != myEntities.end())
{
std::string errorMessage = "[EntityFactory] Entity there is already a object named " + entityName;
DL_ASSERT(errorMessage.c_str());
}
newEntity.myEntity->SetName(entityName);
if (entityName != "E_projectile_enemy_fast")
{
aDifficultScale = 1.f;
}
else {
aDifficultScale = aDifficultScale;
}
ENTITY_LOG("Load entity %s starting", entityName.c_str());
for (tinyxml2::XMLElement* e = entityDocument.FindFirstChild(entityElement); e != nullptr;
e = entityDocument.FindNextElement(e))
{
std::string childName = e->Name();
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("GraphicsComponent").c_str()) == 0)
{
LoadGraphicsComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("AIComponent").c_str()) == 0)
{
LoadAIComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("ShootingComponent").c_str()) == 0)
{
LoadShootingComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("CollisionComponent").c_str()) == 0)
{
LoadCollisionComponent(newEntity, entityDocument, e, eCollisionType::NORMAL);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("PlanetCollisionComponent").c_str()) == 0)
{
LoadCollisionComponent(newEntity, entityDocument, e, eCollisionType::PLANET);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("PhysicsComponent").c_str()) == 0)
{
LoadPhysicsComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("BulletComponent").c_str()) == 0)
{
LoadBulletComponent(newEntity, entityDocument, e, aDifficultScale);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("HealthComponent").c_str()) == 0)
{
LoadHealthComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("PowerUpComponent").c_str()) == 0)
{
LoadPowerUpComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("ParticleEmitterComponent").c_str()) == 0)
{
LoadParticleEmitterComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("StreakEmitterComponent").c_str()) == 0)
{
LoadStreakEmitterComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("rotate").c_str()) == 0)
{
bool rotate;
entityDocument.ReadAttribute(e, "value", rotate);
newEntity.myEntity->SetShouldRotate(rotate);
entityDocument.ReadAttribute(e, "xAxis", rotate);
newEntity.myEntity->SetShouldRotateX(rotate);
entityDocument.ReadAttribute(e, "yAxis", rotate);
newEntity.myEntity->SetShouldRotateY(rotate);
entityDocument.ReadAttribute(e, "zAxis", rotate);
newEntity.myEntity->SetShouldRotateZ(rotate);
}
else if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("SoundComponent").c_str()) == 0)
{
LoadSoundComponent(newEntity, entityDocument, e);
ENTITY_LOG("Entity %s loaded %s", entityName.c_str(), e->Name());
}
else
{
std::string errorMessage = "[EntityFactory]: Entity could not find the component "
+ static_cast<std::string>(e->Name());
DL_ASSERT(errorMessage.c_str());
}
}
if (entityName != "")
{
myEntities.insert(std::pair<std::string, EntityData>(entityName, newEntity));
ENTITY_LOG("Load entity %s ending", entityName.c_str());
}
else
{
DL_ASSERT("[EntityFactory]: Entity could not be created missing a name.");
}
entityDocument.CloseDocument();
}
void EntityFactory::LoadAIComponent(EntityData& aEntityToAddTo, XMLReader& aDocument, tinyxml2::XMLElement* aAIComponentElement)
{
aEntityToAddTo.myEntity->AddComponent<AIComponent>();
for (tinyxml2::XMLElement* e = aAIComponentElement->FirstChildElement(); e != nullptr; e = e->NextSiblingElement())
{
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("FollowEntity").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "targetName", aEntityToAddTo.myTargetName);
}
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("Speed").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "min", aEntityToAddTo.myMinSpeed);
aDocument.ForceReadAttribute(e, "max", aEntityToAddTo.myMaxSpeed);
}
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("TimeToNextDecision").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "min", aEntityToAddTo.myMinTimeToNextDecision);
aDocument.ForceReadAttribute(e, "max", aEntityToAddTo.myMaxTimeToNextDecision);
}
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("AvoidanceDistance").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "value", aEntityToAddTo.myAIAvoidanceDistance);
}
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("AvoidanceOffset").c_str()) == 0)
{
aDocument.ForceReadAttribute(e, "x", aEntityToAddTo.myAIAvoidancePoint.x);
aDocument.ForceReadAttribute(e, "y", aEntityToAddTo.myAIAvoidancePoint.y);
aDocument.ForceReadAttribute(e, "z", aEntityToAddTo.myAIAvoidancePoint.z);
}
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("AIMode").c_str()) == 0)
{
int aiMode = -1;
aDocument.ForceReadAttribute(e, "value", aiMode);
switch (aiMode)
{
case 1:
aEntityToAddTo.myAITargetPositionMode = eAITargetPositionMode::KEEP_DISTANCE;
break;
case 2:
aEntityToAddTo.myAITargetPositionMode = eAITargetPositionMode::ESCAPE_THEN_RETURN;
break;
case 3:
aEntityToAddTo.myAITargetPositionMode = eAITargetPositionMode::KAMIKAZE;
break;
case 5:
aEntityToAddTo.myAITargetPositionMode = eAITargetPositionMode::TURRET;
break;
default:
DL_ASSERT("Invalid AI-mode");
break;
}
}
aEntityToAddTo.myAITurnRate = 1.f;
if (std::strcmp(CU::ToLower(e->Name()).c_str(), CU::ToLower("AITurnRate").c_str()) == 0)
{
aDocument.ReadAttribute(e, "value", aEntityToAddTo.myAITurnRate);
}
}
}
void ParticleEmitterData::LoadDataFile(const char* aFilePath)
{
XMLReader read;
myFileName = aFilePath;
read.OpenDocument(aFilePath);
tinyxml2::XMLElement* emitter = read.ForceFindFirstChild("Emitter");
tinyxml2::XMLElement* element;
element = read.ForceFindFirstChild(emitter, "Shader");
read.ReadAttribute(element, "filepath", myEffectName);
element = read.ForceFindFirstChild(emitter, "Texture");
read.ReadAttribute(element, "filepath", myTextureName);
element = read.ForceFindFirstChild(emitter, "EmitterSize");
read.ReadAttribute(element, "x", myEmitterSize.x);
read.ReadAttribute(element, "y", myEmitterSize.y);
read.ReadAttribute(element, "z", myEmitterSize.z);
element = read.ForceFindFirstChild(emitter, "ParticleMaxRotation");
read.ReadAttribute(element, "value", myMaxRotation);
element = read.ForceFindFirstChild(emitter, "ParticleMinRotation");
read.ReadAttribute(element, "value", myMinRotation);
element = read.ForceFindFirstChild(emitter, "ParticleMaxVelocity");
read.ReadAttribute(element, "x", myMaxVelocity.x);
read.ReadAttribute(element, "y", myMaxVelocity.y);
read.ReadAttribute(element, "z", myMaxVelocity.z);
element = read.ForceFindFirstChild(emitter, "ParticleMinVelocity");
read.ReadAttribute(element, "x", myMinVelocity.x);
read.ReadAttribute(element, "y", myMinVelocity.y);
read.ReadAttribute(element, "z", myMinVelocity.z);
element = read.ForceFindFirstChild(emitter, "ParticleSpeedMultiplier");
read.ReadAttribute(element, "value", mySpeedMultiplier);
element = read.ForceFindFirstChild(emitter, "ParticleStartColor");
read.ReadAttribute(element, "r", myData.myStartColor.r);
read.ReadAttribute(element, "g", myData.myStartColor.g);
read.ReadAttribute(element, "b", myData.myStartColor.b);
element = read.ForceFindFirstChild(emitter, "ParticleEndColor");
read.ReadAttribute(element, "r", myData.myEndColor.r);
read.ReadAttribute(element, "g", myData.myEndColor.g);
read.ReadAttribute(element, "b", myData.myEndColor.b);
element = read.ForceFindFirstChild(emitter, "ParticleLifeTime");
read.ReadAttribute(element, "value", myParticlesLifeTime);
element = read.ForceFindFirstChild(emitter, "EmitterLifeTime");
read.ReadAttribute(element, "value", myEmitterLifeTime);
element = read.ForceFindFirstChild(emitter, "UseEmitterLifeTime");
read.ReadAttribute(element, "value", myUseEmitterLifeTime);
element = read.ForceFindFirstChild(emitter, "EmissionRate");
read.ReadAttribute(element, "value", myEmissionRate);
element = read.ForceFindFirstChild(emitter, "ParticlesPerEmitt");
read.ReadAttribute(element, "value", myParticlesPerEmitt);
element = read.ForceFindFirstChild(emitter, "EmissionRateDelta");
read.ReadAttribute(element, "value", myEmissionRateDelta);
element = read.ForceFindFirstChild(emitter, "ParticleMaxScale");
read.ReadAttribute(element, "value", myMaxScale);
element = read.ForceFindFirstChild(emitter, "ParticleMinScale");
read.ReadAttribute(element, "value", myMinScale);
element = read.ForceFindFirstChild(emitter, "ParticleAlphaDelta");
read.ReadAttribute(element, "value", myData.myAlphaDelta);
element = read.ForceFindFirstChild(emitter, "ParticleSizeDelta");
read.ReadAttribute(element, "value", myData.mySizeDelta);
element = read.ForceFindFirstChild(emitter, "ParticleAlphaStart");
read.ReadAttribute(element, "value", myData.myStartAlpha);
element = read.ForceFindFirstChild(emitter, "ActiveAtStart");
read.ReadAttribute(element, "value", myIsActiveAtStart);
read.CloseDocument();
myData.myStartColor.r = (myData.myStartColor.r / 255.f);
myData.myStartColor.g = (myData.myStartColor.g / 255.f);
myData.myStartColor.b = (myData.myStartColor.b / 255.f);
myData.myEndColor.r = (myData.myEndColor.r / 255.f);
myData.myEndColor.g = (myData.myEndColor.g / 255.f);
myData.myEndColor.b = (myData.myEndColor.b / 255.f);
myData.myMaxStartSize = myMaxScale;
myData.myMinStartSize = myMinScale;
myData.myMaxVelocity = myMaxVelocity;;
myData.myMinVelocity = myMinVelocity;;
myData.myLifeTime = myParticlesLifeTime;
myTexture = Engine::GetInstance()->GetTextureContainer()->GetTexture(myTextureName.c_str());
myEffect = Engine::GetInstance()->GetEffectContainer()->GetEffect(myEffectName.c_str());
CreateInputLayout();
}
void LevelFactory::ReadXML(const std::string& aFilePath)
{
Prism::Engine::GetInstance()->GetModelLoader()->Pause();
Prism::Engine::GetInstance()->myIsLoading = true;
FindTextures("Data/Resource/Texture/Particle/");
myCurrentLevel->myScene = new Prism::Scene();
myCurrentLevel->myWeaponFactory = new WeaponFactory();
myCurrentLevel->myWeaponFactory->LoadWeapons("Data/Script/LI_list_weapon.xml");
myCurrentLevel->myWeaponFactory->LoadProjectiles("Data/Script/LI_list_projectile.xml");
myCurrentLevel->myEntityFactory = new EntityFactory(myCurrentLevel->myWeaponFactory);
myCurrentLevel->myEntityFactory->LoadEntites("Data/Script/LI_list_entity.xml", myDifficults[myCurrentDifficultyID].myMultiplier);
myCurrentLevel->myCollisionManager = new CollisionManager();
myCurrentLevel->myBulletManager = new BulletManager(*myCurrentLevel->myCollisionManager, *myCurrentLevel->myScene);
myCurrentLevel->myBulletManager->LoadFromFactory(myCurrentLevel->myWeaponFactory, myCurrentLevel->myEntityFactory, "Data/Script/LI_list_projectile.xml");
myDirectionalLights.DeleteAll();
myPointLights.DeleteAll();
mySpotLights.DeleteAll();
LoadPlayer();
myCurrentLevel->myEmitterManager = new EmitterManager(myCurrentLevel->myPlayer);
ReadLevelSettings();
myCurrentLevel->myEntities.Add(myCurrentLevel->myPlayer);
myCurrentLevel->myCamera = new Prism::Camera(myCurrentLevel->myPlayer->myOrientation);
myCurrentLevel->myPlayer->GetComponent<GUIComponent>()->SetCamera(myCurrentLevel->myCamera);
myCurrentLevel->GetEmitterManager()->AddEmitter(myCurrentLevel->myPlayer->GetComponent<ParticleEmitterComponent>());
myCurrentLevel->myPlayer->SetPlayerScene(*myCurrentLevel->myScene);
Sleep(10);
XMLReader reader;
reader.OpenDocument(aFilePath);
tinyxml2::XMLElement* levelElement = reader.ForceFindFirstChild("root");
levelElement = reader.ForceFindFirstChild(levelElement, "scene");
std::string skySphere;
std::string cubeMap;
std::string missionXML;
std::string eventXML;
std::string conversationXML;
reader.ForceReadAttribute(reader.ForceFindFirstChild(levelElement, "missionxml"), "source", missionXML);
reader.ForceReadAttribute(reader.ForceFindFirstChild(levelElement, "eventxml"), "source", eventXML);
reader.ForceReadAttribute(reader.ForceFindFirstChild(levelElement, "conversationxml"), "source", conversationXML);
CU::Vector3<float> playerPos;
CU::Vector3<float> playerRot;
tinyxml2::XMLElement* playerPosElement;
playerPosElement = reader.ForceFindFirstChild(levelElement, "PlayerStartTranslate");
playerPosElement = reader.ForceFindFirstChild(playerPosElement, "position");
reader.ForceReadAttribute(playerPosElement, "X", playerPos.x);
reader.ForceReadAttribute(playerPosElement, "Y", playerPos.y);
reader.ForceReadAttribute(playerPosElement, "Z", playerPos.z);
playerPosElement = reader.ForceFindFirstChild(levelElement, "PlayerStartTranslate");
playerPosElement = reader.ForceFindFirstChild(playerPosElement, "rotation");
reader.ForceReadAttribute(playerPosElement, "X", playerRot.x);
reader.ForceReadAttribute(playerPosElement, "Y", playerRot.y);
reader.ForceReadAttribute(playerPosElement, "Z", playerRot.z);
myCurrentLevel->myPlayer->myOrientation = CU::Matrix44f();
myCurrentLevel->myPlayer->myOrientation = myCurrentLevel->myPlayer->myOrientation.CreateRotateAroundX(playerRot.x)
* myCurrentLevel->myPlayer->myOrientation;
myCurrentLevel->myPlayer->myOrientation = myCurrentLevel->myPlayer->myOrientation.CreateRotateAroundY(playerRot.y)
* myCurrentLevel->myPlayer->myOrientation;
myCurrentLevel->myPlayer->myOrientation = myCurrentLevel->myPlayer->myOrientation.CreateRotateAroundZ(playerRot.z)
* myCurrentLevel->myPlayer->myOrientation;
myCurrentLevel->myPlayer->myOrientation = CU::GetOrientation(myCurrentLevel->myPlayer->myOrientation, playerRot);
myCurrentLevel->myPlayer->myOrientation.SetPos(playerPos * 10.f);
myCurrentLevel->myPlayer->myOriginalOrientation = myCurrentLevel->myPlayer->myOrientation;
myCurrentLevel->myPlayer->Reset();
myCurrentLevel->myConversationManager = new ConversationManager(conversationXML);
myCurrentLevel->myMissionManager = new MissionManager(*myCurrentLevel, *myCurrentLevel->myPlayer, missionXML);
myCurrentLevel->myEventManager = new EventManager(eventXML, *myCurrentLevel->myConversationManager
, *myCurrentLevel->myPlayer);
reader.ReadAttribute(reader.ForceFindFirstChild(levelElement, "skysphere"), "source", skySphere);
reader.ReadAttribute(reader.ForceFindFirstChild(levelElement, "cubemap"), "source", cubeMap);
Prism::Engine::GetInstance()->GetEffectContainer()->SetCubeMap(cubeMap);
SetSkySphere(skySphere, "Data/Resource/Shader/S_effect_skybox.fx");
LoadLights(reader, levelElement);
LoadProps(reader, levelElement);
LoadDefendables(reader, levelElement, myDifficults[myCurrentDifficultyID].myHealthMultiplier);
LoadStructures(reader, levelElement);
LoadTriggers(reader, levelElement);
LoadPowerups(reader, levelElement);
reader.CloseDocument();
myCurrentLevel->myEMPHexagon = new Entity(eEntityType::EMP, *myCurrentLevel->myScene, Prism::eOctreeType::STATIC
, "EMP");
myCurrentLevel->myEMPHexagon->AddComponent<GraphicsComponent>()->Init("Data/Resource/Model/Weapon/SM_emp_hexasphere.fbx"
, "Data/Resource/Shader/S_effect_emp.fx");
myCurrentLevel->myEMPHexagon2 = new Entity(eEntityType::EMP, *myCurrentLevel->myScene, Prism::eOctreeType::STATIC
, "EMP");
myCurrentLevel->myEMPHexagon2->AddComponent<GraphicsComponent>()->Init("Data/Resource/Model/Weapon/SM_emp_hexasphere.fbx"
, "Data/Resource/Shader/S_effect_emp.fx");
for (int i = 0; i < myCurrentLevel->myEntities.Size(); ++i)
{
if (myCurrentLevel->myEntities[i]->GetComponent<AIComponent>() != nullptr)
{
std::string targetName = myCurrentLevel->myEntities[i]->GetComponent<AIComponent>()->GetTargetName();
Entity* target = myCurrentLevel->GetEntityWithName(targetName);
myCurrentLevel->myEntities[i]->GetComponent<AIComponent>()->SetEntityToFollow(myCurrentLevel->myPlayer, myCurrentLevel->myPlayer);
if (target != nullptr)
{
myCurrentLevel->myEntities[i]->GetComponent<AIComponent>()->SetEntityToFollow(target, myCurrentLevel->myPlayer);
}
}
if (myCurrentLevel->myEntities[i]->GetComponent<ParticleEmitterComponent>() != nullptr)
{
myCurrentLevel->myEmitterManager->AddEmitter(myCurrentLevel->myEntities[i]->GetComponent<ParticleEmitterComponent>());
}
}
for (int i = 0; i < static_cast<int>(eBulletType::COUNT); ++i)
{
if (i <= 8)
{
for (int j = 0; j < myCurrentLevel->myBulletManager->GetBullet(i)->myPlayerBullets.Size(); ++j)
{
if (myCurrentLevel->myBulletManager->GetBullet(i)->myPlayerBullets[j]->GetComponent<ParticleEmitterComponent>() != nullptr)
{
myCurrentLevel->myEmitterManager->AddEmitter(myCurrentLevel->myBulletManager->GetBullet(i)->myPlayerBullets[j]->GetComponent<ParticleEmitterComponent>());
}
if (myCurrentLevel->myBulletManager->GetBullet(i)->myEnemyBullets[j]->GetComponent<ParticleEmitterComponent>() != nullptr)
{
myCurrentLevel->myEmitterManager->AddEmitter(myCurrentLevel->myBulletManager->GetBullet(i)->myEnemyBullets[j]->GetComponent<ParticleEmitterComponent>());
}
}
}
}
AddToScene();
myCurrentLevel->myMissionManager->Init();
myCurrentLevel->myPlayer->GetComponent<InputComponent>()->SetSkyPosition();
myCurrentLevel->myPlayer->GetComponent<GUIComponent>()->SetCockpitOrientation();
Prism::Engine::GetInstance()->GetModelLoader()->UnPause();
Prism::Engine::GetInstance()->GetModelLoader()->WaitUntilFinished();
Prism::Engine::GetInstance()->GetEffectContainer()->GetEffect("Data/Resource/Shader/S_effect_pbl.fx")->SetAmbientHue(myAmbientHue);
Prism::Engine::GetInstance()->myIsLoading = false;
myIsLoading = false;
}
Menu::Menu(const std::string& aXMLPath)
: myButtons(8)
, myMainMenu(false)
, myRenderCenter(false)
, myLevelID(-1)
, myCredits(nullptr)
{
XMLReader reader;
reader.OpenDocument(aXMLPath);
std::string background;
std::string crosshair;
CU::Vector2<float> crosshairSize;
if (aXMLPath == "Data/Menu/MN_ingame_menu.xml")
{
myIsOptionsMenu = true;
}
else
{
myIsOptionsMenu = false;
}
if (aXMLPath == "Data/Menu/MN_credits.xml")
{
myCredits = new Prism::Sprite("Data/Resource/Texture/Menu/Credits/T_credits.dds", { 1024.f, 1024.f }, { 512.f, 512.f });
}
tinyxml2::XMLElement* menuElement = reader.FindFirstChild("menu");
reader.ReadAttribute(menuElement, "mainMenu", myMainMenu);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "path", background);
reader.ReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "sizeX", myBackgroundSize.x);
reader.ReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "sizeY", myBackgroundSize.y);
reader.ReadAttribute(reader.ForceFindFirstChild(menuElement, "background"), "renderCenter", myRenderCenter);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "crosshair"), "path", crosshair);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "crosshair"), "sizeX", crosshairSize.x);
reader.ForceReadAttribute(reader.ForceFindFirstChild(menuElement, "crosshair"), "sizeY", crosshairSize.y);
myCrosshair = new Prism::Sprite(crosshair, crosshairSize, crosshairSize / 2.f);
myScreenSize = { float(Prism::Engine::GetInstance()->GetWindowSize().x),
float(Prism::Engine::GetInstance()->GetWindowSize().y) };
if (myBackgroundSize.x != 0 && myBackgroundSize.y != 0)
{
myBackground = new Prism::Sprite(background, myBackgroundSize, myBackgroundSize / 2.f);
}
else
{
myFullscreenBackgroundSize = { myScreenSize.y * 2.f, myScreenSize.y };
myBackground = new Prism::Sprite(background, myFullscreenBackgroundSize, myFullscreenBackgroundSize / 2.f);
}
tinyxml2::XMLElement* buttonElement = reader.FindFirstChild(menuElement, "button");
for (; buttonElement != nullptr; buttonElement = reader.FindNextElement(buttonElement))
{
Button* newButton = nullptr;
int id = -1;
reader.ReadAttribute(buttonElement, "ID", id);
if (id >= 0)
{
newButton = new LevelButton(reader, buttonElement, id);
}
else
{
newButton = new Button(reader, buttonElement, -1);
}
myButtons.Add(newButton);
}
reader.CloseDocument();
}
