CWE-ou-minkata/Sources/Plasma/PubUtilLib/plNetClientRecorder/plNetClientStreamRecorder.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plNetClientRecorder.h"
#include "hsStream.h"
#include "plNetMessage/plNetMessage.h"
#include "plCreatableIndex.h"
#include "hsResMgr.h"
#include "plgDispatch.h"
#include "plSDL/plSDL.h"
#include "pnNetCommon/plNetApp.h"

#include "plMessage/plLinkToAgeMsg.h"
#include "plMessage/plLoadAvatarMsg.h"
#include "plMessage/plLinkToAgeMsg.h"
#include "pnMessage/plNotifyMsg.h"
#include "plMessage/plAgeLoadedMsg.h"

#include "plStatusLog/plStatusLog.h"

plNetClientStreamRecorder::plNetClientStreamRecorder(TimeWrapper* timeWrapper) :
    plNetClientLoggingRecorder(timeWrapper),
    fRecordStream(nil),
    fResMgr(nil)
{
    if (fLog)
        delete fLog;
    fLog = plStatusLogMgr::GetInstance().CreateStatusLog(30, "StreamRecorder.log", plStatusLog::kAlignToTop);
}


plNetClientStreamRecorder::~plNetClientStreamRecorder()
{
    if (fRecordStream)
    {
        fRecordStream->Close();
        delete fRecordStream;
    }
}

hsResMgr* plNetClientStreamRecorder::GetResMgr()
{
    if (fResMgr)
        return fResMgr;
    else
        return hsgResMgr::ResMgr();
}

double plNetClientStreamRecorder::GetNextMessageTimeDelta()
{
    return fNextPlaybackTime - (GetTime() - fPlaybackTimeOffset);
}

enum NetClientRecFlags
{
    kNetClientRecSDLDesc,
};

bool plNetClientStreamRecorder::BeginRecording(const char* recName)
{
    if (!fRecordStream)
    {
        fRecordStream = TRACKED_NEW hsUNIXStream;
        char path[256];
        IMakeFilename(recName, path);

        if (!fRecordStream->Open(path, "wb"))
        {
            delete fRecordStream;
            return false;
        }

        hsBitVector contentFlags;
        contentFlags.SetBit(kNetClientRecSDLDesc);
        contentFlags.Write(fRecordStream);

        // kNetClientRecSDLDesc
        plSDLMgr::GetInstance()->Write(fRecordStream);

        return true;
    }

    return false;
}

bool plNetClientStreamRecorder::BeginPlayback(const char* recName)
{
    if (!fRecordStream)
    {
        fRecordStream = TRACKED_NEW hsUNIXStream;
        char path[256];
        IMakeFilename(recName, path);

        if (fRecordStream->Open(path, "rb"))
        {
            hsBitVector contentFlags;
            contentFlags.Read(fRecordStream);

            if (contentFlags.IsBitSet(kNetClientRecSDLDesc))
                plSDLMgr::GetInstance()->Read(fRecordStream);

            fPlaybackTimeOffset = GetTime();
            fNextPlaybackTime = fRecordStream->ReadSwapDouble();
            fBetweenAges = false;
        }
        else
        {
            delete fRecordStream;
            fRecordStream = nil;
            return false;
        }

        return true;
    }

    return false;
}

void plNetClientStreamRecorder::RecordMsg(plNetMessage* msg, double secs)
{
    if (!fRecordStream)
        return;

    if (IProcessRecordMsg(msg,secs))
    {
        fRecordStream->WriteSwapDouble(secs - fPlaybackTimeOffset);
        GetResMgr()->WriteCreatableVersion(fRecordStream, msg);

        ILogMsg(msg);
    }
}

void plNetClientStreamRecorder::RecordAgeLoadedMsg(plAgeLoadedMsg* ageLoadedMsg)
{
    fLog->AddLineF("Age %s", ageLoadedMsg->fLoaded ? "Loaded" : "Unloaded");

    if (ageLoadedMsg->fLoaded)
    {
        fBetweenAges = false;
        fPlaybackTimeOffset = GetTime();
    }
    else
    {
        fBetweenAges = true;
    }
}

bool plNetClientStreamRecorder::IsQueueEmpty()
{
    return (fRecordStream == nil);
}


plNetMessage* plNetClientStreamRecorder::GetNextMessage()
{
    plNetMessage* msg = nil;
    while (!fBetweenAges && (msg = IGetNextMessage()))
    {
        if (IIsValidMsg(msg))
            return msg;
        else
            hsRefCnt_SafeUnRef(msg);
    }

    return nil;
}

plNetMessage* plNetClientStreamRecorder::IGetNextMessage()
{
    plNetMessage* msg = nil;

    if (!IsQueueEmpty() && GetNextMessageTimeDelta() <= 0 )
    {
        msg = plNetMessage::ConvertNoRef(GetResMgr()->ReadCreatableVersion(fRecordStream));
        // msg->SetPeeked(true);

        // Fix the flags on game messages, so we won't get an assert later
        plNetMsgGameMessage* gameMsg = plNetMsgGameMessage::ConvertNoRef(msg);
        if (gameMsg)
        {
            plMessage* plMsg = gameMsg->GetContainedMsg(GetResMgr());
            plNetClientApp::GetInstance()->UnInheritNetMsgFlags(plMsg);

            // write message (and label) to ram stream
            hsRAMStream stream;
            GetResMgr()->WriteCreatable(&stream, plMsg);

            // put stream in net msg wrapper
            gameMsg->StreamInfo()->CopyStream(&stream);
            // gameMsg->StreamInfo()->SetStreamType(plMsg->ClassIndex());       // type of game msg
        }

        double nextPlaybackTime = fRecordStream->ReadSwapDouble();
        if (nextPlaybackTime < fNextPlaybackTime)
            fBetweenAges = true;

        fNextPlaybackTime = nextPlaybackTime;

        // If this was the last message, stop playing back
        if (fRecordStream->AtEnd())
        {
            fRecordStream->Close();
            delete fRecordStream;
            fRecordStream = nil;
        }
    }
    
    return msg;
}

bool plNetClientStreamRecorder::IIsValidMsg(plNetMessage* msg)
{
    if (plNetMsgGameMessage* gameMsg = plNetMsgGameMessage::ConvertNoRef(msg))
    {
        Int16 type = gameMsg->StreamInfo()->GetStreamType();

        //
        // These messages will be regenerated if they are for the local avatar,
        // so don't dispatch them in that case.
        //

        if (type == CLASS_INDEX_SCOPED(plLinkEffectsTriggerMsg))
        {
            plLinkEffectsTriggerMsg* linkMsg = plLinkEffectsTriggerMsg::ConvertNoRef(gameMsg->GetContainedMsg(GetResMgr()));
            if (plNetClientApp::GetInstance())
            {
                bool isLocal = (linkMsg->GetLinkKey() == plNetClientApp::GetInstance()->GetLocalPlayerKey());
                hsRefCnt_SafeUnRef(linkMsg);

                if (isLocal)
                {
                    ILogMsg(msg, "IGNORING ");
                    return false;
                }
            }
        }
        else if (type == CLASS_INDEX_SCOPED(plLoadAvatarMsg))
        {
            plLoadAvatarMsg* loadAvMsg = plLoadAvatarMsg::ConvertNoRef(gameMsg->GetContainedMsg(GetResMgr()));
            if (plNetClientApp::GetInstance())
            {
                bool isLocal = (loadAvMsg->GetCloneKey() == plNetClientApp::GetInstance()->GetLocalPlayerKey());
                hsRefCnt_SafeUnRef(loadAvMsg);

                if (isLocal)
                {
                    ILogMsg(msg, "IGNORING ");
                    return false;
                }
            }
        }
    }

    ILogMsg(msg);
    return true;
}

void plNetClientStreamRecorder::ILogMsg(plNetMessage* msg, const char* preText)
{
    if (msg->ClassIndex() == CLASS_INDEX_SCOPED(plNetMsgGameMessage))
    {
        plNetMsgGameMessage* gameMsg = plNetMsgGameMessage::ConvertNoRef(msg);
        fLog->AddLineF("%s%s(%s)", preText, msg->ClassName(), plFactory::GetNameOfClass(gameMsg->StreamInfo()->GetStreamType()));

        if (gameMsg->StreamInfo()->GetStreamType() == CLASS_INDEX_SCOPED(plNotifyMsg))
        {
            plNotifyMsg* notifyMsg = plNotifyMsg::ConvertNoRef(gameMsg->GetContainedMsg(GetResMgr()));
            int numEvents = notifyMsg->GetEventCount();
            for (int i = 0; i < numEvents; i++)
            {
                const char* eventName = "";

                proEventData* event = notifyMsg->GetEventRecord(i);
                switch (event->fEventType)
                {
                case proEventData::kCollision:      eventName = "Collision";        break;
                case proEventData::kPicked:         eventName = "Picked";           break;
                case proEventData::kControlKey:     eventName = "ControlKey";       break;
                case proEventData::kVariable:       eventName = "Variable";         break;
                case proEventData::kFacing:         eventName = "Facing";           break;
                case proEventData::kContained:      eventName = "Contained";        break;
                case proEventData::kActivate:       eventName = "Activate";         break;
                case proEventData::kCallback:       eventName = "Callback";         break;
                case proEventData::kResponderState: eventName = "ResponderState";   break;
                case proEventData::kMultiStage:     eventName = "MultiStage";       break;
                case proEventData::kSpawned:        eventName = "Spawned";          break;
                case proEventData::kClickDrag:      eventName = "ClickDrag";        break;
                }

                fLog->AddLineF("\t%s", eventName);
            }

            hsRefCnt_SafeUnRef(notifyMsg);
        }
    }
    else if (plNetMsgSDLState* sdlMsg = plNetMsgSDLState::ConvertNoRef(msg))
    {
        hsReadOnlyStream stream(sdlMsg->StreamInfo()->GetStreamLen(), sdlMsg->StreamInfo()->GetStreamBuf());        
        char* descName=nil;
        int ver;
        if (plStateDataRecord::ReadStreamHeader(&stream, &descName, &ver))
        {
            fLog->AddLineF("%s%s(%s)", preText, msg->ClassName(), descName);

            int i;

            plStateDataRecord sdRec(descName, ver);
            sdRec.Read(&stream, 0);
            plStateDataRecord::SimpleVarsList vars;
            sdRec.GetDirtyVars(&vars);
            for (i = 0; i < vars.size(); i++)
            {
                fLog->AddLineF("\t%s", vars[i]->GetVarDescriptor()->GetName());
            }

            plStateDataRecord::SDVarsList sdVars;
            sdRec.GetDirtySDVars(&sdVars);
            for (i = 0; i < sdVars.size(); i++)
            {
                fLog->AddLineF("\t%s", sdVars[i]->GetSDVarDescriptor()->GetName());
            }
        }
        delete [] descName;
    }
    else
        fLog->AddLineF("%s%s", preText, msg->ClassName());
}


bool plNetClientStressStreamRecorder::IsRecordableMsg(plNetMessage* msg) const
{
    UInt16 idx = msg->ClassIndex();

    return (
        plNetClientStreamRecorder::IsRecordableMsg(msg)
        || idx == CLASS_INDEX_SCOPED(plNetMsgTestAndSet)
        || idx == CLASS_INDEX_SCOPED(plNetMsgGameMessageDirected)
        || idx == CLASS_INDEX_SCOPED(plNetMsgVoice)
        );
}