Recorder.cpp from palisma2d at Krugle

Show Recorder.cpp syntax highlighted

#include "StdAfx.h"
#include "Recorder.h"
#include "game/PlayerController.h"
#include "shared/MFile.h"
#include <fstream>
#include <sstream>
#include "kernel.h"

extern Kernel* g_kernel;

/*-------------------------------------------------------------------
    Recording Functions 
--------------------------------------------------------------------*/

Recorder::Recorder() : IEventListener()
{
    m_record = false;
    m_playing = false;
    m_startTime = 0.0f;

    m_fileName = "recording01.rcd";

    record_f.Set( this );
    playrec_f.Set( this );
    stoprec_f.Set( this );
    g_kernel->GetConsole()->AddCommand( &record_f, "record" );
    g_kernel->GetConsole()->AddCommand( &playrec_f, "playdemo" );
    g_kernel->GetConsole()->AddCommand( &stoprec_f, "stopdemo" );
}

Recorder::~Recorder()
{
    IEventListener::~IEventListener();

    g_kernel->GetConsole()->RemoveCommand( "record" );
    g_kernel->GetConsole()->RemoveCommand( "playdemo" );
    g_kernel->GetConsole()->RemoveCommand( "stopdemo" );
}

/** Handle an event */
bool Recorder::HandleEvent( IEvent* e )
{
    // if recording save the events
    if ( m_record ) {
        IEvent stored( *e );
        m_events.push( stored );
    }
    return m_record;
}


/** Update, pop events in play mode */
void Recorder::Update(long dt)
{
    static float nextTime = 0.0f;
    static float killTime = 0.0f;
    static bool  first = true;
    static float oldTime;

    if ( first )
    {
        if ( !m_events.empty() ) {
            oldTime = m_events.front().GetTimeFired();
            std::cout << oldTime << "\n";
            IEvent e = m_events.front();
            EventManager::GetInstance()->TriggerEvent( e );
            m_events.pop();
            nextTime = g_kernel->GetTime() + (e.GetTimeFired());
            first = false;
            return;
        }
    }
    if ( m_playing && !m_events.empty() && g_kernel->GetTime() >= nextTime )
    {
        //std::cout << "size: " << m_events.c.size() << "\n";

    
        IEvent e = m_events.front();
        EventManager::GetInstance()->TriggerEvent( e );
        m_events.pop();
        nextTime = g_kernel->GetTime() + (e.GetTimeFired() - oldTime);
        oldTime = e.GetTimeFired();

        std::cout << nextTime  << " vs CurrentTime: " << oldTime << "\n";
        if ( m_events.empty() ) {
            m_playing = false;
            first = false;
        }
    }
}

/** Enable recording */
void Recorder::StartRecording(const std::string &fileName)
{
    Player* p = EntityManager::GetInstance()->GetPlayer();
    // remove all its contents
    m_events.c.clear();
    if ( !p )
    {
        g_kernel->GetConsole()->Print("--Error could not record, no Player availible!" );
        return;
    } 
    else
    {
        player.name = p->GetName();
        player.state = p->GetState();
        player.pos = p->m_world;
        player.vel = p->m_baseVelocity;
        player.hp = p->m_health;
        m_fileName = fileName;
        m_startTime = g_kernel->GetTime();
        m_record = true;
    }
}

/** Save to file */
void Recorder::Save()
{
    //if ( !m_player || !m_record )
    //{
    //    g_kernel->GetConsole()->Print("--Error could not save, did not record anything!" );
    //    return;
    //}
    std::ofstream   stream;
    stream.open( (m_fileName+".rcd").c_str() );

    // TODO - write out in Binary
    stream << player.name << "," << player.state << "\n";
    // write players coords
    stream << player.pos.x << "," << player.pos.y << "\n";
    stream << player.hp  << "," << player.vel.x << "," << player.vel.y << "\n"; 

    // now write our the actions
    while ( !m_events.empty() )
    {
        IEvent e = m_events.front();

        stream  << e.GetType() << "," << (e.GetTimeFired()-m_startTime) << "," << 
            e.GetData<PlayerMovement>()->buttons << "," << e.GetListenerType() << "\n";

        m_events.pop();
    }
    m_record = false; //stop recording
    stream.close();

}


/** Load File */
void Recorder::Load(const std::string &fileName)
{
    MFile file;
    // open stream
    if ( file.Open( fileName ) )
    {
        g_kernel->GetConsole()->Print( ("ERROR: Could not find: " + fileName).c_str() );
        return;
    }

    Player* m_player = EntityManager::GetInstance()->GetPlayer();
    //m_player->SetName( file.ReadNext(",") );
    file.ReadNext(",");
    m_player->SetState( file.ReadNext("\n") );
    //m_player->MoveTo( Vector2f( file.ReadDouble(), file.ReadDouble() ) );
    int x = file.ReadDouble();
    int y = file.ReadDouble();
    m_player->m_world.Set( x, y  );
    // HACK FOR NOW - move the camera
    g_kernel->GetRenderer()->GetCamera(0)->MoveTo( Vector2f( x, y ) );

    m_player->m_health = file.ReadInt();
    m_player->m_baseVelocity.Set( file.ReadDouble(), file.ReadDouble()  ); 

    while ( !file.IsEnd() )
    {
        EventType evtType = (EventType)file.ReadInt();
        float time = file.ReadDouble();
        int b = ( file.ReadInt() );
        ListenerType listType = (ListenerType)file.ReadInt();

        m_events.push( IEvent( evtType, time, new PlayerMovement(b), listType ) );

    }
    m_playing = true;

}


/*--------------------------------------------------------------
    Recording Console Commands
---------------------------------------------------------------*/

void Record_f::Exec(std::string &s)
{
    if ( m_recorder )
    {
        m_recorder->StartRecording(s);
    }
}

void StopRecording_f::Exec(std::string &s)
{
    if ( m_recorder )
    {
        m_recorder->StopRecording();
    }
    
}

void PlayRecording_f::Exec(std::string &s)
{
    if ( m_recorder )
    {
        m_recorder->Load( s );
    }
    
}
See more files for this project here