public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
{
LuaValue value = null;
try {LuaValue.GetKeyValue(baseValue, new LuaString(this.Method)); } catch (Exception) { }
LuaFunction function = value as LuaFunction;
if (function != null)
{
if (this.Args.Table != null)
{
return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) });
}
else if (this.Args.String != null)
{
return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) });
}
else
{
List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
args.Insert(0, baseValue);
return function.Function.Invoke(args.ToArray());
}
} // method call on table would be like _G:script()
else if ((baseValue as LuaTable) != null)
{
List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
return ((baseValue as LuaTable).MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray());
}
else if ((baseValue as LuaClass) != null)
{
LuaClass c = baseValue as LuaClass;
List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
args.Insert(0, new LuaString(this.Method));
if (c.Self.MetaTable == null)
c.GenerateMetaTable();
return (c.Self.MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray());
}
else if ((baseValue as LuaUserdata) != null)
{
List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
LuaUserdata obj = baseValue as LuaUserdata;
object o = obj.Value;
if (obj.MetaTable != null)
{
if (obj.MetaTable.GetValue(this.Method) != null)
{
LuaValue o2 = obj.MetaTable.GetValue(this.Method);
if ((o2 as LuaFunction) != null)
return (o2 as LuaFunction).Invoke(args.ToArray());
else if ((o2 as LuaTable) != null)
throw new NotImplementedException(); // TODO
}
}
return ObjectToLua.ToLuaValue(o.GetType().GetMethod(this.Method, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Invoke(o, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args.ToArray(), CultureInfo.CurrentCulture));
}
else
{
throw new Exception("Invoke method call on non function value.");
}
}
public static LuaValue IsClass(LuaValue[] args)
{
if ((args[0] as LuaClass) != null)
return LuaBoolean.True;
else
return LuaBoolean.False;
}
public static LuaValue open(LuaValue[] values)
{
//[PixelCrushers]LuaString file = values[0] as LuaString;
LuaString modeStr = values.Length > 1 ? values[1] as LuaString : null;
string mode = modeStr == null ? "r" : modeStr.Text;
switch (mode)
{
case "r":
case "r+":
//[PixelCrushers]StreamReader reader = File.OpenText(file.Text);
//[PixelCrushers]return new LuaUserdata(reader, FileLib.CreateMetaTable());
return null;
case "w":
case "w+":
//[PixelCrushers]StreamWriter writer = File.CreateText(file.Text);
//[PixelCrushers]return new LuaUserdata(writer, FileLib.CreateMetaTable());
return null;
case "a":
case "a+":
//[PixelCrushers]writer = File.AppendText(file.Text);
//[PixelCrushers]return new LuaUserdata(writer, FileLib.CreateMetaTable());
return null;
default:
throw new ArgumentException("Invalid file open mode " + mode);
}
}
public static LuaValue Yield(LuaValue[] args)
{
LuaCoroutine c = args[0] as LuaCoroutine;
c.Pause();
// TODO: set restart args
return LuaNil.Nil;
}
public static LuaValue Wrap(LuaValue[] args)
{
LuaFunction f = args[0] as LuaFunction;
LuaCoroutine c = new LuaCoroutine(f);
LuaFunction f2 = new LuaFunction(new LuaFunc(delegate(LuaValue[] args2) { return LuaBoolean.From(c.Resume(args2)); }));
return f2;
}
public static LuaValue Date(LuaValue[] values)
{
LuaString format = null;
if (values.Length > 0)
format = values[0] as LuaString;
if (format != null)
{
if (format.Text == "*t")
{
LuaTable table = new LuaTable();
DateTime now = DateTime.Now;
table.SetNameValue("year", new LuaNumber (now.Year));
table.SetNameValue("month", new LuaNumber (now.Month ));
table.SetNameValue("day", new LuaNumber (now.Day));
table.SetNameValue("hour", new LuaNumber (now.Hour));
table.SetNameValue("min", new LuaNumber (now.Minute));
table.SetNameValue("sec", new LuaNumber (now.Second));
table.SetNameValue("wday", new LuaNumber ((int)now.DayOfWeek));
table.SetNameValue("yday", new LuaNumber (now.DayOfYear));
table.SetNameValue("isdst", LuaBoolean.From(now.IsDaylightSavingTime()));
}
else
{
return new LuaString(DateTime.Now.ToString(format.Text));
}
}
return new LuaString(DateTime.Now.ToShortDateString());
}
public static LuaValue Concat(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
LuaString separator = values.Length > 1 ? values[1] as LuaString : LuaString.Empty;
LuaNumber startNumber = values.Length > 2 ? values[2] as LuaNumber : null;
LuaNumber endNumber = values.Length > 3 ? values[3] as LuaNumber : null;
int start = startNumber == null ? 1 : (int)startNumber.Number;
int end = endNumber == null ? table.Count : (int)endNumber.Number;
if (start > end)
{
return LuaString.Empty;
}
else
{
StringBuilder text = new StringBuilder();
for (int index = start; index < end; index++)
{
text.Append(table.GetValue(index).ToString());
text.Append(separator.Text);
}
text.Append(table.GetValue(end).ToString());
return new LuaString(text.ToString());
}
}
public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
{
LuaValue value = LuaValue.GetKeyValue(baseValue, new LuaString(this.Method));
LuaFunction function = value as LuaFunction;
if (function != null)
{
if (this.Args.Table != null)
{
return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) });
}
else if (this.Args.String != null)
{
return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) });
}
else
{
//[PixelCrushers]List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
List<LuaValue> args = LuaInterpreterExtensions.EvaluateAll(this.Args.ArgList, enviroment);
args.Insert(0, baseValue);
return function.Function.Invoke(args.ToArray());
}
}
else
{
throw new Exception("Invoke method call on non function value.");
}
}
public static LuaValue Lines(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
TextReader reader = data.Value as TextReader;
LuaFunction func = new LuaFunction((LuaValue[] args) =>
{
LuaUserdata _data = values[0] as LuaUserdata;
TextReader _reader = data.Value as TextReader;
string line = _reader.ReadLine();
if (line != null)
{
return new LuaString(line);
}
else
{
return LuaNil.Nil;
}
}
);
return new LuaMultiValue(new LuaValue[] { func, data, LuaNil.Nil });
}
public static LuaValue CreateClass(LuaValue[] args)
{
LuaTable from = new LuaTable();
if (args.Length > 0)
if (args[0].GetTypeCode() == "table" && ((IsClass(new LuaValue[] {args[0]}) as LuaBoolean).BoolValue == false))
from = args[0] as LuaTable;
LuaClass nClass = new LuaClass("CLASS_" + classCount++, false, false);
List<LuaClass> Parents = new List<LuaClass>();
for (int i = 0; i < args.Length; i++)
{
LuaClass c = args[i] as LuaClass;
if (c == null)
continue;
if (c.Final)
throw new Exception("Cannot inherit from a final class");
else
{
Parents.Add(c);
c.ChildClasses.Add(nClass);
}
}
nClass.ParentClasses = Parents;
TableLib.Copy(new LuaValue[] {nClass.Self, from});
return nClass;
}
public static LuaValue DiffTime(LuaValue[] args)
{
// FIXM
DateTime t2 = DateTime.Parse(args[0].Value.ToString());
DateTime t1 = DateTime.Parse(args[1].Value.ToString());
return new LuaUserdata(t2 - t1);
}
public static LuaValue Flush(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
TextWriter writer = data.Value as TextWriter;
writer.Flush();
return null;
}
private static LuaFunction GetMetaFunction(string name, LuaValue leftValue, LuaValue rightValue)
{
LuaTable left = leftValue as LuaTable;
if (left != null)
{
LuaFunction func = left.GetValue(name) as LuaFunction;
if (func != null)
{
return func;
}
}
LuaFunction f = leftValue.MetaTable.GetValue(name) as LuaFunction;
if (f != null)
return f;
LuaTable right = rightValue as LuaTable;
if (right != null)
{
return right.GetValue(name) as LuaFunction;
}
f = rightValue.MetaTable.GetValue(name) as LuaFunction;
if (f != null)
return f;
return null;
}
public VariableUpdateEventArgs(VariableUpdateType type, LuaValue thread, VariableDetails[] vars, bool cacheFlush)
{
mType = type;
mThread = thread;
mVariables = vars;
mCacheFlush = cacheFlush;
}
public static LuaValue Copy(LuaValue[] args)
{
LuaTable _new = (LuaTable) args[0];
LuaTable old = (LuaTable) args[1];
if (_new == null)
throw new ArgumentNullException("Table to copy to cannot be nil!");
if (old == null)
throw new ArgumentNullException("Table to copy from cannot be nil!");
if (old.Count == 0)
return _new; // nothing to copy
Dictionary<LuaValue, LuaValue> oldFields = (Dictionary<LuaValue, LuaValue>)old.KeyValuePairs;
List<LuaValue> keys = new List<LuaValue>();
List<LuaValue> values = new List<LuaValue>();
foreach (LuaValue key in oldFields.Keys)
keys.Add(key);
foreach (LuaValue val in oldFields.Values)
values.Add(val);
// add to new table
for (int i = 0; i < keys.Count; i++)
{
try {
_new.SetKeyValue(keys[i], values[i]);
} catch (Exception ex) {
throw new Exception("Error copying at index " + i + ": " + ex.Message);
}
}
return _new;
}
public static LuaValue[] UnWrapLuaValues(LuaValue[] values)
{
if (values == null || values.Length == 0 || ContainsMultiValue(values) == false)
return values;
if (values.Length == 1 && values[0] is LuaMultiValue)
return (values[0] as LuaMultiValue).Values;
List<LuaValue> neatValues = new List<LuaValue>(values.Length);
for (int i = 0; i < values.Length - 1; i++)
{
LuaValue value = values[i];
LuaMultiValue multiValue = value as LuaMultiValue;
if (multiValue != null)
neatValues.Add(multiValue.Values[0]);
else
neatValues.Add(value);
}
LuaValue lastValue = values[values.Length - 1];
LuaMultiValue lastMultiValue = lastValue as LuaMultiValue;
if (lastMultiValue != null)
neatValues.AddRange(lastMultiValue.Values);
else
neatValues.Add(lastValue);
return neatValues.ToArray();
}
public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
{
LuaValue value = LuaValue.GetKeyValue(baseValue, new LuaString(this.Method));
LuaFunction function = value as LuaFunction;
if (function != null)
{
if (this.Args.Table != null)
{
return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) });
}
else if (this.Args.String != null)
{
return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) });
}
else
{
// List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
List<LuaValue> args = new List<LuaValue>();
foreach (var arg in this.Args.ArgList)
args.Add(arg.Evaluate(enviroment));
args.Insert(0, baseValue);
return function.Function.Invoke(args.ToArray());
}
}
else
{
throw new Exception("Invoke method call on non function value.");
}
}
/// <summary>
/// Sets the assignment
/// </summary>
/// <param name="baseValue"></param>
/// <param name="key"></param>
/// <param name="value"></param>
private static void SetKeyValue(LuaValue baseValue, LuaValue key, LuaValue value)
{
LuaValue newIndex = LuaNil.Nil;
LuaTable table = baseValue as LuaTable;
if (table != null)
{
if (table.MetaTable != null)
{
newIndex = table.MetaTable.GetValue("__newindex");
// to be finished at the end of this method
}
if (newIndex == LuaNil.Nil)
{
table.SetKeyValue(key, value);
return;
}
}
else if ((baseValue as LuaClass) != null)
{
LuaClass c = baseValue as LuaClass;
// null checks (mainly for debugging)
if (c.Self.MetaTable == null)
c.GenerateMetaTable();
//throw new Exception("Class metatable is nil!");
newIndex = c.Self.MetaTable.GetValue("__newindex");
if (newIndex == LuaNil.Nil)
c.Self.SetKeyValue(key, value);
else
(newIndex as LuaFunction).Invoke(new LuaValue[] { baseValue, key, value });
return;
}
else
{
LuaUserdata userdata = baseValue as LuaUserdata;
if (userdata != null)
{
if (userdata.MetaTable != null)
{
newIndex = userdata.MetaTable.GetValue("__newindex");
}
if (newIndex == LuaNil.Nil)
{
throw new Exception("Assign field of userdata without __newindex defined.");
}
}
}
LuaFunction func = newIndex as LuaFunction;
if (func != null)
{
func.Invoke(new LuaValue[] { baseValue, key, value });
}
else
{
SetKeyValue(newIndex, key, value);
}
}
public void WriteValue(LuaValue value)
{
Write((int)value.Type);
if (value.Type == LuaValueType.NUMBER)
WriteNumber(value.AsNumber());
else
WriteObjectID(value.Value);
}
public static LuaValue RunApp(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
Form form = (Form)data.Value;
form.PerformLayout();
Application.Run(form);
return null;
}
public static LuaValue Create(LuaValue[] args)
{
LuaFunction func = args[0] as LuaFunction;
if (func == null)
throw new ArgumentException("Function expected, got '" + args[0].Value.GetType().Name + "'");
LuaCoroutine c = new LuaCoroutine(func);
return c;
}
public static LuaValue WrapLuaValues(LuaValue[] values)
{
if (values == null || values.Length == 0)
return LuaNil.Nil;
else if (values.Length == 1)
return values[0];
else
return new LuaMultiValue(UnWrapLuaValues(values));
}
private static bool ContainsMultiValue(LuaValue[] values)
{
foreach (LuaValue value in values)
{
if (value is LuaMultiValue)
return true;
}
return false;
}
public static LuaValue setmetatable(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
LuaTable metatable = values[1] as LuaTable;
table.MetaTable = metatable;
return null;
}
public static LuaValue Execute(LuaValue[] values)
{
if (values.Length > 0)
{
LuaString command = values[0] as LuaString;
System.Diagnostics.Process.Start(command.Text);
}
return new LuaNumber (1);
}
public bool Any(LuaValue[] collection, LuaFunction func)
{
foreach (var c in collection)
using (var ret = func.Call(c))
using (var result = ret.FirstOrDefault())
if (result != null && result.ToBoolean())
return true;
return false;
}
public LuaValue InvokeMethod(LuaValue[] args)
{
if (Method == null || args == null) return LuaNil.Nil;
object[] objectArgs = new object[args.Length];
for (int i = 0; i < args.Length; i++) {
objectArgs[i] = LuaInterpreterExtensions.LuaValueToObject(args[i]);
}
object result = Method.Invoke(Target, objectArgs);
return LuaInterpreterExtensions.ObjectToLuaValue(result);
}
// Lua function for formatting strings
public static LuaValue format(LuaValue[] values)
{
LuaString format = values[0] as LuaString;
object[] args = new object[values.Length - 1];
for (int i = 0; i < args.Length; i++)
{
args[i] = values[i + 1].Value;
}
return new LuaString(string.Format(format.Text, args));
}
public static LuaValue Find(LuaValue[] args)
{
LuaValue v = args[0] as LuaValue;
LuaTable t = args[1] as LuaTable;
foreach (LuaValue key in t.Keys)
if (key.Value == v.Value)
return key;
return LuaNil.Nil;
}
public static LuaValue rep(LuaValue[] values)
{
LuaString str = values[0] as LuaString;
LuaNumber number = values[1] as LuaNumber;
StringBuilder text = new StringBuilder();
for (int i = 0; i < number.Number; i++)
{
text.Append(str.Text);
}
return new LuaString(text.ToString());
}
static bool ConvertToBoolean(LuaValue val) => val.Value switch
{
null => false,
public static LuaValue GSub(LuaValue[] args)
{
int totalReplaces = 0;
// string.gsub (s, pattern, repl [, n])
string s = args[0].ToString();
string format = args[1].ToString();
LuaValue r = args[2];
int n = -1;
if (args.Length > 3)
{
n = int.Parse(args[3].ToString());
}
Regex re = new Regex(format);
Match m = re.Match(s);
string result = string.Empty;
int lastposition = 0;
while (m.Success && (n < 0 || totalReplaces < n))
{
for (int i = 0; i < m.Groups.Count; i++)
{
Group g = m.Groups[i];
CaptureCollection cc = g.Captures;
for (int j = 0; j < cc.Count; j++)
{
Capture c = cc[j];
if (r is LuaString)
{
result += s.Substring(lastposition, c.Index - lastposition) + (r as LuaString).Text;
}
else if (r is LuaFunction)
{
object o = (r as LuaFunction).Invoke(new LuaValue[] { new LuaString(c.Value) });
string s2 = c.Value;
if (o != null && o != LuaNil.Nil)
{
s2 = o.ToString();
}
result += s.Substring(lastposition, c.Index - lastposition) + s2;
}
else if (r is LuaTable)
{
result += s.Substring(lastposition, c.Index - lastposition) + ((r as LuaTable).GetValue(c.Value) == null || (r as LuaTable).GetValue(c.Value) == LuaNil.Nil ? s.Substring(c.Index, c.Length) : (r as LuaTable).GetValue(c.Value).ToString());
}
lastposition = c.Index + c.Length;
totalReplaces++;
if (n > -1 && totalReplaces == n)
{
break;
}
}
}
m = m.NextMatch();
}
result += s.Substring(lastposition);
return(new LuaMultiValue(new LuaValue[] { new LuaString(result), new LuaNumber(totalReplaces) }));
}
public LuaArgs date(LuaArgs args)
{
string format;
if (!args.IsNil(0))
{
format = args.GetString(0);
}
else
{
format = "%c";
}
DateTime time;
if (!args.IsNil(1))
{
var seconds = args.GetDouble(1);
time = DateFromTime(seconds);
}
else
{
var clockDevice = FindClock();
if (clockDevice != null)
{
time = clockDevice.Time;
}
else
{
time = DateFromTime(0.0);
}
}
if (format.StartsWith("!", StringComparison.InvariantCulture))
{
time = time.ToUniversalTime();
format = format.Substring(1);
}
else
{
time = time.ToLocalTime();
}
if (format.Equals("*t"))
{
var result = new LuaTable(10);
result["year"] = new LuaValue(time.Year);
result["month"] = new LuaValue(time.Month);
result["day"] = new LuaValue(time.Day);
result["hour"] = new LuaValue(time.Hour);
result["min"] = new LuaValue(time.Minute);
result["sec"] = new LuaValue(time.Second);
result["wday"] = new LuaValue((int)time.DayOfWeek + 1);
result["yday"] = new LuaValue(time.DayOfYear);
result["isdst"] = new LuaValue(time.IsDaylightSavingTime());
result["isutc"] = new LuaValue(time.Kind == DateTimeKind.Utc);
return(new LuaArgs(result));
}
else
{
try
{
return(new LuaArgs(StrFTime(time, format)));
}
catch (FormatException e)
{
throw new LuaError(e.Message);
}
}
}
public LuaTable ReinforceWithTransport(Player owner, string actorType, string[] cargoTypes, CPos[] entryPath, CPos[] exitPath = null,
LuaFunction actionFunc = null, LuaFunction exitFunc = null, int dropRange = 3)
{
var transport = CreateActor(owner, actorType, true, entryPath[0], entryPath.Length > 1 ? entryPath[1] : (CPos?)null);
var cargo = transport.TraitOrDefault <Cargo>();
var passengers = new List <Actor>();
if (cargo != null && cargoTypes != null)
{
foreach (var cargoType in cargoTypes)
{
var passenger = CreateActor(owner, cargoType, false, entryPath[0]);
passengers.Add(passenger);
cargo.Load(transport, passenger);
}
}
for (var i = 1; i < entryPath.Length; i++)
{
Move(transport, entryPath[i]);
}
if (actionFunc != null)
{
var af = (LuaFunction)actionFunc.CopyReference();
transport.QueueActivity(new CallFunc(() =>
{
using (af)
using (LuaValue t = transport.ToLuaValue(Context), p = passengers.ToArray().ToLuaValue(Context))
af.Call(t, p);
}));
}
else
{
var aircraft = transport.TraitOrDefault <Aircraft>();
if (aircraft != null)
{
var destination = entryPath.Last();
// Try to find an alternative landing spot if we can't land at the current destination
if (!aircraft.CanLand(destination) && dropRange > 0)
{
var mobiles = cargo != null?cargo.Passengers.Select(a =>
{
var mobileInfo = a.Info.TraitInfoOrDefault <MobileInfo>();
if (mobileInfo == null)
{
return(new Pair <MobileInfo, uint>(null, 0));
}
return(new Pair <MobileInfo, uint>(mobileInfo, (uint)mobileInfo.GetMovementClass(a.World.Map.Rules.TileSet)));
}) : new Pair <MobileInfo, uint> [0];
foreach (var c in transport.World.Map.FindTilesInCircle(destination, dropRange))
{
if (!aircraft.CanLand(c))
{
continue;
}
if (!mobiles.All(m => m.First == null || domainIndex.IsPassable(destination, c, m.First, m.Second)))
{
continue;
}
destination = c;
break;
}
}
if (aircraft.Info.VTOL)
{
if (destination != entryPath.Last())
{
Move(transport, destination);
}
transport.QueueActivity(new Turn(transport, aircraft.Info.InitialFacing));
transport.QueueActivity(new HeliLand(transport, true));
}
else
{
transport.QueueActivity(new Land(transport, Target.FromCell(transport.World, destination)));
}
transport.QueueActivity(new Wait(15));
}
if (cargo != null)
{
transport.QueueActivity(new UnloadCargo(transport, true));
transport.QueueActivity(new WaitFor(() => cargo.IsEmpty(transport)));
}
transport.QueueActivity(new Wait(aircraft != null ? 50 : 25));
}
if (exitFunc != null)
{
var ef = (LuaFunction)exitFunc.CopyReference();
transport.QueueActivity(new CallFunc(() =>
{
using (ef)
using (var t = transport.ToLuaValue(Context))
ef.Call(t);
}));
}
else if (exitPath != null)
{
foreach (var wpt in exitPath)
{
Move(transport, wpt);
}
transport.QueueActivity(new RemoveSelf());
}
var ret = Context.CreateTable();
using (LuaValue
tKey = 1,
tValue = transport.ToLuaValue(Context),
pKey = 2,
pValue = passengers.ToArray().ToLuaValue(Context))
{
ret.Add(tKey, tValue);
ret.Add(pKey, pValue);
}
return(ret);
}
/// <summary>
/// 解析脚本按钮点击
/// </summary>
public void evalScriptButtonClickedHandler()
{
LuaValue retValue = LuaContext.currentContext.evalScript("print(10);return 'Hello World';");
Debug.Log(string.Format("{0}", retValue.toString()));
}
public static Vector3d valueToVector3d(LuaValue val)
{
Vector3d ret = Vector3d.zero;
LuaTable t = val as LuaTable;
LuaString s = val as LuaString;
if (t != null)
{
try
{
ret.x = (t.GetValue(1) as LuaNumber).Number;
}
catch (Exception)
{
throw new ArgumentException("Invalid vector x value");
}
try
{
ret.y = (t.GetValue(2) as LuaNumber).Number;
}
catch (Exception)
{
throw new ArgumentException("Invalid vector y value");
}
try
{
ret.z = (t.GetValue(3) as LuaNumber).Number;
}
catch (Exception)
{
throw new ArgumentException("Invalid vector z value");
}
}
else if (s != null)
{
switch (s.Text)
{
case "forward":
case "f":
ret = Vector3d.forward;
break;
case "back":
case "b":
ret = Vector3d.back;
break;
case "left":
case "l":
ret = Vector3d.left;
break;
case "right":
case "r":
ret = Vector3d.right;
break;
case "up":
case "u":
ret = Vector3d.up;
break;
case "down":
case "d":
ret = Vector3d.down;
break;
default:
throw new ArgumentException("Invalid vector string");
}
}
else
{
throw new ArgumentException("Invalid vector");
}
return(ret);
}
public void Add(string key, LuaValue value)
{
_table.Add(key, value);
}
public static bool TryGetClrValue(this LuaValue value, Type t, out object clrObject)
{
// Is t a nullable?
// If yes, get the underlying type
var nullable = Nullable.GetUnderlyingType(t);
if (nullable != null)
{
t = nullable;
}
// Value wraps a CLR object
if (value.TryGetClrObject(out var temp))
{
if (temp.GetType() == t)
{
clrObject = temp;
return(true);
}
}
if (value is LuaNil && !t.IsValueType)
{
clrObject = null;
return(true);
}
if (value is LuaBoolean && t.IsAssignableFrom(typeof(bool)))
{
clrObject = value.ToBoolean();
return(true);
}
if (value is LuaNumber && t.IsAssignableFrom(typeof(double)))
{
clrObject = value.ToNumber().Value;
return(true);
}
// Need an explicit test for double -> int
// TODO: Lua 5.3 will introduce an integer type, so this will be able to go away
if (value is LuaNumber && t.IsAssignableFrom(typeof(int)))
{
clrObject = (int)value.ToNumber().Value;
return(true);
}
if (value is LuaNumber && t.IsAssignableFrom(typeof(short)))
{
clrObject = (short)value.ToNumber().Value;
return(true);
}
if (value is LuaNumber && t.IsAssignableFrom(typeof(byte)))
{
clrObject = (byte)value.ToNumber().Value;
return(true);
}
if (value is LuaString && t.IsAssignableFrom(typeof(string)))
{
clrObject = value.ToString();
return(true);
}
if (value is LuaFunction && t.IsAssignableFrom(typeof(LuaFunction)))
{
clrObject = value;
return(true);
}
if (value is LuaTable && t.IsAssignableFrom(typeof(LuaTable)))
{
clrObject = value;
return(true);
}
// Translate LuaTable<int, object> -> object[]
if (value is LuaTable && t.IsArray)
{
var innerType = t.GetElementType();
var table = (LuaTable)value;
var array = Array.CreateInstance(innerType, table.Count);
var i = 0;
foreach (var kv in table)
{
using (kv.Key)
{
object element;
if (innerType == typeof(LuaValue))
{
element = kv.Value;
}
else
{
var elementHasClrValue = kv.Value.TryGetClrValue(innerType, out element);
if (!elementHasClrValue || !(element is LuaValue))
{
kv.Value.Dispose();
}
if (!elementHasClrValue)
{
throw new LuaException($"Unable to convert table value of type {kv.Value.WrappedClrType()} to type {innerType}");
}
}
array.SetValue(element, i++);
}
}
clrObject = array;
return(true);
}
// Value isn't of the requested type.
// Set a default output value and return false
// Value types are assumed to specify a default constructor
clrObject = t.IsValueType ? Activator.CreateInstance(t) : null;
return(false);
}
public LuaValue this[LuaRuntime runtime, LuaValue keyValue]
{
get => luaInterface.Value[runtime, keyValue];
public ElementData(string key, LuaValue value, DataSyncType syncType)
{
this.Key = key;
this.Value = value;
this.SyncType = syncType;
}
public static LuaValue ToLuaValue(this object obj, ScriptContext context)
{
if (obj is LuaValue)
{
return((LuaValue)obj);
}
if (obj == null)
{
return(LuaNil.Instance);
}
if (obj is double)
{
return((LuaValue)(double)obj);
}
if (obj is int)
{
return((LuaValue)(int)obj);
}
if (obj is bool)
{
return((LuaValue)(bool)obj);
}
if (obj is string)
{
return((LuaValue)(string)obj);
}
if (obj is IScriptBindable)
{
// Object needs additional notification / context
var notify = obj as IScriptNotifyBind;
if (notify != null)
{
notify.OnScriptBind(context);
}
return(new LuaCustomClrObject(obj));
}
if (obj is Array)
{
var array = (Array)obj;
var i = 1;
var table = context.CreateTable();
foreach (var x in array)
{
using (LuaValue key = i++, value = x.ToLuaValue(context))
table.Add(key, value);
}
return(table);
}
throw new InvalidOperationException("Cannot convert type '{0}' to Lua. Class must implement IScriptBindable.".F(obj.GetType()));
}
System.Collections.IEnumerator LoadCoroutine()
{
// Verify that the directory exists and grab its files.
string directoryPath = FAGameComponent.Instance.MakeAbsolutePath("/units/" + _unitID);
DirectoryInfo directory = new DirectoryInfo(directoryPath);
if (!directory.Exists)
{
Debug.LogError(directoryPath + " does not exist.");
yield break;
}
IEnumerable <FileInfo> directoryFiles = directory.GetFiles();
// Load the BP, so we know what mesh, animations, and textures to load and what shaders to load.
FileInfo blueprintFile = directoryFiles.FirstOrDefault(x => x.Name.EndsWith("_unit.bp", StringComparison.CurrentCultureIgnoreCase));
if (blueprintFile == null || !blueprintFile.Exists)
{
Debug.LogError(directoryPath + " does not contain a unit blueprint.");
yield break;
}
BPImporter.Load(gameObject, blueprintFile);
_blueprint = GetComponent <BPComponent>();
yield return(null);
// Save the BP to test the BP exporter.
FileInfo blueprintFileExport = new FileInfo(directoryPath + "/exportTest.bp");
BPExporter.Save(_blueprint, blueprintFileExport);
yield return(null);
// Get the LOD0 files.
LODFiles lod0 = GetLODFiles(0, directoryFiles);
if (lod0.mesh == null)
{
Debug.LogError(directoryPath + " does not contain an LOD0.scm file.");
yield break;
}
// Load the mesh.
SCMImporter.Load(gameObject, lod0.mesh);
// Apply the blueprint's scale.
LuaValue scaleVal = _blueprint.Get("Display.UniformScale");
float scale = (scaleVal == null || scaleVal.LVT != LuaValueType.LVT_Float) ? 1.0f : scaleVal.FloatValue;
transform.root.localScale = new Vector3(scale, scale, scale);
yield return(null);
// Iteratively load the DDS files.
for (DDSImporter.LoadStages i = DDSImporter.LoadStages.Init; i < DDSImporter.LoadStages.Count; ++i)
{
bool success = DDSImporter.LoadStage(i, gameObject, lod0);
yield return(null);
if (!success)
{
break;
}
}
// Load the SCAs referenced in the blueprint.
List <FileInfo> scaFiles = GetSCAFiles();
foreach (FileInfo scaFile in scaFiles)
{
SCAImporter.Load(gameObject, scaFile);
yield return(null);
}
Animation animComponent = gameObject.GetComponentInParent <Animation>();
/*if (animComponent.GetClipCount() > 0)
* {
* Debug.Log("Playing animation " + scaFiles[0].Name);
* animComponent.clip = animComponent.GetClip(scaFiles[0].Name);
* animComponent.Play(scaFiles[0].Name);
* }*/
}
public void Add(LuaValue Val)
{
Items.Add(Val.ToStringAsValue() + ",");
}
public LuaKV(String Key, LuaValue Value) : this(new LuaString(Key, LuaStringStyle.Identifier), Value)
{
}
public Triggerable(LuaFunction function, ScriptContext context, Actor self)
{
Function = (LuaFunction)function.CopyReference();
Context = context;
Self = self.ToLuaValue(Context);
}
public bool TryGetValue(string key, out LuaValue value)
{
return(_table.TryGetValue(key, out value));
}
public partial void Parse(LuaValue luaValue);
public static void Load(GameObject gameObject, FileInfo bpFile)
{
BPComponent bpComponent = gameObject.GetComponent <BPComponent>();
using (StreamReader reader = new StreamReader(bpFile.OpenRead(), Encoding.UTF8))
{
Stack <TableBuilder> tableStack = new Stack <TableBuilder>();
StringBuilder input = new StringBuilder();
while (reader.Peek() >= 0)
{
char c = (char)reader.Read();
input.Append(c);
// Skip over whitespace.
if (char.IsWhiteSpace(c))
{
while (reader.Peek() >= 0)
{
char next = (char)reader.Peek();
if (char.IsWhiteSpace(next))
{
reader.Read();
}
else
{
break;
}
}
}
c = input[input.Length - 1];
// Equals denotes the end of an identifier.
if (c == '=')
{
input.Remove(input.Length - 1, 1);
string id = input.ToString();
id = id.Trim();
input.Remove(0, input.Length);
if (id.Length > 0)
{
tableStack.Peek().PushID(id);
}
}
// Number signs and -- indicate a comment.
else if (c == '#')
{
input.Remove(input.Length - 1, 1);
reader.ReadLine();
}
else if (c == '-')
{
if (reader.Peek() == '-')
{
input.Remove(input.Length - 1, 1);
reader.ReadLine();
}
}
// Quotes indicate the beginning of a string.
else if (c == '\"')
{
input.Remove(input.Length - 1, 1);
string val = ReadString(reader, '\"');
if (val == null)
{
Debug.LogError("String parse error.");
return;
}
TableBuilder builder = tableStack.Peek();
EncounteredString(builder.table, builder.PopID(), val);
}
else if (c == '\'')
{
input.Remove(input.Length - 1, 1);
string val = ReadString(reader, '\'');
if (val == null)
{
Debug.LogError("String parse error.");
return;
}
TableBuilder builder = tableStack.Peek();
EncounteredString(builder.table, builder.PopID(), val);
}
// Curly brace indicates a table.
else if (c == '{')
{
input.Remove(input.Length - 1, 1);
string tableName = input.ToString();
tableName = tableName.Trim();
input.Remove(0, input.Length);
if (tableName.Length == 0)
{
tableName = null;
}
StartTable(tableStack, tableName);
}
else if (c == '}')
{
input.Remove(input.Length - 1, 1);
LuaValue root = EndTable(tableStack);
if (root != null)
{
bpComponent.SetRoot(root);
break;
}
}
// Whitespace or comma denotes the end of a token.
else if (char.IsWhiteSpace(c) || c == ',')
{
input.Remove(input.Length - 1, 1);
string val = input.ToString();
val = val.Trim();
input.Remove(0, input.Length);
if (val.Length > 0)
{
if (val == "true")
{
TableBuilder builder = tableStack.Peek();
EncounteredBool(builder.table, builder.PopID(), true);
}
else if (val == "false")
{
TableBuilder builder = tableStack.Peek();
EncounteredBool(builder.table, builder.PopID(), false);
}
else if (val == "nil")
{
TableBuilder builder = tableStack.Peek();
EncounteredNil(builder.table, builder.PopID());
}
else
{
float f = 0.0f;
if (float.TryParse(val, out f))
{
TableBuilder builder = tableStack.Peek();
EncounteredFloat(builder.table, builder.PopID(), f);
}
else if (c != ',')
{
input.Append(val);
}
else
{
Debug.LogError("Token parse error: " + val + " " + c);
//input.Append(val);
}
}
}
}
}
}
}
public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
{
LuaValue key = this.Key.Evaluate(enviroment);
return(LuaValue.GetKeyValue(baseValue, key));
}
public abstract LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment);
public LuaValue Compare(LuaState luaState, int index1, int index2, TokenType opType)
{
LuaValue luaValue1 = luaState.Get(index1);
LuaValue luaValue2 = luaState.Get(index2);
try
{
return(operatorDic[opType](luaValue1, luaValue2));
}
catch (Exception e)
{
switch (opType)
{
case TokenType.Equal:
{
if ((bool)(luaValue1 != luaValue2).OValue)
{
LuaValue result = null;
try
{
if (luaState.CallMetaFunc(luaValue1, luaValue2, GetMetaFuncName(opType), out result))
{
return(result);
}
else
{
throw new Exception("没有找到对应的元方法进行比较！");
}
}
catch (Exception ee)
{
throw e;
}
}
else
{
return(luaValue1 == luaValue2);
}
}
default:
{
LuaValue result = null;
try
{
if (luaState.CallMetaFunc(luaValue1, luaValue2, GetMetaFuncName(opType), out result))
{
return(result);
}
else
{
throw new Exception("没有找到对应的元方法进行比较！");
}
}
catch (Exception ee)
{
throw e;
}
}
}
}
}
public LuaValue this[LuaRuntime runtime, LuaValue keyValue]
{
get { return(luaInterface.Value[runtime, keyValue]); }
set { luaInterface.Value[runtime, keyValue] = value; }
}
public LuaValue this[LuaValue key]
{
get => Get(key);
ActorInit CreateInit(string initName, LuaValue value)
{
// Find the requested type
var initInstance = initName.Split(ActorInfo.TraitInstanceSeparator);
var initType = Game.ModData.ObjectCreator.FindType(initInstance[0] + "Init");
if (initType == null)
{
throw new LuaException("Unknown initializer type '{0}'".F(initInstance[0]));
}
// Construct the ActorInit.
var init = (ActorInit)FormatterServices.GetUninitializedObject(initType);
if (initInstance.Length > 1)
{
initType.GetField("InstanceName").SetValue(init, initInstance[1]);
}
var compositeInit = init as CompositeActorInit;
var tableValue = value as LuaTable;
if (tableValue != null && compositeInit != null)
{
var args = compositeInit.InitializeArgs();
var initValues = new Dictionary <string, object>();
foreach (var kv in tableValue)
{
using (kv.Key)
using (kv.Value)
{
var key = kv.Key.ToString();
Type type;
if (!args.TryGetValue(key, out type))
{
throw new LuaException("Unknown initializer type '{0}.{1}'".F(initInstance[0], key));
}
object clrValue;
var isActorReference = type == typeof(ActorInitActorReference);
if (isActorReference)
{
type = kv.Value is LuaString ? typeof(string) : typeof(Actor);
}
if (!kv.Value.TryGetClrValue(type, out clrValue))
{
throw new LuaException("Invalid data type for '{0}.{1}' (expected {2}, got {3})".F(initInstance[0], key, type.Name, kv.Value.WrappedClrType()));
}
if (isActorReference)
{
clrValue = type == typeof(string) ? new ActorInitActorReference((string)clrValue) : new ActorInitActorReference((Actor)clrValue);
}
initValues[key] = clrValue;
}
}
compositeInit.Initialize(initValues);
return(init);
}
// HACK: Forward compatibility for future WAngle facings
var facingInit = init as FacingInit;
if (facingInit != null)
{
WAngle angle;
if (value.TryGetClrValue(out angle))
{
facingInit.Initialize(angle.Facing);
return(facingInit);
}
Game.Debug("Initializing Facing with integers is deprecated. Use Angle instead.");
}
var initializers = initType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.Where(m => m.Name == "Initialize" && m.GetParameters().Length == 1);
foreach (var initializer in initializers)
{
var parameterType = initializer.GetParameters().First().ParameterType;
var valueType = parameterType.IsEnum ? Enum.GetUnderlyingType(parameterType) : parameterType;
// Try and coerce the table value to the required type
object clrValue;
if (!value.TryGetClrValue(valueType, out clrValue))
{
continue;
}
initializer.Invoke(init, new[] { clrValue });
return(init);
}
var types = initializers.Select(y => y.GetParameters()[0].ParameterType.Name).JoinWith(", ");
throw new LuaException("Invalid data type for '{0}' (expected one of {1})".F(initInstance[0], types));
}
private static void SaveLuaValue(LuaValue luaValue, StreamWriter writer, string tableIndent)
{
switch (luaValue.LVT)
{
case LuaValueType.LVT_Nil:
{
writer.Write("Nil");
break;
}
case LuaValueType.LVT_String:
{
writer.Write('\'');
string sanitizedString = luaValue.StringValue;
sanitizedString.Replace("'", "\\'");
sanitizedString.Replace("\"", "\\\"");
writer.Write(sanitizedString);
writer.Write('\'');
break;
}
case LuaValueType.LVT_Float:
{
writer.Write(luaValue.FloatValue);
break;
}
case LuaValueType.LVT_Bool:
{
writer.Write(luaValue.BoolValue ? "true" : "false");
break;
}
case LuaValueType.LVT_Table:
{
LuaTable table = luaValue.TableValue;
if (table.Name != null)
{
writer.Write(table.Name);
writer.Write(' ');
}
writer.Write("{\n");
ICollection <string> tableKeys = table.Keys;
foreach (string tableKey in tableKeys)
{
writer.Write(tableIndent);
writer.Write(tableKey);
writer.Write(" = ");
LuaValue tableValue = null;
if (table.TryGetValue(tableKey, out tableValue))
{
SaveLuaValue(tableValue, writer, tableIndent + " ");
}
else
{
writer.Write("TABLE SAVE FAILURE");
}
writer.Write(",\n");
}
writer.Write(tableIndent.Substring(1));
writer.Write("}");
break;
}
default:
Debug.LogError("Invalid LVT.");
break;
}
}
public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
{
LuaValue value = null;
try { LuaValue.GetKeyValue(baseValue, new LuaString(this.Method)); } catch (Exception) { }
LuaFunction function = value as LuaFunction;
if (function != null)
{
if (this.Args.Table != null)
{
return(function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) }));
}
else if (this.Args.String != null)
{
return(function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) }));
}
else
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
args.Insert(0, baseValue);
return(function.Function.Invoke(args.ToArray()));
}
} // method call on table would be like _G:script()
else if ((baseValue as LuaTable) != null)
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
return(((baseValue as LuaTable).MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray()));
}
else if ((baseValue as LuaClass) != null)
{
LuaClass c = baseValue as LuaClass;
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
args.Insert(0, new LuaString(this.Method));
if (c.Self.MetaTable == null)
{
c.GenerateMetaTable();
}
return((c.Self.MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray()));
}
else if ((baseValue as LuaUserdata) != null)
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
LuaUserdata obj = baseValue as LuaUserdata;
object o = obj.Value;
if (obj.MetaTable != null)
{
if (obj.MetaTable.GetValue(this.Method) != null)
{
LuaValue o2 = obj.MetaTable.GetValue(this.Method);
if ((o2 as LuaFunction) != null)
{
return((o2 as LuaFunction).Invoke(args.ToArray()));
}
else if ((o2 as LuaTable) != null)
{
throw new NotImplementedException(); // TODO
}
}
}
return(ObjectToLua.ToLuaValue(o.GetType().GetMethod(this.Method, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Invoke(o, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args.ToArray(), CultureInfo.CurrentCulture)));
}
else
{
throw new Exception("Invoke method call on non function value.");
}
}
public static LuaValue Add(LuaValue a, LuaValue b)
{
return(LuaValue.Nil);
}
public LuaTable ReinforceWithTransport(Player owner, string actorType, string[] cargoTypes, CPos[] entryPath, CPos[] exitPath = null,
LuaFunction actionFunc = null, LuaFunction exitFunc = null, int dropRange = 3)
{
var transport = CreateActor(owner, actorType, true, entryPath[0], entryPath.Length > 1 ? entryPath[1] : (CPos?)null);
var cargo = transport.TraitOrDefault <Cargo>();
var passengers = new List <Actor>();
if (cargo != null && cargoTypes != null)
{
foreach (var cargoType in cargoTypes)
{
var passenger = CreateActor(owner, cargoType, false, entryPath[0]);
passengers.Add(passenger);
cargo.Load(transport, passenger);
}
}
for (var i = 1; i < entryPath.Length; i++)
{
Move(transport, entryPath[i]);
}
if (actionFunc != null)
{
var af = (LuaFunction)actionFunc.CopyReference();
transport.QueueActivity(new CallFunc(() =>
{
using (af)
using (LuaValue t = transport.ToLuaValue(Context), p = passengers.ToArray().ToLuaValue(Context))
af.Call(t, p);
}));
}
else
{
var aircraft = transport.TraitOrDefault <Aircraft>();
// Scripted cargo aircraft must turn to default position before unloading.
// TODO: pass facing through UnloadCargo instead.
if (aircraft != null)
{
transport.QueueActivity(new Land(transport, Target.FromCell(transport.World, entryPath.Last()), WDist.FromCells(dropRange), aircraft.Info.InitialFacing));
}
if (cargo != null)
{
transport.QueueActivity(new UnloadCargo(transport, WDist.FromCells(dropRange)));
}
}
if (exitFunc != null)
{
var ef = (LuaFunction)exitFunc.CopyReference();
transport.QueueActivity(new CallFunc(() =>
{
using (ef)
using (var t = transport.ToLuaValue(Context))
ef.Call(t);
}));
}
else if (exitPath != null)
{
foreach (var wpt in exitPath)
{
Move(transport, wpt);
}
transport.QueueActivity(new RemoveSelf());
}
var ret = Context.CreateTable();
using (LuaValue
tKey = 1,
tValue = transport.ToLuaValue(Context),
pKey = 2,
pValue = passengers.ToArray().ToLuaValue(Context))
{
ret.Add(tKey, tValue);
ret.Add(pKey, pValue);
}
return(ret);
}
public static void retainHandler(LuaFunction handler)
{
_func = new LuaValue(handler);
LuaContext.currentContext.retainValue(_func);
}
public LuaKV(LuaValue Key, LuaValue Value)
{
_Key = Key; _Value = Value;
}
