rewind_info.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2016 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_INFO_HPP
#define HEADER_REWIND_INFO_HPP
 
#include "network/event_rewinder.hpp"
#include "network/network_string.hpp"
#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"
 
#include <assert.h>
#include <functional>
#include <string>
#include <vector>
 
class RewindInfo
{
private:
    LEAK_CHECK();
 
    int m_ticks;
 
    bool m_is_confirmed;
 
public:
    RewindInfo(int ticks, bool is_confirmed);
 
    void setTicks(int ticks);
 
    virtual void undo() = 0;
    virtual void restore() = 0;
    virtual void replay() = 0;
    // ------------------------------------------------------------------------
    virtual ~RewindInfo() { }
    // ------------------------------------------------------------------------
    int getTicks() const { return m_ticks; }
    // ------------------------------------------------------------------------
    void setConfirmed(bool b) { m_is_confirmed = b; }
    // ------------------------------------------------------------------------
    bool isConfirmed() const { return m_is_confirmed; }
    // ------------------------------------------------------------------------
    virtual bool isEvent() const { return false; }
    // ------------------------------------------------------------------------
    virtual bool isState() const { return false; }
    // ------------------------------------------------------------------------
};   // RewindInfo
 
// ============================================================================
class RewindInfoState: public RewindInfo
{
private:
    std::vector<std::string> m_rewinder_using;
 
    int m_start_offset;
 
    BareNetworkString *m_buffer;
 
public:
    // ------------------------------------------------------------------------
    RewindInfoState(int ticks, int start_offset,
                    std::vector<std::string>& rewinder_using,
                    std::vector<uint8_t>& buffer);
    // ------------------------------------------------------------------------
    RewindInfoState(int ticks, BareNetworkString *buffer, bool is_confirmed);
    // ------------------------------------------------------------------------
    virtual ~RewindInfoState()                             { delete m_buffer; }
    // ------------------------------------------------------------------------
    virtual void restore();
    // ------------------------------------------------------------------------
    BareNetworkString *getBuffer() const { return m_buffer; }
    // ------------------------------------------------------------------------
    virtual bool isState() const { return true; }
    // ------------------------------------------------------------------------
    virtual void undo()
    {
        // Nothing being done in case of an undo that goes further back
    }   // undo
    // ------------------------------------------------------------------------
    virtual void replay()
    {
        assert(false);
    }   // replay
};   // class RewindInfoState
 
// ============================================================================
class RewindInfoEvent : public RewindInfo
{
private:
    EventRewinder *m_event_rewinder;
 
    BareNetworkString *m_buffer;
public:
             RewindInfoEvent(int ticks, EventRewinder *event_rewinder,
                             BareNetworkString *buffer, bool is_confirmed);
    virtual ~RewindInfoEvent()
    {
        delete m_buffer;
    }   // ~RewindInfoEvent
 
    // ------------------------------------------------------------------------
    void restore() {}
    // ------------------------------------------------------------------------
    virtual bool isEvent() const { return true; }
    // ------------------------------------------------------------------------
    virtual void undo()
    {
        m_buffer->reset();
        m_event_rewinder->undo(m_buffer);
    }   // undo
    // ------------------------------------------------------------------------
    virtual void replay()
    {
        // Make sure to reset the buffer so we read from the beginning
        m_buffer->reset();
        m_event_rewinder->rewind(m_buffer);
    }   // rewind
    // ------------------------------------------------------------------------
    BareNetworkString *getBuffer() { return m_buffer; }
};   // class RewindIndoEvent
 
 
// ============================================================================
class RewindInfoEventFunction : public RewindInfo
{
private:
    const std::function<void()> m_undo_function, m_replay_function,
        m_destroy_function;
public:
    RewindInfoEventFunction(int ticks,
                            std::function<void()> undo_function = [](){},
                            std::function<void()> replay_function = [](){},
                            std::function<void()> destroy_function = [](){})
        : RewindInfo(ticks, true/*is_confirmed*/),
        m_undo_function(undo_function), m_replay_function(replay_function),
        m_destroy_function(destroy_function) {}
    // ------------------------------------------------------------------------
    ~RewindInfoEventFunction()                       {  m_destroy_function(); }
    // ------------------------------------------------------------------------
    void restore() {}
    // ------------------------------------------------------------------------
    virtual bool isEvent() const                               { return true; }
    // ------------------------------------------------------------------------
    virtual void undo()                                  { m_undo_function(); }
    // ------------------------------------------------------------------------
    virtual void replay()                              { m_replay_function(); }
};   // class RewindInfoEventFunction
 
#endif