feature_unlocked.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_FEATURE_UNLOCKED_HPP
#define HEADER_FEATURE_UNLOCKED_HPP
 
#include "graphics/irr_driver.hpp"
#include "guiengine/screen.hpp"
#include "race/race_manager.hpp"
#include "utils/ptr_vector.hpp"
 
#include <memory>
 
namespace irr {
    namespace scene { class ISceneNode; class ICameraSceneNode;
                      class ILightSceneNode;                       }
}
 
namespace SP
{
    class SPTexture;
}
 
class KartModel;
class KartProperties;
class ChallengeData;
 
class FeatureUnlockedCutScene : public GUIEngine::CutsceneScreen,
                                public GUIEngine::ScreenSingleton<FeatureUnlockedCutScene>
{
    friend class GUIEngine::ScreenSingleton<FeatureUnlockedCutScene>;
 
    FeatureUnlockedCutScene();
 
    struct UnlockedThing
    {
        const KartProperties* m_unlocked_kart;
 
        std::string m_unlock_model;
 
        std::vector<irr::video::ITexture*> m_pictures;
 
        std::vector<std::shared_ptr<SP::SPTexture> > m_sp_pictures;
 
        float m_w, m_h;
        int m_curr_image;
 
        scene::ISceneNode* m_root_gift_node;
 
        scene::ISceneNode* m_side_1;
        scene::ISceneNode* m_side_2;
 
        float m_scale;
 
        irr::core::stringw m_unlock_message;
 
        UnlockedThing(const std::string &model, const irr::core::stringw &msg);
 
        UnlockedThing(const KartProperties* kart, const irr::core::stringw &msg);
 
        UnlockedThing(irr::video::ITexture* pict, float w, float h,
                      const irr::core::stringw &msg);
 
        UnlockedThing(std::vector<irr::video::ITexture*> picts, float w, float h,
                      const irr::core::stringw &msg);
 
        ~UnlockedThing();
    };
 
    PtrVector<UnlockedThing, HOLD> m_unlocked_stuff;
 
    PtrVector<KartModel> m_all_kart_models;
 
    float m_global_time;
 
    float m_key_pos;
 
    float m_key_angle;
 
    void continueButtonPressed();
 
public:
 
    virtual void onCutsceneEnd() OVERRIDE;
 
    void onUpdate(float dt) OVERRIDE;
 
    virtual void loadedFromFile() OVERRIDE;
 
    void init() OVERRIDE;
 
    void tearDown() OVERRIDE;
 
    void eventCallback(GUIEngine::Widget* widget, const std::string& name,
                       const int playerID) OVERRIDE;
 
    void findWhatWasUnlocked(RaceManager::Difficulty difficulty, 
                             std::vector<const ChallengeData*>& unlocked);
 
    void addUnlockedKart(const KartProperties* unlocked_kart);
 
    void addUnlockedPicture(irr::video::ITexture* picture, float w, float h,
                            const irr::core::stringw &msg);
 
    void addUnlockedPictures(std::vector<irr::video::ITexture*> pictures,
                             float w, float h, irr::core::stringw msg);
 
    void addUnlockedTrack(const Track* track);
    void addUnlockedGP(const GrandPrixData* gp);
 
    // unused for now... maybe this could could useful later?
    /*
    void addUnlockedThings(const std::vector<const ChallengeData*> unlocked);
    */
 
    void addTrophy(RaceManager::Difficulty difficulty, bool is_grandprix);
 
    virtual bool onEscapePressed() OVERRIDE;
 
    virtual MusicInformation* getInGameMenuMusic() const OVERRIDE;
};
 
#endif