mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
496 lines
16 KiB
C++
496 lines
16 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
|
|
// Copyright (C) 2015 Faust Logic, Inc.
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
#include "platform/platform.h"
|
|
#include "console/simDatablock.h"
|
|
|
|
#include "console/console.h"
|
|
#include "console/consoleInternal.h"
|
|
#include "console/engineAPI.h"
|
|
#include "T3D/gameBase/gameConnectionEvents.h"
|
|
#include "T3D/gameBase/gameConnection.h"
|
|
|
|
#include "core/stream/bitStream.h"
|
|
#include "console/compiler.h"
|
|
|
|
IMPLEMENT_CO_DATABLOCK_V1(SimDataBlock);
|
|
SimObjectId SimDataBlock::sNextObjectId = DataBlockObjectIdFirst;
|
|
S32 SimDataBlock::sNextModifiedKey = 0;
|
|
|
|
ConsoleDocClass( SimDataBlock,
|
|
"@brief \n"
|
|
"@ingroup \n"
|
|
|
|
"@section Datablock_Networking Datablocks and Networking\n"
|
|
|
|
"@section Datablock_ClientSide Client-Side Datablocks\n"
|
|
);
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SimDataBlock::SimDataBlock()
|
|
{
|
|
setModDynamicFields(true);
|
|
setModStaticFields(true);
|
|
}
|
|
// this implements a simple structure for managing substitution statements.
|
|
|
|
SimDataBlock::SubstitutionStatement::SubstitutionStatement(StringTableEntry slot, S32 idx, const char* value)
|
|
{
|
|
this->slot = slot;
|
|
this->idx = idx;
|
|
this->value = dStrdup(value);
|
|
}
|
|
|
|
SimDataBlock::SubstitutionStatement::~SubstitutionStatement()
|
|
{
|
|
dFree(value);
|
|
}
|
|
|
|
void SimDataBlock::SubstitutionStatement::replaceValue(const char* value)
|
|
{
|
|
dFree(this->value);
|
|
this->value = dStrdup(value);
|
|
}
|
|
|
|
// this is the copy-constructor for creating temp-clones.
|
|
SimDataBlock::SimDataBlock(const SimDataBlock& other, bool temp_clone) : SimObject(other, temp_clone)
|
|
{
|
|
modifiedKey = other.modifiedKey;
|
|
}
|
|
|
|
// a destructor is added to SimDataBlock so that we can delete any substitutions.
|
|
SimDataBlock::~SimDataBlock()
|
|
{
|
|
clear_substitutions();
|
|
}
|
|
|
|
void SimDataBlock::clear_substitutions()
|
|
{
|
|
for (S32 i = 0; i < substitutions.size(); i++)
|
|
delete substitutions[i];
|
|
substitutions.clear();
|
|
}
|
|
|
|
void SimDataBlock::addSubstitution(StringTableEntry slot, S32 idx, const char* subst)
|
|
{
|
|
AssertFatal(subst != 0 && subst[0] == '$' && subst[1] == '$', "Bad substition statement string added");
|
|
|
|
subst += 2;
|
|
while (dIsspace(*subst))
|
|
subst++;
|
|
|
|
bool empty_subs = (*subst == '\0');
|
|
|
|
for (S32 i = 0; i < substitutions.size(); i++)
|
|
{
|
|
if (substitutions[i] && substitutions[i]->slot == slot && substitutions[i]->idx == idx)
|
|
{
|
|
if (empty_subs)
|
|
{
|
|
delete substitutions[i];
|
|
substitutions[i] = 0;
|
|
onRemoveSubstitution(slot, idx);
|
|
}
|
|
else
|
|
{
|
|
substitutions[i]->replaceValue(subst);
|
|
onAddSubstitution(slot, idx, subst);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!empty_subs)
|
|
{
|
|
substitutions.push_back(new SubstitutionStatement(slot, idx, subst));
|
|
onAddSubstitution(slot, idx, subst);
|
|
}
|
|
}
|
|
|
|
const char* SimDataBlock::getSubstitution(StringTableEntry slot, S32 idx)
|
|
{
|
|
for (S32 i = 0; i < substitutions.size(); i++)
|
|
{
|
|
if (substitutions[i] && substitutions[i]->slot == slot && substitutions[i]->idx == idx)
|
|
return substitutions[i]->value;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool SimDataBlock::fieldHasSubstitution(StringTableEntry slot)
|
|
{
|
|
for (S32 i = 0; i < substitutions.size(); i++)
|
|
if (substitutions[i] && substitutions[i]->slot == slot)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void SimDataBlock::printSubstitutions()
|
|
{
|
|
for (S32 i = 0; i < substitutions.size(); i++)
|
|
if (substitutions[i])
|
|
Con::errorf("SubstitutionStatement[%s] = \"%s\" -- %d", substitutions[i]->slot, substitutions[i]->value, i);
|
|
}
|
|
|
|
void SimDataBlock::copySubstitutionsFrom(SimDataBlock* other)
|
|
{
|
|
clear_substitutions();
|
|
if (!other)
|
|
return;
|
|
|
|
for (S32 i = 0; i < other->substitutions.size(); i++)
|
|
{
|
|
if (other->substitutions[i])
|
|
{
|
|
SubstitutionStatement* subs = other->substitutions[i];
|
|
substitutions.push_back(new SubstitutionStatement(subs->slot, subs->idx, subs->value));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// This is the method that evaluates any substitution statements on a datablock and does the
|
|
// actual replacement of substituted datablock fields.
|
|
//
|
|
// Much of the work is done by passing the statement to Con::evaluate() but first there are
|
|
// some key operations performed on the statement.
|
|
// -- Instances of "%%" in the statement are replaced with the id of the <obj> object.
|
|
// -- Instances of "##" are replaced with the value of <index>.
|
|
//
|
|
// There are also some return values that get special treatment.
|
|
// -- An empty result will produce a realtime error message.
|
|
// -- A result of "~~" will leave the original field value unchanged.
|
|
// -- A result of "~0" will clear the original field to "" without producing an error message.
|
|
//
|
|
void SimDataBlock::performSubstitutions(SimDataBlock* dblock, const SimObject* obj, S32 index)
|
|
{
|
|
if (!dblock || !dblock->getClassRep())
|
|
{
|
|
// error message
|
|
return;
|
|
}
|
|
|
|
char obj_str[32];
|
|
dStrcpy(obj_str, Con::getIntArg(obj->getId()), 32);
|
|
|
|
char index_str[32];
|
|
dStrcpy(index_str, Con::getIntArg(index), 32);
|
|
|
|
for (S32 i = 0; i < substitutions.size(); i++)
|
|
{
|
|
if (substitutions[i])
|
|
{
|
|
static char buffer[1024];
|
|
static char* b_oob = &buffer[1024];
|
|
char* b = buffer;
|
|
|
|
// perform special token expansion (%% and ##)
|
|
const char* v = substitutions[i]->value;
|
|
while (*v != '\0')
|
|
{
|
|
// identify "%%" tokens and replace with <obj> id
|
|
if (v[0] == '%' && v[1] == '%')
|
|
{
|
|
const char* s = obj_str;
|
|
while (*s != '\0')
|
|
{
|
|
b[0] = s[0];
|
|
b++;
|
|
s++;
|
|
}
|
|
v += 2;
|
|
}
|
|
// identify "##" tokens and replace with <index> value
|
|
else if (v[0] == '#' && v[1] == '#')
|
|
{
|
|
const char* s = index_str;
|
|
while (*s != '\0')
|
|
{
|
|
b[0] = s[0];
|
|
b++;
|
|
s++;
|
|
}
|
|
v += 2;
|
|
}
|
|
else
|
|
{
|
|
b[0] = v[0];
|
|
b++;
|
|
v++;
|
|
}
|
|
}
|
|
|
|
AssertFatal((uintptr_t)b < (uintptr_t)b_oob, "Substitution buffer overflowed");
|
|
|
|
b[0] = '\0';
|
|
|
|
// perform the statement evaluation
|
|
Compiler::gSyntaxError = false;
|
|
//Con::errorf("EVAL [%s]", avar("return %s;", buffer));
|
|
const char *result = Con::evaluate(avar("return %s;", buffer), false, 0);
|
|
if (Compiler::gSyntaxError)
|
|
{
|
|
Con::errorf("Field Substitution Failed: field=\"%s\" substitution=\"%s\" -- syntax error",
|
|
substitutions[i]->slot, substitutions[i]->value);
|
|
Compiler::gSyntaxError = false;
|
|
return;
|
|
}
|
|
|
|
// output a runtime console error when a substitution produces and empty result.
|
|
if (result == 0 || result[0] == '\0')
|
|
{
|
|
Con::errorf("Field Substitution Failed: field=\"%s\" substitution=\"%s\" -- empty result",
|
|
substitutions[i]->slot, substitutions[i]->value);
|
|
return;
|
|
}
|
|
|
|
// handle special return values
|
|
if (result[0] == '~')
|
|
{
|
|
// if value is "~~" then keep the existing value
|
|
if (result[1] == '~' && result[2] == '\0')
|
|
continue;
|
|
// if "~0" then clear it
|
|
if (result[1] == '0' && result[2] == '\0')
|
|
result = "";
|
|
}
|
|
|
|
const AbstractClassRep::Field* field = dblock->getClassRep()->findField(substitutions[i]->slot);
|
|
if (!field)
|
|
{
|
|
// this should be very unlikely...
|
|
Con::errorf("Field Substitution Failed: unknown field, \"%s\".", substitutions[i]->slot);
|
|
continue;
|
|
}
|
|
|
|
if (field->keepClearSubsOnly && result[0] != '\0')
|
|
{
|
|
Con::errorf("Field Substitution Failed: field \"%s\" of datablock %s only allows \"$$ ~~\" (keep) and \"$$ ~0\" (clear) field substitutions. [%s]",
|
|
substitutions[i]->slot, this->getClassName(), this->getName());
|
|
continue;
|
|
}
|
|
|
|
// substitute the field value with its replacement
|
|
Con::setData(field->type, (void*)(((const char*)(dblock)) + field->offset), substitutions[i]->idx, 1, &result, field->table, field->flag);
|
|
|
|
//dStrncpy(buffer, result, 255);
|
|
//Con::errorf("SUBSTITUTION %s.%s[%d] = %s idx=%s", Con::getIntArg(getId()), substitutions[i]->slot, substitutions[i]->idx, buffer, index_str);
|
|
|
|
// notify subclasses of a field modification
|
|
dblock->onStaticModified(substitutions[i]->slot);
|
|
}
|
|
}
|
|
|
|
// notify subclasses of substitution operation
|
|
if (substitutions.size() > 0)
|
|
dblock->onPerformSubstitutions();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool SimDataBlock::onAdd()
|
|
{
|
|
Parent::onAdd();
|
|
|
|
// This initialization is done here, and not in the constructor,
|
|
// because some jokers like to construct and destruct objects
|
|
// (without adding them to the manager) to check what class
|
|
// they are.
|
|
modifiedKey = ++sNextModifiedKey;
|
|
AssertFatal(sNextObjectId <= DataBlockObjectIdLast,
|
|
"Exceeded maximum number of data blocks");
|
|
|
|
// add DataBlock to the DataBlockGroup unless it is client side ONLY DataBlock
|
|
if ( !isClientOnly() )
|
|
if (SimGroup* grp = Sim::getDataBlockGroup())
|
|
grp->addObject(this);
|
|
|
|
Sim::getDataBlockSet()->addObject( this );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SimDataBlock::assignId()
|
|
{
|
|
// We don't want the id assigned by the manager, but it may have
|
|
// already been assigned a correct data block id.
|
|
if ( isClientOnly() )
|
|
setId(sNextObjectId++);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SimDataBlock::onStaticModified(const char* slotName, const char* newValue)
|
|
{
|
|
modifiedKey = sNextModifiedKey++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// packData() and unpackData() do nothing in the stock implementation, but here
|
|
// they've been modified to pack and unpack any substitution statements.
|
|
//
|
|
void SimDataBlock::packData(BitStream* stream)
|
|
{
|
|
for (S32 i = 0; i < substitutions.size(); i++)
|
|
{
|
|
if (substitutions[i])
|
|
{
|
|
stream->writeFlag(true);
|
|
stream->writeString(substitutions[i]->slot);
|
|
stream->write(substitutions[i]->idx);
|
|
stream->writeString(substitutions[i]->value);
|
|
}
|
|
}
|
|
stream->writeFlag(false);
|
|
}
|
|
|
|
void SimDataBlock::unpackData(BitStream* stream)
|
|
{
|
|
clear_substitutions();
|
|
while(stream->readFlag())
|
|
{
|
|
char slotName[256];
|
|
S32 idx;
|
|
char value[256];
|
|
stream->readString(slotName);
|
|
stream->read(&idx);
|
|
stream->readString(value);
|
|
substitutions.push_back(new SubstitutionStatement(StringTable->insert(slotName), idx, value));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool SimDataBlock::preload(bool, String&)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SimDataBlock::write(Stream &stream, U32 tabStop, U32 flags)
|
|
{
|
|
// Only output selected objects if they want that.
|
|
if((flags & SelectedOnly) && !isSelected())
|
|
return;
|
|
|
|
stream.writeTabs(tabStop);
|
|
char buffer[1024];
|
|
|
|
// Client side datablocks are created with 'new' while
|
|
// regular server datablocks use the 'datablock' keyword.
|
|
if ( isClientOnly() )
|
|
dSprintf(buffer, sizeof(buffer), "new %s(%s) {\r\n", getClassName(), getName() ? getName() : "");
|
|
else
|
|
dSprintf(buffer, sizeof(buffer), "datablock %s(%s) {\r\n", getClassName(), getName() ? getName() : "");
|
|
|
|
stream.write(dStrlen(buffer), buffer);
|
|
writeFields(stream, tabStop + 1);
|
|
|
|
stream.writeTabs(tabStop);
|
|
stream.write(4, "};\r\n");
|
|
}
|
|
|
|
//=============================================================================
|
|
// API.
|
|
//=============================================================================
|
|
// MARK: ---- API ----
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DefineEngineMethod( SimDataBlock, reloadOnLocalClient, void, (),,
|
|
"Reload the datablock. This can only be used with a local client configuration." )
|
|
{
|
|
// Make sure we're running a local client.
|
|
|
|
GameConnection* localClient = GameConnection::getLocalClientConnection();
|
|
if( !localClient )
|
|
return;
|
|
|
|
// Do an in-place pack/unpack/preload.
|
|
|
|
if( !object->preload( true, NetConnection::getErrorBuffer() ) )
|
|
{
|
|
Con::errorf( NetConnection::getErrorBuffer() );
|
|
return;
|
|
}
|
|
|
|
U8 buffer[ 16384 ];
|
|
BitStream stream( buffer, 16384 );
|
|
|
|
object->packData( &stream );
|
|
stream.setPosition(0);
|
|
object->unpackData( &stream );
|
|
|
|
if( !object->preload( false, NetConnection::getErrorBuffer() ) )
|
|
{
|
|
Con::errorf( NetConnection::getErrorBuffer() );
|
|
return;
|
|
}
|
|
|
|
// Trigger a post-apply so that change notifications respond.
|
|
object->inspectPostApply();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DefineEngineFunction( preloadClientDataBlocks, void, (),,
|
|
"Preload all datablocks in client mode.\n\n"
|
|
"(Server parameter is set to false). This will take some time to complete.")
|
|
{
|
|
// we go from last to first because we cut 'n pasted the loop from deleteDataBlocks
|
|
SimGroup *grp = Sim::getDataBlockGroup();
|
|
String errorStr;
|
|
for(S32 i = grp->size() - 1; i >= 0; i--)
|
|
{
|
|
AssertFatal(dynamic_cast<SimDataBlock*>((*grp)[i]), "Doh! non-datablock in datablock group!");
|
|
SimDataBlock *obj = (SimDataBlock*)(*grp)[i];
|
|
if (!obj->preload(false, errorStr))
|
|
Con::errorf("Failed to preload client datablock, %s: %s", obj->getName(), errorStr.c_str());
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DefineEngineFunction( deleteDataBlocks, void, (),,
|
|
"Delete all the datablocks we've downloaded.\n\n"
|
|
"This is usually done in preparation of downloading a new set of datablocks, "
|
|
"such as occurs on a mission change, but it's also good post-mission cleanup." )
|
|
{
|
|
// delete from last to first:
|
|
SimGroup *grp = Sim::getDataBlockGroup();
|
|
grp->deleteAllObjects();
|
|
SimDataBlock::sNextObjectId = DataBlockObjectIdFirst;
|
|
SimDataBlock::sNextModifiedKey = 0;
|
|
}
|