story_mode_status.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2010-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 GAME_SLOT_HPP
#define GAME_SLOT_HPP
 
#include "challenges/challenge_data.hpp"
#include "race/race_manager.hpp"
 
#include <irrString.h>
using namespace irr;
 
#include <string>
#include <map>
#include <vector>
 
class ChallengeData;
class ChallengeStatus;
class UTFWriter;
class XMLNode;
 
const int CHALLENGE_POINTS[] = { 6, 7, 8, 10 };
const int GP_FACTOR = 3;
 
class StoryModeStatus
{
private:
    std::map<std::string, bool>   m_locked_features;
 
    std::vector<const ChallengeData*> m_unlocked_features;
 
    std::map<std::string, ChallengeStatus*> m_challenges_state;
 
    const ChallengeStatus *m_current_challenge;
 
    int m_points;
    int m_points_before; // used for unlocks
    int m_next_unlock_points;
 
    bool m_first_time;
 
    int m_easy_challenges;
    int m_medium_challenges;
    int m_hard_challenges;
    int m_best_challenges;
 
    /* Set to true after fort magma */
    bool m_story_mode_finished;
 
    /* Set to true after fort magma if there was a valid speedrun active 
     * This is used to know if m_speedrun_milliseconds contain valid data */
    bool m_valid_speedrun_finished;
 
    // It overflows at over 500 hours
    int m_story_mode_milliseconds;
    int m_speedrun_milliseconds;
 
public:
 
     StoryModeStatus(const XMLNode *node=NULL);
    ~StoryModeStatus();
 
    void       computeActive     (bool first_call=false);
    bool       isLocked          (const std::string& feature);
    void       unlockFeatureByList();
    void       lockFeature       (ChallengeStatus *challenge);
    void       unlockFeature     (ChallengeStatus* c, RaceManager::Difficulty d,
                                  bool do_save=true);
    void       raceFinished      ();
    void       grandPrixFinished ();
    void       save              (UTFWriter &out, bool current_player=false);
    void       addStatus(ChallengeStatus *cs);
    void       setCurrentChallenge(const std::string &challenge_id);
 
    // ----------------------------------------------------------------------------------------
    const std::vector<const ChallengeData*>
        getRecentlyCompletedChallenges() {return m_unlocked_features;}
    // ----------------------------------------------------------------------------------------
    void clearUnlocked     () {m_unlocked_features.clear(); }
    // ----------------------------------------------------------------------------------------
    int getNumCompletedChallenges  () const { return (m_easy_challenges + m_medium_challenges +
                                                      m_hard_challenges + m_best_challenges); }
    // ----------------------------------------------------------------------------------------
    int getNumReqMetInLowerDiff  () const;
    // ----------------------------------------------------------------------------------------
    int getPoints          () const { return m_points; }
    // ----------------------------------------------------------------------------------------
    int getPointsBefore     () const { return m_points_before; }
    // ----------------------------------------------------------------------------------------
    int getNextUnlockPoints () const { return m_next_unlock_points; }
    // ----------------------------------------------------------------------------------------
    int getNumEasyTrophies  () const { return m_easy_challenges;   }
    // ----------------------------------------------------------------------------------------
    /* Returns the number of fulfilled challenges at medium level. */
    int getNumMediumTrophies() const { return m_medium_challenges; }
    // ----------------------------------------------------------------------------------------
    int getNumHardTrophies  () const { return m_hard_challenges;   }
    // ----------------------------------------------------------------------------------------
    int getNumBestTrophies  () const { return m_best_challenges;   }
    // ----------------------------------------------------------------------------------------
    void setFirstTime(bool ft) { m_first_time = ft;   }
    // ----------------------------------------------------------------------------------------
    bool isFirstTime() const   { return m_first_time; }
    // ----------------------------------------------------------------------------------------
    void setFinished()  { m_story_mode_finished = true; }
    // ----------------------------------------------------------------------------------------
    bool isFinished() const   { return m_story_mode_finished; }
    // ----------------------------------------------------------------------------------------
    void setSpeedrunFinished()  { m_valid_speedrun_finished = true; }
    // ----------------------------------------------------------------------------------------
    bool isSpeedrunFinished() const   { return m_valid_speedrun_finished; }
    // ----------------------------------------------------------------------------------------
    void setStoryModeTimer(int milliseconds)  { m_story_mode_milliseconds = milliseconds; }
    // ----------------------------------------------------------------------------------------
    int getStoryModeTimer()  { return  m_story_mode_milliseconds; }
    // ----------------------------------------------------------------------------------------
    void setSpeedrunTimer(int milliseconds)  { m_speedrun_milliseconds = milliseconds; }
    // ----------------------------------------------------------------------------------------
    int getSpeedrunTimer()  { return  m_speedrun_milliseconds; }
    // ----------------------------------------------------------------------------------------
    const ChallengeStatus *getCurrentChallengeStatus() const { return m_current_challenge; }
    // ----------------------------------------------------------------------------------------
    const ChallengeStatus* getChallengeStatus(const std::string& id) const
    {
        std::map<std::string, ChallengeStatus*>::const_iterator it =
            m_challenges_state.find(id);
        assert(it!=m_challenges_state.end());
        return it->second;
    }   // getChallengeStatus
};   // StoryModeStatus
 
#endif