void Unit::ChangeWeapon( )
{
if (!IsAlive())
return;
if( !gSecondaryWeapon || !gCurrentWeapon )
return;
if( gWeaponState != Hold )
return;
if( gCurrentWeapon->GetState() == Reloading || gCurrentWeapon->GetInfo().ReloadTime.first > 0 )
gCurrentWeapon->CancelReload();
if( gCurrentWeapon == gPrimaryWeapon )
{
gPrimaryWeapon->SetState( Hidden );
gCurrentWeapon = gSecondaryWeapon;
gCurrentWeapon->SetState( Alive );
AddGameObject( gSecondaryWeapon );
}
else
{
gSecondaryWeapon->SetState( Hidden );
gCurrentWeapon = gPrimaryWeapon;
gCurrentWeapon->SetState( Alive );
AddGameObject( gPrimaryWeapon );
}
SetWeaponState( Hold );
}
void GameManager::Initialize()
{
//Initialize the resource manager
_resourceManager.Initialize(&_graphicsDevice);
//Create the main camera object
GameObject* mainCamera = new GameObject();
mainCamera->GetTransform().SetPosition(-20,15,30);
Camera* cameraComponent = (Camera*)mainCamera->AddComponent(new Camera(mainCamera, CameraType::Perspective()));
AddGameObject(mainCamera); //Takes over the ownership of the game object
//Initialize the renderer
_renderEngine.Initialize(cameraComponent, &_resourceManager, &_graphicsDevice);
_renderEngine.SetClearColor(Color::CornflowerBlue());
//Create the 2D camera
GameObject* camera2D = new GameObject();
//camera2D->GetTransform().SetPosition(Vector3(0.0f,0.0f,-0.1f));
Camera* camera2DComponent = (Camera*)camera2D->AddComponent(new Camera(camera2D, CameraType::Orthographic()));
camera2DComponent->SetNearClip(-1.0f);
camera2DComponent->SetFarClip(1.0f);
AddGameObject(camera2D); //Takes over the ownership of the game object
//Initialize the 2D renderer
_renderEngine2D.Initialize(camera2DComponent, _renderEngine.GetWindowPointer(), &_graphicsDevice);
LoadDebugComponents();
}
//-----------------------------------------------------------------------------------------------------------------------------------
void RacetrackScreen::AddAICar(AICar* aiCar)
{
AddGameObject(aiCar, true, true);
m_startingPositions.pop_front();
m_cars.push_back(aiCar);
//AddCollisionObject(aiCar);
}
void GameManager::LoadDebugComponents()
{
Font* debugFont = _resourceManager.GetFont("../data/fonts/SourceSansPro-Bold.otf");
debugFont->SetFontSize(12);
_resourceManager.StoreAndInitMaterial("FontMaterial",
new FontMaterial(_resourceManager.GetShaderProgram("Font2D", "../data/FontMaterial.vert", "../data/FontMaterial.frag"),
Color::Yellow()));
GameObject* FPS = new GameObject();
FPS->GetTransform().SetPosition(Vector3(10,16,0));
FPS->AddComponent(new FontRenderer(FPS,_resourceManager.GetMaterial("FontMaterial"), debugFont, "FPS:", GetGraphicsDevice()));
FPS->AddComponent(new PrintFPS(FPS));
AddGameObject(FPS);
GameObject* avgFPS = new GameObject();
avgFPS->GetTransform().SetPosition(Vector3(10,32,0));
avgFPS->AddComponent(new FontRenderer(avgFPS,_resourceManager.GetMaterial("FontMaterial"), debugFont, "Avg FPS:", GetGraphicsDevice()));
avgFPS->AddComponent(new PrintAvgFPS(avgFPS));
AddGameObject(avgFPS);
GameObject* drawCall3D = new GameObject();
drawCall3D->GetTransform().SetPosition(Vector3(10,48,0));
drawCall3D->AddComponent(new FontRenderer(drawCall3D,_resourceManager.GetMaterial("FontMaterial"), debugFont, "Draw Calls(3D):", GetGraphicsDevice()));
drawCall3D->AddComponent(new Print3DDrawCalls(drawCall3D, &_renderEngine));
AddGameObject(drawCall3D);
GameObject* drawCall2D = new GameObject();
drawCall2D->GetTransform().SetPosition(Vector3(10,64,0));
drawCall2D->AddComponent(new FontRenderer(drawCall2D,_resourceManager.GetMaterial("FontMaterial"), debugFont, "Draw Calls(2D):", GetGraphicsDevice()));
drawCall2D->AddComponent(new Print2DDrawCalls(drawCall2D, &_renderEngine2D));
AddGameObject(drawCall2D);
GameObject* triCount3D = new GameObject();
triCount3D->GetTransform().SetPosition(Vector3(10,80,0));
triCount3D->AddComponent(new FontRenderer(triCount3D,_resourceManager.GetMaterial("FontMaterial"), debugFont, "Triangles(3D):", GetGraphicsDevice()));
triCount3D->AddComponent(new Print3DTriangles(triCount3D, &_renderEngine));
AddGameObject(triCount3D);
GameObject* triCount2D = new GameObject();
triCount2D->GetTransform().SetPosition(Vector3(10,96,0));
triCount2D->AddComponent(new FontRenderer(triCount2D,_resourceManager.GetMaterial("FontMaterial"), debugFont, "Triangles(2D):", GetGraphicsDevice()));
triCount2D->AddComponent(new Print2DTriangles(triCount2D, &_renderEngine2D));
AddGameObject(triCount2D);
GameObject* drawDebugObjects = new GameObject();
drawDebugObjects->GetTransform().SetPosition(Vector3(10,704,0));
drawDebugObjects->AddComponent(new FontRenderer(drawDebugObjects,_resourceManager.GetMaterial("FontMaterial"), debugFont,
"Press 'B' to toggle bounding boxes", GetGraphicsDevice()));
AddGameObject(drawDebugObjects);
GameObject* drawWireframe = new GameObject();
drawWireframe->GetTransform().SetPosition(Vector3(10,688,0));
drawWireframe->AddComponent(new FontRenderer(drawWireframe,_resourceManager.GetMaterial("FontMaterial"), debugFont,
"Press 'N' to toggle wireframe", GetGraphicsDevice()));
AddGameObject(drawWireframe);
}
bool LevelWorkerGameObjects::AddFeature(Level* pLevel)
{
m_pGo->SetLevel(pLevel);
//m_pGo->SetRoomId(pLevel->GetRoom()->GetId());
// Use this function so we keep track of which LevelWorker added which object.
AddGameObject(pLevel, m_pGo.GetPtr());
return true;
}
void Unit::DropWeapon()
{
if ( gCurrentWeapon && gWeaponState == Hold )
{
if( !gCurrentWeapon->IsDropable() || gCurrentWeapon->IsReloading() )
return;
if( gCurrentWeapon->GetState() == Reloading )
gCurrentWeapon->CancelReload();
WeaponOnGround* tWoG = new WeaponOnGround( gCurrentWeapon );
tWoG->MoveTo( gCurrentWeapon->GetFloat3Value( Position ) );
//tWoG->SetRotation( GetQuaternation() );
AddGameObject( tWoG );
tWoG->Update(0, 0);
gSecondaryWeapon= 0;
gCurrentWeapon = gPrimaryWeapon;
gCurrentWeapon->SetState( Alive );
AddGameObject( gCurrentWeapon );
}
}
//-----------------------------------------------------------------------------------------------------------------------------------
void RacetrackScreen::AddPlayerCar(PlayerCar* playerCar)
{
// Should only have one player car on the racetrack screen
assert(!m_playerCar);
// Don't want the startingline position and player starting position y to be the same otherwise we have problems detecting lap numbers
assert(m_playerStartingPosition.y != m_startingLine->GetWorldPosition().y);
AddGameObject(playerCar, true, true);
m_playerStartingPosition = playerCar->GetWorldPosition();
m_startingPositions.pop_front();
m_cars.push_back(playerCar);
m_playerCar = playerCar;
//AddCollisionObject(playerCar);
}
// Runs the game
void Game::Run()
{
// Add a test text renderer
{
auto go = AddGameObject("TestTextRenderer");
auto tm = go->AddComponent<TextMaterial>();
tr = go->AddComponent<TextRenderer>();
std::shared_ptr<Font> font = std::make_shared<Font>();
assert(font->LoadFromFile("Fonts\\OpenSans-Regular.ttf"));
tr->SetFont(font);
tr->SetFontSize(12U);
tr->SetText("Hello, world!");
tm->SetTextColor(vec4(1, 0, 0, 1));
go->GetTransform()->SetPosition(glm::vec3(5, 5, 0));
}
gameManager = std::make_shared<BilliardGameManager>();
gameManager->CreateTable();
gameManager->PreparePoolBalls();
Time::Start();
// Set the window to visible then begin the game loop
_window->SetVisible( true );
while ( _window->IsOpen() )
{
// Clear the screen
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Update and draw the game
Update();
Draw();
// Update the time values
Time::Update();
Physics::Update();
Input::Update( _window->_window );
// Poll for events and swap the buffers
_window->SwapBuffers();
_window->PollEvents();
}
}
//-----------------------------------------------------------------------------------------------------------------------------------
void RacetrackScreen::LoadCollisionTiles()
{
LevelObjects collisionTiles;
m_raceScreenData->FindCollisionTiles(collisionTiles);
for (const LevelObjectInfo& info : collisionTiles)
{
GameObject* gameObject = new GameObject(info.m_position, info.m_dataAsset, BaseObject::LoadType::kTexture);
gameObject->SetLocalRotation(info.m_rotation);
AddGameObject(gameObject, true, true);
if (info.m_shouldHaveCollider)
{
AddCollisionObject(gameObject, true);
}
}
}
void GameStage::UpdateSurvival()
{
Plane* pObj;
if( Rules_GameMode == GAMEMODE_SURVIVAL )
{
SurvivalDelay = (SurvivalDelay + 1) % FRAMES_PER_SECOND;
if( SurvivalDelay == 0 )
{
SurvivalTotalTimer++;
SurvivalTimer++;
pObj = 0;
if( SurvivalTimer >= SurvivalArrivals[SurvivalIndex] )
{
SurvivalTimer = 0;
pObj = AddPlayer( (ALLEGRO_JOYSTICK*)-1 );
if( SurvivalPlayer != 0 )
{
SurvivalPlayer->Score++;
}
if( SurvivalIndex < SURVIVAL_INTERVALS - 1 )
{
SurvivalIndex++;
} else {
if( rand() % 3 == 0 )
{
int tmpY;
if( Rules_HasGround )
{
tmpY = rand() % ((Framework::SystemFramework->GetDisplayHeight() / graphicsMultiplier) - 32);
} else {
tmpY = rand() % (Framework::SystemFramework->GetDisplayHeight() / graphicsMultiplier);
}
AddGameObject( new Cloud( new Vector2( Framework::SystemFramework->GetDisplayWidth(), tmpY ), (double)(rand() % 300) / 10.0, 180.0 ) );
}
}
}
if( pObj != 0 )
{
pObj->Team = (Objects.size() % 7) + 1;
}
}
}
}
bool LevelWorkerAddCharacters::AddFeature(Level* pLevel)
{
int numChars = m_charNames.size();
for (int i = 0; i < numChars; i++)
{
// Make a simple cube for the character bounding box.
//float s = 2.0f; // box size
//BoundingBox bb(0, s, 0, s, 0, s);
Orientation initialOr((float)(i * 2), 13, (float)(i * 2), 0, 0, 0);
// GOLF
CharacterGameObject* pCharacter = new PoolCharacter;
pCharacter->SetLevel(pLevel);
pCharacter->SetId(1 + i); // TODO CONFIG ?
pCharacter->SetRoomId(pLevel->GetRoomId());
// Set the attributes which are not loaded.
std::string characterName = m_charNames[i];
File f;
std::string s = characterName;
s += ".txt";
if (!f.OpenRead(s.c_str()))
{
f.ReportError("Failed to open character file.");
return false;
}
pCharacter->Load(&f);
pCharacter->SetState(UNKNOWN);
pCharacter->ClearMeshes();
pCharacter->AddMesh(CharacterManager::Instance()->GetCharacter(characterName));
pCharacter->SetOrientation(initialOr);
// Use this function so we keep track of which LevelWorker added which object.
AddGameObject(pLevel, pCharacter);
}
return true;
}
void GameStage::Begin()
{
GameObject::Game = this;
switch( Rules_GameMode )
{
case GAMEMODE_SURVIVAL:
Rules_PlaneToPlaneCollisions = false;
Rules_BulletToBulletCollisions = false;
Rules_FriendlyFire = true;
Rules_HasGround = true;
Framework::SystemFramework->ProgramStages->Push( (Stage*)new SurvivalControllerSelectStage() );
break;
case GAMEMODE_FREEFLIGHT:
Rules_PlaneToPlaneCollisions = false;
Rules_BulletToBulletCollisions = false;
Rules_FriendlyFire = false;
Rules_HasGround = false;
for( int i = 0; i < FREEFLIGHT_CLOUD_COUNT; i++ )
{
Cloud* c = new Cloud(new Vector2( rand() % Framework::SystemFramework->GetDisplayWidth(), rand() % Framework::SystemFramework->GetDisplayHeight() ), (float)(rand() % 80) / 10, 180.0 );
c->SetTileScale( graphicsMultiplier );
AddGameObject( c );
}
Framework::SystemFramework->ProgramStages->Push( (Stage*)new MultipleControllerSelectStage() );
break;
case GAMEMODE_LASTMANSTANDING:
Rules_PlaneToPlaneCollisions = false;
Rules_BulletToBulletCollisions = false;
Rules_FriendlyFire = true;
Rules_HasGround = true;
Framework::SystemFramework->ProgramStages->Push( (Stage*)new MultipleControllerSelectStage() );
break;
case GAMEMODE_TEAMBATTLES:
Rules_PlaneToPlaneCollisions = false;
Rules_BulletToBulletCollisions = false;
Rules_FriendlyFire = false;
Rules_HasGround = true;
Framework::SystemFramework->ProgramStages->Push( (Stage*)new MultipleControllerSelectStage() );
break;
}
}
Plane* GameStage::AddPlayer( ALLEGRO_JOYSTICK* Controller )
{
int Xpos = rand() % (Framework::SystemFramework->GetDisplayWidth() / graphicsMultiplier);
int Ypos = rand() % (((Framework::SystemFramework->GetDisplayHeight() / graphicsMultiplier) / 4) * 3);
Plane* ply = new Plane( Controller, new Vector2( Xpos, Ypos ), PLANE_VELOCITY_MAX, 0.0 );
if( rand() % 2 == 1 )
{
ply->Angle = 180.0;
ply->Flipped = true;
}
AddGameObject( ply );
if( Controller != (ALLEGRO_JOYSTICK*)-1 )
{
SurvivalPlayer = ply;
}
return ply;
}
//-----------------------------------------------------------------------------------------------------------------------------------
void RacetrackScreen::LoadStartingPoints()
{
LevelObjects startingPoints;
m_raceScreenData->FindStartingPoints(startingPoints);
for (const LevelObjectInfo& info : startingPoints)
{
GameObject* gameObject = new GameObject(info.m_position, info.m_dataAsset, BaseObject::LoadType::kTexture);
gameObject->SetLocalRotation(info.m_rotation);
AddGameObject(gameObject, true, true);
if (info.m_shouldHaveCollider)
{
AddCollisionObject(gameObject, true);
}
m_startingPositions.push_back(info.m_position);
}
}
GameObject* GameManager::CreateGameObjectsFromModel(std::string filePath)
{
std::vector<Mesh*> model = _resourceManager.GetModelFromFile(filePath);
//Create all the necessary materials
for(unsigned int i = 0; i < model.size(); i++)
{
std::string texturePath = FileUtility::LocalFileDirectory() + model[i]->GetDefaultDiffuseTextureName();
if(!_resourceManager.CheckIfMaterialExist(texturePath))
{
_resourceManager.StoreAndInitMaterial(texturePath,
new Diffuse(_resourceManager.GetShaderProgram("Diffuse", "../data/Diffuse.vert", "../data/Diffuse.frag"),
_resourceManager.GetTexture2D(texturePath)));
}
}
GameObject* previousMesh = NULL;
GameObject* rootObject = NULL;
for(unsigned int i = 0; i < model.size(); i++)
{
GameObject* meshObject = new GameObject();
//Correct the transforms
if(previousMesh != NULL)
{
meshObject->GetTransform().SetParent(&previousMesh->GetTransform());
}
else
{
rootObject = meshObject;
}
std::string texturePath = FileUtility::LocalFileDirectory() + model[i]->GetDefaultDiffuseTextureName();
meshObject->AddComponent(new MeshRenderer(meshObject, model[i], _resourceManager.GetMaterial(texturePath)));
AddGameObject(meshObject);
previousMesh = meshObject;
}
return rootObject;
}
GameObject* GameObjectManager::CreateGameObject(int type, const Ogre::Vector3& position, void* data, const Ogre::String& id){
GameObject* go = (this->*m_create_fptr[type])(position, data, id);
go->SetGameObjectManager(this);
AddGameObject(go);
return go;
}
bool LevelWorkerAddStupids::AddFeature(Level* pLevel)
{
// Assume the zeroth character held by Character Manager is reserved
// for the player character.
// For each type of stupid (i.e. name recognised by CharacterManager)
int levelNum = pLevel->GetId();
// How many Stupids to add for this level ?
// Start with 1, easiest.
int numStupids = 1 + levelNum;
int max = (int)Engine::Instance()->GetConfigFloat("max_stupids");
if (numStupids > max)
{
numStupids = max;
}
std::vector<std::string> characterNames;
CharacterManager::Iterator it = CharacterManager::Instance()->Begin();
++it; // skip player character
for ( ;
it != CharacterManager::Instance()->End();
++it)
{
characterNames.push_back(*it);
}
int numAvailableCharacters = characterNames.size();
int characterIndex = levelNum;
characterIndex %= numAvailableCharacters;
float dir = 0;
float turnDir = 90.0f;
// Get a list of the character names we will use.
// Then we want to sort the character names before adding them, to minimise texture changes.
// This is a desperate attempt to try to speed things up on slow graphics cards.
typedef std::vector<std::string> StringVec;
StringVec namevec;
int i;
for (i = 0; i < numStupids; i++)
{
std::string characterName = characterNames[characterIndex];
// Work backwards from index so in level N we get the characters from level
// N - 1 plus one new one (up until all the characters are used).
--characterIndex;
if (characterIndex < 0)
{
characterIndex = characterNames.size() - 1;
}
namevec.push_back(characterName);
}
// Sort the list of character names. The end result of this is that characters with the
// same texture will be drawn consecutively. This will minimise texture changes for characters.
std::sort(namevec.begin(), namevec.end());
for (i = 0; i < numStupids; i++)
{
// Make a simple cube for the character bounding box.
float s = 2.0f; // box size
BoundingBox bb(0, s, 0, s, 0, s);
Orientation initialOr;
if (!GetOrientation(bb, pLevel->GetPlayAreaSize(), &initialOr))
{
return false; // play area too small
}
//float shadowSize = 1.0f; // TODO should be a Character attribute
float thisInitialDir = dir;
dir += 90.0f;
if (dir >= 359.0f)
{
dir = 0;
}
float thisTurnDir = turnDir;
turnDir = -turnDir;
// Speed
//float stupidSpeed = 5.0f; // TODO Should be a character attribute
// Bounding Sphere and collision vol: use defaults loaded from file
Stupid* pStupid = new Stupid;
pStupid->SetLevel(pLevel);
pStupid->SetId(GetUniqueId());
pStupid->SetRoomId(0);
// Choose a file to load from.
// Load the Stupid.
// TODO set up in ctor
File f;
f.OpenRead("stupid1.txt"); // TODO TEMP TEST
pStupid->Load(&f);
// Set the appearance delay.
pStupid->SetAppearanceDelay((float)i * 2.0f + 2.0f); // TODO TEMP TEST
// Set the attributes which are not loaded.
std::string characterName = namevec[i];
pStupid->ClearMeshes();
pStupid->AddMesh(CharacterManager::Instance()->GetCharacter(characterName));
pStupid->SetOrientation(initialOr);
pStupid->SetInitialDirection(thisInitialDir);
pStupid->SetTurnDirection(thisTurnDir);
/*
pStupid->SetMaxSpeed(0); // TODO Should be character attrib
pStupid->SetShadowSize(0); // TODO Should be character attrib
pStupid->SetTurnVel(0); // TODO Should be character attrib
*/
// Use this function so we keep track of which LevelWorker added which object.
AddGameObject(pLevel, pStupid);
}
return true;
}
float SubSectionMenu::LoadContent()
{
//Get the screen width and height
float width = (float)ServiceLocator::GetPlatformLayer()->GetWidth();
float height = (float)ServiceLocator::GetPlatformLayer()->GetHeight();
//Create a overlay
m_Overlay = new Rect(0.0f, 0.0f, width, height);
m_Overlay->SetColor(Color::OnyxColor(0.0f));
AddGameObject(m_Overlay);
//Determine how many buttons we need and allocate an array to keep track of the buttons
const unsigned int buttonCount = WORLD_NUMBER_OF_SUBSECTIONS.x * WORLD_NUMBER_OF_SUBSECTIONS.y;
m_Buttons = new Button*[buttonCount];
//Calculate the available width and height for an inidivual button
float buttonWidth = width / WORLD_NUMBER_OF_SUBSECTIONS.x;
float buttonHeight = height / WORLD_NUMBER_OF_SUBSECTIONS.y;
//Calculate a small spacer between the buttons
vec2 buttonSpacer = vec2(buttonWidth / 8, buttonHeight / 8);
//Re-calculate the button width and height, factoring in the spacer
buttonWidth = (width - (buttonSpacer.x * (WORLD_NUMBER_OF_SUBSECTIONS.x + 1))) / WORLD_NUMBER_OF_SUBSECTIONS.x;
buttonHeight = (height - (buttonSpacer.y * (WORLD_NUMBER_OF_SUBSECTIONS.y + 1))) / WORLD_NUMBER_OF_SUBSECTIONS.y;
//Set the button size vector
vec2 buttonSize = vec2 (buttonWidth, buttonHeight);
//The string stream will be used below to see each's button label text
stringstream ss;
//Cycle through the buttonCount and create a new button object
for(unsigned int i = 0; i < buttonCount; i++)
{
//Calculate the coordinates based on the button index
uvec2 coordinates = uvec2(0,0);
coordinates.x = (i % WORLD_NUMBER_OF_SUBSECTIONS.x);
coordinates.y = ((i - coordinates.x) / WORLD_NUMBER_OF_SUBSECTIONS.x);
//Use those coordinates to set the button label
ss.str("");
ss << "(" << coordinates.x << "," << coordinates.y << ")";
//Create the button and initialize its properties
m_Buttons[i] = new Button("Ubuntu-B", "ttf", 48);
m_Buttons[i]->SetText(ss.str());
m_Buttons[i]->SetBackgroundColor(Color::CornflowerBlueColor(), ButtonStateNormal);
m_Buttons[i]->SetBackgroundColor(Color::CornflowerBlueColor(), ButtonStateSelected);
m_Buttons[i]->SetBackgroundColor(Color::CornflowerBlueColor(), ButtonStateDisabled);
m_Buttons[i]->SetTextColor(Color::WhiteColor(), ButtonStateNormal);
m_Buttons[i]->SetTextColor(Color::WhiteColor(), ButtonStateSelected);
m_Buttons[i]->SetTextColor(Color::WhiteColor(), ButtonStateDisabled);
m_Buttons[i]->SetPreferredSize(buttonSize);
m_Buttons[i]->SetAnchorPoint(0.5f, 0.5f);
m_Buttons[i]->AddEventListener(this, BUTTON_ACTION);
//Calculate the button's exact position and set it
float buttonX = buttonSpacer.x + (buttonSize.x / 2.0f) + (buttonSpacer.x + buttonSize.x) * coordinates.x;
float buttonY = buttonSpacer.y + (buttonSize.y / 2.0f) + (buttonSpacer.y + buttonSize.y) * coordinates.y;
m_Buttons[i]->SetLocalPosition(buttonX, buttonY);
//Add the button object to the scene
AddGameObject(m_Buttons[i]);
}
return 1.0f;
}
Scene::Scene()
{
GameObject *cam = new GameObject();
camera = cam->AddComponent<Camera>();
AddGameObject(cam);
}
void WintergraspWorkshopData::Init(uint8 team)
{
// Outside Workshops
if (m_workshopId < BATTLEFIELD_WG_WORKSHOP_KEEP_WEST)
{
// Set worldstate and nameId
m_WorldState = CapturableWorkshops[m_workshopId].worldState;
m_NameId = CapturableWorkshops[m_workshopId].nameId;
// Spawning Workshop
WintergraspObjectPositionData workshop = CapturableWorkshops[m_workshopId].GameObjectMain[0];
GameObject* pWorkshop = m_WG->SpawnGameObject(workshop.entryHorde, workshop.x, workshop.y, workshop.z, workshop.o);
if (!pWorkshop)
return;
// Spawning Engineer, save them separate
WintergraspObjectPositionData engineer = CapturableWorkshops[m_workshopId].Engineer;
if (Creature* pEngineer = m_WG->SpawnCreature(engineer.entryHorde, engineer.x, engineer.y, engineer.z, engineer.o, TEAM_HORDE))
m_Engineer[TEAM_HORDE] = pEngineer->GetGUID();
if (Creature* pEngineer = m_WG->SpawnCreature(engineer.entryAlliance, engineer.x, engineer.y, engineer.z, engineer.o, TEAM_ALLIANCE))
m_Engineer[TEAM_ALLIANCE] = pEngineer->GetGUID();
// Spawning Spirit Keeper and link him to the graveyard
if (BfGraveyard* pGrave = m_WG->GetGraveyardById(m_workshopId))
{
WintergraspObjectPositionData spirit = CapturableWorkshops[m_workshopId].SpiritGuide;
if (Creature* pSpirit = m_WG->SpawnCreature(spirit.entryHorde, spirit.x, spirit.y, spirit.z, spirit.o, TEAM_HORDE))
// Link spirit to graveyard
pGrave->SetSpirit(pSpirit, TEAM_HORDE);
if (Creature* pSpirit = m_WG->SpawnCreature(spirit.entryAlliance, spirit.x, spirit.y, spirit.z, spirit.o, TEAM_ALLIANCE))
// Link spirit to graveyard
pGrave->SetSpirit(pSpirit, TEAM_ALLIANCE);
}
// Spawning Creature and NPC
for (uint8 i = 0; i < CapturableWorkshops[m_workshopId].nbCreature; ++i)
AddCreature(CapturableWorkshops[m_workshopId].Creature[i]);
// Spawning Banner
for (uint8 i = 0; i < CapturableWorkshops[m_workshopId].nbBanner; ++i)
AddGameObject(CapturableWorkshops[m_workshopId].GameObjectBanner[i]);
// Spawning Rocket Launcher
for (uint8 i = 0; i < CapturableWorkshops[m_workshopId].nbRocketLauncher; ++i)
AddRocketLauncher(CapturableWorkshops[m_workshopId].RocketLauncher[i]);
}
// Fortress Workshops
else
{
// Array support (only 2 elements - 4, 5 are m_workshopIds)
uint8 workshopId = m_workshopId - WG_CAPTURABLE_WORKSHOP;
// Set worldstate
m_WorldState = FortressWorkshops[workshopId].worldState;
// Spawning Workshop
WintergraspObjectPositionData workshop = FortressWorkshops[workshopId].Workshop;
GameObject* pWorkshop = m_WG->SpawnGameObject(workshop.entryHorde, workshop.x, workshop.y, workshop.z, workshop.o);
if (!pWorkshop)
return;
// Spawning Engineer
WintergraspObjectPositionData engineer = FortressWorkshops[workshopId].Engineer;
if (Creature* pEngineer = m_WG->SpawnCreature(engineer.entryHorde, engineer.x, engineer.y, engineer.z, engineer.o, TEAM_HORDE))
m_Engineer[TEAM_HORDE] = pEngineer->GetGUID();
if (Creature* pEngineer = m_WG->SpawnCreature(engineer.entryAlliance, engineer.x, engineer.y, engineer.z, engineer.o, TEAM_ALLIANCE))
m_Engineer[TEAM_ALLIANCE] = pEngineer->GetGUID();
// Spawning Spirit Keeper and link him to the graveyard (only one graveyard in the keep - linked to the west)
if (m_workshopId == BATTLEFIELD_WG_WORKSHOP_KEEP_WEST)
{
if (BfGraveyard* pGrave = m_WG->GetGraveyardById(m_workshopId))
{
WintergraspObjectPositionData spirit = FortressWorkshops[workshopId].SpiritGuide;
if (Creature* pSpirit = m_WG->SpawnCreature(spirit.entryHorde, spirit.x, spirit.y, spirit.z, spirit.o, TEAM_HORDE))
// Link spirit to graveyard
pGrave->SetSpirit(pSpirit, TEAM_HORDE);
if (Creature* pSpirit = m_WG->SpawnCreature(spirit.entryAlliance, spirit.x, spirit.y, spirit.z, spirit.o, TEAM_ALLIANCE))
// Link spirit to graveyard
pGrave->SetSpirit(pSpirit, TEAM_ALLIANCE);
}
}
}
// Finally change faction
GiveControlTo(team);
}
