diff --git a/src/Makefile.am b/src/Makefile.am index 411c8bb8b..b23bc55b7 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -321,15 +321,6 @@ supertuxkart_SOURCES = \ race/race_manager.hpp \ replay/replay.cpp \ replay/replay.hpp \ - replay/replay_base.cpp \ - replay/replay_base.hpp \ - replay/replay_buffer_tpl.hpp \ - replay/replay_buffers.cpp \ - replay/replay_buffers.hpp \ - replay/replay_player.cpp \ - replay/replay_player.hpp \ - replay/replay_recorder.cpp \ - replay/replay_recorder.hpp \ states_screens/credits.cpp \ states_screens/credits.hpp \ states_screens/dialogs/add_device_dialog.cpp \ diff --git a/src/ide/vc9/supertuxkart.vcproj b/src/ide/vc9/supertuxkart.vcproj index b379c5c4b..8e8d9d018 100644 --- a/src/ide/vc9/supertuxkart.vcproj +++ b/src/ide/vc9/supertuxkart.vcproj @@ -1112,22 +1112,6 @@ RelativePath="..\..\replay\replay.cpp" > - - - - - - - - - - - - - - - - - - -// -// 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. - -#ifdef HAVE_GHOST_REPLAY - -#include "replay/replay_base.hpp" - - -const std::string ReplayBase::REPLAY_FOLDER = "replay"; -const std::string ReplayBase::REPLAY_FILE_EXTENSION_HUMAN_READABLE = "rph"; -const std::string ReplayBase::REPLAY_FILE_EXTENSION_BINARY = "rpb"; - - -ReplayBase::ReplayBase() -: m_ReplayBuffers() -{ -} - -ReplayBase::~ReplayBase() -{ - destroy(); -} - -void ReplayBase::destroy() -{ - m_ReplayBuffers.destroy(); -} - - - - -#endif // HAVE_GHOST_REPLAY diff --git a/src/replay/replay_base.hpp b/src/replay/replay_base.hpp deleted file mode 100644 index 18ab5afa9..000000000 --- a/src/replay/replay_base.hpp +++ /dev/null @@ -1,75 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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_REPLAYBASE_HPP -#define HEADER_REPLAYBASE_HPP - -#ifdef HAVE_GHOST_REPLAY - - -#include - -#include "replay/replay_buffers.hpp" - - -// the data stored for each kart in each frame -struct ReplayKartState -{ - sgCoord position; -}; -// the data stored for each frame -struct ReplayFrame -{ - // absolute time of frame - float time; - // for each kart in frame, points to continious block - // in Buffers::m_pp_blocks_kart_states with m_number_karts items - ReplayKartState *p_kart_states; -}; - - -class ReplayBase -{ -public: - static const std::string REPLAY_FOLDER; - static const std::string REPLAY_FILE_EXTENSION_HUMAN_READABLE; - static const std::string REPLAY_FILE_EXTENSION_BINARY; - -public: - - ReplayBase(); - virtual ~ReplayBase(); - - virtual void destroy(); - - bool saveReplayHumanReadable( FILE *fd ) const { return m_ReplayBuffers.saveReplayHumanReadable( fd ); } - -private: - -protected: - ReplayBuffers m_ReplayBuffers; -}; - - - - - -#endif // HAVE_GHOST_REPLAY - -#endif // HEADER_REPLAYBASE_HPP - diff --git a/src/replay/replay_buffer_tpl.hpp b/src/replay/replay_buffer_tpl.hpp deleted file mode 100644 index 7cad95b18..000000000 --- a/src/replay/replay_buffer_tpl.hpp +++ /dev/null @@ -1,327 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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_REPLAYBUFFERTPL_HPP -#define HEADER_REPLAYBUFFERTPL_HPP - -#ifdef HAVE_GHOST_REPLAY - - -#include - -// needed for MSVC-memory-leak-checks -#if defined( REPLAY_UNIT_TEST ) && defined( _MSC_VER ) -# ifdef _DEBUG -# ifndef _DBG_NEW -# include - inline void* __operator_new(size_t __n) { return ::operator - new(__n,_NORMAL_BLOCK,__FILE__,__LINE__); } - inline void* _cdecl operator new(size_t __n,const char* __fname, - int __line) { - return ::operator new(__n,_NORMAL_BLOCK,__fname,__line); } - inline void _cdecl operator delete(void* __p,const char*,int) - { ::operator delete(__p);} -# define _DBG_NEW new(__FILE__,__LINE__) -# define new _DBG_NEW -# endif // _DBG_NEW -# else -# define __operator_new(__n) operator new(__n) -# endif -#endif - - -template class ReplayBufferArray; - -template -class ReplayBuffer -{ - friend class ReplayBufferArray; - -public: - ReplayBuffer() : m_pp_blocks(NULL),m_number_blocks(0),m_block_size(0), - m_number_objects_used(0),m_healthy(true) {} - ~ReplayBuffer() { destroy(); } - -private: - ReplayBuffer( ReplayBuffer const &c ); - ReplayBuffer const &operator=( ReplayBuffer const &c ); - -public: - bool init( size_t number_preallocated_objects ); - void destroy(); - // this is false, if a reallocation failed - bool isHealthy() const { return m_healthy; } - // returns a new *free* object, allocated memory if necessary - T* getNewObject(); - // returs object at given position, like usual array access, - // does not allocate memory, index must be < getNumberObjectsUsed() - T const* getObjectAt( size_t index ) const; - T* getObjectAt( size_t index ); - size_t getNumberObjectsUsed() const - { return m_number_objects_used; } - size_t getNumberBlocks() const { return m_number_blocks; } - -private: - // adds a new block of objects to m_pp_blocks with a size of m_block_size - bool addNewBlock(); - // helper to make sure healthy bit is set, if new fails - template - TT* buffer_new_array( size_t n ) - { -#if defined( REPLAY_UNIT_TEST ) && defined( _MSC_VER ) - // the msvc-debug-new macros didnt like nothrow - TT *p = new TT[ n ]; -#else - TT *p = new(std::nothrow) TT[ n ]; -#endif - m_healthy = (NULL != p ); - return p; - } - -private: - T **m_pp_blocks; - // number of allocated blocks. we start with 1 for recording - // for showing a replay-file it is 1 - size_t m_number_blocks; - // size of all blocks - size_t m_block_size; - // number of used objects - size_t m_number_objects_used; - // this flag indicates, that, if any reallocation happedened, it failed - // then recordings is blocked - bool m_healthy; -}; - - -// does the same as ReplayBuffer, but it returns an array of objects, -// rather than just one object .. -template -class ReplayBufferArray -{ -public: - ReplayBufferArray() : m_Buffer(), m_array_size(0) {} - ~ReplayBufferArray() { destroy(); } - - void destroy(); - bool init( size_t number_preallocated_arrays, - size_t array_size ); - // returns a new *free* array of objects with size of 2nd param in init - T* getNewArray(); - // returs objects at given position, like usual array access, - // does not allocate memory - T const* getArrayAt( size_t index ) const - { assert( m_array_size ); - return m_Buffer.getObjectAt( m_array_size * index ); } - T* getArrayAt( size_t index ) - { assert( m_array_size ); - return m_Buffer.getObjectAt( m_array_size * index ); } - size_t getNumberArraysUsed() const - { return m_Buffer.getNumberObjectsUsed() / m_array_size; } - size_t getNumberBlocks() const - { return m_Buffer.getNumberBlocks(); } - bool isHealthy() const - { return m_Buffer.isHealthy(); } - -private: - ReplayBuffer m_Buffer; - size_t m_array_size; -}; - - - - -template -bool ReplayBuffer::init( size_t number_preallocated_objects ) -{ - // make sure *clean* usage - assert( !m_pp_blocks ); - assert( number_preallocated_objects ); - m_block_size = number_preallocated_objects; - - if( !addNewBlock() ) return false; - - return true; -} - -template -void ReplayBuffer::destroy() -{ - size_t tmp; - if( m_pp_blocks ) - { - for( tmp = 0; tmp < m_number_blocks; ++tmp ) delete[] m_pp_blocks[tmp]; - delete[] m_pp_blocks; m_pp_blocks = NULL; - m_number_blocks = 0; - m_block_size = 0; - m_number_objects_used = 0; - m_healthy = true; - } -} - -// returns a new *free* frame to be used to store the current frame-data into -// it used to *record* the replay -template -T* ReplayBuffer::getNewObject() -{ - // make sure initialization was called properly - assert( m_pp_blocks ); - assert( m_number_blocks ); - - if( !m_healthy ) return NULL; - - // check, if we need a new block - if( m_number_objects_used == (m_block_size*m_number_blocks) ) - { - // we need a new block - if( !addNewBlock() ) return NULL; - } - - // get current frame - T* block_current = m_pp_blocks[ m_number_blocks-1 ]; - size_t new_in_block_idx = m_number_objects_used % m_block_size; - T* current = block_current + new_in_block_idx; - - ++m_number_objects_used; - - return current; -} - -// returs frame at given position from replay data -// used to *show* the replay -template -T const* ReplayBuffer::getObjectAt( size_t index ) const -{ - // make sure initialization was called properly - assert( m_pp_blocks ); - assert( m_number_blocks ); - assert( index < m_number_objects_used ); - assert( (index / m_block_size) < m_number_blocks ); - - T const* block = m_pp_blocks[ index / m_block_size ]; - return block + (index % m_block_size); -} - -template -T* ReplayBuffer::getObjectAt( size_t index ) -{ - // make sure initialization was called properly - assert( m_pp_blocks ); - assert( m_number_blocks ); - assert( index < m_number_objects_used ); - assert( (index / m_block_size) < m_number_blocks ); - - T* block = m_pp_blocks[ index / m_block_size ]; - return block + (index % m_block_size); -} - -// adds a new block of objects to m_pp_blocks with a size of m_block_size -template -bool ReplayBuffer::addNewBlock() -{ - assert( m_block_size ); - - if( !m_healthy ) return false; - - size_t number_blocks_new = m_number_blocks + 1; - - T **pp_blocks_old = m_pp_blocks; - m_pp_blocks = buffer_new_array( number_blocks_new ); - if( !m_pp_blocks ) - { - // put back old blocks - m_pp_blocks = pp_blocks_old; - return false; - } - - // copy old block pointers .. note: we dont copy the objects, - // only the pointers, to blocks of objects, which is supposed - // to be a very small number .. 2 is probably never reached - size_t tmp; - for( tmp = 0; tmp < m_number_blocks; ++tmp ) - m_pp_blocks[tmp] = pp_blocks_old[tmp]; - - // create new objects at new block position - m_pp_blocks[m_number_blocks] = buffer_new_array( m_block_size ); - if( !m_pp_blocks[m_number_blocks] ) - { - // delete and put back old blocks - delete[] m_pp_blocks; - m_pp_blocks = pp_blocks_old; - return false; - } - - // everything went fine, we got new arrays of objects - delete[] pp_blocks_old; pp_blocks_old = NULL; - - ++m_number_blocks; - - return true; -} - - -template -void ReplayBufferArray::destroy() -{ - m_Buffer.destroy(); - m_array_size = 0; -} - -template -bool ReplayBufferArray::init( size_t number_preallocated_arrays, - size_t array_size ) -{ - assert( number_preallocated_arrays ); - assert( array_size ); - m_array_size = array_size; - return m_Buffer.init( number_preallocated_arrays * array_size ); -} - -// returns a new *free* array of objects -template -T* ReplayBufferArray::getNewArray() -{ - if( !isHealthy() ) return NULL; - - // check, if we need a new block - if( m_Buffer.m_number_objects_used == - (m_Buffer.m_block_size*m_Buffer.m_number_blocks) ) - { - // we need a new block - if( !m_Buffer.addNewBlock() ) return NULL; - } - - // get current frame - T* block_current = m_Buffer.m_pp_blocks[ m_Buffer.m_number_blocks-1 ]; - size_t new_in_block_idx = - m_Buffer.m_number_objects_used % m_Buffer.m_block_size; - T* current = block_current + new_in_block_idx; - - assert( (current + m_array_size) <= (m_Buffer - .m_pp_blocks[ m_Buffer.m_number_blocks-1 ] - + m_Buffer.m_block_size) ); - - m_Buffer.m_number_objects_used += m_array_size; - - return current; -} - - -#endif // HAVE_GHOST_REPLAY - -#endif // HEADER_REPLAYBUFFERTPL_HPP - diff --git a/src/replay/replay_buffers.cpp b/src/replay/replay_buffers.cpp deleted file mode 100644 index df6a91983..000000000 --- a/src/replay/replay_buffers.cpp +++ /dev/null @@ -1,175 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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. - -#ifdef HAVE_GHOST_REPLAY - -#include "replay/replay_buffers.hpp" - -#include - -#include "replay/replay_base.hpp" - -#define REPLAY_SAVE_STATISTIC - -ReplayBuffers::ReplayBuffers() -: m_number_karts(0), - m_BufferFrame(), - m_BufferKartState() -{ -} - -ReplayBuffers::~ReplayBuffers() -{ - destroy(); -} - -void ReplayBuffers::destroy() -{ - m_BufferFrame.destroy(); - m_BufferKartState.destroy(); - m_number_karts = 0; -} - -bool ReplayBuffers::init( unsigned int number_karts, - size_t number_preallocated_frames ) -{ - m_number_karts = number_karts; - - if( !m_BufferFrame.init( number_preallocated_frames ) ) return false; - if( !m_BufferKartState.init( number_preallocated_frames, number_karts ) ) return false; - - return true; -} - -ReplayFrame* -ReplayBuffers::getNewFrame() -{ - // make sure initialization was called properly - assert( m_BufferFrame.getNumberObjectsUsed() == m_BufferKartState.getNumberArraysUsed() ); - - if( !isHealthy() ) return NULL; - - ReplayFrame* frame = m_BufferFrame.getNewObject(); - if( !frame ) return NULL; - - // get current karts-array - ReplayKartState* karts_array = m_BufferKartState.getNewArray(); - if( !karts_array ) return NULL; - - frame->p_kart_states = karts_array; - - return frame; -} - -bool ReplayBuffers::saveReplayHumanReadable( FILE *fd ) const -{ - if( !isHealthy() ) return false; - - if( fprintf( fd, "frames: %u\n", getNumberFrames() ) < 1 ) return false; - -#ifdef REPLAY_SAVE_STATISTIC - float time_step_min = 9999999.0f, time_step_max = 0.0f, time_last; -#endif - - unsigned int frame_idx, kart_idx; - ReplayFrame const *frame; - ReplayKartState const *kart; - for( frame_idx = 0; frame_idx < getNumberFrames(); ++frame_idx ) - { - frame = getFrameAt( frame_idx ); - if( fprintf( fd, "frame %u time %f\n", frame_idx, frame->time ) < 1 ) return false; - - for( kart_idx = 0; kart_idx < m_number_karts; ++kart_idx ) - { - kart = frame->p_kart_states + kart_idx; - - if( fprintf( fd, "\tkart %u: %f,%f,%f,%f,%f,%f\n", kart_idx, - kart->position.xyz[0], kart->position.xyz[1], kart->position.xyz[2], - kart->position.hpr[0], kart->position.hpr[1], kart->position.hpr[2] ) < 1 ) return false; - } - -#ifdef REPLAY_SAVE_STATISTIC - if( frame_idx ) - { - float diff = frame->time - time_last; - if( diff < time_step_min ) time_step_min = diff; - if( diff > time_step_max ) time_step_max = diff; - } - time_last = frame->time; -#endif - } - -#ifdef REPLAY_SAVE_STATISTIC - float time_step_avg; - if( getNumberFrames() > 1 ) - { - time_step_avg = time_last / ( getNumberFrames() - 1 ); - } - else - { - time_step_avg = -1.0f; - } - fprintf( fd, "\n# statistic time-steps:\n# \tmin: %f\n# \tmax: %f\n# \tavg: %f\n", time_step_min, time_step_max, time_step_avg ); -#endif - - return true; -} - -bool ReplayBuffers::loadReplayHumanReadable( FILE *fd, unsigned int number_karts ) -{ - size_t frames; - if( fscanf( fd, "frames: %u\n", &frames ) != 1 ) return false; - - if( !init( number_karts, frames ) ) return false; - - assert( m_number_karts ); - unsigned int frame_idx, kart_idx, tmp; - ReplayFrame *frame; - ReplayKartState *kart; - for( frame_idx = 0; frame_idx < frames; ++frame_idx ) - { - // if we are here, it cant fail, since enough objects have to be allocated above - frame = getNewFrame(); - assert( frame ); - - if( fscanf( fd, "frame %u time %f\n", &tmp, &frame->time ) != 2 ) return false; - - for( kart_idx = 0; kart_idx < m_number_karts; ++kart_idx ) - { - kart = frame->p_kart_states + kart_idx; - - if( fscanf( fd, "\tkart %u: %f,%f,%f,%f,%f,%f\n", &tmp, - &kart->position.xyz[0], &kart->position.xyz[1], &kart->position.xyz[2], - &kart->position.hpr[0], &kart->position.hpr[1], &kart->position.hpr[2] ) != 7 ) return false; - } - } - - assert( frames == getNumberFrames() ); - assert( m_BufferFrame.getNumberObjectsUsed() == getNumberFrames() ); - assert( m_BufferKartState.getNumberArraysUsed() == getNumberFrames() ); - - // there should be no reallocation .. - assert( m_BufferFrame.getNumberBlocks() == 1 ); - assert( m_BufferKartState.getNumberBlocks() == 1 ); - - return true; -} - - - -#endif // HAVE_GHOST_REPLAY diff --git a/src/replay/replay_buffers.hpp b/src/replay/replay_buffers.hpp deleted file mode 100644 index 499590330..000000000 --- a/src/replay/replay_buffers.hpp +++ /dev/null @@ -1,77 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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_REPLAYBUFFERS_HPP -#define HEADER_REPLAYBUFFERS_HPP - -#ifdef HAVE_GHOST_REPLAY - - -#include - -#include "replay/replay_buffer_tpl.hpp" - -struct ReplayKartState; -struct ReplayFrame; - - -// the worker-class .. administrates the memory-usage with no copy of -// previous replay-items when reallocation needed if buffers are full -class ReplayBuffers -{ -public: - - ReplayBuffers(); - ~ReplayBuffers(); - - bool init( unsigned int number_karts, - size_t number_preallocated_frames ); - void destroy(); - - // returns a new *free* frame to be used to store the current frame-data into it - // used to *record* the replay - ReplayFrame* getNewFrame(); - - // returs frame at given position from replay data - // used to *show* the replay - // if frame_index >= num_frames -> returns NULL - ReplayFrame const* getFrameAt( size_t frame_index ) const { return m_BufferFrame.getObjectAt( frame_index ); } - - size_t getNumberFrames() const { return m_BufferFrame.getNumberObjectsUsed(); } - unsigned int getNumberKarts() const { return m_number_karts; } - - bool saveReplayHumanReadable( FILE *fd ) const; - bool loadReplayHumanReadable( FILE *fd, unsigned int number_karts ); - -private: - bool isHealthy() const { return m_BufferFrame.isHealthy() && m_BufferKartState.isHealthy(); } - -private: - typedef ReplayBuffer BufferFrame; - typedef ReplayBufferArray BufferKartState; - - unsigned int m_number_karts; - BufferFrame m_BufferFrame; - BufferKartState m_BufferKartState; -}; - - -#endif // HAVE_GHOST_REPLAY - -#endif // HEADER_REPLAYBUFFERS_HPP - diff --git a/src/replay/replay_player.cpp b/src/replay/replay_player.cpp deleted file mode 100644 index 04df51f20..000000000 --- a/src/replay/replay_player.cpp +++ /dev/null @@ -1,186 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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. - -#ifdef HAVE_GHOST_REPLAY - -#include "replay/replay_player.hpp" - -#include "karts/kart_properties_manager.hpp" -#include "karts/kart_properties.hpp" - - -ReplayKart::ReplayKart() -: m_kart_properties(NULL), m_model(NULL) -{ -} - -ReplayKart::~ReplayKart() -{ - destroy(); -} - -void ReplayKart::destroy() -{ - m_kart_properties = NULL; -} - -bool ReplayKart::init( const std::string &strKartIdent ) -{ - assert( !m_kart_properties ); - - m_model = new ssgTransform(); - m_model->ref(); - - m_kart_properties = kart_properties_manager->getKart( strKartIdent ); - if( NULL == m_kart_properties ) return false; - - ssgEntity *obj = m_kart_properties->getModel(); - assert( obj ); - // Optimize the model, this can't be done while loading the model - // because it seems that it removes the name of the wheels or something - // else needed to load the wheels as a separate object. - ssgFlatten(obj); - - ssgRangeSelector *lod = new ssgRangeSelector; - - float r [ 2 ] = { -10.0f, 100.0f } ; - lod -> addKid ( obj ) ; - lod -> setRanges ( r, 2 ) ; - - m_model -> addKid ( lod ) ; - - return true; -} - -ReplayPlayer::ReplayPlayer() -: ReplayBase(), m_current_frame_index(-1) -{ -} - -ReplayPlayer::~ReplayPlayer() -{ - destroy(); -} - -void ReplayPlayer::destroy() -{ - m_current_frame_index = -1; - m_Karts.clear(); - ReplayBase::destroy(); -} - -bool ReplayPlayer::loadReplayHumanReadable( FILE *fd ) -{ - destroy(); - - bool blnRet = false; - int intTemp; - char buff[1000]; - size_t number_karts; - if( fscanf( fd, "Version: %s\n", buff ) != 1 ) return false; - if( fscanf( fd, "numkarts: %u\n", &number_karts ) != 1 ) return false; - if( fscanf( fd, "numplayers: %s\n", buff ) != 1 ) return false; - if( fscanf( fd, "difficulty: %s\n", buff ) != 1 ) return false; - if( fscanf( fd, "track: %s\n", buff ) != 1 ) return false; - for( size_t k = 0; k < number_karts; ++k ) - { - if( fscanf( fd, "model %d: %s\n", &intTemp, buff ) != 2 ) return false; - - m_Karts.resize( m_Karts.size() + 1 ); - ReplayKart &kart = m_Karts[ m_Karts.size() - 1 ]; - if( !kart.init( buff ) ) return false; - - scene->add ( kart.getModel() ); - } - - if( !m_ReplayBuffers.loadReplayHumanReadable( fd, number_karts ) ) return false; - - m_current_frame_index = 0; - - return true; -} - -void ReplayPlayer::showReplayAt( float abs_time ) -{ - assert( m_ReplayBuffers.getNumberFrames() ); - assert( m_current_frame_index > -1 ); - assert( (size_t)m_current_frame_index < m_ReplayBuffers.getNumberFrames() ); - - ReplayFrame const* frame; - - // find the current frame, we only scroll forward .. - while(1) - { - // end reached? - if( (m_current_frame_index + 1) == m_ReplayBuffers.getNumberFrames() ) break; - - // check time of next frame - frame = m_ReplayBuffers.getFrameAt( m_current_frame_index+1 ); - if( frame->time > abs_time ) break; - - ++m_current_frame_index; - } - - frame = m_ReplayBuffers.getFrameAt( m_current_frame_index ); - - // interpolate, if we are not at the end - if( (m_current_frame_index + 1) < (int)m_ReplayBuffers.getNumberFrames() ) - { - ReplayFrame const* frame_next = m_ReplayBuffers.getFrameAt( m_current_frame_index+1 ); - - // calc scale factor based on time between frames - assert( frame_next->time > frame->time ); - assert( frame_next->time != frame->time ); - float scale = (abs_time - frame->time) / (frame_next->time - frame->time); - - sgVec3 tmp_v3; - sgCoord pos; - - // calc interpolations for all objects - for( size_t k = 0; k < m_Karts.size(); ++k ) - { - // calc distance between next and current frame-position - sgCopyVec3( pos.xyz, frame->p_kart_states[k].position.xyz ) ; - sgCopyVec3( tmp_v3, frame_next->p_kart_states[k].position.xyz ) ; - sgSubVec3( tmp_v3, pos.xyz ); - - // scale it based on time between frames - sgScaleVec3( tmp_v3, scale ); - - // add interpolated vector - sgAddVec3( pos.xyz, tmp_v3 ); - - // no orientation-interpolation for starters - sgCopyVec3( pos.hpr, frame->p_kart_states[k].position.hpr ); - - m_Karts[ k ].setPosition( pos ); - } - } - else - { - // replay finished, leave them at last known position - for( size_t k = 0; k < m_Karts.size(); ++k ) - { - m_Karts[ k ].setPosition( frame->p_kart_states[ k ].position ); - } - } - -} - - -#endif // HAVE_GHOST_REPLAY diff --git a/src/replay/replay_player.hpp b/src/replay/replay_player.hpp deleted file mode 100644 index 8c709adf5..000000000 --- a/src/replay/replay_player.hpp +++ /dev/null @@ -1,86 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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_REPLAYPLAYER_HPP -#define HEADER_REPLAYPLAYER_HPP - -#ifdef HAVE_GHOST_REPLAY - -#include -#include "replay/replay_base.hpp" - - -class KartProperties; -class ReplayKart -{ -public: - ReplayKart(); - ~ReplayKart(); - - ReplayKart( ReplayKart const &kart ) { *this = kart; } - ReplayKart& operator=( ReplayKart const &kart ) - { - assert( this != &kart ); - m_kart_properties = kart.m_kart_properties; - m_model = kart.m_model; - sgCopyCoord ( &m_position, &kart.m_position ); - return *this; - } - bool init( const std::string &strKartIdent ); - void destroy(); - - ssgTransform* getModel() { return m_model; } - - void setPosition( const sgCoord &pos ) { sgCopyCoord ( &m_position, &pos ); m_model->setTransform(&m_position); } - -private: - const KartProperties *m_kart_properties; - sgCoord m_position; - ssgTransform *m_model; -}; - -// class managing: -// - the loading of replay-file -// - the rendering of the replay (interpolation if needed) -class ReplayPlayer : public ReplayBase -{ -public: - ReplayPlayer(); - virtual ~ReplayPlayer(); - - void destroy(); - - bool loadReplayHumanReadable( FILE *fd ); - - // calc state of replay-objects at given time - void showReplayAt( float abs_time ); - - void reset() { m_current_frame_index = 0; } - -private: - typedef std::vector ReplayKarts; - - int m_current_frame_index; - ReplayKarts m_Karts; -}; - - -#endif // HAVE_GHOST_REPLAY - -#endif // HEADER_REPLAYPLAYER_HPP - diff --git a/src/replay/replay_recorder.cpp b/src/replay/replay_recorder.cpp deleted file mode 100644 index caded2993..000000000 --- a/src/replay/replay_recorder.cpp +++ /dev/null @@ -1,85 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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. - -#ifdef HAVE_GHOST_REPLAY - -#include "replay/replay_recorder.hpp" - -#include - -#include "modes/world.hpp" - -const float ReplayRecorder::REPLAY_TIME_STEP_MIN = 1.0f / (float)ReplayRecorder::REPLAY_FREQUENCY_MAX; - -ReplayRecorder::ReplayRecorder() -: ReplayBase() -{ -} - -ReplayRecorder::~ReplayRecorder() -{ - destroy(); -} - -void ReplayRecorder::destroy() -{ - ReplayBase::destroy(); -} - -bool ReplayRecorder::initRecorder( unsigned int number_karts, size_t number_preallocated_frames ) -{ - assert( number_karts ); - - destroy(); - - if( !m_ReplayBuffers.init( number_karts, number_preallocated_frames ) ) return false; - - return true; -} - -bool ReplayRecorder::pushFrame() -{ - // we dont record the startphase .. - assert( RaceManager::getWorld()->getPhase() != World::START_PHASE ); - assert( RaceManager::getWorld()->getNumKarts() == m_ReplayBuffers.getNumberKarts() ); - - // make sure we're not under time-step-min - if( m_ReplayBuffers.getNumberFrames() ) - { - ReplayFrame const *last_Frame = m_ReplayBuffers.getFrameAt( m_ReplayBuffers.getNumberFrames() - 1 ); - if( (RaceManager::getWorld()->getTime() - last_Frame->time) < REPLAY_TIME_STEP_MIN ) return true; - } - - ReplayFrame *pFrame = getNewFrame(); - if( !pFrame ) return false; - pFrame->time = RaceManager::getWorld()->getClock(); - - Kart const *kart; - int number_karts = RaceManager::getWorld()->getNumKarts(); - for( int kart_index = 0; kart_index < number_karts; ++kart_index ) - { - kart = RaceManager::getKart( kart_index ); - sgCopyCoord( &( pFrame->p_kart_states[ kart_index ].position ), - kart->getCoord() ); - } - - return true; -} - - -#endif // HAVE_GHOST_REPLAY diff --git a/src/replay/replay_recorder.hpp b/src/replay/replay_recorder.hpp deleted file mode 100644 index 711866ff0..000000000 --- a/src/replay/replay_recorder.hpp +++ /dev/null @@ -1,62 +0,0 @@ -// -// SuperTuxKart - a fun racing game with go-kart -// Copyright (C) 2007 Maik Semder -// -// 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_REPLAYRECORDER_HPP -#define HEADER_REPLAYRECORDER_HPP - -#ifdef HAVE_GHOST_REPLAY - -#include "replay/replay_base.hpp" - - -// class managing: -// - the recording of the replay -// - the serializing to file -class ReplayRecorder : public ReplayBase -{ -private: - // assuming 10 minutes with 50 frames per second - enum { BUFFER_PREALLOCATE_FRAMES = 10 * 50 * 60, }; - enum { REPLAY_FREQUENCY_MAX = 30 }; - // calculated from REPLAY_FREQUENCY_MAX - static const float REPLAY_TIME_STEP_MIN; - -public: - ReplayRecorder(); - virtual ~ReplayRecorder(); - - void destroy(); - bool initRecorder( unsigned int number_karts, - size_t number_preallocated_frames = BUFFER_PREALLOCATE_FRAMES ); - - // something might go wrong, since a new buffer may be allocated, so false means - // no memory available - bool pushFrame(); - -private: - // returns a new *free* frame to be used to store the current frame-data into it - // used to *record* the replay - ReplayFrame* getNewFrame() { return m_ReplayBuffers.getNewFrame(); } -}; - - - -#endif // HAVE_GHOST_REPLAY - -#endif // HEADER_REPLAYRECORDER_HPP -