src/object/player.hpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #ifndef HEADER_SUPERTUX_OBJECT_PLAYER_HPP
  18 #define HEADER_SUPERTUX_OBJECT_PLAYER_HPP
  19
  20 #include "scripting/player.hpp"
  21 #include "supertux/direction.hpp"
  22 #include "supertux/moving_object.hpp"
  23 #include "supertux/physic.hpp"
  24 #include "supertux/player_status.hpp"
  25 #include "supertux/script_interface.hpp"
  26 #include "supertux/timer.hpp"
  27
  28 class BadGuy;
  29 class Portable;
  30 class Climbable;
  31 class Controller;
  32 class CodeController;
  33 class Sprite;
  34 class Surface;
  35 class Timer;
  36
  37 /* Times: */
  38 static const float TUX_SAFE_TIME = 1.8f;
  39 static const float TUX_INVINCIBLE_TIME = 14.0f;
  40 static const float TUX_INVINCIBLE_TIME_WARNING = 2.0f;
  41 static const float GROWING_TIME = 0.35f;
  42 static const int GROWING_FRAMES = 7;
  43
  44 class Camera;
  45 class PlayerStatus;
  46
  47 class Player : public MovingObject,
  48                public scripting::Player,
  49                public ScriptInterface
  50 {
  51 public:
  52   enum FallMode { ON_GROUND, JUMPING, TRAMPOLINE_JUMP, FALLING };
  53   //Tux can only go this fast. If set to 0 no special limit is used, only the default limits.
  54   void set_speedlimit(float newlimit);
  55   float get_speedlimit();
  56
  57 public:
  58   Player(PlayerStatus* player_status, const std::string& name);
  59   virtual ~Player();
  60
  61   virtual void expose(HSQUIRRELVM vm, SQInteger table_idx);
  62   virtual void unexpose(HSQUIRRELVM vm, SQInteger table_idx);
  63
  64   void set_controller(Controller* controller);
  65   Controller* get_controller()
  66   {
  67     return controller;
  68   }
  69
  70   void use_scripting_controller(bool use_or_release);
  71   void do_scripting_controller(std::string control, bool pressed);
  72
  73   virtual void update(float elapsed_time);
  74   virtual void draw(DrawingContext& context);
  75   virtual void collision_solid(const CollisionHit& hit);
  76   virtual HitResponse collision(GameObject& other, const CollisionHit& hit);
  77   virtual void collision_tile(uint32_t tile_attributes);
  78
  79   void make_invincible();
  80   bool is_invincible() const
  81   {
  82     return invincible_timer.started();
  83   }
  84   bool is_dying() const
  85   {
  86     return dying;
  87   }
  88   Direction peeking_direction_x() const
  89   {
  90     return peekingX;
  91   }
  92
  93   Direction peeking_direction_y() const
  94   {
  95     return peekingY;
  96   }
  97
  98   void kill(bool completely);
  99   void check_bounds(Camera* camera);
 100   void move(const Vector& vector);
 101
 102   virtual bool add_bonus(const std::string& bonus);
 103   virtual void add_coins(int count);
 104   virtual int get_coins();
 105
 106   /**
 107    * picks up a bonus, taking care not to pick up lesser bonus items than we already have
 108    *
 109    * @returns true if the bonus has been set (or was already good enough)
 110    *          false if the bonus could not be set (for example no space for big tux)
 111    */
 112   bool add_bonus(BonusType type, bool animate = false);
 113   /**
 114    * like add_bonus, but can also downgrade the bonus items carried
 115    */
 116   bool set_bonus(BonusType type, bool animate = false);
 117
 118   PlayerStatus* get_status()
 119   {
 120     return player_status;
 121   }
 122   // set kick animation
 123   void kick();
 124
 125   /**
 126    * play cheer animation.
 127    * This might need some space and behave in an unpredictable way. Best to use this at level end.
 128    */
 129   void do_cheer();
 130
 131   /**
 132    * duck down if possible.
 133    * this won't last long as long as input is enabled.
 134    */
 135   void do_duck();
 136
 137   /**
 138    * stand back up if possible.
 139    */
 140   void do_standup();
 141
 142   /**
 143    * do a backflip if possible.
 144    */
 145   void do_backflip();
 146
 147   /**
 148    * jump in the air if possible
 149    * sensible values for yspeed are negative - unless we want to jump into the ground of course
 150    */
 151   void do_jump(float yspeed);
 152
 153   /**
 154    * Adds velocity to the player (be careful when using this)
 155    */
 156   void add_velocity(const Vector& velocity);
 157
 158   /**
 159    * Adds velocity to the player until given end speed is reached
 160    */
 161   void add_velocity(const Vector& velocity, const Vector& end_speed);
 162
 163   /**
 164    * Returns the current velocity of the player
 165    */
 166   Vector get_velocity();
 167
 168   void bounce(BadGuy& badguy);
 169
 170   bool is_dead() const
 171   { return dead; }
 172   bool is_big();
 173
 174   void set_visible(bool visible);
 175   bool get_visible();
 176
 177   bool on_ground();
 178
 179   Portable* get_grabbed_object() const
 180   {
 181     return grabbed_object;
 182   }
 183   void stop_grabbing()
 184   {
 185     grabbed_object = NULL;
 186   }
 187
 188   /**
 189    * Switches ghost mode on/off.
 190    * Lets Tux float around and through solid objects.
 191    */
 192   void set_ghost_mode(bool enable);
 193
 194   /**
 195    * Switches edit mode on/off.
 196    * In edit mode, Tux will enter ghost_mode instead of dying.
 197    */
 198   void set_edit_mode(bool enable);
 199
 200   /**
 201    * Returns whether ghost mode is currently enabled
 202    */
 203   bool get_ghost_mode() { return ghost_mode; }
 204
 205   /**
 206    * Changes height of bounding box.
 207    * Returns true if successful, false otherwise
 208    */
 209   bool adjust_height(float new_height);
 210
 211   /**
 212    * Orders the current GameSession to start a sequence
 213    */
 214   void trigger_sequence(std::string sequence_name);
 215
 216   /**
 217    * Requests that the player start climbing the given Climbable
 218    */
 219   void start_climbing(Climbable& climbable);
 220
 221   /**
 222    * Requests that the player stop climbing the given Climbable
 223    */
 224   void stop_climbing(Climbable& climbable);
 225
 226   Physic& get_physic() { return physic; }
 227
 228 private:
 229   void handle_input();
 230   void handle_input_ghost(); /**< input handling while in ghost mode */
 231   void handle_input_climbing(); /**< input handling while climbing */
 232
 233   void init();
 234
 235   void handle_horizontal_input();
 236   void handle_vertical_input();
 237
 238   void activate();
 239   void deactivate();
 240   void walk(float speed);
 241
 242   void do_jump_apex();
 243   void early_jump_apex();
 244
 245   /**
 246    * slows Tux down a little, based on where he's standing
 247    */
 248   void apply_friction();
 249
 250 private:
 251   bool deactivated;
 252
 253   Controller* controller;
 254   std::auto_ptr<CodeController> scripting_controller; /**< This controller is used when the Player is controlled via scripting */
 255   PlayerStatus* player_status;
 256   bool duck;
 257   bool dead;
 258
 259 private:
 260   bool dying;
 261   bool backflipping;
 262   int  backflip_direction;
 263   Direction peekingX;
 264   Direction peekingY;
 265   bool swimming;
 266   float speedlimit;
 267   Controller* scripting_controller_old; /**< Saves the old controller while the scripting_controller is used */
 268   bool jump_early_apex;
 269   bool on_ice;
 270   bool ice_this_frame;
 271
 272 public:
 273   Direction dir;
 274   Direction old_dir;
 275
 276   float last_ground_y;
 277   FallMode fall_mode;
 278
 279   bool on_ground_flag;
 280   bool jumping;
 281   bool can_jump;
 282   Timer jump_button_timer; /**< started when player presses the jump button; runs until Tux jumps or JUMP_GRACE_TIME runs out */
 283   bool wants_buttjump;
 284   bool does_buttjump;
 285
 286   Timer invincible_timer;
 287   Timer skidding_timer;
 288   Timer safe_timer;
 289   Timer kick_timer;
 290   Timer shooting_timer;   // used to show the arm when Tux is shooting
 291   Timer dying_timer;
 292   bool growing;
 293   Timer backflip_timer;
 294
 295   Physic physic;
 296
 297   bool visible;
 298
 299   Portable* grabbed_object;
 300
 301   std::auto_ptr<Sprite> sprite; /**< The main sprite representing Tux */
 302
 303   std::auto_ptr<Surface> airarrow; /**< arrow indicating Tux' position when he's above the camera */
 304
 305   Vector floor_normal;
 306   void try_grab();
 307
 308   bool ghost_mode; /**< indicates if Tux should float around and through solid objects */
 309   bool edit_mode; /**< indicates if Tux should switch to ghost mode rather than dying */
 310
 311   Timer unduck_hurt_timer; /**< if Tux wants to stand up again after ducking and cannot, this timer is started */
 312
 313   Timer idle_timer;
 314   unsigned int idle_stage;
 315
 316   Climbable* climbing; /**< Climbable object we are currently climbing, null if none */
 317
 318 private:
 319   Player(const Player&);
 320   Player& operator=(const Player&);
 321 };
 322
 323 #endif /*SUPERTUX_PLAYER_H*/
 324
 325 /* EOF */