SSpiky Class Reference

#include <sspiky.hpp>

Inherits WalkingBadguy.

List of all members.

Public Member Functions
	SSpiky (const Reader &reader)
void	initialize ()
	called immediately before the first call to initialize
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.
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.
bool	is_freezable () const
Protected Types
enum	SSpikyState { SSPIKY_SLEEPING, SSPIKY_WAKING, SSPIKY_WALKING }
Protected Attributes
SSpikyState	state

---

Detailed Description

Definition at line 22 of file sspiky.hpp.

---

Member Enumeration Documentation

enum SSpiky::SSpikyState [protected]

Enumerator:

SSPIKY_SLEEPING
SSPIKY_WAKING
SSPIKY_WALKING

Definition at line 36 of file sspiky.hpp.

                   {
    SSPIKY_SLEEPING,
    SSPIKY_WAKING,
    SSPIKY_WALKING
  };

---

Constructor & Destructor Documentation

SSpiky::SSpiky

(

const Reader &

reader

)

Definition at line 25 of file sspiky.cpp.

References WalkingBadguy::max_drop_height, WalkingBadguy::walk_speed, and WALKSPEED.

  : WalkingBadguy(reader, "images/creatures/spiky/sleepingspiky.sprite", "left", "right"), state(SSPIKY_SLEEPING)
{
  walk_speed = WALKSPEED;
  max_drop_height = -1;
}

---

Member Function Documentation

void SSpiky::initialize

(

)

[virtual]

called immediately before the first call to initialize

Reimplemented from WalkingBadguy.

Definition at line 33 of file sspiky.cpp.

References BadGuy::dir, LEFT, BadGuy::physic, Physic::set_velocity_x(), MovingSprite::sprite, SSPIKY_SLEEPING, and state.

{
  state = SSPIKY_SLEEPING;
  physic.set_velocity_x(0);
  sprite->set_action(dir == LEFT ? "sleeping-left" : "sleeping-right");
}

void SSpiky::collision_solid

(

const CollisionHit &

hit

)

[virtual]

Called when the badguy collided with solid ground.

Reimplemented from WalkingBadguy.

Definition at line 41 of file sspiky.cpp.

References WalkingBadguy::collision_solid(), BadGuy::collision_solid(), SSPIKY_WALKING, and state.

{
  if(state != SSPIKY_WALKING) {
    BadGuy::collision_solid(hit);
    return;
  }
  WalkingBadguy::collision_solid(hit);
}

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

Called when the badguy collided with another badguy.

Reimplemented from WalkingBadguy.

Definition at line 51 of file sspiky.cpp.

References WalkingBadguy::collision_badguy(), BadGuy::collision_badguy(), SSPIKY_WALKING, and state.

{
  if(state != SSPIKY_WALKING) {
    return BadGuy::collision_badguy(badguy, hit);
  }
  return WalkingBadguy::collision_badguy(badguy, hit);
}

void SSpiky::active_update

(

float

elapsed_time

)

[virtual]

called each frame when the badguy is activated.

Reimplemented from WalkingBadguy.

Definition at line 60 of file sspiky.cpp.

References BadGuy::active_update(), WalkingBadguy::active_update(), BadGuy::dir, MovingObject::get_bbox(), BadGuy::get_nearest_player(), WalkingBadguy::initialize(), LEFT, Rectf::p1, Rectf::p2, RIGHT, MovingSprite::sprite, SSPIKY_SLEEPING, SSPIKY_WAKING, SSPIKY_WALKING, state, Vector::x, and Vector::y.

                                        {

  if(state == SSPIKY_WALKING) {
    WalkingBadguy::active_update(elapsed_time);
    return;
  }

  if(state == SSPIKY_SLEEPING) {

    Player* player = this->get_nearest_player();
    if (player) {
      Rectf mb = this->get_bbox();
      Rectf pb = player->get_bbox();

      bool inReach_left = (pb.p2.x >= mb.p2.x-((dir == LEFT) ? 256 : 0));
      bool inReach_right = (pb.p1.x <= mb.p1.x+((dir == RIGHT) ? 256 : 0));
      bool inReach_top = (pb.p2.y >= mb.p1.y);
      bool inReach_bottom = (pb.p1.y <= mb.p2.y);

      if (inReach_left && inReach_right && inReach_top && inReach_bottom) {
        // wake up
        sprite->set_action(dir == LEFT ? "waking-left" : "waking-right", 1);
        state = SSPIKY_WAKING;
      }
    }

    BadGuy::active_update(elapsed_time);
  }

  if(state == SSPIKY_WAKING) {
    if(sprite->animation_done()) {
      // start walking
      state = SSPIKY_WALKING;
      WalkingBadguy::initialize();
    }

    BadGuy::active_update(elapsed_time);
  }
}

void SSpiky::freeze

(

)

[virtual]

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

Reimplemented from WalkingBadguy.

Definition at line 101 of file sspiky.cpp.

References BadGuy::dir, WalkingBadguy::freeze(), LEFT, MovingSprite::sprite, SSPIKY_WALKING, and state.

{
  WalkingBadguy::freeze();
  sprite->set_action(dir == LEFT ? "iced-left" : "iced-right");
  state = SSPIKY_WALKING; // if we get hit while sleeping, wake up :)
}

bool SSpiky::is_freezable

(

)

const [virtual]

Reimplemented from BadGuy.

Definition at line 109 of file sspiky.cpp.

{
  return true;
}

---

Member Data Documentation

SSpikyState SSpiky::state [protected]

Reimplemented from BadGuy.

Definition at line 41 of file sspiky.hpp.

Referenced by active_update(), collision_badguy(), collision_solid(), freeze(), and initialize().

---

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

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

---