BadGuy Class Reference

Base class for moving sprites that can hurt the Player. More...

#include <badguy.hpp>

Inherits MovingSprite.

Inherited by AngryStone, Bomb, BouncingSnowball, Dart, DartTrap, Dispenser, Fish, Flame, FlyingSnowBall, GhostTree, Jumpy, KamikazeSnowball, Kugelblitz, Mole, MoleRock, Owl, Plant, Root, SkullyHop, SkyDive, SpiderMite, Stalactite, Toad, Totem, TreeWillOWisp, WalkingBadguy, WillOWisp, Yeti, and Zeekling.

List of all members.

Public Member Functions
	BadGuy (const Vector &pos, const std::string &sprite_name, int layer=LAYER_OBJECTS)
	BadGuy (const Vector &pos, Direction direction, const std::string &sprite_name, int layer=LAYER_OBJECTS)
	BadGuy (const Reader &reader, const std::string &sprite_name, int layer=LAYER_OBJECTS)
virtual void	draw (DrawingContext &context)
	Called when the badguy is drawn.
virtual void	update (float elapsed_time)
	Called each frame.
virtual HitResponse	collision (GameObject &other, const CollisionHit &hit)
	Called when a collision with another object occurred.
virtual void	collision_tile (uint32_t tile_attributes)
	Called when a collision with tile with special attributes occurred.
virtual void	kill_fall ()
	Set the badguy to kill/falling state, which makes him falling of the screen (his sprite is turned upside-down).
virtual void	run_dead_script ()
	Call this, if you use custom kill_fall() or kill_squashed(GameObject& object).
virtual bool	can_break ()
	True if this badguy can break bricks or open bonusblocks in his current form.
Vector	get_start_position () const
void	set_start_position (const Vector &vec)
virtual void	ignite ()
	Called when hit by a fire bullet, and is_flammable() returns true.
virtual void	extinguish ()
	Called to revert a badguy when is_ignited() returns true.
virtual bool	is_flammable () const
	Returns whether to call ignite() when a badguy gets hit by a fire bullet.
bool	is_ignited () const
	Returns whether this badguys is currently on fire.
virtual void	freeze ()
	Called when hit by an ice bullet, and is_freezable() returns true.
virtual void	unfreeze ()
	Called to unfreeze the badguy.
virtual bool	is_freezable () const
bool	is_frozen () const
Public Attributes
bool	countMe
	Count this badguy to the statistics? This value should not be changed during runtime.
Protected Types
enum	State {   STATE_INIT, STATE_INACTIVE, STATE_ACTIVE, STATE_SQUISHED,   STATE_FALLING }
Protected Member Functions
virtual HitResponse	collision_player (Player &player, const CollisionHit &hit)
	Called when the badguy collided with a player.
virtual void	collision_solid (const CollisionHit &hit)
	Called when the badguy collided with solid ground.
virtual HitResponse	collision_badguy (BadGuy &other, const CollisionHit &hit)
	Called when the badguy collided with another badguy.
virtual bool	collision_squished (GameObject &object)
	Called when the player hit the badguy from above.
virtual HitResponse	collision_bullet (Bullet &bullet, const CollisionHit &hit)
	Called when the badguy collided with a bullet.
virtual void	active_update (float elapsed_time)
	called each frame when the badguy is activated.
virtual void	inactive_update (float elapsed_time)
	called each frame when the badguy is not activated.
virtual void	initialize ()
	called immediately before the first call to initialize
virtual void	activate ()
	called when the badguy has been activated.
virtual void	deactivate ()
	called when the badguy has been deactivated
void	kill_squished (GameObject &object)
void	set_state (State state)
State	get_state () const
bool	check_state_timer ()
Player *	get_nearest_player ()
	returns a pointer to the nearest player or 0 if no player is available
bool	is_offscreen ()
	initial position of the enemy.
bool	might_fall (int height=1)
	Returns true if we might soon fall at least height pixels.
Direction	str2dir (std::string dir_str)
	Get Direction from String.
void	update_on_ground_flag (const CollisionHit &hit)
	Update on_ground_flag judging by solid collision hit.
bool	on_ground ()
	Returns true if we touched ground in the past frame This only works if update_on_ground_flag() gets called in collision_solid.
Vector	get_floor_normal ()
	Returns floor normal stored the last time when update_on_ground_flag was called and we touched something solid from above.
bool	is_active ()
	Returns true if we were in STATE_ACTIVE at the beginning of the last call to update().
void	set_colgroup_active (CollisionGroup group)
	changes colgroup_active.
Protected Attributes
Physic	physic
bool	is_initialized
	true if initialize() has already been called
Vector	start_position
Direction	dir
	The direction we currently face in.
Direction	start_dir
	The direction we initially faced in.
bool	frozen
bool	ignited
	true if this badguy is currently on fire
std::string	dead_script
	script to execute when badguy is killed
Private Member Functions
void	try_activate ()
	BadGuy (const BadGuy &)
BadGuy &	operator= (const BadGuy &)
Private Attributes
State	state
bool	is_active_flag
	true if state was STATE_ACTIVE at the beginning of the last call to update()
Timer	state_timer
bool	on_ground_flag
	true if we touched something solid from above and update_on_ground_flag was called last frame
Vector	floor_normal
	floor normal stored the last time when update_on_ground_flag was called and we touched something solid from above
CollisionGroup	colgroup_active
	CollisionGroup the badguy should be in while active.

---

Detailed Description

Base class for moving sprites that can hurt the Player.

Definition at line 29 of file badguy.hpp.

---

Member Enumeration Documentation

enum BadGuy::State [protected]

Enumerator:

STATE_INIT
STATE_INACTIVE
STATE_ACTIVE
STATE_SQUISHED
STATE_FALLING

Reimplemented in Bomb, DartTrap, and Snail.

Definition at line 100 of file badguy.hpp.

             {
    STATE_INIT,
    STATE_INACTIVE,
    STATE_ACTIVE,
    STATE_SQUISHED,
    STATE_FALLING
  };

---

Constructor & Destructor Documentation

BadGuy::BadGuy	(	const Vector &	pos,
		const std::string &	sprite_name,
		int	layer = LAYER_OBJECTS
	)

Definition at line 35 of file badguy.cpp.

References AUTO, MovingObject::bbox, dir, LEFT, Rectf::p1, SoundManager::preload(), sound_manager, start_dir, and start_position.

                                                                         :
  MovingSprite(pos, sprite_name, layer, COLGROUP_DISABLED), 
  physic(),
  countMe(true), 
  is_initialized(false),
  start_position(),
  dir(LEFT), 
  start_dir(AUTO), 
  frozen(false), 
  ignited(false),
  dead_script(),
  state(STATE_INIT), 
  is_active_flag(),
  state_timer(),
  on_ground_flag(false),
  floor_normal(),
  colgroup_active(COLGROUP_MOVING)
{
  start_position = bbox.p1;

  sound_manager->preload("sounds/squish.wav");
  sound_manager->preload("sounds/fall.wav");

  dir = (start_dir == AUTO) ? LEFT : start_dir;
}

BadGuy::BadGuy	(	const Vector &	pos,
		Direction	direction,
		const std::string &	sprite_name,
		int	layer = LAYER_OBJECTS
	)

Definition at line 61 of file badguy.cpp.

References AUTO, MovingObject::bbox, dir, LEFT, Rectf::p1, SoundManager::preload(), sound_manager, start_dir, and start_position.

                                                                                              :
  MovingSprite(pos, sprite_name, layer, COLGROUP_DISABLED), 
  physic(),
  countMe(true), 
  is_initialized(false), 
  start_position(),
  dir(direction), 
  start_dir(direction), 
  frozen(false), 
  ignited(false),
  dead_script(),
  state(STATE_INIT), 
  is_active_flag(),
  state_timer(),
  on_ground_flag(false), 
  floor_normal(),
  colgroup_active(COLGROUP_MOVING)
{
  start_position = bbox.p1;

  sound_manager->preload("sounds/squish.wav");
  sound_manager->preload("sounds/fall.wav");

  dir = (start_dir == AUTO) ? LEFT : start_dir;
}

BadGuy::BadGuy	(	const Reader &	reader,
		const std::string &	sprite_name,
		int	layer = LAYER_OBJECTS
	)

Definition at line 87 of file badguy.cpp.

References AUTO, MovingObject::bbox, dead_script, dir, lisp::Lisp::get(), LEFT, Rectf::p1, SoundManager::preload(), sound_manager, start_dir, start_position, and str2dir().

                                                                            :
  MovingSprite(reader, sprite_name, layer, COLGROUP_DISABLED), 
  physic(),
  countMe(true), 
  is_initialized(false), 
  start_position(),
  dir(LEFT), 
  start_dir(AUTO),
  frozen(false), 
  ignited(false), 
  dead_script(),
  state(STATE_INIT), 
  is_active_flag(),
  state_timer(),
  on_ground_flag(false), 
  floor_normal(),
  colgroup_active(COLGROUP_MOVING)
{
  start_position = bbox.p1;

  std::string dir_str = "auto";
  reader.get("direction", dir_str);
  start_dir = str2dir( dir_str );
  dir = start_dir;

  reader.get("dead-script", dead_script);

  sound_manager->preload("sounds/squish.wav");
  sound_manager->preload("sounds/fall.wav");

  dir = (start_dir == AUTO) ? LEFT : start_dir;
}

BadGuy::BadGuy

(

const BadGuy &

)

[private]

---

Member Function Documentation

void BadGuy::draw

(

DrawingContext &

context

)

[virtual]

Called when the badguy is drawn.

The default implementation simply draws the badguy sprite on screen

Reimplemented from MovingSprite.

Reimplemented in Fish, GhostTree, Root, Stalactite, TreeWillOWisp, WillOWisp, and Yeti.

Definition at line 121 of file badguy.cpp.

References DrawingContext::get_drawing_effect(), MovingObject::get_pos(), MovingSprite::layer, DrawingContext::set_drawing_effect(), MovingSprite::sprite, state, STATE_FALLING, STATE_INACTIVE, STATE_INIT, and VERTICAL_FLIP.

Referenced by Yeti::draw(), Root::draw(), and GhostTree::draw().

{
  if(!sprite.get())
    return;
  if(state == STATE_INIT || state == STATE_INACTIVE)
    return;
  if(state == STATE_FALLING) {
    DrawingEffect old_effect = context.get_drawing_effect();
    context.set_drawing_effect((DrawingEffect) (old_effect | VERTICAL_FLIP));
    sprite->draw(context, get_pos(), layer);
    context.set_drawing_effect(old_effect);
  } else {
    sprite->draw(context, get_pos(), layer);
  }
}

void BadGuy::update

(

float

elapsed_time

)

[virtual]

Called each frame.

The default implementation checks badguy state and calls active_update and inactive_update

Reimplemented from MovingSprite.

Reimplemented in YetiStalactite.

Definition at line 138 of file badguy.cpp.

References active_update(), MovingObject::bbox, Timer::check(), Sector::current(), deactivate(), Physic::get_movement(), inactive_update(), is_active_flag, is_offscreen(), MovingObject::movement, on_ground_flag, physic, GameObject::remove_me(), set_state(), state, STATE_ACTIVE, STATE_FALLING, STATE_INACTIVE, STATE_INIT, STATE_SQUISHED, state_timer, and try_activate().

Referenced by YetiStalactite::update().

{
  if(!Sector::current()->inside(bbox)) {
    is_active_flag = false;
    remove_me();
    return;
  }
  if ((state != STATE_INACTIVE) && is_offscreen()) {
    if (state == STATE_ACTIVE) deactivate();
    set_state(STATE_INACTIVE);
  }

  switch(state) {
    case STATE_ACTIVE:
      is_active_flag = true;
      active_update(elapsed_time);
      break;
    case STATE_INIT:
    case STATE_INACTIVE:
      is_active_flag = false;
      inactive_update(elapsed_time);
      try_activate();
      break;
    case STATE_SQUISHED:
      is_active_flag = false;
      if(state_timer.check()) {
        remove_me();
        break;
      }
      movement = physic.get_movement(elapsed_time);
      break;
    case STATE_FALLING:
      is_active_flag = false;
      movement = physic.get_movement(elapsed_time);
      break;
  }

  on_ground_flag = false;
}

HitResponse BadGuy::collision	(	GameObject &	other,
		const CollisionHit &	hit
	)			[virtual]

Called when a collision with another object occurred.

The default implementation calls collision_player, collision_solid, collision_badguy and collision_squished

Implements MovingObject.

Reimplemented in Dispenser, GhostTree, Haywire, MrBomb, and MrIceBlock.

Definition at line 236 of file badguy.cpp.

References ABORT_MOVE, MovingObject::bbox, COLGROUP_MOVING, collision_badguy(), collision_bullet(), collision_player(), collision_squished(), FORCE_MOVE, MovingObject::get_bbox(), MovingObject::get_group(), is_active(), Rectf::p1, Rectf::p2, and Vector::y.

Referenced by MrIceBlock::collision(), MrBomb::collision(), and Haywire::collision().

{
  if (!is_active()) return ABORT_MOVE;

  BadGuy* badguy = dynamic_cast<BadGuy*> (&other);
  if(badguy && badguy->is_active() && badguy->get_group() == COLGROUP_MOVING) {

    /* Badguys don't let badguys squish other badguys. It's bad. */
#if 0
    // hit from above?
    if (badguy->get_bbox().p2.y < (bbox.p1.y + 16)) {
      if(collision_squished(*badguy)) {
        return ABORT_MOVE;
      }
    }
#endif

    return collision_badguy(*badguy, hit);
  }

  Player* player = dynamic_cast<Player*> (&other);
  if(player) {

    // hit from above?
    if (player->get_bbox().p2.y < (bbox.p1.y + 16)) {
      if(collision_squished(*player)) {
        return FORCE_MOVE;
      }
    }

    return collision_player(*player, hit);
  }

  Bullet* bullet = dynamic_cast<Bullet*> (&other);
  if(bullet)
    return collision_bullet(*bullet, hit);

  return FORCE_MOVE;
}

void BadGuy::collision_tile

(

uint32_t

tile_attributes

)

[virtual]

Called when a collision with tile with special attributes occurred.

Reimplemented from MovingObject.

Reimplemented in Fish.

Definition at line 220 of file badguy.cpp.

References Tile::FIRE, freeze(), Tile::HURTS, Tile::ICE, ignite(), is_flammable(), is_freezable(), and kill_fall().

{
  if(tile_attributes & Tile::HURTS) {
    if (tile_attributes & Tile::FIRE) {
      if (is_flammable()) ignite();
    }
    else if (tile_attributes & Tile::ICE) {
      if (is_freezable()) freeze();
    }
    else {
      kill_fall();
    }
  }
}

void BadGuy::kill_fall

(

)

[virtual]

Set the badguy to kill/falling state, which makes him falling of the screen (his sprite is turned upside-down).

Reimplemented in AngryStone, Bomb, Flame, GhostTree, Haywire, Kugelblitz, Mole, MrBomb, Root, ShortFuse, Stalactite, Totem, TreeWillOWisp, WillOWisp, and Yeti.

Definition at line 375 of file badguy.cpp.

References Physic::enable_gravity(), MovingObject::get_pos(), physic, SoundManager::play(), run_dead_script(), Physic::set_acceleration_y(), set_state(), Physic::set_velocity_y(), sound_manager, and STATE_FALLING.

Referenced by IceCrusher::collision(), HurtingPlatform::collision(), Explosion::collision(), Block::collision(), MoleRock::collision_badguy(), Kugelblitz::collision_badguy(), Dart::collision_badguy(), AngryStone::collision_badguy(), collision_player(), Snail::collision_squished(), Owl::collision_squished(), MrIceBlock::collision_squished(), collision_tile(), ignite(), Totem::kill_fall(), and WalkingBadguy::turn_around().

{
  sound_manager->play("sounds/fall.wav", get_pos());
  physic.set_velocity_y(0);
  physic.set_acceleration_y(0);
  physic.enable_gravity(true);
  set_state(STATE_FALLING);

  // start dead-script
  run_dead_script();
}

void BadGuy::run_dead_script

(

)

[virtual]

Call this, if you use custom kill_fall() or kill_squashed(GameObject& object).

Definition at line 388 of file badguy.cpp.

References Statistics::badguys, countMe, Sector::current(), dead_script, Sector::get_level(), Sector::run_script(), and Level::stats.

Referenced by Mole::collision_squished(), Bomb::explode(), KamikazeSnowball::kill_collision(), ShortFuse::kill_fall(), MrBomb::kill_fall(), Mole::kill_fall(), Haywire::kill_fall(), kill_fall(), kill_squished(), Stalactite::squish(), and Yeti::take_hit().

{
  if (countMe)
    Sector::current()->get_level()->stats.badguys++;

  countMe = false;
   
  // start dead-script
  if(dead_script != "") {
    std::istringstream stream(dead_script);
    Sector::current()->run_script(stream, "dead-script");
  }
}

virtual bool BadGuy::can_break

(

)

[inline, virtual]

True if this badguy can break bricks or open bonusblocks in his current form.

Reimplemented in MrIceBlock, and Snail.

Definition at line 62 of file badguy.hpp.

Referenced by Brick::collision(), and BonusBlock::collision().

  {
    return false;
  }

Vector BadGuy::get_start_position

(

)

const [inline]

Definition at line 67 of file badguy.hpp.

References start_position.

Referenced by FlipLevelTransformer::transform_badguy().

  {
    return start_position;
  }

void BadGuy::set_start_position

(

const Vector &

vec

)

[inline]

Definition at line 72 of file badguy.hpp.

References start_position.

Referenced by FlipLevelTransformer::transform_badguy().

  {
    start_position = vec;
  }

void BadGuy::ignite

(

)

[virtual]

Called when hit by a fire bullet, and is_flammable() returns true.

Definition at line 555 of file badguy.cpp.

References kill_fall().

Referenced by collision_bullet(), and collision_tile().

{
  kill_fall();
}

void BadGuy::extinguish

(

)

[virtual]

Called to revert a badguy when is_ignited() returns true.

Definition at line 561 of file badguy.cpp.

Referenced by collision_bullet().

{
}

bool BadGuy::is_flammable

(

)

const [virtual]

Returns whether to call ignite() when a badguy gets hit by a fire bullet.

Reimplemented in GhostTree, Root, TreeWillOWisp, and WillOWisp.

Definition at line 566 of file badguy.cpp.

Referenced by collision_bullet(), and collision_tile().

{
  return true;
}

bool BadGuy::is_ignited

(

)

const

Returns whether this badguys is currently on fire.

Definition at line 572 of file badguy.cpp.

References ignited.

Referenced by collision_bullet().

{
  return ignited;
}

void BadGuy::freeze

(

)

[virtual]

Called when hit by an ice bullet, and is_freezable() returns true.

Reimplemented in Dispenser, Fish, Haywire, Jumpy, MrBomb, Spiky, SSpiky, and WalkingBadguy.

Definition at line 529 of file badguy.cpp.

References COLGROUP_MOVING_STATIC, frozen, and MovingObject::set_group().

Referenced by collision_bullet(), collision_tile(), WalkingBadguy::freeze(), Jumpy::freeze(), Fish::freeze(), and Dispenser::freeze().

{
  set_group(COLGROUP_MOVING_STATIC);
  frozen = true;
}

void BadGuy::unfreeze

(

)

[virtual]

Called to unfreeze the badguy.

Reimplemented in Dispenser, Fish, and WalkingBadguy.

Definition at line 536 of file badguy.cpp.

References colgroup_active, frozen, and MovingObject::set_group().

Referenced by collision_bullet(), collision_player(), WalkingBadguy::unfreeze(), Fish::unfreeze(), and Dispenser::unfreeze().

{
  set_group(colgroup_active);
  frozen = false;
}

bool BadGuy::is_freezable

(

)

const [virtual]

Reimplemented in Dispenser, Fish, GhostTree, Haywire, Jumpy, MrBomb, Root, Spiky, SSpiky, TreeWillOWisp, and WillOWisp.

Definition at line 543 of file badguy.cpp.

Referenced by collision_bullet(), and collision_tile().

{
  return false;
}

bool BadGuy::is_frozen

(

)

const

Definition at line 549 of file badguy.cpp.

References frozen.

Referenced by collision_bullet().

{
  return frozen;
}

HitResponse BadGuy::collision_player	(	Player &	player,
		const CollisionHit &	hit
	)			[protected, virtual]

Called when the badguy collided with a player.

Reimplemented in Bomb, Dart, DartTrap, Haywire, KamikazeSnowball, Kugelblitz, MoleRock, MrBomb, MrIceBlock, ShortFuse, SkyDive, Snail, Stalactite, TreeWillOWisp, and WillOWisp.

Definition at line 285 of file badguy.cpp.

References ABORT_MOVE, FORCE_MOVE, frozen, Player::is_invincible(), Player::kill(), kill_fall(), and unfreeze().

Referenced by collision(), TreeWillOWisp::collision_player(), Snail::collision_player(), MrIceBlock::collision_player(), MrBomb::collision_player(), MoleRock::collision_player(), KamikazeSnowball::collision_player(), Haywire::collision_player(), and Dart::collision_player().

{
  if(player.is_invincible()) {
    kill_fall();
    return ABORT_MOVE;
  }

  if(frozen)
    unfreeze();
  player.kill(false);
  return FORCE_MOVE;
}

void BadGuy::collision_solid

(

const CollisionHit &

hit

)

[protected, virtual]

Called when the badguy collided with solid ground.

Reimplemented from MovingObject.

Reimplemented in AngryStone, Bomb, BouncingSnowball, CaptainSnowball, Dart, Fish, FlyingSnowBall, Jumpy, KamikazeSnowball, Kugelblitz, MoleRock, MrIceBlock, Owl, Plant, SkullyHop, SkyDive, Snail, SpiderMite, SSpiky, Stalactite, Stumpy, Toad, Totem, WalkingBadguy, Yeti, and Zeekling.

Definition at line 277 of file badguy.cpp.

References physic, Physic::set_velocity_x(), Physic::set_velocity_y(), and update_on_ground_flag().

Referenced by Toad::collision_solid(), SSpiky::collision_solid(), and SkullyHop::collision_solid().

{
  physic.set_velocity_x(0);
  physic.set_velocity_y(0);
  update_on_ground_flag(hit);
}

HitResponse BadGuy::collision_badguy	(	BadGuy &	other,
		const CollisionHit &	hit
	)			[protected, virtual]

Called when the badguy collided with another badguy.

Reimplemented in AngryStone, Bomb, BouncingSnowball, Dart, Fish, Jumpy, Kugelblitz, Mole, MoleRock, MrIceBlock, Plant, SkullyHop, SkyDive, Snail, SSpiky, Stalactite, Stumpy, Toad, Totem, and WalkingBadguy.

Definition at line 299 of file badguy.cpp.

References FORCE_MOVE.

Referenced by collision(), Stalactite::collision_badguy(), and SSpiky::collision_badguy().

{
  return FORCE_MOVE;
}

bool BadGuy::collision_squished

(

GameObject &

object

)

[protected, virtual]

Called when the player hit the badguy from above.

You should return true if the badguy was squished, false if squishing wasn't possible

Reimplemented in BouncingSnowball, CaptainSnowball, Crystallo, Dispenser, FlyingSnowBall, Haywire, Igel, KamikazeSnowball, Mole, MrBomb, MrIceBlock, MrTree, Owl, PoisonIvy, ShortFuse, SkullyHop, SkyDive, SmartBall, Snail, SnowBall, Snowman, SpiderMite, Stumpy, Toad, Totem, WalkingLeaf, Yeti, and Zeekling.

Definition at line 305 of file badguy.cpp.

Referenced by collision(), and Kugelblitz::collision_player().

{
  return false;
}

HitResponse BadGuy::collision_bullet	(	Bullet &	bullet,
		const CollisionHit &	hit
	)			[protected, virtual]

Called when the badguy collided with a bullet.

Reimplemented in Igel.

Definition at line 311 of file badguy.cpp.

References ABORT_MOVE, extinguish(), FIRE_BONUS, FORCE_MOVE, freeze(), Bullet::get_type(), ICE_BONUS, ignite(), is_flammable(), is_freezable(), is_frozen(), is_ignited(), GameObject::remove_me(), Bullet::ricochet(), and unfreeze().

Referenced by Dispenser::collision(), collision(), and Igel::collision_bullet().

{
  if (is_frozen()) {
    if(bullet.get_type() == FIRE_BONUS) {
      // fire bullet thaws frozen badguys
      unfreeze();
      bullet.remove_me();
      return ABORT_MOVE;
    } else {
      // other bullets ricochet
      bullet.ricochet(*this, hit);
      return FORCE_MOVE;
    }
  }
  else if (is_ignited()) {
    if(bullet.get_type() == ICE_BONUS) {
      // ice bullets extinguish ignited badguys
      extinguish();
      bullet.remove_me();
      return ABORT_MOVE;
    } else {
      // other bullets are absorbed by ignited badguys
      bullet.remove_me();
      return FORCE_MOVE;
    }
  }
  else if(bullet.get_type() == FIRE_BONUS && is_flammable()) {
    // fire bullets ignite flammable badguys
    ignite();
    bullet.remove_me();
    return ABORT_MOVE;
  }
  else if(bullet.get_type() == ICE_BONUS && is_freezable()) {
    // ice bullets freeze freezable badguys
    freeze();
    bullet.remove_me();
    return ABORT_MOVE;
  }
  else {
    // in all other cases, bullets ricochet
    bullet.ricochet(*this, hit);
    return FORCE_MOVE;
  }
}

void BadGuy::active_update

(

float

elapsed_time

)

[protected, virtual]

called each frame when the badguy is activated.

Reimplemented in AngryStone, Bomb, CaptainSnowball, Crystallo, Dart, DartTrap, Dispenser, Fish, Flame, FlyingSnowBall, GhostTree, Haywire, Igel, Jumpy, Kugelblitz, Mole, MoleRock, MrBomb, MrIceBlock, Owl, Plant, Root, SkullyHop, SkyDive, Snail, SpiderMite, SSpiky, Stalactite, Stumpy, Toad, Totem, TreeWillOWisp, WalkingBadguy, WillOWisp, Yeti, YetiStalactite, and Zeekling.

Definition at line 209 of file badguy.cpp.

References Physic::get_movement(), MovingObject::movement, and physic.

Referenced by Zeekling::active_update(), WalkingBadguy::active_update(), Totem::active_update(), Toad::active_update(), Stumpy::active_update(), SSpiky::active_update(), Snail::active_update(), SkullyHop::active_update(), Root::active_update(), Plant::active_update(), Owl::active_update(), MrIceBlock::active_update(), MoleRock::active_update(), Mole::active_update(), Kugelblitz::active_update(), Jumpy::active_update(), Igel::active_update(), Fish::active_update(), Dart::active_update(), Crystallo::active_update(), AngryStone::active_update(), and update().

{
  movement = physic.get_movement(elapsed_time);
}

void BadGuy::inactive_update

(

float

elapsed_time

)

[protected, virtual]

called each frame when the badguy is not activated.

Definition at line 215 of file badguy.cpp.

Referenced by update().

{
}

void BadGuy::initialize

(

)

[protected, virtual]

called immediately before the first call to initialize

Reimplemented in BouncingSnowball, Dart, DartTrap, FlyingSnowBall, KamikazeSnowball, Kugelblitz, MoleRock, MrIceBlock, Owl, Plant, SkullyHop, Snail, SpiderMite, SSpiky, Stumpy, Toad, Totem, WalkingBadguy, Yeti, and Zeekling.

Definition at line 194 of file badguy.cpp.

Referenced by try_activate().

{
}

void BadGuy::activate

(

)

[protected, virtual]

called when the badguy has been activated.

(As a side effect the dir variable might have been changed so that it faces towards the player.

Reimplemented in Dart, DartTrap, Dispenser, Flame, FlyingSnowBall, GhostTree, Mole, TreeWillOWisp, and WillOWisp.

Definition at line 199 of file badguy.cpp.

Referenced by Kugelblitz::try_activate(), and try_activate().

{
}

void BadGuy::deactivate

(

)

[protected, virtual]

called when the badguy has been deactivated

Reimplemented in Dart, Dispenser, Flame, MoleRock, Root, Stalactite, and WillOWisp.

Definition at line 204 of file badguy.cpp.

Referenced by update().

{
}

void BadGuy::kill_squished

(

GameObject &

object

)

[protected]

Reimplemented in Yeti.

Definition at line 357 of file badguy.cpp.

References Player::bounce(), COLGROUP_MOVING_ONLY_STATIC, Physic::enable_gravity(), MovingObject::get_pos(), physic, SoundManager::play(), run_dead_script(), MovingObject::set_group(), set_state(), Physic::set_velocity_x(), Physic::set_velocity_y(), sound_manager, and STATE_SQUISHED.

Referenced by Zeekling::collision_squished(), WalkingLeaf::collision_squished(), Totem::collision_squished(), Toad::collision_squished(), Stumpy::collision_squished(), SpiderMite::collision_squished(), SnowBall::collision_squished(), SmartBall::collision_squished(), SkullyHop::collision_squished(), PoisonIvy::collision_squished(), MrBomb::collision_squished(), KamikazeSnowball::collision_squished(), FlyingSnowBall::collision_squished(), Crystallo::collision_squished(), CaptainSnowball::collision_squished(), and BouncingSnowball::collision_squished().

{
  sound_manager->play("sounds/squish.wav", get_pos());
  physic.enable_gravity(true);
  physic.set_velocity_x(0);
  physic.set_velocity_y(0);
  set_state(STATE_SQUISHED);
  set_group(COLGROUP_MOVING_ONLY_STATIC);
  Player* player = dynamic_cast<Player*>(&object);
  if (player) {
    player->bounce(*this);
  }

  // start dead-script
  run_dead_script();
}

void BadGuy::set_state

(

State

state

)

[protected]

Definition at line 403 of file badguy.cpp.

References colgroup_active, COLGROUP_DISABLED, GameObject::remove_me(), MovingObject::set_group(), SQUISH_TIME, Timer::start(), STATE_ACTIVE, STATE_FALLING, STATE_INACTIVE, STATE_SQUISHED, and state_timer.

Referenced by Snowman::collision_squished(), KamikazeSnowball::kill_collision(), kill_fall(), kill_squished(), Stalactite::squish(), Kugelblitz::try_activate(), try_activate(), YetiStalactite::update(), and update().

{
  if(this->state == state)
    return;

  State laststate = this->state;
  this->state = state;
  switch(state) {
    case STATE_SQUISHED:
      state_timer.start(SQUISH_TIME);
      break;
    case STATE_ACTIVE:
      set_group(colgroup_active);
      //bbox.set_pos(start_position);
      break;
    case STATE_INACTIVE:
      // was the badguy dead anyway?
      if(laststate == STATE_SQUISHED || laststate == STATE_FALLING) {
        remove_me();
      }
      set_group(COLGROUP_DISABLED);
      break;
    case STATE_FALLING:
      set_group(COLGROUP_DISABLED);
      break;
    default:
      break;
  }
}

State BadGuy::get_state

(

)

const [inline, protected]

Definition at line 146 of file badguy.hpp.

References state.

Referenced by MrIceBlock::collision_player(), Toad::collision_solid(), SkullyHop::collision_solid(), BouncingSnowball::collision_solid(), Stalactite::draw(), Fish::draw(), Jumpy::hit(), and YetiStalactite::update().

  { return state; }

bool BadGuy::check_state_timer

(

)

[inline, protected]

Definition at line 149 of file badguy.hpp.

References Timer::check(), and state_timer.

Referenced by YetiStalactite::update().

                           {
    return state_timer.check();
  }

Player * BadGuy::get_nearest_player

(

)

[protected]

returns a pointer to the nearest player or 0 if no player is available

Definition at line 496 of file badguy.cpp.

References Sector::current(), and Sector::get_nearest_player().

Referenced by Dispenser::activate(), WillOWisp::active_update(), Stalactite::active_update(), SSpiky::active_update(), SpiderMite::active_update(), Plant::active_update(), Jumpy::active_update(), Haywire::active_update(), GhostTree::active_update(), FlyingSnowBall::active_update(), Dispenser::active_update(), AngryStone::active_update(), Yeti::drop_stalactite(), is_offscreen(), Dispenser::launch_badguy(), Toad::set_state(), Zeekling::should_we_dive(), Kugelblitz::try_activate(), and try_activate().

{
  return Sector::current()->get_nearest_player (this->get_bbox ());
}

bool BadGuy::is_offscreen

(

)

[protected]

initial position of the enemy.

Also the position where enemy respawns when after being deactivated.

Definition at line 434 of file badguy.cpp.

References MovingObject::get_bbox(), Rectf::get_middle(), get_nearest_player(), Vector::x, X_OFFSCREEN_DISTANCE, Vector::y, and Y_OFFSCREEN_DISTANCE.

Referenced by Dispenser::launch_badguy(), try_activate(), and update().

{
  Player* player = get_nearest_player();
  if (!player) return false;
  Vector dist = player->get_bbox().get_middle() - get_bbox().get_middle();
  // In SuperTux 0.1.x, Badguys were activated when Tux<->Badguy center distance was approx. <= ~668px
  // This doesn't work for wide-screen monitors which give us a virt. res. of approx. 1066px x 600px
  if ((fabsf(dist.x) <= X_OFFSCREEN_DISTANCE) && (fabsf(dist.y) <= Y_OFFSCREEN_DISTANCE)) {
    return false;
  }
  return true;
}

bool BadGuy::might_fall

(

int

height = 1

)

[protected]

Returns true if we might soon fall at least height pixels.

Minimum value for height is 1 pixel

Definition at line 476 of file badguy.cpp.

References MovingObject::bbox, Sector::current(), dir, Sector::is_free_of_statics(), LEFT, Rectf::p1, Rectf::p2, Vector::x, and Vector::y.

Referenced by WalkingBadguy::active_update(), Totem::active_update(), and CaptainSnowball::active_update().

{
  // make sure we check for at least a 1-pixel fall
  assert(height > 0);

  float x1;
  float x2;
  float y1 = bbox.p2.y + 1;
  float y2 = bbox.p2.y + 1 + height;
  if (dir == LEFT) {
    x1 = bbox.p1.x - 1;
    x2 = bbox.p1.x;
  } else {
    x1 = bbox.p2.x;
    x2 = bbox.p2.x + 1;
  }
  return Sector::current()->is_free_of_statics(Rectf(x1, y1, x2, y2));
}

Direction BadGuy::str2dir

(

std::string

dir_str

)

[protected]

Get Direction from String.

Definition at line 179 of file badguy.cpp.

References AUTO, LEFT, log_warning, and RIGHT.

Referenced by BadGuy().

{
  if( dir_str == "auto" )
    return AUTO;
  if( dir_str == "left" )
    return LEFT;
  if( dir_str == "right" )
    return RIGHT;

  //default to "auto"
  log_warning << "Badguy::str2dir: unknown direction \"" << dir_str << "\"" << std::endl;;
  return AUTO;
}

void BadGuy::update_on_ground_flag

(

const CollisionHit &

hit

)

[protected]

Update on_ground_flag judging by solid collision hit.

This gets called from the base implementation of collision_solid, so call this when overriding collision_solid's default behaviour.

Definition at line 502 of file badguy.cpp.

References CollisionHit::bottom, floor_normal, on_ground_flag, and CollisionHit::slope_normal.

Referenced by WalkingBadguy::collision_solid(), Totem::collision_solid(), Stumpy::collision_solid(), Snail::collision_solid(), MrIceBlock::collision_solid(), Bomb::collision_solid(), and collision_solid().

{
  if (hit.bottom) {
    on_ground_flag = true;
    floor_normal = hit.slope_normal;
  }
}

bool BadGuy::on_ground

(

)

[protected]

Returns true if we touched ground in the past frame This only works if update_on_ground_flag() gets called in collision_solid.

Definition at line 511 of file badguy.cpp.

References on_ground_flag.

Referenced by WalkingBadguy::active_update(), Totem::active_update(), CaptainSnowball::active_update(), and Snail::collision_squished().

{
  return on_ground_flag;
}

Vector BadGuy::get_floor_normal

(

)

[protected]

Returns floor normal stored the last time when update_on_ground_flag was called and we touched something solid from above.

Definition at line 523 of file badguy.cpp.

References floor_normal.

{
  return floor_normal;
}

bool BadGuy::is_active

(

)

[protected]

Returns true if we were in STATE_ACTIVE at the beginning of the last call to update().

Definition at line 517 of file badguy.cpp.

References is_active_flag.

Referenced by collision(), and CaptainSnowball::collision_solid().

{
  return is_active_flag;
}

void BadGuy::set_colgroup_active

(

CollisionGroup

group

)

[protected]

changes colgroup_active.

Also calls set_group when badguy is in STATE_ACTIVE

Definition at line 578 of file badguy.cpp.

References colgroup_active, MovingObject::set_group(), state, and STATE_ACTIVE.

Referenced by Stalactite::active_update(), Dispenser::collision_squished(), DartTrap::DartTrap(), Dispenser::Dispenser(), Flame::Flame(), GhostTree::GhostTree(), SkyDive::grab(), MrIceBlock::grab(), MrBomb::grab(), Bomb::grab(), Fish::jump(), Root::Root(), Mole::set_state(), Stalactite::Stalactite(), Fish::start_waiting(), Yeti::take_hit(), TreeWillOWisp::TreeWillOWisp(), SkyDive::ungrab(), MrIceBlock::ungrab(), MrBomb::ungrab(), Bomb::ungrab(), YetiStalactite::update(), WillOWisp::vanish(), and TreeWillOWisp::vanish().

{
  this->colgroup_active = group;
  if (state == STATE_ACTIVE) set_group(group); 
}

void BadGuy::try_activate

(

)

[private]

Reimplemented in Kugelblitz.

Definition at line 448 of file badguy.cpp.

References activate(), AUTO, dir, MovingObject::get_bbox(), get_nearest_player(), initialize(), is_initialized, is_offscreen(), LEFT, Rectf::p1, Rectf::p2, RIGHT, set_state(), start_dir, STATE_ACTIVE, and Vector::x.

Referenced by update().

{
  // Don't activate if player is dying
  Player* player = get_nearest_player();
  if (!player) return;

  if (!is_offscreen()) {
    set_state(STATE_ACTIVE);
    if (!is_initialized) {

      // if starting direction was set to AUTO, this is our chance to re-orient the badguy
      if (start_dir == AUTO) {
        Player* player = get_nearest_player();
        if (player && (player->get_bbox().p1.x > get_bbox().p2.x)) {
          dir = RIGHT;
        } else {
          dir = LEFT;
        }
      }

      initialize();
      is_initialized = true;
    }
    activate();
  }
}

BadGuy& BadGuy::operator=

(

const BadGuy &

)

[private]

---

Member Data Documentation

Physic BadGuy::physic [protected]

Definition at line 194 of file badguy.hpp.

Referenced by Zeekling::active_update(), Yeti::active_update(), WalkingBadguy::active_update(), Totem::active_update(), Toad::active_update(), Stalactite::active_update(), SpiderMite::active_update(), Snail::active_update(), SkyDive::active_update(), Plant::active_update(), Kugelblitz::active_update(), FlyingSnowBall::active_update(), Fish::active_update(), CaptainSnowball::active_update(), Bomb::active_update(), active_update(), AngryStone::active_update(), WalkingBadguy::add_velocity(), AngryStone::AngryStone(), Yeti::be_angry(), Snail::be_flat(), Snail::be_kicked(), CaptainSnowball::CaptainSnowball(), Stumpy::collision_badguy(), Plant::collision_badguy(), Yeti::collision_solid(), WalkingBadguy::collision_solid(), Totem::collision_solid(), Toad::collision_solid(), Stumpy::collision_solid(), Stalactite::collision_solid(), SpiderMite::collision_solid(), Snail::collision_solid(), SkyDive::collision_solid(), SkullyHop::collision_solid(), Plant::collision_solid(), Owl::collision_solid(), MrIceBlock::collision_solid(), KamikazeSnowball::collision_solid(), FlyingSnowBall::collision_solid(), CaptainSnowball::collision_solid(), BouncingSnowball::collision_solid(), Bomb::collision_solid(), collision_solid(), AngryStone::collision_solid(), Snowman::collision_squished(), Haywire::collision_squished(), FlyingSnowBall::collision_squished(), Fish::collision_tile(), Dart::Dart(), Fish::Fish(), FlyingSnowBall::FlyingSnowBall(), WalkingBadguy::freeze(), Jumpy::freeze(), Fish::freeze(), WalkingBadguy::get_velocity_y(), SkyDive::grab(), Kugelblitz::hit(), Jumpy::hit(), Fish::hit(), Zeekling::initialize(), WalkingBadguy::initialize(), Totem::initialize(), Stumpy::initialize(), SSpiky::initialize(), SpiderMite::initialize(), Plant::initialize(), Owl::initialize(), MoleRock::initialize(), Kugelblitz::initialize(), KamikazeSnowball::initialize(), Dart::initialize(), BouncingSnowball::initialize(), Fish::jump(), Yeti::jump_down(), Totem::jump_off(), Yeti::jump_up(), KamikazeSnowball::kill_collision(), kill_fall(), kill_squished(), Kugelblitz::Kugelblitz(), Mole::Mole(), MoleRock::MoleRock(), Zeekling::onBumpHorizontal(), Zeekling::onBumpVertical(), Root::Root(), Yeti::run(), Toad::set_state(), SkullyHop::set_state(), MrIceBlock::set_state(), WalkingBadguy::set_velocity_y(), SpiderMite::SpiderMite(), Stalactite::squish(), YetiStalactite::start_shaking(), Fish::start_waiting(), Totem::synchronize_with(), Yeti::take_hit(), WalkingBadguy::turn_around(), SkyDive::ungrab(), update(), and Zeekling::Zeekling().

bool BadGuy::countMe

Count this badguy to the statistics? This value should not be changed during runtime.

Definition at line 199 of file badguy.hpp.

Referenced by Bomb::Bomb(), MrTree::collision_squished(), Dart::Dart(), DartTrap::DartTrap(), Dispenser::Dispenser(), Flame::Flame(), Kugelblitz::Kugelblitz(), MoleRock::MoleRock(), run_dead_script(), Stalactite::Stalactite(), WillOWisp::WillOWisp(), and Yeti::Yeti().

bool BadGuy::is_initialized [protected]

true if initialize() has already been called

Definition at line 203 of file badguy.hpp.

Referenced by Kugelblitz::try_activate(), and try_activate().

Vector BadGuy::start_position [protected]

Definition at line 205 of file badguy.hpp.

Referenced by Zeekling::active_update(), TreeWillOWisp::active_update(), Root::active_update(), FlyingSnowBall::active_update(), Flame::active_update(), Crystallo::active_update(), BadGuy(), Root::draw(), Flame::Flame(), get_start_position(), Kugelblitz::Kugelblitz(), set_start_position(), and YetiStalactite::update().

Direction BadGuy::dir [protected]

The direction we currently face in.

Definition at line 208 of file badguy.hpp.

Referenced by Dispenser::activate(), Zeekling::active_update(), Yeti::active_update(), WillOWisp::active_update(), WalkingBadguy::active_update(), TreeWillOWisp::active_update(), Totem::active_update(), SSpiky::active_update(), SpiderMite::active_update(), Snail::active_update(), Plant::active_update(), Owl::active_update(), Jumpy::active_update(), GhostTree::active_update(), FlyingSnowBall::active_update(), Dispenser::active_update(), Crystallo::active_update(), CaptainSnowball::active_update(), BadGuy(), Yeti::be_angry(), Snail::be_flat(), Snail::be_kicked(), Igel::can_see(), WalkingBadguy::collision_badguy(), Totem::collision_badguy(), Plant::collision_badguy(), Igel::collision_bullet(), Snail::collision_player(), MrIceBlock::collision_player(), Yeti::collision_solid(), WalkingBadguy::collision_solid(), Totem::collision_solid(), Snail::collision_solid(), SkullyHop::collision_solid(), Plant::collision_solid(), Owl::collision_solid(), MrIceBlock::collision_solid(), CaptainSnowball::collision_solid(), BouncingSnowball::collision_solid(), Zeekling::collision_squished(), WalkingLeaf::collision_squished(), Totem::collision_squished(), Toad::collision_squished(), Stumpy::collision_squished(), SpiderMite::collision_squished(), Snowman::collision_squished(), SnowBall::collision_squished(), Snail::collision_squished(), SmartBall::collision_squished(), SkullyHop::collision_squished(), PoisonIvy::collision_squished(), Owl::collision_squished(), MrTree::collision_squished(), MrIceBlock::collision_squished(), MrBomb::collision_squished(), KamikazeSnowball::collision_squished(), Haywire::collision_squished(), FlyingSnowBall::collision_squished(), Dispenser::collision_squished(), Crystallo::collision_squished(), CaptainSnowball::collision_squished(), Dispenser::Dispenser(), DartTrap::fire(), SSpiky::freeze(), Spiky::freeze(), MrBomb::freeze(), Jumpy::freeze(), Haywire::freeze(), Zeekling::initialize(), Yeti::initialize(), WalkingBadguy::initialize(), Totem::initialize(), Toad::initialize(), Stumpy::initialize(), SSpiky::initialize(), SpiderMite::initialize(), SkullyHop::initialize(), Plant::initialize(), Owl::initialize(), KamikazeSnowball::initialize(), FlyingSnowBall::initialize(), DartTrap::initialize(), Dart::initialize(), BouncingSnowball::initialize(), Owl::is_above_player(), Yeti::jump_down(), Yeti::jump_up(), KamikazeSnowball::KamikazeSnowball(), KamikazeSnowball::kill_collision(), Dispenser::launch_badguy(), DartTrap::load(), CaptainSnowball::might_climb(), might_fall(), Zeekling::onBumpHorizontal(), Zeekling::onBumpVertical(), Owl::Owl(), Yeti::run(), Toad::set_state(), SkullyHop::set_state(), MrIceBlock::set_state(), Totem::synchronize_with(), Kugelblitz::try_activate(), try_activate(), and WalkingBadguy::turn_around().

Direction BadGuy::start_dir [protected]

The direction we initially faced in.

Definition at line 211 of file badguy.hpp.

Referenced by BadGuy(), DartTrap::DartTrap(), Dispenser::Dispenser(), Dispenser::launch_badguy(), Kugelblitz::try_activate(), and try_activate().

bool BadGuy::frozen [protected]

Definition at line 213 of file badguy.hpp.

Referenced by WalkingBadguy::active_update(), Jumpy::active_update(), Fish::active_update(), Dispenser::collision(), collision_player(), Fish::collision_tile(), freeze(), MrBomb::grab(), Jumpy::hit(), WalkingBadguy::initialize(), is_frozen(), MrBomb::is_portable(), WalkingBadguy::turn_around(), and unfreeze().

bool BadGuy::ignited [protected]

true if this badguy is currently on fire

Definition at line 214 of file badguy.hpp.

Referenced by is_ignited().

std::string BadGuy::dead_script [protected]

script to execute when badguy is killed

Definition at line 216 of file badguy.hpp.

Referenced by BadGuy(), and run_dead_script().

State BadGuy::state [private]

Reimplemented in AngryStone, Bomb, DartTrap, Kugelblitz, Mole, Plant, SkullyHop, Snail, SSpiky, Stalactite, Toad, Yeti, and Zeekling.

Definition at line 219 of file badguy.hpp.

Referenced by draw(), get_state(), set_colgroup_active(), and update().

bool BadGuy::is_active_flag [private]

true if state was STATE_ACTIVE at the beginning of the last call to update()

Definition at line 223 of file badguy.hpp.

Referenced by is_active(), and update().

Timer BadGuy::state_timer [private]

Reimplemented in Yeti.

Definition at line 225 of file badguy.hpp.

Referenced by check_state_timer(), set_state(), and update().

bool BadGuy::on_ground_flag [private]

true if we touched something solid from above and update_on_ground_flag was called last frame

Definition at line 229 of file badguy.hpp.

Referenced by on_ground(), update(), and update_on_ground_flag().

Vector BadGuy::floor_normal [private]

floor normal stored the last time when update_on_ground_flag was called and we touched something solid from above

Definition at line 233 of file badguy.hpp.

Referenced by get_floor_normal(), and update_on_ground_flag().

CollisionGroup BadGuy::colgroup_active [private]

CollisionGroup the badguy should be in while active.

Definition at line 236 of file badguy.hpp.

Referenced by set_colgroup_active(), set_state(), and unfreeze().

---

The documentation for this class was generated from the following files:

• src/badguy/badguy.hpp
• src/badguy/badguy.cpp

---