world_with_rank.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2010-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_WORLD_WITH_RANK_HPP
#define HEADER_WORLD_WITH_RANK_HPP
 
#include <vector>
 
#include "modes/world.hpp"
 
class AbstractKart;
class TrackSector;
 
class WorldWithRank : public World
{
protected:
    std::vector<int> m_position_index;
 
    bool m_display_rank;
 
    std::vector<int> m_score_for_position;
 
#ifdef DEBUG
    std::vector<bool> m_position_used;
 
    bool              m_position_setting_initialised;
#endif
 
    unsigned int getClosestStartPoint(AbstractKart *kart);
 
    std::vector<TrackSector*> m_kart_track_sector;
 
    // ------------------------------------------------------------------------
    void updateSectorForKarts();
 
public:
                  WorldWithRank() : World() {}
    virtual      ~WorldWithRank();
    virtual void  init() OVERRIDE;
    virtual void  reset(bool restart=false) OVERRIDE;
 
    virtual bool  shouldDrawSpeedometerDigit() const OVERRIDE 
                                                    { return m_display_rank; }
    virtual std::pair<int, video::SColor> 
                  getSpeedometerDigit(const AbstractKart *kart) const OVERRIDE;
 
    void          beginSetKartPositions();
    bool          setKartPosition(unsigned int kart_id,
                                  unsigned int position);
    void          endSetKartPositions();
    AbstractKart* getKartAtPosition(unsigned int p) const;
    virtual AbstractKart* getKartAtDrawingPosition(unsigned int p) const
                                               { return getKartAtPosition(p); }
    virtual int   getScoreForPosition(int p);
    virtual unsigned int getRescuePositionIndex(AbstractKart *kart) OVERRIDE;
    // ------------------------------------------------------------------------
    TrackSector* getTrackSector(unsigned int kart_index) const
    {
        assert(kart_index < m_kart_track_sector.size());
        return m_kart_track_sector[kart_index];
    }   // getTrackSector
    // ------------------------------------------------------------------------
    bool isOnRoad(unsigned int kart_index) const;
    // ------------------------------------------------------------------------
    int getSectorForKart(const AbstractKart *kart) const;
 
};   // WorldWithRank
 
#endif