rewind_queue.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2017 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_QUEUE_HPP
#define HEADER_REWIND_QUEUE_HPP
 
#include "utils/synchronised.hpp"
 
#include <assert.h>
#include <list>
#include <vector>
 
class BareNetworkString;
class EventRewinder;
class RewindInfo;
class TimeStepInfo;
 
class RewindQueue
{
private:
 
    typedef std::list<RewindInfo*> AllRewindInfo;
 
    AllRewindInfo m_all_rewind_info;
 
    typedef std::vector<RewindInfo*> AllNetworkRewindInfo;
    Synchronised<AllNetworkRewindInfo> m_network_events;
 
    AllRewindInfo::iterator m_current;
 
    int m_latest_confirmed_state_time;
 
 
    void cleanupOldRewindInfo(int ticks);
 
public:
        static void unitTesting();
 
         RewindQueue();
        ~RewindQueue();
    void reset();
    void addLocalEvent(EventRewinder *event_rewinder, BareNetworkString *buffer,
                       bool confirmed, int ticks);
    void addLocalState(BareNetworkString *buffer, bool confirmed, int ticks);
    void addNetworkEvent(EventRewinder *event_rewinder,
                         BareNetworkString *buffer, int ticks);
    void addNetworkState(BareNetworkString *buffer, int ticks);
    void addNetworkRewindInfo(RewindInfo* ri)
    {
        m_network_events.lock();
        m_network_events.getData().push_back(ri);
        m_network_events.unlock();
    }
    void mergeNetworkData(int world_ticks,  bool *needs_rewind, 
                          int *rewind_ticks);
    void replayAllEvents(int ticks);
    bool isEmpty() const;
    bool hasMoreRewindInfo() const;
    int  undoUntil(int undo_ticks);
    void insertRewindInfo(RewindInfo *ri);
 
    // ------------------------------------------------------------------------
    int getLatestConfirmedState() const
    {
        return m_latest_confirmed_state_time;
    }
    // ------------------------------------------------------------------------
    void next()
    {
        assert(m_current != m_all_rewind_info.end());
        m_current++;
        return;
    }   // operator++
 
    // ------------------------------------------------------------------------
    RewindInfo* getCurrent()
    {
        return (m_current != m_all_rewind_info.end() ) ? *m_current : NULL;
    }   // getNext
 
};   // RewindQueue
 
 
#endif