challenge_data.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2008-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_CHALLENGE_DATA_HPP
#define HEADER_CHALLENGE_DATA_HPP
 
#include <string>
#include <vector>
#include <stdio.h>
#include <stdexcept>
 
 
#include "race/race_manager.hpp"
 
class ChallengeData
{
public:
    enum RewardType
    {
        UNLOCK_TRACK,
        UNLOCK_GP,
        UNLOCK_MODE,
        UNLOCK_KART,
        UNLOCK_DIFFICULTY
    };
 
    enum GPLevel
    {
        GP_NONE,
        GP_EASY,
        GP_MEDIUM,
        GP_HARD,
        GP_BEST
    };
    // ------------------------------------------------------------------------
    class UnlockableFeature
    {
    public:
 
        std::string        m_name; // internal name
        irr::core::stringw m_user_name; // not all types of feature have one
        RewardType         m_type;
 
        const irr::core::stringw getUnlockedMessage() const;
    };   // UnlockableFeature
    // ------------------------------------------------------------------------
 
    enum ChallengeModeType
    {
        CM_GRAND_PRIX,
        CM_SINGLE_RACE,
        CM_ANY
    };
 
    enum SpecialUnlockType
    {
        SPECIAL_NONE,
        SPECIAL_MAX_REQ_IN_LOWER_DIFF
    };
 
 
private:
 
    ChallengeModeType              m_mode;
 
    RaceManager::MinorRaceModeType m_minor;
 
    int                            m_num_laps;
    bool                           m_reverse;
    int                            m_position[RaceManager::DIFFICULTY_COUNT];
    int                            m_default_num_karts[RaceManager::DIFFICULTY_COUNT];
    std::string                    m_ai_kart_ident[RaceManager::DIFFICULTY_COUNT];
    std::string                    m_replay_files[RaceManager::DIFFICULTY_COUNT];
    float                          m_time[RaceManager::DIFFICULTY_COUNT];
    int                            m_energy[RaceManager::DIFFICULTY_COUNT];
    RaceManager::AISuperPower      m_ai_superpower[RaceManager::DIFFICULTY_COUNT];
    std::string                    m_gp_id;
    std::string                    m_track_id;
    std::string                    m_filename;
    int                            m_version;
    bool                           m_is_unlock_list;
    bool                           m_is_ghost_replay;
 
    void setUnlocks(const std::string &id,
                    ChallengeData::RewardType reward);
    void error(const char *id) const;
 
    std::string              m_id;
 
    std::vector<UnlockableFeature> m_feature;
 
    int m_num_trophies;
    int m_num_completed_challenges;
 
    SpecialUnlockType m_unlock_special_type;
    int               m_unlock_special_value;
 
public:
                 ChallengeData(const std::string& filename);
 
    virtual      ~ChallengeData() {}
 
    void         setRace(RaceManager::Difficulty d) const;
 
    virtual void check() const;
    virtual bool isChallengeFulfilled(bool check_best=false) const;
    virtual GPLevel isGPFulfilled() const;
    void  addUnlockTrackReward(const std::string &track_name);
    void  addUnlockModeReward(const std::string &internal_mode_name,
                              const irr::core::stringw &user_mode_name);
    void  addUnlockGPReward(const std::string &gp_name);
    void  addUnlockDifficultyReward(const std::string &internal_name,
                                    const irr::core::stringw &user_name);
    void  addUnlockKartReward(const std::string &internal_name,
                              const irr::core::stringw &user_name);
 
    // ------------------------------------------------------------------------
    int  getVersion() const { return m_version; }
 
    // ------------------------------------------------------------------------
    const std::vector<UnlockableFeature>&
        getFeatures() const { return m_feature; }
 
    // ------------------------------------------------------------------------
    const std::string &getChallengeId() const { return m_id; }
 
    // ------------------------------------------------------------------------
    void  setChallengeId(const std::string& s) { m_id = s; }
 
    // ------------------------------------------------------------------------
    const std::string& getTrackId() const
    {
        assert(m_mode==CM_SINGLE_RACE);
        return m_track_id;
    }   // getTrackId
 
    // ------------------------------------------------------------------------
    const std::string& getGPId() const
    {
        assert(m_mode==CM_GRAND_PRIX);
        return m_gp_id;
    }   // getGPId
 
    // ------------------------------------------------------------------------
    int getNumLaps() const
    {
        assert(m_mode==CM_SINGLE_RACE);
        return m_num_laps;
    }   // getNumLaps
 
    // ------------------------------------------------------------------------
    bool getReverse() const { return m_reverse; }
    // ------------------------------------------------------------------------
    int getNumTrophies() const { return m_num_trophies; }
    // ------------------------------------------------------------------------
    int getNumChallenges() const { return m_num_completed_challenges; }
    // ------------------------------------------------------------------------
    bool isGrandPrix() const { return m_mode == CM_GRAND_PRIX; }
    // ------------------------------------------------------------------------
    bool isSingleRace() const { return m_mode == CM_SINGLE_RACE; }
    // ------------------------------------------------------------------------
    bool isGhostReplay() const { return m_is_ghost_replay; }
    // ------------------------------------------------------------------------
    bool isUnlockList() const { return m_is_unlock_list; }
    // ------------------------------------------------------------------------
    SpecialUnlockType getSpecialType() const { return m_unlock_special_type; }
    // ------------------------------------------------------------------------
    int getSpecialValue() const { return m_unlock_special_value; }
    // ------------------------------------------------------------------------
    ChallengeModeType getMode() const { return m_mode; }
    // ------------------------------------------------------------------------
    RaceManager::MinorRaceModeType getMinorMode()  const { return m_minor; }
    // ------------------------------------------------------------------------
    const irr::core::stringw getChallengeDescription() const;
 
    // ------------------------------------------------------------------------
    int getMaxPosition(RaceManager::Difficulty difficulty) const
    {
        return m_position[difficulty];
    }   // getPosition
 
    // ------------------------------------------------------------------------
    int getNumKarts(RaceManager::Difficulty difficulty) const
    {
        return m_default_num_karts[difficulty];
    }   // getNumKarts
    // ------------------------------------------------------------------------
    float getTimeRequirement(RaceManager::Difficulty difficulty) const
    {
        return m_time[difficulty];
    }   // getTimeRequirement
    // ------------------------------------------------------------------------
    int getEnergy(RaceManager::Difficulty difficulty) const
    {
        return m_energy[difficulty];
    }   // getEnergy
    // ------------------------------------------------------------------------
    const std::string& getAIKartIdent(RaceManager::Difficulty difficulty) const
    {
        return m_ai_kart_ident[difficulty];
    }
 
};   // ChallengeData
 
#endif   // HEADER_CHALLENGE_DATA_HPP