int LobbyMenu::checkButtons(){
InputManager::getInstance()->update();
for (size_t i = 0; i < classButt.size(); ++i){
// if pressed
if (dynamic_cast<ButtonLogicComponent*>(classButt[i]->GetComponent(COMPONENT_LOGIC))->isButtonPressed()){
int selection = dynamic_cast<ButtonRenderComponent*>(classButt[i]->GetComponent(COMPONENT_RENDER))->getCurrImage();
playerSelection(selection);
selected = selection;
return i+10;
}
// if hovering over show images of the tutorials
if (dynamic_cast<ButtonLogicComponent*>(classButt[i]->GetComponent(COMPONENT_LOGIC))->isMouseHovering()){
dynamic_cast<TutorialRenderComponent*>(tutorials[i]->GetComponent(COMPONENT_RENDER))->toggleImage(true);
}
else {
dynamic_cast<TutorialRenderComponent*>(tutorials[i]->GetComponent(COMPONENT_RENDER))->toggleImage(false);
}
}
if (selected != -1 && readyButt && dynamic_cast<ButtonLogicComponent*>(readyButt->GetComponent(COMPONENT_LOGIC))->isButtonPressed()){
ready = !ready;
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("readyupsfx.ogg");
playerReady(ready);
return BUTTON_READY;
}
if (dynamic_cast<ButtonLogicComponent*>(backButt->GetComponent(COMPONENT_LOGIC))->isButtonPressed()){
return BUTTON_BACK;
}
return BUTTON_NONE;
}
void MainWindow::cbStop(Fl_Widget*) {
AudioManager* man = AudioManager::getInstance();
m_playPauseButton->label("@>");
man->stopTrees();
m_playPauseButton->value(0);
m_tuilesTree->redraw();
}
NS_IMETHODIMP Run() {
nsCOMPtr<nsIAudioManager> amService = do_GetService(NS_AUDIOMANAGER_CONTRACTID);
NS_ENSURE_TRUE(amService, NS_OK);
AudioManager *am = static_cast<AudioManager *>(amService.get());
for (int loop = 0; loop < AUDIO_STREAM_CNT; loop++) {
AudioSystem::initStreamVolume(static_cast<audio_stream_type_t>(loop), 0,
sMaxStreamVolumeTbl[loop]);
int32_t index;
am->GetStreamVolumeIndex(loop, &index);
am->SetStreamVolumeIndex(loop, index);
}
if (sHeadsetState & AUDIO_DEVICE_OUT_WIRED_HEADSET)
InternalSetAudioRoutes(SWITCH_STATE_HEADSET);
else if (sHeadsetState & AUDIO_DEVICE_OUT_WIRED_HEADPHONE)
InternalSetAudioRoutes(SWITCH_STATE_HEADPHONE);
else
InternalSetAudioRoutes(SWITCH_STATE_OFF);
int32_t phoneState = nsIAudioManager::PHONE_STATE_INVALID;
am->GetPhoneState(&phoneState);
#if ANDROID_VERSION < 17
AudioSystem::setPhoneState(phoneState);
#else
AudioSystem::setPhoneState(static_cast<audio_mode_t>(phoneState));
#endif
AudioSystem::get_audio_flinger();
return NS_OK;
}
void FakeAudio::loadAudio()
{
// this might take some time, we should move this to a bg thread
buffer = manager.getBuffer(src);
if (!buffer) {
buffer = new OpenALBuffer(src);
manager.setBuffer(buffer, src);
}
alGenSources(1, &sourceId);
alSourcei(sourceId, AL_BUFFER, buffer->getBufferId());
alSourcei(sourceId, AL_PITCH, 1.0f);
alSourcei(sourceId, AL_GAIN, 1.0f);
loaded = true;
if (autoplay)
play(NULL, 0, NULL);
if (loop)
alSourcei(sourceId, AL_LOOPING, AL_TRUE);
// get the duration
ALint bufferID = buffer->getBufferId(),
bufferSize, frequency, bitsPerSample, channels;
alGetBufferi(bufferID, AL_SIZE, &bufferSize);
alGetBufferi(bufferID, AL_FREQUENCY, &frequency);
alGetBufferi(bufferID, AL_CHANNELS, &channels);
alGetBufferi(bufferID, AL_BITS, &bitsPerSample);
duration = ((float)bufferSize)/(frequency*channels*(bitsPerSample/8));
}
void PlayerLogicComponent::hatchBird(bool respawn){
if (isEgg){
if (respawn && gameObjectRef->isLocal){
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("roostersfx.ogg");
}
PlayerRenderComponent* renderComp = dynamic_cast<PlayerRenderComponent*>(gameObjectRef->GetComponent(COMPONENT_RENDER));
//reset sprites
//for (auto obj : renderComp->allObjs)obj.second->visible = true;
createParticle(renderComp->allObjs["egg"], 10, gameObjectRef->posX, gameObjectRef->posY);
renderComp->allObjs["body"]->visible = true;
renderComp->allObjs["egg"]->visible = false;
//reset positions
renderComp->allObjs["base"]->posX = gameObjectRef->posX;
renderComp->allObjs["base"]->posY = gameObjectRef->posY;
//reset rotation
PlayerPhysicsComponent* physicsComp = dynamic_cast<PlayerPhysicsComponent*>(gameObjectRef->GetComponent(COMPONENT_PHYSICS));
b2Vec2 pos;
physicsComp->mBody->SetFixedRotation(true);
pos = physicsComp->mBody->GetPosition();
gameObjectRef->rotation = 0;
physicsComp->mBody->SetTransform(pos, 0);
renderComp->allObjs["base"]->rotation = 0;
isEgg = false;
}
}
int jackCallback(jack_nframes_t nbFrames, void *arg) {
AudioManager* aman = AudioManager::getInstance();
//progress in the trees
aman->processTrees(float(nbFrames)*aman->m_procStep);
//process the buffers
aman->process(nbFrames);
return 0;
}
// background thread that will check the status of the buffers
static void* _checkBufferStatus(void* args) {
AudioManager* manager = (AudioManager*)args;
while (bgThreadAlive) {
manager->checkBuffers();
usleep(500); // 500usec -> 0.5ms
}
return NULL;
}
void PowerShieldLogicComponent::playShieldCollisionSFX() {
//Need shield object
PowerShieldRenderComponent* rendComp = dynamic_cast<PowerShieldRenderComponent*>(gameObjectRef->GetComponent(COMPONENT_RENDER));
RenderManager* renderMan = RenderManager::getRenderManager();
if (renderMan->isObjOnScreen(rendComp->objRef)) {
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("chickenshieldsfx.ogg");
}
}
TEST(AudioManager, init)
{
AudioManager audioMgr;
audioMgr.startUp();
EXPECT_TRUE(audioMgr.isSupport());
audioMgr.shutDown();
EXPECT_FALSE(audioMgr.isSupport());
}
int recordCallback( const void *input, void *output,
unsigned long,
const PaStreamCallbackTimeInfo* timeInfo,
PaStreamCallbackFlags statusFlags,
void *userData)
{
AudioManager *dis = (AudioManager*)userData;
const SAMPLE *in = (const SAMPLE *)input;
int retenc(0);
(void) timeInfo;
(void) statusFlags;
(void) output;
//OLD
// dis->setDataRec(dis->getEnc()->encodeAudio(in, &retenc));
// dis->setRetencRec(retenc);
dis->getPool().tryLock(REC_MUTEX);
//dis->getBufferRec().write(dis->getEnc()->encodeAudio(in, &retenc), retenc);
unsigned char *tmp = dis->getEnc()->encodeAudio(in, &retenc);
if (dis->getSizeRec() + retenc < 255*255)
{
LibC::memcpy(dis->getStaticBufferRec() + dis->getSizeRec(), tmp, retenc);
dis->setSizeRec(dis->getSizeRec() + retenc);
}
dis->getPool().unLock(REC_MUTEX);
return paContinue;
}
int main () {
AudioManager * am = new AudioManager();
am->loadSamples("sampled-repos/car-clean-10.26.2015/");
am->loadGroundTruth("audio-repos/car-clean-10.26.2015/");
XCorrIdentifier * xc = new XCorrIdentifier(am);
xc->doAllMatches();
int correct = am->evaluate(xc->getMatches());
cout << "Got " << correct << " out of " << am->getNumSamples() << endl;
//Identifier identifiers [2] = {XCorrIdentifier(am), RandomIdentifier(am)};
return 0;
}
void test(){
AudioManager* am = AudioManager::getInstance();
//Adding music to filename's map
am->add("1", "FileName1.mp3");
am->add("2", "FileName2.mp3");
char c = 0;
//Testing based on user input
while (42){
c = _getch();
cout << (int)c << endl;
switch (c){
case 'c':
case 'C':
delete am;
AudioRenderer::destroy();
return;
case 'p':
case 'P':
(AudioRenderer::Instance())->pauseMusic();
break;
case 's':
case 'S':
(AudioRenderer::Instance())->stopMusic();
break;
case '1':
(AudioRenderer::Instance())->loadAndPlayMusic("1", am);
break;
case '2':
(AudioRenderer::Instance())->loadAndPlayMusic("2", am);
break;
case 'u':
case 'U':
(AudioRenderer::Instance())->musicVolumeUp();
break;
case 'd':
case 'D':
(AudioRenderer::Instance())->musicVolumeDown();
break;
case 'm':
case 'M':
(AudioRenderer::Instance())->muteMusic();
break;
case 'r':
case 'R':
(AudioRenderer::Instance())->musicVolumeReset();
break;
default:
break;
}
}
}
void FakeAudio::loadAudio()
{
buffer = manager.getBuffer(src);
if (!buffer) {
buffer = new OpenALBuffer(src);
manager.setBuffer(buffer, src);
}
alGenSources(1, &sourceId);
genSource(sourceId, buffer->getBufferId(), loop);
loaded = true;
if (autoplay)
play(NULL, 0, NULL);
updateDuration();
}
void MainWindow::togglePlayPause() {
AudioManager* man = AudioManager::getInstance();
if(man->isPlaying()) {
m_playPauseButton->label("@>");
man->pauseTrees();
m_playPauseButton->value(0);
}
else {
m_playPauseButton->label("@||");
man->startTrees();
m_playPauseButton->value(1);
}
m_tuilesTree->redraw();
}
int playCallback( const void *input, void *output,
unsigned long,
const PaStreamCallbackTimeInfo* timeInfo,
PaStreamCallbackFlags statusFlags,
void *userData)
{
AudioManager *dis = (AudioManager*)userData;
SAMPLE *out = (SAMPLE *)output;
(void) timeInfo;
(void) statusFlags;
(void) input;
int tmp;
//NEW WAY
dis->getPool().tryLock(PLAY_MUTEX);
tmp = dis->getSizePlay();
dis->setSizePlay(0);
dis->getPool().unLock(PLAY_MUTEX);
if (tmp)
dis->getEnc()->decodeAudio(dis->getStaticBufferPlay(), out, tmp);
//OLD
//dis->getEnc()->decodeAudio(dis->getDataPlay(), out, dis->getRetencPlay());
return paContinue;
}
Sound::Sound(int eventId)
{
AudioManager* am = AudioManager::GetInstance();
am->GetEventHandle(eventId, this->zEvent);
this->zCurrentTime = 0;
switch (eventId)
{
case EVENTID_NOTDEADYET_WALK_GRASS:
this->zMaxTime = 0.5f;
break;
case EVENTID_NOTDEADYET_WALK_DIRT:
this->zMaxTime = 0.5f;
break;
default:
break;
}
}
void TreeWidget::updateChildren() {
m_childrenTuileWidgets.clear();
//get new children tuile widgets
AudioManager* man = AudioManager::getInstance();
vector<Tuile*>::const_iterator itChild=man->getChildren().begin();
for(; itChild!=man->getChildren().end(); ++itChild) {
if(m_tuileWidgets.find((*itChild)->getID())!=m_tuileWidgets.end()){
m_childrenTuileWidgets.push_back(
m_tuileWidgets[(*itChild)->getID()]);
}
}
//update the children of all the tuilewidgets
map<unsigned int, TuileWidget*>::iterator itWid=m_tuileWidgets.begin();
for(; itWid!=m_tuileWidgets.end(); ++itWid) {
itWid->second->updateChildren();
}
//print the trees
man->printTrees();
//update everything
notifyUpdate();
}
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR, int)
{
MaloW::ClearDebug();
#ifdef INCLUDE_MODEL_VIEWER
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
MaloW::Debug("(DEBUG): Client: Debug flag set to: _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF). ");
MaloW::Debug("(DEBUG): Client: vld.h included.");
#endif
if ( !GraphicsInit(hInstance) )
{
MaloW::Debug("Failed Initializing Graphics!");
return 1;
}
if ( !PlayerSettingsInit() )
{
MaloW::Debug("Failed Initializing PlayerSettings!");
return 1;
}
AudioManager* am = AudioManager::GetInstance();
// IMPLEMENT MAIN PROGRAM HERE.
MainMenu* menu = new MainMenu();
menu->Init();
menu->Run();
SAFE_DELETE(menu);
am->ReleaseInstance();
am = NULL;
// Free Graphics
FreeGraphics();
// Save and Free Settings
SavePlayerSettings();
FreePlayerSettings();
//_CrtDumpMemoryLeaks();
MaloW::Debug("Quit Game.");
return 0;
}
void PlayerLogicComponent::playDeathSFX(int playerClass, uint64_t deadPlayerID){
//Need to pass a reference to the GameObject* associated with player who was killed
GameObject* deadPlayer = GameObjects.GetGameObject(deadPlayerID);
PlayerRenderComponent* rendComp = dynamic_cast<PlayerRenderComponent*>(deadPlayer->GetComponent(COMPONENT_RENDER));
RenderManager* renderMan = RenderManager::getRenderManager();
if (renderMan->isObjOnScreen(rendComp->objRef)){
AudioManager* audioMan = AudioManager::getAudioInstance();
switch (playerClass){
case CLASS_CHICKEN:
audioMan->playByName("chickensfx.ogg");
break;
case CLASS_PEACOCK:
audioMan->playByName("peacocksfx.ogg");
break;
case CLASS_FLAMINGO:
audioMan->playByName("flamingosfx.ogg");
break;
case CLASS_QUAIL:
audioMan->playByName("quailsfx.ogg");
break;
case CLASS_TURKEY:
audioMan->playByName("turkeysfx.ogg");
break;
case CLASS_EAGLE:
//Unimplemented
//audioMan->playByName("eaglesfx.ogg");
break;
}
}
}
bool MainScene::Init()
{
// 获得用户
UserManager* userMgr = UserManager::getInstance();
// 启动子弹系统
BulletManager::getInstance()->startUp("Data/bulletConfig.lua");
// 启动道具系统
ItemManager::getInstance()->startUp("Data/itemConfig.lua");
// 启动飞机系统
PlaneManager::getInstance()->startUp("Data/planeConfig.lua");
// 启动特效系统
EffectManager::getInstance()->startUp("Data/effectConfig.lua");
// 调整摄像机的z轴位置
Camera::getInstance()->SetCameraPosition(0, 0, -600);
// 缓存音效
AudioManager* audioMgr = AudioManager::getInstance();
audioMgr->loadSoundForCache("Sound/se/beiji.ogg");
audioMgr->loadSoundForCache("Sound/se/boom.mp3");
audioMgr->loadSoundForCache("Sound/se/fly.ogg");
audioMgr->loadSoundForCache("Sound/se/get_item.mp3");
audioMgr->loadSoundForCache("Sound/se/missile.mp3");
audioMgr->loadSoundForCache("Sound/se/own_shoot1.ogg");
audioMgr->loadSoundForCache("Sound/se/own_shoot2.mp3");
audioMgr->loadSoundForCache("Sound/se/own_shoot3.ogg");
audioMgr->loadSoundForCache("Sound/se/se_warning.ogg");
// 初始化主角飞机
_own = Own::Create(userMgr->GetOwn());
_own->SetPosition(0, -150, 0);
Add(_own, LAYER_PLAYER);
// 分数
_scoreText = TextSprite::Create("SCORE:0", "微软雅黑", 16);
Add(_scoreText);
// 启动关卡系统
StageManager::getInstance()->startUp("Data/stage" + to_string(userMgr->GetStage()) + ".lua", this);
// 启动数据更新函数
AddUpdateFunc(UpdateFunc::Create(CALLBACK_PARAMETER_1(MainScene::UpdateData, this)));
EventDispatcher::getInstance()->Add(
KeyboardListener::Create(
this, KeyboardFunc::Create(
CALLBACK_PARAMETER_2(MainScene::onkey, this))));
return true;
}
bool rd::AudioManager::destroyAudioManager()
{
//-- First, stop & delete the manager currently in use (if any)
if (audioManagerInstance != NULL)
{
audioManagerInstance->stop();
delete audioManagerInstance;
audioManagerInstance = NULL;
//-- Remove it also from the registry
std::map<std::string, AudioManager *>::iterator it = audioManagerRegistry.find(currentId);
if (it != audioManagerRegistry.end())
audioManagerRegistry.erase(it);
}
//-- Destroy all the remaining registered InputManagers
for ( std::map<std::string, AudioManager *>::iterator it = audioManagerRegistry.begin();
it != audioManagerRegistry.end(); ++it)
{
AudioManager * currentManager = it->second;
if (currentManager != NULL)
{
currentManager->stop();
delete currentManager;
currentManager = NULL;
}
//-- Remove it also from the registry
audioManagerRegistry.erase(it);
}
return true;
}
bool initialize()
{
REQUIRE(RBConfig::initialize(CONFIG_FILENAME));
REQUIRE(Logger::initialize(LOG_COUT | LOG_TIMESTAMP_SHORT));
REQUIRE(display.init());
REQUIRE(audio.init());
ms_per_frame = RBConfig::getMSPerFrame();
keys = new Keyboard;
mouse = new Mouse;
painter = new RBPainter;
setupWindows();
stringstream welcome;
Logger::log("Welcome to Roguebud V. %s.",RBConfig::getVersion().c_str());
return true;
}
int GameSession::Run(){
// temp
int numLobbyPlayer = 0;
int numPlayers = 1;
//
/// MANAGERS
LogManager* log = LogManager::GetLogManager();
InputManager* input = InputManager::getInstance();
AudioManager* audioMan = AudioManager::getAudioInstance();
RenderManager* renderMan = RenderManager::getRenderManager();
ResourceManager* resourceMan = ResourceManager::GetResourceManager();
SceneManager* sceneMan = SceneManager::GetSceneManager();
input->update();
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/// SYSTEMS
SystemNetworkUpdater sysNetwork;
SystemRenderUpdater sysRenderer;
SystemInputUpdater sysInput;
SystemLogicUpdater sysLogic;
SystemPhysicsUpdater sysPhysics;
SystemClassUpdater sysClass;
SystemUIUpdater sysUI;
/// ENTITIES
PlayerObjectFactory pFactory;
MinionObjectFactory mFactory;
FeatherObjectFactory fFactory;
PlatformObjectFactory plFactory;
MidPlatObjectFactory mpFactory;
numPlayers = NetworkManager::sInstance->GetPlayerCount();
//std::cout << NetworkManager::sInstance->GetLobbyId() << std::endl;
/*for (const auto& iter : NetworkManager::sInstance->lobbyInfoMap){
std::cout << iter.first << std::endl;
std::cout << "\tClass:" << iter.second.classType << std::endl;
}*/
GameObject * player = NULL;
Stats stats;
/// try to join a game and give each user a unique character in the game
unordered_map< uint64_t, PlayerInfo > lobby = NetworkManager::sInstance->getLobbyInfoMap();
Stats::resetStats();
int i = 0;
bool local = true;
for (auto &iter : lobby){
int classType = iter.second.classType;
std::cout << "classType: " << classType << std::endl;
if (iter.first == NetworkManager::sInstance->GetMyPlayerId()){
player = GameObjects.AddObject(pFactory.Spawn(iter.first, (classType % 50) + 1, (i % 2) + 1, local));
Stats::setLocalTeam((i % 2) + 1);
Stats::addPlayer(iter.first, (i % 2) + 1);
}
else{
GameObjects.AddObject(pFactory.Spawn(iter.first, (classType % 50) + 1, (i % 2) + 1, !local));
Stats::addPlayer(iter.first, (i % 2) + 1);
}
++i;
}
/////////////////////////////////////////////////////
/* * * * GAME LOOP * * * */
/////////////////////////////////////////////////////
bool gameloop = true;
int var = 0;
renderMan->zoom = 0.5;
float size = 6;
float ratio = 0.7f;
int armswing = (int)size;
int moveSpd = 1;
int pressed = 0;
int pressedTime = 3;
int rotation = 0;
audioMan->playByName("bgmBAAGameplay.ogg");
bool gameEndMusic = false;
int mousecounter = 5;
renderMan->zoom = 0.6f;
SystemUIObjectQueue queue;
//World Loading
GameSession::LoadWorld();
GameSession::LoadPlayers();
GameSession::LoadHUD(player, queue);
///*auto spawning minion variables
int minionCounter = 10000;
//crosshair variables
SDLRenderObject * crosshair = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), 1109, -1000, -1000, -0.05f);
SDLRenderObject * crosshairCharging = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), 1111, -1000, -1000, -0.05f);
crosshairCharging->visible = false;
PlayerLogicComponent* playerLogic = dynamic_cast<PlayerLogicComponent*>(player->GetComponent(COMPONENT_LOGIC));
PlayerRenderComponent* playerRend = dynamic_cast<PlayerRenderComponent*>(player->GetComponent(COMPONENT_RENDER));
//midway fountain
/*
SDLRenderObject * fount = sceneMan->InstantiateObject(sceneMan->findLayer("layer2"), 101004, 40, 150, 0.005f);
fount->setScale(0.5f);
list<motion> motions;
motions.push_back(makeMotion(keyframeAnimate(fount, 0, 15), 0, 1));
Animation * runWater = new Animation(100, motions);
int aniCounter = 0;
*/
LoadBackgroundProps();
int aniCounter = 0;
bool firstTime = true;
Timing::sInstance.SetCountdownStart();
NetworkManager::sInstance->SetState(NetworkManager::NMS_Playing);
std::cout << NetworkManager::sInstance->GetState() << std::endl;
clock_t current_ticks, delta_ticks;
clock_t fps = 0;
string fpscounter = "";
SDLRenderObject * fpsHUD = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), -1, 5, 0, true);
fpsHUD->setResourceObject(renderMan->renderText(fpscounter.c_str(), 255, 0, 0, 20, "VT323-Regular"));
fpsHUD->setPos(0, 0);
SDLRenderObject * leftbaseHUDicon = nullptr;
SDLRenderObject * rightbaseHUDicon = nullptr;
if (player->team == TEAM_PURPLE){
leftbaseHUDicon = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), 7006, 0, 0, true);
leftbaseHUDicon->flipH = true;
rightbaseHUDicon = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), 7005, 0, 0, true);
rightbaseHUDicon->flipH = true;
}
else{
leftbaseHUDicon = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), 7005, 0, 0, true);
rightbaseHUDicon = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), 7006, 0, 0, true);
}
leftbaseHUDicon->setPos(-150, 600);
string leftBaseHealth = "";
SDLRenderObject * leftbaseHUD = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), -1, 5, 0, true);
leftbaseHUD->setResourceObject(renderMan->renderText(leftBaseHealth.c_str(), 255, 0, 0, 60, "VT323-Regular"));
leftbaseHUD->setPos(15, 650);
rightbaseHUDicon->setPos(1214, 600);
string rightBaseHealth = "";
SDLRenderObject * rightbaseHUD = sceneMan->InstantiateObject(sceneMan->findLayer("layer1"), -1, 5, 0, true);
rightbaseHUD->setResourceObject(renderMan->renderText(rightBaseHealth.c_str(), 255, 0, 0, 60, "VT323-Regular"));
rightbaseHUD->setPos(1281, 650);
renderMan->toggleCursor(0);
/////////////Flip screen if needed/////////////////
if (player->team == TEAM_PURPLE){
std::cout << "flip the screen" << std::endl;
renderMan->flippedScreen = true;
}
//////////////////////////////////////////////////
bool gameEnd = false;
inGameStatsRenderComponent inGameStats;
while (gameloop) {
current_ticks = clock();
if (input->isKeyDown(KEY_TAB)){
inGameStats.updateText();
inGameStats.toggleOn(true);
}
else{
inGameStats.toggleOn(false);
}
//std::cout << NetworkManager::sInstance->GetState() << std::endl;
/*if (input->isKeyDown(KEY_Q)){
if (renderMan->cameraPoint.z < -5){
renderMan->cameraPoint.z += 1;
}
}
if (input->isKeyDown(KEY_W)){
renderMan->cameraPoint.z -= 1;
}
if (input->isKeyDown(KEY_E)){
renderMan->flippedScreen = !renderMan->flippedScreen;
}*/
/*clock_t t;
t = clock();*/
if (input->isKeyDown(KEY_F)){
std::cout << "Number of feathers: " << GameObjects.dead_feathers.size() << std::endl;
}
if (input->isKeyDown(KEY_M)){
std::cout << "Number of minions: " << GameObjects.dead_minions.size() << std::endl;
}
if (input->isKeyDown(KEY_L)){
std::cout << "Alive Objects: " << GameObjects.alive_objects.size() << std::endl;
}
if (input->isKeyDown(KEY_Y)) {
renderMan->ShakeScreen(.2f, .5f);
}
mousecounter++;
////////////////////////////////////
if (numPlayers != 1) NetworkManager::sInstance->UpdateDelay();
//CAMERA MOVEMENT - based on player position
if (!gameEnd){
if (player){
//Camera Shake
if ((!rightBase->isAlive || !leftBase->isAlive) && !endedBaseShake) {
endedBaseShake = true;
renderMan->ShakeScreen(1, 1);
}
/*int mousePos = input->getMouseX();
int wid, hei;
renderMan->getWindowSize(&wid, &hei);
float xRatio = (mousePos - wid / 2) / float(wid / 2);
float xPlus = (float)(wid / 4) - 20;
//std::cout << xRatio << std::endl;
renderMan->setCameraPoint(player->posX + xRatio*xPlus, 0);*/
float mouseX, mouseY;
renderMan->windowCoordToWorldCoord(mouseX, mouseY, input->getMouseX(), input->getMouseY());
float cameraX = (player->posX + mouseX) / 2;
//next line makes the camera favor staying closer to the player
cameraX = (player->posX + cameraX) / 2;
renderMan->setCameraPoint(cameraX, 0);
}
}
int length = 20;
float loop = (float)(var % length);
//crosshair updating
float crossX, crossY;
renderMan->windowCoordToWorldCoord(crossX, crossY, input->getMouseX(), input->getMouseY());
crosshair->posX = crosshairCharging->posX = crossX;
crosshair->posY = crosshairCharging->posY = crossY;
float attackCDPercent = Timing::sInstance.GetAttackCooldownRemaining();
float chargePercent = 1.0f - (playerLogic->currChargePercentage > 0.75f ? 0.75f : playerLogic->currChargePercentage);
if (chargePercent != 1.0f){ //sets scale during charge
//crosshair->setScale(chargePercent);
crosshairCharging->visible = false;
crosshair->visible = true;
playerRend->crosshairRef = crosshair;
}
else if (chargePercent == 1.0f && Timing::sInstance.AttackCooldownEnded()) {
crosshairCharging->visible = false;
crosshair->visible = true;
crosshair->setScale(1.0f);
playerRend->crosshairRef = crosshair;
}
else {//if(attackCDPercent < 1.0f) { //sets scale during attack cooldown
crosshairCharging->setScale(attackCDPercent);
crosshairCharging->visible = true;
crosshair->visible = false;
playerRend->crosshairRef = crosshairCharging;
}
//physics testing stuff
PhysicsListener listener;
GameWorld* gameWorld = GameWorld::getInstance();
gameWorld->physicsWorld->SetContactListener(&listener);
gameWorld->update(); //update physics world
//end physics testing stuff
sysInput.InputUpdate(GameObjects.alive_objects);
sysRenderer.RenderUpdate(GameObjects.alive_objects);
sysLogic.LogicUpdate(GameObjects.alive_objects);
sysPhysics.PhysicsUpdate(GameObjects.alive_objects);
sysClass.ClassUpdate(GameObjects.alive_objects);
sysUI.UIUpdate(queue.alive_objects);
if (numPlayers != 1) sysNetwork.NetworkUpdate(GameObjects.alive_objects);
//updates all timers
Invoke::UpdateTimers();
if (input->isKeyDown(KEY_ESCAPE))
gameloop = false;
//OBJECT POOLING - moves recently dead objects to respective dead pool
for (unsigned int i = 0; i < GameObjects.alive_objects.size(); i++){
if (!GameObjects.alive_objects[i]->isAlive){
//object has died this last gameloop. send it to the object pool
//std::cout << "ID: " << GameObjects.alive_objects[i]->ID << std::endl;
if (GameObjects.alive_objects[i]->type == OBJECT_FEATHER){
GameObjects.dead_feathers.push_back(GameObjects.alive_objects[i]);
}
else if (GameObjects.alive_objects[i]->type == OBJECT_MINION){
GameObjects.dead_minions.push_back(GameObjects.alive_objects[i]);
}
else {
GameObjects.dead_objects.push_back(GameObjects.alive_objects[i]);
}
GameObjects.alive_objects.erase(GameObjects.alive_objects.begin() + i);
}
}
if (!firstTime) //allows culling to start after all initialization happens
cullObjects();
if (NetworkManager::sInstance->IsMasterPeer() && Timing::sInstance.SpawnMinions()){
GameObjects.AddObject(mFactory.Spawn(minionCounter++, -900, 0, TEAM_YELLOW));
GameObjects.AddObject(mFactory.Spawn(minionCounter++, 900, 0, TEAM_PURPLE));
}
input->update();
sceneMan->AssembleScene();
//triggers endgame screen
if (Timing::sInstance.GetTimeRemainingS() <= 0) {
/*if (player->team == TEAM_PURPLE){
std::cout << "flip the screen" << std::endl;
renderMan->flippedScreen = false;
}*/
gameEnd = true;//so the mouse stops registering
int myTeam;
for (unsigned int i = 0; i < players.size(); i++){
if (GamerServices::sInstance->GetLocalPlayerId() == players[i]->playerId){
myTeam = players[i]->team;
}
}
std::cout << "END REACHED " << std::endl;
//GameEnd end = GameEnd::GameEnd();
//end.runGameEnd(myTeam, leftBase, rightBase);
gameloop = false;
}
if (Timing::sInstance.GetTimeRemainingS() <= 30 && !gameEndMusic){
gameEndMusic = true;
audioMan->stopByName("bgmBAAGameplay.ogg");
audioMan->playByName("bgmBAAGameEnd.ogg");
}
firstTime = false;
delta_ticks = clock() - current_ticks; //the time, in ms, that took to render the scene
if (delta_ticks > 0)
fps = CLOCKS_PER_SEC / delta_ticks;
//std::cout <<" FPS : " << fps << std::endl;
fpscounter = std::to_string(fps);
//leftBase->health
//renderMan->renderText(fpscounter.c_str(), 255, 255, 0, 70, "BowlbyOneSC-Regular");
fpsHUD->setResourceObject(renderMan->renderText(fpscounter.c_str(), 0, 20, 240, 20, "VT323-Regular"));
inGameStats.Update();
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
audioMan->stopByName("bgmBAAGameEnd.ogg");
std::cout << renderMan << std::endl;
std::cout << renderMan << std::endl;
konamiUnlocked = false;
log->close();
//delete surf;
//delete fount;
//delete runWater;
GameWorld::getInstance()->~GameWorld();
return SCENE_GAMEOVER;
}
void UIInputComponent::Update(){
uint64_t me = NetworkManager::sInstance->GetMyPlayerId();
switch (uiObjectRef->ID){
case PLAY_BUTTON:
if (isButtonPressed(BUTTON_WIDTH, BUTTON_HEIGHT)){
std::cout << "Play!" << std::endl;
NetworkManager::sInstance->SetState(NetworkManager::sInstance->NMS_SinglePlayer);
}
break;
case CANCEL_BUTTON:
break;
case BACK_BUTTON:
break;
case JOIN_BUTTON:
if (isButtonPressed(BUTTON_WIDTH, BUTTON_HEIGHT)){
std::cout << "Join!" << std::endl;
NetworkManager::sInstance->StartLobbySearch();
}
break;
case READY_BUTTON:
if (isButtonPressed(READY_BUTTON_WIDTH, READY_BUTTON_HEIGHT)){
//std::cout << "click" << std::endl;
}
break;
case INVITE_BUTTON:
if (isButtonPressed(BUTTON_WIDTH, BUTTON_HEIGHT)){
//std::cout << "click" << std::endl;
GamerServices::sInstance->InviteFriendsFromOverlay();
}
break;
case CHICKEN:
if (isButtonPressed(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "click" << std::endl;
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("chickensfx.ogg");
uiObjectRef->ready = true;
}
if (isMouseHovering(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "hovering" << std::endl;
uiObjectRef->hoverPicture = true;
}
else{
uiObjectRef->hoverPicture = false;
}
break;
case EAGLE:
case TURKEY:
if (isButtonPressed(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "click" << std::endl;
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("turkeysfx.ogg");
uiObjectRef->ready = true;
}
if (isMouseHovering(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "hovering" << std::endl;
uiObjectRef->hoverPicture = true;
}
else{
uiObjectRef->hoverPicture = false;
}
break;
case QUAIL:
if (isButtonPressed(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "click" << std::endl;
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("quailsfx.ogg");
uiObjectRef->ready = true;
}
if (isMouseHovering(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "hovering" << std::endl;
uiObjectRef->hoverPicture = true;
}
else{
uiObjectRef->hoverPicture = false;
}
break;
case FLAMINGO:
if (isButtonPressed(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "click" << std::endl;
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("flamingosfx.ogg");
uiObjectRef->ready = true;
}
if (isMouseHovering(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "hovering" << std::endl;
uiObjectRef->hoverPicture = true;
}
else{
uiObjectRef->hoverPicture = false;
}
break;
case PEACOCK:
if (isButtonPressed(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "click" << std::endl;
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("peacocksfx.ogg");
uiObjectRef->ready = true;
}
if (isMouseHovering(this->uiObjectRef->getWidth(), this->uiObjectRef->getHeight())){
//std::cout << "hovering" << std::endl;
uiObjectRef->hoverPicture = true;
}
else{
uiObjectRef->hoverPicture = false;
}
break;
}
}
int main()
{
sf::RenderWindow window(sf::VideoMode(800, 600), "Space Invaders");
//STARTING SETTINGS
AudioManager audioManager;
BulletManager bulletManager;
EnemyManager enemyManager;
Randomizer random;
TimeManager time;
Menu mainMenu;
Interface mainInterface;
Player player(400, 500);
Player *playerWsk = &player;
//CONTROL VARIABLES
bool menu = true;
bool init = false;
bool menuMusic = false;
bool stageTwo = false;
mainMenu.loadData();
while (window.isOpen())
{
if(menu == false)
{
if(init == false)
{
audioManager.stopMenu();
menuMusic = false;
player.setHealth(3);
//CREATING ENEMIES and INITILIAZING
enemyManager.addEnemies(); //2 ROWS
random.initialize();
audioManager.playMusic();
init = true;
}
if((stageTwo == false) && (mainInterface.getScore() >= 280))
{
enemyManager.addEnemiesMedium();
stageTwo = true;
}
if((mainInterface.getScore() >= 560))
{
audioManager.stopMusic();
init = false;
menu = true;
}
time.updateShoot();
time.updateRandomShoot();
// REFRESHING WINDOW
// ALL PHYSICS HERE
while(time.getAccumulator() > time.getUps())
{
time.updateAccumulator();
player.keyboardControl(time.getUps(), bulletManager, time.getShootTimer(), time, audioManager);
enemyManager.controlEnemies(random, bulletManager, time);
bulletManager.controlBullets(time.getUps());
//COLLISIONS
bulletManager.checkPlayerCollisions(playerWsk);
enemyManager.updateDead(bulletManager);
player.gameOver(audioManager, menu, init);
}
//SIMPLE EVENTS
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
}
mainInterface.checkRecords(mainMenu);
//DRAWING
window.clear();
mainInterface.drawText(window, player.getHealth());
enemyManager.drawEnemies(window);
window.draw(player.getSprite());
bulletManager.drawBullets(window);
window.display();
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
{
window.close();
}
time.restartAccumulator();
}
else
{
if(menuMusic == false)
{
audioManager.playMenu();
menuMusic = true;
}
enemyManager.clearAll();
bulletManager.clearAll();
time.clearAll();
mainInterface.clearScore();
mainMenu.keyboardControl(window, menu);
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
}
window.clear();
mainMenu.drawMenu(window);
window.display();
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
{
window.close();
}
}
}
return EXIT_SUCCESS;
}
void Box2dTest::BeginContact(b2Contact* contact)
{
void* userData1= contact->GetFixtureA()->GetBody()->GetUserData();
void* userData2= contact->GetFixtureB()->GetBody()->GetUserData();
if(userData1 && userData2)
{
BoxData* data1 = (BoxData*)userData1;
BoxData* data2 = (BoxData*)userData2;
int sound = -1;
//if(data1->m_ValidCode == 777777 || data2->m_ValidCode == 777777)
{
{
if(data1->m_shapeType == FIGUREDEF_BALL &&
data1->m_setContactPointer == false
)
{
data1->m_setContactPointer=true;
if( data2->m_shapeType == FIGUREDEF_BRICK_BOX
|| data2->m_shapeType == FIGUREDEF_BRICK_TRIANGLE
|| data2->m_shapeType == FIGUREDEF_BRICK_TRIANGLE_BIG
|| data2->m_shapeType == FIGUREDEF_BRICK_RECTANGLE
)
{
sound = AudioItem::CHUNK_BLAST;
data2->m_setForRemoval=true;
}
else
{
sound = AudioItem::CHUNK_EXTCOLLIDE;
}
}
if(data2->m_shapeType == FIGUREDEF_BALL &&
data2->m_setContactPointer == false )
{
data2->m_setContactPointer=true;
if( data1->m_shapeType == FIGUREDEF_BRICK_BOX
|| data1->m_shapeType == FIGUREDEF_BRICK_TRIANGLE
|| data1->m_shapeType == FIGUREDEF_BRICK_TRIANGLE_BIG
|| data1->m_shapeType == FIGUREDEF_BRICK_RECTANGLE
)
{
sound = AudioItem::CHUNK_BLAST;
data1->m_setForRemoval=true;
}
else
{
sound = AudioItem::CHUNK_EXTCOLLIDE;
}
}
if(mCollideExternal<=MAX_COLLIDE_SOUNDS && sound>-1)
{
AudioManager* audiomgr = AudioManager::getInstance();
AudioItem audioBlast;
audioBlast.mChunkId = AudioManager::gChunkIndexes[sound];
audioBlast.mFlags = AudioItem::PLAYONCE;
audioBlast.mLoop=0;
audioBlast.mId = audiomgr->playSoundNow(audioBlast);
mCollideExternal++;
}
}
}
}
}
void MinionPhysicsComponent::handleCollision(GameObject* otherObj){
//if hit, destroy minion or move it out of the alive_objects queue
//std::cout << "MINION handling collision with object ID: " << otherObj->ID << std::endl;
switch (otherObj->type){
case GAMEOBJECT_TYPE::OBJECT_FEATHER:{
if (otherObj->team == gameObjectRef->team)break;
if (otherObj->isLocal){
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("miniondeathsfx.ogg");
}
//dynamic_cast<MinionNetworkComponent*>(gameObjectRef->GetComponent(COMPONENT_NETWORK))->SendMinionDeath();
//createParticle(minRend->allObjs["body"], 20, gameObjectRef->posX, gameObjectRef->posY);
//createDustCloudParticle(4, 50, 200, gameObjectRef->posX, gameObjectRef->posY);
MinionLogicComponent* logicComp = dynamic_cast<MinionLogicComponent*>(gameObjectRef->GetComponent(COMPONENT_LOGIC));
logicComp->MinionDeath(otherObj->isLocal);
//GameObjects.dead_feathers.push_back(gameObjectRef);
break;
}
case GAMEOBJECT_TYPE::OBJECT_MINION:{
//just push each other around. Most likely done for us by box2d already
//std::cout << "Value of coliding minion : " << otherObj->team << "\n"<< std::endl;
//std::cout << "Value of our minion : " << gameObjectRef->team << "\n" << std::endl;
if (otherObj->team != gameObjectRef->team){
if (gameObjectRef->team == TEAM_YELLOW)
std::cout << gameObjectRef->ID % 1000 << ", " << otherObj->ID % 1000 << ", " << gameObjectRef->posX << std::endl;
//createParticle(minRend->allObjs["body"], 20, gameObjectRef->posX, gameObjectRef->posY);
//createDustCloudParticle(4, 50, 200, gameObjectRef->posX, gameObjectRef->posY);
MinionLogicComponent* logicComp = dynamic_cast<MinionLogicComponent*>(gameObjectRef->GetComponent(COMPONENT_LOGIC));
logicComp->MinionDeath(false);
}
//gameObjectRef->isAlive = false;//currently setting the poof to dead,
//w/o this obj keeps moving around
break;
}
case GAMEOBJECT_TYPE::OBJECT_BASE:{
if (otherObj->team == gameObjectRef->team) break;
//createParticle(minRend->allObjs["body"], 20, gameObjectRef->posX, gameObjectRef->posY);
//gameObjectRef->setPos(-10000, 0);
//gameObjectRef->isAlive = false;
break;
}
case GAMEOBJECT_TYPE::OBJECT_FAN:{
//mBody->SetLinearVelocity(b2Vec2(mBody->GetLinearVelocity().x, mBody->GetLinearVelocity().y-500));
FanPhysicsComponent* fanPhys = dynamic_cast<FanPhysicsComponent*>(otherObj->GetComponent(COMPONENT_PHYSICS));
blownForce = fanPhys->forceVec;
isGettingBlown = true;
break;
}
case GAMEOBJECT_TYPE::OBJECT_PLATFORM:{
if (mBody->GetPosition().y < 0){
//hit top wall
mBody->SetLinearVelocity(b2Vec2(mBody->GetLinearVelocity().x, -mBody->GetLinearVelocity().y));
}
else {
//hit bot wall
mBody->SetLinearVelocity(b2Vec2(mBody->GetLinearVelocity().x, -mBody->GetLinearVelocity().y));
}
if (!isBounce){
savedYForce = -mBody->GetLinearVelocity().y;
}
isBounce = true;
////Bounce off the walls
//b2Vec2 vel = mBody->GetLinearVelocity();
//vel.y = -1.0f * vel.y;
////Ensure moving in right direction
//if (gameObjectRef->team == TEAM_YELLOW) vel.x = abs(vel.x);
//if (gameObjectRef->team == TEAM_PURPLE) vel.x = -abs(vel.x);
//mBody->SetLinearVelocity(vel);
//mBody->ApplyForce(b2Vec2(0, -50*mBody->GetLinearVelocity().y), mBody->GetWorldCenter(), true);
break;
}
case GAMEOBJECT_TYPE::OBJECT_MINE:{
if (gameObjectRef->team == otherObj->team) break;
if (otherObj->isLocal){
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("miniondeathsfx.ogg");
}
MinionLogicComponent* logicComp = dynamic_cast<MinionLogicComponent*>(gameObjectRef->GetComponent(COMPONENT_LOGIC));
logicComp->MinionDeath(otherObj->isLocal);
break;
}
default:
break;
}
}
void PlayerLogicComponent::playFailSound(){
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->playByName("abilityfailsfx.ogg");
}
void PlayerLogicComponent::stopFootstepSFX(){
AudioManager* audioMan = AudioManager::getAudioInstance();
audioMan->stopByName("bgmfootstepsfx.ogg");
}
void main(void) {
std::string data = "./levels/data.json";
Json::Value root; // 'root' will contain the root value after parsing.
Json::Reader reader;
ifstream fs(data);
if (!fs) cout << "Failed to read from path.";
if (!reader.parse(fs, root)) cout << "Failed to parse.";
// GAME MANAGER
GameManager *gm = new GameManager(W_X, W_Y);
//ADD SYSTEM MANAGERS
CollisionManager* cm = new CollisionManager();
AudioManager* am = new AudioManager();
InputManager* im = new InputManager();
EventManager* em = new EventManager();
GameLogicManager* glm = new GameLogicManager();
//CREATE SUB SYSTEMS
GameEvents* ge = new GameEvents(gm);
Camera* camera = new Camera(0.0f, 0.0f, Vector3(0, 0, 400), W_X, W_Y);
Camera::projMatrix = Matrix4::Orthographic(1, 1000, W_X/4.0f, -W_X/4.0f, W_Y/4.0f, -W_Y/4.0f);
//Camera::viewMatrix = Matrix4::BuildCamera(Vector3(0.0, 50.0, 20.0), Vector3(0.0, 0.0, 0.0));
//camera->BuildViewMatrix();
GameInput* gi = new GameInput(gm, ge, camera);
GameAudio* ga = new GameAudio(am, ge);
CollisionResponse* cr = new CollisionResponse(cm, ge);
GameLogic* gl = new GameLogic(glm, ge);
// JSON STUFF
Json::Value level = root["level"][0];
//TEXTURES
for (int i = 0; i < level["textures"].size(); i++)
{
string name = level["textures"][i]["name"].asString();
GLuint tex = gm->LoadTexture(level["textures"][i]["path"].asCString());
map_textures.insert(pair <string, GLuint>(name, tex));
}
//AUDIO
for (int i = 0; i < level["audio"].size(); i++)
{
string name = level["audio"][i]["name"].asString();
string path = level["audio"][i]["path"].asCString();
float vol = level["audio"][i]["default_volume"].asFloat();
am->loadSound(name, path.c_str(), vol);
}
//SHADERS
for (int i = 0; i < level["shaders"].size(); i++)
{
Shader* s = new Shader(level["shaders"][i]["vert"].asString(), level["shaders"][i]["frag"].asString());
map_shaders.insert(pair <string, Shader*>(level["shaders"][i]["name"].asString(), s));
}
//MESHES
for (int i = 0; i < level["meshes"].size(); i++)
{
string function = level["meshes"][i]["function"].asString();
Mesh * m;
if (function == "GenerateQuad") {
m = Mesh::GenerateQuad(level["meshes"][i]["x"].asFloat(), level["meshes"][i]["y"].asFloat());
}
else if (function == "GenerateTriFan") {
m = Mesh::GenerateTriFan(level["meshes"][i]["radius"].asFloat(), Vector4(level["meshes"][i]["x"].asFloat(), level["meshes"][i]["y"].asFloat(), level["meshes"][i]["z"].asFloat(), level["meshes"][i]["w"].asFloat()));
}
map_meshes.insert(pair<string, Mesh*>(level["meshes"][i]["name"].asString(), m));
}
//ENTITIES
for (int i = 0; i < level["entities"].size(); i++)
{
Entity *e = new Entity(
level["entities"][i]["name"].asString(),
level["entities"][i]["group"].asString(),
level["entities"][i]["subgroup"].asString(),
Vector3(
level["entities"][i]["position"][0].asFloat(),
level["entities"][i]["position"][1].asFloat(),
level["entities"][i]["position"][2].asFloat()
),
Vector3(
level["entities"][i]["acceleration"][0].asFloat(),
level["entities"][i]["acceleration"][1].asFloat(),
level["entities"][i]["acceleration"][2].asFloat()
),
Vector3(
level["entities"][i]["velocity"][0].asFloat(),
level["entities"][i]["velocity"][1].asFloat(),
level["entities"][i]["velocity"][2].asFloat()
),
map_meshes[level["entities"][i]["mesh"].asString()],
map_shaders[level["entities"][i]["shader"].asString()],
map_textures[level["entities"][i]["texture"].asString()]
);
e->setMass(level["entities"][i]["mass"].asFloat());
if (level["entities"][i]["hidden"].asBool() == true) {
e->is_renderable = false;
}
if (level["entities"][i]["collidable"].asBool()) {
if (level["entities"][i]["collision_object"].asString() == "CIRCLE")
cm->addObject(e, level["entities"][i]["collision_radius"].asFloat());
if (level["entities"][i]["collision_object"].asString() == "PLANE")
cm->addObject(e, e->getPhysicsObject()->getPos().Length(),
Vector3(
level["entities"][i]["normal"][0].asFloat(),
level["entities"][i]["normal"][1].asFloat(),
level["entities"][i]["normal"][2].asFloat()
));
}
if (level["entities"][i]["parent"].asString() == "")
map_entities.insert(pair<string, Entity*>(level["entities"][i]["name"].asString(), e));
else
map_entities[level["entities"][i]["parent"].asString()]->addChild(e);
}
// register entities
for (auto iterator = map_entities.begin(); iterator != map_entities.end(); iterator++)
gm->addEntity(iterator->second);
//register managers
gm->addSystemManager(am);
gm->addSystemManager(cm);
gm->addSystemManager(im);
gm->addSystemManager(em);
gm->addSystemManager(glm);
//register sub systems
im->addSubSystem(camera);
glm->addSubSystem(gl);
im->addSubSystem(gi);
am->addSubSystem(ga);
cm->addSubSystem(cr);
em->addSubSystem(ge);
gm->run();
}
