Пример #1
0
void GameAudio::processPunchSound()
{
	if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_PUNCH] == true)
	{
		Game *game = Game::getSingleton();
		GameStateManager *gsm = game->getGSM();
		SpriteManager *spriteMgr = gsm->getSpriteManager();
		PlayerSprite *player = spriteMgr->getPlayer();

		wstring playerState = player->getCurrentState();

		if (playerState.compare(L"PUNCH_LEFT") == 0 || playerState.compare(L"PUNCH_RIGHT") == 0
			|| playerState.compare(L"PUNCH_BACK") == 0 || playerState.compare(L"PUNCH_FRONT") == 0)
		{
			IXAudio2SourceVoice *punchSound = soundEffectMap[ENUM_SOUND_EFFECT_PUNCH];

			XAUDIO2_VOICE_STATE voiceState;
			punchSound->GetState(&voiceState);

			//// [voiceState.BuffersQueued <= 0] means there are nothing in the buffer
			//// so let's make a new buffer to queue the sound
			if (voiceState.BuffersQueued <= 0)
			{
				XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_PUNCH];
				bool ssbSuccess = SUCCEEDED(punchSound->SubmitSourceBuffer(proto));
				punchSound->Start();
			}
			//// if there is something in the buffer
			else
			{
				/// do nothing
			}
		}
	}
}
Пример #2
0
void GameAudio::processHealSound()
{
	if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_HEAL] == true)
	{
		Game *game = Game::getSingleton();
		GameStateManager *gsm = game->getGSM();
		SpriteManager *spriteMgr = gsm->getSpriteManager();
		PlayerSprite *player = spriteMgr->getPlayer();

		bool isHealing = player->getIshealing();

		if (isHealing == true)
		{
			IXAudio2SourceVoice *healSound = soundEffectMap[ENUM_SOUND_EFFECT_HEAL];

			XAUDIO2_VOICE_STATE voiceState;
			healSound->GetState(&voiceState);

			//// [voiceState.BuffersQueued <= 0] means there are nothing in the buffer
			//// so let's make a new buffer to queue the sound
			if (voiceState.BuffersQueued <= 0)
			{
				XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_HEAL];
				bool ssbSuccess = SUCCEEDED(healSound->SubmitSourceBuffer(proto));
				healSound->Start();
				//// After all, there will be only one buffer node in the queue always ...
			}
			//// if there is something in the buffer
			else
			{
				/// do nothing
			}
		}
	}
}
Пример #3
0
void ScienceMouseEventHandler::handleMousePressEvent(Game *game, int mouseX, int mouseY)
{
	if (game->getGSM()->isGameInProgress())
	{
		Viewport *viewport = game->getGUI()->getViewport();
		
		// DETERMINE WHERE ON THE MAP WE HAVE CLICKED
		int worldCoordinateX = mouseX + viewport->getViewportX();
		int worldCoordinateY = mouseY + viewport->getViewportY();

		// NOW LET'S SEE IF THERE IS A SPRITE THERE
		GameStateManager *gsm = game->getGSM();
		SpriteManager *spriteManager = gsm->getSpriteManager();

		
		// IF THERE IS NO SELECTED SPRITE LOOK FOR ONE
		if (!(spriteManager->getIsSpriteSelected()))
		{
			// IF THIS DOES NOT RETURN NULL THEN YOU FOUND A SPRITE AT THAT LOCATION
			if((spriteManager->getSpriteAt(worldCoordinateX, worldCoordinateY) != NULL))
			{
				AnimatedSprite *selected = spriteManager->getSpriteAt(worldCoordinateX, worldCoordinateY);
				spriteManager->setIsSpriteSelected(true);
			}
		}
		else if (spriteManager->getSelectedSprite() != NULL)
		{
			// MOVE A SPRITE IN A DESIRED DIRECTION 
			AnimatedSprite *selected = spriteManager->getSelectedSprite();
			PhysicalProperties *pp = selected->getPhysicalProperties();
			float spriteX = pp->getX();
			float spriteY = pp->getY();

			//IF A SPRITE IS WHERE YOU WANT IT THEN STOP IT
			if (((spriteX > worldCoordinateX - 64) && (spriteX < worldCoordinateX + 64)) && (spriteY > worldCoordinateY - 64) && (spriteY < worldCoordinateY + 64))
			{
				pp->setVelocity(0, 0);
			}
			else
			{
				float deltaX = worldCoordinateX - spriteX;
				float deltaY = worldCoordinateY - spriteY;
				float hyp = sqrtf((deltaX * deltaX) + (deltaY * deltaY));

				pp->setVelocity((deltaX / hyp) * 3, (deltaY / hyp) * 3);
			}
			spriteManager->setIsSpriteSelected(false);

		//	GridPathfinder *pathfinder = spriteManager->getPathfinder();
		//	pathfinder->mapPath(selected, (float)worldCoordinateX, (float)worldCoordinateY);
		//	gsm->setSpriteSelected(false, selected);
		}
		else
		{
			spriteManager->setIsSpriteSelected(false);
		}
	}
}
void BotSpawningPool::update()
{
	countdownCounter--;
	if (countdownCounter <= 0) {
		// SPAWN A BOT
		Game *game = Game::getSingleton();
		GameStateManager *gsm = game->getGSM();
		SpriteManager *spriteManager = gsm->getSpriteManager();
		BotRecycler *botRecycler = spriteManager->getBotRecycler();
		Bot *spawnedBot = botRecycler->retrieveBot(botType);
		spriteManager->addBot(spawnedBot);
		initCountdownCounter();

		// DO IT'S SPAWNING BEHAVIOR
		BotBehavior *spawningBehavior = spawnedBot->getBehavior(BotState::SPAWNING);
		spawningBehavior->behave(spawnedBot);

		// AND START IT LOCATED AT THE SPAWNING POOL
		PhysicalProperties *pp = spawnedBot->getPhysicalProperties();
		pp->setX(x);
		pp->setY(y);
	}
}
void BalloonEscapeCollisionListener::respondToCollision(Game *game, Collision *collision)
{
	// NOTE FROM THE COLLIDABLE OBJECTS, WHICH ARE IN THE COLLISION,
	// WE CAN CHECK AND SEE ON WHICH SIDE THE COLLISION HAPPENED AND
	// CHANGE SOME APPROPRIATE STATE ACCORDINGLY
	GameStateManager *gsm = game->getGSM();
	AnimatedSprite *player = gsm->getSpriteManager()->getPlayer();
	PhysicalProperties *pp = player->getPhysicalProperties();
	//AnimatedSprite *bot = collision
	CollidableObject *sprite2 = collision->getCO2();
	PhysicalProperties *pp2 = sprite2->getPhysicalProperties();
	AnimatedSprite *bot = (AnimatedSprite*)sprite2;
	if (!collision->isCollisionWithTile() && player->getCurrentState() != L"DYING")
	{
		CollidableObject *sprite = collision->getCO1();

		if (sprite2->getPhysicalProperties()->getZ() == 1.0f) {
			
			bot = (AnimatedSprite*)sprite;
				 pp = sprite2->getPhysicalProperties();
					pp2 = sprite->getPhysicalProperties();

			sprite = collision->getCO2();
			sprite2 = collision->getCO1();
			if (sprite->getCollisionEdge() == BOTTOM_EDGE)
			{	
				bot->setCurrentState(L"DYING");
				pp2->setVelocity(0.0f, 0.0f);
				pp2->setAccelerationX(0);
				pp2->setAccelerationY(0);
				// ENEMY IS DEAD - WE SHOULD PLAY A DEATH ANIMATION
				// AND MARK IT FOR REMOVAL
			}
			else if (bot->getCurrentState() != L"DYING")
			{
				if (pp->getDelay() == 0) {
					if (pp->getHP() == 10 ) {
						//lives->setCurrentState(L"TWO");
						if(deadonce == true)
						//lives->setCurrentState(L"ONE");
						player->setCurrentState(L"DYING");
						pp->setDelay(90);
						pp->setVelocity(0.0f, 0.0f);
						pp->setAccelerationX(0);
						pp->setAccelerationY(0);
						deadonce=true;
					}
					else {
						pp->setDelay(90);
						pp->setHP(pp->getHP()-10);
						SpriteManager *spriteManager = gsm->getSpriteManager();
						AnimatedSpriteType *yellowman = spriteManager->getSpriteType(3);
						player->setSpriteType(yellowman);
					}
				}

				// PLAYER IS DEAD - WE SHOULD PLAY A DEATH ANIMATION
				// AND MARK IT FOR REMOVAL/RESPAWN/RESTART GAME, WHATEVER
				// THE DEMANDS OF THE GAME ARE
			}
		}
		else if(sprite->getPhysicalProperties()->getZ() == 1.0f) {
			PhysicalProperties *pp = sprite->getPhysicalProperties();
			if (sprite->getCollisionEdge() == BOTTOM_EDGE)
			{
				
				bot->setCurrentState(L"DYING");
				pp2->setVelocity(0.0f, 0.0f);
				pp2->setAccelerationX(0);
				pp2->setAccelerationY(0);
				// ENEMY IS DEAD - WE SHOULD PLAY A DEATH ANIMATION
				// AND MARK IT FOR REMOVAL

			}
			else if (bot->getCurrentState() != L"DYING")
			{
				if (pp->getDelay() == 0) {
					if (pp->getHP() == 10 ) {


						//lives->setCurrentState(L"TWO");
						if(deadonce == true)
						//lives->setCurrentState(L"ONE");
						player->setCurrentState(L"DYING");
						pp->setDelay(90);
						pp->setVelocity(0.0f, 0.0f);
						pp->setAccelerationX(0);
						pp->setAccelerationY(0);
						deadonce=true;

					}
					else {
						pp->setDelay(90);
						pp->setHP(pp->getHP()-10);
						SpriteManager *spriteManager = gsm->getSpriteManager();
						AnimatedSpriteType *yellowman = spriteManager->getSpriteType(3);
						player->setSpriteType(yellowman);
					}
				}

				// PLAYER IS DEAD - WE SHOULD PLAY A DEATH ANIMATION
				// AND MARK IT FOR REMOVAL/RESPAWN/RESTART GAME, WHATEVER
				// THE DEMANDS OF THE GAME ARE
			}
		}
	}

	if (pp->getDelay() == 0) {
			SpriteManager *spriteManager = gsm->getSpriteManager();
			AnimatedSpriteType *redman = spriteManager->getSpriteType(2);
			player->setSpriteType(redman);
	}
}
Пример #6
0
/*
handleKeyEvent - this method handles all keyboard interactions. Note that every frame this method
gets called and it can respond to key interactions in any custom way. Ask the GameInput class for
key states since the last frame, which can allow us to respond to key presses, including when keys
are held down for multiple frames.
*/
void BugsKeyEventHandler::handleKeyEvents(Game *game)
{
	// WE CAN QUERY INPUT TO SEE WHAT WAS PRESSED
	GameInput *input = game->getInput();

	// LET'S GET THE PLAYER'S PHYSICAL PROPERTIES, IN CASE WE WANT TO CHANGE THEM
	GameStateManager *gsm = game->getGSM();
	AnimatedSprite *player = gsm->getSpriteManager()->getPlayer();
	PhysicalProperties *pp = player->getPhysicalProperties();
	Viewport *viewport = game->getGUI()->getViewport();

	// IF THE GAME IS IN PROGRESS
	if (gsm->isGameInProgress())
	{
		if (input->isKeyDownForFirstTime(D_KEY))
		{
			viewport->toggleDebugView();
			game->getGraphics()->toggleDebugTextShouldBeRendered();
		}
		if (input->isKeyDownForFirstTime(L_KEY))
		{
			game->getGraphics()->togglePathfindingGridShouldBeRendered();
		}
		if (input->isKeyDownForFirstTime(F_KEY))
		{
			game->getGraphics()->togglePathfindingPathShouldBeRendered();
		}
		if (input->isKeyDownForFirstTime(R_KEY))
		{
			if (wcscmp(player->getCurrentState().c_str(), L"RUNNING") == 0)
				player->setCurrentState(L"WALKING");
			else if ((wcscmp(player->getCurrentState().c_str(), L"IDLE") != 0) && (wcscmp(player->getCurrentState().c_str(), L"DANCING") != 0))
				player->setCurrentState(L"RUNNING");
		}
		if (input->isKeyDownForFirstTime(Y_KEY)){
			player->setCurrentState(DYING);
		}
		if (input->isKeyDownForFirstTime(I_KEY)){
			player->setCurrentState(IDLE);
		}
		bool viewportMoved = false;
		float viewportVx = 0.0f;
		float viewportVy = 0.0f;
		float vX = pp->getVelocityX();
		float vY = pp->getVelocityY();
		if (input->isKeyDown(UP_KEY))
		{
			if (pp->getY() < (viewport->getViewportY() + 0.5f * viewport->getViewportHeight()))
				viewportVy -= MAX_PLAYER_VELOCITY;
			vY = -1 * MAX_PLAYER_VELOCITY;
			vX = 0;
			viewportMoved = true;
		}
		else if (input->isKeyDown(DOWN_KEY))
		{
			if (pp->getY() > (viewport->getViewportY() + 0.5f * viewport->getViewportHeight()))
				viewportVy += MAX_PLAYER_VELOCITY;
			vY = MAX_PLAYER_VELOCITY;
			vX = 0;
			viewportMoved = true;
		}
		else if (input->isKeyDown(LEFT_KEY))
		{
			if (pp->getX() < (viewport->getViewportX() + 0.5f * viewport->getViewportWidth()))
				viewportVx -= MAX_PLAYER_VELOCITY;
			vX = -1 * MAX_PLAYER_VELOCITY;
			vY = 0;
			viewportMoved = true;
		}
		else if (input->isKeyDown(RIGHT_KEY))
		{
			if (pp->getX() > (viewport->getViewportX() + 0.5f * viewport->getViewportWidth()))
			viewportVx += MAX_PLAYER_VELOCITY;
			vX = MAX_PLAYER_VELOCITY;
			vY = 0;
			viewportMoved = true;
		}
		else {
			vX = 0.0f;
			vY = 0.0f;
		}
		if (viewportMoved)
			viewport->moveViewport((int)floor(viewportVx+0.5f), (int)floor(viewportVy+0.5f), game->getGSM()->getWorld()->getWorldWidth(), game->getGSM()->getWorld()->getWorldHeight());
		pp->setVelocity(vX, vY);
	}

	// 0X43 is HEX FOR THE 'C' VIRTUAL KEY
	// THIS CHANGES THE CURSOR IMAGE
	if ((input->isKeyDownForFirstTime(C_KEY))
		&& input->isKeyDown(VK_SHIFT))
	{
		Cursor *cursor = game->getGUI()->getCursor();
		unsigned int id = cursor->getActiveCursorID();
		id++;
		if (id == cursor->getNumCursorIDs())
			id = 0;		
		cursor->setActiveCursorID(id);
	}

	// LET'S MESS WITH THE TARGET FRAME RATE IF THE USER PRESSES THE HOME OR END KEYS
	WindowsTimer *timer = (WindowsTimer*)game->getTimer();
	int fps = timer->getTargetFPS();

	// THIS SPEEDS UP OUR GAME LOOP AND THUS THE GAME, NOTE THAT WE COULD ALTERNATIVELY SCALE
	// DOWN THE GAME LOGIC (LIKE ALL VELOCITIES) AS WE SPEED UP THE GAME. THAT COULD PROVIDE
	// A BETTER PLAYER EXPERIENCE
	if (input->isKeyDown(VK_HOME) && (fps < MAX_FPS))
		timer->setTargetFPS(fps + FPS_INC);

	// THIS SLOWS DOWN OUR GAME LOOP, BUT WILL NOT GO BELOW 5 FRAMES PER SECOND
	else if (input->isKeyDown(VK_END) && (fps > MIN_FPS))
		timer->setTargetFPS(fps - FPS_INC);
}
void GroceryDashKeyEventHandler::handleKeyEvents(Game *game){


	// WE CAN QUERY INPUT TO SEE WHAT WAS PRESSED
	GameInput *input = game->getInput();

	// LET'S GET THE PLAYER'S PHYSICAL PROPERTIES, IN CASE WE WANT TO CHANGE THEM
	GameStateManager *gsm = game->getGSM();
	TopDownSprite *player = gsm->getSpriteManager()->getPlayer();
	b2Body *playerBody = game->getGSM()->getSpriteManager()->playerBody;
	PhysicalProperties *pp = player->getPhysicalProperties();
	Viewport *viewport = game->getGUI()->getViewport();
	GroceryDashDataLoader* dataLoader = dynamic_cast<GroceryDashDataLoader*>(game->getDataLoader());

	if (!gsm->isGameInProgress()){

		if (input->isKeyDownForFirstTime(ESC_KEY)){
			if (gsm->isAtInGameHelp() == true){
				gsm->goToPauseMenu();
			}
			else{
				if (gsm->isAtSettingsScreen() == true || gsm->isAtAboutScreen() == true || gsm->isAtAchievementsScreen() == true
					|| gsm->isAtHelpScreen() == true || gsm->isAtLevelSelect() == true || gsm->isAtStatsScreen() == true){
					gsm->goToMainMenu();
				}
			}
		}

	}//BRACKET -- !isGameInProgress

	if (gsm->isAtPauseMenu()){

		if (input->isKeyDownForFirstTime(R_KEY))
		{
			gsm->goToGame();
		}
	}



	if (gsm->isGameInProgress())
	{

		if (input->isKeyDownForFirstTime(P_KEY))
		{
			gsm->goToPauseMenu();
		}

		if (input->isKeyDownForFirstTime(L_KEY))
		{
			if ( gsm->isAtItemList() == false){
				gsm->goToItemList();
			}
			else{
				gsm->goToGame();
			}
		}

		if (input->isKeyDownForFirstTime(C_KEY))
		{
			if (gsm->isAtCartScreen() == false){
				gsm->goToCartScreen();
			}
			else{
				gsm->goToGame();
			}
		}

		if (input->isKeyDownForFirstTime(M_KEY)){
			runScript(game);
		}



		// ARROW KEYS PRESSES WILL CONTROL THE PLAYER

		// THE USER MOVES VIA MOUSE BUTTON PRESSES
		if (input->isKeyDown(MOVE_LEFT_CONTROL) && gsm->isPlayerControlDisabled() == false && dataLoader->getIsPayingCashier() == false)
		{
			player->clearPath();
			b2Vec2 moveLeft(-PLAYER_SPEED, 0.0f);
			playerBody->ApplyForceToCenter(moveLeft, true);
			playerBody->SetTransform(playerBody->GetPosition(), (1.0f * PI));
		}
		else if (input->isKeyDown(MOVE_RIGHT_CONTROL) && gsm->isPlayerControlDisabled() == false && dataLoader->getIsPayingCashier() == false)
		{
			player->clearPath();
			b2Vec2 moveRight(PLAYER_SPEED, 0.0f);
			playerBody->ApplyForceToCenter(moveRight, true);
			playerBody->SetTransform(playerBody->GetPosition(), (0.0f * PI));
		}
		else if (input->isKeyDown(MOVE_UP_CONTROL) && gsm->isPlayerControlDisabled() == false && dataLoader->getIsPayingCashier() == false)
		{
			player->clearPath();
			b2Vec2 moveUp(0.0f, -PLAYER_SPEED);
			playerBody->ApplyForceToCenter(moveUp, true);
			playerBody->SetTransform(playerBody->GetPosition(), (1.5f * PI));
			
		}
		else if (input->isKeyDown(MOVE_DOWN_CONTROL) && gsm->isPlayerControlDisabled() == false && dataLoader->getIsPayingCashier() == false)
		{
			player->clearPath();
			b2Vec2 moveDown(0.0f, PLAYER_SPEED);
			playerBody->ApplyForceToCenter(moveDown, true);
			playerBody->SetTransform(playerBody->GetPosition(), (0.5f * PI));
		}
		else if (input->isKeyDownForFirstTime(G_KEY))
		{
			viewport->toggleDebugView();
			game->getGraphics()->toggleDebugTextShouldBeRendered();
		}
		else if (input->isKeyDownForFirstTime(H_KEY))
		{
			game->getGraphics()->toggleB2DrawDebugShouldBeRendered();
		}
		else
		{
			b2Vec2 stay(0.0f, 0.0f);
			playerBody->ApplyForceToCenter(stay, false);
		}



		if (input->isKeyDownForFirstTime(ESC_KEY) && (gsm->isPlayerAtShelf() == true || gsm->isAtItemList() == true)){
			gsm->goToGame();
		}

		if (gsm->isPlayerAtShelf() == true){

			// LEAVE THE SHELF SCREEN without TAKING ANY ITEMS
			if (input->isKeyDownForFirstTime(ESC_KEY)){
				gsm->goToGame();
			}

			int isItemTaken = false;

			if (input->isKeyDownForFirstTime(NUM_1) ^ input->isKeyDownForFirstTime(NUMPAD_1)){
				isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 1);
				runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 1, isItemTaken);
				gsm->goToGame();
			}
			else{
				if (input->isKeyDownForFirstTime(NUM_2) ^ input->isKeyDownForFirstTime(NUMPAD_2)){
					isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 2);
					runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 2, isItemTaken);
					gsm->goToGame();
				}
				else{
					if (input->isKeyDownForFirstTime(NUM_3) ^ input->isKeyDownForFirstTime(NUMPAD_3)){
						isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 3);
						runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 3, isItemTaken);
						gsm->goToGame();
					}
					else{
						if (input->isKeyDownForFirstTime(NUM_4) ^ input->isKeyDownForFirstTime(NUMPAD_4)){
							isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 4);
							runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 4, isItemTaken);
							gsm->goToGame();
						}
						else{
							if (input->isKeyDownForFirstTime(NUM_5) ^ input->isKeyDownForFirstTime(NUMPAD_5)){
								isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 5);
								runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 5, isItemTaken);
								gsm->goToGame();
							}
							else{
								if (input->isKeyDownForFirstTime(NUM_6) ^ input->isKeyDownForFirstTime(NUMPAD_6)){
									isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 6);
									runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 6, isItemTaken);
									gsm->goToGame();
								}
								else{
									if (input->isKeyDownForFirstTime(NUM_7) ^ input->isKeyDownForFirstTime(NUMPAD_7)){
										isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 7);
										runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 7, isItemTaken);
										gsm->goToGame();
									}
									else{
										if (input->isKeyDownForFirstTime(NUM_8) ^ input->isKeyDownForFirstTime(NUMPAD_8)){
											isItemTaken = dataLoader->takeItemFromShelf(game, gsm->getGameStateShelfAsNumber(), 8);
											runScript_LookUpShelfItemInfo(game, gsm->getGameStateShelfAsNumber(), 8, isItemTaken);
											gsm->goToGame();
										}
										else{
											//DO NOTHING
			}	}	}	}	}	}	}	}
		}


		bool viewportMoved = false;
		float viewportVx = 0.0f;
		float viewportVy = 0.0f;
		if (input->isKeyDown(VIEWPORT_UP_CONTROL) && gsm->isPlayerControlDisabled() == false)
		{
			viewportVy -= MAX_VIEWPORT_AXIS_VELOCITY;
			viewportMoved = true;
		}
		if (input->isKeyDown(VIEWPORT_DOWN_CONTROL) && gsm->isPlayerControlDisabled() == false)
		{
			viewportVy += MAX_VIEWPORT_AXIS_VELOCITY;
			viewportMoved = true;
		}
		if (input->isKeyDown(VIEWPORT_LEFT_CONTROL) && gsm->isPlayerControlDisabled() == false)
		{
			viewportVx -= MAX_VIEWPORT_AXIS_VELOCITY;
			viewportMoved = true;
		}
		if (input->isKeyDown(VIEWPORT_RIGHT_CONTROL) && gsm->isPlayerControlDisabled() == false)
		{
			viewportVx += MAX_VIEWPORT_AXIS_VELOCITY;
			viewportMoved = true;
		}
		if (!viewportMoved){
			b2Vec2 playerPos = playerBody->GetPosition();
			float playerX = playerPos.x * SCALING_FACTOR;
			float playerY = playerPos.y * SCALING_FACTOR;
			int SCREEN_WIDTH = 1024;
			int SCREEN_HEIGHT = 768;
			if (viewport->getViewportX() + (viewport->getViewportWidth() * 15 / 32) < playerX){
				viewportVx += MAX_VIEWPORT_AXIS_VELOCITY *
					abs(viewport->getViewportX() + (viewport->getViewportWidth() / 2) - playerX) / (SCREEN_WIDTH / 2);
				viewportMoved = true;
			}
			if (viewport->getViewportX() + (viewport->getViewportWidth() * 17 / 32) > playerX){
				viewportVx -= MAX_VIEWPORT_AXIS_VELOCITY *
					abs(viewport->getViewportX() + (viewport->getViewportWidth() / 2) - playerX) / (SCREEN_WIDTH / 2);
				viewportMoved = true;
			}
			if (viewport->getViewportY() + (viewport->getViewportHeight() * 15 / 32) < playerY){
				viewportVy += MAX_VIEWPORT_AXIS_VELOCITY *
					abs(viewport->getViewportY() + (viewport->getViewportHeight() / 2) - playerY) / (SCREEN_HEIGHT / 2);
				viewportMoved = true;
			}
			if (viewport->getViewportY() + (viewport->getViewportHeight() * 17 / 32) > playerY){
				viewportVy -= MAX_VIEWPORT_AXIS_VELOCITY *
					abs(viewport->getViewportY() + (viewport->getViewportHeight() / 2) - playerY) / (SCREEN_HEIGHT / 2);
				viewportMoved = true;
			}
		}
		//Viewport *viewport = game->getGUI()->getViewport();
		if (viewportMoved){
			viewport->moveViewport((int)floor(viewportVx + 0.5f), (int)floor(viewportVy + 0.5f), game->getGSM()->getWorld()->getWorldWidth(), game->getGSM()->getWorld()->getWorldHeight());
		}
		
		/***********	CHEAT CODES LISTED BELOW *******
		
		
		************************************************/

		// INCREASE TIME REMAINING
		if (input->isKeyDownForFirstTime(I_KEY)){
			runScript_TimeCheat(game, true);
		}//isIncreasingTime


		// DECREASE TIME REMAINING
		if (input->isKeyDownForFirstTime(O_KEY)){
			runScript_TimeCheat(game, false);
		}

		// INCREASE SPENDING LIMIT
		if (input->isKeyDownForFirstTime(Y_KEY)){
			if ((dataLoader->spendingLimit + MONEY_CHEAT_INCREASE) > (dataLoader->levelItemsCost * 2) + MONEY_CHEAT_INCREASE){
				dataLoader->spendingLimit = (dataLoader->levelItemsCost * 2) + MONEY_CHEAT_INCREASE;
			}
			else{
				dataLoader->spendingLimit += MONEY_CHEAT_INCREASE;
			}
			
		}//isIncreasingSpendingLimit


		// DECREASE SPENDING LIMIT
		if (input->isKeyDownForFirstTime(U_KEY)){
			if ((dataLoader->spendingLimit - MONEY_CHEAT_DECREASE) < dataLoader->levelItemsCost){
				dataLoader->spendingLimit = dataLoader->levelItemsCost;
			}
			else{
				dataLoader->spendingLimit -= MONEY_CHEAT_DECREASE;
			}
		}//isDecreasingSpendingLimit

	}// BRACKET -- if (gsm->isGameInProgress())
}
Пример #8
0
/*
	handleKeyEvent - this method handles all keyboard interactions. Note that every frame this method
	gets called and it can respond to key interactions in any custom way. Ask the GameInput class for
	key states since the last frame, which can allow us to respond to key presses, including when keys
	are held down for multiple frames.
*/
void SoSKeyEventHandler::handleKeyEvents(Game *game)
{
	// WE CAN QUERY INPUT TO SEE WHAT WAS PRESSED
	GameInput *input = game->getInput();

	// LET'S GET THE PLAYER'S PHYSICAL PROPERTIES, IN CASE WE WANT TO CHANGE THEM
	GameStateManager *gsm = game->getGSM();
	AnimatedSprite *player = gsm->getSpriteManager()->getPlayer();
	PhysicalProperties *pp = player->getPhysicalProperties();
	
	if(gsm->isAtSplashScreen())
	{
		if(input->isKeyDown(ENTER_KEY))
		{
			gsm->goToMainMenu();
		}
	}

	

	// IF THE GAME IS IN PROGRESS
	if (gsm->isGameInProgress())
	{
		// CHECK FOR WASD KEYS FOR MOVEMENT
		int incX = 0;
		int incY = 0;
		bool movingLR = false;
		bool attacking = false;

		if(!pp->isStunned())
		{
			if(input->isKeyDown(SPACE_KEY))
			{
				attacking = true;
				if(input->isKeyDownForFirstTime(SPACE_KEY))
				{
			
					player->setCurrentState(L"ATTACK_STATE");
					if(!pp->isOrientedRight())
						player->setCurrentState(L"ATTACKL_STATE");
				}
			
			}

			// WASD AND DIRECTION KEY PRESSES WILL CONTROL THE PLAYER,
			// SO WE'LL UPDATE THE PLAYER VELOCITY WHEN THESE KEYS ARE
			// PRESSED, THAT WAY PHYSICS CAN CORRECT AS NEEDED
			float vX = pp->getVelocityX();
			float vY = pp->getVelocityY();

		
			if (input->isKeyDown(A_KEY) || input->isKeyDown(LEFT_KEY))
			{
				movingLR = true;
				pp->setOrientedLeft();
				vX = -PLAYER_SPEED;
				if (vY == 0 && player->getCurrentState().compare(L"LEFT_STATE") != 0)
					player->setCurrentState(L"LEFT_STATE");
				else if(vY != 0 && player->getCurrentState().compare(L"JUMPL_STATE") != 0)
					player->setCurrentState(L"JUMPL_STATE");
			}
			if (input->isKeyDown(D_KEY) || input->isKeyDown(RIGHT_KEY))
			{
				movingLR = true;
				pp->setOrientedRight();
				vX = PLAYER_SPEED;
				if (vY == 0 && player->getCurrentState().compare(L"RIGHT_STATE") != 0)
					player->setCurrentState(L"RIGHT_STATE");
				else if(vY != 0 && player->getCurrentState().compare(L"JUMP_STATE") != 0)
					player->setCurrentState(L"JUMP_STATE");
			}
			/*if (input->isKeyDown(S_KEY) || input->isKeyDown(DOWN_KEY))
			{
				vY = PLAYER_SPEED;
			}*/
			if (input->isKeyDown(W_KEY) || input->isKeyDown(UP_KEY))
			{
			

				if ((input->isKeyDownForFirstTime(W_KEY) || input->isKeyDownForFirstTime(UP_KEY))
					&& pp->hasDoubleJumped() == false)
				{
					if(pp->hasJumped() == true)
						pp->setDoubleJumped(true);
					pp->setJumped(true);

					vY = -PLAYER_SPEED;
					player->setCurrentState(L"JUMP_STATE");
					if(vX < 0)
						player->setCurrentState(L"JUMPL_STATE");
				}
			}	

			if(!movingLR)
			{
				vX = 0;
			}

			if(vY == 0 && vX == 0 && !attacking && 
				player->getCurrentState().compare(L"IDLE_STATE") != 0 && player->getCurrentState().compare(L"IDLEL_STATE") != 0 )
			{
				player->setCurrentState(L"IDLE_STATE");
				if(!pp->isOrientedRight())
					player->setCurrentState(L"IDLEL_STATE");
			}
		
			// NOW SET THE ACTUAL VELOCITY
			Physics *physics = gsm->getPhysics();
			pp->setVelocitySafely(physics, vX, vY);

		}
		// NOTE THAT THE VIEWPORT SHOULD FOLLOW THE PLAYER, AND SO SHOULD BE CORRECTED AFTER PHYSICS
		// ARE APPLIED. I HAVE PROVIDED A SIMPLE WAY OF DOING SO, WHICH SHOULD BE IMPROVED, DEPENDING
		// ON THE GAME'S NEED



		if(input->isKeyDownForFirstTime(TAB_KEY))
		{
			gsm->goToPaused();
		}

	}

	else if(gsm->isGamePaused() && input->isKeyDownForFirstTime(TAB_KEY))
	{
		gsm->goToGame();
	}

	// 0X43 is HEX FOR THE 'C' VIRTUAL KEY
	// THIS CHANGES THE CURSOR IMAGE
	if ((input->isKeyDownForFirstTime(C_KEY))
		&& input->isKeyDown(VK_SHIFT))
	{
		Cursor *cursor = game->getGUI()->getCursor();
		unsigned int id = cursor->getActiveCursorID();
		id++;
		if (id == cursor->getNumCursorIDs())
			id = 0;		
		cursor->setActiveCursorID(id);
	}

	// LET'S MESS WITH THE TARGET FRAME RATE IF THE USER PRESSES THE HOME OR END KEYS
	WindowsTimer *timer = (WindowsTimer*)game->getTimer();
	int fps = timer->getTargetFPS();

	// THIS SPEEDS UP OUR GAME LOOP AND THUS THE GAME, NOTE THAT WE COULD ALTERNATIVELY SCALE
	// DOWN THE GAME LOGIC (LIKE ALL VELOCITIES) AS WE SPEED UP THE GAME. THAT COULD PROVIDE
	// A BETTER PLAYER EXPERIENCE
	if (input->isKeyDown(VK_HOME) && (fps < MAX_FPS))
		timer->setTargetFPS(fps + FPS_INC);

	// THIS SLOWS DOWN OUR GAME LOOP, BUT WILL NOT GO BELOW 5 FRAMES PER SECOND
	else if (input->isKeyDown(VK_END) && (fps > MIN_FPS))
		timer->setTargetFPS(fps - FPS_INC);
}
Пример #9
0
void GameAudio::processShootSound()
{
	if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_SHOOT] == true)
	{
		Game *game = Game::getSingleton();
		GameStateManager *gsm = game->getGSM();
		SpriteManager *spriteMgr = gsm->getSpriteManager();
		/*if (moneySoundSignal == true)
		{
			IXAudio2SourceVoice *moneySound = soundEffectMap[ENUM_SOUND_EFFECT_MONEY];

			XAUDIO2_VOICE_STATE voiceState;
			moneySound->GetState(&voiceState);

			XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_MONEY];
			bool ssbSuccess = SUCCEEDED(moneySound->SubmitSourceBuffer(proto));
			moneySound->Start();

			moneySoundSignal = false;
		}
		*/
		if (shootSoundSignal == true)
		{
			IXAudio2SourceVoice *shootSound = soundEffectMap[ENUM_SOUND_EFFECT_SHOOT];

			XAUDIO2_VOICE_STATE voiceState;
			shootSound->GetState(&voiceState);

			XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_SHOOT];
			bool ssbSuccess = SUCCEEDED(shootSound->SubmitSourceBuffer(proto));
			shootSound->Start();

			shootSoundSignal = false;
		}

		/*
		list<Bot*>::iterator botIt = spriteMgr->getBotsIterator();
		list<Bot*>::iterator endBotIt = spriteMgr->getEndOfBotsIterator();
		while (botIt != endBotIt)
		{
		Bot *bot = (*botIt);
		wstring botCurState = bot->getCurrentState();
		if (botCurState.compare(L"SHOOT_LEFT") == 0 || botCurState.compare(L"SHOOT_RIGHT") == 0
		|| botCurState.compare(L"SHOOT_BACK") == 0 || botCurState.compare(L"SHOOT_FRONT") == 0)
		{
		IXAudio2SourceVoice *shootSound = soundEffectMap[ENUM_SOUND_EFFECT_SHOOT];

		XAUDIO2_VOICE_STATE voiceState;
		shootSound->GetState(&voiceState);

		if (voiceState.BuffersQueued <= 0)
		{
		XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_SHOOT];
		bool ssbSuccess = SUCCEEDED(shootSound->SubmitSourceBuffer(proto));
		shootSound->Start();
		}
		}
		botIt++;
		}

		PlayerSprite *player = spriteMgr->getPlayer();
		wstring playerState = player->getCurrentState();
		if (playerState.compare(L"SHOOT_LEFT") == 0 || playerState.compare(L"SHOOT_RIGHT") == 0
		|| playerState.compare(L"SHOOT_BACK") == 0 || playerState.compare(L"SHOOT_FRONT") == 0)
		{
		IXAudio2SourceVoice *shootSound = soundEffectMap[ENUM_SOUND_EFFECT_SHOOT];

		XAUDIO2_VOICE_STATE voiceState;
		shootSound->GetState(&voiceState);

		//// [voiceState.BuffersQueued <= 0] means there are nothing in the buffer
		//// so let's make a new buffer to queue the sound
		if (voiceState.BuffersQueued <= 0)
		{
		XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_SHOOT];
		bool ssbSuccess = SUCCEEDED(shootSound->SubmitSourceBuffer(proto));
		shootSound->Start();
		}
		//// if there is something in the buffer
		else
		{
		/// do nothing
		}
		}
		*/
		
	}
}
Пример #10
0
void Physics::update(Game *game)
{
	// REMEMBER, AT THIS POINT, ALL PLAYER INPUT AND AI
	// HAVE ALREADY BEEN PROCESSED AND BOT AND PLAYER
	// STATES, VELOCITIES, AND ACCELERATIONS HAVE ALREADY
	// BEEN UPDATED. NOW WE HAVE TO PROCESS THE PHYSICS
	// OF ALL THESE OBJECTS INTERACTING WITH EACH OTHER
	// AND THE STATIC GAME WORLD. THIS MEANS WE NEED TO
	// DETECT AND RESOLVE COLLISIONS IN THE ORDER THAT
	// THEY WILL HAPPEN, AND WITH EACH COLLISION, EXECUTE
	// ANY GAMEPLAY RESPONSE CODE, UPDATE VELOCITIES, AND
	// IN THE END, UPDATE POSITIONS

	// FIRST, YOU SHOULD START BY ADDING ACCELERATION TO ALL 
	// VELOCITIES, WHICH INCLUDES GRAVITY, NOTE THE EXAMPLE
	// BELOW DOES NOT DO THAT


	// FOR NOW, WE'LL JUST ADD THE VELOCITIES TO THE
	// POSITIONS, WHICH MEANS WE'RE NOT APPLYING GRAVITY OR
	// ACCELERATION AND WE ARE NOT DOING ANY COLLISION 
	// DETECTION OR RESPONSE
	float timer = 0;

	GameStateManager *gsm = game->getGSM();
	SpriteManager *sm = gsm->getSpriteManager();
	World *w = gsm->getWorld();
	GameRules* gR = game->getGameRules();
	vector<WorldLayer*> *layers = w->getLayers();

	AnimatedSprite *player;
	PhysicalProperties *pp;
	TiledLayer *tL;
	list<Collision*> collisions;
	
	//finding TileLayer
	for(unsigned int i = 0; i < layers->size(); i++)
	{
		WorldLayer *currentLayer = (*layers)[i];
		if(currentLayer->hasCollidableTiles() == true)
		{
			tL = dynamic_cast<TiledLayer*>(currentLayer);
			if(tL != 0)
			{
				i = layers->size();
			}//end if
		}//end if
	}


	player = sm->getPlayer();
	pp = player->getPhysicalProperties();

	//UPDATING ALL VELOCITIES AND DOING TILE COLLISION
	pp->incVelocity(this,pp->getAccelerationX(), pp->getAccelerationY() + gravity); 
	collideTestWithTiles(player, tL, &collisions);

	list<Bot*>::iterator botIterator = sm->getBotsIterator();
	while (botIterator != sm->getEndOfBotsIterator())
	{			
		Bot *bot = (*botIterator);
		pp = bot->getPhysicalProperties();
		pp->incVelocity(this, pp->getAccelerationX(), pp->getAccelerationY());
		if(pp->isGravAffected() == true)
			pp->incVelocity(this, 0, gravity);
		collideTestWithTiles(bot, tL, &collisions);
		botIterator++;
	}

	//HERE, COLLIDE SPRITES WITH OTHER SPRITES
	collideTestWithSprites(game, player, &collisions);
	botIterator = sm->getBotsIterator();
	while (botIterator != sm->getEndOfBotsIterator())
	{			
		Bot *bot = (*botIterator);
		if(bot->isCurrentlyCollidable() == true);
			collideTestWithSprites(game, bot, &collisions);
		botIterator++;
	}

	//SORT COLLISIONS
	collisions.sort(compare_collisionTime);

	//RESOLVING ALL THE COLLISIONS
	while(collisions.empty() == false)
	{
		Collision* currentCollision = collisions.front();
		collisions.pop_front();
		float colTime = currentCollision->getTOC();
		CollidableObject* co1 = currentCollision->getCO1();
		CollidableObject* co2 = currentCollision->getCO2();

		if(colTime >= 0 && colTime <= 1)
		{
			
			pp = co1->getPhysicalProperties();
			//pp->setVelocity(pp->getVelocityX()*9.99f,pp->getVelocityY()*9.99f);
			pp = co2->getPhysicalProperties();
			//pp->setVelocity(pp->getVelocityX()*9.99f,pp->getVelocityY()*9.99f);

			pp = player->getPhysicalProperties();
			pp->setPosition(pp->getX() + (pp->getVelocityX()*(colTime-timer)),pp->getY() + (pp->getVelocityY()*(colTime-timer)));
			botIterator = sm->getBotsIterator();
			while (botIterator != sm->getEndOfBotsIterator())
			{			
				Bot *bot = (*botIterator);
				pp = bot->getPhysicalProperties();
				pp->setPosition(pp->getX() + (pp->getVelocityX()*(colTime-timer)), pp->getY() + (pp->getVelocityY()*(colTime-timer)));
				botIterator++;
			}

			gsm->updateViewport(game, colTime-timer);

			resolveCollision(game, currentCollision);
			gR->gameSpecificResolve(game, currentCollision);
			
			boolean deleteLast = false;
			list<Collision*>::iterator cIterator = collisions.begin();
			list<Collision*>::iterator lastIterator;
			while(cIterator != collisions.end())
			{
				if(deleteLast == true)
				{
					collisions.erase(lastIterator);
				}
				deleteLast = false;
				Collision* check = (*cIterator);
				if(check->contains(co1) || check->contains(co2))
				{
					CollidableObject* checkStatic = check->getCO2();
					if(checkStatic->isStaticObject())
					{
						coStackCounter ++;
						coStack[coStackCounter] = checkStatic;
					}

					collisionStackCounter ++;
					collisionStack[collisionStackCounter] = check;

					lastIterator = cIterator;
					deleteLast = true;
				}
				else
				{
					//check->calculateTimes();
				}

				cIterator++;
			}

			if(deleteLast == true)
			{
				collisions.erase(lastIterator);
			}

			collideTestWithTiles(co1, tL, &collisions);
			collideTestWithSprites(game, co1, &collisions);

			if(co2->isStaticObject() == false)
			{
				collideTestWithTiles(co2, tL, &collisions);
				collideTestWithSprites(game, co2, &collisions);
			}

			collisions.sort(compare_collisionTime);

			timer += (colTime-timer);
		}//end if


		if(co2->isStaticObject() == true)
		{
			coStackCounter ++;
			coStack[coStackCounter] = co2;
		}

		collisionStackCounter ++;
		collisionStack[collisionStackCounter] = currentCollision;
	
	}
	
	if(timer < 1)
	{
		gsm->updateViewport(game, 1-timer);
		pp = player->getPhysicalProperties();
		pp->setPosition(pp->getX() + (pp->getVelocityX()*(1-timer)),pp->getY() + (pp->getVelocityY()*(1-timer)));
		//pp->setVelocity(0.0f, pp->getVelocityY());
		botIterator = sm->getBotsIterator();
		while (botIterator != sm->getEndOfBotsIterator())
		{			
			Bot *bot = (*botIterator);
			pp = bot->getPhysicalProperties();
			pp->setPosition(pp->getX() + (pp->getVelocityX()*(1-timer)), pp->getY() + (pp->getVelocityY()*(1-timer)));
			botIterator++;
		}
		gsm->updateViewport(game, 1-timer);
	}
	
	pp = player->getPhysicalProperties();
	if(pp->getX() < 0)
	{
		pp->setX(0);
	}
	if(pp->getY() < 0)
	{
		pp->setY(0);
	}
	//pp->setVelocity(0.0f, pp->getVelocityY());
	/*pp->setPosition(pp->getX() + pp->getVelocityX(), pp->getY() + pp->getVelocityY());

	// FOR NOW THE PLAYER IS DIRECTLY CONTROLLED BY THE KEYBOARD,
	// SO WE'LL NEED TO TURN OFF ANY VELOCITY APPLIED BY INPUT
	// SO THE NEXT FRAME IT DOESN'T GET ADDED
	pp->setVelocity(0.0f, pp->getVelocityY());

	// AND NOW MOVE ALL THE BOTS
	list<Bot*>::iterator botIterator = sm->getBotsIterator();
	while (botIterator != sm->getEndOfBotsIterator())
	{			
		Bot *bot = (*botIterator);
		pp = bot->getPhysicalProperties();
		pp->setPosition(pp->getX() + pp->getVelocityX(), pp->getY() + pp->getVelocityY());
		botIterator++;
	}*/

	
}
void RebelleUpgradeScreenGUI::loadPlayerStats()
{
	Game* game = Game::getSingleton();
	GameStateManager* gsm = game->getGSM();
	SpriteManager* spriteMgr = gsm->getSpriteManager();
	GameGraphics *graphics = game->getGraphics();
	TextureManager *guiTextureManager = graphics->getGUITextureManager();

	PlayerSprite *player = spriteMgr->getPlayer();
	int speed = player->getSpeed();
	int attack = player->getAttack();
	int defense = player->getDefense();
	unsigned int speedIconTID = guiTextureManager->loadTexture(SPEED_ICON_PATH);
	unsigned int attackIconTID = guiTextureManager->loadTexture(ATTACK_ICON_PATH);
	unsigned int defenseIconTID = guiTextureManager->loadTexture(DEFENSE_ICON_PATH);

	//// - first speed icon will be rendered at 20px right to upgrade button
	int speedIconY = statListY + statLineHeight + ydistBetweenStats;
	int nextSpeedIconX = statListX + statTitleWidth + statTitleWidth + upgradeButtonWidth + 20;
	for (int i = 0; i < speed; i++)
	{
		OverlayImage *speedIcon = new OverlayImage();
		speedIcon->alpha = 255;
		speedIcon->width = STAT_ICON_WIDTH;
		speedIcon->height = STAT_ICON_HEIGHT;
		speedIcon->x = nextSpeedIconX;
		speedIcon->y = speedIconY;
		speedIcon->z = 0;
		speedIcon->imageID = speedIconTID;

		this->addOverlayImage(speedIcon);
		nextSpeedIconX += STAT_ICON_WIDTH + 3;
	}

	//// attack icons should be next to Attack stat title and the button.
	int attackIconY = speedIconY + statLineHeight + ydistBetweenStats;
	int nextAttackIconX = statListX + statTitleWidth + statTitleWidth + upgradeButtonWidth + 20;
	for (int i = 0; i < attack; i++)
	{
		OverlayImage *attackIcon = new OverlayImage();
		attackIcon->alpha = 255;
		attackIcon->width = STAT_ICON_WIDTH;
		attackIcon->height = STAT_ICON_HEIGHT;
		attackIcon->x = nextAttackIconX;
		attackIcon->y = attackIconY;
		attackIcon->z = 0;
		attackIcon->imageID = attackIconTID;

		this->addOverlayImage(attackIcon);
		nextAttackIconX += STAT_ICON_WIDTH + 3;
	}

	//// defense icons
	int defenseIconY = attackIconY + statLineHeight + ydistBetweenStats;
	int nextDefenseIconX = statListX + statTitleWidth + statTitleWidth + upgradeButtonWidth + 20;
	for (int i = 0; i < attack; i++)
	{
		OverlayImage *defenseIcon = new OverlayImage();
		defenseIcon->alpha = 255;
		defenseIcon->width = STAT_ICON_WIDTH;
		defenseIcon->height = STAT_ICON_HEIGHT;
		defenseIcon->x = nextDefenseIconX;
		defenseIcon->y = defenseIconY;
		defenseIcon->z = 0;
		defenseIcon->imageID = defenseIconTID;

		this->addOverlayImage(defenseIcon);
		nextDefenseIconX += STAT_ICON_WIDTH + 3;
	}
}
Пример #12
0
/*
	This is where all game physics starts each frame. It is called each frame 
	by the game statem manager after player input and AI have been processed. It
	updates the physical state of all dynamic objects in the game and
	moves all objects to their end of frame positions, updates all necessary
	object velocities, and calls all collision event handlers.
*/
void Physics::update(Game *game)
{

	GameStateManager *gsm = game->getGSM();
	SpriteManager *spm = gsm->getSpriteManager();
	AnimatedSprite *player = spm->getPlayer();

	if (once == 0) {

	
	/*	b2PolygonShape groundBox;
		groundBox.SetAsBox(50.0f, 10.0f);

		groundBody->CreateFixture(&groundBox, 0.0f);
*/
		b2BodyDef bodyDef;
		bodyDef.type = b2_dynamicBody;
		bodyDef.position.Set(600, 9280);
		body = world->CreateBody(&bodyDef);

		b2PolygonShape dynamicBox;
		dynamicBox.SetAsBox(32.0f, 32.0f);

		b2FixtureDef fixtureDef;
		fixtureDef.shape = &dynamicBox;


		// Set the box density to be non-zero, so it will be dynamic.
		fixtureDef.density = 1.0f;

		// Override the default friction.
		fixtureDef.friction = 0.3f;

		// Add the shape to the body.
		body->CreateFixture(&fixtureDef);
		//body->SetLinearVelocity(b2Vec2(0,-1000));

		//body->SetUserData(player);
		player->setBody(body);
		// This is our little game loop.

		


		once += 1;
	}

	body->ApplyForce( world->GetGravity(), body->GetWorldCenter(), true );

			float32 timeStep = 1.0f / 60.0f;
			int32 velocityIterations = 6;
			int32 positionIterations = 2;

			world->Step(timeStep, velocityIterations, positionIterations);

			// Now print the position and angle of the body.
			b2Vec2 position = body->GetPosition();
			//b2Vec2 position2 = body2->GetPosition();

			float32 angle = body->GetAngle();

			printf("%4.2f %4.2f %4.2f\n", position.x, position.y, angle);
		
			if (f == 0) {
				World *woorld = gsm->getWorld();
				vector<WorldLayer*> *layers = woorld->getLayers();
				CollidableObject *sprite = NULL;
				for (int i = 0; i < woorld->getNumLayers(); i++)
				{
					WorldLayer *layer = layers->at(i);
					if (layer->hasCollidableTiles())
					{
						layer->findTileCollisionsForSprite(this,sprite);
					}
				}
				f++;
			}
			
			if (player->getinvincible() == true) {
				if (invincibletimer == 0) {
					invincibletimer = 100;
				}
				invincibletimer -= 1;
				if (invincibletimer == 0) {
					player->setinvincible(false);
				}
			}
			
				 
			if (z!=0)z--;
			if (z==0)
			if (player->getinvincible() == false)
			for (b2ContactEdge* edge = body->GetContactList(); edge; edge = edge->next)
				if (edge->contact->IsTouching()) {
					z=50;

					if(game->getPlayerLife() > 0)
						{game->decreasePlayerLife();
					PlaySound(L"data/sounds/explosion.wav", NULL, SND_FILENAME|SND_SYNC);}
					else 
					{
					if(game->getLives() > 1) {
						game->decreaseLives();
					}						
					else if(game->getLives() == 1 && game->getPlayerLife() == 0)
					{
						GameStateManager *gsm = game->getGSM();
						once = 0;
						//body->SetTransform(b2Vec2((600-position.x),(9280-position.y)),body->GetAngle());
						Viewport *viewport = game->getGUI()->getViewport();
						viewport->setViewportX(0);
						viewport->setViewportY(8880);

						gsm->gameOver();
						PlaySound(L"data/sounds/end.wav", NULL, SND_FILENAME|SND_SYNC);
					}
	
					game->setPlayerLife();
				}

			}

			/*if (f > 0)
			{
				if(game->getPlayerLife() > 0)
				game->decreasePlayerLife();
		
				else 
				{
					if(game->getLives() > 1)
						game->decreaseLives();
					else if(game->getLives() == 1 && game->getPlayerLife() == 0)
					{
						GameStateManager *gsm = game->getGSM();
						gsm->setCurrentGameState(GS_GAME_OVER);
					}
	
					game->setPlayerLife();
				}	
			}*/
			//OutputDebug(L"My output string.");


	//		activatedForSingleUpdate = false;

	//// WE'LL NEED THE WORLD TO ACCESS THE SPRITES AND WORLD LAYERS
	//World *woorld = gsm->getWorld();

	//currentCollisionTime = 0.0f;


	//// FOR ALL SPRITES, INCLUDING THE BOTS AND PLAYER
	//vector<CollidableObject*>::iterator spritesIt = sortedSweptShapes[LEFT_EDGE]->begin();
	//while (spritesIt != sortedSweptShapes[LEFT_EDGE]->end())
	//{
	//	CollidableObject *sprite = (*spritesIt);
	//	prepSpriteForCollisionTesting(woorld, sprite);
	//	getAllTileCollisionsForAGivenSprite(woorld, sprite, 1.0f);
	//	spritesIt++;
	//}

	//// PREPARE FOR SPRITE-SPRITE COLLISION TESTING

	//	// SWEEP AND PRUNE DATA STRUCTURES PREP WORK
	//		// SORT S_AND_P VECTOR SORTED BY START X OF SWEPT SHAPE
	//		// SORT S_AND_P VECTOR SORTED BY END X OF SWEPT SHAPE
	//		// WE DON'T NEED THE Y-AXIS SORTED, BUT WOULD IF THIS
	//		// WERE A 3D SYSTEM TO SAVE ON COMPARISONS.

	//// WE'RE USING C++'s STL sort METHOD AND ARE PROVIDING
	//// A CUSTOM MEANS FOR COMPARISON
	//sort(sortedSweptShapes[LEFT_EDGE]->begin(),		sortedSweptShapes[LEFT_EDGE]->end(),	SweptShapesComparitorByLeft());
	//sort(sortedSweptShapes[RIGHT_EDGE]->begin(),	sortedSweptShapes[RIGHT_EDGE]->end(),	SweptShapesComparitorByRight());
	//	
	//// RECORD SORTED POSITIONS WITH EACH SPRITE. THEY NEED TO KNOW WHERE
	//// THEY ARE IN THOSE DATA STRUCTURES SUCH THAT WE CAN JUMP INTO
	//// THOSE DATA STRUCTURES TO TEST COLLISIONS WITH NEIGHBORS
	//updateSweptShapeIndices();

	//// YOU'LL NEED TO TEST FOR SPRITE-TO-SPRITE COLLISIONS HERE

	//// *** LOOP STARTS HERE. WE'LL DO THIS UNTIL THERE ARE NO
	//// MORE COLLISIONS TO RESOLVE FOR THIS FRAME
	//while (activeCollisions.size() > 0)
	//{
	//	// SORT COLLISION OBJECTS BY TIME OF COLLISION
	//	// NOTE THAT I'M JUST EMPLOYING THE STL'S List
	//	// CLASS' SORT METHOD BY PROVIDING MY OWN
	//	// MEANS FOR COMPARING Collision OBJECTS
	//	activeCollisions.sort(CollisionComparitor());

	//	// GET FIRST COLLISION - NOTE THAT WE HAVE THE COLLISIONS SORTED
	//	// IN DESCENDING ORDER, SO TO TAKE THE EARLIEST ONE, WE REMOVE IT
	//	// FOM THE BACK OF THE SORTED LIST
	//	Collision *earliestCollision = activeCollisions.back();
	//	activeCollisions.pop_back();
	//	float collisionTime = earliestCollision->getTimeOfCollision();

	//	// MOVE ALL SPRITES UP TO TIME OF FIRST COLLISION USING
	//	// APPROPRIATELY SCALED VELOCITIES
	//	moveAllSpritesUpToBufferedTimeOfCollision(earliestCollision);

	//	// AND ADVANCE COLLISION TIME
	//	currentCollisionTime = collisionTime;

	//	// AND UPDATE THE VELOCITIES OF THE SPRITE(S) INVOLVED IN THE COLLISION
	//	performCollisionResponse(earliestCollision);

	//	// EXECUTE COLLISION EVENT CODE
	//	// TEST TO SEE TYPES OF OBJECTS AND APPROPRIATE RESPONSE
	//	// ACCORDING TO CUSTOMIZED COLLISION EVENT HANDLER
	//	collisionListener->respondToCollision(game, earliestCollision);

	//	CollidableObject *co1 = earliestCollision->getCO1();
	//	CollidableObject *co2 = earliestCollision->getCO2();
	//	removeActiveCOCollisions(co1);
 //		co1->updateSweptShape(1.0f - currentCollisionTime);
	//	getAllTileCollisionsForAGivenSprite(woorld, co1, 1.0f - currentCollisionTime);

	//	// ONLY DO IT FOR THE SECOND ONE IF IT'S NOT A TILE
	//	if (!earliestCollision->isCollisionWithTile())
	//	{
	//		removeActiveCOCollisions(co2);
	//		co2->updateSweptShape(1.0f - currentCollisionTime);
	//		getAllTileCollisionsForAGivenSprite(woorld, co2, 1.0f - currentCollisionTime);
	//	}
	//	else
	//	{
	//		spriteToTileCollisionsThisFrame[co1].insert(earliestCollision->getTile());
	//		recycledCollidableObjectsList.push_back(co2);
	//	}
	//	
	//	// IF IT WAS ONLY ONE SPRITE WITH A TILE THIS IS EASY TO DO
	//	if (earliestCollision->isCollisionWithTile())
	//	{
	//		reorderCollidableObject(co1);
	//	}
	//	// YOU'LL HAVE TO WORRY ABOUT REORDERING STUFF FOR COLLISIONS
	//	// BETWEEN TWO SPRITES
	//	
	//	// NOW TEST NEIGHBORS OF SPRITES INVOLVED IN RESOLVED COLLISION
	//	// AGAINST NEIGHBORS IN SWEPT SHAPE DATA STRUCTURES. YOU'LL HAVE
	//	// TO FIGURE OUT HOW TO DO THIS AND HOW TO RESOLVE SUCH COLLISIONS
	//		
	//	// RECYCLE THE COLLISION SINCE WE'RE NOW DONE WITH IT
	//	recycledCollisions.push_back(earliestCollision);
	//}

	//// APPLY THE REMAINING TIME TO MOVE THE SPRITES. NOTE THAT
	//// THIS IS ACTUALLY A VERY RISKY, TRICKY STEP BECAUSE IT COULD
	//// MOVE OBJECTS ALMOST TO THE POINT OF COLLISION, WHICH MAY THEN
	//// BE DETECTED ALMOST AT TIME 0 NEXT FRAME. THERE ARE OTHER TRICKY
	//// ISSUES RELATED TO OUR BUFFER AS WELL, SO WE CHEAT A LITTLE HERE
	//// AND SCALE THE TIME REMAINING DOWN A LITTE
	//if (currentCollisionTime < 1.0f)
	//	moveAllSpritesToEndOfFrame();

	//// INIT TILE COLLISION INFO
	//// SET ON TILE LAST FRAME USING ON TILE THIS FRAME
	//// SET ON TILE THIS FRAME TO FALSE
	//spritesIt = sortedSweptShapes[LEFT_EDGE]->begin();
	//while (spritesIt != sortedSweptShapes[LEFT_EDGE]->end())
	//{
	//	CollidableObject *sprite = (*spritesIt);
	//	sprite->advanceOnTileStatus();
	//	spritesIt++;
	//}

	//// WE'RE NOT GOING TO ALLOW MULTIPLE COLLISIONS TO HAPPEN IN A FRAME
	//// BETWEEN THE SAME TWO OBJECTS
	//spriteToTileCollisionsThisFrame.clear();
	//


}
void WalkaboutButtonEventHandler::handleButtonEvents(	Game *game, 
													wstring command)
{
	game->getGAM()->playSound(C_MENUBUTTON);
	// THE USER PRESSED THE Exit BUTTON ON THE MAIN MENU,
	// SO LET'S SHUTDOWN THE ENTIRE APPLICATION
	if (command.compare(W_EXIT_COMMAND) == 0)
	{
		game->shutdown();
	}
	// THE USER PRESSED THE MOUSE BUTTON ON THE SPLASH
	// SCREEN, SO LET'S GO TO THE MAIN MENU
	else if (command.compare(W_GO_TO_MM_COMMAND) == 0)
	{
		GameStateManager *gsm = game->getGSM();
		gsm->goToMainMenu();
	}
	// THE USER PRESSED THE Start BUTTON ON THE MAIN MENU,
	// SO LET'S START THE GAME FROM THE FIRST LEVEL
	else if (command.compare(W_START_COMMAND) == 0)
	{
		game->getGSM()->getSpriteManager()->getPlayer()->setHitPoints(PLAYER_HITPOINTS);
		game->getGAM()->setMusic(C_LEVEL1);
		game->setCurrentLevelFileName(W_LEVEL_1_NAME);
		game->startGame();
	}
	else if (command.compare(W_RETURN_COMMAND) == 0)
	{
		game->getGSM()->getPhysics()->togglePhysics();
		game->getGSM()->goToGame();
	}
	else if (command.compare(W_HELP_COMMAND) == 0)
	{
		GameStateManager *gsm = game->getGSM();
		gsm->goToHelp();
	}
	else if (command.compare(W_CREDITS_COMMAND) == 0)
	{
		GameStateManager *gsm = game->getGSM();
		gsm->goToCredits();
	}
	// THE USER PRESSED THE Quit BUTTON ON THE IN-GAME MENU,
	// SO LET'S UNLOAD THE LEVEL AND RETURN TO THE MAIN MENU
	else if (command.compare(W_QUIT_COMMAND) == 0)
	{
		game->getGAM()->setMusic(C_INTRO);
		game->quitGame();
		game->getGSM()->goToMainMenu();
	}
	else if (command.compare(W_NEXT_SCENE_COMMAND) == 0)
	{
		game->getGAM()->playSound(C_SWOOSHTALK);
		OverlayImage* currentImage = game->getGSM()->getCutsceneImage();
		if (currentImage==NULL){
			currentImage = game->getGSM()->initCutscene();
		}
		setCutsceneImage(currentImage,game);
	}
	else if(command.compare(W_NEXT_LEVEL_COMMAND) == 0) {
		GameStateManager *gsm = game->getGSM();
		game->quitGame();
		if(game->getCurrentLevelFileName().compare(W_LEVEL_1_NAME) == 0) {
			// If finished first level, load second
			game->getGAM()->setMusic(C_LEVEL2);
			game->setCurrentLevelFileName(W_LEVEL_2_NAME);
			game->startGame();
		}
		else if(game->getCurrentLevelFileName().compare(W_LEVEL_2_NAME) == 0) {
			// If finished second level, load third
			game->getGAM()->setMusic(C_LEVEL3);
			game->setCurrentLevelFileName(W_LEVEL_3_NAME);
			game->startGame();
		}
		else {
			// ONLY THREE LEVELS, GO TO MAIN MENU WHEN DONE, COULD ALSO JUMP INTO A CUTSCENE HERE TO END THE GAME
			game->getGSM()->goToMainMenu();
		}
	}
	else if(command.compare(W_RESTART_LEVEL_COMMAND) == 0) {
		GameStateManager *gsm = game->getGSM();
		gsm->getSpriteManager()->getPlayer()->setHitPoints(PLAYER_HITPOINTS);
		game->quitGame();
		if(game->getCurrentLevelFileName().compare(W_LEVEL_1_NAME) == 0) {
			// Reload first level
			game->getGAM()->setMusic(C_LEVEL1);
			game->setCurrentLevelFileName(W_LEVEL_1_NAME);
			game->startGame();
		}
		else if(game->getCurrentLevelFileName().compare(W_LEVEL_2_NAME) == 0) {
			// Reload second level
			game->getGAM()->setMusic(C_LEVEL2);
			game->setCurrentLevelFileName(W_LEVEL_2_NAME);
			game->startGame();
		}
		else if(game->getCurrentLevelFileName().compare(W_LEVEL_3_NAME) == 0) {
			// Reload third level
			game->getGAM()->setMusic(C_LEVEL3);
			game->setCurrentLevelFileName(W_LEVEL_3_NAME);
			game->startGame();
		}
		else {
			// ONLY THREE LEVELS, GO TO MAIN MENU WHEN DONE, COULD ALSO JUMP INTO A CUTSCENE HERE TO END THE GAME
			game->getGSM()->goToMainMenu();
		}
	}
}
Пример #14
0
/*
	handleKeyEvent - this method handles all keyboard interactions. Note that every frame this method
	gets called and it can respond to key interactions in any custom way. Ask the GameInput class for
	key states since the last frame, which can allow us to respond to key presses, including when keys
	are held down for multiple frames.
*/
void BugginOutKeyEventHandler::handleKeyEvents(Game *game)
{
	// WE CAN QUERY INPUT TO SEE WHAT WAS PRESSED
	GameInput *input = game->getInput();

	// LET'S GET THE PLAYER'S PHYSICAL PROPERTIES, IN CASE WE WANT TO CHANGE THEM
	GameStateManager *gsm = game->getGSM();
	AnimatedSprite *player = gsm->getSpriteManager()->getPlayer();
	list<AnimatedSprite*>::iterator blocks;
	PhysicalProperties *pp = player->getPhysicalProperties();
	Viewport *viewport = game->getGUI()->getViewport();

	// IF THE GAME IS IN PROGRESS
	if (gsm->isGameInProgress())
	{
		Physics *phy = game->getGSM()->getPhysics();
		// WASD KEY PRESSES WILL CONTROL THE PLAYER
		// SO WE'LL UPDATE THE PLAYER VELOCITY WHEN THESE KEYS ARE
		// PRESSED, THAT WAY PHYSICS CAN CORRECT AS NEEDED
		float vX = pp->getVelocityX();
		float vY = pp->getVelocityY();

		// YOU MIGHT WANT TO UNCOMMENT THIS FOR SOME TESTING,

		b2Body *body = player->body;

		if (game->getGSM()->levelSwitchTrigger == true)
		{
			game->quitGame();

			if (game->getCurrentLevelFileName() == W_LEVEL_1_NAME)
				game->setCurrentLevelFileName(W_LEVEL_2_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_2_NAME)
				game->setCurrentLevelFileName(W_LEVEL_3_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_3_NAME)
				game->setCurrentLevelFileName(W_LEVEL_4_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_4_NAME)
				game->setCurrentLevelFileName(W_LEVEL_5_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_5_NAME)
				game->setCurrentLevelFileName(W_LEVEL_6_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_6_NAME)
				game->setCurrentLevelFileName(W_LEVEL_7_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_7_NAME)
				game->setCurrentLevelFileName(W_LEVEL_8_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_8_NAME)
				game->setCurrentLevelFileName(W_LEVEL_9_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_9_NAME)
				game->setCurrentLevelFileName(W_LEVEL_10_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_10_NAME)
				game->setCurrentLevelFileName(W_LEVEL_1_NAME);

			game->startGame();
			game->getGSM()->levelSwitchTrigger = false;
		}

		if (game->getGSM()->levelResetTrigger == true)
		{
			game->quitGame();

			if (game->getCurrentLevelFileName() == W_LEVEL_1_NAME)
				game->setCurrentLevelFileName(W_LEVEL_1_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_2_NAME)
				game->setCurrentLevelFileName(W_LEVEL_2_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_3_NAME)
				game->setCurrentLevelFileName(W_LEVEL_3_NAME);

			else if (game->getCurrentLevelFileName() == W_LEVEL_4_NAME)
				game->setCurrentLevelFileName(W_LEVEL_4_NAME);

			game->startGame();
			game->getGSM()->levelResetTrigger = false;
		}

		if (input->isKeyDown('1')){
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_1_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_1_NAME);
			/*game->setCurrentLevelFileName(W_LEVEL_1_NAME);
			game->startGame();*/
		}
		else if (input->isKeyDown('2')){
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_2_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_2_NAME);
		}
		else if (input->isKeyDown('3')){
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_3_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_3_NAME);
		}
		else if (input->isKeyDown('4'))
		{
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_4_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_4_NAME);
		}
		else if (input->isKeyDown('5'))
		{
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_5_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_4_NAME);
		}
		else if (input->isKeyDown('6'))
		{
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_6_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_4_NAME);
		}
		else if (input->isKeyDown('7'))
		{
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_7_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_4_NAME);
		}
		else if (input->isKeyDown('8'))
		{
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_8_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_4_NAME);
		}
		else if (input->isKeyDown('9'))
		{
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_9_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_4_NAME);
		}
		else if (input->isKeyDown('0'))
		{
			game->quitGame();
			game->setCurrentLevelFileName(W_LEVEL_10_NAME);
			game->startGame();
			//game->getGSM()->unloadCurrentLevel();
			//game->getGSM()->loadLevel(game, W_LEVEL_1_DIR + W_LEVEL_4_NAME);
		}

		else if (input->isKeyDown(A_KEY))
		{
			if (player->dead == false)
			{
				pp->facing = 1;

				if ((phy->CurrentGrav == phy->Normal_Grav || phy->CurrentGrav == phy->Reverse_Grav))
				{
					if (player->onGround())
						body->ApplyForce(b2Vec2(body->GetMass() * -0.1 / (1 / 60.0), 0), body->GetWorldCenter(), true);
					else
						body->ApplyForce(b2Vec2(body->GetMass() * -0.1 / (1 / 60.0), 0), body->GetWorldCenter(), true);
				}

				if ((phy->CurrentGrav == phy->Left_Grav || phy->CurrentGrav == phy->Right_Grav))
				{
					if (player->onGround())
						body->ApplyForce(b2Vec2(0, body->GetMass() * -0.1 / (1 / 60.0)), body->GetWorldCenter(), true);
					else
						body->ApplyForce(b2Vec2(0, body->GetMass() * -0.1 / (1 / 60.0)), body->GetWorldCenter(), true);
				}

				if (player->onGround())
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(LWALK);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(ULWALK);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RLWALK);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LLWALK);
				}
				else
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(LFALL);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(ULFALL);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RLFALL);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LLFALL);
				}
			}
		}
		else if (input->isKeyDown(D_KEY))
		{
			if (player->dead == false)
			{
				pp->facing = 0;
				if ((phy->CurrentGrav == phy->Normal_Grav || phy->CurrentGrav == phy->Reverse_Grav))
				{
					if (player->onGround())
						body->ApplyForce(b2Vec2(body->GetMass() * 0.1 / (1 / 60.0), 0), body->GetWorldCenter(), true);
					else
						body->ApplyForce(b2Vec2(body->GetMass() * 0.1 / (1 / 60.0), 0), body->GetWorldCenter(), true);
				}

				if ((phy->CurrentGrav == phy->Left_Grav || phy->CurrentGrav == phy->Right_Grav))
				{
					if (player->onGround())
						body->ApplyForce(b2Vec2(0, body->GetMass() * 0.1 / (1 / 60.0)), body->GetWorldCenter(), true);
					else
						body->ApplyForce(b2Vec2(0, body->GetMass() * 0.1 / (1 / 60.0)), body->GetWorldCenter(), true);
				}

				if (player->onGround())
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(RWALK);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(URWALK);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RRWALK);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LRWALK);
				}

				else
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(RFALL);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(URFALL);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RRFALL);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LRFALL);
				}
			}
		}
		else if (input->isKeyDownForFirstTime(G_KEY))
		{
			/*((BugginOutDataLoader*)game->getDataLoader())->remotePlaySound(((BugginOutDataLoader*)game->getDataLoader())->gravSound);
			b2World *world = game->getGSM()->getPhysics()->getBoxWorld();

			if (phy->CurrentGrav == phy->Normal_Grav)
			{
				player->body->SetTransform(player->body->GetPosition(), 0.0f);
				blocks = gsm->getSpriteManager()->getBlocksIterator();
				while (blocks != gsm->getSpriteManager()->getEndOfBlocksIterator())
				{
					(*blocks)->body->SetGravityScale(1);
					blocks++;
				}

				world->SetGravity(phy->Reverse_Grav);
				phy->CurrentGrav = phy->Reverse_Grav;
			}

			else if (phy->CurrentGrav == phy->Reverse_Grav)
			{
				player->body->SetTransform(player->body->GetPosition(), 270.0f);
				blocks = gsm->getSpriteManager()->getBlocksIterator();
				while (blocks != gsm->getSpriteManager()->getEndOfBlocksIterator())
				{
					(*blocks)->body->SetGravityScale(0);
					blocks++;
				}

				world->SetGravity(phy->Left_Grav);
				phy->CurrentGrav = phy->Left_Grav;

			}

			else if (phy->CurrentGrav == phy->Left_Grav)
			{
				player->body->SetTransform(player->body->GetPosition(), 270.0f);
				blocks = gsm->getSpriteManager()->getBlocksIterator();
				while (blocks != gsm->getSpriteManager()->getEndOfBlocksIterator())
				{
					(*blocks)->body->SetGravityScale(0);
					blocks++;
				}

				world->SetGravity(phy->Right_Grav);
				phy->CurrentGrav = phy->Right_Grav;

			}

			else if (phy->CurrentGrav == phy->Right_Grav)
			{
				player->body->SetTransform(player->body->GetPosition(), 0.0f);
				blocks = gsm->getSpriteManager()->getBlocksIterator();
				while (blocks != gsm->getSpriteManager()->getEndOfBlocksIterator())
				{
					(*blocks)->body->SetGravityScale(1);
					blocks++;
				}

				world->SetGravity(phy->Normal_Grav);
				phy->CurrentGrav = phy->Normal_Grav;

			}

			player->setGrounded(false);*/
		}

		else if (player->onGround())
		{
			if (player->dead == false)
			{
				if (pp->facing == 0)
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(RIDLE);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(URIDLE);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RRIDLE);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LRIDLE);
				}
				else
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(LIDLE);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(ULIDLE);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RLIDLE);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LLIDLE);
				}
			}

			else
			{
				if (player->getCurrentState() != L"LDEATH")
				{
					if (pp->facing == 0){
						if (phy->CurrentGrav == phy->Normal_Grav)
							player->setCurrentState(RFALL);
						else if (phy->CurrentGrav == phy->Reverse_Grav)
							player->setCurrentState(URFALL);
						else if (phy->CurrentGrav == phy->Right_Grav)
							player->setCurrentState(RRFALL);
						else if (phy->CurrentGrav == phy->Left_Grav)
							player->setCurrentState(LRFALL);
					}
					else{
						if (phy->CurrentGrav == phy->Normal_Grav)
							player->setCurrentState(LFALL);
						else if (phy->CurrentGrav == phy->Reverse_Grav)
							player->setCurrentState(ULFALL);
						else if (phy->CurrentGrav == phy->Right_Grav)
							player->setCurrentState(RLFALL);
						else if (phy->CurrentGrav == phy->Left_Grav)
							player->setCurrentState(LLFALL);
					}
				}
			}
		}
			if (input->isKeyDownForFirstTime(SPACE_KEY) && player->onGround() && player->dead == false)
			{
				((BugginOutDataLoader*)game->getDataLoader())->remotePlaySound(((BugginOutDataLoader*)game->getDataLoader())->jumpSound);
				//float mass = body->GetMass();
				float impulse = 3.0f; 

				if (phy->CurrentGrav == phy->Normal_Grav)
				{
					body->SetLinearVelocity(b2Vec2(body->GetLinearVelocity().x, -impulse));
				}
				if (phy->CurrentGrav == phy->Reverse_Grav)
				{
					body->SetLinearVelocity(b2Vec2(body->GetLinearVelocity().x, impulse));
				}
				if (phy->CurrentGrav == phy->Right_Grav)
				{
					body->SetLinearVelocity(b2Vec2(-impulse, body->GetLinearVelocity().y));
				}
				if (phy->CurrentGrav == phy->Left_Grav)
				{
					body->SetLinearVelocity(b2Vec2(impulse, body->GetLinearVelocity().y));
				}

				if (pp->facing == 0)
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(RJUMP);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(URJUMP);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RRJUMP);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LRJUMP);
				}
				else
				{
					if (phy->CurrentGrav == phy->Normal_Grav)
						player->setCurrentState(LJUMP);
					else if (phy->CurrentGrav == phy->Reverse_Grav)
						player->setCurrentState(ULJUMP);
					else if (phy->CurrentGrav == phy->Right_Grav)
						player->setCurrentState(RLJUMP);
					else if (phy->CurrentGrav == phy->Left_Grav)
						player->setCurrentState(LLJUMP);
				}

				player->setGrounded(false);
			}
			if (input->isKeyDownForFirstTime(P_KEY))
			{
				game->getGSM()->getPhysics()->activated = !(game->getGSM()->getPhysics()->activated);
			}
			if (input->isKeyDownForFirstTime(R_KEY))
			{
				game->getGSM()->levelResetTrigger = true;
			}

			// NOW SET THE ACTUAL PLAYER VELOCITY
			pp->setVelocity(vX, vY);
		

		// 0X43 is HEX FOR THE 'C' VIRTUAL KEY
		// THIS CHANGES THE CURSOR IMAGE
		if ((input->isKeyDownForFirstTime(C_KEY)) && input->isKeyDown(VK_SHIFT))
		{
			Cursor *cursor = game->getGUI()->getCursor();
			unsigned int id = cursor->getActiveCursorID();
			id++;
			if (id == cursor->getNumCursorIDs())
				id = 0;
			cursor->setActiveCursorID(id);
		}

		// LET'S MESS WITH THE TARGET FRAME RATE IF THE USER PRESSES THE HOME OR END KEYS
		WindowsTimer *timer = (WindowsTimer*)game->getTimer();
		int fps = timer->getTargetFPS();

		// THIS SPEEDS UP OUR GAME LOOP AND THUS THE GAME, NOTE THAT WE COULD ALTERNATIVELY SCALE
		// DOWN THE GAME LOGIC (LIKE ALL VELOCITIES) AS WE SPEED UP THE GAME. THAT COULD PROVIDE
		// A BETTER PLAYER EXPERIENCE
		if (input->isKeyDown(VK_HOME) && (fps < MAX_FPS))
			timer->setTargetFPS(fps + FPS_INC);

		// THIS SLOWS DOWN OUR GAME LOOP, BUT WILL NOT GO BELOW 5 FRAMES PER SECOND
		else if (input->isKeyDown(VK_END) && (fps > MIN_FPS))
			timer->setTargetFPS(fps - FPS_INC);
	}

}
Пример #15
0
/*
This is where all game physics starts each frame. It is called each frame 
by the game state manager after player input and AI have been processed. It
updates the physical state of all dynamic objects in the game and
moves all objects to their end of frame positions, updates all necessary
object velocities, and calls all collision event handlers.
*/
void Physics::update(Game *game)
{
    // WE'LL USE A CONTINUOUS COLLISION SYSTEM TO ENSURE TEMPORAL 
    // COHERENCE, WHICH MEANS WE'LL MAKE SURE COLLISIONS ARE RESOLVED
    // IN THE ORDER WITH WHICH THEY HAPPEN. WE DON'T WANT GAME EVENTS
    // TO APPEAR TO HAPPEN IN THE WRONG ORDER. WE'LL TRY TO MAKE IT
    // A LITTLE MORE EFFICIENT BY EMPLOYING A VARIATION ON THE
    // SWEEP AND PRUNE ALGORITHM FOR DYNAMIC-DYNAMIC OBJECT COLLISIONS

    // IN CASE WE'RE DOING THE ONE UPDATE STEP AT A TIME
    // THIS MAKES SURE THE UPDATE DOESN'T GET CALLED AGAIN
    // NEXT FRAME WITHOUT THE USER EXPLICITY REQUESTING IT
    // BY PRESSING THE 'T' KEY (for Time sTep)
    activatedForSingleUpdate = false;

    // WE'LL NEED THE WORLD TO ACCESS THE SPRITES AND WORLD LAYERS
    GameStateManager *gsm = game->getGSM();
    World *world = gsm->getWorld();

    // NOTE THAT WE MAKE SURE THE activeCollisions VECTOR IS
    // EMPTIED BEFORE THIS METHOD EXITS, SO WE CAN ASSUME
    // IT'S EMPTY NOW. activeCollisions CONTAINS ALL THE COLLISIONS
    // DETECTED SO FAR THIS FRAME. THESE ARE THE THINGS WE MUST
    // RESOLVE.

    // START THE CLOCK AT 0, THAT MEANS 0% OF THE WAY THROUGH THE FRAME.
    // NOTE THAT TIME 0 IS THE MOST DANGEROUS TIME FOR DETECTING COLLISIONS
    // BECAUSE THEY CAN BE EASILY OVERLOOKED. THE SAME FOR SIMULTANEOUS 
    // COLLISIONS. TO MINIMIZE RIGID BODY PENETRATION, SUCH CIRCUMSTANCES
    // ARE TYPICALLY HANDLED AS SPECIAL CASES
    currentCollisionTime = 0.0f;

    // FIRST WE NEED TO DO COLLISION TESTING PREP WORK FOR SPRITES
    // APPLY ACCELERATION AND GRAVITY TO VELOCITY
    // INIT TILE COLLISION INFO
    // SET ON TILE LAST FRAME USING ON TILE THIS FRAME
    // SET ON TILE THIS FRAME TO FALSE	
    // GET COLLISIONS WITH ALL TILES TO HAPPEN DURING THIS FRAME
    // PUT THESE COLLISIONS INTO A SORTABLE DATA STRUCTURE
    // INIT SPRITE'S SWEPT SHAPE INFO

    // FOR ALL SPRITES, INCLUDING THE BOTS AND PLAYER
    vector<CollidableObject*>::iterator spritesIt = sortedSweptShapes[LEFT_EDGE]->begin();
    while (spritesIt != sortedSweptShapes[LEFT_EDGE]->end())
    {

        CollidableObject *sprite = (*spritesIt);

        prepSpriteForCollisionTesting(world, sprite);
        getAllTileCollisionsForAGivenSprite(world, sprite, 1.0f);
        spritesIt++;
    }

    // PREPARE FOR SPRITE-SPRITE COLLISION TESTING

    // SWEEP AND PRUNE DATA STRUCTURES PREP WORK
    // SORT S_AND_P VECTOR SORTED BY START X OF SWEPT SHAPE
    // SORT S_AND_P VECTOR SORTED BY END X OF SWEPT SHAPE
    // WE DON'T NEED THE Y-AXIS SORTED, BUT WOULD IF THIS
    // WERE A 3D SYSTEM TO SAVE ON COMPARISONS.

    // WE'RE USING C++'s STL sort METHOD AND ARE PROVIDING
    // A CUSTOM MEANS FOR COMPARISON

    //PAULO- I THINK THIS WILL ONLY SEE IF THE SPRITES WILL COLLIDE ON X AXIS.
    sort(sortedSweptShapes[LEFT_EDGE]->begin(),		sortedSweptShapes[LEFT_EDGE]->end(),	SweptShapesComparitorByLeft());
    sort(sortedSweptShapes[RIGHT_EDGE]->begin(),	sortedSweptShapes[RIGHT_EDGE]->end(),	SweptShapesComparitorByRight());

    // RECORD SORTED POSITIONS WITH EACH SPRITE. THEY NEED TO KNOW WHERE
    // THEY ARE IN THOSE DATA STRUCTURES SUCH THAT WE CAN JUMP INTO
    // THOSE DATA STRUCTURES TO TEST COLLISIONS WITH NEIGHBORS
    updateSweptShapeIndices();

    // YOU'LL NEED TO TEST FOR SPRITE-TO-SPRITE COLLISIONS HERE
    //PAULO- I AM GOING TO WORK JUST WITH ONE ADVERSARY, BUT I DON`T KNOW HOW TO TAKE THE NEIGHBORS OF ONE SPRITE
    //BECAUSE OF THAT , I AM JUST GOING TO TAKE THE NEXT ONE TO USE IN THE COMPARISIONS

    vector<CollidableObject*>::iterator iteratorSprite = sortedSweptShapes[LEFT_EDGE]->begin();
    while (iteratorSprite != sortedSweptShapes[LEFT_EDGE]->end())
    {

        //PAULO- TESTS IN PAIR
        CollidableObject *sprite1 = (*iteratorSprite);

        advance(iteratorSprite,1);
        if((iteratorSprite != sortedSweptShapes[LEFT_EDGE]->end()))
        {

            CollidableObject *sprite2 = (*iteratorSprite);
            //prepSpriteForCollisionTesting(world, sprite);
            //getAllTileCollisionsForAGivenSprite(world, sprite, 1.0f);

            getCollisionsSpriteSprite(world, sprite1, sprite2, 1.0f);

        }

    }

    // *** LOOP STARTS HERE. WE'LL DO THIS UNTIL THERE ARE NO
    // MORE COLLISIONS TO RESOLVE FOR THIS FRAME
    while (activeCollisions.size() > 0)
    {
        // SORT COLLISION OBJECTS BY TIME OF COLLISION
        // NOTE THAT I'M JUST EMPLOYING THE STL'S List
        // CLASS' SORT METHOD BY PROVIDING MY OWN
        // MEANS FOR COMPARING Collision OBJECTS
        activeCollisions.sort(CollisionComparitor());

        // GET FIRST COLLISION - NOTE THAT WE HAVE THE COLLISIONS SORTED
        // IN DESCENDING ORDER, SO TO TAKE THE EARLIEST ONE, WE REMOVE IT
        // FOM THE BACK OF THE SORTED LIST
        Collision *earliestCollision = activeCollisions.back();
        activeCollisions.pop_back();
        float collisionTime = earliestCollision->getTimeOfCollision();

        // MOVE ALL SPRITES UP TO TIME OF FIRST COLLISION USING
        // APPROPRIATELY SCALED VELOCITIES
        moveAllSpritesUpToBufferedTimeOfCollision(earliestCollision);

        // AND ADVANCE COLLISION TIME
        currentCollisionTime = collisionTime;

        // AND UPDATE THE VELOCITIES OF THE SPRITE(S) INVOLVED IN THE COLLISION
        performCollisionResponse(earliestCollision);

        // EXECUTE COLLISION EVENT CODE
        // TEST TO SEE TYPES OF OBJECTS AND APPROPRIATE RESPONSE
        // ACCORDING TO CUSTOMIZED COLLISION EVENT HANDLER
        collisionListener->respondToCollision(game, earliestCollision);

        // FOR THE TWO OBJECTS INVOLVED IN THE COLLISION
        // REMOVE ALL OTHER COLLISIONS INVOLVING THEM
        // SINCE THEY ARE NOW OBSOLETE. THE REASON BEING
        // THE OBJECT COLLISION NOW LIKELY HAS A 
        // DIFFERENT VECTOR
        // UPDATE THEIR SWEPT SHAPES
        // TEST THEM AGAINST TILES AGAIN
        CollidableObject *co1 = earliestCollision->getCO1();
        CollidableObject *co2 = earliestCollision->getCO2();
        removeActiveCOCollisions(co1);
        co1->updateSweptShape(1.0f - currentCollisionTime);
        getAllTileCollisionsForAGivenSprite(world, co1, 1.0f - currentCollisionTime);



        // ONLY DO IT FOR THE SECOND ONE IF IT'S NOT A TILE
        if (!earliestCollision->isCollisionWithTile())
        {

            removeActiveCOCollisions(co2);
            co2->updateSweptShape(1.0f - currentCollisionTime);
            getAllTileCollisionsForAGivenSprite(world, co2, 1.0f - currentCollisionTime);
            ////if(earliestCollision->isCollisionWithSprite())
            ////{
            //    co1->
            ////}

        }
        else
        {

            spriteToTileCollisionsThisFrame[co1].insert(earliestCollision->getTile());
            recycledCollidableObjectsList.push_back(co2);
        }


        //I should change this to get  different *win positions* 
        if (gsm->getSpriteManager()->getPlayer()->getBoundingVolume()->getBottom() >   30*64.0f)
        {
            GameStateManager *gsm = game->getGSM();
            gsm->win();

        }



        // NOW WE NEED TO SEE IF THE SPRITES INVOLVED IN THE JUST
        // RESOLVED COLLISION ARE GOING TO BE INVOLVED IN ANY MORE
        // WITH OTHER SPRITES BUT WE DON'T WANT TO CHECK ALL OF THEM,
        // WE ONLY WANT TO CHECK NEIGHBORS, BUT FIRST WE HAVE TO
        // MAKE SURE THE SPRITE(S) THAT WE JUST RESOLVED ARE IN THEIR
        // PROPER SWEPT SHAPE LOCATIONS WITHOUT HAVING TO RESORT EVERTYHING

        // IF IT WAS ONLY ONE SPRITE WITH A TILE THIS IS EASY TO DO
        if (earliestCollision->isCollisionWithTile())
        {
            reorderCollidableObject(co1);
        }



        // YOU'LL HAVE TO WORRY ABOUT REORDERING STUFF FOR COLLISIONS
        // BETWEEN TWO SPRITES



        // NOW TEST NEIGHBORS OF SPRITES INVOLVED IN RESOLVED COLLISION
        // AGAINST NEIGHBORS IN SWEPT SHAPE DATA STRUCTURES. YOU'LL HAVE
        // TO FIGURE OUT HOW TO DO THIS AND HOW TO RESOLVE SUCH COLLISIONS

        // RECYCLE THE COLLISION SINCE WE'RE NOW DONE WITH IT
        recycledCollisions.push_back(earliestCollision);
    }

    // APPLY THE REMAINING TIME TO MOVE THE SPRITES. NOTE THAT
    // THIS IS ACTUALLY A VERY RISKY, TRICKY STEP BECAUSE IT COULD
    // MOVE OBJECTS ALMOST TO THE POINT OF COLLISION, WHICH MAY THEN
    // BE DETECTED ALMOST AT TIME 0 NEXT FRAME. THERE ARE OTHER TRICKY
    // ISSUES RELATED TO OUR BUFFER AS WELL, SO WE CHEAT A LITTLE HERE
    // AND SCALE THE TIME REMAINING DOWN A LITTE
    if (currentCollisionTime < 1.0f)
        moveAllSpritesToEndOfFrame();

    // INIT TILE COLLISION INFO
    // SET ON TILE LAST FRAME USING ON TILE THIS FRAME
    // SET ON TILE THIS FRAME TO FALSE
    spritesIt = sortedSweptShapes[LEFT_EDGE]->begin();
    while (spritesIt != sortedSweptShapes[LEFT_EDGE]->end())
    {
        CollidableObject *sprite = (*spritesIt);
        sprite->advanceOnTileStatus();
        spritesIt++;
    }

    // WE'RE NOT GOING TO ALLOW MULTIPLE COLLISIONS TO HAPPEN IN A FRAME
    // BETWEEN THE SAME TWO OBJECTS
    spriteToTileCollisionsThisFrame.clear();
}