forked from Mirrors/openclonk
1631 lines
80 KiB
C
1631 lines
80 KiB
C
/* User action execution handler */
|
|
// Handles actions set in editor e.g. for dialogues, switches, etc.
|
|
// An object is sometimes needed to show a menu or start a timer, so this definition is created whenever a user action is run
|
|
|
|
local Name = "UserAction";
|
|
local Plane=0;
|
|
|
|
/* UserAction definition */
|
|
|
|
// Base classes for EditorProps using actions
|
|
local Evaluator;
|
|
|
|
// EditorProps for generic user action callbacks
|
|
local Prop, PropProgressMode, PropParallel;
|
|
|
|
// Base props for action execution conditions
|
|
local ActionEvaluation ;
|
|
|
|
// Proplist containing callback function. Indexed by option names.
|
|
local EvaluatorCallbacks;
|
|
|
|
// Proplist containing option definitions. Indexed by option names.
|
|
local EvaluatorDefs;
|
|
|
|
// Call this definition early (but after EditorBase) to allow EditorProp initialization
|
|
local DefinitionPriority=99;
|
|
|
|
// Localized group names
|
|
local GroupNames = { Structure="$Structure$", Game="$Game$", Ambience="$Ambience$", Disasters="$Disasters$" };
|
|
|
|
// Storage for global user variables
|
|
static g_UserAction_global_vars;
|
|
|
|
// Localized evaluator names
|
|
local EvaluatorTypeNames = {
|
|
Action = "$UserAction$",
|
|
Color = "$UserColor$",
|
|
Object = "$UserObject$",
|
|
ObjectList = "$UserObjectList$",
|
|
Definition = "$UserDefinition$",
|
|
Player = "$UserPlayer$",
|
|
PlayerList = "$UserPlayerList$",
|
|
Boolean = "$UserBoolean$",
|
|
Integer = "$UserInteger$",
|
|
String = "$UserString$",
|
|
Position = "$UserPosition$",
|
|
Offset = "$UserOffset$"
|
|
};
|
|
|
|
// All evaluator types (unfortunately, EvaluatorReturnTypes->GetProperties() does not work)
|
|
local EvaluatorTypes = ["Action", "Object", "ObjectList", "Definition", "Player", "PlayerList", "Boolean", "Integer", "Color", "String", "Position", "Offset", "Any"];
|
|
|
|
// Evaluator return types
|
|
local EvaluatorReturnTypes = {
|
|
Action = C4V_Nil,
|
|
Object = C4V_C4Object,
|
|
ObjectList = [C4V_C4Object],
|
|
Definition = C4V_Def,
|
|
Player = C4V_Int,
|
|
PlayerList = [C4V_Int],
|
|
Boolean = C4V_Bool,
|
|
Integer = C4V_Int,
|
|
String = C4V_String,
|
|
Position = [C4V_Int, 2],
|
|
Offset = [C4V_Int, 2],
|
|
Any = C4V_Nil
|
|
};
|
|
|
|
// Array of specialized object evaluators
|
|
local object_evaluators;
|
|
|
|
func Definition(def)
|
|
{
|
|
// Typed evaluator base definitions
|
|
Evaluator = {};
|
|
Evaluator.Action = { Name="$UserAction$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$None$", Priority=100 } ] };
|
|
Evaluator.Object = { Name="$UserObject$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$None$", Priority=100 } ] };
|
|
Evaluator.ObjectList = { Name="$UserObjectList$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$None$", Priority=100 } ] };
|
|
Evaluator.Definition = { Name="$UserDefinition$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$None$", Priority=100 } ] };
|
|
Evaluator.Player = { Name="$UserPlayer$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$Noone$", Priority=100 } ] };
|
|
Evaluator.PlayerList = { Name="$UserPlayerList$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$Noone$", Priority=100 } ] };
|
|
Evaluator.Boolean = { Name="$UserBoolean$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$None$", Priority=100 } ] };
|
|
Evaluator.Integer = { Name="$UserInteger$", Type="enum", OptionKey="Function", Sorted=true, Options = [ {Name="0", Priority=100 } ] };
|
|
Evaluator.Color = { Name="$UserColor$", Type="enum", OptionKey="Function", Sorted=true, Options = [ {Name="$Default$", Priority=100 } ] };
|
|
Evaluator.String = { Name="$UserString$", Type="enum", OptionKey="Function", Sorted=true, Options = [ {Name="($EmptyString$)", Priority=100 } ] };
|
|
Evaluator.Position = { Name="$UserPosition$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$Here$", Priority=100 } ] };
|
|
Evaluator.Offset = { Name="$UserOffset$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$None$", Priority=100 } ] };
|
|
Evaluator.Any = { Name="$UserAny$", Type="enum", OptionKey="Function", Sorted=true, Options = [ { Name="$None$", Priority=100 } ] };
|
|
EvaluatorCallbacks = {};
|
|
EvaluatorDefs = {};
|
|
// Object constant evaluator may be needed early be evaluators referencing filtered objects
|
|
AddEvaluator("Object", nil, ["$ConstantObject$", ""], "$ConstantObjectHelp$", "object_constant", [def, def.EvalConstant], { Value=nil }, { Type="object", Name="$Value$" });
|
|
// Action evaluators
|
|
AddEvaluator("Action", "$Sequence$", "$Sequence$", "$SequenceHelp$", "sequence", [def, def.EvalAct_Sequence], { Actions=[] }, { Type="proplist", DescendPath="Actions", HideFullName=true, Display="{{Actions}}", EditorProps = {
|
|
Actions = { Name="$Actions$", Type="array", Elements=Evaluator.Action },
|
|
} } );
|
|
AddEvaluator("Action", "$Sequence$", "$Goto$", "$GotoHelp$", "goto", [def, def.EvalAct_Goto], { Index={Function="int_constant", Value=0} }, new Evaluator.Integer { Name="$Index$" }, "Index");
|
|
AddEvaluator("Action", "$Sequence$", "$StopSequence$", "$StopSequenceHelp$", "stop_sequence", [def, def.EvalAct_StopSequence]);
|
|
AddEvaluator("Action", "$Sequence$", "$SuspendSequence$", "$SuspendSequenceHelp$", "suspend_sequence", [def, def.EvalAct_SuspendSequence]);
|
|
AddEvaluator("Action", "$Sequence$", "$Wait$", "$WaitHelp$", "wait", [def, def.EvalAct_Wait], { Time=60 }, { Type="proplist", Display="{{Time}}", EditorProps = {
|
|
Time = { Name="$Time$", Type="int", Min=1 }
|
|
} } );
|
|
AddEvaluator("Action", "$Sequence$", "$WaitForcondition$", "$WaitForConditionHelp$", "wait_condition", [def, def.EvalAct_WaitCondition], { Interval=20 }, { Type="proplist", Display="{{Condition}}", EditorProps = {
|
|
Interval = { Name="$CheckInterval$", Type="int", Min=1 },
|
|
Condition = new Evaluator.Boolean { Name="$Condition$", EditorHelp="$WaitConditionHelp$", Priority=60 }
|
|
} } );
|
|
AddEvaluator("Action", "$Ambience$", "$Sound$", "$SoundHelp$", "sound", [def, def.EvalAct_Sound], { Pitch={Function="int_constant", Value=0}, Volume={Function="int_constant", Value=100}, TargetPlayers={Function="all_players"} }, { Type="proplist", Display="{{Sound}}", EditorProps = {
|
|
Sound = { Name="$SoundName$", EditorHelp="$SoundNameHelp$", Type="sound", AllowEditing=true, Priority=100 },
|
|
Pitch = new Evaluator.Integer { Name="$SoundPitch$", EditorHelp="$SoundPitchHelp$" },
|
|
Volume = new Evaluator.Integer { Name="$SoundVolume$", EditorHelp="$SoundVolumeHelp$" },
|
|
Loop = { Name="$SoundLoop$", EditorHelp="$SoundLoopHelp$", Type="enum", Options=[
|
|
{ Name="$SoundLoopNone$" },
|
|
{ Name="$SoundLoopOn$", Value=+1 },
|
|
{ Name="$SoundLoopOff$", Value=-1 }
|
|
] },
|
|
TargetPlayers = new Evaluator.PlayerList { EditorHelp="$SoundTargetPlayersHelp$" },
|
|
SourceObject = new Evaluator.Object { Name="$SoundSourceObject$", EditorHelp="$SoundSourceObjectHelp$", EmptyName="$Global$" }
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$CreateObject$", "$CreateObjectHelp$", "create_object", [def, def.EvalAct_CreateObject], { SpeedX={Function="int_constant", Value=0},SpeedY={Function="int_constant", Value=0},SpeedR={Function="int_constant", Value=0},Rotation={Function="int_constant", Value=0} }, { Type="proplist", Display="{{ID}}", EditorProps = {
|
|
ID = new Evaluator.Definition { EditorHelp="$CreateObjectDefinitionHelp$", Priority=100 },
|
|
Position = new Evaluator.Position { EditorHelp="$CreateObjectPositionHelp$" },
|
|
CreateAbove = { Name="$CreateObjectCreationOffset$", EditorHelp="$CreateObjectCreationOffsetHelp$", Type="enum", Options=[
|
|
{ Name="$Center$" },
|
|
{ Name="$Bottom$", Value=true }
|
|
]},
|
|
Owner = new Evaluator.Player { Name="$Owner$", EditorHelp="$CreateObjectOwnerHelp$" },
|
|
Container = new Evaluator.Object { Name="$Container$", EditorHelp="$CreateObjectContainerHelp$" },
|
|
SpeedX = new Evaluator.Integer { Name="$SpeedX$", EditorHelp="$CreateObjectSpeedXHelp$" },
|
|
SpeedY = new Evaluator.Integer { Name="$SpeedY$", EditorHelp="$CreateObjectSpeedYHelp$" },
|
|
Rotation = new Evaluator.Integer { Name="$Rotation$", EditorHelp="$CreateObjectRotationHelp$" },
|
|
SpeedR = new Evaluator.Integer { Name="$SpeedR$", EditorHelp="$CreateObjectSpeedRHelp$" }
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$CastObjects$", "$CastObjectsHelp$", "cast_objects", [def, def.EvalAct_CastObjects], { Amount={Function="int_constant", Value=8},Speed={Function="int_constant", Value=20},AngleDeviation={Function="int_constant", Value=360} }, { Type="proplist", Display="{{Amount}}x{{ID}}", EditorProps = {
|
|
ID = new Evaluator.Definition { EditorHelp="$CastObjectsDefinitionHelp$", Priority=100 },
|
|
Position = new Evaluator.Position { EditorHelp="$CastObjectsPositionHelp$" },
|
|
Amount = new Evaluator.Integer { Name="$Amount$", EditorHelp="$CastObjectsAmountHelp$" },
|
|
Speed = new Evaluator.Integer { Name="$Speed$", EditorHelp="$CastObjectsSpeedHelp$" },
|
|
MeanAngle = new Evaluator.Integer { Name="$MeanAngle$", EditorHelp="$CastObjectsMeanAngleHelp$" },
|
|
AngleDeviation = new Evaluator.Integer { Name="$AngleDeviation$", EditorHelp="$CastObjectsAngleDeviationHelp$" },
|
|
Owner = new Evaluator.Player { Name="$Owner$", EditorHelp="$CastObjectsOwnerHelp$" }
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$RemoveObject$", "$RemoveObjectHelp$", "remove_object", [def, def.EvalAct_RemoveObject], { }, { Type="proplist", Display="{{Object}}", EditorProps = {
|
|
Object = new Evaluator.Object { EditorHelp="$RemoveObjectObject$", Priority=100 },
|
|
EjectContents = { Name="$EjectContents$", EditorHelp="$EjectContentsHelp$", Type="enum", Options=[
|
|
{ Name="$EjectContentsNo$" },
|
|
{ Name="$EjectContentsYes$", Value=true }
|
|
] },
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$SetPosition$", "$SetPositionHelp$", "set_position", [def, def.EvalAct_SetPosition], { Object={ Function="triggering_clonk" }, Position={ Function="position_constant_rel" } }, { Type="proplist", Display="({{Object}}->{{Position}})", EditorProps = {
|
|
Object = new Evaluator.Object { Name="$Object$", EditorHelp="$SetPositionObjectHelp$" },
|
|
Position = new Evaluator.Position { Name="$Position$", EditorHelp="$SetPositionPositionHelp$" }
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$Fling$", "$FlingHelp$", "fling", [def, def.EvalAct_Fling], { Object={ Function="triggering_clonk" }, SpeedX={ Function="int_constant", Value=0 }, SpeedY={ Function="int_constant", Value=-20 }, AddSpeed={ Function="bool_constant", Value=false } }, { Type="proplist", Display="({{Object}}, {{SpeedX}}, {{SpeedY}})", EditorProps = {
|
|
Object = new Evaluator.Object { Name="$Object$", EditorHelp="$FlingObjectHelp$" },
|
|
SpeedX = new Evaluator.Integer { Name="$SpeedX$", EditorHelp="$FlingSpeedXHelp$" },
|
|
SpeedY = new Evaluator.Integer { Name="$SpeedY$", EditorHelp="$FlingSpeedYHelp$" },
|
|
AddSpeed = new Evaluator.Boolean { Name="$AddSpeedY$", EditorHelp="$FlingAddSpeedHelp$" },
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$EnterObject$", "$EnterObjectHelp$", "enter_object", [def, def.EvalAct_EnterObject], { }, { Type="proplist", Display="{{Object}} -> {{Container}}", EditorProps = {
|
|
Object = new Evaluator.Object { EditorHelp="$EnterObjectObjectHelp$", Priority=90 },
|
|
Container = new Evaluator.Object { Name="$Container$", EditorHelp="$EnterObjectContainerHelp$", Priority=80 },
|
|
CollectionCheck = { Name="$CollectionCheck$", EditorHelp="$CollectionCheckHelp$", Type="enum", Options=[
|
|
{ Name="$CollectionCheckIgnore$" },
|
|
{ Name="$CollectionCheckCheck$", Value="check" },
|
|
{ Name="$CollectionCheckExit$", Value="exit" }
|
|
] }
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$ExitObject$", "$ExitObjectHelp$", "exit_object", [def, def.EvalAct_ExitObject], { }, new Evaluator.Object { }, "Object");
|
|
AddEvaluator("Action", "$Object$", "$SetVisibility$", "$SetVisibilityHelp$", "set_visibility", [def, def.EvalAct_SetVisibility], { Object={ Function="triggering_clonk" }, Visibility=VIS_All }, { Type="proplist", Display="({{Object}}, {{Visibility}})", EditorProps = {
|
|
Object = new Evaluator.Object { Name="$Object$" },
|
|
Visibility = { Name="$Visibility$", Type="enum", Options = [{ Name="$Visible$", Value=VIS_All }, { Name="$Invisible$", Value=VIS_None }] }
|
|
} } );
|
|
AddEvaluator("Action", "$Object$", "$SetVincibility$", "$SetVincibilityHelp$", "set_vincibility", [def, def.EvalAct_SetVincibility], { Object={ Function="triggering_clonk" }, Vincibility=false }, { Type="proplist", Display="({{Object}}, {{Vincibility}})", EditorProps = {
|
|
Object = new Evaluator.Object { Name="$Object$" },
|
|
Vincibility = { Name="$Vincibility$", Type="enum", Options = [{ Name="$Invincible$", Value=false }, { Name="$Vincible$", Value=true }] }
|
|
} } );
|
|
AddEvaluator("Action", "Clonk", "$DoEnergy$", "$DoEnergyHelp$", "do_energy", [def, def.EvalAct_ObjectCallInt, Global.DoEnergy], { Object={ Function="triggering_clonk" } }, { Type="proplist", Display="({{Object}}, {{Value}})", EditorProps = {
|
|
Object = new Evaluator.Object { Name="$Object$", EditorHelp="$DoEnergyObjectHelp$" },
|
|
Value = new Evaluator.Integer { Name="$ValueChange$", EditorHelp="$DoEnergyValueChangeHelp$" }
|
|
} } );
|
|
AddEvaluator("Action", "Clonk", "$SetDirection$", "$SetDirectionHelp$", "set_direction", [def, def.EvalAct_SetDirection], { Object={ Function="triggering_clonk" }, Direction=DIR_Left }, { Type="proplist", Display="({{Object}}, {{Direction}})", EditorProps = {
|
|
Object = GetObjectEvaluator("IsClonk", "$Clonk$"),
|
|
Direction = { Name="$Direction$", Type="enum", Options=[{ Name="$Left$", Value=DIR_Left }, { Name="$Right$", Value=DIR_Right }] }
|
|
} } );
|
|
AddEvaluator("Action", "Ambience", "$CastParticles$", "$CastParticlesHelp$", "cast_particles", [def, def.EvalAct_CastParticles], {
|
|
Name="StarFlash",
|
|
Amount={Function="int_constant", Value=8},
|
|
Speed={Function="int_constant", Value=20},
|
|
Lifetime={Function="int_constant", Value=100},
|
|
Size={Function="int_constant", Value=10},
|
|
SizeEnd={Function="int_constant", Value=1},
|
|
Color={Function="color_constant", Value=0xffff},
|
|
BlitMode=0,
|
|
Gravity={Function="int_constant", Value=100},
|
|
FadeOut=true,
|
|
CollisionFunc="bounce"
|
|
}, { Type="proplist", Display="{{Amount}}x{{Name}}", EditorProps = {
|
|
Name = { Name="$ParticleName$", EditorHelp="$ParticleNameHelp$", Type="enum", Priority=50, Sorted=true, Options = [
|
|
{ Name="$Dust$", Value="Dust" },
|
|
{ Name="$Flash$", Value="Flash" },
|
|
{ Name="$Magic$", Value="Magic" },
|
|
{ Name="$Smoke$", Value="Smoke" },
|
|
{ Name="$Sphere$", Value="Sphere" },
|
|
{ Name="$StarFlash$", Value="StarFlash" },
|
|
{ Name="$StarSpark$", Value="StarSpark" },
|
|
{ Name="$Fire$", Value="MagicFire" },
|
|
{ Name="$Ring$", Value="MagicRing" }
|
|
] },
|
|
Position = new Evaluator.Position { EditorHelp="$CastObjectsPositionHelp$" },
|
|
Amount = new Evaluator.Integer { Name="$Amount$", EditorHelp="$CastParticlesAmountHelp$" },
|
|
Speed = new Evaluator.Integer { Name="$Speed$", EditorHelp="$CastParticlesSpeedHelp$" },
|
|
Lifetime = new Evaluator.Integer { Name="$Lifetime$", EditorHelp="$CastParticlesLifetimeHelp$" },
|
|
Size = new Evaluator.Integer { Name="$Size$", EditorHelp="$CastParticlesSizeHelp$" },
|
|
SizeEnd = new Evaluator.Integer { Name="$SizeEnd$", EditorHelp="$CastParticlesSizeEndHelp$" },
|
|
Color = new Evaluator.Color { Name="$Color$", EditorHelp="$CastParticlesColorHelp$" },
|
|
BlitMode = { Name="$BlitMode$", EditorHelp="$ParticleBlitModeHelp$", Type="enum", Options = [
|
|
{ Name="$Normal$", Value=0 },
|
|
{ Name="$Additive$", Value=GFX_BLIT_Additive },
|
|
{ Name="$Mod2$", Value=GFX_BLIT_Mod2 }
|
|
] },
|
|
Gravity = new Evaluator.Integer { Name="$Gravity$", EditorHelp="$ParticleGravityHelp$" },
|
|
FadeOut = { Name="$FadeOut$", EditorHelp="$ParticleFadeOutHelp$", Type="bool" },
|
|
CollisionFunc = { Name="$CollisionFunc$", EditorHelp="$ParticleCollisionFuncHelp$", Type="enum", Options = [
|
|
{ Value="pass", Name="$Pass$" },
|
|
{ Value="stop", Name="$Stop$" },
|
|
{ Value="bounce", Name="$Bounce$" },
|
|
{ Value="die", Name="$Die$" }
|
|
] }
|
|
} } );
|
|
AddEvaluator("Action", "$Player$", "$DoWealth$", "$DoWealthHelp$", "do_wealth", [def, def.EvalAct_DoWealth], { Player={ Function="triggering_player" }, DoSound={ Function="bool_constant", Value=true } }, { Type="proplist", Display="({{Player}}, {{Change}})", EditorProps = {
|
|
Player = Evaluator.Player,
|
|
Change = new Evaluator.Integer { Name="$Change$", EditorHelp="$DoWealthChangeHelp$" },
|
|
DoSound = new Evaluator.Boolean { Name="$Sound$", EditorHelp="$DoWealthSoundHelp$", Priority=-1 }
|
|
} } );
|
|
AddEvaluator("Action", "$Player$", "$PlrKnowledge$", "$PlrKnowledgeHelp$", "plr_knowledge", [def, def.EvalAct_PlrKnowledge], { Players={ Function="triggering_player_list" }, ID={ Function="def_constant" } }, { Type="proplist", Display="({{Players}}, {{ID}})", EditorProps = {
|
|
Players = Evaluator.PlayerList,
|
|
ID = Evaluator.Definition
|
|
} } );
|
|
AddEvaluator("Action", "$Player$", "$SetPlrView$", "$SetPlrViewHelp$", "plr_view", [def, def.EvalAct_PlrView], { Players={ Function="triggering_player_list" }, Target={ Function="action_object" } }, { Type="proplist", Display="({{Players}}, {{Target}})", EditorProps = {
|
|
Players = Evaluator.PlayerList,
|
|
Target = new Evaluator.Object { Name="$Target$", EditorHelp="$PlrViewTargetHelp$" },
|
|
Immediate = { Name="$ScrollMode$", EditorHelp="$SetPlrViewScrollModeHelp$", Type="enum", Priority=-10, Options = [
|
|
{ Name="$Smooth$" },
|
|
{ Value=true, Name="$Immediate$" }
|
|
] }
|
|
} } );
|
|
AddEvaluator("Action", "$Script$", "$ConditionalAction$", "$ConditionalActionHelp$", "if", [def, def.EvalAct_If], { }, { Type="proplist", Display="if({{Condition}}) {{TrueEvaluator}} else {{FalseEvaluator}}", EditorProps = {
|
|
Condition = new Evaluator.Boolean { Name="$Condition$", EditorHelp="$IfConditionHelp$", Priority=60 },
|
|
TrueEvaluator = new Evaluator.Action { Name="$TrueEvaluator$", EditorHelp="$TrueEvaluatorHelp$", Priority=50 },
|
|
FalseEvaluator = new Evaluator.Action { Name="$FalseEvaluator$", EditorHelp="$FalseEvaluatorHelp$", Priority=30 }
|
|
} } );
|
|
AddEvaluator("Action", "$Script$", "$SetVariable$", "$SetVariableHelp$", "set_variable", [def, def.EvalAct_SetVariable], { VariableName={ Function="string_constant", Value="" } }, { Type="proplist", Display="{{Context}}::{{VariableName}}={{Value}}", EditorProps = {
|
|
Context = new Evaluator.Object { Name="$Context$", EditorHelp="$VariableContextHelp$", EmptyName="$Global$" },
|
|
VariableName = new Evaluator.String { Name="$VariableName$", EditorHelp="$VariableNameHelp$" },
|
|
Value = new Evaluator.Any { Name="$Value$", EditorHelp="$SetVariableValueHelp$" }
|
|
} } );
|
|
AddEvaluator("Action", "$Script$", "$ForInteger$", "$ForIntegerHelp$", "for_int", [def, def.EvalAct_For, def.EvalAct_For_IntRange], { Start={ Function="int_constant", Value=1}, End={ Function="int_constant", Value=10}, Step={ Function="int_constant", Value=1} }, { Type="proplist", HideFullName=true, Display="for({{Start}}:{{Step}}:{{End}}) {{Action}}", EditorProps = {
|
|
Action = new Evaluator.Action { Name="$UserAction$", EditorHelp="$ForActionHelp$", Priority=100 },
|
|
Start = new Evaluator.Integer { Name="$Start$", EditorHelp="$ForStartHelp$", Priority=90 },
|
|
End = new Evaluator.Integer { Name="$End$", EditorHelp="$ForEndHelp$", Priority=80 },
|
|
Step = new Evaluator.Integer { Name="$Step$", EditorHelp="$ForStepHelp$", Priority=70 }
|
|
} } );
|
|
AddEvaluator("Action", "$Script$", "$ForPlayer$", "$ForPlayerHelp$", "for_player", [def, def.EvalAct_For, def.EvalAct_For_PlayerList], { Players={ Function="all_players" } }, { Type="proplist", HideFullName=true, Display="for({{Players}}) {{Action}}", EditorProps = {
|
|
Action = new Evaluator.Action { Name="$UserAction$", EditorHelp="$ForActionHelp$", Priority=100 },
|
|
Players = new Evaluator.PlayerList { EditorHelp="$ForPlayersHelp$" }
|
|
} } );
|
|
AddEvaluator("Action", "$Script$", "$ForObject$", "$ForObjectHelp$", "for_object", [def, def.EvalAct_For, def.EvalAct_For_ObjectList], { }, { Type="proplist", HideFullName=true, Display="for({{Objects}}) {{Action}}", EditorProps = {
|
|
Action = new Evaluator.Action { Name="$UserAction$", EditorHelp="$ForActionHelp$", Priority=100 },
|
|
Objects = new Evaluator.ObjectList { EditorHelp="$ForObjectsHelp$" }
|
|
} } );
|
|
AddEvaluator("Action", "$Script$", "$Log$", "$LogHelp$", "log", [def, def.EvalAct_Log], { }, new Evaluator.String { Name="$LogMessage$", EditorHelp="$LogMessageHelp$" }, "Message");
|
|
AddEvaluator("Action", "$Script$", "$Comment$", "$CommentHelp$", "comment", [def, def.EvalAct_Nop], { Comment="" }, { Name="$Comment$", EditorHelp="$CommentHelp$", Type="string" }, "Comment");
|
|
AddEvaluator("Action", "Game", "$GameOver$", "$GameOverHelp$", "game_over", [def, def.EvalAct_GameOver]);
|
|
// Object evaluators
|
|
AddEvaluator("Object", nil, "$ActionObject$", "$ActionObjectHelp$", "action_object", [def, def.EvalContextValue, "action_object"]);
|
|
AddEvaluator("Object", nil, "$TriggerClonk$", "$TriggerClonkHelp$", "triggering_clonk", [def, def.EvalContextValue, "triggering_clonk"]);
|
|
AddEvaluator("Object", nil, "$TriggerObject$", "$TriggerObjectHelp$", "triggering_object", [def, def.EvalContextValue, "triggering_object"]);
|
|
AddEvaluator("Object", nil, "$IteratedObject$", "$IteratedObjectHelp$", "iterated_object", [def, def.EvalContextValue, "for_object"]);
|
|
AddEvaluator("Object", nil, "$LastCreatedObject$", "$LastCreatedObjectHelp$", "last_created_object", [def, def.EvalContextValue, "last_created_object"]);
|
|
var find_object_in_area_delegate = { Type="proplist", Display="{{ID}}", EditorProps = {
|
|
ID = new Evaluator.Definition { Name="$ID$", EditorHelp="$FindObjectsIDHelp$", EmptyName="$Any$", Priority=51 },
|
|
Area = { Name="$SearchArea$", EditorHelp="$SearchAreaHelp$", Type="enum", OptionKey="Function", Priority=41, Options=[
|
|
{ Name="$SearchAreaWholeMap$", EditorHelp="$SearchAreaWholeMapHelp$" },
|
|
{ Name="$SearchAreaInRect$", EditorHelp="$SearchAreaInRectHelp$", Value={ Function="InRect" }, DefaultValueFunction=def.GetDefaultRect, ValueKey="Area", Delegate={ Type="rect", Name="$Rectangle$", Relative=false, Color=0xffff00 } },
|
|
{ Name="$SearchAreaAtRect$", EditorHelp="$SearchAreaAtRectHelp$", Value={ Function="AtRect" }, DefaultValueFunction=def.GetDefaultRect, ValueKey="Area", Delegate={ Type="rect", Name="$Rectangle$", Relative=false, Color=0xffff80 } },
|
|
{ Name="$SearchAreaCircle$", EditorHelp="$SearchAreaCircleHelp$", Value={ Function="Circle" }, DefaultValueFunction=def.GetDefaultCircle, ValueKey="Area", Delegate={ Type="circle", Name="$Circle$", Relative=false, CanMoveCenter=true, Color=0xff00ff } },
|
|
{ Name="$SearchAreaNearPosition$", EditorHelp="$SearchAreaNearPositionHelp$", Value={ Function="NearPosition", Parameters={Radius=25} }, ValueKey="Parameters", Delegate={ Type="proplist", Display="({{Position}}, {{Radius}})", EditorProps = {
|
|
Position = new Evaluator.Position { EditorHelp="$SearchAreaNearPositionPositionHelp$"},
|
|
Radius = { Type="circle", Relative=true, Name="$Radius$", Color=0xff80ff }
|
|
} } }
|
|
] },
|
|
AllowContained = { Name="$AllowContained$", EditorHelp="$AllowContainedHelp$", Type="bool", Priority=31 }
|
|
} };
|
|
var find_object_in_container_delegate = { Type="proplist", Display="{{ID}} in {{Container}}", EditorProps = {
|
|
ID = new Evaluator.Definition { Name="$ID$", EditorHelp="$FindObjectsIDHelp$", EmptyName="$Any$" },
|
|
Container = new Evaluator.Object { Name="$Container$", EditorHelp="FindObjectsContainerHelp" }
|
|
} };
|
|
AddEvaluator("Object", nil, "$FindObjectInArea$", "$FindObjectInAreaHelp$", "find_object_in_area", [def, def.EvalObjList_FindObjectsInArea, true], {}, find_object_in_area_delegate);
|
|
AddEvaluator("Object", nil, "$FindObjectInContainer$", "$FindObjectInContainerHelp$", "find_object_in_container", [def, def.EvalObjList_FindObjectInContainer], {}, find_object_in_container_delegate);
|
|
// Object list evaluators
|
|
AddEvaluator("ObjectList", nil, "$FindObjectsInArea$", "$FindObjectsInAreaHelp$", "find_objects_in_area", [def, def.EvalObjList_FindObjectsInArea], {}, find_object_in_area_delegate);
|
|
AddEvaluator("ObjectList", nil, "$FindObjectsInContainer$", "$FindObjectsInContainerHelp$", "find_objects_in_container", [def, def.EvalObjList_FindObjectsInContainer], {}, find_object_in_container_delegate);
|
|
// Definition evaluators
|
|
AddEvaluator("Definition", nil, ["$Constant$", ""], "$ConstantHelp$", "def_constant", [def, def.EvalConstant], { Value=nil }, { Type="def", Name="$Value$" });
|
|
AddEvaluator("Definition", nil, "$TypeOfObject$", "$TypeOfObjectHelp$", "type_of_object", [def, def.EvalObjProp, Global.GetID], { }, new Evaluator.Object { }, "Object");
|
|
// Player evaluators
|
|
AddEvaluator("Player", nil, "$TriggeringPlayer$", "$TriggeringPlayerHelp$", "triggering_player", [def, def.EvalContextValue, "triggering_player"]);
|
|
AddEvaluator("Player", nil, "$OwnerOfObject$", "$OwnerOfObjectHelp$", "owner", [def, def.EvalObjProp, Global.GetOwner], { }, new Evaluator.Object { }, "Object");
|
|
AddEvaluator("Player", nil, "$ControllerOfObject$", "$ControllerOfObjectHelp$", "owner", [def, def.EvalObjProp, Global.GetController], { }, new Evaluator.Object { }, "Object");
|
|
AddEvaluator("Player", nil, "$IteratedPlayer$", "$IteratedPlayerHelp$", "iterated_player", [def, def.EvalContextValue, "for_player"]);
|
|
// Player list evaluators
|
|
AddEvaluator("PlayerList", nil, "$TriggeringPlayer$", "$TriggeringPlayerHelp$", "triggering_player_list", [def, def.EvalPlrList_Single, def.EvalPlr_Trigger]);
|
|
AddEvaluator("PlayerList", nil, "$AllPlayers$", "$AllPlayersHelp$", "all_players", [def, def.EvalPlrList_All]);
|
|
// Boolean (condition) evaluators
|
|
AddEvaluator("Boolean", nil, ["$Constant$", ""], "$ConstantHelp$", "bool_constant", [def, def.EvalConstant], { Value=true }, { Type="bool", Name="$Value$" });
|
|
AddEvaluator("Boolean", "$Comparison$", "$CompareInteger$", "$ComparisonHelp$", "compare_int", [def, def.EvalComparison, "Integer"], { }, { Type="proplist", Display="{{LeftOperand}}{{Operator}}{{RightOperand}}", EditorProps = {
|
|
LeftOperand = new Evaluator.Integer { Name="$LeftOperand$", EditorHelp="$LeftOperandHelp$", Priority=44 },
|
|
Operator = { Type="enum", Name="$Operator$", EditorHelp="$OperatorHelp$", Priority=43, Options = [
|
|
{ Name="==", EditorHelp="$EqualHelp$" },
|
|
{ Name="!=", EditorHelp="$NotEqualHelp$", Value="ne" },
|
|
{ Name="<", EditorHelp="$LessThanHelp$", Value="lt" },
|
|
{ Name=">", EditorHelp="$GreaterThanHelp$", Value="gt" },
|
|
{ Name="<=", EditorHelp="$LessOrEqualHelp$", Value="le" },
|
|
{ Name=">=", EditorHelp="$GreaterOrEqualHelp$", Value="ge" }
|
|
] },
|
|
RightOperand = new Evaluator.Integer { Name="$RightOperand$", EditorHelp="$RightOperandHelp$", Priority=42 }
|
|
} } );
|
|
AddEvaluator("Boolean", "$Comparison$", "$CompareBoolean$", "$ComparisonHelp$", "compare_bool", [def, def.EvalComparison, "Boolean"], { }, { Type="proplist", Display="{{LeftOperand}}{{Operator}}{{RightOperand}}", EditorProps = {
|
|
LeftOperand = new Evaluator.Object { Name="$LeftOperand$", EditorHelp="$LeftOperandHelp$", Priority=44 },
|
|
Operator = { Type="enum", Name="$Operator$", EditorHelp="$OperatorHelp$", Priority=43, Options = [
|
|
{ Name="==", EditorHelp="$EqualHelp$" },
|
|
{ Name="!=", EditorHelp="$NotEqualHelp$", Value="ne" },
|
|
] },
|
|
RightOperand = new Evaluator.Object { Name="$RightOperand$", EditorHelp="$RightOperandHelp$", Priority=42 }
|
|
} } );
|
|
AddEvaluator("Boolean", "$Comparison$", "$CompareObject$", "$ComparisonHelp$", "compare_object", [def, def.EvalComparison, "Object"], { }, { Type="proplist", Display="{{LeftOperand}}{{Operator}}{{RightOperand}}", EditorProps = {
|
|
LeftOperand = new Evaluator.Object { Name="$LeftOperand$", EditorHelp="$LeftOperandHelp$", Priority=44 },
|
|
Operator = { Type="enum", Name="$Operator$", EditorHelp="$OperatorHelp$", Priority=43, Options = [
|
|
{ Name="==", EditorHelp="$EqualHelp$" },
|
|
{ Name="!=", EditorHelp="$NotEqualHelp$", Value="ne" },
|
|
] },
|
|
RightOperand = new Evaluator.Object { Name="$RightOperand$", EditorHelp="$RightOperandHelp$", Priority=42 }
|
|
} } );
|
|
AddEvaluator("Boolean", "$Comparison$", "$CompareString$", "$ComparisonHelp$", "compare_string", [def, def.EvalComparison, "String"], { }, { Type="proplist", Display="{{LeftOperand}}{{Operator}}{{RightOperand}}", EditorProps = {
|
|
LeftOperand = new Evaluator.String { Name="$LeftOperand$", EditorHelp="$LeftOperandHelp$", Priority=44 },
|
|
Operator = { Type="enum", Name="$Operator$", EditorHelp="$OperatorHelp$", Priority=43, Options = [
|
|
{ Name="==", EditorHelp="$EqualHelp$" },
|
|
{ Name="!=", EditorHelp="$NotEqualHelp$", Value="ne" },
|
|
] },
|
|
RightOperand = new Evaluator.String { Name="$RightOperand$", EditorHelp="$RightOperandHelp$", Priority=42 }
|
|
} } );
|
|
AddEvaluator("Boolean", "$Comparison$", "$CompareDefinition$", "$ComparisonHelp$", "compare_definition", [def, def.EvalComparison, "Definition"], { }, { Type="proplist", Display="{{LeftOperand}}{{Operator}}{{RightOperand}}", EditorProps = {
|
|
LeftOperand = new Evaluator.Definition { Name="$LeftOperand$", EditorHelp="$LeftOperandHelp$", Priority=44 },
|
|
Operator = { Type="enum", Name="$Operator$", EditorHelp="$OperatorHelp$", Priority=43, Options = [
|
|
{ Name="==", EditorHelp="$EqualHelp$" },
|
|
{ Name="!=", EditorHelp="$NotEqualHelp$", Value="ne" },
|
|
] },
|
|
RightOperand = new Evaluator.Definition { Name="$RightOperand$", EditorHelp="$RightOperandHelp$", Priority=42 }
|
|
} } );
|
|
AddEvaluator("Boolean", "$Comparison$", "$ComparePlayer$", "$ComparisonHelp$", "compare_player", [def, def.EvalComparison, "Player"], { }, { Type="proplist", Display="{{LeftOperand}}{{Operator}}{{RightOperand}}", EditorProps = {
|
|
LeftOperand = new Evaluator.Player { Name="$LeftOperand$", EditorHelp="$LeftOperandHelp$", Priority=44 },
|
|
Operator = { Type="enum", Name="$Operator$", EditorHelp="$OperatorHelp$", Priority=43, Options = [
|
|
{ Name="==", EditorHelp="$EqualHelp$" },
|
|
{ Name="!=", EditorHelp="$NotEqualHelp$", Value="ne" },
|
|
] },
|
|
RightOperand = new Evaluator.Player { Name="$RightOperand$", EditorHelp="$RightOperandHelp$", Priority=42 }
|
|
} } );
|
|
AddEvaluator("Boolean", "$Logic$", "$Not$", "$NotHelp$", "not", [def, def.EvalBool_Not], { }, new Evaluator.Boolean { }, "Operand");
|
|
AddEvaluator("Boolean", "$Logic$", "$And$", "$AndHelp$", "and", [def, def.EvalBool_And], { Operands=[] }, { Type="proplist", DescendPath="Operands", Display="{{Operands}}", EditorProps = {
|
|
Operands = { Name="$Operands$", Type="array", Elements=Evaluator.Boolean }
|
|
} } );
|
|
AddEvaluator("Boolean", "$Logic$", "$Or$", "$OrHelp$", "or", [def, def.EvalBool_Or], { Operands=[] }, { Type="proplist", DescendPath="Operands", Display="{{Operands}}", EditorProps = {
|
|
Operands = { Name="$Operands$", Type="array", Elements=Evaluator.Boolean }
|
|
} } );
|
|
AddEvaluator("Boolean", nil, "$ObjectExists$", "$ObjectExistsHelp$", "object_exists", [def, def.EvalBool_ObjectExists], { }, new Evaluator.Object { }, "Object");
|
|
AddEvaluator("Boolean", nil, "$ObjectAlive$", "$ObjectAliveHelp$", "object_alive", [def, def.EvalBool_ObjectAlive], { }, new Evaluator.Object { }, "Object");
|
|
// Integer evaluators
|
|
AddEvaluator("Integer", nil, ["$Constant$", ""], "$ConstantHelp$", "int_constant", [def, def.EvalConstant], { Value=0 }, { Type="int", Name="$Value$" });
|
|
var arithmetic_delegate = { Type="proplist", HideFullName=true, EditorProps = {
|
|
LeftOperand = new Evaluator.Integer { Name="$LeftOperand$", EditorHelp="$LeftArithmeticOperandHelp$", Priority=44 },
|
|
RightOperand = new Evaluator.Integer { Name="$RightOperand$", EditorHelp="$RightArithmeticOperandHelp$", Priority=42 }
|
|
} };
|
|
AddEvaluator("Integer", "$Arithmetic$", "$Sum$ (+)", "$SumHelp$", "add", [def, def.EvalInt_Add], { }, new arithmetic_delegate { Display="{{LeftOperand}}+{{RightOperand}}" });
|
|
AddEvaluator("Integer", "$Arithmetic$", "$Sub$ (-)", "$SumHelp$", "subtract", [def, def.EvalInt_Sub], { }, new arithmetic_delegate { Display="{{LeftOperand}}-{{RightOperand}}" });
|
|
AddEvaluator("Integer", "$Arithmetic$", "$Mul$ (*)", "$MulHelp$", "multiply", [def, def.EvalInt_Mul], { }, new arithmetic_delegate { Display="{{LeftOperand}}*{{RightOperand}}" });
|
|
AddEvaluator("Integer", "$Arithmetic$", "$Div$ (/)", "$DivHelp$", "divide", [def, def.EvalInt_Div], { }, new arithmetic_delegate { Display="{{LeftOperand}}/{{RightOperand}}" });
|
|
AddEvaluator("Integer", "$Arithmetic$", "$Mod$ (%)", "$ModHelp$", "modulo", [def, def.EvalInt_Mod], { }, new arithmetic_delegate { Display="{{LeftOperand}}%{{RightOperand}}" });
|
|
AddEvaluator("Integer", nil, "$Random$", "$RandomIntHelp$", "int_random", [def, def.EvalIntRandom], { Min={Function="int_constant", Value=0}, Max={Function="int_constant", Value=99} }, { Type="proplist", HideFullName=true, Display="Rnd({{Min}}..{{Max}})", EditorProps = {
|
|
Min = new Evaluator.Integer { Name="$Min$", EditorHelp="$RandomMinHelp$", Priority=51 },
|
|
Max = new Evaluator.Integer { Name="$Max$", EditorHelp="$RandomMaxHelp$", Priority=21 }
|
|
} } );
|
|
AddEvaluator("Integer", nil, "$Distance$", "$DistanceHelp$", "distance", [def, def.EvalInt_Distance], { }, { Type="proplist", HideFullName=true, Display="d({{PositionA}}..{{PositionB}})", EditorProps = {
|
|
PositionA = new Evaluator.Position { Name="$PositionA$", EditorHelp="$PositionAHelp$" },
|
|
PositionB = new Evaluator.Position { Name="$PositionB$", EditorHelp="$PositionBHelp$" }
|
|
} } );
|
|
AddEvaluator("Integer", nil, "$NumberOfObjects$", "$NumberOfObjectsHelp$", "object_count", [def, def.EvalCount, "ObjectList"], { }, new Evaluator.ObjectList { }, "Array");
|
|
AddEvaluator("Integer", nil, "$NumberOfPlayers$", "$NumberOfPlayersHelp$", "player_count", [def, def.EvalCount, "PlayerList"], { }, new Evaluator.PlayerList { }, "Array");
|
|
AddEvaluator("Integer", nil, "$PlayerWealth$", "$PlayerWealthHelp$", "player_wealth", [def, def.EvalInt_Wealth], { }, new Evaluator.Player { }, "Player");
|
|
AddEvaluator("Integer", nil, "$ClonkEnergy$", "$ClonkEnergyHelp$", "clonk_energy", [def, def.EvalObjProp, Global.GetEnergy], { }, GetObjectEvaluator("IsClonk", "$Clonk$"), "Object");
|
|
AddEvaluator("Integer", nil, "$ObjectMass$", "$ObjectMassHelp$", "object_mass", [def, def.EvalObjProp, Global.GetMass], { }, new Evaluator.Object { }, "Object");
|
|
AddEvaluator("Integer", nil, "$ObjectSpeed$", "$ObjectSpeedHelp$", "object_speed", [def, def.EvalObjProp, Global.GetSpeed], { }, new Evaluator.Object { }, "Object");
|
|
AddEvaluator("Integer", nil, "$PositionX$", "$PositionXHelp$", "position_x", [def, def.EvalInt_PosCoord, 0], { }, new Evaluator.Position { }, "Position");
|
|
AddEvaluator("Integer", nil, "$PositionY$", "$PositionYHelp$", "position_y", [def, def.EvalInt_PosCoord, 1], { }, new Evaluator.Position { }, "Position");
|
|
AddEvaluator("Integer", nil, "$IteratedInteger$", "$IteratedIntegerHelp$", "iterated_int", [def, def.EvalContextValue, "for_int"]);
|
|
// String evaluators
|
|
AddEvaluator("String", nil, ["$Constant$", ""], "$ConstantHelp$", "string_constant", [def, def.EvalStringConstant], { Value="" }, { Type="string", Name="$Value$", Translatable=true });
|
|
AddEvaluator("String", nil, ["$ValueToString$", ""], "$ValueToStringHelp$", "value_to_string", [def, def.EvalStr_ValueToString], { }, new Evaluator.Any { });
|
|
AddEvaluator("String", nil, "$Concat$", "$ConcatHelp$", "string_concat", [def, def.EvalStr_Concat], { Substrings=[] }, { Type="proplist", HideFullName=true, DescendPath="Substrings", Display="{{Substrings}}", EditorProps = {
|
|
Substrings = { Name="$Substrings$", Type="array", Elements=Evaluator.String }
|
|
} } );
|
|
// Color evaluators
|
|
AddEvaluator("Color", nil, ["$Constant$", ""], "$ConstantHelp$", "color_constant", [def, def.EvalConstant], { Value=0xffffff }, { Type="color", Name="$Value$" });
|
|
AddEvaluator("Color", nil, "$RandomColor$", "$RandomColorHelp$", "random_color", [def, def.EvalClr_Random], { ColorA={ Function="color_constant", Value=0 }, ColorB={ Function="color_constant", Value=0xffffff } }, { Type="proplist", Display="({{ColorA}}..{{ColorB}})", EditorProps = {
|
|
ColorA = new Evaluator.Color { Name="$ColorA$" },
|
|
ColorB = new Evaluator.Color { Name="$ColorB$" }
|
|
} } );
|
|
AddEvaluator("Color", nil, "$PlayerColor$", "$PlayerColorHelp$", "player_color", [def, def.EvalClr_PlayerColor], { Player={ Function="triggering_player" } }, new Evaluator.Player { }, "Player");
|
|
AddEvaluator("Color", nil, "$RGB$", "$RGBHelp$", "rgb_color", [def, def.EvalClr_RGB], { R={ Function="int_constant", Value=255 }, G={ Function="int_constant", Value=255 }, B={ Function="int_constant", Value=255 } }, { Type="proplist", Display="({{R}}, {{G}}, {{B}})", EditorProps = {
|
|
R = new Evaluator.Integer { Name="$Red$", Priority=51 },
|
|
G = new Evaluator.Integer { Name="$Green$", Priority=41 },
|
|
B = new Evaluator.Integer { Name="$Blue$", Priority=31 }
|
|
} } );
|
|
// Position evaluators
|
|
AddEvaluator("Position", nil, ["$ConstantPositionAbsolute$", ""], "$ConstantPositionAbsoluteHelp$", "position_constant", [def, def.EvalConstant], def.GetDefaultPosition, { Type="point", Name="$Position$", Relative=false, Color=0xff2000 });
|
|
AddEvaluator("Position", nil, ["$ConstantPositionRelative$", "+"], "$ConstantPositionRelativeHelp$", "position_constant_rel", [def, def.EvalPositionRelative], { Value=[0,0] }, { Type="point", Name="$Position$", Relative=true, Color=0xff0050 });
|
|
AddEvaluator("Position", nil, "$Coordinates$", "$CoordinatesHelp$", "position_coordinates", [def, def.EvalCoordinates], def.GetDefaultCoordinates, { Type="proplist", HideFullName=true, Display="({{X}},{{Y}})", EditorProps = {
|
|
X = new Evaluator.Integer { Name="X", EditorHelp="$PosXHelp$" },
|
|
Y = new Evaluator.Integer { Name="Y", EditorHelp="$PosYHelp$" }
|
|
} } );
|
|
AddEvaluator("Position", nil, "$PositionOffset$", "$PositionOffsetHelp$", "position_offset", [def, def.EvalPositionOffset], { }, { Type="proplist", HideFullName=true, Display="{{Position}}+{{Offset}}", EditorProps = {
|
|
Position = new Evaluator.Position { EditorHelp="$PositionOffsetPositionHelp$", Priority=51 },
|
|
Offset = new Evaluator.Offset { EditorHelp="$PositionOffsetOffsetHelp$", Priority=21 }
|
|
} } );
|
|
AddEvaluator("Position", nil, "$ObjectPosition$", "$ObjectPositionHelp$", "object_position", [def, def.EvalPositionObject], { Object={Function="triggering_object"} }, new Evaluator.Object { EditorHelp="$ObjectPositionObjectHelp$" }, "Object");
|
|
AddEvaluator("Position", nil, "$LastUsePosition$", "$LastUsePositionHelp$", "use_position", [def, def.EvalPos_LastUse]);
|
|
AddEvaluator("Position", "$RandomPosition$", "$RandomRectAbs$", "$RandomRectAbsHelp$", "random_pos_rect_abs", [def, def.EvalPos_RandomRect, false], def.GetDefaultRect, { Type="rect", Name="$Rectangle$", Relative=false, Color=0xffff00 }, "Area");
|
|
AddEvaluator("Position", "$RandomPosition$", "$RandomRectRel$", "$RandomRectRelHelp$", "random_pos_rect_rel", [def, def.EvalPos_RandomRect, true], { Area=[-30,-30,60,60] }, { Type="rect", Name="$Rectangle$", Relative=true, Color=0x00ffff }, "Area");
|
|
AddEvaluator("Position", "$RandomPosition$", "$RandomCircleAbs$", "$RandomCircleAbsHelp$", "random_pos_circle_abs", [def, def.EvalPos_RandomCircle, false], def.GetDefaultCircle, { Type="circle", Name="$Circle$", Relative=false, CanMoveCenter=true, Color=0xff00ff }, "Area");
|
|
AddEvaluator("Position", "$RandomPosition$", "$RandomCircleRel$", "$RandomCircleRelHelp$", "random_pos_circle_rel", [def, def.EvalPos_RandomCircle, true], { Area=[50,0,0] }, { Type="circle", Name="$Circle$", Relative=true, CanMoveCenter=true, Color=0xa000a0 }, "Area");
|
|
// Offset evaluators
|
|
AddEvaluator("Offset", nil, ["$ConstantOffsetRelative$", ""], "$ConstantOffsetRelativeHelp$", "offset_constant", [def, def.EvalConstant], { Value=[0,0] }, { Type="point", Name="$Position$", Relative=true, Color=0xff30ff });
|
|
AddEvaluator("Offset", nil, ["$Coordinates$", ""], "$CoordinatesHelp$", "offset_coordinates", [def, def.EvalCoordinates], { Value={X=0,Y=0} }, { Type="proplist", HideFullName=true, Display="({{X}},{{Y}})", EditorProps = {
|
|
X = new Evaluator.Integer { Name="X", EditorHelp="$OffXHelp$" },
|
|
Y = new Evaluator.Integer { Name="Y", EditorHelp="$OffYHelp$" },
|
|
} } );
|
|
AddEvaluator("Offset", nil, "$AddOffsets$", "$AddOffsetsHelp$", "add_offsets", [def, def.EvalOffsetAdd], { }, { Type="proplist", HideFullName=true, Display="{{Offset1}}+{{Offset2}}", EditorProps = {
|
|
Offset1 = new Evaluator.Offset { EditorHelp="$AddOffsetOffsetHelp$" },
|
|
Offset2 = new Evaluator.Offset { EditorHelp="$AddOffsetOffsetHelp$" }
|
|
} } );
|
|
AddEvaluator("Offset", nil, "$DiffPositions$", "$DiffPositionsHelp$", "diff_positions", [def, def.EvalOffsetDiff], { }, { Type="proplist", HideFullName=true, Display="{{PositionB}}-{{PositionA}}", EditorProps = {
|
|
PositionA = new Evaluator.Position { Name="$PositionA$", EditorHelp="$PositionAHelp$" },
|
|
PositionB = new Evaluator.Position { Name="$PositionB$", EditorHelp="$PositionBHelp$" }
|
|
} } );
|
|
AddEvaluator("Offset", nil, "$RandomOffRectRel$", "$RandomRectRelHelp$", "random_off_rect_rel", [def, def.EvalPos_RandomRect, "rect", false], { Area=[-30,-30,60,60] }, { Type="rect", Name="$Rectangle$", Relative=true, Color=0x00ffff }, "Area");
|
|
AddEvaluator("Offset", nil, "$RandomOffCircleRel$", "$RandomCircleRelHelp$", "random_off_circle_rel", [def, def.EvalPos_RandomCircle, "circle", false], { Area=[0,0,50] }, { Type="circle", Name="$Circle$", Relative=true, CanMoveCenter=true, Color=0xa000a0 }, "Area");
|
|
// Script evaluators
|
|
var variable_delegate = { Type="proplist", HideFullName=true, Display="{{Context}}::{{VariableName}}", EditorProps = {
|
|
Context = new Evaluator.Object { Name="$Context$", EditorHelp="$VariableContextHelp$", EmptyName="$Global$" },
|
|
VariableName = new Evaluator.String { Name="$VariableName$", EditorHelp="$VariableNameHelp$", Priority=50 } } };
|
|
for (var eval_type in EvaluatorTypes)
|
|
{
|
|
var data_type = EvaluatorReturnTypes[eval_type];
|
|
var group = nil;
|
|
if (eval_type != "Action")
|
|
{
|
|
AddEvaluator(eval_type, nil, "$Variable$", "$VariableHelp$", Format("%s_variable", eval_type), [def, def.EvalVariable, data_type], { VariableName={ Function="string_constant", Value="" } }, variable_delegate);
|
|
AddEvaluator(eval_type, nil, "$ConditionalValue$", "$ConditionalValueHelp$", Format("%s_conditional", eval_type), [def, def.EvalConditionalValue, eval_type], { }, { Type="proplist", HideFullName=true, Display="{{Condition}} ? {{TrueEvaluator}} : {{FalseEvaluator}}", EditorProps = {
|
|
Condition = new Evaluator.Boolean { Name="$Condition$", EditorHelp="$IfConditionValueHelp$", Priority=60 },
|
|
TrueEvaluator = new Evaluator[eval_type] { Name="$TrueEvaluatorValue$", EditorHelp="$TrueEvaluatorValueHelp$", Priority=50 },
|
|
FalseEvaluator = new Evaluator[eval_type] { Name="$FalseEvaluatorValue$", EditorHelp="$FalseEvaluatorValueHelp$", Priority=30 }
|
|
} } );
|
|
}
|
|
else
|
|
{
|
|
group = "$Script$";
|
|
}
|
|
AddEvaluator(eval_type, group, "$Script$", "$ScriptHelp$", Format("%s_script", eval_type), [def, def.EvalScript, data_type], { }, { Type="proplist", HideFullName=true, Display="{{Context}}::{{Script}}", EditorProps = {
|
|
Context = new Evaluator.Object { Name="$Context$", EditorHelp="$VariableContextHelp$", EmptyName="$Global$" },
|
|
Script = new Evaluator.String { Name="$ScriptCommand$", EditorHelp="$ScriptCommandHelp$" } } });
|
|
}
|
|
// User action editor props
|
|
Prop = Evaluator.Action;
|
|
PropProgressMode = { Name="$UserActionProgressMode$", EditorHelp="$UserActionProgressModeHelp$", Type="enum", Options = [ { Name="$Session$", Value="session" }, { Name="$PerPlayer$", Value="player" }, { Name="$Global$" } ] };
|
|
PropParallel = { Name="$ParallelAction$", EditorHelp="$ParallelActionHelp$", Type="bool" };
|
|
return true;
|
|
}
|
|
|
|
public func GetObjectEvaluator(filter_def, name, help)
|
|
{
|
|
// Create copy of the Evaluator.Object delegate, but with the object_constant proplist replaced by a version with filter_def
|
|
var object_options = Evaluator.Object.Options[:];
|
|
// Need to copy the option Value field to ensure it is owned by the correct parent.
|
|
// Otherwise it would be assigned by reference in the editor
|
|
var const_option = new EvaluatorDefs["object_constant"] { Value = { Function="object_constant", Value=nil } };
|
|
const_option.Delegate = new const_option.Delegate { Filter=filter_def };
|
|
object_options[const_option.OptionIndex] = const_option;
|
|
var new_evaluator = new Evaluator.Object { Name=name, Options=object_options, EditorHelp=help };
|
|
if (!object_evaluators) object_evaluators = [];
|
|
object_evaluators[GetLength(object_evaluators)] = new_evaluator;
|
|
return new_evaluator;
|
|
}
|
|
|
|
private func CopyProplist(p)
|
|
{
|
|
// Create copy of p to ensure unique global reference
|
|
if (GetType(p) != C4V_PropList) return p;
|
|
var r = {};
|
|
for (var k in GetProperties(p)) r[k] = p[k];
|
|
return r;
|
|
}
|
|
|
|
public func AddEvaluator(string eval_type, string group, name, string help, string identifier, callback_data, default_val, proplist delegate, string delegate_storage_key)
|
|
{
|
|
// Add an evaluator for one of the data types. Evaluators allow users to write small action sequences and scripts in the editor using dropdown lists.
|
|
// eval_type: Return type of the evaluator (Action, Object, Boolean, Player, etc. as defined in UserAction.Evaluator)
|
|
// group [optional] Localized name of sub-group for larger enums (i.e. actions)
|
|
// name: Localized name as it appears in the dropdown list of evaluators. May also be an array [name, short_name].
|
|
// identifier: Unique identifier that is used to store this action in savegames and look up the action def. Identifiers must be unique among all data types.
|
|
// callback_data: Array of [definition, definition.Function, parameter (optional)]. Function to be called when this evaluator is called
|
|
// default_val [optional]: Default value to be set when this evaluator is selected. Must be a proplist. Should contain values for all properties in the delegate
|
|
// delegate: Parameters for this evaluator
|
|
// Copy all value evaluations
|
|
if (eval_type != "Action" && eval_type != "Any" && callback_data[1] != UserAction.EvalVariable)
|
|
{
|
|
var any_group;
|
|
if (group) any_group = Format("%s/%s", EvaluatorTypeNames[eval_type], group); else any_group = EvaluatorTypeNames[eval_type];
|
|
AddEvaluator("Any", any_group, name, help, identifier, callback_data, CopyProplist(default_val), delegate, delegate_storage_key);
|
|
}
|
|
// Dissect parameters
|
|
if (group) group = GroupNames[group] ?? group; // resolve localized group name
|
|
var short_name;
|
|
if (GetType(name) == C4V_Array)
|
|
{
|
|
short_name = name[1];
|
|
name = name[0];
|
|
}
|
|
else if (delegate && delegate.HideFullName)
|
|
{
|
|
// Some proplist delegates provide their own display string and need not show the option name
|
|
short_name = "";
|
|
}
|
|
if (!default_val) default_val = {};
|
|
var default_get;
|
|
if (GetType(default_val) == C4V_Function)
|
|
{
|
|
default_get = default_val;
|
|
default_val = Call(default_get, nil, {Function=identifier});
|
|
}
|
|
default_val.Function = identifier;
|
|
var action_def = { Name=name, ShortName=short_name, EditorHelp=help, Group=group, Value=default_val, Delegate=delegate, DefaultValueFunction=default_get }, n;
|
|
if (delegate)
|
|
{
|
|
if (delegate.EditorProps || delegate.Elements)
|
|
{
|
|
// Proplist of array parameter for this evaluator: Descend path title should be name
|
|
delegate.Name = name;
|
|
var child_delegate = delegate;
|
|
if (delegate.DescendPath) child_delegate = delegate.EditorProps[delegate.DescendPath];
|
|
if (!child_delegate.EditorHelp) child_delegate.EditorHelp = help;
|
|
}
|
|
else
|
|
{
|
|
// Any other parameter type: Store in value
|
|
action_def.ValueKey = delegate_storage_key ?? "Value";
|
|
}
|
|
}
|
|
// Constant has higher priority
|
|
if (callback_data[1] == UserAction.EvalConstant)
|
|
{
|
|
action_def.Priority = 50;
|
|
}
|
|
Evaluator[eval_type].Options[n = GetLength(Evaluator[eval_type].Options)] = action_def;
|
|
action_def.OptionIndex = n;
|
|
// Remember lookup table through identifier (ignore duplicates)
|
|
if (eval_type != "Any" || !group)
|
|
{
|
|
EvaluatorCallbacks[identifier] = callback_data;
|
|
EvaluatorDefs[identifier] = action_def;
|
|
}
|
|
// Copy any object evaluators to existing evaluator lists
|
|
if (eval_type == "Object" && object_evaluators)
|
|
for (var obj_eval in object_evaluators)
|
|
obj_eval.Options[GetLength(obj_eval.Options)] = action_def;
|
|
return action_def;
|
|
}
|
|
|
|
public func EvaluateValue(string eval_type, proplist props, proplist context)
|
|
{
|
|
//Log("EvaluateValue %v %v %v", eval_type, props, context);
|
|
if (!props) return nil;
|
|
// Finish any hold-action
|
|
if (context.hold == props)
|
|
{
|
|
context.hold = nil;
|
|
return context.hold_result;
|
|
}
|
|
// Not on hold: Perform evaluation
|
|
var cb = EvaluatorCallbacks[props.Function];
|
|
/*var rval = cb[0]->Call(cb[1], props, context, cb[2]);
|
|
Log("%v <- EvaluateValue %v %v %v", rval, eval_type, props, context);
|
|
return rval;*/
|
|
return cb[0]->Call(cb[1], props, context, cb[2]);
|
|
}
|
|
|
|
public func EvaluateAction(proplist props, object action_object, object triggering_object, int triggering_player, string progress_mode, bool allow_parallel, finish_callback, array position)
|
|
{
|
|
// No action
|
|
if (!props) if (finish_callback) return action_object->Call(finish_callback); else return;
|
|
// Determine context
|
|
var context;
|
|
if (!progress_mode)
|
|
{
|
|
if (!(context = props._context))
|
|
props._context = context = CreateObject(UserAction);
|
|
}
|
|
else if (progress_mode == "player")
|
|
{
|
|
if (!props._contexts) props._contexts = [];
|
|
var plr_id = GetPlayerID(triggering_player);
|
|
if (!(context = props._contexts[plr_id]))
|
|
props._contexts[plr_id] = context = CreateObject(UserAction);
|
|
}
|
|
else // if (progress_mode == "session")
|
|
{
|
|
// Temporary context
|
|
context = CreateObject(UserAction);
|
|
context.temp = true;
|
|
}
|
|
// Prevent duplicate parallel execution
|
|
if (!allow_parallel && (context.hold && !context.suspended)) return false;
|
|
// Init context settings
|
|
context->InitContext(action_object, triggering_player, triggering_object, props, finish_callback, position);
|
|
// Execute action
|
|
EvaluateValue("Action", props, context);
|
|
FinishAction(context);
|
|
return true;
|
|
}
|
|
|
|
public func EvaluateCondition(proplist props, object action_object, object triggering_object, int triggering_player)
|
|
{
|
|
// Build temp context
|
|
var context = CreateObject(UserAction);
|
|
context.temp = true;
|
|
// Init context settings
|
|
context->InitContext(action_object, triggering_player, triggering_object, props);
|
|
// Execute condition evaluator
|
|
var result = EvaluateValue("Boolean", props, context);
|
|
// Cleanup
|
|
if (context) context->RemoveObject();
|
|
// Done
|
|
return result;
|
|
}
|
|
|
|
public func EvaluateString(proplist props, object context)
|
|
{
|
|
return EvaluateValue("String", props, context) ?? "";
|
|
}
|
|
|
|
private func EvaluatePosition(proplist props, object context)
|
|
{
|
|
// Execute position evaluator; fall back to position of action object
|
|
var position = EvaluateValue("Position", props, context);
|
|
if (!position)
|
|
{
|
|
if (context.action_object) position = [context.action_object->GetX(), context.action_object->GetY()];
|
|
else position = [0,0];
|
|
}
|
|
return position;
|
|
}
|
|
|
|
private func EvaluateOffset(proplist props, object context)
|
|
{
|
|
// Execute offset evaluator; fall back to [0, 0]
|
|
return EvaluateValue("Offset", props, context) ?? [0,0];
|
|
}
|
|
|
|
private func EvaluatePlayer(proplist props, object context)
|
|
{
|
|
// Execute player evaluator; nil means NO_OWNER
|
|
var plr = EvaluateValue("Player", props, context);
|
|
if (!GetType(plr)) plr = NO_OWNER;
|
|
return plr;
|
|
}
|
|
|
|
private func ResumeAction(proplist context, proplist resume_props)
|
|
{
|
|
//Log("ResumeAction %v %v", context, resume_props);
|
|
// Resume only if on hold for the same entry
|
|
if (context.hold != resume_props) return;
|
|
// Not if owning object is dead
|
|
if (!context.action_object) return;
|
|
// Resume action
|
|
EvaluateValue("Action", context.root_action, context);
|
|
// Cleanup action object (unless it ran into another hold)
|
|
FinishAction(context);
|
|
}
|
|
|
|
private func FinishAction(proplist context)
|
|
{
|
|
// Cleanup action object (unless it's kept around for callbacks or to store sequence progress)
|
|
// Note that context.root_action.contexts is checked to kill session-contexts that try to suspend
|
|
// There would be no way to resume so just kill the context
|
|
if (!context.hold || context.temp)
|
|
{
|
|
if (context.action_object && context.finish_callback) context.action_object->Call(context.finish_callback, context);
|
|
context->RemoveObject();
|
|
}
|
|
}
|
|
|
|
private func EvalConstant(proplist props, proplist context) { return props.Value; }
|
|
private func EvalStringConstant(proplist props, proplist context) { return GetTranslatedString(props.Value); }
|
|
private func EvalContextValue(proplist props, proplist context, string name) { return context[name]; }
|
|
private func EvalObj_ActionObject(proplist props, proplist context) { return context.action_object; }
|
|
private func EvalObj_TriggeringObject(proplist props, proplist context) { return context.triggering_object; }
|
|
private func EvalObj_TriggeringClonk(proplist props, proplist context) { return context.triggering_clonk; }
|
|
private func EvalObj_LastCreatedObject(proplist props, proplist context) { return context.last_created_object; }
|
|
private func EvalPlr_Trigger(proplist props, proplist context) { return context.triggering_player; }
|
|
private func EvalPlrList_Single(proplist props, proplist context, fn) { return [Call(fn, props, context)]; }
|
|
|
|
private func EvalCount(proplist props, proplist context, data_type)
|
|
{
|
|
var list = EvaluateValue(data_type, props.Array, context);
|
|
if (list) return GetLength(list); else return 0;
|
|
}
|
|
|
|
private func EvalObjList_FindObjectsInArea(proplist props, proplist context, bool find_one)
|
|
{
|
|
var params = Find_And(), np=1;
|
|
// Resolve area parameter
|
|
if (props.Area)
|
|
{
|
|
var area = props.Area.Area;
|
|
var fn = props.Area.Function;
|
|
var area_criterion;
|
|
if (fn == "InRect")
|
|
area_criterion = Find_InRect(area[0], area[1], area[2], area[3]);
|
|
else if (fn == "AtRect")
|
|
area_criterion = Find_AtRect(area[0], area[1], area[2], area[3]);
|
|
else if (fn == "Circle")
|
|
area_criterion = Find_Distance(area[0], area[1], area[2]);
|
|
else if (fn == "NearPosition")
|
|
{
|
|
var pos_params = props.Area.Parameters;
|
|
var pos = EvaluatePosition(pos_params.Position, context);
|
|
area_criterion = Find_Distance(pos_params.Radius, pos[0], pos[1]);
|
|
}
|
|
if (area_criterion) params[np++] = area_criterion;
|
|
}
|
|
// Other parameters
|
|
var idobj = EvaluateValue("Definition", props.ID, context);
|
|
if (idobj) params[np++] = Find_ID(idobj);
|
|
if (!props.AllowContained) params[np++] = Find_NoContainer();
|
|
// Find objects
|
|
var result = FindObjects(params);
|
|
if (find_one) return result[0]; else return result;
|
|
}
|
|
|
|
private func EvalObjList_FindObjectInContainer(proplist props, proplist context)
|
|
{
|
|
var container = EvaluateValue("Object", props.Container, context);
|
|
var idobj = EvaluateValue("Definition", props.ID, context);
|
|
if (!container) return;
|
|
if (idobj)
|
|
return container->FindContents(idobj);
|
|
else
|
|
return container->Contents();
|
|
}
|
|
|
|
private func EvalObjList_FindObjectsInContainer(proplist props, proplist context)
|
|
{
|
|
// Return array of all objects contained in container
|
|
var container = EvaluateValue("Object", props.Container, context);
|
|
var idobj = EvaluateValue("Definition", props.ID, context);
|
|
if (!container) return; // nil is treated as empty list
|
|
var i, n = container->ContentsCount(idobj), j;
|
|
if (!n) return;
|
|
var result = CreateArray(n), obj;
|
|
while ((obj = container->Contents(i++)))
|
|
if (!idobj || obj->GetID() == idobj)
|
|
result[j++] = obj;
|
|
return result;
|
|
}
|
|
|
|
private func EvalPlrList_All(proplist props, proplist context, fn)
|
|
{
|
|
var n = GetPlayerCount(C4PT_User);
|
|
var result = CreateArray(n);
|
|
for (var i=0; i<n; ++i) result[i] = GetPlayerByIndex(i);
|
|
return result;
|
|
}
|
|
|
|
private func EvalComparison(proplist props, proplist context, data_type)
|
|
{
|
|
var left = EvaluateValue(data_type, props.LeftOperand, context);
|
|
var right = EvaluateValue(data_type, props.RightOperand, context);
|
|
if (!left) left = nil; // 0 ==nil
|
|
if (!right) right = nil; // 0 == nil
|
|
var op = props.Operator;
|
|
if (!op)
|
|
return left == right;
|
|
else if (op == "ne")
|
|
return left != right;
|
|
else if (op == "lt")
|
|
return left < right;
|
|
else if (op == "gt")
|
|
return left > right;
|
|
else if (op == "le")
|
|
return left <= right;
|
|
else if (op == "ge")
|
|
return left >= right;
|
|
}
|
|
|
|
private func EvalBool_Not(proplist props, proplist context) { return !EvaluateValue("Boolean", props.Operand, context); }
|
|
|
|
private func EvalBool_And(proplist props, proplist context)
|
|
{
|
|
for (var cond in props.Operands)
|
|
if (!EvaluateValue("Boolean", cond, context))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
private func EvalBool_Or(proplist props, proplist context)
|
|
{
|
|
for (var cond in props.Operands)
|
|
if (EvaluateValue("Boolean", cond, context))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
private func EvalBool_ObjectExists(proplist props, proplist context) { return !!EvaluateValue("Object", props.Object, context); }
|
|
|
|
private func EvalBool_ObjectAlive(proplist props, proplist context)
|
|
{
|
|
var obj = EvaluateValue("Object", props.Object, context);
|
|
return obj && obj->GetAlive();
|
|
}
|
|
|
|
private func EvalAct_Sequence(proplist props, proplist context)
|
|
{
|
|
// Sequence execution: Iterate over actions until one action puts the context on hold
|
|
var n = GetLength(props.Actions), sid = props._sequence_id;
|
|
if (!sid) sid = props._sequence_id = Format("%d", ++UserAction_SequenceIDs);
|
|
for (var progress = context.action_data[sid] ?? 0; progress < n; ++progress)
|
|
{
|
|
//Log("Sequence progress exec %v %v", progress, context.hold);
|
|
// goto preparations
|
|
context.sequence_had_goto[sid] = false;
|
|
context.last_sequence = props;
|
|
// Evaluate next sequence step
|
|
EvaluateValue("Action", props.Actions[progress], context);
|
|
if (context.hold || context.suspended)
|
|
{
|
|
// Execution on hold (i.e. wait action). Stop execution for now
|
|
if (!context.hold) progress = 0; // No hold specified: Stop with sequence reset
|
|
context.action_data[sid] = progress;
|
|
return;
|
|
}
|
|
// Apply jump in the sequence
|
|
if (context.sequence_had_goto[sid]) progress = context.action_data[sid] - 1;
|
|
}
|
|
// Sequence finished
|
|
context.last_sequence = nil;
|
|
// Reset for next execution.
|
|
context.action_data[sid] = 0;
|
|
}
|
|
|
|
private func EvalAct_Goto(proplist props, proplist context)
|
|
{
|
|
// Apply goto by jumping in most recently executed sequence
|
|
if (context.last_sequence)
|
|
{
|
|
var index = props.Index;
|
|
if (GetType(index) != C4V_Int) index = EvaluateValue("Integer", index, context); // compatibility
|
|
context.action_data[context.last_sequence._sequence_id] = index;
|
|
context.sequence_had_goto[context.last_sequence._sequence_id] = true;
|
|
}
|
|
}
|
|
|
|
private func EvalAct_StopSequence(proplist props, proplist context)
|
|
{
|
|
// Stop: Suspend without hold props, which causes all sequences to reset
|
|
context.hold = nil;
|
|
context.suspended = true;
|
|
}
|
|
|
|
private func EvalAct_SuspendSequence(proplist props, proplist context)
|
|
{
|
|
// Suspend: Remember hold position and stop action execution
|
|
context.hold = props;
|
|
context.suspended = true;
|
|
}
|
|
|
|
private func EvalAct_For_IntRange(proplist props, proplist context)
|
|
{
|
|
// Create list with range of integers
|
|
// Both start and end inclusive
|
|
var start = EvaluateValue("Integer", props.Start, context);
|
|
var end = EvaluateValue("Integer", props.End, context);
|
|
var step = EvaluateValue("Integer", props.Step, context);
|
|
if (!step) return [];
|
|
var d = end - start;
|
|
if (d * step < 0) return []; // wrong direction
|
|
var n = (end - start) / step + 1;
|
|
var list = CreateArray(n), i;
|
|
for (var v = start; v <= end; v += step) list[i++] = v;
|
|
return list;
|
|
}
|
|
|
|
private func EvalAct_For_ObjectList(proplist props, proplist context)
|
|
{
|
|
return EvaluateValue("ObjectList", props.Objects, context) ?? [];
|
|
}
|
|
|
|
private func EvalAct_For_PlayerList(proplist props, proplist context)
|
|
{
|
|
return EvaluateValue("PlayerList", props.Players, context) ?? [];
|
|
}
|
|
|
|
private func EvalAct_For(proplist props, proplist context, list_function)
|
|
{
|
|
// For: Iterate over elements until one action puts the context on hold
|
|
// list_info: [list_function, current_item_field]
|
|
var sid = props._sequence_id;
|
|
if (!sid) sid = props._sequence_id = Format("%d", ++UserAction_SequenceIDs);
|
|
// Get list data
|
|
var list, progress;
|
|
if (!context.action_data[sid])
|
|
{
|
|
list = Call(list_function, props, context);
|
|
}
|
|
else
|
|
{
|
|
list = context.action_data[sid][0];
|
|
progress = context.action_data[sid][1];
|
|
context.action_data[sid] = nil;
|
|
}
|
|
var n = GetLength(list);
|
|
for (; progress < n; ++progress)
|
|
{
|
|
// Get iterated item
|
|
var curr_value = list[progress];
|
|
if (!GetType(curr_value)) continue; // Ignore nil (deleted objects)
|
|
context[props.Function] = curr_value;
|
|
// Evaluate next sequence step
|
|
EvaluateValue("Action", props.Action, context);
|
|
if (context.hold || context.suspended)
|
|
{
|
|
// Execution on hold (i.e. wait action). Stop execution for now
|
|
if (context.hold) context.action_data[sid] = [list, progress];
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private func EvalAct_Wait(proplist props, proplist context)
|
|
{
|
|
// Wait for specified number of frames
|
|
context.hold = props;
|
|
ScheduleCall(context, UserAction.ResumeAction, props.Time, 1, context, props);
|
|
}
|
|
|
|
private func EvalAct_WaitCondition(proplist props, proplist context)
|
|
{
|
|
// Poll condition and resume when it's met.
|
|
var cond = props.Condition;
|
|
// Invalid condition?
|
|
if (!cond) return;
|
|
// Condition fulfilled?
|
|
if (EvaluateValue("Boolean", cond, context)) return;
|
|
// Re-check condition periodically
|
|
context.hold = props;
|
|
ScheduleCall(context, UserAction.EvalAct_WaitConditionRe, props.Interval, 0x7fffffff, props, context);
|
|
}
|
|
|
|
private func EvalAct_WaitConditionRe(proplist props, proplist context)
|
|
{
|
|
if (UserAction->EvaluateValue("Boolean", props.Condition, context))
|
|
{
|
|
ClearScheduleCall(context, UserAction.EvalAct_WaitConditionRe);
|
|
UserAction->ResumeAction(context, props);
|
|
}
|
|
}
|
|
|
|
private func EvalAct_Sound(proplist props, proplist context)
|
|
{
|
|
if (!props.Sound) return;
|
|
var sound_context;
|
|
if (props.SourceObject)
|
|
{
|
|
sound_context = EvaluateValue("Object", props.SourceObject, context);
|
|
if (!sound_context) return;
|
|
}
|
|
else
|
|
{
|
|
sound_context = Global;
|
|
}
|
|
var volume = EvaluateValue("Integer", props.Volume, context);
|
|
var pitch = EvaluateValue("Integer", props.Pitch, context);
|
|
if (props.TargetPlayers == "all_players")
|
|
{
|
|
sound_context->Sound(props.Sound, true, volume, nil, props.Loop, nil, pitch);
|
|
}
|
|
else
|
|
{
|
|
for (var plr in EvaluateValue("PlayerList", props.TargetPlayers, context))
|
|
{
|
|
sound_context->Sound(props.Sound, false, volume, plr, props.Loop, nil, pitch);
|
|
}
|
|
}
|
|
}
|
|
|
|
private func EvalAct_CreateObject(proplist props, proplist context)
|
|
{
|
|
// Create a new object
|
|
var create_id = EvaluateValue("Definition", props.ID, context);
|
|
if (!create_id) return;
|
|
var owner = EvaluatePlayer(props.Owner, context);
|
|
var container = EvaluateValue("Object", props.Container, context);
|
|
var obj;
|
|
if (container)
|
|
{
|
|
// Contained object
|
|
obj = container->CreateContents(create_id);
|
|
if (obj) obj->SetOwner(owner);
|
|
}
|
|
else
|
|
{
|
|
// Uncontained object
|
|
var position = EvaluatePosition(props.Position, context);
|
|
var speed_x = EvaluateValue("Integer", props.SpeedX, context);
|
|
var speed_y = EvaluateValue("Integer", props.SpeedY, context);
|
|
var rotation = EvaluateValue("Integer", props.Rotation, context);
|
|
var speed_r = EvaluateValue("Integer", props.SpeedR, context);
|
|
if (props.CreateAbove)
|
|
obj = Global->CreateObjectAbove(create_id, position[0], position[1], owner);
|
|
else
|
|
obj = Global->CreateObject(create_id, position[0], position[1], owner);
|
|
// Default speed and rotation
|
|
if (obj) obj->SetXDir(speed_x);
|
|
if (obj) obj->SetYDir(speed_y);
|
|
if (obj) obj->SetR(rotation);
|
|
if (obj) obj->SetRDir(speed_r, 5); // Internal rdir value is in five degrees frame
|
|
}
|
|
// Remember object for later access
|
|
context.last_created_object = obj;
|
|
}
|
|
|
|
private func EvalAct_CastObjects(proplist props, proplist context)
|
|
{
|
|
// Cast objects in multiple directions
|
|
var create_id = EvaluateValue("Definition", props.ID, context);
|
|
if (!create_id) return;
|
|
var owner = EvaluatePlayer(props.Owner, context);
|
|
var amount = EvaluateValue("Integer", props.Amount, context);
|
|
var speed = EvaluateValue("Integer", props.Speed, context);
|
|
var mean_angle = EvaluateValue("Integer", props.MeanAngle, context);
|
|
var angle_deviation = EvaluateValue("Integer", props.AngleDeviation, context);
|
|
var position = EvaluatePosition(props.Position, context);
|
|
var objects = CastObjects(create_id, amount, speed, position[0], position[1], mean_angle, angle_deviation);
|
|
for (var obj in objects)
|
|
obj->SetOwner(owner);
|
|
context.last_casted_objects = objects;
|
|
}
|
|
|
|
private func EvalAct_CastParticles(proplist props, proplist context)
|
|
{
|
|
var particle_name = props.Name;
|
|
var amount = EvaluateValue("Integer", props.Amount, context);
|
|
var speed = EvaluateValue("Integer", props.Speed, context);
|
|
var size_start = EvaluateValue("Integer", props.Size, context);
|
|
var size_end = EvaluateValue("Integer", props.SizeEnd, context);
|
|
var lifetime = EvaluateValue("Integer", props.Lifetime, context);
|
|
if (lifetime <= 0) return;
|
|
var position = EvaluatePosition(props.Position, context);
|
|
var color = (EvaluateValue("Color", props.Color, context) ?? 0xffffff) | 0xff000000;
|
|
var fadeout = props.FadeOut;
|
|
var gravity = EvaluateValue("Integer", props.Gravity, context);
|
|
var collision_func = props.CollisionFunc;
|
|
var prototype =
|
|
{
|
|
BlitMode = props.BlitMode,
|
|
Size = PV_Linear(size_start, size_end),
|
|
Rotation = PV_Direction(),
|
|
R = (color >> 16) & 0xff,
|
|
G = (color >> 8) & 0xff,
|
|
B = (color >> 0) & 0xff,
|
|
CollisionVertex = 500
|
|
};
|
|
if (fadeout) prototype.Alpha = PV_Linear(255, 0); else prototype.Alpha=255;
|
|
if (gravity) prototype.ForceY = PV_Gravity(gravity);
|
|
if (collision_func == "pass")
|
|
{
|
|
prototype.CollisionDensity = 9999;
|
|
}
|
|
else if (collision_func == "bounce")
|
|
{
|
|
prototype.OnCollision = PC_Bounce(500);
|
|
}
|
|
else if (collision_func == "die")
|
|
{
|
|
prototype.OnCollision = PC_Die();
|
|
}
|
|
else if (collision_func == "stop")
|
|
{
|
|
prototype.OnCollision = PC_Stop();
|
|
}
|
|
CreateParticle(particle_name, position[0], position[1], PV_Random(-speed, speed), PV_Random(-speed, speed), lifetime, prototype, amount);
|
|
}
|
|
|
|
private func EvalAct_RemoveObject(proplist props, proplist context)
|
|
{
|
|
var obj = EvaluateValue("Object", props.Object, context);
|
|
if (!obj) return;
|
|
obj->RemoveObject(props.EjectContents);
|
|
}
|
|
|
|
private func EvalAct_SetPosition(proplist props, proplist context)
|
|
{
|
|
var obj = EvaluateValue("Object", props.Object, context);
|
|
if (!obj) return;
|
|
var pos = EvaluatePosition(props.Position, context);
|
|
obj->SetPosition(pos[0], pos[1]);
|
|
}
|
|
|
|
private func EvalAct_Fling(proplist props, proplist context)
|
|
{
|
|
var obj = EvaluateValue("Object", props.Object, context);
|
|
if (!obj) return;
|
|
var vx = EvaluateValue("Integer", props.SpeedX, context);
|
|
var vy = EvaluateValue("Integer", props.SpeedY, context);
|
|
var add_speed = EvaluateValue("Boolean", props.AddSpeed, context);
|
|
obj->Fling(vx, vy, 10, add_speed);
|
|
}
|
|
|
|
private func EvalAct_EnterObject(proplist props, proplist context)
|
|
{
|
|
var object = EvaluateValue("Object", props.Object, context);
|
|
var container = EvaluateValue("Object", props.Container, context);
|
|
if (!container || !object) return;
|
|
// Enter either with a check (Collect) or just force-Enter
|
|
if (!props.CollectionCheck)
|
|
{
|
|
object->Enter(container);
|
|
}
|
|
else
|
|
{
|
|
if (!container->Collect(object, true))
|
|
{
|
|
if (props.CollectionCheck == "exit")
|
|
{
|
|
object->SetPosition(container->GetX(), container->GetY());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func EvalAct_ExitObject(proplist props, proplist context)
|
|
{
|
|
var object = EvaluateValue("Object", props.Object, context);
|
|
if (object) object->Exit();
|
|
}
|
|
|
|
private func EvalAct_SetDirection(proplist props, proplist context)
|
|
{
|
|
var object = EvaluateValue("Object", props.Object, context);
|
|
if (object) object->SetDir(props.Direction);
|
|
}
|
|
|
|
private func EvalAct_SetVisibility(proplist props, proplist context)
|
|
{
|
|
var object = EvaluateValue("Object", props.Object, context);
|
|
if (object) object.Visibility = props.Visibility;
|
|
}
|
|
|
|
private func EvalAct_SetVincibility(proplist props, proplist context)
|
|
{
|
|
var object = EvaluateValue("Object", props.Object, context);
|
|
if (object) object->SetInvincibility(!props.Vincibility);
|
|
}
|
|
|
|
private func EvalAct_DoWealth(proplist props, proplist context)
|
|
{
|
|
var player = EvaluatePlayer(props.Player, context);
|
|
var change = EvaluateValue("Integer", props.Change, context);
|
|
if (player != NO_OWNER && change)
|
|
{
|
|
SetWealth(player, GetWealth(player) + change);
|
|
var do_sound = EvaluateValue("Boolean", props.DoSound, context);
|
|
if (do_sound)
|
|
{
|
|
if (change < 0) Sound("UI::Cash*", true, nil, player); else Sound("UI::UnCash*", true, nil, player);
|
|
}
|
|
}
|
|
}
|
|
|
|
private func EvalAct_PlrKnowledge(proplist props, proplist context)
|
|
{
|
|
var players = EvaluateValue("PlayerList", props.Players, context) ?? [];
|
|
var def = EvaluateValue("Definition", props.ID, context);
|
|
if (!def) return;
|
|
for (var plr in players) SetPlrKnowledge(plr, def);
|
|
}
|
|
|
|
private func EvalAct_PlrView(proplist props, proplist context)
|
|
{
|
|
var players = EvaluateValue("PlayerList", props.Players, context) ?? [];
|
|
var target = EvaluateValue("Object", props.Target, context);
|
|
var immediate = props.Immediate;
|
|
if (!target) return;
|
|
for (var plr in players) SetPlrView(plr, target, immediate);
|
|
}
|
|
|
|
private func EvalAct_ObjectCallInt(proplist props, proplist context, func call_fn)
|
|
{
|
|
var obj = EvaluateValue("Object", props.Object, context);
|
|
if (!obj) return;
|
|
var parameter = EvaluateValue("Integer", props.Value, context);
|
|
obj->Call(call_fn, parameter);
|
|
}
|
|
|
|
private func EvalAct_If(proplist props, proplist context)
|
|
{
|
|
// Do evaluation on first pass. After that, take context value.
|
|
var sid = props._sequence_id;
|
|
if (!sid) sid = props._sequence_id = Format("%d", ++UserAction_SequenceIDs);
|
|
var cond = context.action_data[sid] ?? !!EvaluateValue("Boolean", props.Condition, context);
|
|
if (cond)
|
|
EvaluateValue("Action", props.TrueEvaluator, context);
|
|
else
|
|
EvaluateValue("Action", props.FalseEvaluator, context);
|
|
// Only keep conditional value within a held action
|
|
if (context.hold) context.action_data[sid] = cond;
|
|
}
|
|
|
|
private func EvalConditionalValue(proplist props, proplist context, eval_type)
|
|
{
|
|
// Return value by condition
|
|
if (EvaluateValue("Boolean", props.Condition, context))
|
|
return EvaluateValue(eval_type, props.TrueEvaluator, context);
|
|
else
|
|
return EvaluateValue(eval_type, props.FalseEvaluator, context);
|
|
}
|
|
|
|
private func EvalAct_Log(proplist props, proplist context)
|
|
{
|
|
Log(EvaluateString(props.Message, context));
|
|
}
|
|
|
|
private func EvalAct_Nop(proplist props, proplist context) {}
|
|
|
|
private func GetVariableContext(proplist props, proplist context)
|
|
{
|
|
// Resolve context for variable. Global or object context.
|
|
var var_context = EvaluateValue("Object", props, context);
|
|
if (!var_context)
|
|
{
|
|
if (!g_UserAction_global_vars) g_UserAction_global_vars = {};
|
|
var_context = g_UserAction_global_vars;
|
|
}
|
|
else
|
|
{
|
|
if (!var_context.user_variables) var_context.user_variables = {};
|
|
var_context = var_context.user_variables;
|
|
}
|
|
return var_context;
|
|
}
|
|
|
|
private func EvalAct_SetVariable(proplist props, proplist context)
|
|
{
|
|
// Assign variable
|
|
var var_context = GetVariableContext(props.Context, context);
|
|
var var_name = StringToIdentifier(EvaluateString(props.VariableName, context));
|
|
var value = EvaluateValue("Any", props.Value, context);
|
|
var_context[var_name] = value;
|
|
}
|
|
|
|
private func EvalVariable(proplist props, proplist context, expected_type)
|
|
{
|
|
// Get variable value
|
|
var var_context = GetVariableContext(props.Context, context);
|
|
var var_name = StringToIdentifier(EvaluateString(props.VariableName, context));
|
|
var value = var_context[var_name];
|
|
// Check type (except for C4V_Nil which means "Any" here)
|
|
var val_type = GetType(value);
|
|
if (val_type != expected_type && expected_type)
|
|
{
|
|
// Array types have special checking
|
|
if (GetType(expected_type) == C4V_Array)
|
|
{
|
|
var expected_len = expected_type[1];
|
|
var valid;
|
|
if (val_type == C4V_Array)
|
|
{
|
|
// Check required length
|
|
if (!expected_len || GetLength(value) == expected_len)
|
|
{
|
|
// Check data type of contents
|
|
var subtype = expected_type[0];
|
|
valid = true;
|
|
for (var v in value) if (v && GetType(v) != subtype) valid = false;
|
|
}
|
|
}
|
|
// Invalid value for expected array: Return default array.
|
|
// All nil is OK because there is no string list type and nil converts to 0.
|
|
if (!valid) return CreateArray(expected_len);
|
|
}
|
|
else
|
|
{
|
|
// Type not matching. Construct default.
|
|
if (expected_type == C4V_Int) return 0;
|
|
if (expected_type == C4V_Bool) return !!value; // This conversion is OK
|
|
if (expected_type == C4V_String) return "";
|
|
return nil;
|
|
}
|
|
}
|
|
// Value OK. Return it.
|
|
return value;
|
|
}
|
|
|
|
private func EvalScript(proplist props, proplist context)
|
|
{
|
|
var script_context;
|
|
if (props.Context)
|
|
{
|
|
if (!(script_context = EvaluateValue("Object", props.Context, context))) return;
|
|
}
|
|
else
|
|
{
|
|
script_context = Global;
|
|
}
|
|
var script = EvaluateString(props.Script, context);
|
|
return script_context->eval(script, true);
|
|
}
|
|
|
|
private func EvalAct_GameOver(proplist props, proplist context) { GameOver(); }
|
|
|
|
private func GetDefaultPosition(object target_object)
|
|
{
|
|
// Default position for constant absolute position evaluator: Use selected object position
|
|
var value;
|
|
if (target_object)
|
|
value = [target_object->GetX(), target_object->GetY()];
|
|
else
|
|
value = [0,0];
|
|
return { Function="position_constant", Value=value };
|
|
}
|
|
|
|
private func GetDefaultCoordinates(object target_object)
|
|
{
|
|
// Default position for constant absolute position evaluator: Use selected object position
|
|
var value;
|
|
if (target_object)
|
|
value = {X={Function="int_constant", Value=target_object->GetX()}, Y={Function="int_constant", Value=target_object->GetY()}};
|
|
else
|
|
value = {X=0, Y=0};
|
|
value.Function="position_coordinates";
|
|
return value;
|
|
}
|
|
|
|
private func GetDefaultRect(object target_object, proplist props)
|
|
{
|
|
// Default rectangle around target object
|
|
var r;
|
|
if (target_object) r = [target_object->GetX()-30, target_object->GetY()-30, 60, 60]; else r = [100,100,100,100];
|
|
return { Function=props.Function, Area=r };
|
|
}
|
|
|
|
private func GetDefaultCircle(object target_object, proplist props)
|
|
{
|
|
// Default circle around target object
|
|
var r;
|
|
if (target_object) r = [50, target_object->GetX(), target_object->GetY()]; else r = [50,100,100];
|
|
return { Function=props.Function, Area=r };
|
|
}
|
|
|
|
private func GetDefaultSearchRect(object target_object)
|
|
{
|
|
// Default rectangle around target object
|
|
var r;
|
|
if (target_object) r = [target_object->GetX()-30, target_object->GetY()-30, 60, 60]; else r = [100,100,100,100];
|
|
return { Function="Rect", Area=r };
|
|
}
|
|
|
|
private func GetDefaultSearchCircle(object target_object)
|
|
{
|
|
// Default circle around target object
|
|
var r;
|
|
if (target_object) r = [50, target_object->GetX(), target_object->GetY()]; else r = [50,100,100];
|
|
return { Function="Circle", Area=r };
|
|
}
|
|
|
|
private func EvalIntRandom(proplist props, proplist context)
|
|
{
|
|
// Random value between min and max. Also allow them to be swapped.
|
|
var min = EvaluateValue("Integer", props.Min, context);
|
|
var max = EvaluateValue("Integer", props.Max, context);
|
|
var rmin = Min(min,max);
|
|
return Random(Max(max,min)-rmin) + rmin;
|
|
}
|
|
|
|
private func EvalPositionRelative(proplist props, proplist context)
|
|
{
|
|
// Return position relative to action_object
|
|
if (context.action_object)
|
|
return [props.Value[0] + context.action_object->GetX(), props.Value[1] + context.action_object->GetY()];
|
|
else
|
|
return props.Value;
|
|
}
|
|
|
|
private func EvalCoordinates(proplist props, proplist context)
|
|
{
|
|
// Coordinate evaluation: Make array [X, Y]
|
|
return [EvaluateValue("Integer", props.X, context), EvaluateValue("Integer", props.Y, context)];
|
|
}
|
|
|
|
private func EvalPositionOffset(proplist props, proplist context)
|
|
{
|
|
var p = EvaluatePosition(props.Position, context);
|
|
var o = EvaluateOffset(props.Offset, context);
|
|
return [p[0]+o[0], p[1]+o[1]];
|
|
}
|
|
|
|
private func EvalPositionObject(proplist props, proplist context)
|
|
{
|
|
var obj = EvaluateValue("Object", props.Object, context);
|
|
if (obj) return [obj->GetX(), obj->GetY()];
|
|
return [0,0]; // undefined object: Position is 0/0 default
|
|
}
|
|
|
|
private func EvalPos_LastUse(proplist props, proplist context) { return context.position; }
|
|
|
|
private func EvalPos_RandomRect(proplist props, proplist context, bool relative)
|
|
{
|
|
// Constant random distribution in rectangle
|
|
var a = props.Area;
|
|
var rval = [a[0] + Random(a[2]), a[1] + Random(a[3])];
|
|
// Apply relative offset
|
|
if (relative && context.action_object)
|
|
{
|
|
rval[0] += context.action_object->GetX();
|
|
rval[1] += context.action_object->GetY();
|
|
}
|
|
return rval;
|
|
}
|
|
|
|
private func EvalPos_RandomCircle(proplist props, proplist context, bool relative)
|
|
{
|
|
// Constant random distribution in circle
|
|
var a = props.Area;
|
|
var r = a[0];
|
|
r = Sqrt(Random(r*r));
|
|
var ang = Random(360);
|
|
var x = Sin(ang, r), y = Cos(ang, r);
|
|
var rval = [a[1]+x, a[2]+y];
|
|
// Apply relative offset
|
|
if (relative && context.action_object)
|
|
{
|
|
rval[0] += context.action_object->GetX();
|
|
rval[1] += context.action_object->GetY();
|
|
}
|
|
return rval;
|
|
}
|
|
|
|
private func EvalOffsetAdd(proplist props, proplist context)
|
|
{
|
|
var o1 = EvaluateOffset(props.Offset1, context);
|
|
var o2 = EvaluateOffset(props.Offset2, context);
|
|
return [o1[0]+o2[0], o1[1]+o2[1]];
|
|
}
|
|
|
|
private func EvalOffsetDiff(proplist props, proplist context)
|
|
{
|
|
var pA = EvaluatePosition(props.PositionA, context);
|
|
var pB = EvaluatePosition(props.PositionB, context);
|
|
return [pB[0]-pA[0], pB[1]-pA[1]];
|
|
}
|
|
|
|
private func EvalInt_Add(proplist props, proplist context) { return EvaluateValue("Integer", props.LeftOperand, context) + EvaluateValue("Integer", props.RightOperand, context); }
|
|
private func EvalInt_Sub(proplist props, proplist context) { return EvaluateValue("Integer", props.LeftOperand, context) - EvaluateValue("Integer", props.RightOperand, context); }
|
|
private func EvalInt_Mul(proplist props, proplist context) { return EvaluateValue("Integer", props.LeftOperand, context) * EvaluateValue("Integer", props.RightOperand, context); }
|
|
|
|
private func EvalInt_Div(proplist props, proplist context)
|
|
{
|
|
var a = EvaluateValue("Integer", props.LeftOperand, context), b = EvaluateValue("Integer", props.RightOperand, context);
|
|
return a/(b+!b);
|
|
}
|
|
|
|
private func EvalInt_Mod(proplist props, proplist context)
|
|
{
|
|
var a = EvaluateValue("Integer", props.LeftOperand, context), b = EvaluateValue("Integer", props.RightOperand, context);
|
|
return a%(b+!b);
|
|
}
|
|
|
|
private func EvalInt_Distance(proplist props, proplist context)
|
|
{
|
|
var pA = EvaluatePosition(props.PositionA, context);
|
|
var pB = EvaluatePosition(props.PositionB, context);
|
|
return Distance(pA[0], pA[1], pB[0], pB[1]);
|
|
}
|
|
|
|
private func EvalInt_Wealth(proplist props, proplist context) { return GetWealth(EvaluatePlayer(props.Player, context)); }
|
|
|
|
private func EvalInt_PosCoord(proplist props, proplist context, int idx) { return EvaluatePosition(props.Position, context)[idx]; }
|
|
|
|
private func EvalClr_PlayerColor(proplist props, proplist context) { return GetPlayerColor(EvaluatePlayer(props.Player, context)); }
|
|
|
|
private func EvalClr_RGB(proplist props, proplist context)
|
|
{
|
|
var R = EvaluateValue("Integer", props.R, context);
|
|
var G = EvaluateValue("Integer", props.G, context);
|
|
var B = EvaluateValue("Integer", props.B, context);
|
|
return RGB(R, G, B);
|
|
}
|
|
|
|
private func EvalClr_Random(proplist props, proplist context)
|
|
{
|
|
var a = EvaluateValue("Color", props.ColorA, context);
|
|
var b = EvaluateValue("Color", props.ColorB, context);
|
|
var result;
|
|
for (var i=0; i<3; ++i)
|
|
{
|
|
var ca = (a>>(i*8)) & 0xff;
|
|
var cb = (b>>(i*8)) & 0xff;
|
|
result |= ((Random(Abs(ca-cb+1)) + Min(ca, cb)) << (i*8));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private func EvalStr_ValueToString(proplist props, proplist context)
|
|
{
|
|
return Format("%v", EvaluateValue("Any", props.Value, context));
|
|
}
|
|
|
|
private func EvalStr_Concat(proplist props, proplist context)
|
|
{
|
|
var result="";
|
|
for (var s in props.Substrings) result = Format("%s%s", result, EvaluateString(s, context));
|
|
return result;
|
|
}
|
|
|
|
private func EvalObjProp(proplist props, proplist context, prop_fn)
|
|
{
|
|
var obj = EvaluateValue("Object", props.Object, context);
|
|
if (!obj) return nil;
|
|
return obj->Call(prop_fn);
|
|
}
|
|
|
|
|
|
|
|
/* Context instance */
|
|
|
|
// Proplist holding progress in each sequence
|
|
local action_data, sequence_had_goto;
|
|
static UserAction_SequenceIDs;
|
|
|
|
// Set to innermost sequence (for goto)
|
|
local last_sequence;
|
|
|
|
// If this action is paused and will be resumed by a callback or by re-execution of the action, this property is set to the props of the holding action
|
|
local hold;
|
|
|
|
// Set to true if action is on hold but waiting for re-execution
|
|
local suspended;
|
|
|
|
// Return value if a value-providing evaluator is held
|
|
local hold_result;
|
|
|
|
public func Initialize()
|
|
{
|
|
action_data = {};
|
|
sequence_had_goto = {};
|
|
return true;
|
|
}
|
|
|
|
public func InitContext(object action_object, int triggering_player, object triggering_object, proplist props, finish_callback, position)
|
|
{
|
|
// Determine triggering player+objects
|
|
var triggering_clonk;
|
|
// Triggering player unknown? Try fallback to the controller of the triggering object
|
|
if (!GetType(triggering_player) && triggering_object)
|
|
{
|
|
triggering_player = triggering_object->GetController();
|
|
}
|
|
// Triggering clonk is the selected clonk of the triggering player
|
|
if (GetType(triggering_player))
|
|
{
|
|
triggering_clonk = GetCursor(triggering_player);;
|
|
if (!triggering_clonk) triggering_clonk = GetCrew(triggering_player);
|
|
}
|
|
// Triggering object / Triggering player clonk fallbacks
|
|
if (!triggering_object)
|
|
triggering_object = triggering_clonk;
|
|
else if (triggering_object->~IsClonk())
|
|
triggering_clonk = triggering_object;
|
|
// Position default
|
|
if (!position && triggering_object)
|
|
position = [triggering_object->GetX(), triggering_object->GetY()];
|
|
// Init context settings
|
|
this.action_object = action_object;
|
|
this.triggering_object = triggering_object;
|
|
this.triggering_clonk = triggering_clonk;
|
|
this.triggering_player = triggering_player;
|
|
this.position = position;
|
|
this.root_action = props;
|
|
this.suspended = false;
|
|
this.finish_callback = finish_callback;
|
|
return true;
|
|
}
|
|
|
|
public func MenuOK(proplist menu_id, object clonk)
|
|
{
|
|
// Pressed 'Next' in dialogue: Resume in user action
|
|
UserAction->ResumeAction(this, this.hold);
|
|
}
|
|
|
|
public func MenuSelectOption(int index)
|
|
{
|
|
// Selected an option in dialogue: Resume at specified position in innermost sequence
|
|
if (!hold || !hold.Options) return;
|
|
var opt = this.hold.Options[index];
|
|
if (opt && last_sequence)
|
|
{
|
|
action_data[last_sequence._sequence_id] = opt._goto;
|
|
hold = nil;
|
|
}
|
|
UserAction->ResumeAction(this, hold);
|
|
}
|
|
|
|
public func SaveScenarioObject(props) { return false; } // temp. don't save.
|