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 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;

    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;

    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();
    void displayCTFResults();
    void displaySoccerResults();
    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();
};   // RaceResultGUI

#endif