worldmap::Tux Class Reference

#include <tux.hpp>

Inherits GameObject.

List of all members.

Public Member Functions
	Tux (WorldMap *worldmap_)
	~Tux ()
void	setup ()
	called prior to first update
void	draw (DrawingContext &context)
	The GameObject should draw itself onto the provided DrawingContext if this function is called.
void	update (float elapsed_time)
	This function is called once per frame and allows the object to update it's state.
void	set_direction (Direction dir)
void	set_ghost_mode (bool enabled)
bool	get_ghost_mode ()
bool	is_moving () const
Vector	get_pos ()
Vector	get_tile_pos () const
void	set_tile_pos (Vector p)
Public Attributes
Direction	back_direction
Private Member Functions
void	stop ()
bool	canWalk (int tile_data, Direction dir)
	check if we can leave a tile (with given "tile_data") in direction "dir"
void	updateInputDirection ()
	if controller was pressed, update input_direction
void	tryStartWalking ()
	try starting to walk in input_direction
void	tryContinueWalking (float elapsed_time)
	try to continue walking in current direction
	Tux (const Tux &)
Tux &	operator= (const Tux &)
Private Attributes
WorldMap *	worldmap
SpritePtr	sprite
Controller *	controller
Direction	input_direction
Direction	direction
Vector	tile_pos
float	offset
	Length by which tux is away from its current tile, length is in input_direction direction.
bool	moving
bool	ghost_mode

---

Detailed Description

Definition at line 29 of file tux.hpp.

---

Constructor & Destructor Documentation

worldmap::Tux::Tux

(

WorldMap *

worldmap_

)

Definition at line 33 of file tux.cpp.

References SpriteManager::create(), worldmap::D_NONE, direction, ghost_mode, input_direction, moving, offset, sprite, and sprite_manager.

                            :
  back_direction(),
  worldmap(worldmap_),
  sprite(),
  controller(),
  input_direction(),
  direction(),
  tile_pos(),
  offset(),
  moving(),
  ghost_mode()
{
  sprite = sprite_manager->create("images/worldmap/common/tux.sprite");

  offset = 0;
  moving = false;
  direction = D_NONE;
  input_direction = D_NONE;

  ghost_mode = false;
}

worldmap::Tux::~Tux

(

)

Definition at line 55 of file tux.cpp.

{
}

worldmap::Tux::Tux

(

const Tux &

)

[private]

---

Member Function Documentation

void worldmap::Tux::stop

(

)

[private]

Definition at line 109 of file tux.cpp.

References worldmap::D_NONE, direction, input_direction, moving, and offset.

Referenced by tryContinueWalking().

{
  offset = 0;
  direction = D_NONE;
  input_direction = D_NONE;
  moving = false;
}

bool worldmap::Tux::canWalk	(	int	tile_data,
		Direction	dir
	)			[private]

check if we can leave a tile (with given "tile_data") in direction "dir"

Definition at line 162 of file tux.cpp.

References worldmap::D_EAST, worldmap::D_NORTH, worldmap::D_SOUTH, worldmap::D_WEST, ghost_mode, Tile::WORLDMAP_EAST, Tile::WORLDMAP_NORTH, Tile::WORLDMAP_SOUTH, and Tile::WORLDMAP_WEST.

Referenced by tryContinueWalking().

{
  return ghost_mode || 
    ((tile_data & Tile::WORLDMAP_NORTH && dir == D_NORTH) ||
     (tile_data & Tile::WORLDMAP_SOUTH && dir == D_SOUTH) ||
     (tile_data & Tile::WORLDMAP_EAST  && dir == D_EAST) ||
     (tile_data & Tile::WORLDMAP_WEST  && dir == D_WEST));
}

void worldmap::Tux::updateInputDirection

(

)

[private]

if controller was pressed, update input_direction

Definition at line 288 of file tux.cpp.

References controller, worldmap::D_EAST, worldmap::D_NORTH, worldmap::D_SOUTH, worldmap::D_WEST, Controller::DOWN, g_jk_controller, JoystickKeyboardController::get_main_controller(), Controller::hold(), input_direction, Controller::LEFT, Controller::RIGHT, and Controller::UP.

Referenced by update().

{
  Controller *controller = g_jk_controller->get_main_controller();
  if(controller->hold(Controller::UP))
    input_direction = D_NORTH;
  else if(controller->hold(Controller::DOWN))
    input_direction = D_SOUTH;
  else if(controller->hold(Controller::LEFT))
    input_direction = D_WEST;
  else if(controller->hold(Controller::RIGHT))
    input_direction = D_EAST;
}

void worldmap::Tux::tryStartWalking

(

)

[private]

try starting to walk in input_direction

Definition at line 136 of file tux.cpp.

References worldmap::WorldMap::at_level(), back_direction, worldmap::D_NONE, direction, worldmap::WorldMap::get_next_tile(), ghost_mode, input_direction, moving, worldmap::WorldMap::path_ok(), worldmap::reverse_dir(), worldmap::LevelTile::solved, tile_pos, and worldmap.

Referenced by update().

{
  if (moving)
    return;
  if (input_direction == D_NONE)
    return;

  LevelTile* level = worldmap->at_level();

  // We got a new direction, so lets start walking when possible
  Vector next_tile;
  if ((!level || level->solved)
      && worldmap->path_ok(input_direction, tile_pos, &next_tile)) {
    tile_pos = next_tile;
    moving = true;
    direction = input_direction;
    back_direction = reverse_dir(direction);
  } else if (ghost_mode || (input_direction == back_direction)) {
    moving = true;
    direction = input_direction;
    tile_pos = worldmap->get_next_tile(tile_pos, direction);
    back_direction = reverse_dir(direction);
  }
}

void worldmap::Tux::tryContinueWalking

(

float

elapsed_time

)

[private]

try to continue walking in current direction

Definition at line 172 of file tux.cpp.

References worldmap::SpecialTile::apply_action_east, worldmap::SpecialTile::apply_action_north, worldmap::SpecialTile::apply_action_south, worldmap::SpecialTile::apply_action_west, worldmap::WorldMap::at_level(), worldmap::WorldMap::at_special_tile(), worldmap::WorldMap::at_sprite_change(), worldmap::WorldMap::at_teleporter(), back_direction, canWalk(), worldmap::SpriteChange::change_on_touch, worldmap::SpriteChange::clear_stay_action(), worldmap::D_EAST, worldmap::D_NONE, worldmap::D_NORTH, worldmap::D_SOUTH, worldmap::D_WEST, direction, ghost_mode, input_direction, log_debug, log_warning, worldmap::SpecialTile::map_message, worldmap::map_message_TIME, moving, offset, worldmap::WorldMap::passive_message, worldmap::SpecialTile::passive_message, worldmap::WorldMap::passive_message_timer, worldmap::WorldMap::path_ok(), worldmap::reverse_dir(), worldmap::WorldMap::run_script(), worldmap::SpecialTile::script, worldmap::SpriteChange::set_stay_action(), worldmap::SpriteChange::sprite, sprite, Timer::start(), stop(), worldmap::WorldMap::tile_data_at(), tile_pos, worldmap::TUXSPEED, worldmap, Tile::WORLDMAP_EAST, Tile::WORLDMAP_NORTH, Tile::WORLDMAP_SOUTH, Tile::WORLDMAP_STOP, and Tile::WORLDMAP_WEST.

Referenced by update().

{
  if (!moving)
    return;

  // Let tux walk
  offset += TUXSPEED * elapsed_time;

  // Do nothing if we have not yet reached the next tile
  if (offset <= 32)
    return;

  offset -= 32;

  SpriteChange* sprite_change = worldmap->at_sprite_change(tile_pos);
  if(sprite_change != NULL) {
    sprite = sprite_change->sprite->clone();
    sprite_change->clear_stay_action();
  }

  // if this is a special_tile with passive_message, display it
  SpecialTile* special_tile = worldmap->at_special_tile();
  if(special_tile)
  {
    // direction and the apply_action_ are opposites, since they "see"
    // directions in a different way
    if((direction == D_NORTH && special_tile->apply_action_south) ||
       (direction == D_SOUTH && special_tile->apply_action_north) ||
       (direction == D_WEST && special_tile->apply_action_east) ||
       (direction == D_EAST && special_tile->apply_action_west))
    {
      if(special_tile->passive_message) {
        worldmap->passive_message = special_tile->map_message;
        worldmap->passive_message_timer.start(map_message_TIME);
      } else if(special_tile->script != "") {
        try {
          std::istringstream in(special_tile->script);
          worldmap->run_script(in, "specialtile");
        } catch(std::exception& e) {
          log_warning << "Couldn't execute special tile script: " << e.what()
                      << std::endl;
        }
      }
    }
  }

  // check if we are at a Teleporter
  Teleporter* teleporter = worldmap->at_teleporter(tile_pos);

  // stop if we reached a level, a WORLDMAP_STOP tile, a teleporter or a special tile without a passive_message
  if ((worldmap->at_level())
      || (worldmap->tile_data_at(tile_pos) & Tile::WORLDMAP_STOP)
      || (special_tile && !special_tile->passive_message
          && special_tile->script == "")
      || (teleporter) || ghost_mode) {
    if(special_tile && !special_tile->map_message.empty()
       && !special_tile->passive_message)
      worldmap->passive_message_timer.start(0);
    stop();
    return;
  }

  // if user wants to change direction, try changing, else guess the direction in which to walk next
  const int tile_data = worldmap->tile_data_at(tile_pos);
  if ((direction != input_direction) && canWalk(tile_data, input_direction)) {
    direction = input_direction;
    back_direction = reverse_dir(direction);
  } else {
    Direction dir = D_NONE;
    if (tile_data & Tile::WORLDMAP_NORTH && back_direction != D_NORTH)
      dir = D_NORTH;
    else if (tile_data & Tile::WORLDMAP_SOUTH && back_direction != D_SOUTH)
      dir = D_SOUTH;
    else if (tile_data & Tile::WORLDMAP_EAST && back_direction != D_EAST)
      dir = D_EAST;
    else if (tile_data & Tile::WORLDMAP_WEST && back_direction != D_WEST)
      dir = D_WEST;

    if (dir == D_NONE) {
      // Should never be reached if tiledata is good
      log_warning << "Could not determine where to walk next" << std::endl;
      stop();
      return;
    }

    direction = dir;
    input_direction = direction;
    back_direction = reverse_dir(direction);
  }

  // Walk automatically to the next tile
  if(direction == D_NONE)
    return;

  Vector next_tile;
  if (!ghost_mode && !worldmap->path_ok(direction, tile_pos, &next_tile)) {
    log_debug << "Tilemap data is buggy" << std::endl;
    stop();
    return;
  }

  SpriteChange* next_sprite = worldmap->at_sprite_change(next_tile);
  if(next_sprite != NULL && next_sprite->change_on_touch) {
    sprite = next_sprite->sprite->clone();
    next_sprite->clear_stay_action();
  }
  SpriteChange* last_sprite = worldmap->at_sprite_change(tile_pos);
  if(last_sprite != NULL && next_sprite != NULL) {
    log_debug << "Old: " << tile_pos << " New: " << next_tile << std::endl;
    last_sprite->set_stay_action();
  }

  tile_pos = next_tile;
}

void worldmap::Tux::setup

(

)

called prior to first update

Definition at line 312 of file tux.cpp.

References worldmap::WorldMap::at_sprite_change(), worldmap::SpriteChange::clear_stay_action(), worldmap::SpriteChange::sprite, sprite, tile_pos, and worldmap.

Referenced by worldmap::WorldMap::setup().

{
  // check if we already touch a SpriteChange object
  SpriteChange* sprite_change = worldmap->at_sprite_change(tile_pos);
  if(sprite_change != NULL) {
    sprite = sprite_change->sprite->clone();
    sprite_change->clear_stay_action();
  }
}

void worldmap::Tux::draw

(

DrawingContext &

context

)

[virtual]

The GameObject should draw itself onto the provided DrawingContext if this function is called.

Implements GameObject.

Definition at line 60 of file tux.cpp.

References PlayerStatus::bonus, FIRE_BONUS, worldmap::WorldMap::get_player_status(), get_pos(), GROWUP_BONUS, LAYER_OBJECTS, log_debug, moving, NO_BONUS, sprite, and worldmap.

{
  switch (worldmap->get_player_status()->bonus) {
    case GROWUP_BONUS:
      sprite->set_action(moving ? "large-walking" : "large-stop");
      break;
    case FIRE_BONUS:
      sprite->set_action(moving ? "fire-walking" : "fire-stop");
      break;
    case NO_BONUS:
      sprite->set_action(moving ? "small-walking" : "small-stop");
      break;
    default:
      log_debug << "Bonus type not handled in worldmap." << std::endl;
      sprite->set_action("large-stop");
      break;
  }

  sprite->draw(context, get_pos(), LAYER_OBJECTS);
}

void worldmap::Tux::update

(

float

elapsed_time

)

[virtual]

This function is called once per frame and allows the object to update it's state.

The elapsed_time is the time since the last frame in seconds and should be the base for all timed calculations (don't use SDL_GetTicks directly as this will fail in pause mode)

Implements GameObject.

Definition at line 302 of file tux.cpp.

References moving, tryContinueWalking(), tryStartWalking(), and updateInputDirection().

{
  updateInputDirection();
  if (moving)
    tryContinueWalking(elapsed_time);
  else
    tryStartWalking();
}

void worldmap::Tux::set_direction

(

Direction

dir

)

Definition at line 118 of file tux.cpp.

References input_direction.

Referenced by worldmap::WorldMap::finished_level(), worldmap::WorldMap::move_to_spawnpoint(), and worldmap::WorldMap::on_escape_press().

{
  input_direction = dir;
}

void worldmap::Tux::set_ghost_mode

(

bool

enabled

)

Definition at line 124 of file tux.cpp.

References ghost_mode.

{
  ghost_mode = enabled;
}

bool worldmap::Tux::get_ghost_mode

(

)

Definition at line 130 of file tux.cpp.

References ghost_mode.

{
  return ghost_mode;
}

bool worldmap::Tux::is_moving

(

)

const [inline]

Definition at line 68 of file tux.hpp.

References moving.

Referenced by worldmap::WorldMap::draw_status(), and worldmap::WorldMap::update().

{ return moving; }

Vector worldmap::Tux::get_pos

(

)

Definition at line 82 of file tux.cpp.

References worldmap::D_EAST, worldmap::D_NONE, worldmap::D_NORTH, worldmap::D_SOUTH, worldmap::D_WEST, direction, offset, tile_pos, Vector::x, and Vector::y.

Referenced by draw(), and worldmap::WorldMap::get_camera_pos_for_tux().

{
  float x = tile_pos.x * 32;
  float y = tile_pos.y * 32;

  switch(direction)
  {
    case D_WEST:
      x -= offset - 32;
      break;
    case D_EAST:
      x += offset - 32;
      break;
    case D_NORTH:
      y -= offset - 32;
      break;
    case D_SOUTH:
      y += offset - 32;
      break;
    case D_NONE:
      break;
  }

  return Vector(x, y);
}

Vector worldmap::Tux::get_tile_pos

(

)

const [inline]

Definition at line 70 of file tux.hpp.

References tile_pos.

Referenced by worldmap::WorldMap::at_level(), worldmap::WorldMap::at_special_tile(), worldmap::WorldMap::draw_status(), worldmap::WorldMap::finished_level(), worldmap::WorldMap::save_state(), and worldmap::WorldMap::update().

{ return tile_pos; }

void worldmap::Tux::set_tile_pos

(

Vector

p

)

[inline]

Definition at line 71 of file tux.hpp.

References tile_pos.

Referenced by worldmap::WorldMap::load_state(), and worldmap::WorldMap::move_to_spawnpoint().

{ tile_pos = p; }

Tux& worldmap::Tux::operator=

(

const Tux &

)

[private]

---

Member Data Documentation

Direction worldmap::Tux::back_direction

Definition at line 32 of file tux.hpp.

Referenced by worldmap::WorldMap::finished_level(), worldmap::WorldMap::load_state(), worldmap::WorldMap::save_state(), tryContinueWalking(), tryStartWalking(), and worldmap::WorldMap::update().

WorldMap* worldmap::Tux::worldmap [private]

Definition at line 34 of file tux.hpp.

Referenced by draw(), setup(), tryContinueWalking(), and tryStartWalking().

SpritePtr worldmap::Tux::sprite [private]

Definition at line 35 of file tux.hpp.

Referenced by draw(), setup(), tryContinueWalking(), and Tux().

Controller* worldmap::Tux::controller [private]

Definition at line 36 of file tux.hpp.

Referenced by updateInputDirection().

Direction worldmap::Tux::input_direction [private]

Definition at line 38 of file tux.hpp.

Referenced by set_direction(), stop(), tryContinueWalking(), tryStartWalking(), Tux(), and updateInputDirection().

Direction worldmap::Tux::direction [private]

Definition at line 39 of file tux.hpp.

Referenced by get_pos(), stop(), tryContinueWalking(), tryStartWalking(), and Tux().

Vector worldmap::Tux::tile_pos [private]

Definition at line 40 of file tux.hpp.

Referenced by get_pos(), get_tile_pos(), set_tile_pos(), setup(), tryContinueWalking(), and tryStartWalking().

float worldmap::Tux::offset [private]

Length by which tux is away from its current tile, length is in input_direction direction.

Definition at line 43 of file tux.hpp.

Referenced by get_pos(), stop(), tryContinueWalking(), and Tux().

bool worldmap::Tux::moving [private]

Definition at line 44 of file tux.hpp.

Referenced by draw(), is_moving(), stop(), tryContinueWalking(), tryStartWalking(), Tux(), and update().

bool worldmap::Tux::ghost_mode [private]

Definition at line 46 of file tux.hpp.

Referenced by canWalk(), get_ghost_mode(), set_ghost_mode(), tryContinueWalking(), tryStartWalking(), and Tux().

---

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

• src/worldmap/tux.hpp
• src/worldmap/tux.cpp

---