forked from Mirrors/openclonk
254 lines
7.6 KiB
C++
254 lines
7.6 KiB
C++
/*
|
|
* OpenClonk, http://www.openclonk.org
|
|
*
|
|
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
|
|
* Copyright (c) 2013, The OpenClonk Team and contributors
|
|
*
|
|
* Distributed under the terms of the ISC license; see accompanying file
|
|
* "COPYING" for details.
|
|
*
|
|
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
|
|
* See accompanying file "TRADEMARK" for details.
|
|
*
|
|
* To redistribute this file separately, substitute the full license texts
|
|
* for the above references.
|
|
*/
|
|
|
|
#include "C4Include.h"
|
|
#include "editor/C4PropertyPath.h"
|
|
#include "script/C4Value.h"
|
|
#include "object/C4Object.h"
|
|
#include "object/C4GameObjects.h"
|
|
#include "object/C4DefList.h"
|
|
#include "object/C4Def.h"
|
|
#include "script/C4Effect.h"
|
|
#include "script/C4AulExec.h"
|
|
#include "editor/C4Console.h"
|
|
|
|
|
|
/* Property path for property setting synchronization */
|
|
|
|
C4PropertyPath::C4PropertyPath(C4PropList *target) : get_path_type(PPT_Root), set_path_type(PPT_Root)
|
|
{
|
|
// Build string to set target
|
|
if (target)
|
|
{
|
|
// Object target
|
|
C4Object *obj = target->GetObject();
|
|
C4PropListStatic *target_static;
|
|
if (obj)
|
|
{
|
|
get_path.Format("Object(%d)", (int)obj->Number);
|
|
root = get_path;
|
|
}
|
|
else if ((target_static = target->IsStatic()))
|
|
{
|
|
// Global static prop lists: Resolve name
|
|
get_path = target_static->GetDataString();
|
|
root = get_path;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise leave empty. We do not want assignments into temporary values, etc.
|
|
}
|
|
}
|
|
}
|
|
|
|
C4PropertyPath::C4PropertyPath(C4Effect *fx, C4Object *target_obj) : get_path_type(PPT_Root), set_path_type(PPT_Root)
|
|
{
|
|
// Effect property path: Represent as GetEffect("name", Object(%d), index) for object effects and GetEffect("name", nil, index) for global effects
|
|
if (!fx) return;
|
|
const char *name = fx->GetName();
|
|
int32_t index = 0;
|
|
for (C4Effect *ofx = target_obj ? target_obj->pEffects : ::ScriptEngine.pGlobalEffects; ofx; ofx = ofx->pNext)
|
|
if (ofx == fx) break; else if (!strcmp(ofx->GetName(), name)) ++index;
|
|
if (target_obj)
|
|
{
|
|
get_path.Format(R"(GetEffect("%s", Object(%d), %d))", name, (int)target_obj->Number, (int)index);
|
|
root.Format("Object(%d)", (int)target_obj->Number);
|
|
}
|
|
else
|
|
{
|
|
get_path.Format(R"(GetEffect("%s", nil, %d))", name, (int)index);
|
|
root = ::Strings.P[P_Global].GetData();
|
|
}
|
|
}
|
|
|
|
C4PropertyPath::C4PropertyPath(const C4PropertyPath &parent, int32_t elem_index) : root(parent.root)
|
|
{
|
|
get_path.Format("%s[%d]", parent.GetGetPath(), (int)elem_index);
|
|
get_path_type = set_path_type = PPT_Index;
|
|
}
|
|
|
|
C4PropertyPath::C4PropertyPath(const C4PropertyPath &parent, const char *child_property)
|
|
: get_path_type(PPT_Property), set_path_type(PPT_Property), root(parent.root)
|
|
{
|
|
get_path.Format("%s.%s", parent.GetGetPath(), child_property);
|
|
}
|
|
|
|
void C4PropertyPath::SetSetPath(const C4PropertyPath &parent, const char *child_property, C4PropertyPath::PathType path_type)
|
|
{
|
|
set_path_type = path_type;
|
|
if (path_type == PPT_Property)
|
|
set_path.Format("%s.%s", parent.GetGetPath(), child_property);
|
|
else if (path_type == PPT_SetFunction)
|
|
set_path.Format("%s->%s", parent.GetGetPath(), child_property);
|
|
else if (path_type == PPT_GlobalSetFunction)
|
|
{
|
|
set_path.Copy(parent.GetGetPath());
|
|
argument.Copy(child_property);
|
|
}
|
|
else if (path_type == PPT_RootSetFunction)
|
|
{
|
|
set_path.Format("%s->%s", parent.GetRoot(), child_property);
|
|
}
|
|
else
|
|
{
|
|
assert(false);
|
|
}
|
|
}
|
|
|
|
void C4PropertyPath::SetProperty(const char *set_string) const
|
|
{
|
|
// Compose script to update property
|
|
const char *set_path_c = GetSetPath();
|
|
StdStrBuf script;
|
|
if (set_path_type == PPT_SetFunction || set_path_type == PPT_RootSetFunction)
|
|
script.Format("%s(%s)", set_path_c, set_string);
|
|
else if (set_path_type == PPT_GlobalSetFunction)
|
|
script.Format("%s(%s,%s)", argument.getData(), set_path_c, set_string);
|
|
else
|
|
script.Format("%s=%s", set_path_c, set_string);
|
|
// Execute synced scripted
|
|
::Console.EditCursor.EMControl(CID_Script, new C4ControlScript(script.getData(), 0, false));
|
|
}
|
|
|
|
void C4PropertyPath::SetProperty(const C4Value &to_val, const C4PropListStatic *ignore_reference_parent) const
|
|
{
|
|
SetProperty(to_val.GetDataString(9999999, ignore_reference_parent).getData());
|
|
}
|
|
|
|
C4Value C4PropertyPath::ResolveValue() const
|
|
{
|
|
if (!get_path.getLength()) return C4VNull;
|
|
return AulExec.DirectExec(::ScriptEngine.GetPropList(), get_path.getData(), "resolve property", false, nullptr);
|
|
}
|
|
|
|
C4Value C4PropertyPath::ResolveRoot() const
|
|
{
|
|
if (!root.getLength()) return C4VNull;
|
|
return AulExec.DirectExec(::ScriptEngine.GetPropList(), root.getData(), "resolve property root", false, nullptr);
|
|
}
|
|
|
|
void C4PropertyPath::DoCall(const char *call_string) const
|
|
{
|
|
// Compose script call
|
|
StdStrBuf script;
|
|
script.Format(call_string, get_path.getData());
|
|
// Execute synced scripted
|
|
::Console.EditCursor.EMControl(CID_Script, new C4ControlScript(script.getData(), 0, false));
|
|
}
|
|
|
|
|
|
/* C4PropertyCollection */
|
|
|
|
void C4PropertyCollection::Clear()
|
|
{
|
|
entries.clear();
|
|
checked_values.clear();
|
|
}
|
|
|
|
bool C4PropertyCollection::CollectPropList(C4PropList *p, const C4PropertyPath &path, C4PropertyName prop, const C4Value &val, const char *base_name)
|
|
{
|
|
// Collect prop list if it matches the condition
|
|
C4Value cmp;
|
|
if (p->GetProperty(prop, &cmp))
|
|
{
|
|
if (cmp == val)
|
|
{
|
|
// Only stuff set in the game
|
|
if (!p->IsFrozen())
|
|
{
|
|
entries.emplace_back(path, C4VPropList(p), base_name);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void C4PropertyCollection::CollectPropLists(C4ValueArray *target, const C4PropertyPath &target_path, C4PropertyName prop, const C4Value &val, const char *base_name)
|
|
{
|
|
// Avoid recursion
|
|
if (checked_values.find(target) != checked_values.end()) return;
|
|
checked_values.insert(target);
|
|
// Check all child elements
|
|
for (int32_t index = 0; index < target->GetSize(); ++index)
|
|
{
|
|
const C4Value &childval = target->GetItem(index);
|
|
switch (childval.GetType())
|
|
{
|
|
case C4V_Array:
|
|
CollectPropLists(childval._getArray(), C4PropertyPath(target_path, index), prop, val, base_name);
|
|
break;
|
|
case C4V_PropList:
|
|
CollectPropLists(childval._getPropList(), C4PropertyPath(target_path, index), prop, val, base_name);
|
|
break;
|
|
default:
|
|
// nada
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void C4PropertyCollection::CollectPropLists(C4PropList *target, const C4PropertyPath &target_path, C4PropertyName prop, const C4Value &val, const char *base_name)
|
|
{
|
|
// Avoid recursion
|
|
if (checked_values.find(target) != checked_values.end()) return;
|
|
checked_values.insert(target);
|
|
// Check base itself
|
|
if (CollectPropList(target, target_path, prop, val, base_name))
|
|
{
|
|
// No need to check children then
|
|
return;
|
|
}
|
|
// Check all child properties
|
|
for (C4String *key : target->GetSortedLocalProperties(false))
|
|
{
|
|
C4Value childval;
|
|
target->GetPropertyByS(key, &childval);
|
|
switch (childval.GetType())
|
|
{
|
|
case C4V_Array:
|
|
CollectPropLists(childval._getArray(), C4PropertyPath(target_path, key->GetCStr()), prop, val, base_name);
|
|
break;
|
|
case C4V_PropList:
|
|
CollectPropLists(childval._getPropList(), C4PropertyPath(target_path, key->GetCStr()), prop, val, base_name);
|
|
break;
|
|
default:
|
|
// nada
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void C4PropertyCollection::CollectPropLists(C4PropertyName prop, const C4Value &val)
|
|
{
|
|
Clear();
|
|
// Walk over game content and search for matching prop lists
|
|
// Walk in reverse because prop lists of more permanent objects are often assigned to temporary objects
|
|
for (C4Object *obj : ::Objects.reverse())
|
|
{
|
|
CollectPropLists(obj, C4PropertyPath(obj), prop, val, obj->GetName());
|
|
for (C4Effect *fx = obj->pEffects; fx; fx = fx->pNext)
|
|
{
|
|
CollectPropLists(fx, C4PropertyPath(fx, obj), prop, val, fx->GetName());
|
|
}
|
|
}
|
|
for (C4Effect *fx = ::ScriptEngine.pGlobalEffects; fx; fx = fx->pNext)
|
|
{
|
|
CollectPropLists(fx, C4PropertyPath(fx, nullptr), prop, val, fx->GetName());
|
|
}
|
|
}
|
|
|