public override void Update(GameTime gameTime, Rectangle clientBounds,
UnfailableHeartSpriteManager spriteManager)
{
speed.Y += 1.5f;
base.Update(gameTime, clientBounds, spriteManager);
}
public override void Update(GameTime gameTime, Rectangle clientBounds,
UnfailableHeartSpriteManager spriteManager)
{
if (speed.X != 0)
position += new Vector2(speed.X - spriteManager.shiftingSpeed.X, speed.Y);
base.Update(gameTime, clientBounds, spriteManager);
}
public virtual void Update(GameTime gameTime, Rectangle clientBounds,
UnfailableHeartSpriteManager spriteManager)
{
timeSinceLastFrame += gameTime.ElapsedGameTime.Milliseconds;
if (timeSinceLastFrame > millisecondsPerFrame)
{
timeSinceLastFrame -= millisecondsPerFrame;
currentFrame.X++;
if (currentFrame.X >= sheetSizes[textureIndex].X)
{
currentFrame.X = 0;
currentFrame.Y++;
if (currentFrame.Y >= sheetSizes[textureIndex].Y)
currentFrame.Y = 0;
}
}
}
public override void Update(GameTime gameTime, Rectangle clientBounds, UnfailableHeartSpriteManager spriteManager)
{
position += -spriteManager.shiftingSpeed;
if (currentState == State.consuming)
{
ChangeTextureAnimated(1);
duration -= gameTime.ElapsedGameTime.Milliseconds;
if (duration <= 0)
currentState = State.consume;
}
base.Update(gameTime, clientBounds, spriteManager);
}
// the obstacles are static relative to the background
public override void Update(GameTime gameTime, Rectangle clientBounds, UnfailableHeartSpriteManager spriteManager)
{
speedOfLastUpdate = speed = -spriteManager.shiftingSpeed;
position += speed;
base.Update(gameTime, clientBounds, spriteManager);
}
public override void Update(GameTime gameTime, Rectangle clientBounds,
UnfailableHeartSpriteManager spriteManager)
{
Rectangle playerCollisionRect = GetCollisionRect();
// Figure out what is the player's base before updating speed
if (!blockDirections[3] && status != Status.TURBO)
{
baseLineY = groundLineY;
}
DetectStatus();
StatusOrientedUpdate(gameTime, spriteManager);
if (FACINATED)
{
fancyTimer += gameTime.ElapsedGameTime.Milliseconds;
if (fancyTimer > timeToResumeFromFancy)
{
fancyTimer = 0;
FACINATED = false;
}
// Walk in an invertive pattern
speedOfLastUpdate = new Vector2(accelerometerDataY * speed.X, speed.Y);
}
else
{
speedOfLastUpdate = new Vector2(-accelerometerDataY * speed.X, speed.Y);
}
if ((blockDirections[0] && speedOfLastUpdate.X + spriteManager.shiftingSpeed.X < 0)
|| (blockDirections[1] && speedOfLastUpdate.X + spriteManager.shiftingSpeed.X > 0 )
|| status == Status.FALLING)
{
speedOfLastUpdate.X = -spriteManager.shiftingSpeed.X;
}
if (blockDirections[2] && speed.Y < 0)
{
speedOfLastUpdate.Y = 0;
}
if ((playerCollisionRect.Left - 45 >= clientBounds.Left && playerCollisionRect.Right + 5 <= clientBounds.Right)
|| (playerCollisionRect.Left - 45 < clientBounds.Left && speedOfLastUpdate.X > 0)
|| (playerCollisionRect.Right + 5 > clientBounds.Right && speedOfLastUpdate.X < 0)
|| blockDirections[1] || status == Status.FALLING)
{
position.X += speedOfLastUpdate.X;
}
position.Y += speedOfLastUpdate.Y;
base.Update(gameTime, clientBounds, spriteManager);
}
private void StatusOrientedUpdate(GameTime gameTime,
UnfailableHeartSpriteManager spriteManager)
{
switch (status)
{
case Status.FORWARDING:
if (statusChanged)
{
ChangeTextureAnimated(0);
speed = new Vector2(FORWARDING_SPEED_X, speed.Y);
statusChanged = false;
}
speed.Y++;
if (position.Y + speed.Y > baseLineY)
{
position.Y = baseLineY;
speed.Y = 0;
}
break;
case Status.BACKWARDING:
if (statusChanged)
{
ChangeTextureAnimated(1);
speed = new Vector2(BACKWARDING_SPEED_X, speed.Y);
statusChanged = false;
}
speed.Y++;
if (position.Y + speed.Y > baseLineY)
{
position.Y = baseLineY;
speed.Y = 0;
}
break;
case Status.CHARGING:
if (statusChanged)
{
ChangeTextureAnimated(2);
chargingTimer = 0;
statusChanged = false;
}
else
{
chargingTimer += gameTime.ElapsedGameTime.Milliseconds;
if (chargingTimer > chargingTime)
{
status = Status.JUMPING;
statusChanged = true;
}
}
break;
case Status.JUMPING:
if (statusChanged)
{
collisionSound.Play();
ChangeTextureAnimated(3);
speed = new Vector2(speed.X, JUMPING_INITIAL_SPEED_Y);
statusChanged = false;
}
else
{
speed.Y++;
if (position.Y + speed.Y > baseLineY)
{
position.Y = baseLineY;
speed.Y = 0;
status = Status.FORWARDING;
statusChanged = true;
}
}
break;
case Status.ATTACKING:
if (statusChanged)
{
// spawn a shot
spriteManager.SpawnShot(position, shotSpeed);
ChangeTextureAnimated(4);
statusChanged = false;
attackingTimer = 0;
}
else
{
attackingTimer += gameTime.ElapsedGameTime.Milliseconds;
if (attackingTimer > timeToStopAttack)
{
if (preStatus == Status.JUMPING)
{
ChangeTextureAnimated(3);
status = Status.JUMPING;
}
else
{
status = Status.FORWARDING;
statusChanged = true;
}
}
}
speed.Y++;
if (position.Y + speed.Y > baseLineY)
{
position.Y = baseLineY;
speed.Y = 0;
}
break;
case Status.BEATEN:
if (statusChanged)
{
ChangeTextureAnimated(5);
statusChanged = false;
beatenTimer = 0;
vibrateController.Start(TimeSpan.FromMilliseconds(100));
}
else
{
beatenTimer += gameTime.ElapsedGameTime.Milliseconds;
if (beatenTimer > timeToResumeFromBeaten)
{
if (preStatus == Status.JUMPING)
{
ChangeTextureAnimated(3);
status = Status.JUMPING;
}
else
{
status = Status.FORWARDING;
statusChanged = true;
}
}
}
speed.Y++;
if (position.Y + speed.Y > baseLineY)
{
position.Y = baseLineY;
speed.Y = 0;
}
break;
case Status.FALLING:
if (statusChanged)
{
ChangeTextureAnimated(6);
fallOverTimer = 0;
statusChanged = false;
vibrateController.Start(TimeSpan.FromMilliseconds(200));
}
else
{
fallOverTimer += gameTime.ElapsedGameTime.Milliseconds;
if (fallOverTimer > timeToResumeFromFallingOver)
{
if (preStatus == Status.JUMPING)
{
ChangeTextureAnimated(3);
status = Status.JUMPING;
}
else
{
status = Status.FORWARDING;
statusChanged = true;
}
}
}
speed.Y++;
if (position.Y + speed.Y > baseLineY)
{
position.Y = baseLineY;
speed.Y = 0;
}
break;
case Status.TURBO:
if (statusChanged)
{
baseLineY = turboLineY;
ChangeTextureAnimated(7);
statusChanged = false;
}
speed.Y++;
if (position.Y + speed.Y > baseLineY)
{
position.Y = baseLineY;
speed.Y = 0;
}
break;
}
}
private void InvokeTheSecondGame()
{
onceThrough = false;
isOpening = true;
isTouched = false;
Content.Unload();
Components.Remove(upRisingSpriteManger);
upRisingSpriteManger = null;
unfailableHeartSpriteManager = new UnfailableHeartSpriteManager(this);
Components.Add(unfailableHeartSpriteManager);
unfailableHeartSpriteManager.Enabled = false;
unfailableHeartSpriteManager.Visible = false;
upRisingSpriteManger = new UpRisingSpriteManager(this);
graphics.SupportedOrientations = DisplayOrientation.LandscapeLeft;
graphics.PreferredBackBufferWidth = Level.PreferredBackBufferHeight;
graphics.PreferredBackBufferHeight = Level.PreferredBackBufferWidth;
graphics.ApplyChanges();
}
private void InvokeTheFirstGame()
{
Content.Unload();
Components.Remove(unfailableHeartSpriteManager);
unfailableHeartSpriteManager = null;
Components.Add(upRisingSpriteManger);
graphics.SupportedOrientations = DisplayOrientation.Portrait;
graphics.PreferredBackBufferWidth = Level.PreferredBackBufferWidth;
graphics.PreferredBackBufferHeight = Level.PreferredBackBufferHeight;
graphics.ApplyChanges();
onceThrough = true;
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
unfailableHeartSpriteManager = new UnfailableHeartSpriteManager(this);
Components.Add(unfailableHeartSpriteManager);
unfailableHeartSpriteManager.Enabled = false;
unfailableHeartSpriteManager.Visible = false;
upRisingSpriteManger = new UpRisingSpriteManager(this);
rnd = new Random();
base.Initialize();
}
//bullet will fly out every shotDelay time
private void FireShots(GameTime gameTime, UnfailableHeartSpriteManager spriteManager, Vector2 playerPos)
{
if (shotCountdown <= 0)
{
ChangeTextureAnimated(1);
//the bullet's speed set to be the enemy's speed*8
Vector2 shotSpeed = - (13 * Vector2.UnitX + 20 * Vector2.UnitY);
spriteManager.SpawnEnemyShot(position, shotSpeed);
shotCountdown = shotDelay;
}
else
shotCountdown -= gameTime.ElapsedGameTime.Milliseconds;
}
//it may attack the player when it is close enough
//it may cast a weapon
//it may be out of the visible world
//it may get zapped by the player
//refresh the state in time
public override void Update(GameTime gameTime, Rectangle clientBounds, UnfailableHeartSpriteManager spriteManager)
{
if (enemyType == Type.RED)
{
Vector2 playerPos = spriteManager.GetPlayerPos();
refreshStatusAccordingTo(playerPos);
if (stateChanged == true)
{
if (currentGameState == Status.IDLE)
{
//play walking movie
ChangeTextureAnimated(0);
}
else if (currentGameState == Status.ATTACKING)
{
//play attacking movie
//ChangeTextureAnimated(1);
}
else if (currentGameState == Status.DYING)
{
//play the attacked last frame
ChangeTextureAnimated(2);
}
stateChanged = false;
}
if (currentGameState == Status.ATTACKING)
{
//some bullets will fly out
FireShots(gameTime, spriteManager, playerPos);
restoreToIdleImage(gameTime);
}
if (currentGameState == Status.DYING)
{
//change to DEAD state after 2sec
DyingToDead(gameTime);
}
position += -spriteManager.shiftingSpeed;
}
else // Muddy Green
{
// Muddy green moves when it's alive
if (currentGameState == Status.IDLE)
{
if (isTransparent)
{
transparentTimer += gameTime.ElapsedGameTime.Milliseconds;
if (transparentTimer > transparentTimeMilliseconds)
{
transparentTimer = 0;
isTransparent = false;
}
}
position += (-spriteManager.shiftingSpeed + speed * direction);
if (!isReturning)
{
speed.X -= .1f;
if (speed.X <= 0)
{
ChangeTextureAnimated((textureIndex + 1) % 2);
direction = -direction;
isReturning = true;
}
}
else
{
speed.X += .1f;
if (speed.X > defaultSpeed.X)
{
speed = defaultSpeed;
isReturning = false;
}
}
}
else if (currentGameState == Status.DYING)
{
if (stateChanged)
{
if (direction.X < 0)
ChangeTextureAnimated(2);
else
ChangeTextureAnimated(3);
}
// Make it static relative to the background
position += -spriteManager.shiftingSpeed;
dyingTimer += gameTime.ElapsedGameTime.Milliseconds;
if (dyingTimer > dyingDelay)
{
currentGameState = Status.DEAD;
}
}
}
base.Update(gameTime, clientBounds, spriteManager);
}
