src/badguy/badguy.hpp

Go to the documentation of this file.

//  SuperTux
//  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef HEADER_SUPERTUX_BADGUY_BADGUY_HPP
#define HEADER_SUPERTUX_BADGUY_BADGUY_HPP

#include "object/moving_sprite.hpp"
#include "supertux/direction.hpp"
#include "supertux/physic.hpp"
#include "supertux/timer.hpp"

class Player;
class Bullet;

class BadGuy : public MovingSprite
{
public:
  BadGuy(const Vector& pos, const std::string& sprite_name, int layer = LAYER_OBJECTS);
  BadGuy(const Vector& pos, Direction direction, const std::string& sprite_name, int layer = LAYER_OBJECTS);
  BadGuy(const Reader& reader, const std::string& sprite_name, int layer = LAYER_OBJECTS);

  virtual void draw(DrawingContext& context);

  virtual void update(float elapsed_time);

  virtual HitResponse collision(GameObject& other, const CollisionHit& hit);

  virtual void collision_tile(uint32_t tile_attributes);

  virtual void kill_fall();
  
  virtual void run_dead_script();

  virtual bool can_break()
  {
    return false;
  }

  Vector get_start_position() const
  {
    return start_position;
  }

  void set_start_position(const Vector& vec)
  {
    start_position = vec;
  }

  virtual void ignite();

  virtual void extinguish();

  virtual bool is_flammable() const;

  bool is_ignited() const;

  virtual void freeze();

  virtual void unfreeze();

  virtual bool is_freezable() const;

  bool is_frozen() const;

protected:
  enum State {
    STATE_INIT,
    STATE_INACTIVE,
    STATE_ACTIVE,
    STATE_SQUISHED,
    STATE_FALLING
  };

protected:
  virtual HitResponse collision_player(Player& player, const CollisionHit& hit);

  virtual void collision_solid(const CollisionHit& hit);

  virtual HitResponse collision_badguy(BadGuy& other, const CollisionHit& hit);

  virtual bool collision_squished(GameObject& object);

  virtual HitResponse collision_bullet(Bullet& bullet, const CollisionHit& hit);

  virtual void active_update(float elapsed_time);

  virtual void inactive_update(float elapsed_time);

  virtual void initialize();
  
  virtual void activate();

  virtual void deactivate();

  void kill_squished(GameObject& object);

  void set_state(State state);
  State get_state() const
  { return state; }

  bool check_state_timer() {
    return state_timer.check();
  }

  Player* get_nearest_player();

  bool is_offscreen();

  bool might_fall(int height = 1);

  Direction str2dir( std::string dir_str );

  void update_on_ground_flag(const CollisionHit& hit);

  bool on_ground();

  Vector get_floor_normal();

  bool is_active();

  void set_colgroup_active(CollisionGroup group); 

private:
  void try_activate();

protected:
  Physic physic;

public:  
  bool countMe;

protected:
  bool is_initialized; 

  Vector start_position;

  Direction dir;

  Direction start_dir;

  bool frozen;
  bool ignited; 
  std::string dead_script; 
private:
  State state;

  bool is_active_flag; 

  Timer state_timer;

  bool on_ground_flag; 

  Vector floor_normal; 
  
  CollisionGroup colgroup_active;

private:
  BadGuy(const BadGuy&);
  BadGuy& operator=(const BadGuy&);
};

#endif

/* EOF */

---