world.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2004-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_WORLD_HPP
#define HEADER_WORLD_HPP
 
#include <cstring>
#include <limits>
#include <map>
#include <memory>
#include <vector>
#include <stdexcept>
 
#include "graphics/weather.hpp"
#include "modes/world_status.hpp"
#include "race/highscores.hpp"
#include "states_screens/race_gui_base.hpp"
#include "states_screens/state_manager.hpp"
#include "utils/random_generator.hpp"
#include "utils/stk_process.hpp"
 
#include "LinearMath/btTransform.h"
 
class AbstractKart;
class BareNetworkString;
class btRigidBody;
class Controller;
class ItemState;
class PhysicalObject;
class STKPeer;
 
namespace Scripting
{
    class ScriptEngine;
}
 
namespace irr
{
    namespace scene { class ISceneNode; }
}
 
class AbortWorldUpdateException : public std::runtime_error
{
public:
    AbortWorldUpdateException() : std::runtime_error("race abort") { };
};
 
class World : public WorldStatus
{
public:
    typedef std::vector<std::shared_ptr<AbstractKart> > KartList;
private:
    static World *m_world[PT_COUNT];
    // ------------------------------------------------------------------------
    void setAITeam();
    // ------------------------------------------------------------------------
    std::shared_ptr<AbstractKart> createKartWithTeam
        (const std::string &kart_ident, int index, int local_player_id,
        int global_player_id, RaceManager::KartType type,
        HandicapLevel handicap);
 
protected:
 
#ifdef DEBUG
    unsigned int m_magic_number;
#endif
 
    /* Team related variables. */
    int m_red_ai;
    int m_blue_ai;
    std::map<int, KartTeam> m_kart_team_map;
    std::map<int, unsigned int> m_kart_position_map;
 
    KartList                  m_karts;
    RandomGenerator           m_random;
 
    AbstractKart* m_fastest_kart;
    int         m_eliminated_karts;
    int         m_eliminated_players;
    int         m_num_players;
 
    bool        m_faster_music_active; // true if faster music was activated
 
    bool        m_stop_music_when_dialog_open;
 
    bool        m_unfair_team;
 
    bool        m_use_highscores;
 
    void  updateHighscores  (int* best_highscore_rank);
    void  resetAllKarts     ();
    Controller*
          loadAIController  (AbstractKart *kart);
 
    virtual std::shared_ptr<AbstractKart> createKart
        (const std::string &kart_ident, int index, int local_player_id,
        int global_player_id, RaceManager::KartType type,
        HandicapLevel handicap);
 
    RaceGUIBase *m_race_gui;
 
    RaceGUIBase *m_saved_race_gui;
 
    bool m_schedule_pause;
 
    bool m_schedule_unpause;
 
    bool m_schedule_exit_race;
 
    bool m_schedule_tutorial;
 
    Phase m_scheduled_pause_phase;
 
    bool m_restart_camera;
 
    bool m_self_destruct;
 
    bool m_is_network_world;
 
    bool m_ended_early;
 
    virtual void  onGo() OVERRIDE;
    virtual bool  isRaceOver() = 0;
    virtual void  update(int ticks) OVERRIDE;
    virtual void  createRaceGUI();
            void  updateTrack(int ticks);
    // ------------------------------------------------------------------------
    virtual float estimateFinishTimeForKart(AbstractKart* kart)
                                        {return getTime(); }
    void updateAchievementDataEndRace();
    void updateAchievementModeCounters(bool start);
 
public:
                    World();
    virtual        ~World();
    // Static functions to access world:
    // =================================
    // ------------------------------------------------------------------------
    static World*   getWorld()
    {
        ProcessType type = STKProcess::getType();
        return m_world[type];
    }
    // ------------------------------------------------------------------------
    static void     deleteWorld()
    {
        ProcessType type = STKProcess::getType();
        delete m_world[type];
        m_world[type] = NULL;
    }
    // ------------------------------------------------------------------------
    static void     setWorld(World *world)
    {
        ProcessType type = STKProcess::getType();
        m_world[type] = world;
    }
    // ------------------------------------------------------------------------
    static void     clear() { memset(m_world, 0, sizeof(m_world)); }
    // ------------------------------------------------------------------------
 
    // Pure virtual functions
    // ======================
 
    virtual const std::string& getIdent() const = 0;
    // ------------------------------------------------------------------------
    virtual unsigned int getNumberOfRescuePositions() const;
    // ------------------------------------------------------------------------
    virtual unsigned int getRescuePositionIndex(AbstractKart *kart) = 0;
    // ------------------------------------------------------------------------
    virtual btTransform getRescueTransform(unsigned int index) const;
    // ------------------------------------------------------------------------
    virtual void moveKartAfterRescue(AbstractKart* kart);
    // ------------------------------------------------------------------------
    virtual bool raceHasLaps() = 0;
    // ------------------------------------------------------------------------
    virtual bool showLapsTarget() { return false; }
    // ------------------------------------------------------------------------
    virtual int getFinishedLapsOfKart(unsigned int kart_index) const
    {
        assert(false); return -1; // remove compiler warning
    }   // getFinishedLapsOfKart
    // ------------------------------------------------------------------------
    virtual void getKartsDisplayInfo(
                       std::vector<RaceGUIBase::KartIconDisplayInfo> *info)= 0;
    // ------------------------------------------------------------------------
 
    // Virtual functions
    // =================
    virtual void    init();
    virtual void    updateGraphics(float dt);
    virtual void    terminateRace() OVERRIDE;
    virtual void    reset(bool restart=false) OVERRIDE;
    virtual void    pause(Phase phase) OVERRIDE;
    virtual void    unpause() OVERRIDE;
    virtual void    getDefaultCollectibles(int *collectible_type,
                                           int *amount );
    // ------------------------------------------------------------------------
    virtual void collectedItem(const AbstractKart *kart, 
                               const ItemState *item    ) {}
    // ------------------------------------------------------------------------
    virtual void endRaceEarly() { return; }
    // ------------------------------------------------------------------------
    virtual bool hasRaceEndedEarly() const { return m_ended_early; }
    // ------------------------------------------------------------------------
    virtual bool haveBonusBoxes() { return true; }
    // ------------------------------------------------------------------------
    virtual bool useFastMusicNearEnd() const { return true; }
    // ------------------------------------------------------------------------
    virtual void kartAdded(AbstractKart* kart, scene::ISceneNode* node) {}
    // ------------------------------------------------------------------------
    virtual void newLap(unsigned int kart_index) {}
    // ------------------------------------------------------------------------
    virtual bool kartHit(int kart_id, int hitter = -1) { return false; }
    // ------------------------------------------------------------------------
    virtual void onMouseClick(int x, int y) {};
 
    // Other functions
    // ===============
    Highscores     *getHighscores() const;
    Highscores     *getGPHighscores() const; 
    void            schedulePause(Phase phase);
    void            scheduleUnpause();
    void            scheduleExitRace() { m_schedule_exit_race = true; }
    void            scheduleTutorial();
    void            updateWorld(int ticks);
    void            handleExplosion(const Vec3 &xyz, AbstractKart *kart_hit,
                                    PhysicalObject *object);
    AbstractKart*   getPlayerKart(unsigned int player) const;
    AbstractKart*   getLocalPlayerKart(unsigned int n) const;
    virtual const btTransform &getStartTransform(int index);
    void moveKartTo(AbstractKart* kart, const btTransform &t);
    void updateTimeTargetSound();
    // ------------------------------------------------------------------------
    RaceGUIBase    *getRaceGUI() const { return m_race_gui;}
    // ------------------------------------------------------------------------
    unsigned int    getNumKarts() const { return (unsigned int) m_karts.size(); }
    // ------------------------------------------------------------------------
    AbstractKart       *getKart(int kartId) const {
                        assert(kartId >= 0 && kartId < int(m_karts.size()));
                        return m_karts[kartId].get();                              }
    // ------------------------------------------------------------------------
    const KartList & getKarts() const { return m_karts; }
    // ------------------------------------------------------------------------
    unsigned int    getCurrentNumKarts() const { return (int)m_karts.size() -
                                                         m_eliminated_karts; }
    // ------------------------------------------------------------------------
    unsigned int    getCurrentNumPlayers() const { return m_num_players -
                                                         m_eliminated_players;}
    // ------------------------------------------------------------------------
    void resetElimination()
    {
        m_eliminated_karts = 0;
        m_eliminated_players = 0;
    }
    // ------------------------------------------------------------------------
    virtual void addReservedKart(int kart_id)
    {
        if (m_eliminated_karts > 0)
            m_eliminated_karts--;
    }
    // ------------------------------------------------------------------------
    virtual void saveCompleteState(BareNetworkString* bns, STKPeer* peer) {}
    // ------------------------------------------------------------------------
    virtual void restoreCompleteState(const BareNetworkString& buffer) {}
    // ------------------------------------------------------------------------
    virtual bool shouldDrawTimer() const
                    { return isActiveRacePhase() && getClockMode() != CLOCK_NONE; }
    // ------------------------------------------------------------------------
    virtual bool shouldDrawSpeedometerDigit() const { return false; }
    // ------------------------------------------------------------------------
    virtual std::pair<int, video::SColor> getSpeedometerDigit(const AbstractKart *kart) const 
                { return std::make_pair(0, video::SColor(255, 255, 255, 255)); }
    // ------------------------------------------------------------------------
    bool useHighScores() const { return m_use_highscores; }
    // ------------------------------------------------------------------------
    virtual void onFirePressed(Controller* who) {}
    // ------------------------------------------------------------------------
    virtual bool useChecklineRequirements() const { return false; }
    // ------------------------------------------------------------------------
    virtual void escapePressed();
    // ------------------------------------------------------------------------
    virtual void loadCustomModels() {}
    // ------------------------------------------------------------------------
    void eliminateKart(int kart_number, bool notify_of_elimination = true);
    // ------------------------------------------------------------------------
    void setUnfairTeam(bool val)                       { m_unfair_team = val; }
    // ------------------------------------------------------------------------
    virtual bool hasTeam() const                              { return false; }
    // ------------------------------------------------------------------------
    KartTeam getKartTeam(unsigned int kart_id) const;
    // ------------------------------------------------------------------------
    int getTeamNum(KartTeam team) const;
    // ------------------------------------------------------------------------
    void setNetworkWorld(bool is_networked) { m_is_network_world = is_networked; }
    // ------------------------------------------------------------------------
    bool isNetworkWorld() const { return m_is_network_world; }
    // ------------------------------------------------------------------------
    void initTeamArrows(AbstractKart* k);
    // ------------------------------------------------------------------------
    virtual std::pair<uint32_t, uint32_t> getGameStartedProgress() const
    {
        return std::make_pair(std::numeric_limits<uint32_t>::max(),
            std::numeric_limits<uint32_t>::max());
    }
    // ------------------------------------------------------------------------
    virtual bool isGoalPhase() const { return false; }
};   // World
 
#endif
 
/* EOF */