stk_config.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2006-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_STK_CONFIG_HPP
#define HEADER_STK_CONFIG_HPP
 
#include "network/remote_kart_info.hpp"
#include "utils/interpolation_array.hpp"
#include "utils/no_copy.hpp"
 
#include "utils/constants.hpp"
#include <map>
#include <set>
#include <string>
#include <vector>
 
class KartProperties;
class MusicInformation;
class XMLNode;
 
class STKConfig : public NoCopy
{
protected:
    KartProperties *m_default_kart_properties;
    std::map<std::string, KartProperties*> m_kart_properties;
 
public:
    enum {
        POWERUP_MODE_NEW,
        POWERUP_MODE_SAME,
        POWERUP_MODE_ONLY_IF_SAME
    }
    m_same_powerup_mode;
 
    int   m_bonusbox_item_return_ticks;  
    int   m_nitro_item_return_ticks;     
    int   m_banana_item_return_ticks;    
    int   m_bubblegum_item_return_ticks; 
    static float UNDEFINED;
    float m_bomb_time;                 
    float m_bomb_time_increase;        
    int   m_item_switch_ticks;          
    int   m_bubblegum_counter;         
    bool  m_shield_restrict_weapons;   
    float m_explosion_impulse_objects; 
    int   m_penalty_ticks;              
    float m_delay_finish_time;         
    float m_music_credit_time;         
    int   m_max_karts;                 
    bool  m_smooth_normals;            
    float m_no_explosive_items_timeout;
 
    int m_max_moveable_objects;
 
    float m_network_steering_reduction;
 
    float m_smooth_angle_limit;
 
    float m_default_track_friction;
 
    float m_default_moveable_friction;
 
    int m_solver_iterations;
 
    bool m_solver_split_impulse;
 
    float m_solver_split_impulse_thresh;
 
    int m_solver_set_flags, m_solver_reset_flags;
 
    int   m_max_skidmarks;           
    float m_skid_fadeout_time;       
    float m_near_ground;             
    int   m_min_kart_version,        
        m_max_kart_version;        
    int   m_min_track_version,       
        m_max_track_version;       
    int   m_min_server_version,       
        m_max_server_version;       
    int   m_max_display_news;        
    bool m_disable_steer_while_unskid;
 
    bool m_camera_follow_skid;
 
    float m_ai_acceleration;         
    std::vector<float>
        m_leader_intervals;        
    float m_leader_time_per_kart;    
    std::vector<int> m_switch_items; 
    std::vector<int> m_score_increase;
 
    MusicInformation *m_title_music;
 
    MusicInformation *m_default_music;
 
    MusicInformation *m_race_win_music;
 
    MusicInformation *m_race_neutral_music;
 
    MusicInformation *m_race_lose_music;
 
    MusicInformation *m_gp_win_music;
 
    MusicInformation *m_gp_lose_music;
 
    MusicInformation *m_unlock_music;
 
    int m_replay_max_frames;
 
    float m_replay_dt;
 
    float m_replay_delta_speed;
 
    float m_replay_delta_steering;
 
    float m_minimap_size;
 
    /* The size of icons for AIs and human players, respectively */
    float m_minimap_ai_icon;
    float m_minimap_player_icon;
 
    float m_camera_fov[MAX_PLAYER_COUNT];
 
    float m_cutscene_fov;
 
    unsigned m_max_skinning_bones;
 
    unsigned m_tc_quality;
 
    uint16_t m_server_discovery_port;
    uint16_t m_client_port;
    uint16_t m_server_port;
 
    /* URLs for the stk website, donating and reseting the password */
    std::string m_stk_website_url;
    std::string m_donate_url;
    std::string m_password_reset_url;
    std::string m_assets_download_url;
 
    /* SRV records for stun server lists created */
    std::string m_stun_ipv4;
    std::string m_stun_ipv6;
 
    std::vector<std::string> m_normal_ttf;
    std::vector<std::string> m_digit_ttf;
    std::string m_color_emoji_ttf;
 
    float m_snb_min_adjust_length, m_snb_max_adjust_length,
        m_snb_min_adjust_speed, m_snb_max_adjust_time,
        m_snb_adjust_length_threshold;
 
    std::string m_server_api;
 
    uint32_t m_server_api_version = 0;
 
    std::string m_server_addons;
 
    std::string m_server_hardware_report;
 
    bool m_allow_news_redirects = true;
 
    std::set<std::string> m_network_capabilities;
 
private:
    bool  m_has_been_loaded;
 
    int m_physics_fps;
 
    std::string m_title_music_file;
    std::string m_default_music_file;
    std::string m_race_win_music_file;
    std::string m_race_neutral_music_file;
    std::string m_race_lose_music_file;
    std::string m_gp_win_music_file;
    std::string m_gp_lose_music_file;
    std::string m_unlock_music_file;
 
public:
    STKConfig();
    ~STKConfig();
    void init_defaults();
    void getAllData(const XMLNode * root);
    void load(const std::string &filename);
    const std::string &getMainMenuPicture(int n);
    const std::string &getBackgroundPicture(int n);
    void initMusicFiles();
    void  getAllScores(std::vector<int> *all_scores, int num_karts);
    // ------------------------------------------------------------------------
    const KartProperties &
        getDefaultKartProperties() const { return *m_default_kart_properties; }
 
    // ------------------------------------------------------------------------
    const KartProperties& getKartProperties(const std::string &type)
    {
        return *m_kart_properties.at(type);
    }   // getKartProperties
    // ------------------------------------------------------------------------
    float ticks2Time(int ticks) { return float(ticks)/m_physics_fps; }
    // ------------------------------------------------------------------------
    int time2Ticks(float t) { return int(t * m_physics_fps);  }
    // ------------------------------------------------------------------------
    int getPhysicsFPS() const { return m_physics_fps; }
}
;   // STKConfig
 
extern STKConfig* stk_config;
#endif