You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

408 lines
10 KiB

/*==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 "hsStream.h"
#include "plLinkToAgeMsg.h"
#include "hsResMgr.h"
#include "hsUtils.h"
#include "plgDispatch.h"
#include "../plNetCommon/plNetServerSessionInfo.h"
#include "../plNetCommon/plNetCommon.h"
#include "hsBitVector.h"
/////////////////////////////////////////////////////////////////////////
//
// plLinkToAgeMsg
plLinkToAgeMsg::plLinkToAgeMsg() : fLinkInAnimName(nil)
{
}
plLinkToAgeMsg::plLinkToAgeMsg( const plAgeLinkStruct * link ) : fLinkInAnimName(nil)
{
fAgeLink.CopyFrom( link );
}
plLinkToAgeMsg::~plLinkToAgeMsg()
{
delete [] fLinkInAnimName;
}
// StreamVersion needed for back compatibility.
UInt8 plLinkToAgeInfo_StreamVersion = 0;
void plLinkToAgeMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead( stream, mgr );
UInt8 ltaVer = stream->ReadByte();
fAgeLink.Read( stream, mgr );
fLinkInAnimName = stream->ReadSafeString();
}
void plLinkToAgeMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite( stream, mgr );
stream->WriteByte( plLinkToAgeInfo_StreamVersion );
fAgeLink.Write( stream, mgr );
stream->WriteSafeString(fLinkInAnimName);
}
enum LinkToAgeFlags
{
kLinkToAgeAgeLinkStruct,
kLinkToAgeLinkAnimName,
};
void plLinkToAgeMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgReadVersion(s, mgr);
hsBitVector contentFlags;
contentFlags.Read(s);
if ( contentFlags.IsBitSet( kLinkToAgeAgeLinkStruct ) )
fAgeLink.Read( s, mgr );
if ( contentFlags.IsBitSet( kLinkToAgeLinkAnimName ) )
fLinkInAnimName = s->ReadSafeString();
}
void plLinkToAgeMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgWriteVersion(s, mgr);
hsBitVector contentFlags;
contentFlags.SetBit(kLinkToAgeAgeLinkStruct);
contentFlags.SetBit(kLinkToAgeLinkAnimName);
contentFlags.Write(s);
// write kLinkToAgeAgeLinkStruct
fAgeLink.Write( s, mgr );
s->WriteSafeString(fLinkInAnimName);
}
/////////////////////////////////////////////////////////////////////////////
//
// plLinkingMgrMsg
plLinkingMgrMsg::plLinkingMgrMsg()
: fLinkingMgrCmd( 0 /*plNetLinkingMgr::kNilCmd*/ )
{
}
plLinkingMgrMsg::~plLinkingMgrMsg()
{
}
enum LinkingMgrMsgFlags
{
kLinkingMgrCmd,
kLinkingMgrArgs,
};
void plLinkingMgrMsg::Read( hsStream* stream, hsResMgr* mgr )
{
plMessage::IMsgRead( stream, mgr );
hsBitVector contentFlags;
contentFlags.Read( stream );
if ( contentFlags.IsBitSet( kLinkingMgrCmd ) )
stream->ReadSwap( &fLinkingMgrCmd );
if ( contentFlags.IsBitSet( kLinkingMgrArgs ) )
fArgs.Read( stream, mgr );
}
void plLinkingMgrMsg::Write( hsStream* stream, hsResMgr* mgr )
{
plMessage::IMsgWrite( stream, mgr );
hsBitVector contentFlags;
contentFlags.SetBit( kLinkingMgrCmd );
contentFlags.SetBit( kLinkingMgrArgs );
contentFlags.Write( stream );
stream->WriteSwap( fLinkingMgrCmd );
fArgs.Write( stream, mgr );
}
void plLinkingMgrMsg::ReadVersion( hsStream* s, hsResMgr* mgr )
{
// Read() does the contentFlags thing.
Read( s, mgr );
}
void plLinkingMgrMsg::WriteVersion( hsStream* s, hsResMgr* mgr )
{
// Write() does the contentFlags thing.
Write( s, mgr );
}
/////////////////////////////////////////////////////////////////////////////
//
// plLinkEffectsTriggerMsg
plLinkEffectsTriggerMsg::~plLinkEffectsTriggerMsg()
{
}
void plLinkEffectsTriggerMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead( stream, mgr );
fInvisLevel = stream->ReadSwap32();
fLeavingAge = stream->ReadBool();
fLinkKey = mgr->ReadKey(stream);
// This variable is for internal use only. Still read/written for backwards compatability.
fEffects = stream->ReadSwap32();
fEffects = 0;
fLinkInAnimKey = mgr->ReadKey(stream);
}
void plLinkEffectsTriggerMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite( stream, mgr );
stream->WriteSwap32(fInvisLevel);
stream->WriteBool(fLeavingAge);
mgr->WriteKey(stream, fLinkKey);
stream->WriteSwap32(fEffects);
mgr->WriteKey(stream, fLinkInAnimKey);
}
enum LinkEffectsFlags
{
kLinkEffectsLeavingAge,
kLinkEffectsLinkKey,
kLinkEffectsEffects,
kLinkEffectsLinkInAnimKey,
};
#include "../pnNetCommon/plNetApp.h"
void plLinkEffectsTriggerMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgReadVersion(s, mgr);
hsBitVector contentFlags;
contentFlags.Read(s);
if (contentFlags.IsBitSet(kLinkEffectsLeavingAge))
fLeavingAge = s->ReadBool();
if (contentFlags.IsBitSet(kLinkEffectsLinkKey))
fLinkKey = mgr->ReadKey(s);
if (contentFlags.IsBitSet(kLinkEffectsEffects))
fEffects = s->ReadSwap32();
if (contentFlags.IsBitSet(kLinkEffectsLinkInAnimKey))
fLinkInAnimKey = mgr->ReadKey(s);
if (plNetClientApp::GetInstance() && fLinkKey == plNetClientApp::GetInstance()->GetLocalPlayerKey())
{
SetBCastFlag(plMessage::kNetStartCascade, true);
SetBCastFlag(plMessage::kNetNonLocal | plMessage::kNetPropagate, false);
}
}
void plLinkEffectsTriggerMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgWriteVersion(s, mgr);
hsBitVector contentFlags;
contentFlags.SetBit(kLinkEffectsLeavingAge);
contentFlags.SetBit(kLinkEffectsLinkKey);
contentFlags.SetBit(kLinkEffectsEffects);
contentFlags.SetBit(kLinkEffectsLinkInAnimKey);
contentFlags.Write(s);
// kLinkEffectsLeavingAge
s->WriteBool(fLeavingAge);
// kLinkEffectsLinkKey
mgr->WriteKey(s, fLinkKey);
// kLinkEffectsEffects
s->WriteSwap32(fEffects);
// kLinkEffectsLinkInAnimKey
mgr->WriteKey(s, fLinkInAnimKey);
}
void plLinkEffectsTriggerMsg::SetLinkKey(plKey &key)
{
fLinkKey = key;
}
void plLinkEffectsTriggerMsg::SetLinkInAnimKey(plKey &key)
{
fLinkInAnimKey = key;
}
/////////////////////////////////////////////////////////////////////////////
//
// plLinkEffectsPrepMsg
plLinkEffectsTriggerPrepMsg::~plLinkEffectsTriggerPrepMsg()
{
if (fTrigger)
hsRefCnt_SafeUnRef(fTrigger);
}
void plLinkEffectsTriggerPrepMsg::SetTrigger(plLinkEffectsTriggerMsg *msg)
{
if (fTrigger)
hsRefCnt_SafeUnRef(fTrigger);
hsRefCnt_SafeRef(msg);
fTrigger = msg;
}
/////////////////////////////////////////////////////////////////////////////
//
// plLinkEffectBCMsg
plLinkEffectBCMsg::plLinkEffectBCMsg() : fLinkKey(nil), fLinkFlags(0) { SetBCastFlag(plMessage::kBCastByExactType); }
void plLinkEffectBCMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fLinkKey = mgr->ReadKey(stream);
fLinkFlags = stream->ReadSwap32();
}
void plLinkEffectBCMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
mgr->WriteKey(stream, fLinkKey);
stream->WriteSwap32(fLinkFlags);
}
void plLinkEffectBCMsg::SetLinkFlag(UInt32 flag, hsBool on /* = true */)
{
if (on)
fLinkFlags |= flag;
else
fLinkFlags &= ~flag;
}
hsBool plLinkEffectBCMsg::HasLinkFlag(UInt32 flag)
{
return fLinkFlags & flag;
}
/////////////////////////////////////////////////////////////////////////////
//
// plLinkEffectPrepBCMsg
plLinkEffectPrepBCMsg::plLinkEffectPrepBCMsg() : fLinkKey(nil), fLeavingAge(false) { SetBCastFlag(plMessage::kBCastByExactType); }
/////////////////////////////////////////////////////////////////////////////
//
// plLinkCallbacks
void plLinkCallbackMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plEventCallbackMsg::Read(stream, mgr);
fLinkKey = mgr->ReadKey(stream);
}
void plLinkCallbackMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plEventCallbackMsg::Write(stream, mgr);
mgr->WriteKey(stream, fLinkKey);
}
/////////////////////////////////////////////////////////////////////////////////////
////
//// plPseudoLinkEffectMsg
plPseudoLinkEffectMsg::plPseudoLinkEffectMsg() : fLinkObjKey(nil), fAvatarKey(nil)
{
SetBCastFlag(plMessage::kNetPropagate | plMessage::kBCastByExactType);
}
void plPseudoLinkEffectMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fLinkObjKey = mgr->ReadKey(stream);
fAvatarKey = mgr->ReadKey(stream);
}
void plPseudoLinkEffectMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
mgr->WriteKey(stream, fLinkObjKey);
mgr->WriteKey(stream, fAvatarKey);
}
/////////////////////////////////////////////////////////////////////////////////////
////
//// plPseudoLinkAnimTriggerMsg
plPseudoLinkAnimTriggerMsg::plPseudoLinkAnimTriggerMsg() : fForward(false)
{
SetBCastFlag(plMessage::kBCastByExactType);
}
plPseudoLinkAnimTriggerMsg::plPseudoLinkAnimTriggerMsg(hsBool forward, plKey avatarKey)
{
fForward = forward;
fAvatarKey = avatarKey;
SetBCastFlag(plMessage::kBCastByExactType);
}
void plPseudoLinkAnimTriggerMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream,mgr);
fForward = stream->ReadBool();
fAvatarKey = mgr->ReadKey(stream);
}
void plPseudoLinkAnimTriggerMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream,mgr);
stream->WriteBool(fForward);
mgr->WriteKey(stream, fAvatarKey);
}
/////////////////////////////////////////////////////////////////////////////////////
////
//// plPseudoLinkAnimCallbackMsg
void plPseudoLinkAnimCallbackMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream,mgr);
mgr->WriteKey(stream, fAvatarKey);
}
void plPseudoLinkAnimCallbackMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream,mgr);
mgr->WriteKey(stream, fAvatarKey);
}