Dispenser Class Reference

#include <dispenser.hpp>

Inherits BadGuy.

List of all members.

Public Member Functions
	Dispenser (const Reader &reader)
void	activate ()
	called when the badguy has been activated.
void	deactivate ()
	called when the badguy has been deactivated
void	active_update (float elapsed_time)
	called each frame when the badguy is activated.
void	freeze ()
	Called when hit by an ice bullet, and is_freezable() returns true.
void	unfreeze ()
	Called to unfreeze the badguy.
bool	is_freezable () const
Protected Member Functions
bool	collision_squished (GameObject &object)
	Called when the player hit the badguy from above.
HitResponse	collision (GameObject &other, const CollisionHit &hit)
	Called when a collision with another object occurred.
void	launch_badguy ()
Private Attributes
float	cycle
std::vector< std::string >	badguys
unsigned int	next_badguy
Timer	dispense_timer
bool	autotarget
bool	swivel
bool	broken
bool	random
std::string	type

---

Detailed Description

Definition at line 22 of file dispenser.hpp.

---

Constructor & Destructor Documentation

Dispenser::Dispenser

(

const Reader &

reader

)

Definition at line 29 of file dispenser.cpp.

References AUTO, autotarget, badguys, MovingObject::bbox, broken, COLGROUP_MOVING, COLGROUP_MOVING_STATIC, BadGuy::countMe, cycle, BadGuy::dir, lisp::Lisp::get(), LEFT, next_badguy, SoundManager::preload(), random, BadGuy::set_colgroup_active(), Rectf::set_size(), sound_manager, MovingSprite::sprite, BadGuy::start_dir, swivel, and type.

                                         :
  BadGuy(reader, "images/creatures/dispenser/dispenser.sprite"),
  cycle(),
  badguys(),
  next_badguy(),
  dispense_timer(),
  autotarget(),
  swivel(),
  broken(),
  random(),
  type()
{
  set_colgroup_active(COLGROUP_MOVING_STATIC);
  sound_manager->preload("sounds/squish.wav");
  reader.get("cycle", cycle);
  reader.get("badguy", badguys);
  random = false; // default
  reader.get("random", random);
  type = "dropper"; //default
  reader.get("type", type);
  next_badguy = 0;
  autotarget = false;
  swivel = false;
  broken = false;

  if (badguys.size() <= 0)
    throw std::runtime_error("No badguys in dispenser.");

  if (type == "rocketlauncher") {
    sprite->set_action(dir == LEFT ? "working-left" : "working-right");
    set_colgroup_active(COLGROUP_MOVING); //if this were COLGROUP_MOVING_STATIC MrRocket would explode on launch.

    if (start_dir == AUTO) {
      autotarget = true;
    }
  } else if (type == "cannon") {
    sprite->set_action("working");
  } else {
    sprite->set_action("dropper");
  }

  bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());
  countMe = false;
}

---

Member Function Documentation

void Dispenser::activate

(

)

[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 from BadGuy.

Definition at line 75 of file dispenser.cpp.

References autotarget, broken, cycle, BadGuy::dir, dispense_timer, BadGuy::get_nearest_player(), MovingObject::get_pos(), launch_badguy(), LEFT, RIGHT, MovingSprite::sprite, Timer::start(), swivel, and Vector::x.

Referenced by unfreeze().

{
  if( broken ){
    return;
  }
  if( autotarget && !swivel ){ // auto cannon sprite might be wrong
    Player* player = this->get_nearest_player();
    if( player ){
      dir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT;
      sprite->set_action(dir == LEFT ? "working-left" : "working-right");
    }
  }
  dispense_timer.start(cycle, true);
  launch_badguy();
}

void Dispenser::deactivate

(

)

[virtual]

called when the badguy has been deactivated

Reimplemented from BadGuy.

Definition at line 92 of file dispenser.cpp.

References dispense_timer, and Timer::stop().

{
  dispense_timer.stop();
}

void Dispenser::active_update

(

float

elapsed_time

)

[virtual]

called each frame when the badguy is activated.

Reimplemented from BadGuy.

Definition at line 144 of file dispenser.cpp.

References autotarget, Timer::check(), BadGuy::dir, dispense_timer, BadGuy::get_nearest_player(), MovingObject::get_pos(), launch_badguy(), LEFT, RIGHT, MovingSprite::sprite, swivel, and Vector::x.

{
  if (dispense_timer.check()) {
    // auto always shoots in Tux's direction
    if( autotarget ){ 
      if( sprite->animation_done()) {
        sprite->set_action(dir == LEFT ? "working-left" : "working-right");
        swivel = false;
      }

      Player* player = this->get_nearest_player();
      if( player && !swivel ){
        Direction targetdir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT;
        if( dir != targetdir ){ // no target: swivel cannon 
          swivel = true;
          dir = targetdir;
          sprite->set_action(dir == LEFT ? "swivel-left" : "swivel-right", 1);
        } else { // tux in sight: shoot
          launch_badguy();
        }
      }
    } else {
      launch_badguy();
    }
  }
}

void Dispenser::freeze

(

)

[virtual]

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

Reimplemented from BadGuy.

Definition at line 244 of file dispenser.cpp.

References dispense_timer, BadGuy::freeze(), and Timer::stop().

{
  BadGuy::freeze();
  dispense_timer.stop();
}

void Dispenser::unfreeze

(

)

[virtual]

Called to unfreeze the badguy.

Reimplemented from BadGuy.

Definition at line 251 of file dispenser.cpp.

References activate(), and BadGuy::unfreeze().

Referenced by collision().

{
  BadGuy::unfreeze();
  activate();
}

bool Dispenser::is_freezable

(

)

const [virtual]

Reimplemented from BadGuy.

Definition at line 258 of file dispenser.cpp.

{
  return true;
}

bool Dispenser::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 from BadGuy.

Definition at line 99 of file dispenser.cpp.

References Player::bounce(), broken, COLGROUP_MOVING_STATIC, BadGuy::dir, dispense_timer, MovingObject::get_pos(), LEFT, SoundManager::play(), BadGuy::set_colgroup_active(), sound_manager, MovingSprite::sprite, Timer::start(), and type.

Referenced by collision().

{
  //Cannon launching MrRocket can be broken by jumping on it
  //other dispensers are not that fragile.
  if (broken || type != "rocketlauncher") {
    return false;
  }

  sprite->set_action(dir == LEFT ? "broken-left" : "broken-right");
  dispense_timer.start(0);
  set_colgroup_active(COLGROUP_MOVING_STATIC); // Tux can stand on broken cannon.
  Player* player = dynamic_cast<Player*>(&object);
  if (player){
    player->bounce(*this);
  }
  sound_manager->play("sounds/squish.wav", get_pos());
  broken = true;
  return true;
}

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

Called when a collision with another object occurred.

The default implementation calls collision_player, collision_solid, collision_badguy and collision_squished

Reimplemented from BadGuy.

Definition at line 120 of file dispenser.cpp.

References MovingObject::bbox, BadGuy::collision_bullet(), collision_squished(), FORCE_MOVE, BadGuy::frozen, MovingObject::get_bbox(), Rectf::p1, Rectf::p2, unfreeze(), and Vector::y.

{
  Player* player = dynamic_cast<Player*> (&other);
  if(player) {
    // hit from above?
    if (player->get_bbox().p2.y < (bbox.p1.y + 16)) {
      collision_squished(*player);
      return FORCE_MOVE;
    }
    if(frozen){
      unfreeze();
    }
    return FORCE_MOVE;
  }

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

  return FORCE_MOVE;
}

void Dispenser::launch_badguy

(

)

[protected]

Definition at line 172 of file dispenser.cpp.

References Sector::add_object(), ANCHOR_BOTTOM, AUTO, autotarget, badguys, ObjectFactory::create(), Sector::current(), BadGuy::dir, gameRandom, get_anchor_pos(), MovingObject::get_bbox(), BadGuy::get_nearest_player(), MovingObject::get_pos(), Rectf::get_width(), ObjectFactory::instance(), BadGuy::is_offscreen(), LEFT, log_warning, next_badguy, RandomGenerator::rand(), random, RIGHT, MovingObject::set_pos(), BadGuy::start_dir, type, and Vector::x.

Referenced by activate(), and active_update().

{
  //FIXME: Does is_offscreen() work right here?
  if (!is_offscreen()) {
    Direction launchdir = dir;
    if( !autotarget && start_dir == AUTO ){
      Player* player = this->get_nearest_player();
      if( player ){
        launchdir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT;
      } 
    } 

    if (badguys.size() > 1) {
      if (random) {
        next_badguy = gameRandom.rand(badguys.size());
      }
      else {
        next_badguy++;

        if (next_badguy >= badguys.size())
          next_badguy = 0;
      }
    }

    std::string badguy = badguys[next_badguy];

    if(badguy == "random") {
      log_warning << "random is outdated; use a list of badguys to select from." << std::endl;
      return;
    }

    try {
      GameObject *game_object;
      MovingObject *moving_object;
      Vector spawnpoint;
      Rectf object_bbox;

      /* Need to allocate the badguy first to figure out its bounding box. */
      game_object = ObjectFactory::instance().create(badguy, get_pos(), launchdir);
      if (game_object == NULL)
        throw std::runtime_error("Creating " + badguy + " object failed.");

      moving_object = dynamic_cast<MovingObject *> (game_object);
      if (moving_object == NULL)
        throw std::runtime_error(badguy + " is not a moving object.");

      object_bbox = moving_object->get_bbox ();

      if (type == "dropper") {
        spawnpoint = get_anchor_pos (get_bbox (), ANCHOR_BOTTOM);
        spawnpoint.x -= 0.5 * object_bbox.get_width ();
      }
      else if ((type == "cannon") || (type == "rocketlauncher")) {
        spawnpoint = get_pos (); /* top-left corner of the cannon */
        if (launchdir == LEFT)
          spawnpoint.x -= object_bbox.get_width () + 1;
        else
          spawnpoint.x += get_bbox ().get_width () + 1;
      }

      /* Now we set the real spawn position */
      moving_object->set_pos (spawnpoint);

      Sector::current()->add_object(moving_object);
    } catch(std::exception& e) {
      log_warning << "Error dispensing badguy: " << e.what() << std::endl;
      return;
    }
  }
}

---

Member Data Documentation

float Dispenser::cycle [private]

Definition at line 41 of file dispenser.hpp.

Referenced by activate(), and Dispenser().

std::vector<std::string> Dispenser::badguys [private]

Definition at line 42 of file dispenser.hpp.

Referenced by Dispenser(), and launch_badguy().

unsigned int Dispenser::next_badguy [private]

Definition at line 43 of file dispenser.hpp.

Referenced by Dispenser(), and launch_badguy().

Timer Dispenser::dispense_timer [private]

Definition at line 44 of file dispenser.hpp.

Referenced by activate(), active_update(), collision_squished(), deactivate(), and freeze().

bool Dispenser::autotarget [private]

Definition at line 45 of file dispenser.hpp.

Referenced by activate(), active_update(), Dispenser(), and launch_badguy().

bool Dispenser::swivel [private]

Definition at line 46 of file dispenser.hpp.

Referenced by activate(), active_update(), and Dispenser().

bool Dispenser::broken [private]

Definition at line 47 of file dispenser.hpp.

Referenced by activate(), collision_squished(), and Dispenser().

bool Dispenser::random [private]

Definition at line 48 of file dispenser.hpp.

Referenced by Dispenser(), and launch_badguy().

std::string Dispenser::type [private]

Definition at line 49 of file dispenser.hpp.

Referenced by collision_squished(), Dispenser(), and launch_badguy().

---

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

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

---