/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotMilliseconds > firingDelay)
{
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
Projectile projectile = new Projectile(ProjectileType.TeddyBear,
Game1.GetProjectileSprite(ProjectileType.TeddyBear),
drawRectangle.Center.X,
drawRectangle.Center.Y + GameConstants.TeddyBearProjectileOffset,
GetProjectileYVelocity());
Game1.AddProjectile(projectile);
shootSound.Play();
}
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
// timer concept (for animations) introduced in Chapter 7
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotMilliseconds > firingDelay)
{
// shoot
Texture2D projectileSprite = Game1.GetProjectileSprite(ProjectileType.TeddyBear);
int xLocation = drawRectangle.Center.X;
int yLocation = drawRectangle.Bottom + GameConstants.TeddyBearProjectileOffset;
Projectile teddyProjectile = new Projectile(ProjectileType.TeddyBear, projectileSprite,
xLocation, yLocation, GetProjectileYVelocity());
Game1.AddProjectile(teddyProjectile);
shootSound.Play();
// reset firing
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
}
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
this.drawRectangle.X += (int)(this.velocity.X * gameTime.ElapsedGameTime.Milliseconds);
this.drawRectangle.Y += (int)(this.velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
this.elapsedShotTime += gameTime.ElapsedGameTime.Milliseconds;
if (this.elapsedShotTime > this.firingDelay)
{
this.elapsedShotTime = 0;
this.firingDelay = GetRandomFiringDelay();
//create a projectile and add it to Game1
Projectile projectile = new Projectile(ProjectileType.TeddyBear,
Game1.GetProjectileSprite(ProjectileType.TeddyBear),
this.drawRectangle.Center.X,
this.drawRectangle.Center.Y + GameConstants.TEDDY_BEAR_PROJECTILE_OFFSET,
GetProjectileYVelocity());
Game1.AddProjectile(projectile);
//play shoot sound
this.shootSound.Play(0.3f, 0.0f, 0.0f);
}
// timer concept (for animations) introduced in Chapter 7
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
// timer concept (for animations) introduced in Chapter 7
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotMilliseconds > firingDelay)
{
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
Projectile teddybear = new Projectile(ProjectileType.TeddyBear,
Game1.GetProjectileSprite(ProjectileType.TeddyBear),
drawRectangle.Center.X,
drawRectangle.Center.Y + GameConstants.TeddyBearProjectileOffset,
GameConstants.TeddyBearProjectileSpeed);
Game1.AddProjectile(teddybear);
}
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
// firing teddy projectile
if (elapsedShotMilliseconds > firingDelay)
{
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
// creating projectile
ProjectileType teddyProjectile = ProjectileType.TeddyBear;
int x = drawRectangle.Center.X;
int y = drawRectangle.Center.Y + GameConstants.TeddyBearProjectileOffset;
Projectile projectile = new Projectile(teddyProjectile, Game1.GetProjectileSprite(teddyProjectile), x, y, -GetProjectileYVelocity());
Game1.AddProjectile(projectile);
// adding sound efect
shootSound.Play();
}
// timer concept (for animations) introduced in Chapter 7
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotMilliseconds > firingDelay)
{
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
Texture2D projectileSprite = Game1.GetProjectileSprite(projectileType);
int projectileY = drawRectangle.Center.Y + GameConstants.TeddyBearProjectileOffset;
Projectile projectile = new Projectile(projectileType, projectileSprite, drawRectangle.Center.X, projectileY, -GetProjectileYVelocity());
Game1.AddProjectile(projectile);
// use instance to lower volume as it was horrible
SoundEffectInstance instance = shootSound.CreateInstance();
instance.Volume = 0.2f;
instance.Play();
}
// timer concept (for animations) introduced in Chapter 7
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X *
gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y *
gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotMilliseconds > firingDelay)
{
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
Projectile projectile = new Projectile(ProjectileType.TeddyBear, Game1.GetProjectileSprite(ProjectileType.TeddyBear),
drawRectangle.X + drawRectangle.Width / 2, drawRectangle.Y + drawRectangle.Height / 2 + GameConstants.TeddyBearProjectileOffset,
-GetProjectileYVelocity());
Game1.AddProjectile(projectile);
shootSound.Play(0.3f, 0f, 0f);
}
// timer concept (for animations) introduced in Chapter 7
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
// timer concept (for animations) introduced in Chapter 7
elapsedShotTime += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotTime > firingDelay)
{
elapsedShotTime = 0;
firingDelay = GetRandomFiringDelay();
Projectile projectile = new Projectile(ProjectileType.TeddyBear, Game1.GetProjectileSprite(ProjectileType.TeddyBear),
drawRectangle.Center.X, drawRectangle.Center.Y + GameConstants.TEDDY_BEAR_PROJECTILE_OFFSET,
GetProjectileYVelocity());
Game1.AddProjectile(projectile);
shootSound.Play();
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (this.health <= 0)
{
return;
}
// move burger using mouse
drawRectangle.X = mouse.X - drawRectangle.Width / 2;
drawRectangle.Y = mouse.Y - drawRectangle.Height / 2;
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.Bottom > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowWidth - drawRectangle.Height;
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
if ((mouse.LeftButton == ButtonState.Pressed) && (canShoot))
{
Projectile projectile = new Projectile(ProjectileType.FrenchFries,
Game1.GetProjectileSprite(ProjectileType.FrenchFries), drawRectangle.Center.X,
drawRectangle.Center.Y - GameConstants.FrenchFriesProjectileOffset,
-GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(projectile);
canShoot = false;
}
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds ||
mouse.LeftButton == ButtonState.Released)
{
elapsedCooldownMilliseconds = 0;
canShoot = true;
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
drawRectangle.X = mouse.Position.X;
drawRectangle.Y = mouse.Position.Y;
// clamp burger in window
if (drawRectangle.X < 0)
{
drawRectangle.X = 0;
}
else if (drawRectangle.X + drawRectangle.Width > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Y < 0)
{
drawRectangle.Y = 0;
}
else if ((drawRectangle.Y + drawRectangle.Height) > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds)
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
// shoot if appropriate
if (mouse.LeftButton == ButtonState.Pressed)
{
if (canShoot)
{
canShoot = false;
Projectile frenchFries = new Projectile(ProjectileType.FrenchFries,
Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.Center.X,
drawRectangle.Center.Y - GameConstants.FrenchFriesProjectileOffset,
-1 * GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(frenchFries);
}
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
drawRectangle.X = mouse.X - drawRectangle.Width / 2;
drawRectangle.Y = mouse.Y - drawRectangle.Height / 2;
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
else if (drawRectangle.Right > GameConstants.WINDOW_WIDTH)
{
drawRectangle.X = GameConstants.WINDOW_WIDTH - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
else if (drawRectangle.Bottom > GameConstants.WINDOW_HEIGHT)
{
drawRectangle.Y = GameConstants.WINDOW_HEIGHT - drawRectangle.Height;
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
if (!canShoot)
{
elapsedCooldownTime += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownTime >= GameConstants.BURGER_COOLDOWN_MILLISECONDS ||
mouse.LeftButton == ButtonState.Released)
{
canShoot = true;
elapsedCooldownTime = 0;
}
}
// shoot if appropriate
if (health > 0 &&
mouse.LeftButton == ButtonState.Pressed &&
canShoot)
{
canShoot = false;
Projectile projectile = new Projectile(ProjectileType.FrenchFries,
Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.Center.X,
drawRectangle.Center.Y - GameConstants.FRENCH_FRIES_PROJECTILE_OFFSET,
-GameConstants.FRENCH_FRIES_PROJECTILE_SPEED);
Game1.AddProjectile(projectile);
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
drawRectangle.X = mouse.X;
drawRectangle.Y = mouse.Y;
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Top > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
if (drawRectangle.Bottom < 0)
{
drawRectangle.Y = 0;
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
if (mouse.LeftButton == ButtonState.Pressed && canShoot)
{
canShoot = false;
Texture2D projectileTexture = Game1.GetProjectileSprite(ProjectileType.FrenchFries);
float yVelocity = GameConstants.FrenchFriesProjectileSpeed;
Projectile frenchProjectile = new Projectile(ProjectileType.FrenchFries, projectileTexture,
(mouse.X + (sprite.Width) / 2), mouse.Y, yVelocity);
Game1.AddProjectile(frenchProjectile);
}
// shoot if appropriate
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds >= GameConstants.BurgerTotalCooldownMilliseconds && mouse.LeftButton == ButtonState.Pressed)
{
elapsedCooldownMilliseconds = 0;
canShoot = true;
}
}
}
}
/// <summary>
/// Updates the burger's location based on keyboard WSAD. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState key)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
int x, y;
// clamp burger in window
x = key.IsKeyDown(Keys.A) ? -GameConstants.BurgerMovementAmount : 0;
x = key.IsKeyDown(Keys.D) ? +GameConstants.BurgerMovementAmount : x;
y = key.IsKeyDown(Keys.W) ? -GameConstants.BurgerMovementAmount : 0;
y = key.IsKeyDown(Keys.S) ? +GameConstants.BurgerMovementAmount : y;
x += drawRectangle.X;
y += drawRectangle.Y;
x = Math.Max(x, 0);
y = Math.Max(y, 0);
x = Math.Min(x, GameConstants.WindowWidth - drawRectangle.Width);
y = Math.Min(y, GameConstants.WindowHeight - drawRectangle.Height);
drawRectangle.X = x;
drawRectangle.Y = y;
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
if (key.IsKeyDown(Keys.Space) && canShoot)
{
Projectile prj = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.Center.X, drawRectangle.Center.Y + GameConstants.FrenchFriesProjectileOffset,
-GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(prj);
canShoot = false;
shootSound.Play();
}
// shoot if appropriate
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds || key.IsKeyUp(Keys.Space))
{
elapsedCooldownMilliseconds = 0;
canShoot = true;
}
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
// move burger using mouse
if (health > 0)
{
if ((mouse.X > 0) && (mouse.X < GameConstants.WINDOW_WIDTH - 10))
{
drawRectangle.X = mouse.X;
}
if ((mouse.Y > 0) && (mouse.Y < GameConstants.WINDOW_HEIGHT - 10))
{
drawRectangle.Y = mouse.Y;
}
}
if (health > 0 && canShoot == true && mouse.LeftButton == ButtonState.Pressed)
{
Projectile projectile = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries), drawRectangle.X, drawRectangle.Y - GameConstants.FRENCH_FRIES_PROJECTILE_OFFSET, GameConstants.TEDDY_BEAR_PROJECTILE_SPEED);
canShoot = false;
Game1.AddProjectile(projectile);
}
if (canShoot == false)
{
elapsedCooldownTime += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownTime >= GameConstants.BURGER_COOLDOWN_MILLISECONDS)
{
canShoot = true;
elapsedCooldownTime = 0;
}
else if (mouse.LeftButton == ButtonState.Released)
{
canShoot = true;
}
}
// clamp burger in window
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update_mouse(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
int x = mouse.X, y = mouse.Y;
// clamp burger in window
x = Math.Max(x, 0);
y = Math.Max(y, 0);
x = Math.Min(x, GameConstants.WindowWidth - drawRectangle.Width);
y = Math.Min(y, GameConstants.WindowHeight - drawRectangle.Height);
drawRectangle.X = x;
drawRectangle.Y = y;
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
if (mouse.LeftButton == ButtonState.Pressed && canShoot)
{
Projectile prj = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.Center.X, drawRectangle.Center.Y + GameConstants.FrenchFriesProjectileOffset,
-GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(prj);
canShoot = false;
}
// shoot if appropriate
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds || mouse.LeftButton == ButtonState.Released)
{
elapsedCooldownMilliseconds = 0;
canShoot = true;
}
}
}
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
// timer concept (for animations) introduced in Chapter 7
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotMilliseconds >= firingDelay)
{
//reset elapsed shot time and give new value to firing delay
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
//create x and y for projectiles
int projectileX = drawRectangle.X + drawRectangle.Width / 2;
int projectileY = drawRectangle.Y + drawRectangle.Height / 2 + GameConstants.TeddyBearProjectileOffset;
//create new projectile and add it
Projectile newProjectile = new Projectile(ProjectileType.TeddyBear, Game1.GetProjectileSprite(ProjectileType.TeddyBear),
projectileX, projectileY, GetProjectileYVelocity());
//add projectile
Game1.AddProjectile(newProjectile);
//play shooting sound if not null
if (shootSound != null)
{
shootSound.Play();
}
}
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
this.drawRectangle.X += (int)(gameTime.ElapsedGameTime.Milliseconds * this.velocity.X);
this.drawRectangle.Y += (int)(gameTime.ElapsedGameTime.Milliseconds * this.velocity.Y);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
elapsedShotTime += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotTime > firingDelay)
{
elapsedShotTime = 0;
firingDelay = GetRandomFiringDelay();
Game1.AddProjectile(new Projectile(ProjectileType.TeddyBear,
Game1.GetProjectileSprite(ProjectileType.TeddyBear),
this.drawRectangle.X + this.drawRectangle.Width / 2,
this.drawRectangle.Y + this.drawRectangle.Height / 2 + GameConstants.TEDDY_BEAR_PROJECTILE_OFFSET,
-GameConstants.TEDDY_BEAR_PROJECTILE_SPEED));
this.shootSound.Play();
}
// timer concept (for animations) introduced in Chapter 7
}
/// <summary>
/// Updates the teddy bear's location, bouncing if necessary. Also has
/// the teddy bear fire a projectile when it's time to
/// </summary>
/// <param name="gameTime">game time</param>
public void Update(GameTime gameTime)
{
// move the teddy bear
drawRectangle.X += (int)(velocity.X * gameTime.ElapsedGameTime.Milliseconds);
drawRectangle.Y += (int)(velocity.Y * gameTime.ElapsedGameTime.Milliseconds);
// bounce as necessary
BounceTopBottom();
BounceLeftRight();
// fire projectile as appropriate
// timer concept (for animations) introduced in Chapter 7
elapsedShotMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedShotMilliseconds >= firingDelay)
{
elapsedShotMilliseconds = 0;
firingDelay = GetRandomFiringDelay();
Projectile teddyProjectile = new Projectile(ProjectileType.TeddyBear, Game1.GetProjectileSprite(ProjectileType.TeddyBear),
(drawRectangle.X + sprite.Width / 2), (drawRectangle.Y + sprite.Height), -GetProjectileYVelocity());
Game1.AddProjectile(teddyProjectile);
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState keyboard)
{
// burger should only respond to input if it still has health
if (health > 0)
{
//drawRectangle.X = mouse.X-sprite.Width/2;
//drawRectangle.Y = mouse.Y-sprite.Height/2;
//// clamp burger in window
//if (drawRectangle.Left < 0)
// drawRectangle.X = 0;
//else if (drawRectangle.Right > GameConstants.WINDOW_WIDTH - drawRectangle.Width)
// drawRectangle.X = GameConstants.WINDOW_WIDTH - drawRectangle.Width;
//if (drawRectangle.Top < 0)
// drawRectangle.Y = 0;
//else if (drawRectangle.Bottom > GameConstants.WINDOW_HEIGHT - drawRectangle.Height)
// drawRectangle.Y = GameConstants.WINDOW_HEIGHT - drawRectangle.Height;
// move burger using keyboard
if (keyboard.IsKeyDown(Keys.Up) || keyboard.IsKeyDown(Keys.W))
{
Y -= GameConstants.BURGER_MOVEMENT_AMOUNT;
}
if (keyboard.IsKeyDown(Keys.Down) || keyboard.IsKeyDown(Keys.S))
{
Y += GameConstants.BURGER_MOVEMENT_AMOUNT;
}
if (keyboard.IsKeyDown(Keys.Right) || keyboard.IsKeyDown(Keys.D))
{
X += GameConstants.BURGER_MOVEMENT_AMOUNT;
}
if (keyboard.IsKeyDown(Keys.Left) || keyboard.IsKeyDown(Keys.A))
{
X -= GameConstants.BURGER_MOVEMENT_AMOUNT;
}
//update shooting allowed
// timer concept (for animations) introduced in Chapter 7
if (!canShoot)
{
elapsedCooldownTime += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownTime >= GameConstants.BURGER_COOLDOWN_MILLISECONDS)// || mouse.LeftButton == ButtonState.Released)
{
canShoot = true;
elapsedCooldownTime = 0;
}
}
// shoot if appropriate
if (keyboard.IsKeyDown(Keys.Space) && canShoot)
{
canShoot = false;
Projectile fprojectile = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.Center.X, drawRectangle.Center.Y - GameConstants.FRENCH_FRIES_PROJECTILE_OFFSET,
-GameConstants.FRENCH_FRIES_PROJECTILE_SPEED);
Game1.AddProjectile(fprojectile);
shootSound.Play();
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState key)
{
MouseState mouse = Mouse.GetState();
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using keyboard
if (key.IsKeyDown(Keys.W) || key.IsKeyDown(Keys.Up))
{
drawRectangle.Y -= GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.S) || key.IsKeyDown(Keys.Down))
{
drawRectangle.Y += GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.A) || key.IsKeyDown(Keys.Left))
{
drawRectangle.X -= GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.D) || key.IsKeyDown(Keys.Right))
{
drawRectangle.X += GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.Space) && shooting == false)
{
shooting = true;
makeShot = true;
}
else
{
makeShot = false;
}
if (key.IsKeyUp(Keys.Space) && shooting == true)
{
shooting = false;
}
}
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.Bottom > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
// update shooting allowed
if (canShoot == false)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds >= GameConstants.BurgerTotalCooldownMilliseconds || mouse.LeftButton == ButtonState.Released)
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
}
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
if (health > 0)
{
if ((mouse.LeftButton == ButtonState.Pressed || makeShot == true) && canShoot == true)
{
canShoot = false;
Projectile frenchFriesProjectile = new Projectile(ProjectileType.FrenchFries,
sprite: Game1.GetProjectileSprite(ProjectileType.FrenchFries),
x: drawRectangle.Center.X,
y: drawRectangle.Center.Y - GameConstants.FrenchFriesProjectileOffset,
yVelocity: -GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(frenchFriesProjectile);
shootSound.Play();
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="keyBoard">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState keyBoard)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
//drawRectangle.X = keyBoard.X - (drawRectangle.Width / 2);
//drawRectangle.Y = keyBoard.Y - (drawRectangle.Height / 2);
// move burger using Keyboard
if (keyBoard.IsKeyDown(Keys.W))
{
drawRectangle.Y -= GameConstants.BurgerMovementAmount;
}
if (keyBoard.IsKeyDown(Keys.S))
{
drawRectangle.Y += GameConstants.BurgerMovementAmount;
}
if (keyBoard.IsKeyDown(Keys.A))
{
drawRectangle.X -= GameConstants.BurgerMovementAmount;
}
if (keyBoard.IsKeyDown(Keys.D))
{
drawRectangle.X += GameConstants.BurgerMovementAmount;
}
// clamp burger in window
//Right Clamp
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
//Left Clamp
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
//Bottom Clamp
if (drawRectangle.Bottom > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
//Top Clamp
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
// update shooting allowed
if (keyBoard.IsKeyDown(Keys.Space) && canShoot)
{
canShoot = false;
//Projectile initialization
projectile = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(
ProjectileType.FrenchFries), drawRectangle.X + drawRectangle.Width / 2,
drawRectangle.Y - GameConstants.FrenchFriesProjectileOffset,
GameConstants.FrenchFriesProjectileSpeed);
//Adding Projectile
Game1.AddProjectile(projectile);
//play shoot soundEffects
shootSound.Play();
}
// timer concept (for animations) introduced in Chapter 7
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
}
// shoot if appropriate
if (elapsedCooldownMilliseconds >= GameConstants.BurgerTotalCooldownMilliseconds || keyBoard.IsKeyUp(Keys.Space))
{
elapsedCooldownMilliseconds = 0;
canShoot = true;
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState keyboard)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
//drawRectangle.X = mouse.X - drawRectangle.Width / 2;
//drawRectangle.Y = mouse.Y - drawRectangle.Height / 2;
// move burger using keyboard
if (keyboard.IsKeyDown(Keys.Right))
{
drawRectangle.X += GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.Left))
{
drawRectangle.X -= GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.Up))
{
drawRectangle.Y -= GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.Down))
{
drawRectangle.Y += GameConstants.BurgerMovementAmount;
}
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.Bottom > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
// update shooting allowed
//if (mouse.LeftButton == ButtonState.Pressed && canShoot)
if (keyboard.IsKeyDown(Keys.Space) && canShoot)
{
canShoot = false;
Projectile frenchFries = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.X - GameConstants.FrenchFriesProjectileOffset, drawRectangle.Y - GameConstants.FrenchFriesProjectileOffset,
GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(frenchFries);
shootSound.Play();
}
if (canShoot == false)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
}
// timer concept (for animations) introduced in Chapter 7
//if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds
//|| mouse.LeftButton == ButtonState.Released)
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds || keyboard.IsKeyUp(Keys.Space))
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
// shoot if appropriate
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
drawRectangle.X = mouse.X - drawRectangle.Width / 2;
drawRectangle.Y = mouse.Y - drawRectangle.Height / 2;
// clamp burger in window
if (drawRectangle.X < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Y < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.X + drawRectangle.Width > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Y + drawRectangle.Height > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
if (health > 0 && mouse.LeftButton == ButtonState.Pressed && canShoot)
{
Projectile frenchfrie = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries), (int)drawRectangle.Center.X, (int)drawRectangle.Y + GameConstants.FrenchFriesProjectileOffset, GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(frenchfrie);
canShoot = false;
}
// update shooting allowed
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (GameConstants.BurgerTotalCooldownMilliseconds <= elapsedCooldownMilliseconds || mouse.LeftButton == ButtonState.Released)
{
elapsedCooldownMilliseconds = 0;
canShoot = true;
}
}
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState keyboard)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using keyboard W(up)A(left)S(down)D(right)
if (keyboard.IsKeyDown(Keys.W))
{
drawRectangle.Y -= GameConstants.BURGER_MOVEMENT_AMOUNT;
}
if (keyboard.IsKeyDown(Keys.S))
{
drawRectangle.Y += GameConstants.BURGER_MOVEMENT_AMOUNT;
}
if (keyboard.IsKeyDown(Keys.A))
{
drawRectangle.X -= GameConstants.BURGER_MOVEMENT_AMOUNT;
}
if (keyboard.IsKeyDown(Keys.D))
{
drawRectangle.X += GameConstants.BURGER_MOVEMENT_AMOUNT;
}
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WINDOW_WIDTH)
{
drawRectangle.X = GameConstants.WINDOW_WIDTH - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.Bottom > GameConstants.WINDOW_HEIGHT)
{
drawRectangle.Y = GameConstants.WINDOW_HEIGHT - drawRectangle.Height;
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
if (canShoot == true && keyboard.IsKeyDown(Keys.Space))
{
canShoot = false;
Projectile frechfriesprojectile = new Projectile(ProjectileType.FrenchFries,
Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.X + drawRectangle.Width * 1 / 2,
drawRectangle.Y - GameConstants.FRENCH_FRIES_PROJECTILE_OFFSET,
GameConstants.FRENCH_FRIES_PROJECTILE_SPEED);
Game1.AddProjectile(frechfriesprojectile);
shootSound.Play();
}
// shoot if appropriate
if (canShoot == false)
{
elapsedCooldownTime += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownTime > GameConstants.BURGER_COOLDOWN_MILLISECONDS || keyboard.IsKeyUp(Keys.Space))
{
elapsedCooldownTime = 0;
canShoot = true;
}
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (Health > 0)
{
drawRectangle.X = mouse.X - sprite.Width / 2;
drawRectangle.Y = mouse.Y - sprite.Height / 2;
}
// move burger using mouse
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.Bottom > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
// update shooting allowed
if (canShoot == false)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds && mouse.LeftButton == ButtonState.Released)
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
}
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
if (canShoot && Health > 0)
{
if (mouse.LeftButton == ButtonState.Pressed)
{
float projectileVelocity = GameConstants.FrenchFriesProjectileSpeed;
int projectileLocationX = drawRectangle.Center.X;//In order to make it centered horizontally (barely).
int projectileLocationY = drawRectangle.Center.Y + GameConstants.FrenchFriesProjectileOffset;
Projectile burgerAmmo = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries), projectileLocationX, projectileLocationY - GameConstants.FrenchFriesProjectileOffset, -projectileVelocity);
Game1.AddProjectile(burgerAmmo);
canShoot = false;
shootSound.Play();
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="keyboard">the current state of the keyboard</param>
public void Update(GameTime gameTime, KeyboardState keyboard)
{
// burger should only respond to input if it still has health
if (health > 0)
{
if (keyboard.IsKeyDown(Keys.D) || keyboard.IsKeyDown(Keys.Left))
{
drawRectangle.X += GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.A) || keyboard.IsKeyDown(Keys.Right))
{
drawRectangle.X -= GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.W) || keyboard.IsKeyDown(Keys.Up))
{
drawRectangle.Y -= GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.S) || keyboard.IsKeyDown(Keys.Down))
{
drawRectangle.Y += GameConstants.BurgerMovementAmount;
}
// clamp burger in window
// Y
if (drawRectangle.Y < 0)
{
drawRectangle.Y = 0;
}
else if ((drawRectangle.Y + drawRectangle.Height) > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
// X
if (drawRectangle.X < 0)
{
drawRectangle.X = 0;
}
else if ((drawRectangle.X + drawRectangle.Width) > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
if (canShoot && keyboard.IsKeyDown(Keys.Space))
{
canShoot = false;
// creating projectile
ProjectileType frenchProjectile = ProjectileType.FrenchFries;
int x = drawRectangle.Center.X;
int y = drawRectangle.Center.Y - GameConstants.FrenchFriesProjectileOffset;
Projectile projectile = new Projectile(frenchProjectile, Game1.GetProjectileSprite(frenchProjectile), x, y, GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(projectile);
// adding sound effect
shootSound.Play();
}
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
// Enable canShoot
if (elapsedCooldownMilliseconds >= GameConstants.BurgerTotalCooldownMilliseconds || keyboard.IsKeyUp(Keys.Space))
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState key)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
//drawRectangle.X = mouse.X - sprite.Width / 2;
//drawRectangle.Y = mouse.Y - sprite.Height / 2;
//Move burger using WASD
if (key.IsKeyDown(Keys.W))
{
drawRectangle.Y -= GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.S))
{
drawRectangle.Y += GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.A))
{
drawRectangle.X -= GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.D))
{
drawRectangle.X += GameConstants.BurgerMovementAmount;
}
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.Bottom > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds >= GameConstants.BurgerTotalCooldownMilliseconds && key.IsKeyDown(Keys.Space))
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
}
// shoot if appropriate
if (key.IsKeyDown(Keys.Space) && canShoot)
{
canShoot = false;
Projectile newProjectile = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries),
drawRectangle.Center.X, drawRectangle.Center.Y - GameConstants.FrenchFriesProjectileOffset, GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(newProjectile);
shootSound.Play();
}
}
/// <summary>
/// Updates the burger's location based on keyboard. Also fires with space
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState keyboard)
{
// burger should only respond to input if it still has health
if (this.health <= 0)
{
return;
}
// move burger using keyboard
if (keyboard.IsKeyDown(Keys.Right))
{
drawRectangle.X += GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.Left))
{
drawRectangle.X -= GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.Up))
{
drawRectangle.Y -= GameConstants.BurgerMovementAmount;
}
if (keyboard.IsKeyDown(Keys.Down))
{
drawRectangle.Y += GameConstants.BurgerMovementAmount;
}
// clamp burger in window
if (drawRectangle.Left < 0)
{
drawRectangle.X = 0;
}
if (drawRectangle.Right > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - drawRectangle.Width;
}
if (drawRectangle.Top < 0)
{
drawRectangle.Y = 0;
}
if (drawRectangle.Bottom > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - drawRectangle.Height;
}
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
if ((keyboard.IsKeyDown(Keys.Space)) && (canShoot))
{
Projectile projectile = new Projectile(ProjectileType.FrenchFries,
Game1.GetProjectileSprite(ProjectileType.FrenchFries), drawRectangle.Center.X,
drawRectangle.Center.Y - GameConstants.FrenchFriesProjectileOffset,
-GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(projectile);
shootSound.Play();
canShoot = false;
}
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds ||
keyboard.IsKeyUp(Keys.Space))
{
elapsedCooldownMilliseconds = 0;
canShoot = true;
}
}
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, MouseState mouse)
{
// burger should only respond to input if it still has health
if (this.health > 0)
{
// move burger using mouse
this.drawRectangle.X = mouse.X;
this.drawRectangle.Y = mouse.Y;
// clamp burger in window
if (drawRectangle.X < 0)
{
drawRectangle.X = 0;
}
if ((drawRectangle.Y + sprite.Height) > GameConstants.WindowHeight)
{
drawRectangle.Y = GameConstants.WindowHeight - sprite.Height;
}
if ((drawRectangle.X + sprite.Width) > GameConstants.WindowWidth)
{
drawRectangle.X = GameConstants.WindowWidth - sprite.Width;
}
if (drawRectangle.Y < 0)
{
drawRectangle.Y = 0;
}
if (mouse.LeftButton == ButtonState.Pressed && canShoot)
{
canShoot = false;
Projectile projectile = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries),
this.drawRectangle.X + sprite.Width / 2,
(this.drawRectangle.Y + GameConstants.FrenchFriesProjectileOffset),
GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(projectile);
}
// update shooting allowed
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if ((elapsedCooldownMilliseconds >= GameConstants.BurgerTotalCooldownMilliseconds) || mouse.LeftButton != ButtonState.Pressed)
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
}
}
// move burger using mouse - Done up there
// clamp burger in window - Done up there
// update shooting allowed - Done up there
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
}
/// <summary>
/// Updates the burger's location based on mouse. Also fires
/// french fries as appropriate
/// </summary>
/// <param name="gameTime">game time</param>
/// <param name="mouse">the current state of the mouse</param>
public void Update(GameTime gameTime, KeyboardState key)
{
// burger should only respond to input if it still has health
if (health > 0)
{
// move burger using mouse
if (key.IsKeyDown(Keys.W) && drawRectangle.Y - GameConstants.BurgerMovementAmount > 0)
{
drawRectangle.Y -= GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.A) && drawRectangle.X - GameConstants.BurgerMovementAmount > 0)
{
drawRectangle.X -= GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.S) && drawRectangle.Y + sprite.Height + GameConstants.BurgerMovementAmount < GameConstants.WindowHeight)
{
drawRectangle.Y += GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.D) && drawRectangle.X + sprite.Width + GameConstants.BurgerMovementAmount < GameConstants.WindowWidth)
{
drawRectangle.X += GameConstants.BurgerMovementAmount;
}
if (key.IsKeyDown(Keys.Space) && canShoot)
{
Projectile NewProjectile = new Projectile(ProjectileType.FrenchFries, Game1.GetProjectileSprite(ProjectileType.FrenchFries), drawRectangle.X + GameConstants.FrenchFriesProjectileOffset, drawRectangle.Y + GameConstants.FrenchFriesProjectileOffset, GameConstants.FrenchFriesProjectileSpeed);
Game1.AddProjectile(NewProjectile);
canShoot = false;
shootSound.Play();
}
if (!canShoot)
{
elapsedCooldownMilliseconds += gameTime.ElapsedGameTime.Milliseconds;
if (elapsedCooldownMilliseconds > GameConstants.BurgerTotalCooldownMilliseconds)
{
canShoot = true;
elapsedCooldownMilliseconds = 0;
}
}
if (!key.IsKeyDown(Keys.Space))
{
canShoot = true;
}
}
// clamp burger in window
// update shooting allowed
// timer concept (for animations) introduced in Chapter 7
// shoot if appropriate
}