示例#1
0
void Lobby::createClassButts(){
	RenderManager* renderMan = RenderManager::getRenderManager();
	GameObject* button;

	int w, h;
	float midHeight, offset;
	float x, y;

	renderMan->getWindowSize(&w, &h);
	// height for the character class buttons
	midHeight = h * (1 / 2.0f);
	// finding the offset of the slots
	offset = w * (1 / 4.0f);

	// chicken button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);
	button = bFactory.Spawn(buttonID++, x, y, 50, 75.0f, 75.0f, 0.75f);
	dynamic_cast<ButtonLogicComponent*>(button->GetComponent(COMPONENT_LOGIC))->setSound("chickensfx.ogg");
	classButt.push_back(button);
	GameObjects.AddObject(button);
	offset += w * (1 / 9.0f);
	// peacock button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);
	button = bFactory.Spawn(buttonID++, x, y, 51, 75.0f, 75.0f, 0.75f);
	dynamic_cast<ButtonLogicComponent*>(button->GetComponent(COMPONENT_LOGIC))->setSound("peacocksfx.ogg");
	classButt.push_back(button);
	GameObjects.AddObject(button);
	offset += w * (1 / 9.0f);
	// flamingo button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);
	button = bFactory.Spawn(buttonID++, x, y, 52, 75.0f, 75.0f, 0.75f);
	dynamic_cast<ButtonLogicComponent*>(button->GetComponent(COMPONENT_LOGIC))->setSound("flamingosfx.ogg");
	classButt.push_back(button);
	GameObjects.AddObject(button);
	offset += w * (1 / 9.0f);
	// quail button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);
	button = bFactory.Spawn(buttonID++, x, y, 53, 75.0f, 75.0f, 0.75f);
	dynamic_cast<ButtonLogicComponent*>(button->GetComponent(COMPONENT_LOGIC))->setSound("quailsfx.ogg");
	classButt.push_back(button);
	GameObjects.AddObject(button);
	offset += w * (1 / 9.0f);
	// turkey button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);
	button = bFactory.Spawn(buttonID++, x, y, 54, 75.0f, 75.0f, 0.75f);
	dynamic_cast<ButtonLogicComponent*>(button->GetComponent(COMPONENT_LOGIC))->setSound("turkeysfx.ogg");
	classButt.push_back(button);
	GameObjects.AddObject(button);
	offset += w * (1 / 9.0f);
}
示例#2
0
GameObject* GameObjectManager::CreateSpeechBubble(const Ogre::Vector3& position, void* data, const Ogre::String& id){
	//Ogre::SceneNode* node = *static_cast<Ogre::SceneNode**>(data);

	std::ostringstream stream;
	stream << "Speech_Bubble_" << m_speech_bubble_iterations;
	m_speech_bubble_iterations++;
	Ogre::String spbubble_id = stream.str();

	GameObject* tott = *static_cast<GameObject**>(data);
	Ogre::SceneNode* node = static_cast<NodeComponent*>(tott->GetComponent(COMPONENT_NODE))->GetSceneNode();
	TottDef tott_def = static_cast<TottController*>(tott->GetComponent(COMPONENT_CHARACTER_CONTROLLER))->m_def;

	static_cast<TottController*>(tott->GetComponent(COMPONENT_CHARACTER_CONTROLLER))->SetSpeechBubble(spbubble_id);

	GameObject* go = new GameObject(GAME_OBJECT_SPEECH_BUBBLE, spbubble_id);
	NodeComponent* node_comp = new NodeComponent;
	go->AddComponent(node_comp);
	MeshRenderComponent* mrc = new MeshRenderComponent;
	go->AddComponent(mrc);
	SyncedTriggerComponent* trc = new SyncedTriggerComponent;
	go->AddComponent(trc);
	go->AddUpdateable(trc);
	SpeechBubbleComponent* sbcomp = new SpeechBubbleComponent;
	go->AddComponent(sbcomp);
	go->AddUpdateable(sbcomp);



	node_comp->Init(node, m_scene_manager);
	node_comp->SetId(spbubble_id);
	mrc->Init("PratBubblaCherry.mesh", m_scene_manager, node_comp->GetSceneNode()->getName());//, node->getName());
	sbcomp->Init(node, m_scene_manager, tott);
	
	/*
	node_comp->Init(position, m_scene_manager);
	mrc->Init("PratBubbla.mesh", m_scene_manager);//, m_temp_node->getName());//, node->getName());
	sbcomp->Init(m_temp_node, m_scene_manager);
	*/

	TriggerDef trdef;
	trdef.body_type = DYNAMIC_BODY;
	trdef.collider_type = COLLIDER_SPHERE;
	trdef.mass = 0.0f;
	trdef.radius = 2.5f;
	trdef.collision_filter.filter = COL_WORLD_TRIGGER;
	trdef.collision_filter.mask = COL_PLAYER;
	trc->Init(position, m_physics_engine, &trdef);

	return go;
};
示例#3
0
void ComAircraft::Awake()
{
	FactoryGameObject factory;

	// 컨트롤 구성요소
	m_pAircraftControl = (ComAircraftControl*)gameObject->GetComponent("ComAircraftControl");
	
	// LEVEL Text 구성요소
	GameObject* pGoUITextLV = factory.CreateUIText(NULL, "UI1Text", "", 0.f, 0.f, 200.f, 100.f);
	m_pTextInfo = (ComUIText*)pGoUITextLV->GetComponent("ComUIText");

	GameObject* pGO = GameObject::Find("UIPanelDialog");
	if (pGO != NULL)
		m_pPanelUI = (ComUIPanelDialog*)pGO->GetComponent("ComUIPanelDialog");
}
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;
		}
	}
}
示例#5
0
  Game::Game(void(*Exit)())
    :Exit(Exit)
  {
    for(int i = 0; i < 5; ++i)
    {
      GameObject* go = gof::CreateGameObject("assets/myGameObject.go");
      SpriteRenderer* spr = (SpriteRenderer*)go->GetComponent(SPRITE_RENDERER);
      spr->SetSprite(engine::SPR::TEST);
      go->SetName("PIE!");
      go->GetTransform().position = float2(rand() % 100, rand() % 100);
      m_objects.push_back(go);
    }

    COMPONENT_ID list[] = {TEXT_RENDERER, MOVE_COMPONENT};
    const int sizeList = sizeof(list) / sizeof(COMPONENT_ID);
    GameObject* go = gof::CreateGameObject(list, sizeList);
    go->SetName("FPS Counter");
    m_objects.push_back(go);

    COMPONENT_ID list2[] = {TEXT_RENDERER, TEST};
    const int sizeList2 = sizeof(list2) / sizeof(COMPONENT_ID);
    go = gof::CreateGameObject(list2, sizeList2);
    go->GetTransform().position = float2(0.0f, 10.0f);
    go->SetName("FUPS Counter");
    m_objects.push_back(go);
  }
void ComCharacter::Init()
{
	GameObject* pObjMap = GameObject::Find("ObjMap");
	if (pObjMap != NULL)
		m_pMap = (ComObjMap*)pObjMap->GetComponent("ComObjMap");
	if (m_pMap)
	{
		m_pMap->UpdateIndexBufferQuadTree();
		GetHeight();
	}

	m_pFollow = (ComFollowTarget*)gameObject->GetComponent("ComFollowTarget");
	m_pAnimation = (ComRenderSkinnedMesh*)gameObject->GetComponent("ComRenderSkinnedMesh");
	m_pChrEquipment = (ComChrEquipment*)gameObject->GetComponent("ComChrEquipment");

	m_pTimerHPRec = new CTimer(CClock::GetInstance()); m_pTimerHPRec->Start();
	m_pTimerMPRec = new CTimer(CClock::GetInstance()); m_pTimerMPRec->Start();
	m_pTimerDamage = new CTimer(CClock::GetInstance()); m_pTimerDamage->Start();
	m_pTimerCritical = new CTimer(CClock::GetInstance()); m_pTimerCritical->Start();

	m_pComUIDamage = (ComText3D*)gameObject->GetComponent("ComText3D_Damage");
	m_pComUICritical = (ComText3D*)gameObject->GetComponent("ComText3D_Critical");
}
void ChickenClassComponent::destroyShield() {
    GameObject* shield = GameObjects.GetGameObject(*shieldIDs.begin());
    shield->isAlive = false;
    PowerShieldPhysicsComponent* physicsComp = dynamic_cast<PowerShieldPhysicsComponent*>(shield->GetComponent(COMPONENT_PHYSICS));
    physicsComp->setCollisionFilter(COLLISION_POWERSHIELD, 0);
    assert(!shieldIDs.empty());
    shieldIDs.pop_front();
}
示例#8
0
void LobbyMenu::createClassButts(){
	RenderManager* renderMan = RenderManager::getRenderManager();
	GameObject* tutorial;

	int w, h;
	float midHeight, offset;
	float x, y;

	renderMan->getWindowSize(&w, &h);
	// height for the character class buttons
	midHeight = h * (1 / 1.5f);
	// finding the offset of the slots
	offset = w * (1 / 14.0f);

	// chicken button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);

	GameObject* chickButton = bFactory.Spawn(buttonID++, x, y + 10, 9150, 50.0f, 50.0f, 0.30f);
	ButtonLogicComponent* chickLogic = dynamic_cast<ButtonLogicComponent*>(chickButton->GetComponent(COMPONENT_LOGIC));
	ButtonRenderComponent* chickRender = dynamic_cast<ButtonRenderComponent*>(chickButton->GetComponent(COMPONENT_RENDER));
	chickRender->addSecondSprite(27);
	chickLogic->setSound("chickensfx.ogg");
	classButt.push_back(chickButton);
	GameObjects.AddObject(chickButton);
	offset += w * (1 / 12.0f);

		// chicken tutorial
	tutorial = tFactory.Spawn(tutorialID++, 9350, 80, 0);
	tutorials.push_back(tutorial);

	// peacock button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);

	GameObject* peaButton = bFactory.Spawn(buttonID++, x, y, 9151, 50.0f, 50.0f, 0.5);
	ButtonLogicComponent* peaLogic = dynamic_cast<ButtonLogicComponent*>(peaButton->GetComponent(COMPONENT_LOGIC));
	ButtonRenderComponent* peaRender = dynamic_cast<ButtonRenderComponent*>(peaButton->GetComponent(COMPONENT_RENDER));
	peaRender->addSecondSprite(27);
	peaLogic->setSound("peacocksfx.ogg");
	classButt.push_back(peaButton);
	GameObjects.AddObject(peaButton);
	offset += w * (1 / 11.0f);

		// peacock tutorial
	tutorial = tFactory.Spawn(tutorialID++, 9351,80, 0);
	tutorials.push_back(tutorial);

	// flamingo button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);
	GameObject* flamButton = bFactory.Spawn(buttonID++, x, y - 70, 9152, 59.0f, 59.0f, 0.4f);
	ButtonLogicComponent* flamLogic = dynamic_cast<ButtonLogicComponent*>(flamButton->GetComponent(COMPONENT_LOGIC));
	ButtonRenderComponent* flamRender = dynamic_cast<ButtonRenderComponent*>(flamButton->GetComponent(COMPONENT_RENDER));
	flamRender->addSecondSprite(27);
	flamLogic->setSound("flamingosfx.ogg");
	classButt.push_back(flamButton);
	GameObjects.AddObject(flamButton);
	offset += w * (1 / 12.0f);


		// flamingo tutorial
	tutorial = tFactory.Spawn(tutorialID++, 9352, 80, 0);
	tutorials.push_back(tutorial);

	// quail button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);

	GameObject* quaButton = bFactory.Spawn(buttonID++, x, y + 20, 9153, 50.0f, 50.0f, 0.3f);
	ButtonLogicComponent* quaLogic = dynamic_cast<ButtonLogicComponent*>(quaButton->GetComponent(COMPONENT_LOGIC));
	ButtonRenderComponent* quaRender = dynamic_cast<ButtonRenderComponent*>(quaButton->GetComponent(COMPONENT_RENDER));
	quaRender->addSecondSprite(27);
	quaLogic->setSound("quailsfx.ogg");
	classButt.push_back(quaButton);
	GameObjects.AddObject(quaButton);
	offset += w * (1 / 8.0f);

		// quail tutorial
	tutorial = tFactory.Spawn(tutorialID++, 9353, 80, 0);
	tutorials.push_back(tutorial);

	// turkey button
	renderMan->windowCoordToWorldCoord(x, y, (int)offset, (int)midHeight);

	GameObject* turkButton = bFactory.Spawn(buttonID++, x, y, 9154, 50.0f, 50.0f, 0.6f);
	ButtonLogicComponent* turkLogic = dynamic_cast<ButtonLogicComponent*>(turkButton->GetComponent(COMPONENT_LOGIC));
	ButtonRenderComponent* turkRender = dynamic_cast<ButtonRenderComponent*>(turkButton->GetComponent(COMPONENT_RENDER));
	turkRender->addSecondSprite(27);
	turkLogic->setSound("turkeysfx.ogg");
	classButt.push_back(turkButton);
	GameObjects.AddObject(turkButton);
	offset += w * (1 / 11.0f);

		// turkey tutorial
	tutorial = tFactory.Spawn(tutorialID++, 9354, 80, 0);
	tutorials.push_back(tutorial);


	//Now assing all the controller mapping stuff
	chickLogic->setNavButtons(NULL, backButt, NULL, peaButton);
	peaLogic->setNavButtons(flamButton, backButt, chickButton, flamButton);
	flamLogic->setNavButtons(NULL, backButt, peaButton, quaButton);
	quaLogic->setNavButtons(flamButton, backButt, flamButton, turkButton);
	turkLogic->setNavButtons(NULL, backButt, quaButton, readyButt);
	ButtonLogicComponent* readyLogic = dynamic_cast<ButtonLogicComponent*>(readyButt->GetComponent(COMPONENT_LOGIC));
	readyLogic->setNavButtons(turkButton, NULL, backButt, NULL);
	readyLogic->selectButton();
	ButtonLogicComponent* backLogic = dynamic_cast<ButtonLogicComponent*>(backButt->GetComponent(COMPONENT_LOGIC));
	backLogic->setNavButtons(chickButton, NULL, NULL, readyButt);

}
示例#9
0
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;
}