Zeekling Class Reference

#include <zeekling.hpp>

Inherits BadGuy.

List of all members.

Public Member Functions
	Zeekling (const Reader &reader)
	Zeekling (const Vector &pos, Direction d)
void	initialize ()
	called immediately before the first call to initialize
void	collision_solid (const CollisionHit &hit)
	Called when the badguy collided with solid ground.
void	active_update (float elapsed_time)
	called each frame when the badguy is activated.
Private Types
enum	ZeeklingState { FLYING, DIVING, CLIMBING }
Private Member Functions
bool	collision_squished (GameObject &object)
	Called when the player hit the badguy from above.
bool	should_we_dive ()
	linear prediction of player and badguy positions to decide if we should enter the DIVING state
void	onBumpHorizontal ()
void	onBumpVertical ()
	Zeekling (const Zeekling &)
Zeekling &	operator= (const Zeekling &)
Private Attributes
float	speed
Timer	diveRecoverTimer
ZeeklingState	state
const MovingObject *	last_player
	last player we tracked
Vector	last_player_pos
	position we last spotted the player at
Vector	last_self_pos
	position we last were at

---

Detailed Description

Definition at line 23 of file zeekling.hpp.

---

Member Enumeration Documentation

enum Zeekling::ZeeklingState [private]

Enumerator:

FLYING
DIVING
CLIMBING

Definition at line 40 of file zeekling.hpp.

                     {
    FLYING,
    DIVING,
    CLIMBING
  };

---

Constructor & Destructor Documentation

Zeekling::Zeekling

(

const Reader &

reader

)

Definition at line 27 of file zeekling.cpp.

References Physic::enable_gravity(), FLYING, gameRandom, BadGuy::physic, RandomGenerator::rand(), speed, and state.

                                       :
  BadGuy(reader, "images/creatures/zeekling/zeekling.sprite"),
  speed(),
  diveRecoverTimer(),
  state(),
  last_player(0),
  last_player_pos(),
  last_self_pos()
{
  state = FLYING;
  speed = gameRandom.rand(130, 171);
  physic.enable_gravity(false);
}

Zeekling::Zeekling	(	const Vector &	pos,
		Direction	d
	)

Definition at line 41 of file zeekling.cpp.

References Physic::enable_gravity(), FLYING, gameRandom, BadGuy::physic, RandomGenerator::rand(), speed, and state.

                                                 :
  BadGuy(pos, d, "images/creatures/zeekling/zeekling.sprite"),
  speed(),
  diveRecoverTimer(),
  state(),
  last_player(0),
  last_player_pos(),
  last_self_pos()
{
  state = FLYING;
  speed = gameRandom.rand(130, 171);
  physic.enable_gravity(false);
}

Zeekling::Zeekling

(

const Zeekling &

)

[private]

---

Member Function Documentation

void Zeekling::initialize

(

)

[virtual]

called immediately before the first call to initialize

Reimplemented from BadGuy.

Definition at line 56 of file zeekling.cpp.

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

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

void Zeekling::collision_solid

(

const CollisionHit &

hit

)

[virtual]

Called when the badguy collided with solid ground.

Reimplemented from BadGuy.

Definition at line 110 of file zeekling.cpp.

References CollisionHit::bottom, CollisionHit::left, onBumpHorizontal(), onBumpVertical(), CollisionHit::right, and CollisionHit::top.

{
  if(hit.top || hit.bottom) {
    onBumpVertical();
  } else if(hit.left || hit.right) {
    onBumpHorizontal();
  }
}

void Zeekling::active_update

(

float

elapsed_time

)

[virtual]

called each frame when the badguy is activated.

Reimplemented from BadGuy.

Definition at line 172 of file zeekling.cpp.

References BadGuy::active_update(), CLIMBING, BadGuy::dir, DIVING, FLYING, MovingObject::get_pos(), Physic::get_velocity_x(), LEFT, BadGuy::physic, Physic::set_velocity_y(), should_we_dive(), MovingSprite::sprite, BadGuy::start_position, state, and Vector::y.

                                          {
  if (state == FLYING) {
    if (should_we_dive()) {
      state = DIVING;
      physic.set_velocity_y(2*fabsf(physic.get_velocity_x()));
      sprite->set_action(dir == LEFT ? "diving-left" : "diving-right");
    }
    BadGuy::active_update(elapsed_time);
    return;
  } else if (state == DIVING) {
    BadGuy::active_update(elapsed_time);
    return;
  } else if (state == CLIMBING) {
    // stop climbing when we're back at initial height
    if (get_pos().y <= start_position.y) {
      state = FLYING;
      physic.set_velocity_y(0);
    }
    BadGuy::active_update(elapsed_time);
    return;
  } else {
    assert(false);
  }
}

bool Zeekling::collision_squished

(

GameObject &

object

)

[private, 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 63 of file zeekling.cpp.

References BadGuy::dir, BadGuy::kill_squished(), LEFT, and MovingSprite::sprite.

{
  sprite->set_action(dir == LEFT ? "squished-left" : "squished-right");
  kill_squished(object);
  return true;
}

bool Zeekling::should_we_dive

(

)

[private]

linear prediction of player and badguy positions to decide if we should enter the DIVING state

Definition at line 123 of file zeekling.cpp.

References BadGuy::get_nearest_player(), MovingObject::get_pos(), last_player, last_player_pos, last_self_pos, Vector::x, and Vector::y.

Referenced by active_update().

                         {

  const MovingObject* player = this->get_nearest_player();
  if (player && last_player && (player == last_player)) {

    // get positions, calculate movement
    const Vector player_pos = player->get_pos();
    const Vector player_mov = (player_pos - last_player_pos);
    const Vector self_pos = this->get_pos();
    const Vector self_mov = (self_pos - last_self_pos);

    // new vertical speed to test with
    float vy = 2*fabsf(self_mov.x);

    // do not dive if we are not above the player
    float height = player_pos.y - self_pos.y;
    if (height <= 0) return false;

    // do not dive if we are too far above the player
    if (height > 512) return false;

    // do not dive if we would not descend faster than the player
    float relSpeed = vy - player_mov.y;
    if (relSpeed <= 0) return false;

    // guess number of frames to descend to same height as player
    float estFrames = height / relSpeed;

    // guess where the player would be at this time
    float estPx = (player_pos.x + (estFrames * player_mov.x));

    // guess where we would be at this time
    float estBx = (self_pos.x + (estFrames * self_mov.x));

    // near misses are OK, too
    if (fabsf(estPx - estBx) < 8) return true;
  }

  // update last player tracked, as well as our positions
  last_player = player;
  if (player) {
    last_player_pos = player->get_pos();
    last_self_pos = this->get_pos();
  }

  return false;
}

void Zeekling::onBumpHorizontal

(

)

[private]

Definition at line 71 of file zeekling.cpp.

References CLIMBING, BadGuy::dir, DIVING, FLYING, LEFT, BadGuy::physic, RIGHT, Physic::set_velocity_x(), Physic::set_velocity_y(), speed, MovingSprite::sprite, and state.

Referenced by collision_solid().

                           {
  if (state == FLYING) {
    dir = (dir == LEFT ? RIGHT : LEFT);
    sprite->set_action(dir == LEFT ? "left" : "right");
    physic.set_velocity_x(dir == LEFT ? -speed : speed);
  } else
    if (state == DIVING) {
      dir = (dir == LEFT ? RIGHT : LEFT);
      state = FLYING;
      sprite->set_action(dir == LEFT ? "left" : "right");
      physic.set_velocity_x(dir == LEFT ? -speed : speed);
      physic.set_velocity_y(0);
    } else
      if (state == CLIMBING) {
        dir = (dir == LEFT ? RIGHT : LEFT);
        sprite->set_action(dir == LEFT ? "left" : "right");
        physic.set_velocity_x(dir == LEFT ? -speed : speed);
      } else {
        assert(false);
      }
}

void Zeekling::onBumpVertical

(

)

[private]

Definition at line 94 of file zeekling.cpp.

References CLIMBING, BadGuy::dir, DIVING, FLYING, LEFT, BadGuy::physic, Physic::set_velocity_y(), speed, MovingSprite::sprite, and state.

Referenced by collision_solid().

                         {
  if (state == FLYING) {
    physic.set_velocity_y(0);
  } else
    if (state == DIVING) {
      state = CLIMBING;
      physic.set_velocity_y(-speed);
      sprite->set_action(dir == LEFT ? "left" : "right");
    } else
      if (state == CLIMBING) {
        state = FLYING;
        physic.set_velocity_y(0);
      }
}

Zeekling& Zeekling::operator=

(

const Zeekling &

)

[private]

---

Member Data Documentation

float Zeekling::speed [private]

Definition at line 47 of file zeekling.hpp.

Referenced by initialize(), onBumpHorizontal(), onBumpVertical(), and Zeekling().

Timer Zeekling::diveRecoverTimer [private]

Definition at line 48 of file zeekling.hpp.

ZeeklingState Zeekling::state [private]

Reimplemented from BadGuy.

Definition at line 49 of file zeekling.hpp.

Referenced by active_update(), onBumpHorizontal(), onBumpVertical(), and Zeekling().

const MovingObject* Zeekling::last_player [private]

last player we tracked

Definition at line 50 of file zeekling.hpp.

Referenced by should_we_dive().

Vector Zeekling::last_player_pos [private]

position we last spotted the player at

Definition at line 51 of file zeekling.hpp.

Referenced by should_we_dive().

Vector Zeekling::last_self_pos [private]

position we last were at

Definition at line 52 of file zeekling.hpp.

Referenced by should_we_dive().

---

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

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

---