GlobalScripts::GlobalScripts (const ESMS::ESMStore& store, ScriptManager& scriptManager)
: mStore (store), mScriptManager (scriptManager)
{
addScript ("Main");
for (ESMS::RecListT<ESM::StartScript>::MapType::const_iterator iter
(store.startScripts.list.begin());
iter != store.startScripts.list.end(); ++iter)
addScript (iter->second.script);
}
void GlobalScripts::addStartup()
{
addScript ("main");
for (MWWorld::Store<ESM::StartScript>::iterator iter =
mStore.get<ESM::StartScript>().begin();
iter != mStore.get<ESM::StartScript>().end(); ++iter)
{
addScript (iter->mScript);
}
}
void GlobalScripts::addStartup()
{
// make list of global scripts to be added
std::vector<std::string> scripts;
scripts.push_back ("main");
for (MWWorld::Store<ESM::StartScript>::iterator iter =
mStore.get<ESM::StartScript>().begin();
iter != mStore.get<ESM::StartScript>().end(); ++iter)
{
scripts.push_back (iter->mId);
}
// add scripts
for (std::vector<std::string>::const_iterator iter (scripts.begin());
iter!=scripts.end(); ++iter)
{
try
{
addScript (*iter);
}
catch (const std::exception& exception)
{
std::cerr
<< "Failed to add start script " << *iter << " because an exception has "
<< "been thrown: " << exception.what() << std::endl;
}
}
}
void
Namespace::stubPrototype(ClassHierarchy& ch, string_table::key name)
{
abc::Class *pClass = ch.newClass();
pClass->setName(name);
addScript(name, pClass);
}
void PluginManager::preparePlugins() {
// Ordered by load priority
QStringList knownRoles = {"core", "service", "widget", "window"};
QQueue<AdamantPluginInfo*> plugins;
for (const QString role : knownRoles) {
for (AdamantPluginInfo* data : _pluginsByRole.values(role)) {
// Here we want to enqueue plugins to be loaded
plugins.enqueue(data);
}
}
// Clear master list
_plugins.clear();
// Now they should be in the correct role loading order.
while (!plugins.isEmpty()) {
AdamantPluginInfo* data = plugins.dequeue();
// LOADER CODE
data->loader = new QPluginLoader(data->file.absoluteFilePath(), this);
bool load = data->loader->load();
bool loaded = data->loader->isLoaded();
QString error = data->loader->errorString();
if (load && loaded) {
AdamantPlugin* plugin = qobject_cast<AdamantPlugin*>(data->loader->instance());
if (plugin != nullptr) {
data->instance = plugin;
// Now we inject the PluginManager
injectPluginData(data);
// The plugin has been created successfully, so we can execute it's script (if it exists).
const QDir dir = data->file.absoluteDir();
QFile scriptFile(dir.filePath(data->file.fileName() + ".qs"));
if (scriptFile.exists() && scriptFile.open(QFile::ReadOnly)) {
const QString script = scriptFile.readAll();
scriptFile.close();
data->script = addScript(scriptFile.fileName(), script, data->instance);
}
_plugins.append(data);
continue;
}
}
// Delete if we couldn't load
data->loader->deleteLater();
delete data;
data = nullptr;
}
_pluginsByRole.clear();
loadAndExecuteScripts();
}
TTscripts::TTscripts() {
// Load room scripts
for (int scriptNum = 100; scriptNum < 133; ++scriptNum)
addScript(new TTroomScript(scriptNum));
// Load npc scripts
addScript(new DoorbotScript(104, "Doorbot", 0, "Fentible", 11, 1, -1, -1, -1, 0), 100);
addScript(new BellbotScript(101, "Bellbot", 0, "Krage", 8, 1), 110);
addScript(new LiftbotScript(105, "LiftBot", 0, "Nobby", 11, 1, -1, -1, -1, 0), 103);
addScript(new DeskbotScript(103, "DeskBot", 0, "Marsinta", 11, 2), 110);
addScript(new BarbotScript(100, "Barbot", 0, "Fortillian", 9, 1, -1, -1, -1, 0), 112);
addScript(new ParrotScript(107, "Parrot", 0, "The Parrot", 5, 1, -1, -1, -1, 0), 111);
addScript(new MaitreDScript(112, "MaitreDBot", 0, "Dastrogaaar", 8, 1), 132);
addScript(new SuccUBusScript(111, "Succubus", 0, "Shorbert", 9, 1, -1, -1, -1, 0), 110);
}
void PluginManager::loadScripts() {
QFileInfoList list = _scriptPath.entryInfoList();
for (QFileInfo info : list) {
QFile file(info.absoluteFilePath());
if (file.open(QFile::ReadOnly | QFile::Text)) {
QString script = file.readAll();
ScriptSandbox* s = addScript(file.fileName(), script);
if (s) s->evaluateProgram();
file.close();
}
}
}
result_t SandBox::require(const char *id, v8::Local<v8::Value> &retVal)
{
std::string fname = resolvePath(id);
std::map<std::string, VariantEx >::iterator it;
// remove .js ext name if exists
if (fname.length() > 3 && !qstrcmp(&fname[fname.length() - 3], ".js"))
fname.resize(fname.length() - 3);
it = m_mods.find(fname);
if (it != m_mods.end())
{
retVal = it->second;
return 1;
}
if (!m_require.IsEmpty())
{
v8::Local<v8::Value> arg = v8::String::NewFromUtf8(isolate, fname.c_str());
retVal = v8::Local<v8::Function>::New(isolate, m_require)->Call(wrap(), 1, &arg);
if (retVal.IsEmpty())
return CALL_E_JAVASCRIPT;
if (!IsEmpty(retVal))
{
if (retVal->IsObject() && !object_base::getInstance(retVal))
retVal = retVal->ToObject()->Clone();
InstallModule(fname, retVal);
return 0;
}
}
// append .js ext name
fname += ".js";
result_t hr;
const char *pname = fname.c_str();
std::string buf;
hr = fs_base::ac_readFile(pname, buf);
if (hr < 0)
return hr;
return addScript(pname, buf.c_str(), retVal);
}
// Simple setting and getting of properties for scripts and the set command.
stError* cUObject::setProperty( const QString& name, const cVariant& value )
{
changed( TOOLTIP );
changed_ = true;
// \rproperty object.serial This integer property contains the serial for this object.
if ( name == "serial" )
{
if ( !value.canCast( cVariant::IntType ) )
{
PROPERTY_ERROR( -3, QString( "Invalid integer value: '%1'" ).arg( value.toString() ) );
}
setSerial( value.toInt() );
return 0;
}
// \property object.free This boolean property indicates that the object has been freed and is awaiting deletion.
else
SET_BOOL_PROPERTY( "free", free )
// \property object.name This string property contains the name of the object.
else
SET_STR_PROPERTY( "name", this->name_ )
// \property object.pos This property is a <object id="coord">coord</object> object (Python) or a string representation (Show/Set) of the objects position.
else if ( name == "pos" )
{
Coord pos;
if ( !parseCoordinates( value.toString(), pos ) )
PROPERTY_ERROR( -3, QString( "Invalid coordinate value: '%1'" ).arg( value.toString() ) )
moveTo( pos );
return 0;
}
// \property object.eventlist This string property contains a comma separated list of the names of the scripts that are assigned to this object.
else if ( name == "scriptlist" )
{
clearScripts();
QStringList list = value.toString().split( "," );
for ( QStringList::const_iterator it( list.begin() ); it != list.end(); ++it )
{
cPythonScript* script = ScriptManager::instance()->find( ( *it ).toLatin1() );
if ( script )
addScript( script );
else
PROPERTY_ERROR( -3, QString( "Script not found: '%1'" ).arg( *it ) )
}
return 0;
}
void QSimpleResource::addExtensionDataToDOM(QAbstractFormBuilder *afb,
QDesignerFormEditorInterface *core,
DomWidget *ui_widget, QWidget *widget)
{
QExtensionManager *emgr = core->extensionManager();
if (QDesignerExtraInfoExtension *extra = qt_extension<QDesignerExtraInfoExtension*>(emgr, widget)) {
extra->saveWidgetExtraInfo(ui_widget);
}
if (QDesignerScriptExtension *scriptExt = qt_extension<QDesignerScriptExtension*>(emgr, widget)) {
// Add internal state
const QVariantMap data = scriptExt->data();
if (!data.empty()) {
// Convert the map to a DomState.
// We pass on the widget for property introspection. Thus, non-designable properties
// that have to be converted using QMetaObject (enums and the like) will work.
DomPropertyList properties;
const QVariantMap::const_iterator vcend = data.constEnd();
for (QVariantMap::const_iterator it = data.constBegin(); it != vcend; ++it) {
if (DomProperty *prop = variantToDomProperty(afb, widget, it.key(), it.value()))
properties += prop;
}
if (!properties.empty()) {
DomWidgetData *domData = new DomWidgetData;
domData->setElementProperty(properties);
DomWidgetDataList domDataList;
domDataList += domData;
ui_widget->setElementWidgetData(domDataList);
}
}
// Add script
const QString script = scriptExt->script();
if (!script.isEmpty()) {
DomScripts domScripts = ui_widget->elementScript();
addScript(script, ScriptExtension, domScripts);
ui_widget->setElementScript(domScripts);
}
}
}
bool ScriptManager::loadScript(QString path, QString name) {
QFileInfo&& info = ResourceManager::get()->findFile(path);
QFile file(info.absoluteFilePath());
if(!file.exists())
return false;
// check if file is open or open it
if(!(file.isOpen() || file.open(QIODevice::ReadOnly | QIODevice::Text))) {
Logger::get().error("Cannot open file <" + path + ">: " + file.errorString());
return false;
}
QTextStream stream(&file);
QString script = stream.readAll();
file.close();
if(name == "") {
name = info.fileName();
}
return addScript(script, name);
}
//////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
bool BaseScriptHolder::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// DEBUG_CrashMe
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "DEBUG_CrashMe") == 0) {
stack->correctParams(0);
byte *p = 0;
*p = 10;
stack->pushNULL();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// ApplyEvent
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "ApplyEvent") == 0) {
stack->correctParams(1);
ScValue *val = stack->pop();
bool ret;
ret = applyEvent(val->getString());
if (DID_SUCCEED(ret)) {
stack->pushBool(true);
} else {
stack->pushBool(false);
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// CanHandleEvent
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "CanHandleEvent") == 0) {
stack->correctParams(1);
stack->pushBool(canHandleEvent(stack->pop()->getString()));
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// CanHandleMethod
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "CanHandleMethod") == 0) {
stack->correctParams(1);
stack->pushBool(canHandleMethod(stack->pop()->getString()));
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// AttachScript
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "AttachScript") == 0) {
stack->correctParams(1);
stack->pushBool(DID_SUCCEED(addScript(stack->pop()->getString())));
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// DetachScript
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "DetachScript") == 0) {
stack->correctParams(2);
const char *filename = stack->pop()->getString();
bool killThreads = stack->pop()->getBool(false);
bool ret = false;
for (uint32 i = 0; i < _scripts.size(); i++) {
if (scumm_stricmp(_scripts[i]->_filename, filename) == 0) {
_scripts[i]->finish(killThreads);
ret = true;
break;
}
}
stack->pushBool(ret);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// IsScriptRunning
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "IsScriptRunning") == 0) {
stack->correctParams(1);
const char *filename = stack->pop()->getString();
bool ret = false;
for (uint32 i = 0; i < _scripts.size(); i++) {
if (scumm_stricmp(_scripts[i]->_filename, filename) == 0 && _scripts[i]->_state != SCRIPT_FINISHED && _scripts[i]->_state != SCRIPT_ERROR) {
ret = true;
break;
}
}
stack->pushBool(ret);
return STATUS_OK;
} else {
return BaseScriptable::scCallMethod(script, stack, thisStack, name);
}
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool AdRegion::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(REGION)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(NAME)
TOKEN_TABLE(ACTIVE)
TOKEN_TABLE(ZOOM)
TOKEN_TABLE(SCALE)
TOKEN_TABLE(BLOCKED)
TOKEN_TABLE(DECORATION)
TOKEN_TABLE(POINT)
TOKEN_TABLE(ALPHA_COLOR)
TOKEN_TABLE(ALPHA)
TOKEN_TABLE(EDITOR_SELECTED_POINT)
TOKEN_TABLE(EDITOR_SELECTED)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE(PROPERTY)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE_END
byte *params;
int cmd;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_REGION) {
_gameRef->LOG(0, "'REGION' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
for (uint32 i = 0; i < _points.size(); i++) {
delete _points[i];
}
_points.clear();
int ar = 255, ag = 255, ab = 255, alpha = 255;
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_CAPTION:
setCaption((char *)params);
break;
case TOKEN_ACTIVE:
parser.scanStr((char *)params, "%b", &_active);
break;
case TOKEN_BLOCKED:
parser.scanStr((char *)params, "%b", &_blocked);
break;
case TOKEN_DECORATION:
parser.scanStr((char *)params, "%b", &_decoration);
break;
case TOKEN_ZOOM:
case TOKEN_SCALE: {
int j;
parser.scanStr((char *)params, "%d", &j);
_zoom = (float)j;
}
break;
case TOKEN_POINT: {
int x, y;
parser.scanStr((char *)params, "%d,%d", &x, &y);
_points.add(new BasePoint(x, y));
}
break;
case TOKEN_ALPHA_COLOR:
parser.scanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
break;
case TOKEN_ALPHA:
parser.scanStr((char *)params, "%d", &alpha);
break;
case TOKEN_EDITOR_SELECTED:
parser.scanStr((char *)params, "%b", &_editorSelected);
break;
case TOKEN_EDITOR_SELECTED_POINT:
parser.scanStr((char *)params, "%d", &_editorSelectedPoint);
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_PROPERTY:
parseProperty(params, false);
break;
case TOKEN_EDITOR_PROPERTY:
parseEditorProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in REGION definition");
return STATUS_FAILED;
}
createRegion();
_alpha = BYTETORGBA(ar, ag, ab, alpha);
return STATUS_OK;
}
SXObject::SXObject(BaseGame *inGame, ScStack *stack) : BaseObject(inGame) {
int numParams = stack->pop()->getInt(0);
for (int i = 0; i < numParams; i++) {
addScript(stack->pop()->getString());
}
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool AdEntity::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ENTITY)
TOKEN_TABLE(SPRITE)
TOKEN_TABLE(X)
TOKEN_TABLE(Y)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(NAME)
TOKEN_TABLE(SCALABLE)
TOKEN_TABLE(REGISTRABLE)
TOKEN_TABLE(INTERACTIVE)
TOKEN_TABLE(SHADOWABLE)
TOKEN_TABLE(COLORABLE)
TOKEN_TABLE(ACTIVE)
TOKEN_TABLE(EVENTS)
TOKEN_TABLE(FONT)
TOKEN_TABLE(TALK_SPECIAL)
TOKEN_TABLE(TALK)
TOKEN_TABLE(CURSOR)
TOKEN_TABLE(REGION)
TOKEN_TABLE(BLOCKED_REGION)
TOKEN_TABLE(EDITOR_SELECTED)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(SOUND_START_TIME)
TOKEN_TABLE(SOUND_VOLUME)
TOKEN_TABLE(SOUND_PANNING)
TOKEN_TABLE(SOUND)
TOKEN_TABLE(SUBTYPE)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE(PROPERTY)
TOKEN_TABLE(WAYPOINTS)
TOKEN_TABLE(IGNORE_ITEMS)
TOKEN_TABLE(ROTABLE)
TOKEN_TABLE(ROTATABLE)
TOKEN_TABLE(ALPHA_COLOR)
TOKEN_TABLE(SCALE)
TOKEN_TABLE(RELATIVE_SCALE)
TOKEN_TABLE(ALPHA)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE(ITEM)
TOKEN_TABLE(WALK_TO_X)
TOKEN_TABLE(WALK_TO_Y)
TOKEN_TABLE(WALK_TO_DIR)
TOKEN_TABLE(SAVE_STATE)
TOKEN_TABLE_END
byte *params;
int cmd;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ENTITY) {
_gameRef->LOG(0, "'ENTITY' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
AdGame *adGame = (AdGame *)_gameRef;
BaseSprite *spr = nullptr;
int ar = 0, ag = 0, ab = 0, alpha = 0;
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_X:
parser.scanStr((char *)params, "%d", &_posX);
break;
case TOKEN_Y:
parser.scanStr((char *)params, "%d", &_posY);
break;
case TOKEN_SPRITE: {
delete _sprite;
_sprite = nullptr;
spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
} else {
_sprite = spr;
}
}
break;
case TOKEN_TALK: {
spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) {
cmd = PARSERR_GENERIC;
} else {
_talkSprites.add(spr);
}
}
break;
case TOKEN_TALK_SPECIAL: {
spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) {
cmd = PARSERR_GENERIC;
} else {
_talkSpritesEx.add(spr);
}
}
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_ITEM:
setItem((char *)params);
break;
case TOKEN_CAPTION:
setCaption((char *)params);
break;
case TOKEN_FONT:
setFont((char *)params);
break;
case TOKEN_SCALABLE:
parser.scanStr((char *)params, "%b", &_zoomable);
break;
case TOKEN_SCALE: {
int s;
parser.scanStr((char *)params, "%d", &s);
_scale = (float)s;
}
break;
case TOKEN_RELATIVE_SCALE: {
int s;
parser.scanStr((char *)params, "%d", &s);
_relativeScale = (float)s;
}
break;
case TOKEN_ROTABLE:
case TOKEN_ROTATABLE:
parser.scanStr((char *)params, "%b", &_rotatable);
break;
case TOKEN_REGISTRABLE:
case TOKEN_INTERACTIVE:
parser.scanStr((char *)params, "%b", &_registrable);
break;
case TOKEN_SHADOWABLE:
case TOKEN_COLORABLE:
parser.scanStr((char *)params, "%b", &_shadowable);
break;
case TOKEN_ACTIVE:
parser.scanStr((char *)params, "%b", &_active);
break;
case TOKEN_CURSOR:
delete _cursor;
_cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_EDITOR_SELECTED:
parser.scanStr((char *)params, "%b", &_editorSelected);
break;
case TOKEN_REGION: {
if (_region) {
_gameRef->unregisterObject(_region);
}
_region = nullptr;
BaseRegion *rgn = new BaseRegion(_gameRef);
if (!rgn || DID_FAIL(rgn->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
} else {
_region = rgn;
_gameRef->registerObject(_region);
}
}
break;
case TOKEN_BLOCKED_REGION: {
delete _blockRegion;
_blockRegion = nullptr;
delete _currentBlockRegion;
_currentBlockRegion = nullptr;
BaseRegion *rgn = new BaseRegion(_gameRef);
BaseRegion *crgn = new BaseRegion(_gameRef);
if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
delete _blockRegion;
_blockRegion = nullptr;
delete _currentBlockRegion;
_currentBlockRegion = nullptr;
cmd = PARSERR_GENERIC;
} else {
_blockRegion = rgn;
_currentBlockRegion = crgn;
_currentBlockRegion->mimic(_blockRegion);
}
}
break;
case TOKEN_WAYPOINTS: {
delete _wptGroup;
_wptGroup = nullptr;
delete _currentWptGroup;
_currentWptGroup = nullptr;
AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
delete _wptGroup;
_wptGroup = nullptr;
delete _currentWptGroup;
_currentWptGroup = nullptr;
cmd = PARSERR_GENERIC;
} else {
_wptGroup = wpt;
_currentWptGroup = cwpt;
_currentWptGroup->mimic(_wptGroup);
}
}
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_SUBTYPE: {
if (scumm_stricmp((char *)params, "sound") == 0) {
delete _sprite;
_sprite = nullptr;
if (_gameRef->_editorMode) {
spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile("entity_sound.sprite"))) {
cmd = PARSERR_GENERIC;
} else {
_sprite = spr;
}
}
if (_gameRef->_editorMode) {
_editorOnly = true;
}
_zoomable = false;
_rotatable = false;
_registrable = _gameRef->_editorMode;
_shadowable = false;
_subtype = ENTITY_SOUND;
}
}
break;
case TOKEN_SOUND:
playSFX((char *)params, false, false);
break;
case TOKEN_SOUND_START_TIME:
parser.scanStr((char *)params, "%d", &_sFXStart);
break;
case TOKEN_SOUND_VOLUME:
parser.scanStr((char *)params, "%d", &_sFXVolume);
break;
case TOKEN_SOUND_PANNING:
parser.scanStr((char *)params, "%b", &_autoSoundPanning);
break;
case TOKEN_SAVE_STATE:
parser.scanStr((char *)params, "%b", &_saveState);
break;
case TOKEN_PROPERTY:
parseProperty(params, false);
break;
case TOKEN_IGNORE_ITEMS:
parser.scanStr((char *)params, "%b", &_ignoreItems);
break;
case TOKEN_ALPHA_COLOR:
parser.scanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
break;
case TOKEN_ALPHA:
parser.scanStr((char *)params, "%d", &alpha);
break;
case TOKEN_EDITOR_PROPERTY:
parseEditorProperty(params, false);
break;
case TOKEN_WALK_TO_X:
parser.scanStr((char *)params, "%d", &_walkToX);
break;
case TOKEN_WALK_TO_Y:
parser.scanStr((char *)params, "%d", &_walkToY);
break;
case TOKEN_WALK_TO_DIR: {
int i;
parser.scanStr((char *)params, "%d", &i);
if (i < 0) {
i = 0;
}
if (i >= NUM_DIRECTIONS) {
i = DI_NONE;
}
_walkToDir = (TDirection)i;
}
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in ENTITY definition");
return STATUS_FAILED;
}
if (cmd == PARSERR_GENERIC) {
_gameRef->LOG(0, "Error loading ENTITY definition");
if (spr) {
delete spr;
}
return STATUS_FAILED;
}
if (_region && _sprite) {
_gameRef->LOG(0, "Warning: Entity '%s' has both sprite and region.", getName());
}
updatePosition();
if (alpha != 0 && ar == 0 && ag == 0 && ab == 0) {
ar = ag = ab = 255;
}
_alphaColor = BYTETORGBA(ar, ag, ab, alpha);
_state = STATE_READY;
if (_item && ((AdGame *)_gameRef)->isItemTaken(_item)) {
_active = false;
}
return STATUS_OK;
}
/**
* Create a script line from a syntax parser.
*/
ScriptLine* ScriptLineBlock::createLine(SyntaxParser* parser)
{
// create an anonymous block
auto blockParser = parser->block();
if ( blockParser )
{
auto block = new ScriptAnonymousBlock(this);
block->addScript( blockParser->match() );
return block;
}
// create an expression
auto exprParser = parser->expression();
if ( exprParser )
{
Kernel::EParser expr;
expr.parse( exprParser->match() );
if ( expr.name() == ":=" )
{
if ( expr.size() != 2 )
{
throw std::runtime_error("ScriptLineBlock:: syntax error: " + expr.str() );
}
auto e = Expression_ptr(new Expression(m_local_namespace, expr[1]) );
auto setLine = new ScriptLineSet( m_local_namespace, expr[0].name(), e );
return setLine;
}
else
{
auto e = Expression_ptr(new Expression(m_local_namespace, expr) );
return new ScriptLineExpression( m_local_namespace, e );
}
}
// declare a variable
auto varParser = parser->defVar();
if ( varParser )
{
std::string value = varParser->value() ? varParser->value()->match() : "";
auto line = new ScriptLineDef(m_local_namespace, varParser->type()->match(), varParser->var()->match(), value);
return line;
}
// an if-block
auto ifParser = parser->ifBlock();
if ( ifParser )
{
auto cond = ifParser->condition();
auto trueBlock = ifParser->trueBlock();
auto elseBlock = ifParser->elseBlock();
std::string condStr(cond->getInnerStart(), cond->getInnerEnd());
std::string trueScript(trueBlock->getInnerStart(), trueBlock->getInnerEnd());
// create the if line instance
auto ifLine = new ScriptLineIf(m_local_namespace);
// create the first condition expression
Kernel::EParser expr;
expr.parse( condStr );
auto e = Expression_ptr(new Expression(m_local_namespace, expr) );
// add first condition
auto block = new ScriptAnonymousBlock(this);
block->addScript( trueScript );
ifLine->addCondition(e, ScriptLine_ptr(block) );
// add the else block
std::string elseScript;
if ( elseBlock )
{
elseScript.assign(elseBlock->getInnerStart(), elseBlock->getInnerEnd());
auto block = new ScriptAnonymousBlock(this);
block->addScript( trueScript );
ifLine->addDefault( ScriptLine_ptr(block) );
}
return ifLine;
}
return nullptr;
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool UIButton::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(BUTTON)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(DISABLED)
TOKEN_TABLE(VISIBLE)
TOKEN_TABLE(FOCUSABLE)
TOKEN_TABLE(BACK_HOVER)
TOKEN_TABLE(BACK_PRESS)
TOKEN_TABLE(BACK_DISABLE)
TOKEN_TABLE(BACK_FOCUS)
TOKEN_TABLE(BACK)
TOKEN_TABLE(CENTER_IMAGE)
TOKEN_TABLE(IMAGE_HOVER)
TOKEN_TABLE(IMAGE_PRESS)
TOKEN_TABLE(IMAGE_DISABLE)
TOKEN_TABLE(IMAGE_FOCUS)
TOKEN_TABLE(IMAGE)
TOKEN_TABLE(FONT_HOVER)
TOKEN_TABLE(FONT_PRESS)
TOKEN_TABLE(FONT_DISABLE)
TOKEN_TABLE(FONT_FOCUS)
TOKEN_TABLE(FONT)
TOKEN_TABLE(TEXT_ALIGN)
TOKEN_TABLE(TEXT)
TOKEN_TABLE(X)
TOKEN_TABLE(Y)
TOKEN_TABLE(WIDTH)
TOKEN_TABLE(HEIGHT)
TOKEN_TABLE(CURSOR)
TOKEN_TABLE(NAME)
TOKEN_TABLE(EVENTS)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE(PARENT_NOTIFY)
TOKEN_TABLE(PRESSED)
TOKEN_TABLE(PIXEL_PERFECT)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE_END
byte *params;
int cmd = 2;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_BUTTON) {
_gameRef->LOG(0, "'BUTTON' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_CAPTION:
setCaption((char *)params);
break;
case TOKEN_BACK:
delete _back;
_back = new UITiledImage(_gameRef);
if (!_back || DID_FAIL(_back->loadFile((char *)params))) {
delete _back;
_back = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_BACK_HOVER:
delete _backHover;
_backHover = new UITiledImage(_gameRef);
if (!_backHover || DID_FAIL(_backHover->loadFile((char *)params))) {
delete _backHover;
_backHover = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_BACK_PRESS:
delete _backPress;
_backPress = new UITiledImage(_gameRef);
if (!_backPress || DID_FAIL(_backPress->loadFile((char *)params))) {
delete _backPress;
_backPress = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_BACK_DISABLE:
delete _backDisable;
_backDisable = new UITiledImage(_gameRef);
if (!_backDisable || DID_FAIL(_backDisable->loadFile((char *)params))) {
delete _backDisable;
_backDisable = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_BACK_FOCUS:
delete _backFocus;
_backFocus = new UITiledImage(_gameRef);
if (!_backFocus || DID_FAIL(_backFocus->loadFile((char *)params))) {
delete _backFocus;
_backFocus = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE:
delete _image;
_image = new BaseSprite(_gameRef);
if (!_image || DID_FAIL(_image->loadFile((char *)params))) {
delete _image;
_image = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE_HOVER:
delete _imageHover;
_imageHover = new BaseSprite(_gameRef);
if (!_imageHover || DID_FAIL(_imageHover->loadFile((char *)params))) {
delete _imageHover;
_imageHover = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE_PRESS:
delete _imagePress;
_imagePress = new BaseSprite(_gameRef);
if (!_imagePress || DID_FAIL(_imagePress->loadFile((char *)params))) {
delete _imagePress;
_imagePress = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE_DISABLE:
delete _imageDisable;
_imageDisable = new BaseSprite(_gameRef);
if (!_imageDisable || DID_FAIL(_imageDisable->loadFile((char *)params))) {
delete _imageDisable;
_imageDisable = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE_FOCUS:
delete _imageFocus;
_imageFocus = new BaseSprite(_gameRef);
if (!_imageFocus || DID_FAIL(_imageFocus->loadFile((char *)params))) {
delete _imageFocus;
_imageFocus = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT:
if (_font) {
_gameRef->_fontStorage->removeFont(_font);
}
_font = _gameRef->_fontStorage->addFont((char *)params);
if (!_font) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT_HOVER:
if (_fontHover) {
_gameRef->_fontStorage->removeFont(_fontHover);
}
_fontHover = _gameRef->_fontStorage->addFont((char *)params);
if (!_fontHover) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT_PRESS:
if (_fontPress) {
_gameRef->_fontStorage->removeFont(_fontPress);
}
_fontPress = _gameRef->_fontStorage->addFont((char *)params);
if (!_fontPress) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT_DISABLE:
if (_fontDisable) {
_gameRef->_fontStorage->removeFont(_fontDisable);
}
_fontDisable = _gameRef->_fontStorage->addFont((char *)params);
if (!_fontDisable) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT_FOCUS:
if (_fontFocus) {
_gameRef->_fontStorage->removeFont(_fontFocus);
}
_fontFocus = _gameRef->_fontStorage->addFont((char *)params);
if (!_fontFocus) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_TEXT:
setText((char *)params);
_gameRef->_stringTable->expand(&_text);
break;
case TOKEN_TEXT_ALIGN:
if (scumm_stricmp((char *)params, "left") == 0) {
_align = TAL_LEFT;
} else if (scumm_stricmp((char *)params, "right") == 0) {
_align = TAL_RIGHT;
} else {
_align = TAL_CENTER;
}
break;
case TOKEN_X:
parser.scanStr((char *)params, "%d", &_posX);
break;
case TOKEN_Y:
parser.scanStr((char *)params, "%d", &_posY);
break;
case TOKEN_WIDTH:
parser.scanStr((char *)params, "%d", &_width);
break;
case TOKEN_HEIGHT:
parser.scanStr((char *)params, "%d", &_height);
break;
case TOKEN_CURSOR:
delete _cursor;
_cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_PARENT_NOTIFY:
parser.scanStr((char *)params, "%b", &_parentNotify);
break;
case TOKEN_DISABLED:
parser.scanStr((char *)params, "%b", &_disable);
break;
case TOKEN_VISIBLE:
parser.scanStr((char *)params, "%b", &_visible);
break;
case TOKEN_FOCUSABLE:
parser.scanStr((char *)params, "%b", &_canFocus);
break;
case TOKEN_CENTER_IMAGE:
parser.scanStr((char *)params, "%b", &_centerImage);
break;
case TOKEN_PRESSED:
parser.scanStr((char *)params, "%b", &_stayPressed);
break;
case TOKEN_PIXEL_PERFECT:
parser.scanStr((char *)params, "%b", &_pixelPerfect);
break;
case TOKEN_EDITOR_PROPERTY:
parseEditorProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in BUTTON definition");
return STATUS_FAILED;
}
if (cmd == PARSERR_GENERIC) {
_gameRef->LOG(0, "Error loading BUTTON definition");
return STATUS_FAILED;
}
correctSize();
return STATUS_OK;
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool UIText::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(STATIC)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(DISABLED)
TOKEN_TABLE(VISIBLE)
TOKEN_TABLE(BACK)
TOKEN_TABLE(IMAGE)
TOKEN_TABLE(FONT)
TOKEN_TABLE(TEXT_ALIGN)
TOKEN_TABLE(VERTICAL_ALIGN)
TOKEN_TABLE(TEXT)
TOKEN_TABLE(X)
TOKEN_TABLE(Y)
TOKEN_TABLE(WIDTH)
TOKEN_TABLE(HEIGHT)
TOKEN_TABLE(CURSOR)
TOKEN_TABLE(NAME)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE(PARENT_NOTIFY)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE_END
byte *params;
int cmd = 2;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_STATIC) {
_gameRef->LOG(0, "'STATIC' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_CAPTION:
setCaption((char *)params);
break;
case TOKEN_BACK:
delete _back;
_back = new UITiledImage(_gameRef);
if (!_back || DID_FAIL(_back->loadFile((char *)params))) {
delete _back;
_back = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE:
delete _image;
_image = new BaseSprite(_gameRef);
if (!_image || DID_FAIL(_image->loadFile((char *)params))) {
delete _image;
_image = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT:
if (_font) {
_gameRef->_fontStorage->removeFont(_font);
}
_font = _gameRef->_fontStorage->addFont((char *)params);
if (!_font) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_TEXT:
setText((char *)params);
_gameRef->expandStringByStringTable(&_text);
break;
case TOKEN_TEXT_ALIGN:
if (scumm_stricmp((char *)params, "left") == 0) {
_textAlign = TAL_LEFT;
} else if (scumm_stricmp((char *)params, "right") == 0) {
_textAlign = TAL_RIGHT;
} else {
_textAlign = TAL_CENTER;
}
break;
case TOKEN_VERTICAL_ALIGN:
if (scumm_stricmp((char *)params, "top") == 0) {
_verticalAlign = VAL_TOP;
} else if (scumm_stricmp((char *)params, "bottom") == 0) {
_verticalAlign = VAL_BOTTOM;
} else {
_verticalAlign = VAL_CENTER;
}
break;
case TOKEN_X:
parser.scanStr((char *)params, "%d", &_posX);
break;
case TOKEN_Y:
parser.scanStr((char *)params, "%d", &_posY);
break;
case TOKEN_WIDTH:
parser.scanStr((char *)params, "%d", &_width);
break;
case TOKEN_HEIGHT:
parser.scanStr((char *)params, "%d", &_height);
break;
case TOKEN_CURSOR:
delete _cursor;
_cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_PARENT_NOTIFY:
parser.scanStr((char *)params, "%b", &_parentNotify);
break;
case TOKEN_DISABLED:
parser.scanStr((char *)params, "%b", &_disable);
break;
case TOKEN_VISIBLE:
parser.scanStr((char *)params, "%b", &_visible);
break;
case TOKEN_EDITOR_PROPERTY:
parseEditorProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in STATIC definition");
return STATUS_FAILED;
}
if (cmd == PARSERR_GENERIC) {
_gameRef->LOG(0, "Error loading STATIC definition");
return STATUS_FAILED;
}
correctSize();
return STATUS_OK;
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool UIEntity::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ENTITY_CONTAINER)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(DISABLED)
TOKEN_TABLE(VISIBLE)
TOKEN_TABLE(X)
TOKEN_TABLE(Y)
TOKEN_TABLE(NAME)
TOKEN_TABLE(ENTITY)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE_END
byte *params;
int cmd = 2;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ENTITY_CONTAINER) {
_gameRef->LOG(0, "'ENTITY_CONTAINER' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_X:
parser.scanStr((char *)params, "%d", &_posX);
break;
case TOKEN_Y:
parser.scanStr((char *)params, "%d", &_posY);
break;
case TOKEN_DISABLED:
parser.scanStr((char *)params, "%b", &_disable);
break;
case TOKEN_VISIBLE:
parser.scanStr((char *)params, "%b", &_visible);
break;
case TOKEN_ENTITY:
if (DID_FAIL(setEntity((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_EDITOR_PROPERTY:
parseEditorProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in ENTITY_CONTAINER definition");
return STATUS_FAILED;
}
if (cmd == PARSERR_GENERIC) {
_gameRef->LOG(0, "Error loading ENTITY_CONTAINER definition");
return STATUS_FAILED;
}
correctSize();
if (_gameRef->_editorMode) {
_width = 50;
_height = 50;
}
return STATUS_OK;
}
DlgPrefController::DlgPrefController(QWidget* parent, Controller* controller,
ControllerManager* controllerManager,
UserSettingsPointer pConfig)
: DlgPreferencePage(parent),
m_pConfig(pConfig),
m_pControllerManager(controllerManager),
m_pController(controller),
m_pDlgControllerLearning(NULL),
m_pInputTableModel(NULL),
m_pInputProxyModel(NULL),
m_pOutputTableModel(NULL),
m_pOutputProxyModel(NULL),
m_bDirty(false) {
m_ui.setupUi(this);
initTableView(m_ui.m_pInputMappingTableView);
initTableView(m_ui.m_pOutputMappingTableView);
initTableView(m_ui.m_pScriptsTableWidget);
connect(m_pController, SIGNAL(presetLoaded(ControllerPresetPointer)),
this, SLOT(slotPresetLoaded(ControllerPresetPointer)));
// TODO(rryan): Eh, this really isn't thread safe but it's the way it's been
// since 1.11.0. We shouldn't be calling Controller methods because it lives
// in a different thread. Booleans (like isOpen()) are fine but a complex
// object like a preset involves QHash's and other data structures that
// really don't like concurrent access.
ControllerPresetPointer pPreset = m_pController->getPreset();
slotPresetLoaded(pPreset);
m_ui.labelDeviceName->setText(m_pController->getName());
QString category = m_pController->getCategory();
if (!category.isEmpty()) {
m_ui.labelDeviceCategory->setText(category);
} else {
m_ui.labelDeviceCategory->hide();
}
// When the user picks a preset, load it.
connect(m_ui.comboBoxPreset, SIGNAL(activated(int)),
this, SLOT(slotLoadPreset(int)));
// When the user toggles the Enabled checkbox, toggle.
connect(m_ui.chkEnabledDevice, SIGNAL(clicked(bool)),
this, SLOT(slotEnableDevice(bool)));
// Connect our signals to controller manager.
connect(this, SIGNAL(openController(Controller*)),
m_pControllerManager, SLOT(openController(Controller*)));
connect(this, SIGNAL(closeController(Controller*)),
m_pControllerManager, SLOT(closeController(Controller*)));
connect(this, SIGNAL(loadPreset(Controller*, ControllerPresetPointer)),
m_pControllerManager, SLOT(loadPreset(Controller*, ControllerPresetPointer)));
// Input mappings
connect(m_ui.btnAddInputMapping, SIGNAL(clicked()),
this, SLOT(addInputMapping()));
connect(m_ui.btnRemoveInputMappings, SIGNAL(clicked()),
this, SLOT(removeInputMappings()));
connect(m_ui.btnLearningWizard, SIGNAL(clicked()),
this, SLOT(showLearningWizard()));
connect(m_ui.btnClearAllInputMappings, SIGNAL(clicked()),
this, SLOT(clearAllInputMappings()));
// Output mappings
connect(m_ui.btnAddOutputMapping, SIGNAL(clicked()),
this, SLOT(addOutputMapping()));
connect(m_ui.btnRemoveOutputMappings, SIGNAL(clicked()),
this, SLOT(removeOutputMappings()));
connect(m_ui.btnClearAllOutputMappings, SIGNAL(clicked()),
this, SLOT(clearAllOutputMappings()));
// Scripts
connect(m_ui.m_pScriptsTableWidget, SIGNAL(cellChanged(int, int)),
this, SLOT(slotDirty()));
connect(m_ui.btnAddScript, SIGNAL(clicked()),
this, SLOT(addScript()));
connect(m_ui.btnRemoveScript, SIGNAL(clicked()),
this, SLOT(removeScript()));
connect(m_ui.btnOpenScript, SIGNAL(clicked()),
this, SLOT(openScript()));
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool AdActor::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ACTOR)
TOKEN_TABLE(X)
TOKEN_TABLE(Y)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(NAME)
TOKEN_TABLE(SCALABLE)
TOKEN_TABLE(REGISTRABLE)
TOKEN_TABLE(INTERACTIVE)
TOKEN_TABLE(SHADOWABLE)
TOKEN_TABLE(COLORABLE)
TOKEN_TABLE(ACTIVE)
TOKEN_TABLE(WALK)
TOKEN_TABLE(STAND)
TOKEN_TABLE(TALK_SPECIAL)
TOKEN_TABLE(TALK)
TOKEN_TABLE(TURN_LEFT)
TOKEN_TABLE(TURN_RIGHT)
TOKEN_TABLE(EVENTS)
TOKEN_TABLE(FONT)
TOKEN_TABLE(CURSOR)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(SOUND_VOLUME)
TOKEN_TABLE(SOUND_PANNING)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE(PROPERTY)
TOKEN_TABLE(BLOCKED_REGION)
TOKEN_TABLE(WAYPOINTS)
TOKEN_TABLE(IGNORE_ITEMS)
TOKEN_TABLE(ROTABLE)
TOKEN_TABLE(ROTATABLE)
TOKEN_TABLE(ALPHA_COLOR)
TOKEN_TABLE(SCALE)
TOKEN_TABLE(RELATIVE_SCALE)
TOKEN_TABLE(ALPHA)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE(ANIMATION)
TOKEN_TABLE_END
byte *params;
int cmd;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ACTOR) {
_gameRef->LOG(0, "'ACTOR' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
AdGame *adGame = (AdGame *)_gameRef;
AdSpriteSet *spr = nullptr;
int ar = 0, ag = 0, ab = 0, alpha = 0;
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_X:
parser.scanStr((char *)params, "%d", &_posX);
break;
case TOKEN_Y:
parser.scanStr((char *)params, "%d", &_posY);
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_CAPTION:
setCaption((char *)params);
break;
case TOKEN_FONT:
setFont((char *)params);
break;
case TOKEN_SCALABLE:
parser.scanStr((char *)params, "%b", &_zoomable);
break;
case TOKEN_ROTABLE:
case TOKEN_ROTATABLE:
parser.scanStr((char *)params, "%b", &_rotatable);
break;
case TOKEN_REGISTRABLE:
case TOKEN_INTERACTIVE:
parser.scanStr((char *)params, "%b", &_registrable);
break;
case TOKEN_SHADOWABLE:
case TOKEN_COLORABLE:
parser.scanStr((char *)params, "%b", &_shadowable);
break;
case TOKEN_ACTIVE:
parser.scanStr((char *)params, "%b", &_active);
break;
case TOKEN_WALK:
delete _walkSprite;
_walkSprite = nullptr;
spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texWalkLifeTime, CACHE_HALF))) {
cmd = PARSERR_GENERIC;
} else {
_walkSprite = spr;
}
break;
case TOKEN_TALK:
spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) {
cmd = PARSERR_GENERIC;
} else {
_talkSprites.add(spr);
}
break;
case TOKEN_TALK_SPECIAL:
spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) {
cmd = PARSERR_GENERIC;
} else {
_talkSpritesEx.add(spr);
}
break;
case TOKEN_STAND:
delete _standSprite;
_standSprite = nullptr;
spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texStandLifeTime))) {
cmd = PARSERR_GENERIC;
} else {
_standSprite = spr;
}
break;
case TOKEN_TURN_LEFT:
delete _turnLeftSprite;
_turnLeftSprite = nullptr;
spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true))) {
cmd = PARSERR_GENERIC;
} else {
_turnLeftSprite = spr;
}
break;
case TOKEN_TURN_RIGHT:
delete _turnRightSprite;
_turnRightSprite = nullptr;
spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true))) {
cmd = PARSERR_GENERIC;
} else {
_turnRightSprite = spr;
}
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_CURSOR:
delete _cursor;
_cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = nullptr;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_SOUND_VOLUME:
parser.scanStr((char *)params, "%d", &_sFXVolume);
break;
case TOKEN_SCALE: {
int s;
parser.scanStr((char *)params, "%d", &s);
_scale = (float)s;
}
break;
case TOKEN_RELATIVE_SCALE: {
int s;
parser.scanStr((char *)params, "%d", &s);
_relativeScale = (float)s;
}
break;
case TOKEN_SOUND_PANNING:
parser.scanStr((char *)params, "%b", &_autoSoundPanning);
break;
case TOKEN_PROPERTY:
parseProperty(params, false);
break;
case TOKEN_BLOCKED_REGION: {
delete _blockRegion;
delete _currentBlockRegion;
_blockRegion = nullptr;
_currentBlockRegion = nullptr;
BaseRegion *rgn = new BaseRegion(_gameRef);
BaseRegion *crgn = new BaseRegion(_gameRef);
if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
delete _blockRegion;
delete _currentBlockRegion;
_blockRegion = nullptr;
_currentBlockRegion = nullptr;
cmd = PARSERR_GENERIC;
} else {
_blockRegion = rgn;
_currentBlockRegion = crgn;
_currentBlockRegion->mimic(_blockRegion);
}
}
break;
case TOKEN_WAYPOINTS: {
delete _wptGroup;
delete _currentWptGroup;
_wptGroup = nullptr;
_currentWptGroup = nullptr;
AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
delete _wptGroup;
delete _currentWptGroup;
_wptGroup = nullptr;
_currentWptGroup = nullptr;
cmd = PARSERR_GENERIC;
} else {
_wptGroup = wpt;
_currentWptGroup = cwpt;
_currentWptGroup->mimic(_wptGroup);
}
}
break;
case TOKEN_IGNORE_ITEMS:
parser.scanStr((char *)params, "%b", &_ignoreItems);
break;
case TOKEN_ALPHA_COLOR:
parser.scanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
break;
case TOKEN_ALPHA:
parser.scanStr((char *)params, "%d", &alpha);
break;
case TOKEN_EDITOR_PROPERTY:
parseEditorProperty(params, false);
break;
case TOKEN_ANIMATION: {
AdSpriteSet *anim = new AdSpriteSet(_gameRef, this);
if (!anim || DID_FAIL(anim->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
} else {
_anims.add(anim);
}
}
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in ACTOR definition");
return STATUS_FAILED;
}
if (cmd == PARSERR_GENERIC) {
if (spr) {
delete spr;
}
_gameRef->LOG(0, "Error loading ACTOR definition");
return STATUS_FAILED;
}
if (alpha != 0 && ar == 0 && ag == 0 && ab == 0) {
ar = ag = ab = 255;
}
_alphaColor = BYTETORGBA(ar, ag, ab, alpha);
_state = _nextState = STATE_READY;
return STATUS_OK;
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool UIEdit::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(DISABLED)
TOKEN_TABLE(VISIBLE)
TOKEN_TABLE(BACK)
TOKEN_TABLE(IMAGE)
TOKEN_TABLE(FONT_SELECTED)
TOKEN_TABLE(FONT)
TOKEN_TABLE(TEXT)
TOKEN_TABLE(X)
TOKEN_TABLE(Y)
TOKEN_TABLE(WIDTH)
TOKEN_TABLE(HEIGHT)
TOKEN_TABLE(CURSOR_BLINK_RATE)
TOKEN_TABLE(CURSOR)
TOKEN_TABLE(FRAME_WIDTH)
TOKEN_TABLE(NAME)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(PARENT_NOTIFY)
TOKEN_TABLE(MAX_LENGTH)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE(EDIT)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE_END
byte *params;
int cmd = 2;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_EDIT) {
_gameRef->LOG(0, "'EDIT' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_BACK:
delete _back;
_back = new UITiledImage(_gameRef);
if (!_back || DID_FAIL(_back->loadFile((char *)params))) {
delete _back;
_back = NULL;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE:
delete _image;
_image = new BaseSprite(_gameRef);
if (!_image || DID_FAIL(_image->loadFile((char *)params))) {
delete _image;
_image = NULL;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT:
if (_font) {
_gameRef->_fontStorage->removeFont(_font);
}
_font = _gameRef->_fontStorage->addFont((char *)params);
if (!_font) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT_SELECTED:
if (_fontSelected) {
_gameRef->_fontStorage->removeFont(_fontSelected);
}
_fontSelected = _gameRef->_fontStorage->addFont((char *)params);
if (!_fontSelected) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_TEXT:
setText((char *)params);
_gameRef->_stringTable->expand(&_text);
break;
case TOKEN_X:
parser.scanStr((char *)params, "%d", &_posX);
break;
case TOKEN_Y:
parser.scanStr((char *)params, "%d", &_posY);
break;
case TOKEN_WIDTH:
parser.scanStr((char *)params, "%d", &_width);
break;
case TOKEN_HEIGHT:
parser.scanStr((char *)params, "%d", &_height);
break;
case TOKEN_MAX_LENGTH:
parser.scanStr((char *)params, "%d", &_maxLength);
break;
case TOKEN_CAPTION:
setCaption((char *)params);
break;
case TOKEN_CURSOR:
delete _cursor;
_cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = NULL;
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_CURSOR_BLINK_RATE:
parser.scanStr((char *)params, "%d", &_cursorBlinkRate);
break;
case TOKEN_FRAME_WIDTH:
parser.scanStr((char *)params, "%d", &_frameWidth);
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_PARENT_NOTIFY:
parser.scanStr((char *)params, "%b", &_parentNotify);
break;
case TOKEN_DISABLED:
parser.scanStr((char *)params, "%b", &_disable);
break;
case TOKEN_VISIBLE:
parser.scanStr((char *)params, "%b", &_visible);
break;
case TOKEN_EDITOR_PROPERTY:
parseEditorProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in EDIT definition");
return STATUS_FAILED;
}
if (cmd == PARSERR_GENERIC) {
_gameRef->LOG(0, "Error loading EDIT definition");
return STATUS_FAILED;
}
correctSize();
return STATUS_OK;
}
WizardError::WIZARD_ERROR_CODE EmitterPluginGenerator::generate()
{
WizardError::WIZARD_ERROR_CODE status = WizardError::NO_ERROR;
// first we need to generate the file structure
createFileStructure(m_emitterName);
// file structure created
std::string mainSrcFileName = "main.cpp";
std::string emitterHeaderName = m_emitterName + "Plugin.h";
std::string emitterSrcName = m_emitterName + "Plugin.cpp";
std::string emitterUIScriptName = "AE" + m_emitterName + "Template.mel";
addSrcFile(mainSrcFileName);
addSrcFile(emitterSrcName);
addIncludeFile(emitterHeaderName);
addScript(emitterUIScriptName);
std::string mainSrcFilePath = std::string(getSrcPath() + "/" + mainSrcFileName);
std::string emitterIncFilePath = std::string(getIncPath() + "/" + emitterHeaderName);
std::string emitterSrcFilePath = std::string(getSrcPath() + "/" + emitterSrcName);
std::string emitterUIScriptPath = std::string(getScriptPath() + "/" + emitterUIScriptName);
std::vector<std::string> toWrite;
toWrite.clear();
std::vector<std::string> fnFetch;
fnFetch.clear();
std::vector<std::string> incFetch;
incFetch.clear();
std::vector<std::string> grdFetch;
grdFetch.clear();
std::vector<std::string> noticeFetch;
noticeFetch.clear();
std::vector<std::string> classFetch;
classFetch.clear();
std::vector<std::string> classForwardFetch;
classForwardFetch.clear();
std::vector<std::string> fnContFetch;
fnContFetch.clear();
QJsonParseError err;
QJsonDocument doc;
QJsonObject obj;
//==================================================================================================
// lets first write out the main.cpp
status = createDefaultMainSourceFile("emitterMain",m_emitterName,emitterHeaderName,mainSrcFilePath);
if (status != WizardError::NO_ERROR)
{
return status;
}
//==================================================================================================
// next lets move onto the UI script as this is a nice simple one to do
status = createNodeScriptTemplateFile("emitterUIScript",m_emitterName,emitterUIScriptPath);
if (status != WizardError::NO_ERROR)
{
return status;
}
//==================================================================================================
// now to write the header file for the plugin
QString hContents;
QString classContents;
status = Utilities::getContentsOfFile(":/Framework/emitterH",&hContents);
if (status != WizardError::NO_ERROR)
{
return status;
}
status = Utilities::getContentsOfFile(":/Framework/coreClassDef",&classContents);
if (status != WizardError::NO_ERROR)
{
return status;
}
doc = QJsonDocument::fromJson(hContents.toUtf8(), &err);
QJsonDocument classDoc = QJsonDocument::fromJson(classContents.toUtf8(),&err);
if (!doc.isObject() || !classDoc.isObject())
{
return WizardError::ERR_GENERATOR_QUIT;
}
obj = doc.object();
status = Utilities::findInJsonObj("genNotice",obj,¬iceFetch);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::writeVectorToVector(noticeFetch,&toWrite);
// now clear the noticeFetch ready for next time
noticeFetch.clear();
// add a line break to ensure formatting is correct
toWrite.push_back("\n");
// set to the class obj to get the guards
obj = classDoc.object();
status = replaceIncludeGuards(&grdFetch,m_emitterName,obj);
if (status != WizardError::NO_ERROR)
{
return status;
}
// add the first two guards only, the last element will go at the end of the header
Utilities::writeStringToVector(grdFetch.at(0),&toWrite);
Utilities::writeStringToVector(grdFetch.at(1),&toWrite);
// add a line break to ensure formatting is correct
toWrite.push_back("\n");
// switch the object back to the header now
obj = doc.object();
status = Utilities::findInJsonObj("includes",obj,&incFetch);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::writeVectorToVector(incFetch,&toWrite);
// clear the incFetch ready for next time
incFetch.clear();
// add a line break to ensure formatting is correct
toWrite.push_back("\n");
// lets now get the forward declarations of classes used within this header
status = Utilities::findInJsonObj("forwardDecs",obj,&classForwardFetch);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::writeVectorToVector(classForwardFetch,&toWrite);
// switch obj context back to the class stuff
obj = classDoc.object();
status = Utilities::findInJsonObj("classDef",obj,&classFetch);
// lets just now replace %_#_CTRPARAMS_#_%, %_#_CREATORRETTYPE_#_% and %_#_CREATORPARAMS_#_% as we know here
// they will be "" void and "" respectively
Utilities::replaceInStringVector(&classFetch,"%_#_CTRPARAMS_#_%","");
Utilities::replaceInStringVector(&classFetch,"%_#_CREATORRETTYPE_#_%","void");
Utilities::replaceInStringVector(&classFetch,"%_#_CREATORPARAMS_#_%","");
Utilities::replaceInStringVector(&classFetch,"%_#_INHERITFROM_#_%","MPxEmitterNode");
obj = doc.object();
// need a temp vector to build up a vector if chosen options
std::vector<std::string> temp;
temp.clear();
// firstly though lets quickly replace the public attributes in the class def with the required ones
status = Utilities::findInJsonObj("reqPubAttribs",obj,&temp);
if (status != WizardError::NO_ERROR)
{
return status;
}
// now replace %_#_PUBLICATTRIBS_#_% in coreClassDef with this vector
Utilities::replaceInStringVectorWithVector(&classFetch,"%_#_PUBLICATTRIBS_#_%",temp);
temp.clear();
status = Utilities::findInJsonObj("reqFns",obj,&temp);
if (status != WizardError::NO_ERROR)
{
return status;
}
// now we need to write these to the fnFetch so we can use temp again
Utilities::writeVectorToVector(temp,&fnFetch);
temp.clear();
// now check if we need to get the emit function
if (m_createEmit)
{
status = Utilities::findInJsonObj("emitFn",obj,&temp);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::writeVectorToVector(temp,&fnFetch);
}
Utilities::replaceInStringVectorWithVector(&classFetch,"%_#_FNSPECFN_#_%",fnFetch);
fnFetch.clear();
// now replace %_#_CLASSNAME_#_% within classFetch with the right name
Utilities::replaceInStringVector(&classFetch,"%_#_CLASSNAME_#_%",m_emitterName);
// now replace the private attributes/objects
if (m_addObjs)
{
// here we simply need to igore the ARGUMENT types
std::vector<std::string> tempArgs;
tempArgs.clear();
for (int i = 0; i < getNumExtraArguments(); i++)
{
if (getExtraArgumentAt(i)._vType != "ARGUMENT") // cannot accept arguments here
{
tempArgs.push_back(Utilities::argumentToStringRep(getExtraArgumentAt(i)));
}
}
Utilities::replaceInStringVectorWithVector(&classFetch,"%_#_FNSPECATTRIBS_#_%",tempArgs);
tempArgs.clear();
}
else
{
Utilities::replaceInStringVector(&classFetch,"%_#_FNSPECATTRIBS_#_%","");
}
Utilities::writeVectorToVector(classFetch,&toWrite);
classFetch.clear();
// add a line break to ensure formatting is correct
toWrite.push_back("\n");
Utilities::writeStringToVector(grdFetch.at(2),&toWrite);
// now need to clear the guards
grdFetch.clear();
Utilities::writeVectorToFile(emitterIncFilePath, toWrite);
toWrite.clear();
//==================================================================================================
// and finally the cpp for the plugin
// this one will be a little bit different form the others as it will be filling out the contents
// of two of the functions already when generating
QString cppContents;
status = Utilities::getContentsOfFile(":/Framework/emitterCpp",&cppContents);
if (status != WizardError::NO_ERROR)
{
return status;
}
doc = QJsonDocument::fromJson(cppContents.toUtf8(), &err);
if(doc.isObject())
{
obj = doc.object();
}
else
{
return WizardError::ERR_GENERATOR_QUIT;
}
status = Utilities::findInJsonObj("genNotice",obj,¬iceFetch);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::writeVectorToVector(noticeFetch,&toWrite);
noticeFetch.clear();
status = Utilities::findInJsonObj("includes",obj,&incFetch);
if (status != WizardError::NO_ERROR)
{
return status;
}
// need to replace the attributes
Utilities::replaceInStringVector(&incFetch,"%_#_EMITTERINCLUDE_#_%",emitterHeaderName);
Utilities::writeVectorToVector(incFetch,&toWrite);
incFetch.clear();
toWrite.push_back("\n");
fnFetch.clear();
temp.clear();
status = Utilities::findInJsonObj("reqFns",obj,&temp);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::writeVectorToVector(temp,&fnFetch);
temp.clear();
// now to do some replacing if necessary for the objects
if (m_addObjs)
{
// here we simply need to only collect the OBJECT types
std::vector<std::string> objs;
objs.clear();
for (int i = 0; i < getNumExtraArguments(); i++)
{
if (getExtraArgumentAt(i)._vType == "OBJECT") // cannot accept arguments here
{
objs.push_back(Utilities::createObjectCppDecString(m_emitterName, getExtraArgumentAt(i)._name));
}
}
Utilities::replaceInStringVectorWithVector(&fnFetch,"%_#_OBJDEC_#_%",objs);
objs.clear();
// we also now need to replace %_#_OBJINIT_#_% with the already calculated code for the objects
Utilities::replaceInStringVectorWithVector(&fnFetch,"%_#_OBJINIT_#_%",objInitCode());
}
else
{
Utilities::replaceInStringVector(&fnFetch,"%_#_OBJDEC_#_%","");
Utilities::replaceInStringVector(&fnFetch,"%_#_OBJINIT_#_%","");
}
// now check to see if we need the emit function
// now check if we need to get the emit function
if (m_createEmit)
{
status = Utilities::findInJsonObj("emitFn",obj,&temp);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::writeVectorToVector(temp,&fnFetch);
}
// now replace all instances of the class name with the right value
Utilities::replaceInStringVector(&fnFetch,"%_#_CLASSNAME_#_%",m_emitterName);
// now we need to do some fetching of function content and simply replacing the parts with this
status = Utilities::findInJsonObj("gwposcont",obj,&fnContFetch);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::replaceInStringVectorWithVector(&fnFetch,"%_#_GWPOSCONT_#_%",fnContFetch);
fnContFetch.clear(); // clear this vector for the next one
status = Utilities::findInJsonObj("gwposcontblock",obj,&fnContFetch);
if (status != WizardError::NO_ERROR)
{
return status;
}
Utilities::replaceInStringVectorWithVector(&fnFetch,"%_#_GWPOSCONTBLOCK_#_%",fnContFetch);
fnContFetch.clear();
Utilities::writeVectorToVector(fnFetch,&toWrite);
fnFetch.clear();
Utilities::writeVectorToFile(emitterSrcFilePath,toWrite);
toWrite.clear();
temp.clear();
//==================================================================================================
genMakefiles(m_emitterName);
return WizardError::NO_ERROR;
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
bool BaseRegion::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(REGION)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(NAME)
TOKEN_TABLE(ACTIVE)
TOKEN_TABLE(POINT)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(EDITOR_SELECTED_POINT)
TOKEN_TABLE(PROPERTY)
TOKEN_TABLE_END
byte *params;
int cmd;
BaseParser parser;
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_REGION) {
_gameRef->LOG(0, "'REGION' keyword expected.");
return STATUS_FAILED;
}
buffer = params;
}
for (uint32 i = 0; i < _points.size(); i++) {
delete _points[i];
}
_points.clear();
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (DID_FAIL(loadFile((char *)params))) {
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_NAME:
setName((char *)params);
break;
case TOKEN_CAPTION:
setCaption((char *)params);
break;
case TOKEN_ACTIVE:
parser.scanStr((char *)params, "%b", &_active);
break;
case TOKEN_POINT: {
int x, y;
parser.scanStr((char *)params, "%d,%d", &x, &y);
_points.add(new BasePoint(x, y));
}
break;
case TOKEN_SCRIPT:
addScript((char *)params);
break;
case TOKEN_EDITOR_SELECTED_POINT:
parser.scanStr((char *)params, "%d", &_editorSelectedPoint);
break;
case TOKEN_PROPERTY:
parseProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
_gameRef->LOG(0, "Syntax error in REGION definition");
return STATUS_FAILED;
}
createRegion();
return STATUS_OK;
}
unsigned int com_addScript(LPTSTR script, int aExecute){return addScript(script,aExecute);}
