X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fobject%2Fplayer.hpp;h=bcbbcbc79915b4b6d676299202b34632fa887f58;hb=dae274f7bc4ae7914207586dd7e7b1cfc5f3a98f;hp=4226f9ebc5616bb8950981575acbf9226729da85;hpb=77d6c22146b06e5737b905795c8d7aab3f146527;p=supertux.git diff --git a/src/object/player.hpp b/src/object/player.hpp index 4226f9ebc..bcbbcbc79 100644 --- a/src/object/player.hpp +++ b/src/object/player.hpp @@ -1,12 +1,10 @@ -// $Id$ -// // 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 -// as published by the Free Software Foundation; either version 2 -// of the License, or (at your option) any later version. +// 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 @@ -14,122 +12,77 @@ // 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, 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 - -#include -#include - -#include "timer.hpp" -#include "direction.hpp" -#include "video/surface.hpp" -#include "moving_object.hpp" -#include "sprite/sprite.hpp" -#include "physic.hpp" -#include "control/controller.hpp" +// along with this program. If not, see . + +#ifndef HEADER_SUPERTUX_OBJECT_PLAYER_HPP +#define HEADER_SUPERTUX_OBJECT_PLAYER_HPP + #include "scripting/player.hpp" -#include "player_status.hpp" -#include "display_effect.hpp" -#include "script_interface.hpp" -#include "console.hpp" -#include "coin.hpp" +#include "sprite/sprite_ptr.hpp" +#include "supertux/direction.hpp" +#include "supertux/moving_object.hpp" +#include "supertux/physic.hpp" +#include "supertux/player_status.hpp" +#include "supertux/script_interface.hpp" +#include "supertux/timer.hpp" class BadGuy; class Portable; +class Climbable; +class Controller; +class CodeController; +class Surface; +class Timer; /* 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 = 14.0f; +static const float TUX_INVINCIBLE_TIME_WARNING = 2.0f; +static const float GROWING_TIME = 0.35f; static const int GROWING_FRAMES = 7; +static const float TUX_BACKFLIP_TIME = 2.1f; // minimum air time that backflip results in a loss of control class Camera; class PlayerStatus; -extern Surface* growingtux_left[GROWING_FRAMES]; -extern Surface* growingtux_right[GROWING_FRAMES]; - -class TuxBodyParts -{ -public: - TuxBodyParts() - : head(0), body(0), arms(0), feet(0) - { } - ~TuxBodyParts() { - delete head; - delete body; - delete arms; - delete feet; - } - - void set_action(std::string action, int loops = -1); - void one_time_animation(); - void draw(DrawingContext& context, const Vector& pos, int layer); - - Sprite* head; - Sprite* body; - Sprite* arms; - Sprite* feet; -}; - -extern TuxBodyParts* small_tux; -extern TuxBodyParts* big_tux; -extern TuxBodyParts* fire_tux; -extern TuxBodyParts* ice_tux; - -class Player : public MovingObject, public Scripting::Player, public ScriptInterface +class Player : public MovingObject, + public scripting::Player, + public ScriptInterface { public: enum FallMode { ON_GROUND, JUMPING, TRAMPOLINE_JUMP, FALLING }; + //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(); - Controller* controller; - PlayerStatus* player_status; - bool duck; - bool dead; - -private: - bool dying; - bool backflipping; - int backflip_direction; - public: - Direction dir; - Direction old_dir; - - float last_ground_y; - FallMode fall_mode; + Player(PlayerStatus* player_status, const std::string& name); + virtual ~Player(); - bool on_ground_flag; - bool jumping; - bool can_jump; - bool butt_jump; + virtual void expose(HSQUIRRELVM vm, SQInteger table_idx); + virtual void unexpose(HSQUIRRELVM vm, SQInteger table_idx); - Timer invincible_timer; - Timer skidding_timer; - Timer safe_timer; - Timer kick_timer; - Timer shooting_timer; // used to show the arm when Tux is shooting - Timer dying_timer; - Timer growing_timer; - Timer idle_timer; - Timer backflip_timer; - Physic physic; - -public: - Player(PlayerStatus* player_status); - virtual ~Player(); + void set_controller(Controller* controller); + /* + * Level solved. Don't kill Tux any more. + */ + void set_winning(); + bool is_winning() + { + return winning; + } - virtual void expose(HSQUIRRELVM vm, int table_idx); - virtual void unexpose(HSQUIRRELVM vm, int table_idx); + Controller* get_controller() + { + return controller; + } - void set_controller(Controller* controller); + void use_scripting_controller(bool use_or_release); + void do_scripting_controller(std::string control, bool pressed); 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); @@ -142,15 +95,36 @@ public: { return dying; } - + Direction peeking_direction_x() const + { + return peekingX; + } + + Direction peeking_direction_y() const + { + return peekingY; + } + void kill(bool completely); - void check_bounds(Camera* camera); + void check_bounds(); void move(const Vector& vector); - virtual void add_bonus(const std::string& bonus); + virtual bool add_bonus(const std::string& bonus); virtual void add_coins(int count); - void add_bonus(BonusType type, bool animate = false); /**< picks up a bonus, taking care not to pick up lesser bonus items than we already have */ - void set_bonus(BonusType type, bool animate = false); /**< like add_bonus, but can also downgrade the bonus items carried */ + 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; @@ -159,10 +133,48 @@ public: void kick(); /** - * Adds velocity to the player (be carefull when using this) + * 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 careful 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); + + /** + * Returns the current velocity of the player + */ + Vector get_velocity(); + void bounce(BadGuy& badguy); bool is_dead() const @@ -174,29 +186,153 @@ public: bool on_ground(); + Portable* get_grabbed_object() const + { + return grabbed_object; + } + void stop_grabbing() + { + grabbed_object = NULL; + } + + /** + * Switches ghost mode on/off. + * Lets Tux float around and through solid objects. + */ + void set_ghost_mode(bool enable); + + /** + * Switches edit mode on/off. + * In edit mode, Tux will enter ghost_mode instead of dying. + */ + void set_edit_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); + + Physic& get_physic() { return physic; } + private: void handle_input(); - bool deactivated; - + void handle_input_ghost(); /**< input handling while in ghost mode */ + void handle_input_climbing(); /**< input handling while climbing */ + void init(); - + void handle_horizontal_input(); void handle_vertical_input(); void activate(); void deactivate(); void walk(float speed); + void set_dir(bool right); - bool visible; + void do_jump_apex(); + void early_jump_apex(); + + /** + * slows Tux down a little, based on where he's standing + */ + void apply_friction(); - float adjust_height; +private: + bool deactivated; + + Controller* controller; + std::auto_ptr scripting_controller; /**< This controller is used when the Player is controlled via scripting */ + PlayerStatus* player_status; + bool duck; + bool dead; + +private: + bool dying; + bool winning; + bool backflipping; + int backflip_direction; + Direction peekingX; + Direction peekingY; + bool swimming; + float speedlimit; + Controller* scripting_controller_old; /**< Saves the old controller while the scripting_controller is used */ + bool jump_early_apex; + bool on_ice; + bool ice_this_frame; + +public: + Direction dir; + Direction old_dir; + + float last_ground_y; + FallMode fall_mode; + + bool on_ground_flag; + bool jumping; + bool can_jump; + Timer jump_button_timer; /**< started when player presses the jump button; runs until Tux jumps or JUMP_GRACE_TIME runs out */ + bool wants_buttjump; + bool does_buttjump; + + Timer invincible_timer; + Timer skidding_timer; + Timer safe_timer; + Timer kick_timer; + Timer shooting_timer; // used to show the arm when Tux is shooting + Timer dying_timer; + bool growing; + Timer backflip_timer; + + Physic physic; + + bool visible; Portable* grabbed_object; - Sprite* smalltux_gameover; - Sprite* smalltux_star; - Sprite* bigtux_star; + SpritePtr sprite; /**< The main sprite representing Tux */ + + SurfacePtr airarrow; /**< arrow indicating Tux' position when he's above the camera */ + Vector floor_normal; + void position_grabbed_object(); + void try_grab(); + + bool ghost_mode; /**< indicates if Tux should float around and through solid objects */ + bool edit_mode; /**< indicates if Tux should switch to ghost mode rather than dying */ + + Timer unduck_hurt_timer; /**< if Tux wants to stand up again after ducking and cannot, this timer is started */ + + Timer idle_timer; + unsigned int idle_stage; + + Climbable* climbing; /**< Climbable object we are currently climbing, null if none */ + +private: + Player(const Player&); + Player& operator=(const Player&); }; #endif /*SUPERTUX_PLAYER_H*/ + +/* EOF */