mirror of
https://bitbucket.org/theswgsource/src-1.2.git
synced 2026-09-25 10:12:52 -04:00
564 lines
13 KiB
C++
564 lines
13 KiB
C++
// ScriptParamArchive.cpp
|
|
// Copyright 2000-02, Sony Online Entertainment Inc., all rights reserved.
|
|
// Author: Justin Randall
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
#include "serverScript/FirstServerScript.h"
|
|
#include "serverScript/ScriptParamArchive.h"
|
|
|
|
#include "Archive/Archive.h"
|
|
#include "UnicodeUtils.h"
|
|
#include "localizationArchive/StringIdArchive.h"
|
|
#include "serverScript/ScriptParameters.h"
|
|
#include "sharedFoundation/NetworkIdArchive.h"
|
|
#include "sharedGame/AttribMod.h"
|
|
#include "sharedGame/AttribModArchive.h"
|
|
#include "sharedMathArchive/VectorArchive.h"
|
|
#include "sharedNetworkMessages/ObjectMenuRequestData.h"
|
|
#include "sharedNetworkMessages/ObjectMenuRequestDataArchive.h"
|
|
#include "sharedObject/CachedNetworkIdArchive.h"
|
|
#include "sharedUtility/ValueDictionary.h"
|
|
#include "sharedUtility/ValueDictionaryArchive.h"
|
|
#include "unicodeArchive/UnicodeArchive.h"
|
|
#include <deque>
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
namespace Archive
|
|
{
|
|
|
|
void get(ReadIterator & source, std::vector<const std::vector<NetworkId> *> & target)
|
|
{
|
|
target.clear();
|
|
signed int length = 0;
|
|
get(source, length);
|
|
for (int i = 0; i < length; ++i)
|
|
{
|
|
std::vector<NetworkId> * inner = new std::vector<NetworkId>();
|
|
NOT_NULL(inner);
|
|
signed int innerLength = 0;
|
|
get(source, innerLength);
|
|
NetworkId id;
|
|
for (int j = 0; j < innerLength; ++j)
|
|
{
|
|
get(source, id);
|
|
inner->push_back(id);
|
|
}
|
|
target.push_back(inner);
|
|
}
|
|
}
|
|
|
|
void put(ByteStream & target, const std::vector<const std::vector<NetworkId> *> & source)
|
|
{
|
|
signed int length = source.size();
|
|
put(target, length);
|
|
for (int i = 0; i < length; ++i)
|
|
{
|
|
const std::vector<NetworkId> * inner = source[i];
|
|
signed int innerLength = 0;
|
|
if (inner != NULL)
|
|
innerLength = inner->size();
|
|
put(target, innerLength);
|
|
for (int j = 0; j < innerLength; ++j)
|
|
{
|
|
put(target, inner->at(j));
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void get(ReadIterator & source, Param & target)
|
|
{
|
|
Param * p = ⌖
|
|
p->m_owned = true;
|
|
int paramType;
|
|
get(source, paramType);
|
|
p->m_type = static_cast<Param::ParamType>(paramType);
|
|
get(source, p->m_name);
|
|
switch(paramType)
|
|
{
|
|
case Param::BOOL:
|
|
{
|
|
get(source, p->m_param.bParam);
|
|
}
|
|
break;
|
|
case Param::BOOL_ARRAY:
|
|
{
|
|
std::deque<bool> * b = new std::deque<bool>;
|
|
get(source, *b);
|
|
p->m_param.baParam = b;
|
|
}
|
|
break;
|
|
case Param::INT:
|
|
{
|
|
get(source, p->m_param.iParam);
|
|
}
|
|
break;
|
|
case Param::INT_ARRAY:
|
|
{
|
|
std::vector<int> * v = new std::vector<int>;
|
|
get(source, *v);
|
|
p->m_param.iaParam = v;
|
|
}
|
|
break;
|
|
case Param::FLOAT:
|
|
{
|
|
get(source, p->m_param.fParam);
|
|
}
|
|
break;
|
|
case Param::FLOAT_ARRAY:
|
|
{
|
|
std::vector<float> * v = new std::vector<float>;
|
|
get(source, *v);
|
|
p->m_param.faParam = v;
|
|
}
|
|
break;
|
|
case Param::STRING:
|
|
{
|
|
std::string s;
|
|
get(source, s);
|
|
char * str = new char[s.length() + 1];
|
|
strcpy(str, s.c_str());
|
|
p->m_param.sParam = str;
|
|
}
|
|
break;
|
|
case Param::STRING_ARRAY:
|
|
{
|
|
std::vector<std::string> v;
|
|
get(source, v);
|
|
std::vector<std::string>::const_iterator si;
|
|
std::vector<const char *> * s = new std::vector<const char *>;
|
|
for(si = v.begin(); si != v.end(); ++si)
|
|
{
|
|
char * str = new char[(*si).length() + 1];
|
|
strcpy(str, (*si).c_str());
|
|
s->push_back(str);
|
|
}
|
|
p->m_param.saParam = s;
|
|
}
|
|
break;
|
|
case Param::UNICODE:
|
|
{
|
|
Unicode::String * s = new Unicode::String;
|
|
get(source, *s);
|
|
p->m_param.uParam = s;
|
|
}
|
|
break;
|
|
case Param::UNICODE_ARRAY:
|
|
{
|
|
std::vector<const Unicode::String *> * s = new std::vector<const Unicode::String *>;
|
|
int count;
|
|
get(source, count);
|
|
int index;
|
|
for(index = 0; index < count; ++index)
|
|
{
|
|
Unicode::String tmp;
|
|
get(source, tmp);
|
|
Unicode::String * entry = new Unicode::String(tmp);
|
|
s->push_back(entry);
|
|
}
|
|
p->m_param.uaParam = s;
|
|
}
|
|
break;
|
|
case Param::OBJECT_ID:
|
|
{
|
|
NetworkId * id = new NetworkId;
|
|
get(source, *id);
|
|
p->m_param.oidParam = id;
|
|
}
|
|
break;
|
|
case Param::OBJECT_ID_ARRAY:
|
|
{
|
|
std::vector<NetworkId> * ids = new std::vector<NetworkId>;
|
|
get(source, *ids);
|
|
p->m_param.oidaParam = ids;
|
|
}
|
|
break;
|
|
case Param::CACHED_OBJECT_ID_ARRAY:
|
|
{
|
|
std::vector<CachedNetworkId> * ids = new std::vector<CachedNetworkId>;
|
|
get(source, *ids);
|
|
p->m_param.coidaParam = ids;
|
|
}
|
|
break;
|
|
case Param::OBJECT_ID_ARRAY_ARRAY:
|
|
{
|
|
std::vector<const std::vector<NetworkId> *> * ids = new std::vector<const std::vector<NetworkId> *>;
|
|
get(source, *ids);
|
|
p->m_param.oidaaParam = ids;
|
|
}
|
|
break;
|
|
case Param::STRING_ID:
|
|
{
|
|
StringId * s = new StringId;
|
|
get(source, *s);
|
|
p->m_param.sidParam = s;
|
|
}
|
|
break;
|
|
case Param::STRING_ID_ARRAY:
|
|
{
|
|
int count;
|
|
get(source, count);
|
|
std::vector<const StringId *> * s = new std::vector<const StringId *>;
|
|
int index;
|
|
for(index = 0; index < count; ++index)
|
|
{
|
|
StringId * id = new StringId;
|
|
get(source, *id);
|
|
s->push_back(id);
|
|
}
|
|
p->m_param.sidaParam = s;
|
|
}
|
|
break;
|
|
case Param::ATTRIB_MOD:
|
|
{
|
|
AttribMod::AttribMod * m = new AttribMod::AttribMod;
|
|
get(source, *m);
|
|
p->m_param.amParam = m;
|
|
}
|
|
break;
|
|
case Param::ATTRIB_MOD_ARRAY:
|
|
{
|
|
std::vector<AttribMod::AttribMod> * m = new std::vector<AttribMod::AttribMod>;
|
|
int count;
|
|
get(source, count);
|
|
int index;
|
|
for(index = 0; index < count; ++index)
|
|
{
|
|
AttribMod::AttribMod mod;
|
|
get(source, mod);
|
|
m->push_back(mod);
|
|
}
|
|
p->m_param.amaParam = m;
|
|
}
|
|
break;
|
|
case Param::MENTAL_STATE_MOD:
|
|
{
|
|
ServerObjectTemplate::MentalStateMod * m = new ServerObjectTemplate::MentalStateMod;
|
|
int t ;
|
|
get(source, t);
|
|
m->target = static_cast<ServerObjectTemplate::MentalStates>(t);
|
|
get(source, m->value);
|
|
get(source, m->timeAtValue);
|
|
get(source, m->decay);
|
|
p->m_param.msmParam = m;
|
|
}
|
|
break;
|
|
case Param::MENTAL_STATE_MOD_ARRAY:
|
|
{
|
|
std::vector<ServerObjectTemplate::MentalStateMod> * m = new std::vector<ServerObjectTemplate::MentalStateMod>;
|
|
int count;
|
|
get(source, count);
|
|
int index;
|
|
for(index = 0; index < count; ++index)
|
|
{
|
|
ServerObjectTemplate::MentalStateMod mod;
|
|
int t;
|
|
get(source, t);
|
|
mod.target = static_cast<ServerObjectTemplate::MentalStates>(t);
|
|
get(source, mod.value);
|
|
get(source, mod.timeAtValue);
|
|
get(source, mod.decay);
|
|
m->push_back(mod);
|
|
}
|
|
p->m_param.amsmParam = m;
|
|
}
|
|
break;
|
|
case Param::OBJECT_MENU_INFO:
|
|
{
|
|
MenuDataVector * v = new MenuDataVector;
|
|
get(source, *v);
|
|
p->m_param.aomrdParam = v;
|
|
}
|
|
break;
|
|
case Param::MANUFACTURE_SCHEMATIC:
|
|
{
|
|
DEBUG_FATAL(true, ("This NEVER is sent over the network! --sjakab\n"));
|
|
}
|
|
break;
|
|
case Param::INGREDIENT_SLOT:
|
|
{
|
|
DEBUG_FATAL(true, ("This NEVER is sent over the network! --sjakab\n"));
|
|
}
|
|
break;
|
|
case Param::LOCATION:
|
|
{
|
|
Vector * v = new Vector;
|
|
get(source, *v);
|
|
p->m_param.lParam = v;
|
|
}
|
|
break;
|
|
case Param::LOCATION_ARRAY:
|
|
{
|
|
std::vector<const Vector *> * v = new std::vector<const Vector *>;
|
|
get_ptr<Vector>(source, *v);
|
|
p->m_param.laParam = v;
|
|
}
|
|
break;
|
|
case Param::DICTIONARY:
|
|
{
|
|
ValueDictionary * dictionary = new ValueDictionary;
|
|
get(source, *dictionary);
|
|
p->m_param.valueDictionaryParam = dictionary;
|
|
}
|
|
break;
|
|
case Param::DICTIONARY_ARRAY:
|
|
{
|
|
int32 count;
|
|
get(source, count);
|
|
|
|
std::vector<ValueDictionary> * dictionaryArray = new std::vector<ValueDictionary>;
|
|
ValueDictionary dictionary;
|
|
|
|
int index;
|
|
for(index = 0; index < static_cast<int>(count); ++index)
|
|
{
|
|
get(source, dictionary);
|
|
dictionaryArray->push_back(dictionary);
|
|
}
|
|
|
|
p->m_param.valueDictionaryArrayParam = dictionaryArray;
|
|
}
|
|
break;
|
|
case Param::BYTE_ARRAY:
|
|
{
|
|
std::vector<unsigned char> * v = new std::vector<unsigned char>;
|
|
get(source, *v);
|
|
p->m_param.byteArrayParam = v;
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
DEBUG_FATAL(true, ("Unknown or unhandled ScriptParam type!!!!\n"));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void put(ByteStream & target, const Param & source)
|
|
{
|
|
Archive::put(target, source.m_type);
|
|
Archive::put(target, source.m_name);
|
|
switch(source.m_type)
|
|
{
|
|
case Param::BOOL:
|
|
{
|
|
Archive::put(target, source.m_param.bParam);
|
|
}
|
|
break;
|
|
case Param::BOOL_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.baParam);
|
|
}
|
|
break;
|
|
case Param::INT:
|
|
{
|
|
Archive::put(target, source.m_param.iParam);
|
|
}
|
|
break;
|
|
case Param::INT_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.iaParam);
|
|
}
|
|
break;
|
|
case Param::FLOAT:
|
|
{
|
|
Archive::put(target, source.m_param.fParam);
|
|
}
|
|
break;
|
|
case Param::FLOAT_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.faParam);
|
|
}
|
|
break;
|
|
case Param::STRING:
|
|
{
|
|
std::string s = source.m_param.sParam;
|
|
Archive::put(target, s);
|
|
}
|
|
break;
|
|
case Param::STRING_ARRAY:
|
|
{
|
|
std::vector<std::string> s;
|
|
std::vector<const char *>::const_iterator c;
|
|
for(c = source.m_param.saParam->begin(); c != source.m_param.saParam->end(); ++c)
|
|
{
|
|
if (*c)
|
|
{
|
|
s.push_back(std::string(*c));
|
|
}
|
|
else
|
|
{
|
|
s.push_back(std::string(""));
|
|
}
|
|
}
|
|
Archive::put(target, s);
|
|
}
|
|
break;
|
|
case Param::UNICODE:
|
|
{
|
|
Archive::put(target, *source.m_param.uParam);
|
|
}
|
|
break;
|
|
case Param::UNICODE_ARRAY:
|
|
{
|
|
std::vector<const Unicode::String *>::const_iterator ui;
|
|
int count = source.m_param.uaParam->size();
|
|
Archive::put(target, count);
|
|
for(ui = source.m_param.uaParam->begin(); ui != source.m_param.uaParam->end(); ++ui)
|
|
{
|
|
if ((*ui))
|
|
{
|
|
Archive::put(target, *(*ui));
|
|
}
|
|
else
|
|
{
|
|
static const Unicode::String emptyStr =
|
|
Unicode::narrowToWide("");
|
|
Archive::put(target, emptyStr);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case Param::OBJECT_ID:
|
|
{
|
|
Archive::put(target, *source.m_param.oidParam);
|
|
}
|
|
break;
|
|
case Param::OBJECT_ID_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.oidaParam);
|
|
}
|
|
break;
|
|
case Param::CACHED_OBJECT_ID_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.coidaParam);
|
|
}
|
|
break;
|
|
case Param::OBJECT_ID_ARRAY_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.oidaaParam);
|
|
}
|
|
break;
|
|
case Param::STRING_ID:
|
|
{
|
|
Archive::put(target, *source.m_param.sidParam);
|
|
}
|
|
break;
|
|
case Param::STRING_ID_ARRAY:
|
|
{
|
|
int count = source.m_param.sidaParam->size();
|
|
Archive::put(target, count);
|
|
std::vector<const StringId *>::const_iterator si;
|
|
for(si = source.m_param.sidaParam->begin(); si != source.m_param.sidaParam->end(); ++si)
|
|
{
|
|
Archive::put(target, *(*si));
|
|
}
|
|
}
|
|
break;
|
|
case Param::ATTRIB_MOD:
|
|
{
|
|
const AttribMod::AttribMod * m = source.m_param.amParam;
|
|
Archive::put(target, *m);
|
|
}
|
|
break;
|
|
case Param::ATTRIB_MOD_ARRAY:
|
|
{
|
|
std::vector<AttribMod::AttribMod>::const_iterator mi;
|
|
int count = source.m_param.amaParam->size();
|
|
Archive::put(target, count);
|
|
for (mi = source.m_param.amaParam->begin(); mi != source.m_param.amaParam->end(); ++mi)
|
|
{
|
|
Archive::put(target, *mi);
|
|
}
|
|
}
|
|
break;
|
|
case Param::MENTAL_STATE_MOD:
|
|
{
|
|
const ServerObjectTemplate::MentalStateMod * m = source.m_param.msmParam;
|
|
int t = m->target;
|
|
Archive::put(target, t);
|
|
Archive::put(target, m->value);
|
|
Archive::put(target, m->timeAtValue);
|
|
Archive::put(target, m->decay);
|
|
}
|
|
break;
|
|
case Param::MENTAL_STATE_MOD_ARRAY:
|
|
{
|
|
std::vector<ServerObjectTemplate::MentalStateMod>::const_iterator mi;
|
|
int count = source.m_param.amsmParam->size();
|
|
Archive::put(target, count);
|
|
for(mi = source.m_param.amsmParam->begin(); mi != source.m_param.amsmParam->end(); ++mi)
|
|
{
|
|
int t = (*mi).target;
|
|
Archive::put(target, t);
|
|
Archive::put(target, (*mi).value);
|
|
Archive::put(target, (*mi).timeAtValue);
|
|
Archive::put(target, (*mi).decay);
|
|
}
|
|
}
|
|
break;
|
|
case Param::OBJECT_MENU_INFO:
|
|
{
|
|
Archive::put(target, *source.m_param.aomrdParam);
|
|
}
|
|
break;
|
|
case Param::MANUFACTURE_SCHEMATIC:
|
|
{
|
|
DEBUG_FATAL(true, ("This NEVER is sent over the network! --sjakab\n"));
|
|
}
|
|
break;
|
|
case Param::INGREDIENT_SLOT:
|
|
{
|
|
DEBUG_FATAL(true, ("This NEVER is sent over the network! --sjakab\n"));
|
|
}
|
|
break;
|
|
case Param::LOCATION:
|
|
{
|
|
Archive::put(target, *source.m_param.lParam);
|
|
}
|
|
break;
|
|
case Param::LOCATION_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.laParam);
|
|
}
|
|
break;
|
|
case Param::DICTIONARY:
|
|
{
|
|
Archive::put(target, *source.m_param.valueDictionaryParam);
|
|
}
|
|
break;
|
|
case Param::DICTIONARY_ARRAY:
|
|
{
|
|
int32 count = static_cast<int32>(source.m_param.valueDictionaryArrayParam->size());
|
|
Archive::put(target, count);
|
|
std::vector<ValueDictionary>::const_iterator iter;
|
|
for(iter = source.m_param.valueDictionaryArrayParam->begin(); iter != source.m_param.valueDictionaryArrayParam->end(); ++iter)
|
|
{
|
|
Archive::put(target, (*iter));
|
|
}
|
|
}
|
|
break;
|
|
case Param::BYTE_ARRAY:
|
|
{
|
|
Archive::put(target, *source.m_param.byteArrayParam);
|
|
}
|
|
break;
|
|
default:
|
|
DEBUG_FATAL(true, ("Unknown or unhandled ScriptParam type!!!!\n"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
}//namespace Archive
|
|
|
|
//-----------------------------------------------------------------------
|
|
|