abstract_kart.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2012-2015  Joerg Henrichs
//
//  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_ABSTRACT_KART_HPP
#define HEADER_ABSTRACT_KART_HPP
 
#include <memory>
 
#include "items/powerup_manager.hpp"
#include "karts/moveable.hpp"
#include "karts/controller/kart_control.hpp"
#include "race/race_manager.hpp"
 
namespace irr
{
    namespace scene
    {
        class IDummyTransformationSceneNode;
    }
}
 
class AbstractKartAnimation;
class Attachment;
class btKart;
class btQuaternion;
class Controller;
class Item;
class ItemState;
class KartGFX;
class KartModel;
class KartProperties;
class Material;
class Powerup;
namespace GE { class GERenderInfo; }
class SFXBuffer;
class Skidding;
class SlipStream;
class Stars;
class TerrainInfo;
 
 
class AbstractKart : public Moveable
{
private:
    float m_kart_length;
    float m_kart_width;
    float m_kart_height;
    float m_kart_highest_point;
    const Vec3* m_wheel_graphics_position;
 
    unsigned int m_world_kart_id;
 
    core::stringw m_name;
 
    // ------------------------------------------------------------------------
    void loadKartProperties(const std::string& new_ident,
                            HandicapLevel handicap,
                            std::shared_ptr<GE::GERenderInfo> ri,
                            const KartData& kart_data = KartData());
protected:
    btTransform m_starting_transform;
 
    int m_live_join_util;
 
    std::unique_ptr<KartProperties> m_kart_properties;
 
    HandicapLevel m_handicap;
 
    std::unique_ptr<KartModel> m_kart_model;
 
    std::unique_ptr<Attachment> m_attachment;
 
    KartControl  m_controls;
 
    AbstractKartAnimation *m_kart_animation;
 
    irr::scene::IDummyTransformationSceneNode    *m_wheel_box;
public:
                   AbstractKart(const std::string& ident,
                                int world_kart_id,
                                int position, const btTransform& init_transform,
                                HandicapLevel handicap,
                                std::shared_ptr<GE::GERenderInfo> ri);
    virtual       ~AbstractKart();
    // ------------------------------------------------------------------------
    const core::stringw& getName() const                     { return m_name; }
    // ------------------------------------------------------------------------
    virtual void   reset();
    virtual void   init(RaceManager::KartType type) = 0;
    // ========================================================================
    // Functions related to controlling the kart
    // ------------------------------------------------------------------------
    virtual float getSteerPercent() const { return m_controls.getSteer(); }
    // ------------------------------------------------------------------------
    KartControl&  getControls() { return m_controls; }
    // ------------------------------------------------------------------------
    const KartControl& getControls() const { return m_controls; }
 
    // ========================================================================
    // Access to the kart properties.
    // ------------------------------------------------------------------------
    const KartProperties* getKartProperties() const
                            { return m_kart_properties.get(); }
    // ========================================================================
    virtual void changeKart(const std::string& new_ident,
                            HandicapLevel handicap,
                            std::shared_ptr<GE::GERenderInfo> ri,
                            const KartData& kart_data = KartData());
    // ========================================================================
    // Access to the handicap.
    // ------------------------------------------------------------------------
    const HandicapLevel getHandicap() const { return m_handicap; }
    // ------------------------------------------------------------------------
    void setHandicap(const HandicapLevel h) { m_handicap=h; }
 
    // ------------------------------------------------------------------------
    virtual const std::string& getIdent() const;
    // ------------------------------------------------------------------------
    virtual float getMaxSteerAngle () const = 0;
    // ------------------------------------------------------------------------
    virtual float  getSpeedForTurnRadius(float radius) const = 0;
    // ------------------------------------------------------------------------
    virtual float getTimeFullSteer(float steer) const = 0;
 
    // ========================================================================
    // Attachment related functions.
    // ------------------------------------------------------------------------
    const Attachment* getAttachment() const {return m_attachment.get(); }
    // ------------------------------------------------------------------------
    Attachment*    getAttachment() {return m_attachment.get(); }
 
    // ========================================================================
    // Access to the graphical kart model.
    // ------------------------------------------------------------------------
    KartModel* getKartModel() const { return m_kart_model.get();      }
    // ------------------------------------------------------------------------
    float getKartLength() const { return m_kart_length; }
    // ------------------------------------------------------------------------
    float getKartHeight() const { return m_kart_height; }
    // ------------------------------------------------------------------------
    float getKartWidth() const {return m_kart_width; }
    // ------------------------------------------------------------------------
    float getHighestPoint() const { return m_kart_highest_point;  }
    // ------------------------------------------------------------------------
    virtual void kartIsInRestNow();
 
    // ------------------------------------------------------------------------
    virtual float getTimeForDistance(float distance);
    // ------------------------------------------------------------------------
    bool isWheeless() const;
    // ------------------------------------------------------------------------
    virtual const Vec3& getFrontXYZ() const = 0;
    // ------------------------------------------------------------------------
    const Vec3& getWheelGraphicsPosition(int i) const
                {assert(i>=0 && i<4); return m_wheel_graphics_position[i];}
 
    // ========================================================================
    // Emergency animation related functions.
    // ------------------------------------------------------------------------
    AbstractKartAnimation *getKartAnimation() { return m_kart_animation; }
    // ------------------------------------------------------------------------
    const AbstractKartAnimation *getKartAnimation() const
                                                   { return m_kart_animation; }
    // ------------------------------------------------------------------------
    virtual void setKartAnimation(AbstractKartAnimation *ka);
    // ------------------------------------------------------------------------
 
    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------
    unsigned int   getWorldKartId() const         { return m_world_kart_id;   }
    // ------------------------------------------------------------------------
    virtual void setController(Controller *controller) = 0;
    // ------------------------------------------------------------------------
    virtual Controller* getController() = 0;
    // ------------------------------------------------------------------------
    virtual const Controller* getController() const = 0;
    // ------------------------------------------------------------------------
    virtual const Skidding *getSkidding() const = 0;
    // ------------------------------------------------------------------------
    virtual RaceManager::KartType getType() const = 0;
    // ------------------------------------------------------------------------
    virtual Skidding *getSkidding() = 0;
    // ------------------------------------------------------------------------
    virtual bool isEliminated() const = 0;
    // ------------------------------------------------------------------------
    virtual void eliminate() = 0;
    // ------------------------------------------------------------------------
    virtual void finishedRace(float time, bool from_server=false) = 0;
    // ------------------------------------------------------------------------
    virtual float getFinishTime() const = 0;
    // ------------------------------------------------------------------------
    virtual int getBlockedByPlungerTicks() const = 0;
    // ------------------------------------------------------------------------
    virtual void blockViewWithPlunger() = 0;
    // ------------------------------------------------------------------------
    virtual bool isSquashed() const = 0;
    // ------------------------------------------------------------------------
    virtual bool setSquash(float time, float slowdown) = 0;
    // ------------------------------------------------------------------------
    virtual void unsetSquash() = 0;
    // ------------------------------------------------------------------------
    virtual float getSpeed() const = 0;
    // ------------------------------------------------------------------------
    virtual float getCurrentMaxSpeed() const = 0;
    // ------------------------------------------------------------------------
    virtual int getSpeedIncreaseTicksLeft(unsigned int category) const = 0;
    
    // ------------------------------------------------------------------------
    virtual void setBoostAI(bool boosted) = 0;
    
    // ------------------------------------------------------------------------
    virtual bool getBoostAI() const = 0;
    
    // ------------------------------------------------------------------------
    
    virtual void increaseMaxSpeed(unsigned int category, float add_speed,
                                  float engine_force, int duration,
                                  int fade_out_time) = 0;
 
    // ----------------------------------------------------------------------------
    virtual void instantSpeedIncrease(unsigned int category, float add_max_speed,
                                    float speed_boost, float engine_force,
                                    int duration, int fade_out_time) = 0;
 
    // ------------------------------------------------------------------------
    virtual void setSlowdown(unsigned int category, float max_speed_fraction,
                             int fade_in_time) = 0;
    // ------------------------------------------------------------------------
    virtual float getEnergy() const = 0;
    // ------------------------------------------------------------------------
    virtual void  collectedItem(ItemState *item_state) = 0;
    // ------------------------------------------------------------------------
    virtual int getPosition() const = 0;
    // ------------------------------------------------------------------------
    virtual void setPosition(int p) = 0;
    // ------------------------------------------------------------------------
    virtual int getInitialPosition() const = 0;
    // ------------------------------------------------------------------------
    virtual bool isOnGround() const = 0;
    // ------------------------------------------------------------------------
    virtual const SlipStream* getSlipstream() const = 0;
    // ------------------------------------------------------------------------
    virtual SlipStream* getSlipstream() = 0;
    // ------------------------------------------------------------------------
    virtual void setSlipstreamEffect(float f) = 0;
    // ------------------------------------------------------------------------
    virtual void beep() = 0;
    // ------------------------------------------------------------------------
    virtual bool playCustomSFX(unsigned int type) = 0;
    // ------------------------------------------------------------------------
    virtual void showZipperFire() = 0;
    // ------------------------------------------------------------------------
    virtual void handleZipper(const Material *m=NULL,
                              bool play_sound=false) = 0;
    // ------------------------------------------------------------------------
    virtual bool hasFinishedRace() const = 0;
    // ------------------------------------------------------------------------
    virtual void setEnergy(float val) = 0;
    // ------------------------------------------------------------------------
    virtual bool isOnMinNitroTime() const = 0;
    // ------------------------------------------------------------------------
    virtual const Material *getMaterial() const = 0;
    // ------------------------------------------------------------------------
    virtual const Material *getLastMaterial() const = 0;
    // ------------------------------------------------------------------------
    virtual const Powerup *getPowerup() const = 0;
    // ------------------------------------------------------------------------
    virtual Powerup *getPowerup() = 0;
    // ------------------------------------------------------------------------
    virtual PowerupManager::PowerupType getLastUsedPowerup() = 0;
    // ------------------------------------------------------------------------
    virtual int getNumPowerup() const = 0;
    // ------------------------------------------------------------------------
    virtual KartGFX* getKartGFX() = 0;
    // ------------------------------------------------------------------------
    virtual void setPowerup (PowerupManager::PowerupType t, int n) = 0;
    // ------------------------------------------------------------------------
    virtual btKart* getVehicle() const = 0;
    // ------------------------------------------------------------------------
    virtual btQuaternion getVisualRotation() const = 0;
    // ------------------------------------------------------------------------
    virtual bool isInRest() const = 0;
    // ------------------------------------------------------------------------
    virtual void startEngineSFX() = 0;
    // ------------------------------------------------------------------------
    virtual void adjustSpeed(float f) = 0;
    // ------------------------------------------------------------------------
    virtual void setSpeed(float s) = 0;
    // ------------------------------------------------------------------------
    virtual bool isInvulnerable() const = 0;
    // ------------------------------------------------------------------------
    virtual void setInvulnerableTicks(int ticks) = 0;
    // ------------------------------------------------------------------------
    virtual bool isShielded() const = 0;
    // ------------------------------------------------------------------------
    virtual void setShieldTime(float t) = 0;
    // ------------------------------------------------------------------------
    virtual float getShieldTime() const = 0;
    // ------------------------------------------------------------------------
    virtual void decreaseShieldTime() = 0;
    // ------------------------------------------------------------------------
 
    virtual void showStarEffect(float t) = 0;
    // ------------------------------------------------------------------------
    virtual const TerrainInfo *getTerrainInfo() const = 0;
    // ------------------------------------------------------------------------
    virtual void crashed(AbstractKart *k, bool update_attachments) = 0;
    // ------------------------------------------------------------------------
    virtual void crashed(const Material *m, const Vec3 &normal) = 0;
    // ------------------------------------------------------------------------
    virtual const Vec3& getNormal() const = 0;
    // ------------------------------------------------------------------------
    virtual const Vec3& getPreviousXYZ() const = 0;
    // ------------------------------------------------------------------------
    virtual const Vec3& getRecentPreviousXYZ() const = 0;
    // ------------------------------------------------------------------------
    virtual const float getRecentPreviousXYZTime() const = 0;
    // ------------------------------------------------------------------------
    virtual float getHoT() const = 0;
    // ------------------------------------------------------------------------
    virtual float getTerrainPitch(float heading) const = 0;
    // -------------------------------------------------------------------------
    virtual btTransform getAlignedTransform(const float customPitch=-1) = 0;
    // -------------------------------------------------------------------------
    virtual void setOnScreenText(const core::stringw& text) = 0;
    // ------------------------------------------------------------------------
    virtual bool getRaceResult() const = 0;
    // ------------------------------------------------------------------------
    virtual bool isGhostKart() const = 0;
    // ------------------------------------------------------------------------
    virtual bool isJumping() const = 0;
    // ------------------------------------------------------------------------
    virtual void playSound(SFXBuffer* buffer) = 0;
    // ------------------------------------------------------------------------
    virtual bool isVisible() const = 0;
    // ------------------------------------------------------------------------
    virtual void makeKartRest();
    // ------------------------------------------------------------------------
    virtual void setStartupBoost(float val) = 0;
    // ------------------------------------------------------------------------
    virtual float getStartupBoost() const = 0;
    // ------------------------------------------------------------------------
    virtual float getStartupBoostFromStartTicks(int ticks) const = 0;
    // ------------------------------------------------------------------------
    virtual Stars* getStarsEffect() const = 0;
    // ------------------------------------------------------------------------
    int getLiveJoinUntilTicks() const              { return m_live_join_util; }
    // ------------------------------------------------------------------------
    void setLiveJoinKart(int util_ticks)     { m_live_join_util = util_ticks; }
    // ------------------------------------------------------------------------
    virtual int getNetworkConfirmedFinishTicks() const = 0;
};   // AbstractKart
 
 
#endif
 
/* EOF */