rewind_manager.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2013 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_REWIND_MANAGER_HPP
#define HEADER_REWIND_MANAGER_HPP
 
#include "network/rewind_queue.hpp"
#include "utils/stk_process.hpp"
 
#include <assert.h>
#include <atomic>
#include <functional>
#include <memory>
#include <map>
#include <set>
#include <string>
#include <vector>
 
class Rewinder;
class RewindInfo;
class RewindInfoEventFunction;
class EventRewinder;
 
class RewindManager
{
private:
    static RewindManager *m_rewind_manager[PT_COUNT];
 
    static std::atomic_bool m_enable_rewind_manager;
 
    std::map<int, std::vector<std::function<void()> > > m_local_state;
 
    std::map<std::string, std::weak_ptr<Rewinder> > m_all_rewinder;
 
    RewindQueue m_rewind_queue;
 
    unsigned int m_overall_state_size;
 
    bool m_is_rewinding;
 
    int m_state_frequency;
 
    std::atomic<int> m_not_rewound_ticks;
 
    std::vector<RewindInfoEventFunction*> m_pending_rief;
 
    bool m_schedule_reset_network_body;
 
    std::set<std::string> m_missing_rewinders;
 
    RewindManager();
   ~RewindManager();
    // ------------------------------------------------------------------------
    void clearExpiredRewinder()
    {
        for (auto it = m_all_rewinder.begin(); it != m_all_rewinder.end();)
        {
            if (it->second.expired())
            {
                it = m_all_rewinder.erase(it);
                continue;
            }
            it++;
        }
    }
    // ------------------------------------------------------------------------
    void mergeRewindInfoEventFunction();
 
public:
    // First static functions to manage rewinding.
    // ===========================================
    static RewindManager *create();
    static void destroy();
    // ------------------------------------------------------------------------
    static void setEnable(bool m) { m_enable_rewind_manager = m; }
    // ------------------------------------------------------------------------
    static bool isEnabled() { return m_enable_rewind_manager; }
    // ------------------------------------------------------------------------
    static bool exists()
    {
        ProcessType pt = STKProcess::getType();
        return m_rewind_manager[pt] != NULL;
    }   // exists
    // ------------------------------------------------------------------------
    static RewindManager *get()
    {
        ProcessType pt = STKProcess::getType();
        assert(m_rewind_manager[pt]);
        return m_rewind_manager[pt];
    }   // get
 
    // Non-static function declarations:
 
    void reset();
    void update(int ticks);
    void rewindTo(int target_ticks, int ticks_now, bool fast_forward);
    void playEventsTill(int world_ticks, bool fast_forward);
    void addEvent(EventRewinder *event_rewinder, BareNetworkString *buffer,
                  bool confirmed, int ticks = -1);
    void addNetworkEvent(EventRewinder *event_rewinder,
                         BareNetworkString *buffer, int ticks);
    void addNetworkState(BareNetworkString *buffer, int ticks);
    void saveState();
    // ------------------------------------------------------------------------
    std::shared_ptr<Rewinder> getRewinder(const std::string& name)
    {
        auto it = m_all_rewinder.find(name);
        if (it != m_all_rewinder.end())
        {
            if (auto r = it->second.lock())
                return r;
        }
        return nullptr;
    }
    // ------------------------------------------------------------------------
    bool addRewinder(std::shared_ptr<Rewinder> rewinder);
    // ------------------------------------------------------------------------
    bool isRewinding() const { return m_is_rewinding; }
 
    // ------------------------------------------------------------------------
    int getNotRewoundWorldTicks() const
    {
        return m_not_rewound_ticks.load(std::memory_order_relaxed);
    }   // getNotRewoundWorldTicks
    // ------------------------------------------------------------------------
    int getLatestConfirmedState() const
    {
        return m_rewind_queue.getLatestConfirmedState(); 
    }   // getLatestConfirmedState
    // ------------------------------------------------------------------------
    bool useLocalEvent() const;
    // ------------------------------------------------------------------------
    void addRewindInfoEventFunction(RewindInfoEventFunction* rief)
                                            { m_pending_rief.push_back(rief); }
    // ------------------------------------------------------------------------
    void addNetworkRewindInfo(RewindInfo* ri)
                                   { m_rewind_queue.addNetworkRewindInfo(ri); }
    // ------------------------------------------------------------------------
    bool shouldSaveState(int ticks)
    {
        int a = ticks - m_state_frequency + 1;
        return ticks != 0 && a >= 0 && a % m_state_frequency == 0;
    }
    // ------------------------------------------------------------------------
    void resetSmoothNetworkBody()     { m_schedule_reset_network_body = true; }
    // ------------------------------------------------------------------------
    void handleResetSmoothNetworkBody();
    // ------------------------------------------------------------------------
    void addMissingRewinder(const std::string& name)
                                          { m_missing_rewinders.insert(name); }
    // ------------------------------------------------------------------------
    bool hasMissingRewinder(const std::string& name) const
        { return m_missing_rewinders.find(name) != m_missing_rewinders.end(); }
 
};   // RewindManager
 
 
#endif