kart.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2004-2015 Steve Baker <sjbaker1@airmail.net>
//  Copyright (C) 2006-2015 SuperTuxKart-Team, Joerg Henrichs, Steve Baker
//
//  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, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef HEADER_KART_HPP
#define HEADER_KART_HPP
 
#include "LinearMath/btTransform.h"
 
#include "items/powerup_manager.hpp"    // For PowerupType
#include "karts/abstract_kart.hpp"
#include "utils/cpp2011.hpp"
#include "utils/no_copy.hpp"
 
#include <SColor.h>
 
class AbstractKartAnimation;
class Attachment;
class btKart;
class btUprightConstraint;
class Controller;
class HitEffect;
class Item;
class ItemState;
class KartGFX;
class KartRewinder;
class MaxSpeed;
class ParticleKind;
class SFXBase;
class Shadow;
class Skidding;
class SkidMarks;
class SlipStream;
class Stars;
class TerrainInfo;
 
#ifndef SERVER_ONLY
class ParticleEmitter;
#endif
 
class Kart : public AbstractKart
{
    friend class Skidding;
private:
    int m_network_finish_check_ticks;
    int m_network_confirmed_finish_ticks;
protected:
    float m_graphical_y_offset;
 
    Vec3 m_xyz_front;
 
    /* Determines the time covered by the history size, in seconds */
    const float XYZ_HISTORY_TIME = 0.25f;
 
    /* Determines the number of previous XYZ positions of the kart to remember
       Initialized in the constructor and unchanged from then on */
    int m_xyz_history_size;
 
    std::vector<Vec3> m_previous_xyz;
 
    std::vector<float> m_previous_xyz_times;
 
    float m_time_previous_counter;
 
    bool m_is_jumping;
 
    bool        m_bubblegum_torque_sign;
 
    uint8_t      m_bounce_back_ticks;
 
protected:
    MaxSpeed *m_max_speed;
 
    TerrainInfo *m_terrain_info;
 
    Powerup *m_powerup;
 
    std::unique_ptr<btVehicleRaycaster> m_vehicle_raycaster;
 
    std::unique_ptr<btKart> m_vehicle;
 
    std::unique_ptr<Skidding> m_skidding;
 
    std::unique_ptr<Stars> m_stars_effect;
 
    // Graphical effects
    // -----------------
 
#ifndef SERVER_ONLY
    std::unique_ptr<Shadow> m_shadow;
 
    std::unique_ptr<SkidMarks> m_skidmarks;
#endif
 
    std::unique_ptr<KartGFX> m_kart_gfx;
 
    std::unique_ptr<SlipStream> m_slipstream;
 
    // Bullet physics parameters
    // -------------------------
    struct btCompoundShapeDeleter
    {
        void operator()(btCompoundShape* p) const
        {
            for(int i = 0; i< p->getNumChildShapes(); i++)
                delete p->getChildShape(i);
            delete p;
        }
    };
    std::unique_ptr<btCompoundShape, btCompoundShapeDeleter> m_kart_chassis;
 
#ifndef SERVER_ONLY
    ParticleEmitter *m_collision_particles;
#endif
 
    Controller  *m_controller;
 
    Controller  *m_saved_controller;
 
    PowerupManager::PowerupType m_last_used_powerup;
 
    bool m_flying;
 
    bool m_has_caught_nolok_bubblegum;
 
    bool m_race_result;
 
    bool m_eliminated;
 
    int m_initial_position;
 
    int m_race_position;
 
    float        m_max_gear_rpm;
 
    int          m_brake_ticks;
 
    int16_t      m_invulnerable_ticks;
 
    int16_t      m_bubblegum_ticks;
 
    int16_t       m_view_blocked_by_plunger;
 
    float        m_current_lean;
 
    int8_t        m_min_nitro_ticks;
 
    bool         m_fire_clicked;
 
    bool         m_boosted_ai;
 
    bool            m_finished_race;
 
    float           m_finish_time;
 
    float         m_collected_energy;
 
    float         m_consumption_per_tick;
 
    float         m_energy_to_min_ratio;
 
    float           m_startup_boost;
 
    float           m_falling_time;
 
    float           m_weight;
 
    float         m_speed;
 
    float         m_last_factor_engine_sound;
 
    float         m_default_suspension_force;
 
    btTransform  m_reset_transform;
 
    std::vector<SFXBase*> m_custom_sounds;
    int m_emitter_id = 0;
    static const int EMITTER_COUNT = 3;
    SFXBase      *m_emitters[EMITTER_COUNT];
    SFXBase      *m_engine_sound;
    SFXBase      *m_terrain_sound;
 
    const Material *m_last_sound_material;
 
    SFXBase      *m_nitro_sound;
    SFXBase      *m_previous_terrain_sound;
    SFXBase      *m_skid_sound;
    SFXBuffer    *m_horn_sound;
    static const int CRASH_SOUND_COUNT = 3;
    SFXBuffer    *m_crash_sounds[CRASH_SOUND_COUNT];
    SFXBuffer    *m_goo_sound;
    SFXBuffer    *m_boing_sound;
    /* Used to avoid re-play the sound during rewinding, if it's happening at
     * the same ticks. */
    int          m_ticks_last_crash;
    int          m_ticks_last_zipper;
    RaceManager::KartType m_type;
 
    void          updatePhysics(int ticks);
    void          handleMaterialSFX();
    void          handleMaterialGFX(float dt);
    void          updateFlying();
    void          updateSliding();
    void          updateEnginePowerAndBrakes(int ticks);
    void          updateEngineSFX(float dt);
    void          updateSpeed();
    void          updateNitro(int ticks);
    float         applyAirFriction (float engine_power);
    float         getActualWheelForce();
    void          playCrashSFX(const Material* m, AbstractKart *k);
    void          loadData(RaceManager::KartType type, bool animatedModel);
    void          updateWeight();
    void          initSound();
public:
                   Kart(const std::string& ident, unsigned int world_kart_id,
                        int position, const btTransform& init_transform,
                        HandicapLevel handicap,
                        std::shared_ptr<GE::GERenderInfo> ri);
    virtual       ~Kart();
    virtual void   init(RaceManager::KartType type) OVERRIDE;
    virtual void   kartIsInRestNow() OVERRIDE;
    virtual void   updateGraphics(float dt) OVERRIDE;
    virtual void   createPhysics    ();
    virtual bool   isInRest         () const OVERRIDE;
    virtual void   applyEngineForce (float force);
 
    virtual void   flyUp() OVERRIDE;
    virtual void   flyDown() OVERRIDE;
 
    virtual void   startEngineSFX   () OVERRIDE;
    virtual void  collectedItem(ItemState *item) OVERRIDE;
    virtual float getStartupBoostFromStartTicks(int ticks) const OVERRIDE;
    virtual float getStartupBoost() const OVERRIDE  { return m_startup_boost; }
    virtual void setStartupBoost(float val) OVERRIDE { m_startup_boost = val; }
    virtual const Material *getMaterial() const OVERRIDE;
    virtual const Material *getLastMaterial() const OVERRIDE;
    virtual float getTerrainPitch(float heading) const OVERRIDE;
 
    virtual void   reset            () OVERRIDE;
    virtual void   handleZipper     (const Material *m=NULL,
                                     bool play_sound=false) OVERRIDE;
    virtual bool   setSquash        (float time, float slowdown) OVERRIDE;
            void   setSquashGraphics();
    virtual void   unsetSquash      () OVERRIDE;
 
    virtual void   crashed          (AbstractKart *k, bool update_attachments) OVERRIDE;
    virtual void   crashed          (const Material *m, const Vec3 &normal) OVERRIDE;
    virtual float  getHoT           () const OVERRIDE;
    virtual void   update           (int ticks) OVERRIDE;
    virtual void   finishedRace     (float time, bool from_server=false) OVERRIDE;
    virtual void   setPosition      (int p) OVERRIDE;
    virtual void   beep             () OVERRIDE;
    virtual void   showZipperFire   () OVERRIDE;
 
 
    virtual bool   playCustomSFX    (unsigned int type) OVERRIDE;
    virtual void   setController(Controller *controller) OVERRIDE;
    virtual void   setXYZ(const Vec3& a) OVERRIDE;
    virtual void changeKart(const std::string& new_ident,
                            HandicapLevel handicap,
                            std::shared_ptr<GE::GERenderInfo> ri,
                            const KartData& kart_data = KartData()) OVERRIDE;
 
    // ========================================================================================
    // SPEED and speed-boost related functions
    // ----------------------------------------------------------------------------------------
    virtual void   adjustSpeed      (float f) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void   increaseMaxSpeed(unsigned int category, float add_speed,
                                    float engine_force, int duration,
                                    int fade_out_time) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void   instantSpeedIncrease(unsigned int category, float add_max_speed,
                                    float speed_boost, float engine_force, 
                                    int duration, int fade_out_time) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void   setSlowdown(unsigned int category, float max_speed_fraction,
                               int fade_in_time) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual int   getSpeedIncreaseTicksLeft(unsigned int category) const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual float  getSpeed() const OVERRIDE { return m_speed; }
    // ----------------------------------------------------------------------------------------
    virtual float  getCurrentMaxSpeed() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void setSpeed(float s) OVERRIDE { m_speed = s; }
 
    // ========================================================================================
    // STEERING and skidding related functions
    // ----------------------------------------------------------------------------------------
    virtual float getMaxSteerAngle () const OVERRIDE
                    { return getMaxSteerAngle(getSpeed()); }
    // ----------------------------------------------------------------------------------------
    virtual float getTimeFullSteer(float steer) const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual float  getSpeedForTurnRadius(float radius) const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual float  getMaxSteerAngle(float speed) const;
    // ----------------------------------------------------------------------------------------
    virtual const Skidding *getSkidding() const OVERRIDE { return m_skidding.get(); }
    // ----------------------------------------------------------------------------------------
    virtual Skidding *getSkidding() OVERRIDE { return m_skidding.get(); }
 
    // ========================================================================================
    // NITRO related functions.
    // ----------------------------------------------------------------------------------------
    virtual float getEnergy() const OVERRIDE { return m_collected_energy; }
    // ----------------------------------------------------------------------------------------
    virtual void setEnergy(float val) OVERRIDE { m_collected_energy = val; }
    // ----------------------------------------------------------------------------------------
    virtual bool isOnMinNitroTime() const OVERRIDE { return m_min_nitro_ticks > 0; }
 
    // ========================================================================================
    // POWERUP related functions.
    // ----------------------------------------------------------------------------------------
    virtual void setPowerup (PowerupManager::PowerupType t, int n) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void setLastUsedPowerup (PowerupManager::PowerupType t);
    // ----------------------------------------------------------------------------------------
    virtual const Powerup* getPowerup() const OVERRIDE { return m_powerup; }
    // ----------------------------------------------------------------------------------------
    virtual Powerup* getPowerup() OVERRIDE  { return m_powerup; }
    // ----------------------------------------------------------------------------------------
    virtual PowerupManager::PowerupType getLastUsedPowerup() OVERRIDE
    {
        return m_last_used_powerup;
    }
    // ----------------------------------------------------------------------------------------
    virtual int getNumPowerup() const OVERRIDE;
 
    // ========================================================================================
    // SPECIAL-STATUS related functions (plunger, squash, shield, immunity).
    // ----------------------------------------------------------------------------------------
    virtual void setInvulnerableTicks(int ticks) OVERRIDE
    {
        // int16_t max
        if (ticks > 32767)
            ticks = 32767;
        m_invulnerable_ticks = ticks;
    }   // setInvulnerableTicks
    // ----------------------------------------------------------------------------------------
    virtual bool isInvulnerable() const OVERRIDE { return m_invulnerable_ticks > 0; }
    // ----------------------------------------------------------------------------------------
    virtual int getBlockedByPlungerTicks() const OVERRIDE
                                         { return m_view_blocked_by_plunger; }
    // ----------------------------------------------------------------------------------------
    virtual void blockViewWithPlunger() OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void setShieldTime(float t) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual bool isShielded() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual float getShieldTime() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void decreaseShieldTime() OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual bool isSquashed() const OVERRIDE;
 
    // ========================================================================================
    // CONTROLLER related functions
    // ----------------------------------------------------------------------------------------
    virtual void  setBoostAI     (bool boosted) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual bool  getBoostAI     () const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual Controller* getController() OVERRIDE { return m_controller; }
    // ----------------------------------------------------------------------------------------
    const Controller* getController() const OVERRIDE { return m_controller; }
 
    // ========================================================================================
    // LOCATION ON-TRACK related functions
    // ----------------------------------------------------------------------------------------
    virtual const Vec3& getFrontXYZ() const OVERRIDE { return m_xyz_front; }
    // -----------------------------------------------------------------------------------------
    virtual btTransform getAlignedTransform(const float customPitch=-1) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    const btTransform& getResetTransform() const {return m_reset_transform;}
    // ----------------------------------------------------------------------------------------
    virtual bool isOnGround() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    bool isNearGround() const;
    // ----------------------------------------------------------------------------------------
    virtual const Vec3& getNormal() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual const Vec3& getPreviousXYZ() const OVERRIDE
            { return m_previous_xyz[m_xyz_history_size-1]; }
    // ----------------------------------------------------------------------------------------
    virtual const Vec3& getRecentPreviousXYZ() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual const float getRecentPreviousXYZTime() const OVERRIDE
            { return m_previous_xyz_times[m_xyz_history_size/5]; }
    // ----------------------------------------------------------------------------------------
    bool isFlying() const { return m_flying;  }
    // ----------------------------------------------------------------------------------------
    virtual bool isJumping() const OVERRIDE { return m_is_jumping; }
    // ----------------------------------------------------------------------------------------
    virtual const TerrainInfo *getTerrainInfo() const OVERRIDE { return m_terrain_info; }
 
    // ========================================================================================
    // ----------------------------------------------------------------------------------------
    virtual KartGFX* getKartGFX() OVERRIDE         { return m_kart_gfx.get(); }
    // ----------------------------------------------------------------------------------------
    virtual int getPosition() const OVERRIDE { return m_race_position; }
    // ----------------------------------------------------------------------------------------
    virtual int getInitialPosition () const OVERRIDE { return m_initial_position; }
    // ----------------------------------------------------------------------------------------
    virtual float getFinishTime () const OVERRIDE { return m_finish_time; }
    // ----------------------------------------------------------------------------------------
    virtual bool hasFinishedRace () const OVERRIDE { return m_finished_race; }
    // -----------------------------------------------------------------------------------------
    const irr::video::SColor &getColor() const;
    // ----------------------------------------------------------------------------------------
    virtual RaceManager::KartType getType() const OVERRIDE { return m_type; }
    // ----------------------------------------------------------------------------------------
    virtual btKart *getVehicle() const OVERRIDE { return m_vehicle.get(); }
    // ----------------------------------------------------------------------------------------
    virtual btQuaternion getVisualRotation() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual const SlipStream* getSlipstream() const OVERRIDE { return m_slipstream.get(); }
    // ----------------------------------------------------------------------------------------
    virtual SlipStream* getSlipstream() OVERRIDE  {return m_slipstream.get(); }
    // ----------------------------------------------------------------------------------------
    virtual void setSlipstreamEffect(float f) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual bool isEliminated() const OVERRIDE { return m_eliminated; }
    // ----------------------------------------------------------------------------------------
    virtual void eliminate() OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void setOnScreenText(const core::stringw& text) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual bool getRaceResult() const OVERRIDE { return m_race_result;  }
    // ----------------------------------------------------------------------------------------
    void setRaceResult();
    // ----------------------------------------------------------------------------------------
    virtual bool isGhostKart() const OVERRIDE { return false;  }
    // ----------------------------------------------------------------------------------------
    SFXBase* getNextEmitter();
    // ----------------------------------------------------------------------------------------
    virtual void playSound(SFXBuffer* buffer) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual bool isVisible() const OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual void showStarEffect(float t) OVERRIDE;
    // ----------------------------------------------------------------------------------------
    virtual Stars* getStarsEffect() const OVERRIDE
                                               { return m_stars_effect.get(); }
    // ------------------------------------------------------------------------
    int getNetworkConfirmedFinishTicks() const OVERRIDE
                                   { return m_network_confirmed_finish_ticks; }
 
};   // Kart
 
 
#endif
 
/* EOF */