replay_recorder.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2012-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_REPLAY_RECORDER_HPP
#define HEADER_REPLAY_RECORDER_HPP
 
#include "items/attachment.hpp"
#include "items/powerup_manager.hpp"
#include "karts/controller/kart_control.hpp"
#include "replay/replay_base.hpp"
 
#include <vector>
 
class ReplayRecorder : public ReplayBase
{
private:
    std::string m_filename;
 
    std::vector< std::vector<TransformEvent> > m_transform_events;
 
    std::vector< std::vector<PhysicInfo> > m_physic_info;
 
    std::vector< std::vector<BonusInfo> > m_bonus_info;
 
    std::vector< std::vector<KartReplayEvent> > m_kart_replay_event;
 
    std::vector<float> m_last_saved_time;
 
    std::vector<unsigned int> m_count_transforms;
 
    static ReplayRecorder *m_replay_recorder;
 
    bool  m_complete_replay;
 
    bool  m_incorrect_replay;
 
    unsigned int m_max_frames;
 
    // Stores the steering value at the previous transform.
    // Used to trigger the recording of new transforms.
    float m_previous_steer = 0.0f;
 
    const float DISTANCE_FAST_UPDATES = 10.0f;
 
    const float DISTANCE_MAX_UPDATES = 1.0f;
 
    uint64_t m_last_uid;
 
#ifdef DEBUG
    unsigned int m_count;
 
    unsigned int m_count_skipped_time;
 
    unsigned int m_count_skipped_interpolation;
#endif
 
    uint64_t computeUID(float min_time);
 
 
          ReplayRecorder();
         ~ReplayRecorder();
public:
    void  init();
    void  reset();
    void  save();
    void  update(int ticks);
 
    const uint64_t getLastUID() { return m_last_uid; }
 
    static int enumToCode (Attachment::AttachmentType type);
    static int enumToCode (PowerupManager::PowerupType type);
    static Attachment::AttachmentType codeToEnumAttach (int code);
    static PowerupManager::PowerupType codeToEnumItem (int code);
 
    // ------------------------------------------------------------------------
    static void create() {
        assert(!m_replay_recorder);
        m_replay_recorder = new ReplayRecorder();
    }
    // ------------------------------------------------------------------------
    static ReplayRecorder *get() { return m_replay_recorder; }
    // ------------------------------------------------------------------------
    static void destroy() { delete m_replay_recorder; m_replay_recorder=NULL; }
    // ------------------------------------------------------------------------
    virtual const std::string& getReplayFilename(int replay_file_number = 1) const { return m_filename; }
    // ------------------------------------------------------------------------
};   // ReplayRecorder
 
#endif