CWE-ou-minkata/Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.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==*/
#ifndef NO_AV_MSGS

#include "plAvatarMsg.h"

#include "hsResMgr.h"

#include "pnKeyedObject/plKey.h"
#include "pnSceneObject/plSceneObject.h"

#ifndef SERVER
#include "plAvatar/plAvBrain.h"
#endif


//////////////
// PLAVATARMSG
//////////////

// CTOR()
plAvatarMsg::plAvatarMsg()
: plMessage()
{
}

// CTOR(sender, receiver, time)
plAvatarMsg::plAvatarMsg(const plKey &sender, const plKey &receiver)
: plMessage(sender, receiver, nil)
{
}

// READ
void plAvatarMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    plMessage::IMsgRead(stream, mgr);
}

// WRITE
void plAvatarMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    plMessage::IMsgWrite(stream, mgr);
}

//////////////////////
// PLARMATUREUPDATEMSG
//////////////////////

// CTOR()
plArmatureUpdateMsg::plArmatureUpdateMsg()
: fIsInvis(false)
{
    SetBCastFlag(plMessage::kBCastByExactType);
}

// CTOR sender receiver islocal isplayercontrolled
plArmatureUpdateMsg::plArmatureUpdateMsg(const plKey &sender,
                                         hsBool isLocal, hsBool isPlayerControlled,
                                         plArmatureMod *armature)
: plAvatarMsg(sender, nil),
  fIsLocal(isLocal),
  fIsPlayerControlled(isPlayerControlled),
  fArmature(armature),
  fIsInvis(false)
{
    SetBCastFlag(plMessage::kBCastByExactType);
}

// READ stream mgr
void plArmatureUpdateMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    hsAssert(false, "This message is not supposed to travel over the network or persist in a file.");
}

// WRITE stream mgr
void plArmatureUpdateMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    hsAssert(false, "This message is not supposed to travel over the network or persist in a file.");
}

// ISLOCAL
hsBool plArmatureUpdateMsg::IsLocal() const
{
    return fIsLocal;
}

// ISPLAYERCONTROLLED
hsBool plArmatureUpdateMsg::IsPlayerControlled() const
{
    return fIsPlayerControlled;
}

hsBool plArmatureUpdateMsg::IsInvis() const
{
    return fIsInvis;
}

/////////////////////
// PLAVATARSETTYPEMSG
/////////////////////

// ctor
plAvatarSetTypeMsg::plAvatarSetTypeMsg()
: fIsPlayer(false)
{
}

plAvatarSetTypeMsg::plAvatarSetTypeMsg(const plKey &sender, const plKey &receiver)
: plAvatarMsg(sender, receiver),
  fIsPlayer(false)
{
}

// READ
void plAvatarSetTypeMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    fIsPlayer = stream->Readbool();
}

// WRITE
void plAvatarSetTypeMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    stream->Writebool(fIsPlayer);
}

// SETISPLAYER
void plAvatarSetTypeMsg::SetIsPlayer(bool is)
{
    fIsPlayer = is;
}

// ISPLAYER
bool plAvatarSetTypeMsg::IsPlayer()
{
    return fIsPlayer;
}



//////////////
// PLAVTASKMSG
//////////////

plAvTaskMsg::plAvTaskMsg()
: plAvatarMsg(), fTask(nil)
{
}

plAvTaskMsg::plAvTaskMsg(const plKey &sender, const plKey &receiver)
: plAvatarMsg(sender, receiver), fTask(nil)
{
}

plAvTaskMsg::plAvTaskMsg(const plKey &sender, const plKey &receiver, plAvTask *task)
: plAvatarMsg(sender, receiver),
  fTask(task)
{
}

plAvTask *plAvTaskMsg::GetTask()
{
    return fTask;
}

// READ
void plAvTaskMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    plAvatarMsg::Read(stream, mgr);
    if(stream->ReadBool())
        fTask = (plAvTask *)mgr->ReadCreatable(stream);

}

// WRITE
void plAvTaskMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    plAvatarMsg::Write(stream, mgr);
    if(fTask)
    {
        stream->WriteBool(true);
        mgr->WriteCreatable(stream, (plCreatable *)fTask);
    } else {
        stream->WriteBool(false);
    }
}

//////////////
//
// PLAVSEEKMSG
//
//////////////
// Tell the avatar to go to a specific seekpoint.
// The given key (seekKey) must be to a plSeekPointMod

// CTOR()
plAvSeekMsg::plAvSeekMsg()
: plAvTaskMsg(),
  fSeekPoint(nil),
  fDuration(0),
  fSmartSeek(true),
  fAlignType(kAlignHandle),
  fAnimName(nil),
  fNoSeek(false),
  fFlags(kSeekFlagForce3rdPersonOnStart)
{
}

// CTOR(sender, receiver, seekKey, time)
plAvSeekMsg::plAvSeekMsg(const plKey& sender, const plKey& receiver,
                         const plKey &seekKey, float duration, hsBool smartSeek,
                         plAvAlignment alignType, char *animName, hsBool noSeek, 
                         UInt8 flags, plKey finishKey)
: plAvTaskMsg(sender, receiver),
  fSeekPoint(seekKey),
  fTargetPos(0, 0, 0),
  fTargetLookAt(0, 0, 0),
  fDuration(duration),
  fSmartSeek(smartSeek),
  fAnimName(animName),
  fAlignType(alignType),
  fNoSeek(noSeek),
  fFlags(flags),
  fFinishKey(finishKey)
{
}

hsBool plAvSeekMsg::Force3rdPersonOnStart()
{
    return fFlags & kSeekFlagForce3rdPersonOnStart;
}

hsBool plAvSeekMsg::UnForce3rdPersonOnFinish()
{
    return fFlags & kSeekFlagUnForce3rdPersonOnFinish;
}

hsBool plAvSeekMsg::NoWarpOnTimeout()
{
    return fFlags & kSeekFlagNoWarpOnTimeout;
}

hsBool plAvSeekMsg::RotationOnly()
{
    return fFlags & kSeekFlagRotationOnly;
}

// READ
void plAvSeekMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    plAvTaskMsg::Read(stream, mgr);

    fSeekPoint = mgr->ReadKey(stream);
    if (!fSeekPoint)
    {
        fTargetPos.Read(stream);
        fTargetLookAt.Read(stream);
    }

    fDuration = stream->ReadSwapScalar();
    fSmartSeek = stream->ReadBool();
    fAnimName = stream->ReadSafeString();
    fAlignType = static_cast<plAvAlignment>(stream->ReadSwap16());
    fNoSeek = stream->ReadBool();
    fFlags = stream->ReadByte();
    fFinishKey = mgr->ReadKey(stream);
}

// WRITE
void plAvSeekMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    plAvTaskMsg::Write(stream, mgr);

    mgr->WriteKey(stream, fSeekPoint);
    if (!fSeekPoint)
    {
        fTargetPos.Write(stream);
        fTargetLookAt.Write(stream);
    }

    stream->WriteSwapScalar(fDuration);
    stream->WriteBool(fSmartSeek);
    stream->WriteSafeString(fAnimName);
    stream->WriteSwap16(static_cast<UInt16>(fAlignType));
    stream->WriteBool(fNoSeek);
    stream->WriteByte(fFlags);
    mgr->WriteKey(stream, fFinishKey);
}

/////////////////////////////////////////////////////////////////////////////////////////

void plAvTaskSeekDoneMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    plAvatarMsg::Read(stream, mgr);

    fAborted = stream->ReadBool();
}

void plAvTaskSeekDoneMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    plAvatarMsg::Write(stream, mgr);

    stream->WriteBool(fAborted);
}

/////////////////
//
// PLAVONESHOTMSG
//
/////////////////

#include "../plMessage/plOneShotCallbacks.h"

// CTOR()
plAvOneShotMsg::plAvOneShotMsg()
: plAvSeekMsg(), fAnimName(nil), fDrivable(false), fReversible(false), fCallbacks(nil)
{
}

// CTOR(sender, receiver, seekKey, time)
plAvOneShotMsg::plAvOneShotMsg(const plKey &sender, const plKey& receiver,
                         const plKey& seekKey, float duration, hsBool smartSeek,
                         const char *animName, hsBool drivable, hsBool reversible)
: plAvSeekMsg(sender, receiver, seekKey, duration, smartSeek),
  fDrivable(drivable), fReversible(reversible), fCallbacks(nil)
{
    fAnimName = hsStrcpy(animName);
}

// DTOR
plAvOneShotMsg::~plAvOneShotMsg()
{
    hsRefCnt_SafeUnRef(fCallbacks);
    fCallbacks = nil;

    delete[] fAnimName;
}

// READ
void plAvOneShotMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    plAvSeekMsg::Read(stream, mgr);

    delete [] fAnimName;
    fAnimName = stream->ReadSafeString();
    fDrivable = stream->ReadBool();
    fReversible = stream->ReadBool();
}

// WRITE
void plAvOneShotMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    plAvSeekMsg::Write(stream, mgr);

    stream->WriteSafeString(fAnimName);
    stream->WriteBool(fDrivable);
    stream->WriteBool(fReversible);
}


////////////////
//
// plAvBrainGenericMsg
//
////////////////

// default CTOR
plAvBrainGenericMsg::plAvBrainGenericMsg()
: fType(kNextStage),        // default verb is goto next stage
  fWhichStage(0),           // default stage is 0
  fSetTime(false),          // don't set the time of the target stage
  fNewTime(0.0f),           // if we do set, set it to zero
  fSetDirection(false),     // don't set the direction of the brain
  fNewDirection(true),      // if we do set the direction, set it to forward
  fNewLoopCount(0)
{
}

// canonical CTOR sender receiver type stage rewind transitionTime
plAvBrainGenericMsg::plAvBrainGenericMsg(const plKey& sender, const plKey &receiver,
                    plAvBrainGenericMsg::Type type, int stage, hsBool rewind, hsScalar transitionTime)
: plAvatarMsg(sender, receiver),
  fType(type),
  fWhichStage(stage),
  fSetTime(rewind),
  fNewTime(0.0f),
  fSetDirection(false),
  fNewDirection(true),
  fNewLoopCount(0)
{
    
}

plAvBrainGenericMsg::plAvBrainGenericMsg(const plKey& sender, const plKey &receiver,
                                         Type type, int stage, hsBool setTime, hsScalar newTime,
                                         hsBool setDirection, bool isForward, hsScalar transitiontime)
: plAvatarMsg(sender, receiver),
  fType(type),
  fWhichStage(stage),
  fSetTime(setTime),
  fNewTime(newTime),
  fSetDirection(setDirection),
  fNewDirection(isForward),
  fNewLoopCount(0)
{
}

plAvBrainGenericMsg::plAvBrainGenericMsg(plKey sender, plKey receiver,
                                         Type type, int stage, int newLoopCount)
: plAvatarMsg(sender, receiver),
  fType(type),
  fWhichStage(stage),
  fSetTime(false),                  // unused
  fNewTime(0),                      // unused
  fSetDirection(false),             // unused
  fNewDirection(false),             // unused
  fNewLoopCount(newLoopCount)
{
    hsAssert(type == kSetLoopCount, "This constructor form is only for the kSetLoopCount command.");
}


void plAvBrainGenericMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    plAvatarMsg::Write(stream, mgr);
    stream->WriteSwap32(fType);
    stream->WriteSwap32(fWhichStage);
    stream->WriteBool(fSetTime);
    stream->WriteSwapScalar(fNewTime);
    stream->WriteBool(fSetDirection);
    stream->WriteBool(fNewDirection);
    stream->WriteSwapScalar(fTransitionTime);
}

void plAvBrainGenericMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    plAvatarMsg::Read(stream, mgr);
    fType = static_cast<plAvBrainGenericMsg::Type>(stream->ReadSwap32());
    fWhichStage = stream->ReadSwap32();
    fSetTime = stream->ReadBool();
    fNewTime = stream->ReadSwapScalar();
    fSetDirection = stream->ReadBool();
    fNewDirection = stream->ReadBool();
    fTransitionTime = stream->ReadSwapScalar();
}

enum AvBrainGenericFlags
{
    kAvBrainGenericType,
    kAvBrainGenericWhich,
    kAvBrainGenericSetTime,
    kAvBrainGenericNewTime,
    kAvBrainGenericSetDir,
    kAvBrainGenericNewDir,
    kAvBrainGenericTransTime,
};

void plAvBrainGenericMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
{
    plMessage::IMsgWriteVersion(s, mgr);

    hsBitVector contentFlags;
    contentFlags.SetBit(kAvBrainGenericType);
    contentFlags.SetBit(kAvBrainGenericWhich);
    contentFlags.SetBit(kAvBrainGenericSetTime);
    contentFlags.SetBit(kAvBrainGenericNewTime);
    contentFlags.SetBit(kAvBrainGenericSetDir);
    contentFlags.SetBit(kAvBrainGenericNewDir);
    contentFlags.SetBit(kAvBrainGenericTransTime);
    contentFlags.Write(s);

    // kAvBrainGenericType
    s->WriteSwap32(fType);
    // kAvBrainGenericWhich 
    s->WriteSwap32(fWhichStage);
    // kAvBrainGenericSetTime   
    s->WriteBool(fSetTime);
    // kAvBrainGenericNewTime   
    s->WriteSwapScalar(fNewTime);
    // kAvBrainGenericSetDir    
    s->WriteBool(fSetDirection);
    // kAvBrainGenericNewDir    
    s->WriteBool(fNewDirection);
    // kAvBrainGenericTransTime 
    s->WriteSwapScalar(fTransitionTime);
}

void plAvBrainGenericMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
{
    plMessage::IMsgReadVersion(s, mgr);

    hsBitVector contentFlags;
    contentFlags.Read(s);

    if (contentFlags.IsBitSet(kAvBrainGenericType))
        fType = static_cast<plAvBrainGenericMsg::Type>(s->ReadSwap32());
    if (contentFlags.IsBitSet(kAvBrainGenericWhich))
        fWhichStage = s->ReadSwap32();
    if (contentFlags.IsBitSet(kAvBrainGenericSetTime))
        fSetTime = s->ReadBool();
    if (contentFlags.IsBitSet(kAvBrainGenericNewTime))
        fNewTime = s->ReadSwapScalar();
    if (contentFlags.IsBitSet(kAvBrainGenericSetDir))
        fSetDirection = s->ReadBool();
    if (contentFlags.IsBitSet(kAvBrainGenericNewDir))
        fNewDirection = s->ReadBool();
    if (contentFlags.IsBitSet(kAvBrainGenericTransTime))
        fTransitionTime = s->ReadSwapScalar();
}

///////////////////
//
// PLAVPUSHBRAINMSG
//
///////////////////

#ifndef SERVER

// default ctor
plAvPushBrainMsg::plAvPushBrainMsg()
: fBrain(nil)
{
}

// canonical ctor
plAvPushBrainMsg::plAvPushBrainMsg(const plKey& sender, const plKey &receiver, plArmatureBrain *brain)
: plAvTaskMsg(sender, receiver)
{
    fBrain = brain;
}

// dtor
plAvPushBrainMsg::~plAvPushBrainMsg()
{
}

// READ
void plAvPushBrainMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    plAvTaskMsg::Read(stream, mgr);

    fBrain = plArmatureBrain::ConvertNoRef(mgr->ReadCreatable(stream));
    hsAssert(fBrain, "PLAVPUSHBRAINMSG: Problem reading brain from stream.");
}

// WRITE
void plAvPushBrainMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    plAvTaskMsg::Write(stream, mgr);
    mgr->WriteCreatable(stream, fBrain);
}



//////////////////
//
// PLAVPOPBRAINMSG
//
//////////////////

// default ctor
plAvPopBrainMsg::plAvPopBrainMsg()
{
}

// canonical ctor
plAvPopBrainMsg::plAvPopBrainMsg(const plKey &sender, const plKey &receiver)
: plAvTaskMsg(sender, receiver)
{
}

#endif // SERVER


/////////////////
////
//// PLAVEMOTEMSG
////
/////////////////
//
//// default ctor
//plAvEmoteMsg::plAvEmoteMsg()
//: fAnimName(nil)
//{
//}
//
//// canonical ctor
//plAvEmoteMsg::plAvEmoteMsg(plKey sender, plKey receiver, char *name)
//: plAvTaskMsg(sender, receiver)
//{
//  fAnimName = hsStrcpy(name);
//}
//
//// READ
//void plAvEmoteMsg::Read(hsStream *stream, hsResMgr *mgr)
//{
//  plAvTaskMsg::Read(stream, mgr);
//  fAnimName = stream->ReadSafeString();
//}
//
//// WRITE
//void plAvEmoteMsg::Write(hsStream *stream, hsResMgr *mgr)
//{
//  plAvTaskMsg::Write(stream, mgr);
//  stream->WriteSafeString(fAnimName);




///////////////////////////
//
// PLAVATARSTEALTHMODEMSG
//
///////////////////////////

plAvatarStealthModeMsg::plAvatarStealthModeMsg() : plAvatarMsg(), fMode(kStealthVisible), fLevel(0) 
{ 
    SetBCastFlag(plMessage::kBCastByExactType); 
}

plAvatarStealthModeMsg::~plAvatarStealthModeMsg() {}

// READ stream mgr
void plAvatarStealthModeMsg::Read(hsStream *stream, hsResMgr *mgr)
{
    hsAssert(false, "This message is not supposed to travel over the network or persist in a file.");
}

// WRITE stream mgr
void plAvatarStealthModeMsg::Write(hsStream *stream, hsResMgr *mgr)
{
    hsAssert(false, "This message is not supposed to travel over the network or persist in a file.");
}


#endif // ndef NO_AV_MSGS