kart_properties.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2006-2015 SuperTuxKart-Team
//
//  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_PROPERTIES_HPP
#define HEADER_KART_PROPERTIES_HPP

#include <memory>
#include <string>
#include <vector>

#include <SColor.h>
#include <irrString.h>
namespace irr
{
    namespace video { class ITexture; }
}
using namespace irr;

#include "io/xml_node.hpp"
#include "race/race_manager.hpp"
#include "utils/interpolation_array.hpp"
#include "utils/vec3.hpp"

class AbstractCharacteristic;
class AIProperties;
class CachedCharacteristic;
class CombinedCharacteristic;
class KartModel;
class Material;
class RenderInfo;
class XMLNode;


class KartProperties
{
private:
    std::string              m_root;

    std::shared_ptr<AIProperties> m_ai_properties[RaceManager::DIFFICULTY_COUNT];

    Material                *m_icon_material;

    std::string              m_minimap_icon_file;

    video::ITexture         *m_minimap_icon;

    mutable std::shared_ptr<KartModel> m_kart_model;

    std::vector<std::string> m_groups;

    static float UNDEFINED;

    int   m_version;

    // SFX files
    // ---------------
    std::vector<int> m_custom_sfx_id;     
    // Display and gui
    // ---------------
    std::string m_name;               
    std::string m_ident;              
    std::string m_icon_file;          
    std::string m_shadow_file;        
    float m_shadow_scale;             
    float m_shadow_x_offset;          
    float m_shadow_z_offset;          
    Material* m_shadow_material;      
    video::SColor m_color;            
    int  m_shape;                     
    std::shared_ptr<AbstractCharacteristic> m_characteristic;
    std::shared_ptr<CombinedCharacteristic> m_combined_characteristic;
    std::shared_ptr<CachedCharacteristic> m_cached_characteristic;

    // Physic properties
    // -----------------
    Vec3  m_bevel_factor;

    float m_physical_wheel_position;

    int8_t m_nitro_min_consumption;

    bool m_is_addon;

    std::string m_kart_type;

    std::string m_wheel_filename[4];

    float       m_wheel_base;

    std::string m_engine_sfx_type;

    std::string m_skid_sound;

    // bullet physics data
    // -------------------
    float m_friction_slip;

    Vec3  m_gravity_center_shift;

public:
    enum TerrainImpulseType {IMPULSE_NONE, IMPULSE_NORMAL,
                             IMPULSE_TO_DRIVELINE};
private:
    TerrainImpulseType m_terrain_impulse_type;

    float m_collision_terrain_impulse;

    float m_collision_impulse;

    float m_collision_impulse_time;

    InterpolationArray m_restitution;

    void  load              (const std::string &filename,
                             const std::string &node);
    void combineCharacteristics(HandicapLevel h);

    void setWheelBase(float kart_length)
    {
        // The longer the kart,the bigger its turn radius if using an identical
        // wheel base, exactly proportionally to its length.
        // The wheel base is used to compensate this
        // We divide by 1.425 to have a default turn radius which conforms
        // closely (+-0,1%) with the specifications in kart_characteristics.xml
        m_wheel_base = fabsf(kart_length / 1.425f);
    }
public:
    static std::string      getHandicapAsString(HandicapLevel h);

          KartProperties    (const std::string &filename="");
         ~KartProperties    ();
    void  copyForPlayer     (const KartProperties *source,
                             HandicapLevel h = HANDICAP_NONE);
    void  adjustForOnlineAddonKart(const KartProperties* source);
    void  updateForOnlineKart(const std::string& id, const Vec3& gravity_shift,
                              float kart_length)
    {
        m_ident = id;
        m_gravity_center_shift = gravity_shift;
        setWheelBase(kart_length);
    }
    void  copyFrom          (const KartProperties *source);
    void  getAllData        (const XMLNode * root);
    void  checkAllSet       (const std::string &filename);
    bool  isInGroup         (const std::string &group) const;
    bool operator<(const KartProperties &other) const;

    // ------------------------------------------------------------------------
    const AbstractCharacteristic* getCharacteristic() const;
    // ------------------------------------------------------------------------
    const AbstractCharacteristic* getCombinedCharacteristic() const;

    // ------------------------------------------------------------------------
    Material*     getIconMaterial    () const {return m_icon_material;        }

    // ------------------------------------------------------------------------
    video::ITexture *getMinimapIcon  () const {return m_minimap_icon;         }

    // ------------------------------------------------------------------------
    KartModel* getKartModelCopy(std::shared_ptr<RenderInfo> ri=nullptr) const;
    // ------------------------------------------------------------------------
    const KartModel& getMasterKartModel() const {return *m_kart_model;        }
    // ------------------------------------------------------------------------
    void setHatMeshName(const std::string &hat_name);
    // ------------------------------------------------------------------------
    core::stringw getName() const;
    // ------------------------------------------------------------------------
    const std::string getNonTranslatedName() const {return m_name;}

    // ------------------------------------------------------------------------
    const std::string& getIdent      () const {return m_ident;                }

    // ------------------------------------------------------------------------
    const std::string& getKartType   () const { return m_kart_type;           }

    // ------------------------------------------------------------------------
    Material* getShadowMaterial() const           { return m_shadow_material; }

    // ------------------------------------------------------------------------
    const std::string& getAbsoluteIconFile() const      { return m_icon_file; }

    // ------------------------------------------------------------------------
    const int          getCustomSfxId (int type)
                                       const  {return m_custom_sfx_id[type];  }

    // ------------------------------------------------------------------------
    int   getVersion                () const {return m_version;               }

    // ------------------------------------------------------------------------
    const video::SColor &getColor   () const {return m_color;                 }

    // ------------------------------------------------------------------------
    int   getShape                  () const {return m_shape;                 }

    // ------------------------------------------------------------------------
    const std::vector<std::string>&
                  getGroups         () const {return m_groups;                }

    // ------------------------------------------------------------------------
    const std::string& getEngineSfxType    () const {return m_engine_sfx_type;}
    // ------------------------------------------------------------------------
    const std::string& getSkidSound    () const         {return m_skid_sound; }

    // Bullet physics get functions
    //-----------------------------
    float getFrictionSlip           () const {return m_friction_slip;         }

    // ------------------------------------------------------------------------
    float getWheelBase              () const {return m_wheel_base;            }

    // ------------------------------------------------------------------------
    const Vec3&getGravityCenterShift() const {return m_gravity_center_shift;  }

    // ------------------------------------------------------------------------
    float getCollisionTerrainImpulse() const
                                          {return m_collision_terrain_impulse;}

    // ------------------------------------------------------------------------
    TerrainImpulseType getTerrainImpulseType() const
                                             { return m_terrain_impulse_type; }
    // ------------------------------------------------------------------------
    float getCollisionImpulse       () const {return m_collision_impulse;}

    // ------------------------------------------------------------------------
    float getCollisionImpulseTime() const { return m_collision_impulse_time;}

    // ------------------------------------------------------------------------
    float getRestitution(float speed) const { return m_restitution.get(speed);}

    // ------------------------------------------------------------------------
    const AIProperties *getAIPropertiesForDifficulty() const
    {
        return m_ai_properties[RaceManager::get()->getDifficulty()].get();
    }   // getAIProperties

    // ------------------------------------------------------------------------
    const std::string& getKartDir   () const {return m_root;                  }

    // ------------------------------------------------------------------------
    const Vec3 &getBevelFactor() const { return m_bevel_factor; }
    // ------------------------------------------------------------------------
    const float getPhysicalWheelPosition() const
    {
        return m_physical_wheel_position;
    }   // getPhysicalWheelPosition

    // ------------------------------------------------------------------------
    float getAccelerationEfficiency() const;
    // ------------------------------------------------------------------------
    int8_t getNitroMinConsumptionTicks() const
                                            { return m_nitro_min_consumption; }
    // ------------------------------------------------------------------------
    bool isAddon() const                                 { return m_is_addon; }

    // Script-generated content generated by tools/create_kart_properties.py defs
    // Please don't change the following tag. It will be automatically detected
    // by the script and replace the contained content.
    // To update the code, use tools/update_characteristics.py
    /* <characteristics-start kpdefs> */

    float getSuspensionStiffness() const;
    float getSuspensionRest() const;
    float getSuspensionTravel() const;
    bool getSuspensionExpSpringResponse() const;
    float getSuspensionMaxForce() const;

    float getStabilityRollInfluence() const;
    float getStabilityChassisLinearDamping() const;
    float getStabilityChassisAngularDamping() const;
    float getStabilityDownwardImpulseFactor() const;
    float getStabilityTrackConnectionAccel() const;
    std::vector<float> getStabilityAngularFactor() const;
    float getStabilitySmoothFlyingImpulse() const;

    InterpolationArray getTurnRadius() const;
    float getTurnTimeResetSteer() const;
    InterpolationArray getTurnTimeFullSteer() const;

    float getEnginePower() const;
    float getEngineMaxSpeed() const;
    float getEngineGenericMaxSpeed() const;
    float getEngineBrakeFactor() const;
    float getEngineBrakeTimeIncrease() const;
    float getEngineMaxSpeedReverseRatio() const;

    std::vector<float> getGearSwitchRatio() const;
    std::vector<float> getGearPowerIncrease() const;

    float getMass() const;

    float getWheelsDampingRelaxation() const;
    float getWheelsDampingCompression() const;

    float getJumpAnimationTime() const;

    float getLeanMax() const;
    float getLeanSpeed() const;

    float getAnvilDuration() const;
    float getAnvilWeight() const;
    float getAnvilSpeedFactor() const;

    float getParachuteFriction() const;
    float getParachuteDuration() const;
    float getParachuteDurationOther() const;
    float getParachuteDurationRankMult() const;
    float getParachuteDurationSpeedMult() const;
    float getParachuteLboundFraction() const;
    float getParachuteUboundFraction() const;
    float getParachuteMaxSpeed() const;

    float getFrictionKartFriction() const;

    float getBubblegumDuration() const;
    float getBubblegumSpeedFraction() const;
    float getBubblegumTorque() const;
    float getBubblegumFadeInTime() const;
    float getBubblegumShieldDuration() const;

    float getZipperDuration() const;
    float getZipperForce() const;
    float getZipperSpeedGain() const;
    float getZipperMaxSpeedIncrease() const;
    float getZipperFadeOutTime() const;

    float getSwatterDuration() const;
    float getSwatterDistance() const;
    float getSwatterSquashDuration() const;
    float getSwatterSquashSlowdown() const;

    float getPlungerBandMaxLength() const;
    float getPlungerBandForce() const;
    float getPlungerBandDuration() const;
    float getPlungerBandSpeedIncrease() const;
    float getPlungerBandFadeOutTime() const;
    float getPlungerInFaceTime() const;

    std::vector<float> getStartupTime() const;
    std::vector<float> getStartupBoost() const;

    float getRescueDuration() const;
    float getRescueVertOffset() const;
    float getRescueHeight() const;

    float getExplosionDuration() const;
    float getExplosionRadius() const;
    float getExplosionInvulnerabilityTime() const;

    float getNitroDuration() const;
    float getNitroEngineForce() const;
    float getNitroEngineMult() const;
    float getNitroConsumption() const;
    float getNitroSmallContainer() const;
    float getNitroBigContainer() const;
    float getNitroMaxSpeedIncrease() const;
    float getNitroFadeOutTime() const;
    float getNitroMax() const;

    float getSlipstreamDurationFactor() const;
    float getSlipstreamBaseSpeed() const;
    float getSlipstreamLength() const;
    float getSlipstreamWidth() const;
    float getSlipstreamInnerFactor() const;
    float getSlipstreamMinCollectTime() const;
    float getSlipstreamMaxCollectTime() const;
    float getSlipstreamAddPower() const;
    float getSlipstreamMinSpeed() const;
    float getSlipstreamMaxSpeedIncrease() const;
    float getSlipstreamFadeOutTime() const;

    float getSkidIncrease() const;
    float getSkidDecrease() const;
    float getSkidMax() const;
    float getSkidTimeTillMax() const;
    float getSkidVisual() const;
    float getSkidVisualTime() const;
    float getSkidRevertVisualTime() const;
    float getSkidMinSpeed() const;
    std::vector<float> getSkidTimeTillBonus() const;
    std::vector<float> getSkidBonusSpeed() const;
    std::vector<float> getSkidBonusTime() const;
    std::vector<float> getSkidBonusForce() const;
    float getSkidPhysicalJumpTime() const;
    float getSkidGraphicalJumpTime() const;
    float getSkidPostSkidRotateFactor() const;
    float getSkidReduceTurnMin() const;
    float getSkidReduceTurnMax() const;
    bool getSkidEnabled() const;

    /* <characteristics-end kpdefs> */
    
    LEAK_CHECK()
};   // KartProperties

#endif