powerup_manager.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2006-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_POWERUPMANAGER_HPP
#define HEADER_POWERUPMANAGER_HPP
 
#include "utils/leak_check.hpp"
#include "utils/no_copy.hpp"
#include "utils/types.hpp"
 
#include "btBulletDynamicsCommon.h"
 
#include <atomic>
#include <map>
#include <string>
#include <vector>
 
class Material;
class XMLNode;
namespace irr
{
    namespace scene { class IMesh; }
}
 
class PowerupManager : public NoCopy
{
public:
    LEAK_CHECK();
private:
    // ------------------------------------------------------------------------
    class WeightsData
    {
    private:
        unsigned int m_num_karts;
 
        std::vector < std::vector<int> > m_weights_for_section;
 
        std::vector < std::vector<unsigned> > m_summed_weights_for_rank;
 
    public:
        // The friend declaration gives the PowerupManager access to the
        // internals, which is ONLY used for testing!!
        friend PowerupManager;
        WeightsData() { m_num_karts = 0; }
        void reset();
        void readData(int num_karts, const XMLNode *node);
        void interpolate(WeightsData *prev, WeightsData *next, int num_karts);
        void convertRankToSection(int rank, int *prev, int *next,
                                 float *weight);
        void precomputeWeights();
        int getRandomItem(int rank, uint64_t random_number);
        // --------------------------------------------------------------------
        void setNumKarts(int num_karts) { m_num_karts = num_karts; }
        // --------------------------------------------------------------------
        int getNumKarts() const { return m_num_karts; }
    };   // class WeightsData
    // ------------------------------------------------------------------------
 
    std::map<std::string, std::vector<WeightsData*> > m_all_weights;
 
public:
    // The anvil and parachute must be at the end of the enum, and the
    // zipper just before them (see Powerup::hitBonusBox).
    enum PowerupType {POWERUP_NOTHING,
                      POWERUP_FIRST,
                      POWERUP_BUBBLEGUM = POWERUP_FIRST,
                      POWERUP_CAKE,
                      POWERUP_BOWLING, POWERUP_ZIPPER, POWERUP_PLUNGER,
                      POWERUP_SWITCH, POWERUP_SWATTER, POWERUP_RUBBERBALL,
                      POWERUP_PARACHUTE,
                      POWERUP_ANVIL,      //powerup.cpp assumes these two come last
                      POWERUP_LAST=POWERUP_ANVIL,
                      POWERUP_MAX
    };
 
private:
 
    Material*     m_all_icons [POWERUP_MAX];
 
    irr::scene::IMesh *m_all_meshes[POWERUP_MAX];
 
    WeightsData m_current_item_weights;
 
    PowerupType   getPowerupType(const std::string &name) const;
 
    std::atomic<uint64_t> m_random_seed;
 
public:
    static void unitTesting();
 
                  PowerupManager  ();
                 ~PowerupManager  ();
    void          loadPowerupsModels ();
    void          loadWeights(const XMLNode *node, const std::string &category);
    void          unloadPowerups  ();
    void          computeWeightsForRace(int num_karts);
    void          loadPowerup     (PowerupType type, const XMLNode &node);
    PowerupManager::PowerupType
        getRandomPowerup(unsigned int pos, unsigned int *n,
                         uint64_t random_number);
    // ------------------------------------------------------------------------
    Material* getIcon(int type) const {return m_all_icons [type];}
    // ------------------------------------------------------------------------
    irr::scene::IMesh *getMesh(int type) const {return m_all_meshes[type];}
    // ------------------------------------------------------------------------
    uint64_t getRandomSeed() const { return m_random_seed.load(); }
    // ------------------------------------------------------------------------
    void setRandomSeed(uint64_t seed) { m_random_seed.store(seed); }
 
};   // class PowerupManager
 
extern PowerupManager* powerup_manager;
 
#endif