Totem Class Reference

"Totem" Badguy - A variable-height stack of wooden blocks More...

#include <totem.hpp>

Inherits BadGuy.

List of all members.

Public Member Functions
	Totem (const Reader &reader)
	~Totem ()
void	initialize ()
	called immediately before the first call to initialize
void	active_update (float elapsed_time)
	called each frame when the badguy is activated.
void	collision_solid (const CollisionHit &hit)
	Called when the badguy collided with solid ground.
HitResponse	collision_badguy (BadGuy &badguy, const CollisionHit &hit)
	Called when the badguy collided with another badguy.
virtual bool	updatePointers (const GameObject *from_object, GameObject *to_object)
Protected Member Functions
bool	collision_squished (GameObject &object)
	Called when the player hit the badguy from above.
void	kill_fall ()
	Set the badguy to kill/falling state, which makes him falling of the screen (his sprite is turned upside-down).
void	jump_on (Totem *target)
	jump on target
void	jump_off ()
	jump off current base
void	synchronize_with (Totem *baseTotem)
	synchronize position and movement with baseTotem
Private Member Functions
	Totem (const Totem &)
Totem &	operator= (const Totem &)
Private Attributes
Totem *	carrying
	Totem we are currently carrying (or 0).
Totem *	carried_by
	Totem by which we are currently carried (or 0).

---

Detailed Description

"Totem" Badguy - A variable-height stack of wooden blocks

Definition at line 25 of file totem.hpp.

---

Constructor & Destructor Documentation

Totem::Totem

(

const Reader &

reader

)

Definition at line 31 of file totem.cpp.

References LAND_ON_TOTEM_SOUND, SoundManager::preload(), and sound_manager.

                                 :
  BadGuy(reader, "images/creatures/totem/totem.sprite"),
  carrying(0),
  carried_by(0)
{
  sound_manager->preload( LAND_ON_TOTEM_SOUND );
}

Totem::~Totem

(

)

Definition at line 39 of file totem.cpp.

References carried_by, carrying, and jump_off().

{
  if (carrying) carrying->jump_off();
  if (carried_by) jump_off();
}

Totem::Totem

(

const Totem &

)

[private]

---

Member Function Documentation

void Totem::initialize

(

)

[virtual]

called immediately before the first call to initialize

Reimplemented from BadGuy.

Definition at line 60 of file totem.cpp.

References carried_by, BadGuy::dir, LEFT, BadGuy::physic, Physic::set_velocity_x(), MovingSprite::sprite, synchronize_with(), and WALKSPEED.

Referenced by active_update(), collision_badguy(), collision_solid(), jump_off(), and jump_on().

{
  if (!carried_by) {
static const float WALKSPEED = 100;
    physic.set_velocity_x(dir == LEFT ? -WALKSPEED : WALKSPEED);
    sprite->set_action(dir == LEFT ? "walking-left" : "walking-right");
    return;
  } else {
    synchronize_with(carried_by);
    sprite->set_action(dir == LEFT ? "stacked-left" : "stacked-right");
    return;
  }
}

void Totem::active_update

(

float

elapsed_time

)

[virtual]

called each frame when the badguy is activated.

Reimplemented from BadGuy.

Definition at line 75 of file totem.cpp.

References BadGuy::active_update(), carried_by, carrying, Sector::current(), BadGuy::dir, MovingObject::get_pos(), initialize(), JUMP_ON_SPEED_Y, LEFT, BadGuy::might_fall(), Sector::moving_objects, BadGuy::on_ground(), BadGuy::physic, RIGHT, MovingObject::set_pos(), Physic::set_velocity_y(), synchronize_with(), Vector::x, and Vector::y.

{
  BadGuy::active_update(elapsed_time);

  if (!carried_by) {
    if (on_ground() && might_fall())
    {
      dir = (dir == LEFT ? RIGHT : LEFT);
      initialize();
    }

    Sector* s = Sector::current();
    if (s) {
      // jump a bit if we find a suitable totem
      for (std::vector<MovingObject*>::iterator i = s->moving_objects.begin(); i != s->moving_objects.end(); i++) {
        Totem* t = dynamic_cast<Totem*>(*i);
        if (!t) continue;

        // skip if we are not approaching each other
        if (!((this->dir == LEFT) && (t->dir == RIGHT))) continue;

        Vector p1 = this->get_pos();
        Vector p2 = t->get_pos();

        // skip if not on same height
        float dy = (p1.y - p2.y);
        if (fabsf(dy - 0) > 2) continue;

        // skip if too far away
        float dx = (p1.x - p2.x);
        if (fabsf(dx - 128) > 2) continue;

        physic.set_velocity_y(JUMP_ON_SPEED_Y);
        p1.y -= 1;
        this->set_pos(p1);
        break;
      }
    }
  }

  if (carried_by) {
    this->synchronize_with(carried_by);
  }

  if (carrying) {
    carrying->synchronize_with(this);
  }

}

void Totem::collision_solid

(

const CollisionHit &

hit

)

[virtual]

Called when the badguy collided with solid ground.

Reimplemented from BadGuy.

Definition at line 143 of file totem.cpp.

References CollisionHit::bottom, carried_by, collision_solid(), BadGuy::dir, initialize(), LEFT, CollisionHit::left, BadGuy::physic, CollisionHit::right, RIGHT, Physic::set_velocity_y(), CollisionHit::top, and BadGuy::update_on_ground_flag().

Referenced by collision_solid().

{
  update_on_ground_flag(hit);

  // if we are being carried around, pass event to bottom of stack and ignore it
  if (carried_by) {
    carried_by->collision_solid(hit);
    return;
  }

  // If we hit something from above or below: stop moving in this direction
  if (hit.top || hit.bottom) {
    physic.set_velocity_y(0);
  }

  // If we are hit from the direction we are facing: turn around
  if (hit.left && (dir == LEFT)) {
    dir = RIGHT;
    initialize();
  }
  if (hit.right && (dir == RIGHT)) {
    dir = LEFT;
    initialize();
  }
}

HitResponse Totem::collision_badguy	(	BadGuy &	badguy,
		const CollisionHit &	hit
	)			[virtual]

Called when the badguy collided with another badguy.

Reimplemented from BadGuy.

Definition at line 170 of file totem.cpp.

References carried_by, carrying, collision_badguy(), CONTINUE, BadGuy::dir, initialize(), jump_on(), LEFT, CollisionHit::left, CollisionHit::right, and RIGHT.

Referenced by collision_badguy().

{
  // if we are being carried around, pass event to bottom of stack and ignore it
  if (carried_by) {
    carried_by->collision_badguy(badguy, hit);
    return CONTINUE;
  }

  // if we hit a Totem that is not from our stack: have our base jump on its top
  Totem* totem = dynamic_cast<Totem*>(&badguy);
  if (totem) {
    Totem* thisBase = this; while (thisBase->carried_by) thisBase=thisBase->carried_by;
    Totem* srcBase = totem; while (srcBase->carried_by)  srcBase=srcBase->carried_by;
    Totem* thisTop = this;  while (thisTop->carrying)    thisTop=thisTop->carrying;
    if (srcBase != thisBase) {
      srcBase->jump_on(thisTop);
    }
  }

  // If we are hit from the direction we are facing: turn around
  if(hit.left && (dir == LEFT)) {
    dir = RIGHT;
    initialize();
  }
  if(hit.right && (dir == RIGHT)) {
    dir = LEFT;
    initialize();
  }

  return CONTINUE;
}

bool Totem::updatePointers	(	const GameObject *	from_object,
		GameObject *	to_object
	)			[virtual]

Definition at line 46 of file totem.cpp.

References carried_by, and carrying.

{
  if (from_object == carrying) {
    carrying = dynamic_cast<Totem*>(to_object);
    return true;
  }
  if (from_object == carried_by) {
    carried_by = dynamic_cast<Totem*>(to_object);
    return true;
  }
  return false;
}

bool Totem::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 126 of file totem.cpp.

References MovingObject::bbox, Player::bounce(), carried_by, carrying, BadGuy::dir, jump_off(), BadGuy::kill_squished(), LEFT, Rectf::set_size(), and MovingSprite::sprite.

{
  if (carrying) carrying->jump_off();
  if (carried_by) {
    Player* player = dynamic_cast<Player*>(&object);
    if (player) player->bounce(*this);
    jump_off();
  }

  sprite->set_action(dir == LEFT ? "squished-left" : "squished-right");
  bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());

  kill_squished(object);
  return true;
}

void Totem::kill_fall

(

)

[protected, virtual]

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

Reimplemented from BadGuy.

Definition at line 203 of file totem.cpp.

References carried_by, carrying, jump_off(), and BadGuy::kill_fall().

{
  if (carrying) carrying->jump_off();
  if (carried_by) jump_off();

  BadGuy::kill_fall();
}

void Totem::jump_on

(

Totem *

target

)

[protected]

jump on target

Definition at line 212 of file totem.cpp.

References MovingObject::bbox, carried_by, carrying, MovingObject::get_pos(), initialize(), LAND_ON_TOTEM_SOUND, log_warning, SoundManager::play(), Rectf::set_size(), sound_manager, MovingSprite::sprite, and synchronize_with().

Referenced by collision_badguy().

{
  if (target->carrying) {
    log_warning << "target is already carrying someone" << std::endl;
    return;
  }

  target->carrying = this;

  this->carried_by = target;
  this->initialize();
  bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());

  sound_manager->play( LAND_ON_TOTEM_SOUND , get_pos());

  this->synchronize_with(target);
}

void Totem::jump_off

(

)

[protected]

jump off current base

Definition at line 231 of file totem.cpp.

References MovingObject::bbox, carried_by, carrying, initialize(), JUMP_OFF_SPEED_Y, log_warning, BadGuy::physic, Rectf::set_size(), Physic::set_velocity_y(), and MovingSprite::sprite.

Referenced by collision_squished(), kill_fall(), and ~Totem().

                {
  if (!carried_by) {
    log_warning << "not carried by anyone" << std::endl;
    return;
  }

  carried_by->carrying = 0;

  this->carried_by = 0;

  this->initialize();
  bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());

  physic.set_velocity_y(JUMP_OFF_SPEED_Y);
}

void Totem::synchronize_with

(

Totem *

baseTotem

)

[protected]

synchronize position and movement with baseTotem

Definition at line 248 of file totem.cpp.

References BadGuy::dir, MovingObject::get_pos(), Physic::get_velocity_x(), Physic::get_velocity_y(), LEFT, BadGuy::physic, MovingObject::set_pos(), Physic::set_velocity_x(), Physic::set_velocity_y(), MovingSprite::sprite, and Vector::y.

Referenced by active_update(), initialize(), and jump_on().

{

  if (dir != base->dir) {
    dir = base->dir;
    sprite->set_action(dir == LEFT ? "stacked-left" : "stacked-right");
  }

  Vector pos = base->get_pos();
  pos.y -= sprite->get_current_hitbox_height();
  set_pos(pos);

  physic.set_velocity_x(base->physic.get_velocity_x());
  physic.set_velocity_y(base->physic.get_velocity_y());
}

Totem& Totem::operator=

(

const Totem &

)

[private]

---

Member Data Documentation

Totem* Totem::carrying [private]

Totem we are currently carrying (or 0).

Definition at line 48 of file totem.hpp.

Referenced by active_update(), collision_badguy(), collision_squished(), jump_off(), jump_on(), kill_fall(), updatePointers(), and ~Totem().

Totem* Totem::carried_by [private]

Totem by which we are currently carried (or 0).

Definition at line 49 of file totem.hpp.

Referenced by active_update(), collision_badguy(), collision_solid(), collision_squished(), initialize(), jump_off(), jump_on(), kill_fall(), updatePointers(), and ~Totem().

---

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

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

---