saved_grand_prix.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 HEADER_SAVED_GRAND_PRIX_HPP
#define HEADER_SAVED_GRAND_PRIX_HPP
 
#include "config/user_config.hpp"
#include "race/race_manager.hpp"
#include "utils/ptr_vector.hpp"
 
#include <algorithm>
#include <string>
 
class RaceManager;
 
// ============================================================================
 
class SavedGrandPrix
{
private:
    class SavedGPKart
    {
        friend class SavedGrandPrix;
        GroupUserConfigParam m_group;
        StringUserConfigParam m_ident;
        IntUserConfigParam m_score, m_local_player_id, m_global_player_id;
        FloatUserConfigParam m_overall_time;
    public:
        SavedGPKart(GroupUserConfigParam * group, const XMLNode* node);
        SavedGPKart(GroupUserConfigParam * group,
                    const std::string &ident,
                    int score,
                    int local_player_id,
                    int global_player_id,
                    float overall_time);
    };   // SavedGPKart
 
protected:
 
    GroupUserConfigParam        m_savedgp_group;
    IntUserConfigParam          m_player_id;
 
    StringUserConfigParam       m_gp_id;
    
    IntUserConfigParam          m_race_type;
 
    IntUserConfigParam          m_difficulty;
 
    IntUserConfigParam          m_player_karts;
 
    IntUserConfigParam          m_next_track;
 
    IntUserConfigParam          m_reverse_type;
 
    IntUserConfigParam          m_skipped_tracks;
 
    FloatUserConfigParam        m_time_target;
 
    IntUserConfigParam          m_player_total_laps;
 
    PtrVector<SavedGPKart> m_karts;
 
public:
 
    SavedGrandPrix(unsigned int player_id,
                   const std::string &gp_id,
                   RaceManager::MinorRaceModeType race_type,
                   RaceManager::Difficulty difficulty,
                   int player_karts,
                   int last_track,
                   int reverse_type,
                   int skipped_tracks,
                   float time_target,
                   int player_total_laps,
                   const std::vector<RaceManager::KartStatus> &kart_list);
 
    SavedGrandPrix(const XMLNode* node);
    void setKarts(const std::vector<RaceManager::KartStatus> &kart_list);
    void clearKarts();
    void loadKarts(std::vector<RaceManager::KartStatus> & kart_list);
 
    // ------------------------------------------------------------------------
    unsigned int getPlayerID() const { return m_player_id; }
 
    // ------------------------------------------------------------------------
    std::string getGPID() const { return m_gp_id; }
 
    // ------------------------------------------------------------------------
    int getRaceType() const { return m_race_type; }
 
    // ------------------------------------------------------------------------
    int getDifficulty() const { return m_difficulty; }
 
    // ------------------------------------------------------------------------
    int getTotalKarts() const { return m_karts.size(); }
 
    // ------------------------------------------------------------------------
    int getPlayerKarts() const { return m_player_karts; }
 
    // ------------------------------------------------------------------------
    int getNextTrack() const { return m_next_track; }
 
    // ------------------------------------------------------------------------
    int getReverseType() const { return m_reverse_type; }
 
    // ------------------------------------------------------------------------
    int getSkippedTracks() const { return m_skipped_tracks; }
 
    // ------------------------------------------------------------------------
    float getTimeTarget() const { return m_time_target; }
 
    // ------------------------------------------------------------------------
    int getPlayerTotalLaps() const { return m_player_total_laps; }
 
    // ------------------------------------------------------------------------
    void setNextTrack(int next_track) { m_next_track = next_track; }
 
    // ------------------------------------------------------------------------
    void remove()
    {
        UserConfigParams::m_saved_grand_prix_list.remove(this);
        delete this;
    }   // remove
 
    // ------------------------------------------------------------------------
    static SavedGrandPrix* getSavedGP(unsigned int player,
                                      const std::string &gpid,
                                      RaceManager::MinorRaceModeType race_type,
                                      const unsigned int number_of_players)
    {
        for (unsigned int n=0; n<UserConfigParams::m_saved_grand_prix_list.size(); n++)
        {
            SavedGrandPrix* gp = &UserConfigParams::m_saved_grand_prix_list[n];
            if (gp->getGPID()        == gpid   &&
                gp->getRaceType()    == race_type &&
                gp->getPlayerID()    == player &&
                gp->getPlayerKarts() == (int)number_of_players)
                return gp;
        }
        return NULL;
    }   // getSavedGP
    // ------------------------------------------------------------------------
};   // class SavedGrandPrix
 
#endif
 
/*EOF*/