race_result_gui.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 SERVER_ONLY // No GUI files in server builds
#ifndef HEADER_RACE_RESULT_GUI_HPP
#define HEADER_RACE_RESULT_GUI_HPP
 
 
#include "guiengine/screen.hpp"
#include "states_screens/dialogs/message_dialog.hpp"
#include "states_screens/race_gui_base.hpp"
#include "states_screens/state_manager.hpp"
 
#include <assert.h>
#include <vector>
 
 
namespace irr
{
    namespace gui
    {
        class ScalableFont;
    }
}
 
class MusicInformation;
class SFXBase;
 
class RaceResultGUI : public RaceGUIBase,
                      public GUIEngine::Screen,
                      public GUIEngine::ScreenSingleton<RaceResultGUI>,
                      public MessageDialog::IConfirmDialogListener
{
private:
    float                      m_timer;
 
    enum                       {RR_INIT,
                                RR_RACE_RESULT,
                                RR_WAITING_GP_RESULT,
                                RR_OLD_GP_RESULTS,
                                RR_INCREASE_POINTS,
                                RR_RESORT_TABLE,
                                RR_WAIT_TILL_END}
                               m_animation_state;
 
    class RowInfo
    {
    public:
        unsigned int     m_kart_id;
        float            m_start_at;
        float            m_x_pos;
        float            m_y_pos;
        bool             m_is_player_kart;
        float            m_radius;
        float            m_centre_point;
        core::stringw    m_kart_name;
        float            m_new_points;
        int              m_new_overall_points;
        int              m_new_gp_rank;
        float            m_current_displayed_points;
        video::ITexture *m_kart_icon;
        core::stringw    m_finish_time_string;
        float            m_kart_color;
        unsigned int     m_laps;
    };   // Rowinfo
 
    std::vector<RowInfo>       m_all_row_infos, m_all_row_info_waiting;
 
    float                      m_time_between_rows;
 
    float                      m_time_single_scroll;
 
    float                      m_time_rotation;
 
    float                      m_time_for_points;
 
    float                      m_time_overall_scroll;
 
    float                      m_extra_scroll_time;
 
    unsigned int               m_distance_between_rows;
 
    unsigned int               m_distance_between_meta_rows;
 
    unsigned int               m_width_icon;
 
    unsigned int               m_width_kart_name;
 
    unsigned int               m_width_finish_time;
 
    unsigned int               m_width_new_points;
 
    unsigned int               m_leftmost_column;
 
    unsigned int               m_top;
 
    unsigned int               m_width_column_space;
 
    unsigned int               m_table_width;
 
    gui::ScalableFont         *m_font;
 
    bool                       m_gp_position_was_changed;
 
    bool                       m_started_race_over_music;
 
    //bool                       m_was_monospace;
 
    SFXBase                   *m_finish_sound;
 
    MusicInformation          *m_race_over_music;
 
    int m_highscore_rank;
 
    float m_most_points;
 
    unsigned int m_width_all_points;
 
    int m_max_tracks;
    int m_start_track;
    int m_end_track;
    int m_sshot_height;
 
    PtrVector<GUIEngine::Widget, HOLD>  m_gp_progress_widgets;
 
    static const int SSHOT_SEPARATION = 10;
 
    void displayOneEntry(unsigned int x, unsigned int y,
                         unsigned int n, bool display_points);
    void determineTableLayout();
    void determineGPLayout();
    void enableAllButtons();
    void enableGPProgress();
    void addGPProgressWidget(GUIEngine::Widget* widget);
    void displayGPProgress();
    void displayPostRaceInfo();
    int  displayHighscores(int x, int y, bool increase_density);
    int  displayLapDifficulty(int x, int y, bool increase_density);
    int  displayChallengeInfo(int x, int y, bool increase_density);
    void displayCTFResults();
    void drawCTFScorers(KartTeam team, int x, int y, int height);
    void displaySoccerResults();
    void drawTeamScorers(KartTeam team, int x, int y, int height);
    void displayBenchmarkSummary();
    void displayScreenShots();
 
    int  getFontHeight () const;
 
public:
 
                 RaceResultGUI();
    virtual void renderGlobal(float dt) OVERRIDE;
 
    virtual void loadedFromFile() OVERRIDE {};
 
    virtual void init() OVERRIDE;
    virtual void tearDown() OVERRIDE;
    virtual bool onEscapePressed() OVERRIDE;
    virtual void unload() OVERRIDE;
    virtual GUIEngine::EventPropagation
                 filterActions(PlayerAction action, int deviceID, const unsigned int value,
                               Input::InputType type, int playerId) OVERRIDE;
    void eventCallback(GUIEngine::Widget* widget, const std::string& name,
                       const int playerID) OVERRIDE;
    friend class GUIEngine::ScreenSingleton<RaceResultGUI>;
 
    const core::dimension2du getMiniMapSize() const OVERRIDE
                  { return core::dimension2du(0, 0); }
 
    virtual void renderPlayerView(const Camera *camera, float dt) OVERRIDE {}
 
    virtual void onUpdate(float dt) OVERRIDE;
    virtual void onDraw(float dt) OVERRIDE;
 
    virtual void addMessage(const irr::core::stringw &m,
                            const AbstractKart *kart,
                            float time,
                            const video::SColor &color=
                                video::SColor(255, 255, 0, 255),
                            bool important=true,
                            bool big_font=false,
                            bool outline=false) OVERRIDE { }
 
    void nextPhase();
 
    void clearHighscores();
 
    void setHighscore(int rank);
 
    virtual void onConfirm() OVERRIDE;
    void cleanupGPProgress();
    virtual void onResize() OVERRIDE;
};   // RaceResultGUI
 
#endif
#endif // ifndef SERVER_ONLY