X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fobject%2Fplayer.hpp;h=f27decd4a232f4c02374451d9c7351a2b0ddea94;hb=9ba388a672ff024010e38b09e576edf8730bb454;hp=43cddf99904b7eb849d2eb9e5a2d78414227634c;hpb=eb6819ec3002b546e67401f7600cc93e0ec32daf;p=supertux.git diff --git a/src/object/player.hpp b/src/object/player.hpp index 43cddf999..f27decd4a 100644 --- a/src/object/player.hpp +++ b/src/object/player.hpp @@ -1,7 +1,7 @@ // $Id$ // -// SuperTux - A Jump'n Run -// Copyright (C) 2003 Tobias Glaesser +// SuperTux +// Copyright (C) 2006 Matthias Braun // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License @@ -16,6 +16,7 @@ // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + #ifndef SUPERTUX_PLAYER_H #define SUPERTUX_PLAYER_H @@ -32,16 +33,19 @@ #include "scripting/player.hpp" #include "player_status.hpp" #include "display_effect.hpp" +#include "script_interface.hpp" #include "console.hpp" +#include "coin.hpp" class BadGuy; class Portable; +class Climbable; /* Times: */ -static const float TUX_SAFE_TIME = 1.8; -static const float TUX_INVINCIBLE_TIME = 10.0; -static const float TUX_INVINCIBLE_TIME_WARNING = 2.0; -static const float GROWING_TIME = 1.0; +static const float TUX_SAFE_TIME = 1.8f; +static const float TUX_INVINCIBLE_TIME = 10.0f; +static const float TUX_INVINCIBLE_TIME_WARNING = 2.0f; +static const float GROWING_TIME = 0.35f; static const int GROWING_FRAMES = 7; class Camera; @@ -65,7 +69,7 @@ public: void set_action(std::string action, int loops = -1); void one_time_animation(); - void draw(DrawingContext& context, const Vector& pos, int layer); + void draw(DrawingContext& context, const Vector& pos, int layer, Portable* grabbed_object); Sprite* head; Sprite* body; @@ -78,22 +82,27 @@ extern TuxBodyParts* big_tux; extern TuxBodyParts* fire_tux; extern TuxBodyParts* ice_tux; -class Player : public MovingObject, public Scripting::Player, public ConsoleCommandReceiver +class Player : public MovingObject, public UsesPhysic, public Scripting::Player, public ScriptInterface { public: - enum HurtMode { KILL, SHRINK }; enum FallMode { ON_GROUND, JUMPING, TRAMPOLINE_JUMP, FALLING }; Controller* controller; PlayerStatus* player_status; bool duck; bool dead; + //Tux can only go this fast. If set to 0 no special limit is used, only the default limits. + void set_speedlimit(float newlimit); + float get_speedlimit(); private: bool dying; bool backflipping; int backflip_direction; - + Direction peeking; + bool swimming; + float speedlimit; + public: Direction dir; Direction old_dir; @@ -115,16 +124,23 @@ public: Timer growing_timer; Timer idle_timer; Timer backflip_timer; - Physic physic; - + public: - Player(PlayerStatus* player_status); + Player(PlayerStatus* player_status, const std::string& name); virtual ~Player(); - void set_controller(Controller* controller); + virtual void expose(HSQUIRRELVM vm, SQInteger table_idx); + virtual void unexpose(HSQUIRRELVM vm, SQInteger table_idx); + + void set_controller(Controller* controller); + Controller* get_controller() + { + return controller; + } virtual void update(float elapsed_time); virtual void draw(DrawingContext& context); + virtual void collision_solid(const CollisionHit& hit); virtual HitResponse collision(GameObject& other, const CollisionHit& hit); virtual void collision_tile(uint32_t tile_attributes); @@ -137,11 +153,31 @@ public: { return dying; } - - void kill(HurtMode mode); + Direction peeking_direction() const + { + return peeking; + } + + void kill(bool completely); void check_bounds(Camera* camera); void move(const Vector& vector); - void set_bonus(BonusType type, bool animate = false); + + virtual bool add_bonus(const std::string& bonus); + virtual void add_coins(int count); + virtual int get_coins(); + + /** + * picks up a bonus, taking care not to pick up lesser bonus items than we already have + * + * @returns true if the bonus has been set (or was already good enough) + * false if the bonus could not be set (for example no space for big tux) + */ + bool add_bonus(BonusType type, bool animate = false); + /** + * like add_bonus, but can also downgrade the bonus items carried + */ + bool set_bonus(BonusType type, bool animate = false); + PlayerStatus* get_status() { return player_status; @@ -150,10 +186,43 @@ public: void kick(); /** + * play cheer animation. + * This might need some space and behave in an unpredictable way. Best to use this at level end. + */ + void do_cheer(); + + /** + * duck down if possible. + * this won't last long as long as input is enabled. + */ + void do_duck(); + + /** + * stand back up if possible. + */ + void do_standup(); + + /** + * do a backflip if possible. + */ + void do_backflip(); + + /** + * jump in the air if possible + * sensible values for yspeed are negative - unless we want to jump into the ground of course + */ + void do_jump(float yspeed); + + /** * Adds velocity to the player (be carefull when using this) */ void add_velocity(const Vector& velocity); + /** + * Adds velocity to the player until given end speed is reached + */ + void add_velocity(const Vector& velocity, const Vector& end_speed); + void bounce(BadGuy& badguy); bool is_dead() const @@ -165,14 +234,51 @@ public: bool on_ground(); - bool consoleCommand(std::string command, std::vector arguments); /**< callback from Console; return false if command was unknown, true otherwise */ + Portable* get_grabbed_object() const + { + return grabbed_object; + } + + /** + * Switches ghost mode on/off. + * Lets Tux float around and through solid objects. + */ + void set_ghost_mode(bool enable); + + /** + * Returns whether ghost mode is currently enabled + */ + bool get_ghost_mode() { return ghost_mode; } + + /** + * Changes height of bounding box. + * Returns true if successful, false otherwise + */ + bool adjust_height(float new_height); + + /** + * Orders the current GameSession to start a sequence + */ + void trigger_sequence(std::string sequence_name); + /** + * Requests that the player start climbing the given Climbable + */ + void start_climbing(Climbable& climbable); + + /** + * Requests that the player stop climbing the given Climbable + */ + void stop_climbing(Climbable& climbable); + private: void handle_input(); + void handle_input_ghost(); /**< input handling while in ghost mode */ + void handle_input_climbing(); /**< input handling while climbing */ bool deactivated; - + void init(); - + void handle_horizontal_input(); void handle_vertical_input(); @@ -180,16 +286,29 @@ private: void deactivate(); void walk(float speed); - bool visible; + /** + * slows Tux down a little, based on where he's standing + */ + void apply_friction(); - float adjust_height; + bool visible; Portable* grabbed_object; Sprite* smalltux_gameover; Sprite* smalltux_star; Sprite* bigtux_star; + + std::auto_ptr airarrow; /**< arrow indicating Tux' position when he's above the camera */ + Vector floor_normal; + void try_grab(); + + bool ghost_mode; /**< indicates if Tux should float around and through solid objects */ + + Timer unduck_hurt_timer; /**< if Tux wants to stand up again after ducking and cannot, this timer is started */ + + Climbable* climbing; /**< Climbable object we are currently climbing, null if none */ }; #endif /*SUPERTUX_PLAYER_H*/