bool Bowser::initialize(Game *gamePtr, int width, int height, int ncols,
TextureManager *textureM)
{
attackTimer = 1.0f;
// Bowser sprite initialize
bowserSpriteCoordinates.populateVector("sprite_data\\bowser.xml");
if (!initializeCoords(bowserSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing bowser"));
//Idle
bowserIdle.initialize(gamePtr->getGraphics(), bowserNS::WIDTH,
bowserNS::HEIGHT, 0, textureM);
if (!bowserIdle.initialize(bowserSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing bowser"));
bowserIdle.setFrames(bowserNS::IDLE_START_FRAME, bowserNS::IDLE_END_FRAME);
bowserIdle.setCurrentFrame(bowserNS::IDLE_START_FRAME);
bowserIdle.setFrameDelay(bowserNS::IDLE_ANIMATION_DELAY);
//Spin Attack
bowserSpin.initialize(gamePtr->getGraphics(), bowserNS::WIDTH,
bowserNS::HEIGHT, 0, textureM);
if (!bowserSpin.initialize(bowserSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing bowser"));
bowserSpin.setFrames(bowserNS::SPIN_START_FRAME, bowserNS::SPIN_END_FRAME);
bowserSpin.setCurrentFrame(bowserNS::SPIN_START_FRAME);
bowserSpin.setFrameDelay(bowserNS::SPIN_ANIMATION_DELAY);
// Fire Ball Attack
bowserFireBreath.initialize(gamePtr->getGraphics(), bowserNS::WIDTH,
bowserNS::HEIGHT, 0, textureM);
if (!bowserFireBreath.initialize(bowserSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing bowser"));
bowserFireBreath.setFrames(bowserNS::FIRE_BREATH_START_FRAME, bowserNS::FIRE_BREATH_END_FRAME);
bowserFireBreath.setCurrentFrame(bowserNS::FIRE_BREATH_START_FRAME);
bowserFireBreath.setFrameDelay(bowserNS::FIRE_BREATH_ANIMATION_DELAY);
//Dying
bowserDying.initialize(gamePtr->getGraphics(), bowserNS::WIDTH,
bowserNS::HEIGHT, 0, textureM);
if (!bowserDying.initialize(bowserSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing bowser"));
bowserDying.setFrames(bowserNS::DYING_START_FRAME, bowserNS::DYING_END_FRAME);
bowserDying.setCurrentFrame(bowserNS::DYING_START_FRAME);
bowserDying.setFrameDelay(bowserNS::DYING_ANIMATION_DELAY);
bowserDying.setLoop(false);
return(Entity::initialize(gamePtr, width, height, ncols, textureM));
}
int main(){
initializeCoords();
fillBoard();
#ifdef _DEBUG
for(int index=0;index<100;index++)
printf("%d\t",get(coords[index].row,coords[index].col));
printf("\n");
#endif
int caseNum;
scanf("%d",&caseNum);
while(caseNum--){
int index;
scanf("%d",&index);
printf("%d\n",get(coords[index-1].row,coords[index-1].col));
}
return 0;
}
//=============================================================================
// Initialize Mega Man.
// Post: returns true if successful, false if failed
//=============================================================================
bool chargingSprites::initialize(Game *gamePtr, int width, int height, int ncols,
TextureManager *textureM)
{
// chargingSprites shooting sprite initialize
megamanShootingSpriteCoordinates.populateVector("sprite_data\\xshootcoords.txt");
if (!initializeCoords(megamanShootingSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing chargingSprites"));
megamanCharge1.initialize(gamePtr->getGraphics(), chargingSpritesNS::WIDTH,
chargingSpritesNS::HEIGHT, 0, textureM);
if (!megamanCharge1.initialize(megamanShootingSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing chargingSprites"));
megamanCharge1.setFrames(chargingSpritesNS::CHARGE1_MEGAMAN_START_FRAME, chargingSpritesNS::CHARGE1_MEGAMAN_END_FRAME);
megamanCharge1.setCurrentFrame(chargingSpritesNS::CHARGE1_MEGAMAN_START_FRAME);
megamanCharge1.setFrameDelay(chargingSpritesNS::CHARGE1_MEGAMAN_ANIMATION_DELAY);
return(Entity::initialize(gamePtr, width, height, ncols, textureM));
}
//=============================================================================
// Initialize Mega Man.
// Post: returns true if successful, false if failed
//=============================================================================
bool Megaman::initialize(Game *gamePtr, int width, int height, int ncols,
TextureManager *textureM)
{
// megaman sprite initialize
megamanSpriteCoordinates.populateVector("sprite_data\\mmx4.xml");
if (!initializeCoords(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
//Idle
megamanIdle.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanIdle.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanIdle.setFrames(megamanNS::IDLE_MEGAMAN_START_FRAME, megamanNS::IDLE_MEGAMAN_END_FRAME);
megamanIdle.setCurrentFrame(megamanNS::IDLE_MEGAMAN_START_FRAME);
megamanIdle.setFrameDelay(megamanNS::IDLE_MEGAMAN_ANIMATION_DELAY);
//Walking
megamanWalking.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanWalking.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanWalking.setFrames(megamanNS::WALKING_MEGAMAN_START_FRAME, megamanNS::WALKING_MEGAMAN_END_FRAME);
megamanWalking.setCurrentFrame(megamanNS::WALKING_MEGAMAN_START_FRAME);
megamanWalking.setFrameDelay(megamanNS::WALKING_MEGAMAN_ANIMATION_DELAY);
//Jumping Up
megamanJumping.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanJumping.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanJumping.setFrames(megamanNS::JUMPING_MEGAMAN_START_FRAME, megamanNS::JUMPING_MEGAMAN_END_FRAME);
megamanJumping.setCurrentFrame(megamanNS::JUMPING_MEGAMAN_START_FRAME);
megamanJumping.setFrameDelay(megamanNS::JUMPING_MEGAMAN_ANIMATION_DELAY);
megamanJumping.setLoop(false);
//Jump Peak
megamanJumpPeak.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanJumpPeak.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanJumpPeak.setFrames(megamanNS::JUMP_PEAK_MEGAMAN_START_FRAME, megamanNS::JUMP_PEAK_MEGAMAN_END_FRAME);
megamanJumpPeak.setCurrentFrame(megamanNS::JUMP_PEAK_MEGAMAN_START_FRAME);
megamanJumpPeak.setFrameDelay(megamanNS::JUMP_PEAK_MEGAMAN_ANIMATION_DELAY);
//Falling
megamanFalling.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanFalling.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanFalling.setFrames(megamanNS::FALLING_MEGAMAN_START_FRAME, megamanNS::FALLING_MEGAMAN_END_FRAME);
megamanFalling.setCurrentFrame(megamanNS::FALLING_MEGAMAN_START_FRAME);
megamanFalling.setFrameDelay(megamanNS::FALLING_MEGAMAN_ANIMATION_DELAY);
//Shooting - Idle
megamanShooting.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanShooting.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanShooting.setFrames(megamanNS::SHOOTING_MEGAMAN_START_FRAME, megamanNS::SHOOTING_MEGAMAN_END_FRAME);
megamanShooting.setCurrentFrame(megamanNS::SHOOTING_MEGAMAN_START_FRAME);
megamanShooting.setFrameDelay(megamanNS::SHOOTING_MEGAMAN_ANIMATION_DELAY);
//Shooting & Jumping
megamanShootingJump.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanShootingJump.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanShootingJump.setFrames(megamanNS::SHOOTING_JUMP_MEGAMAN_START_FRAME, megamanNS::SHOOTING_JUMP_MEGAMAN_END_FRAME);
megamanShootingJump.setCurrentFrame(megamanNS::SHOOTING_JUMP_MEGAMAN_START_FRAME);
megamanShootingJump.setFrameDelay(megamanNS::SHOOTING_JUMP_MEGAMAN_ANIMATION_DELAY);
megamanShootingJump.setLoop(false);
//Shooting & Jump Peak
megamanShootingJumpPeak.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanShootingJumpPeak.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanShootingJumpPeak.setFrames(megamanNS::SHOOTING_JUMP_PEAK_MEGAMAN_START_FRAME, megamanNS::SHOOTING_JUMP_PEAK_MEGAMAN_END_FRAME);
megamanShootingJumpPeak.setCurrentFrame(megamanNS::SHOOTING_JUMP_PEAK_MEGAMAN_START_FRAME);
megamanShootingJumpPeak.setFrameDelay(megamanNS::SHOOTING_JUMP_PEAK_MEGAMAN_ANIMATION_DELAY);
//Shooting and falling
megamanShootingFalling.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanShootingFalling.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanShootingFalling.setFrames(megamanNS::SHOOTING_FALLING_MEGAMAN_START_FRAME, megamanNS::SHOOTING_FALLING_MEGAMAN_END_FRAME);
megamanShootingFalling.setCurrentFrame(megamanNS::SHOOTING_FALLING_MEGAMAN_START_FRAME);
megamanShootingFalling.setFrameDelay(megamanNS::SHOOTING_FALLING_MEGAMAN_ANIMATION_DELAY);
megamanShootingFalling.setLoop(false);
//Dashing
megamanDashing.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanDashing.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanDashing.setFrames(megamanNS::DASHING_MEGAMAN_START_FRAME, megamanNS::DASHING_MEGAMAN_END_FRAME);
megamanDashing.setCurrentFrame(megamanNS::DASHING_MEGAMAN_START_FRAME);
megamanDashing.setFrameDelay(megamanNS::DASHING_MEGAMAN_ANIMATION_DELAY);
//Walking and shooting // Needs to modify sprite sheet for this to work
megamanShootingWalking.initialize(gamePtr->getGraphics(), megamanNS::WIDTH, // Could possible work by modifying currentFrame when updating frames
megamanNS::HEIGHT, 0, textureM);
if (!megamanShootingWalking.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanShootingWalking.setFrames(megamanNS::SHOOTING_WALKING_MEGAMAN_START_FRAME, megamanNS::SHOOTING_WALKING_MEGAMAN_END_FRAME);
megamanShootingWalking.setCurrentFrame(megamanNS::SHOOTING_WALKING_MEGAMAN_START_FRAME);
megamanShootingWalking.setFrameDelay(megamanNS::SHOOTING_WALKING_MEGAMAN_ANIMATION_DELAY);
//Dashing and shooting
megamanShootingDashing.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanShootingDashing.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanShootingDashing.setFrames(megamanNS::SHOOTING_DASHING_MEGAMAN_START_FRAME, megamanNS::SHOOTING_DASHING_MEGAMAN_END_FRAME);
megamanShootingDashing.setCurrentFrame(megamanNS::SHOOTING_DASHING_MEGAMAN_START_FRAME);
megamanShootingDashing.setFrameDelay(megamanNS::SHOOTING_DASHING_MEGAMAN_ANIMATION_DELAY);
//Sliding down a wall
megamanWallSliding.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanWallSliding.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanWallSliding.setFrames(megamanNS::WALL_SLIDING_MEGAMAN_START_FRAME, megamanNS::WALL_SLIDING_MEGAMAN_END_FRAME);
megamanWallSliding.setCurrentFrame(megamanNS::WALL_SLIDING_MEGAMAN_START_FRAME);
megamanWallSliding.setFrameDelay(megamanNS::WALL_SLIDING_MEGAMAN_ANIMATION_DELAY);
//Taking damage
megamanDamaged.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanDamaged.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanDamaged.setFrames(megamanNS::DAMAGED_MEGAMAN_START_FRAME, megamanNS::DAMAGED_MEGAMAN_END_FRAME);
megamanDamaged.setCurrentFrame(megamanNS::DAMAGED_MEGAMAN_START_FRAME);
megamanDamaged.setFrameDelay(megamanNS::DAMAGED_MEGAMAN_ANIMATION_DELAY);
//Dying
megamanDying.initialize(gamePtr->getGraphics(), megamanNS::WIDTH,
megamanNS::HEIGHT, 0, textureM);
if (!megamanDying.initialize(megamanSpriteCoordinates))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing megaman"));
megamanDying.setFrames(megamanNS::DYING_MEGAMAN_START_FRAME, megamanNS::DYING_MEGAMAN_END_FRAME);
megamanDying.setCurrentFrame(megamanNS::DYING_MEGAMAN_START_FRAME);
megamanDying.setFrameDelay(megamanNS::DYING_MEGAMAN_ANIMATION_DELAY);
megamanDying.setLoop(false);
return(Entity::initialize(gamePtr, width, height, ncols, textureM));
}
