public static StringRange FromLuaRange(DynValue start, DynValue end, int? defaultEnd = null)
{
int i = start.IsNil() ? 1 : (int)start.Number;
int j = end.IsNil() ? (defaultEnd ?? i) : (int)end.Number;
return new StringRange(i, j);
}
protected static lua_Integer LuaLOptInteger(LuaState L, lua_Integer pos, lua_Integer def)
{
DynValue v = ArgAsType(L, pos, DataType.Number, true);
if (v.IsNil())
{
return(def);
}
else
{
return((int)v.Number);
}
}
static FileUserDataBase GetDefaultFile(ScriptExecutionContext executionContext, StandardFileType file)
{
Table R = executionContext.GetScript().Registry;
DynValue ff = R.Get("853BEAAF298648839E2C99D005E1DF94_" + file.ToString());
if (ff.IsNil())
{
ff = GetStandardFile(executionContext.GetScript(), file);
}
return(ff.CheckUserDataType <FileUserDataBase>("getdefaultfile(" + file.ToString() + ")"));
}
public IEnumerable <Table> GetFunction(ScriptState function_name)
{
DynValue function = Script.Globals.Get(function_name.ToString());
if (function.IsNil() || function.Type != DataType.Function)
{
return(null);
}
DynValue result = Script.Call(function);
return(result.Type != DataType.Table ? null : result.Table.Values.Where(data => data.Type == DataType.Table).Select(f => f.Table));
}
private void Teleport(DynValue mapName, DynValue x, DynValue y, DynValue facingLua, DynValue rawLua)
{
OrthoDir?facing = null;
if (!facingLua.IsNil())
{
facing = OrthoDirExtensions.Parse(facingLua.String);
}
var loc = new Vector2Int((int)x.Number, (int)y.Number);
var raw = rawLua.IsNil() ? false : rawLua.Boolean;
RunRoutineFromLua(Global.Instance().Maps.TeleportRoutine(mapName.String, loc, facing, raw));
}
public virtual void Add(DynValue table)
{
if (MetaTable == null)
{
MetaTable = GetDynVal(LuaTableKey);
}
if (!MetaTable.IsNil())
{
baseTable = AddByDefault(MetaTable, table);
}
else
{
baseTable = table;
}
//获得Lua类模板
string temp = GetStrByBaseTable(Template);
Type classType = typeof(T);
if (temp != null)
{
classType = Type.GetType(NameSpace + "." + temp, true, false);
if (classType == null)
{
CLog.Error("无法找到此类型:" + temp);
}
TempClassData = classType.Assembly.CreateInstance(classType.FullName) as T;
}
else
{
TempClassData = new T();
}
TempClassData = (T)LuaReader.Read(baseTable, classType);
if (TempClassData == null)
{
return;
}
string key = TempClassData.TDID;
if (Data.ContainsKey(key))
{
CLog.Error(baseTable.ToString() + "已经存在这个key:" + key);
return;
}
//TempClassData.OnBeAddedToData();
//Add(key, TempClassData);
//Keys.Add(key);
TempClassData.TDID = key;
Register(TempClassData);
}
public static DynValue load_impl(ScriptExecutionContext executionContext, CallbackArguments args, Table defaultEnv)
{
try
{
Script S = executionContext.GetScript();
DynValue ld = args[0];
string script = "";
if (ld.Type == DataType.Function)
{
while (true)
{
DynValue ret = executionContext.GetScript().Call(ld);
if (ret.Type == DataType.String && ret.String.Length > 0)
{
script += ret.String;
}
else if (ret.IsNil())
{
break;
}
else
{
return(DynValue.NewTuple(DynValue.Nil, DynValue.NewString("reader function must return a string")));
}
}
}
else if (ld.Type == DataType.String)
{
script = ld.String;
}
else
{
args.AsType(0, "load", DataType.Function, false);
}
DynValue source = args.AsType(1, "load", DataType.String, true);
DynValue env = args.AsType(3, "load", DataType.Table, true);
DynValue fn = S.LoadString(script,
!env.IsNil() ? env.Table : defaultEnv,
!source.IsNil() ? source.String : "=(load)");
return(fn);
}
catch (SyntaxErrorException ex)
{
return(DynValue.NewTuple(DynValue.Nil, DynValue.NewString(ex.Message)));
}
}
public static DynValue concat(ScriptExecutionContext executionContext, CallbackArguments args)
{
DynValue vlist = args.AsType(0, "concat", DataType.Table, false);
DynValue vsep = args.AsType(1, "concat", DataType.String, true);
DynValue vstart = args.AsType(2, "concat", DataType.Number, true);
DynValue vend = args.AsType(3, "concat", DataType.Number, true);
Table list = vlist.Table;
string sep = vsep.IsNil() ? "" : vsep.String;
int start = vstart.IsNilOrNan() ? 1 : (int)vstart.Number;
int end;
if (vend.IsNilOrNan())
{
end = GetTableLength(executionContext, vlist);
}
else
{
end = (int)vend.Number;
}
if (end < start)
{
return(DynValue.NewString(string.Empty));
}
StringBuilder sb = new StringBuilder();
for (int i = start; i <= end; i++)
{
DynValue v = list.Get(i);
if (v.Type != DataType.Number && v.Type != DataType.String)
{
throw new ScriptRuntimeException("invalid value ({1}) at index {0} in table for 'concat'", i, v.Type.ToLuaTypeString());
}
string s = v.ToPrintString();
if (i != start)
{
sb.Append(sep);
}
sb.Append(s);
}
return(DynValue.NewString(sb.ToString()));
}
private void RemoveItem(DynValue itemLua, DynValue isCollectableLua)
{
var key = itemLua.String;
var isCollectable = isCollectableLua.IsNil() || isCollectableLua.Boolean;
if (isCollectable)
{
Global.Instance().Data.Collectables.RemoveItem(key);
}
else
{
var data = IndexDatabase.Instance().CombatItems.GetData(key);
Global.Instance().Data.Inventory.DropItemType(data);
}
}
protected void Play(DynValue filename, DynValue delay, bool blocks = true)
{
if (delay.IsNil())
{
RunRoutineFromLua(RunRoutineFromFile(filename.String, blocks));
}
else
{
RunRoutineFromLua(CoUtils.Wait(0.01f));
activeScripts.Peek().scriptRoutine.Resume();
Global.Instance().StartCoroutine(CoUtils.RunAfterDelay((float)delay.Number, () => {
Global.Instance().StartCoroutine(RunRoutineFromFile(filename.String));
}));
}
}
public static DynValue random(ScriptExecutionContext executionContext, CallbackArguments args)
{
DynValue m = args.AsType(0, "random", DataType.Number, true);
DynValue n = args.AsType(1, "random", DataType.Number, true);
Random R = GetRandom(executionContext.GetScript());
double d;
if (m.IsNil() && n.IsNil())
{
d = R.NextDouble();
}
else
{
int a = n.IsNil() ? 1 : (int)n.Number;
int b = (int)m.Number;
if (a < b)
d = R.Next(a, b + 1);
else
d = R.Next(b, a + 1);
}
return DynValue.NewNumber(d);
}
private DynValue GetNext(DynValue prev)
{
if (prev.IsNil())
Reset();
while (m_Enumerator.MoveNext())
{
DynValue v = ClrToScriptConversions.ObjectToDynValue(m_Script, m_Enumerator.Current);
if (!v.IsNil())
return v;
}
return DynValue.Nil;
}
private void AddItem(DynValue itemLua, DynValue isCollectableLua)
{
var key = itemLua.String;
var isCollectable = !isCollectableLua.IsNil() && isCollectableLua.Boolean;
if (isCollectable)
{
Global.Instance().Data.Collectables.AddItem(key);
}
else
{
var data = IndexDatabase.Instance().CombatItems.GetData(key);
var item = new CombatItem(data);
Global.Instance().Data.Inventory.Add(item);
}
}
private void PathEvent(DynValue moverLua, DynValue targetLua, DynValue waitLua)
{
var map = Global.Instance().Maps.ActiveMap;
var mover = map.GetEventNamed(moverLua.String);
var target = map.GetEventNamed(targetLua.String);
var routine = mover.PathToRoutine(target.Position, ignoreEvents: true);
if (waitLua.IsNil() || waitLua.Boolean)
{
RunRoutineFromLua(routine);
}
else
{
mover.StartCoroutine(routine);
}
}
public IEnumerable <Table> get_Entradas_Funciones(string nombre_funcion)
{
DynValue funcion = script.Globals.Get(nombre_funcion);
if (funcion.IsNil() || funcion.Type != DataType.Function)
{
return(null);
}
DynValue resultado = script.Call(funcion);
if (resultado.Type != DataType.Table)
{
return(null);
}
return(resultado.Table.Values.Where(f => f.Type == DataType.Table).Select(f => f.Table));
}
public T get_Global_Or <T>(string key, DataType tipo, T valor_or)
{
DynValue global = script.Globals.Get(key);
if (global.IsNil() || global.Type != tipo)
{
return(valor_or);
}
try
{
return((T)global.ToObject(typeof(T)));
}
catch
{
return(valor_or);
}
}
private static DynValue __tostring_continuation(ScriptExecutionContext executionContext, CallbackArguments args)
{
DynValue b = args[0].ToScalar();
if (b.IsNil())
{
return(b);
}
if (b.Type != DataType.String)
{
throw new ScriptRuntimeException("'tostring' must return a string");
}
return(b);
}
private static DynValue loadfile_impl(ScriptExecutionContext executionContext, CallbackArguments args, Table defaultEnv)
{
try
{
Script S = executionContext.GetScript();
DynValue filename = args.AsType(0, "loadfile", DataType.String, false);
DynValue env = args.AsType(2, "loadfile", DataType.Table, true);
DynValue fn = S.LoadFile(filename.String, env.IsNil() ? defaultEnv : env.Table);
return(fn);
}
catch (SyntaxErrorException ex)
{
return(DynValue.NewTuple(DynValue.Nil, DynValue.NewString(ex.Message)));
}
}
private CaminhoNodeType FromString(DynValue val)
{
if (val.IsNil())
{
return(CaminhoNodeType.Error);
}
else if (val.String == "text")
{
return(CaminhoNodeType.Text);
}
else if (val.String == "choice")
{
return(CaminhoNodeType.Choice);
}
else if (val.String == "wait")
{
return(CaminhoNodeType.Choice);
}
else if (val.String == "event")
{
return(CaminhoNodeType.Choice);
}
else if (val.String == "function")
{
return(CaminhoNodeType.Function);
}
else if (val.String == "set")
{
return(CaminhoNodeType.Set);
}
else if (val.String == "increment")
{
return(CaminhoNodeType.Increment);
}
else if (val.String == "decrement")
{
return(CaminhoNodeType.Increment);
}
else if (val.String == "conditional")
{
return(CaminhoNodeType.Error);
}
return(CaminhoNodeType.Error);
}
public DynValue GetVar(Script caller, string key)
{
if (key == null)
{
throw new CYFException("script.GetVar: The first argument (key) is nil.\n\nSee the documentation for proper usage.");
}
DynValue value = script.Globals.Get(key);
if (value == null || value.IsNil())
{
return(DynValue.NewNil());
}
if (caller == null)
{
return(value);
}
return(script.Globals[key] != null?MoonSharpUtil.CloneIfRequired(caller, value) : null);
}
private void Battle(DynValue partyLua, DynValue bgmLua)
{
var partyTag = partyLua.String;
var bgmTag = bgmLua.IsNil() ? null : bgmLua.String;
Party party = null;
var partyData = IndexDatabase.Instance().Parties.GetDataOrNull(partyTag);
if (partyData != null)
{
party = new Party(partyData);
}
else
{
var encounterData = IndexDatabase.Instance().Encounters.GetData(partyTag);
party = new Party(encounterData);
}
RunRoutineFromLua(BattleView.SpawnBattleRoutine(party, bgmTag));
}
public static T get_Or <T>(this Table table, string key, DataType type, T orValue)
{
DynValue bandera = table.Get(key);
if (bandera.IsNil() || bandera.Type != type)
{
return(orValue);
}
try
{
return((T)bandera.ToObject(typeof(T)));
}
catch
{
return(orValue);
}
}
public DynValue GetVar(Script caller, string key)
{
DynValue value = script.Globals.Get(key);
if (value == null || value.IsNil())
{
return(DynValue.NewNil());
}
if (caller == null)
{
return(value);
}
if (script.Globals[key] != null)
{
return(MoonSharpUtil.CloneIfRequired(caller, value));
}
return(null);
}
public T Get <T>(string key, DataType type, T value)
{
DynValue global = Script.Globals.Get(key);
if (global.IsNil() || global.Type != type)
{
return(value);
}
try
{
return((T)global.ToObject(typeof(T)));
}
catch (Exception)
{
return(value);
}
}
public static void MoonSharpInit(Table globalTable, Table ioTable)
{
DynValue package = globalTable.Get("package");
if (package.IsNil())
{
package = DynValue.NewTable(globalTable.OwnerScript);
globalTable["package"] = package;
}
else if (package.Type != DataType.Table)
{
throw new InternalErrorException("'package' global variable was found and it is not a table");
}
string cfg = System.IO.Path.DirectorySeparatorChar + "\n;\n?\n!\n-\n";
package.Table.Set("config", DynValue.NewString(cfg));
}
private void ExecIterPrep(Instruction i)
{
DynValue v = m_ValueStack.Pop();
if (v.Type != DataType.Tuple)
{
v = DynValue.NewTuple(v, DynValue.Nil, DynValue.Nil);
}
DynValue f = v.Tuple.Length >= 1 ? v.Tuple[0] : DynValue.Nil;
DynValue s = v.Tuple.Length >= 2 ? v.Tuple[1] : DynValue.Nil;
DynValue var = v.Tuple.Length >= 3 ? v.Tuple[2] : DynValue.Nil;
// MoonSharp additions - given f, s, var
// 1) if f is not a function and has a __iterator metamethod, call __iterator to get the triplet
// 2) if f is a table with no __call metamethod, use a default table iterator
if (f.Type != DataType.Function && f.Type != DataType.ClrFunction)
{
DynValue meta = this.GetMetamethod(f, "__iterator");
if (meta != null && !meta.IsNil())
{
v = this.GetScript().Call(meta, f, s, var);
f = v.Tuple.Length >= 1 ? v.Tuple[0] : DynValue.Nil;
s = v.Tuple.Length >= 2 ? v.Tuple[1] : DynValue.Nil;
var = v.Tuple.Length >= 3 ? v.Tuple[2] : DynValue.Nil;
m_ValueStack.Push(DynValue.NewTuple(f, s, var));
}
else if (f.Type == DataType.Table)
{
DynValue callmeta = this.GetMetamethod(f, "__call");
if (callmeta == null || callmeta.IsNil())
{
m_ValueStack.Push(EnumerableWrapper.ConvertTable(f.Table));
}
}
}
m_ValueStack.Push(DynValue.NewTuple(f, s, var));
}
public static DynValue tostring(ScriptExecutionContext executionContext, CallbackArguments args)
{
if (args.Count < 1)
{
throw ScriptRuntimeException.BadArgumentValueExpected(0, "tostring");
}
DynValue v = args[0];
DynValue tail = executionContext.GetMetamethodTailCall(v, "__tostring", v);
if (tail == null || tail.IsNil())
{
return(DynValue.NewString(v.ToPrintString()));
}
tail.TailCallData.Continuation = new CallbackFunction(__tostring_continuation, "__tostring");
return(tail);
}
public static DynValue assert(ScriptExecutionContext executionContext, CallbackArguments args)
{
DynValue v = args[0];
DynValue message = args[1];
if (!v.CastToBool())
{
if (message.IsNil())
{
throw new ScriptRuntimeException("assertion failed!"); // { DoNotDecorateMessage = true };
}
else
{
throw new ScriptRuntimeException(message.ToPrintString()); // { DoNotDecorateMessage = true };
}
}
return(DynValue.NewTupleNested(args.GetArray()));
}
private DynValue GetNext(DynValue prev)
{
if (prev.IsNil())
{
Reset();
}
while (m_Enumerator.MoveNext())
{
DynValue v = ConversionHelper.ClrObjectToComplexMoonSharpValue(m_Script, m_Enumerator.Current);
if (!v.IsNil())
{
return(v);
}
}
return(DynValue.Nil);
}
private DynValue GetNext(DynValue prev)
{
if (prev.IsNil())
{
Reset();
}
while (m_Enumerator.MoveNext())
{
DynValue v = ClrToScriptConversions.ObjectToDynValue(m_Script, m_Enumerator.Current);
if (!v.IsNil())
{
return(v);
}
}
return(DynValue.Nil);
}
public static DynValue insert(ScriptExecutionContext executionContext, CallbackArguments args)
{
DynValue vlist = args.AsType(0, "table.insert", DataType.Table, false);
DynValue vpos = args[1];
DynValue vvalue = args[2];
if (args.Count > 3)
{
throw new ScriptRuntimeException("wrong number of arguments to 'insert'");
}
int len = GetTableLength(executionContext, vlist);
Table list = vlist.Table;
if (vvalue.IsNil())
{
vvalue = vpos;
vpos = DynValue.NewNumber(len + (executionContext.OwnerScript.Options.ZeroIndexTables ? 0 : 1)); // + 1
}
if (vpos.Type != DataType.Number)
{
throw ScriptRuntimeException.BadArgument(1, "table.insert", DataType.Number, vpos.Type, false);
}
int pos = (int)vpos.Number;
if (pos > len + 1 || pos < (executionContext.OwnerScript.Options.ZeroIndexTables ? 0 : 1))
{
throw new ScriptRuntimeException("bad argument #2 to 'insert' (position out of bounds)");
}
for (int i = len; i >= pos; i--)
{
list.Set(i + 1, list.Get(i));
}
list.Set(pos, vvalue);
return(vlist);
}
private static int?AdjustIndex(string s, DynValue vi, int defval)
{
if (vi.IsNil())
{
return(defval);
}
int i = (int)Math.Round(vi.Number, 0);
if (i == 0)
{
return(null);
}
if (i > 0)
{
return(i - 1);
}
return(s.Length - i);
}
private static int SortComparer(ScriptExecutionContext executionContext, DynValue a, DynValue b, DynValue lt)
{
if (lt == null || lt.IsNil())
{
lt = executionContext.GetBinaryMetamethod(a, b, "__lt");
if (lt == null || lt.IsNil())
{
if (a.Type == DataType.Number && b.Type == DataType.Number)
return a.Number.CompareTo(b.Number);
if (a.Type == DataType.String && b.Type == DataType.String)
return a.String.CompareTo(b.String);
throw ScriptRuntimeException.CompareInvalidType(a, b);
}
return LuaComparerToClrComparer(
executionContext.GetScript().Call(lt, a, b),
executionContext.GetScript().Call(lt, b, a));
}
return LuaComparerToClrComparer(
executionContext.GetScript().Call(lt, a, b),
executionContext.GetScript().Call(lt, b, a));
}
private static int? AdjustIndex(string s, DynValue vi, int defval)
{
if (vi.IsNil())
return defval;
var i = (int) Math.Round(vi.Number, 0);
if (i == 0)
return null;
if (i > 0)
return i - 1;
return s.Length - i;
}
private static bool IsValueJsonCompatible(DynValue value)
{
return value.Type == DataType.Boolean || value.IsNil() ||
value.Type == DataType.Number || value.Type == DataType.String ||
value.Type == DataType.Table ||
(JsonNull.IsJsonNull(value));
}
