X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fobject%2Fplayer.hpp;h=f27decd4a232f4c02374451d9c7351a2b0ddea94;hb=9ba388a672ff024010e38b09e576edf8730bb454;hp=ddf02b578e63c86c95de44644d2a9de3d5533329;hpb=b72c5d178e4cc95130735d8bf8716513c7cc28e1;p=supertux.git diff --git a/src/object/player.hpp b/src/object/player.hpp index ddf02b578..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 @@ -29,20 +30,22 @@ #include "sprite/sprite.hpp" #include "physic.hpp" #include "control/controller.hpp" -#include "player_status.hpp" #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 TUX_FLAPPING_TIME = 1; /* How long Tux can flap his wings to gain additional jump height */ -static const float TUX_FLAPPING_STRENGTH = 100; /* How much Y velocity Tux gains when flapping */ -static const float TUX_FLAPPING_LEAST_X = 30; /* How much X velocity Tux gains when flapping from vertical jump */ -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; @@ -66,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; @@ -79,21 +82,28 @@ extern TuxBodyParts* big_tux; extern TuxBodyParts* fire_tux; extern TuxBodyParts* ice_tux; -class Player : public MovingObject, public Scripting::Player +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; -public: + bool backflipping; + int backflip_direction; + Direction peeking; + bool swimming; + float speedlimit; +public: Direction dir; Direction old_dir; @@ -102,22 +112,8 @@ public: bool on_ground_flag; bool jumping; - bool flapping; bool can_jump; - bool can_flap; - bool falling_from_flap; - bool enable_hover; bool butt_jump; - - float flapping_velocity; - - // Ricardo's flapping - int flaps_nb; - - // temporary to help player's choosing a flapping - // TODO: remove this after agreeing on flapstyle! - enum { MAREK_FLAP, RICARDO_FLAP, RYAN_FLAP, NO_FLAP }; - int flapping_mode; Timer invincible_timer; Timer skidding_timer; @@ -127,18 +123,26 @@ public: Timer dying_timer; Timer growing_timer; Timer idle_timer; - Timer flapping_timer; - Physic physic; - + Timer backflip_timer; + 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); void make_invincible(); bool is_invincible() const @@ -149,36 +153,162 @@ 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; } + // set kick animation + 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 { return dead; } bool is_big(); + + void set_visible(bool visible); + bool get_visible(); + + bool on_ground(); + + 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(); - bool on_ground(); - + 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(); + void activate(); + void deactivate(); + void walk(float speed); + + /** + * slows Tux down a little, based on where he's standing + */ + void apply_friction(); + + 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*/