public override SubPacket CreateScriptBindPacket()
{
bool isEntranceDesion = false;
List <LuaParam> lParams;
lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, "", -1, canRideChocobo ? (byte)1 : (byte)0, canStealth, isInn, false, false, false, true, isInstanceRaid, isEntranceDesion);
return(ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams));
}
public static MetaInfo GetMetaInfo(byte[] meta)
{
string metaStr = LuaUtils.GetString(meta);
var lines = metaStr.Split('\n');
var metaStruct = new MetaInfo();
metaStruct.Name = lines[0];
metaStruct.Version = lines[1];
metaStruct.RuntimeVersion = System.Convert.ToInt32(lines[2]);
return(metaStruct);
}
public override SubPacket CreateScriptBindPacket()
{
List <LuaParam> lParams;
string path = className;
string realClassName = className.Substring(className.LastIndexOf("/") + 1);
lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, privateAreaName, privateAreaType, canRideChocobo ? (byte)1 : (byte)0, canStealth, isInn, false, false, false, false, false, false);
ActorInstantiatePacket.BuildPacket(actorId, actorName, realClassName, lParams).DebugPrintSubPacket();
return(ActorInstantiatePacket.BuildPacket(actorId, actorName, realClassName, lParams));
}
public EventStartPacket(byte[] data)
{
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryReader binReader = new BinaryReader(mem))
{
try{
actorID = binReader.ReadUInt32();
scriptOwnerActorID = binReader.ReadUInt32();
val1 = binReader.ReadUInt32();
val2 = binReader.ReadUInt32();
val3 = binReader.ReadByte();
/*
* //Lua Error Dump
* if (val1 == 0x39800010)
* {
* errorIndex = actorID;
* errorNum = scriptOwnerActorID;
* error = ASCIIEncoding.ASCII.GetString(binReader.ReadBytes(0x80)).Replace("\0", "");
*
* if (errorIndex == 0)
* Program.Log.Error("LUA ERROR:");
*
* return;
* }
*/
List <byte> strList = new List <byte>();
byte curByte;
while ((curByte = binReader.ReadByte()) != 0)
{
strList.Add(curByte);
}
triggerName = Encoding.ASCII.GetString(strList.ToArray());
binReader.BaseStream.Seek(0x31, SeekOrigin.Begin);
if (binReader.PeekChar() == 0x1)
{
luaParams = new List <LuaParam>();
}
else
{
luaParams = LuaUtils.ReadLuaParams(binReader);
}
}
catch (Exception) {
invalidPacket = true;
}
}
}
}
public void kickEvent(Actor actor, string conditionName, params object[] parameters)
{
if (actor == null)
{
return;
}
List <LuaParam> lParams = LuaUtils.createLuaParamList(parameters);
SubPacket spacket = KickEventPacket.buildPacket(actorId, actor.actorId, conditionName, lParams);
spacket.debugPrintSubPacket();
queuePacket(spacket);
}
static public int SwitchToLevel_s(IntPtr l)
{
try {
System.String a1;
checkType(l, 1, out a1);
LuaUtils.SwitchToLevel(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
public static SubPacket BuildPacket(uint sourceActorId, List <LuaParam> luaParams)
{
byte[] data = new byte[PACKET_SIZE - 0x20];
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
LuaUtils.WriteLuaParams(binWriter, luaParams);
}
}
return(new SubPacket(OPCODE, sourceActorId, data));
}
static public int ReadFileAsString_s(IntPtr l)
{
try {
System.String a1;
checkType(l, 1, out a1);
var ret = LuaUtils.ReadFileAsString(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public static SubPacket buildPacket(uint playerActorID, uint targetActorID, List <LuaParam> luaParams)
{
byte[] data = new byte[PACKET_SIZE - 0x20];
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
LuaUtils.writeLuaParams(binWriter, luaParams);
}
}
return(new SubPacket(OPCODE, playerActorID, targetActorID, data));
}
public List <LuaParam> CallLuaFunctionForReturn(Player player, Actor target, string funcName, bool optional, params object[] args)
{
//Need a seperate case for NPCs cause that child/parent thing.
if (target is Npc)
{
return(CallLuaFunctionNpcForReturn(player, (Npc)target, funcName, optional, args));
}
object[] args2 = new object[args.Length + (player == null ? 1 : 2)];
Array.Copy(args, 0, args2, (player == null ? 1 : 2), args.Length);
if (player != null)
{
args2[0] = player;
args2[1] = target;
}
else
{
args2[0] = target;
}
string luaPath = GetScriptPath(target);
LuaScript script = LoadScript(luaPath);
if (script != null)
{
if (!script.Globals.Get(funcName).IsNil())
{
//Run Script
DynValue result = script.Call(script.Globals[funcName], args2);
List <LuaParam> lparams = LuaUtils.CreateLuaParamList(result);
return(lparams);
}
else
{
if (!optional)
{
SendError(player, String.Format("Could not find function '{0}' for actor {1}.", funcName, target.GetName()));
}
}
}
else
{
if (!optional)
{
SendError(player, String.Format("Could not find script for actor {0}.", target.GetName()));
}
}
return(null);
}
public override SubPacket createScriptBindPacket(uint playerActorId)
{
List <LuaParam> lParams;
string path = className;
if (className.ToLower().Contains("content"))
{
path = "Content/" + className;
}
lParams = LuaUtils.createLuaParamList("/Area/PrivateArea/" + path, false, true, zoneName, privateAreaName, 0x9E, canRideChocobo ? (byte)1 : (byte)0, canStealth, isInn, false, false, false, false, false, false);
ActorInstantiatePacket.buildPacket(actorId, playerActorId, actorName, className, lParams).debugPrintSubPacket();
return(ActorInstantiatePacket.buildPacket(actorId, playerActorId, actorName, className, lParams));
}
static public int PostLuaEvent_s(IntPtr l)
{
try {
System.String a1;
checkType(l, 1, out a1);
System.Object[] a2;
checkParams(l, 2, out a2);
LuaUtils.PostLuaEvent(a1, a2);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
public static void doActorOnEventStarted(Player player, Actor target, EventStartPacket eventStart)
{
string luaPath;
if (target is Command)
{
luaPath = String.Format(FILEPATH_COMMANDS, target.getName());
}
else if (target is Director)
{
luaPath = String.Format(FILEPATH_DIRECTORS, target.getName());
}
else
{
luaPath = String.Format(FILEPATH_NPCS, target.zoneId, target.getName());
}
if (File.Exists(luaPath))
{
Script script = loadScript(luaPath);
if (script == null)
{
return;
}
//Have to do this to combine LuaParams
List <Object> objects = new List <Object>();
objects.Add(player);
objects.Add(target);
objects.Add(eventStart.triggerName);
if (eventStart.luaParams != null)
{
objects.AddRange(LuaUtils.createLuaParamObjectList(eventStart.luaParams));
}
//Run Script
if (!script.Globals.Get("onEventStarted").IsNil())
{
script.Call(script.Globals["onEventStarted"], objects.ToArray());
}
}
else
{
SendError(player, String.Format("ERROR: Could not find script for actor {0}.", target.getName()));
}
}
public static SubPacket BuildPacket(uint sourceActorId, uint actorId, uint textOwnerActorId, ushort textId, byte log, List <LuaParam> lParams)
{
int lParamsSize = findSizeOfParams(lParams);
byte[] data;
ushort opcode;
if (lParamsSize <= 0x8)
{
data = new byte[SIZE_GAMEMESSAGE_WITH_ACTOR2 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_ACTOR2;
}
else if (lParamsSize <= 0x10)
{
data = new byte[SIZE_GAMEMESSAGE_WITH_ACTOR3 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_ACTOR3;
}
else if (lParamsSize <= 0x20)
{
data = new byte[SIZE_GAMEMESSAGE_WITH_ACTOR4 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_ACTOR4;
}
else
{
data = new byte[SIZE_GAMEMESSAGE_WITH_ACTOR5 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_ACTOR5;
}
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
binWriter.Write((UInt32)actorId);
binWriter.Write((UInt32)textOwnerActorId);
binWriter.Write((UInt16)textId);
binWriter.Write((UInt16)log);
LuaUtils.WriteLuaParams(binWriter, lParams);
if (lParamsSize <= 0x14 - 12)
{
binWriter.Seek(0x14, SeekOrigin.Begin);
binWriter.Write((UInt32)8);
}
}
}
return(new SubPacket(opcode, sourceActorId, data));
}
public static SubPacket BuildPacket(uint sourceActorId, uint textOwnerActorId, ushort textId, string sender, byte log, List <LuaParam> lParams)
{
int lParamsSize = findSizeOfParams(lParams);
byte[] data;
ushort opcode;
if (lParamsSize <= 0x8)
{
data = new byte[SIZE_GAMEMESSAGE_WITH_CUSTOM_SENDER2 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_CUSTOM_SENDER2;
}
else if (lParamsSize <= 0x10)
{
data = new byte[SIZE_GAMEMESSAGE_WITH_CUSTOM_SENDER3 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_CUSTOM_SENDER3;
}
else if (lParamsSize <= 0x20)
{
data = new byte[SIZE_GAMEMESSAGE_WITH_CUSTOM_SENDER4 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_CUSTOM_SENDER4;
}
else
{
data = new byte[SIZE_GAMEMESSAGE_WITH_CUSTOM_SENDER5 - 0x20];
opcode = OPCODE_GAMEMESSAGE_WITH_CUSTOM_SENDER5;
}
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
binWriter.Write((UInt32)textOwnerActorId);
binWriter.Write((UInt16)textId);
binWriter.Write((UInt16)log);
binWriter.Write(Encoding.ASCII.GetBytes(sender), 0, Encoding.ASCII.GetByteCount(sender) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(sender));
LuaUtils.WriteLuaParams(binWriter, lParams);
if (lParamsSize <= 0x14 - 12)
{
binWriter.Seek(0x30, SeekOrigin.Begin);
binWriter.Write((UInt32)8);
}
}
}
return(new SubPacket(opcode, sourceActorId, data));
}
public override SubPacket createScriptBindPacket(uint playerActorId)
{
List <LuaParam> lParams;
Player player = Server.GetWorldManager().GetPCInWorld(playerActorId);
lParams = LuaEngine.doActorInstantiate(player, this);
if (lParams == null)
{
className = "PopulaceStandard";
lParams = LuaUtils.createLuaParamList("/Chara/Npc/Populace/PopulaceStandard", false, false, false, false, false, 0xF47F6, false, false, 0, 1, "TEST");
}
return(ActorInstantiatePacket.buildPacket(actorId, playerActorId, actorName, className, lParams));
}
private List <LuaParam> CallLuaScript(string funcName, params object[] args)
{
if (directorScript != null)
{
if (!directorScript.Globals.Get(funcName).IsNil())
{
DynValue result = directorScript.Call(directorScript.Globals[funcName], args);
List <LuaParam> lparams = LuaUtils.CreateLuaParamList(result);
return(lparams);
}
else
{
Program.Log.Error("Could not find script for director {0}.", GetName());
}
}
return(null);
}
public List <LuaParam> CallLuaFunctionForReturn(string path, string funcName, bool optional, params object[] args)
{
string luaPath = path;
LuaScript script = LoadScript(luaPath);
if (script != null)
{
if (!script.Globals.Get(funcName).IsNil())
{
//Run Script
DynValue result = script.Call(script.Globals[funcName], args);
List <LuaParam> lparams = LuaUtils.CreateLuaParamList(result);
return(lparams);
}
}
return(null);
}
public byte[] Finish(string name = "Unknown", string version = "1.0")
{
if (zipStream.IsFinished)
{
throw new System.Exception("Package is already built but another attempt to build was requested!");
}
string meta = name.Replace(System.Environment.NewLine, " ") + System.Environment.NewLine +
version + System.Environment.NewLine +
LuaShared.RUNTIME_VERSION.ToString();
AddData(META_ENTRY, LuaUtils.GetBytes(meta));
zipStream.IsStreamOwner = true;
zipStream.Close();
return(outputMemStream.ToArray());
}
public EventUpdatePacket(byte[] data)
{
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryReader binReader = new BinaryReader(mem))
{
try{
actorID = binReader.ReadUInt32();
scriptOwnerActorID = binReader.ReadUInt32();
val1 = binReader.ReadUInt32();
val2 = binReader.ReadUInt32();
step = binReader.ReadByte();
luaParams = LuaUtils.ReadLuaParams(binReader);
}
catch (Exception) {
invalidPacket = true;
}
}
}
}
public override SubPacket createScriptBindPacket(uint playerActorId)
{
List <LuaParam> lParams;
if (isMyPlayer(playerActorId))
{
if (currentDirector != null)
{
lParams = LuaUtils.createLuaParamList("/Chara/Player/Player_work", false, false, true, currentDirector, true, 0, false, timers, true);
}
else
{
lParams = LuaUtils.createLuaParamList("/Chara/Player/Player_work", false, false, false, true, 0, false, timers, true);
}
}
else
{
lParams = LuaUtils.createLuaParamList("/Chara/Player/Player_work", false, false, false, false, false, true);
}
return(ActorInstantiatePacket.buildPacket(actorId, playerActorId, actorName, className, lParams));
}
public void OnEventUpdate(Player player, List <LuaParam> args)
{
if (mSleepingOnPlayerEvent.ContainsKey(player.actorId))
{
try
{
Coroutine coroutine = mSleepingOnPlayerEvent[player.actorId];
mSleepingOnPlayerEvent.Remove(player.actorId);
DynValue value = coroutine.Resume(LuaUtils.CreateLuaParamObjectList(args));
ResolveResume(player, coroutine, value);
}
catch (ScriptRuntimeException e)
{
LuaEngine.SendError(player, String.Format("OnEventUpdated: {0}", e.DecoratedMessage));
player.EndEvent();
}
}
else
{
player.EndEvent();
}
}
// actorClassId, [], [], numBattleCommon, [battleCommon], numEventCommon, [eventCommon], args for either initForBattle/initForEvent
public override SubPacket CreateScriptBindPacket(Player player)
{
List <LuaParam> lParams;
lParams = LuaEngine.GetInstance().CallLuaFunctionForReturn(player, this, "init", false);
if (lParams != null && lParams.Count >= 3 && lParams[2].typeID == 0 && (int)lParams[2].value == 0)
{
isStatic = true;
}
else
{
//charaWork.property[2] = 1;
//npcWork.hateType = 1;
}
if (lParams == null)
{
string classPathFake = "/Chara/Npc/Populace/PopulaceStandard";
string classNameFake = "PopulaceStandard";
lParams = LuaUtils.CreateLuaParamList(classPathFake, false, false, false, false, false, 0xF47F6, false, false, 0, 0);
isStatic = true;
//ActorInstantiatePacket.BuildPacket(actorId, actorName, classNameFake, lParams).DebugPrintSubPacket();
return(ActorInstantiatePacket.BuildPacket(actorId, actorName, classNameFake, lParams));
}
else
{
lParams.Insert(0, new LuaParam(2, classPath));
lParams.Insert(1, new LuaParam(4, 4));
lParams.Insert(2, new LuaParam(4, 4));
lParams.Insert(3, new LuaParam(4, 4));
lParams.Insert(4, new LuaParam(4, 4));
lParams.Insert(5, new LuaParam(4, 4));
lParams.Insert(6, new LuaParam(0, (int)actorClassId));
}
//ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams).DebugPrintSubPacket();
return(ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams));
}
public static SubPacket BuildPacket(uint sourceActorId, string objectName, string className, List <LuaParam> initParams)
{
byte[] data = new byte[PACKET_SIZE - 0x20];
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
int value1 = 0x00; //Instance ID?
int value2 = 0x3040;
binWriter.Write((Int16)value1);
binWriter.Write((Int16)value2);
binWriter.Write(Encoding.ASCII.GetBytes(objectName), 0, Encoding.ASCII.GetByteCount(objectName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(objectName));
binWriter.BaseStream.Seek(0x24, SeekOrigin.Begin);
binWriter.Write(Encoding.ASCII.GetBytes(className), 0, Encoding.ASCII.GetByteCount(className) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(className));
binWriter.BaseStream.Seek(0x44, SeekOrigin.Begin);
LuaUtils.WriteLuaParams(binWriter, initParams);
}
}
return(new SubPacket(OPCODE, sourceActorId, data));
}
public static SubPacket BuildPacket(uint sourcePlayerActorId, uint eventOwnerActorID, string eventStarter, string callFunction, List <LuaParam> luaParams)
{
byte[] data = new byte[PACKET_SIZE - 0x20];
int maxBodySize = data.Length - 0x80;
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
binWriter.Write((UInt32)sourcePlayerActorId);
binWriter.Write((UInt32)eventOwnerActorID);
binWriter.Write((Byte)5);
binWriter.Write(Encoding.ASCII.GetBytes(eventStarter), 0, Encoding.ASCII.GetByteCount(eventStarter) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(eventStarter));
binWriter.Seek(0x29, SeekOrigin.Begin);
binWriter.Write(Encoding.ASCII.GetBytes(callFunction), 0, Encoding.ASCII.GetByteCount(callFunction) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(callFunction));
binWriter.Seek(0x49, SeekOrigin.Begin);
LuaUtils.WriteLuaParams(binWriter, luaParams);
}
}
return(new SubPacket(OPCODE, sourcePlayerActorId, data));
}
// 每帧检查处理消息
public void UpdateSocket()
{
// 向 Lua 发送缓存的socket链接状态
if (cacheConnectEvent != SocketConnectionEvent.None)
{
Debug.Log(cacheConnectEvent.ToString());
LuaUtils.PostLuaEvent(cacheConnectEvent.ToString(), null);
cacheConnectEvent = SocketConnectionEvent.None;
}
// 检查是否有消息来了
if (null != _conn && _conn.State == SocketConnectionState.Connected)
{
List <SocketData> sockDatas = _conn.RecvSocketDataList();
if (sockDatas != null && sockDatas.Count > 0)
{
for (int i = 0; i < sockDatas.Count; ++i)
{
SocketData data = sockDatas [i];
ReceiveMsg msgData = new ReceiveMsg();
msgData.data = data;
tobeHandledSocketData.Enqueue(msgData);
}
}
}
// 处理接收的消息
if (tobeHandledSocketData.Count > 0)
{
ReceiveMsg msgData = tobeHandledSocketData.Dequeue();
DealWithSocketData(msgData);
}
else
{
}
}
public static void Main(string[] args)
{
if (args.Length < 2)
{
if (args[0] == "version")
{
Console.WriteLine(LuaClassStd.GetCredentials());
return;
}
Console.WriteLine("Invalid arguments!");
Environment.Exit(EXIT_CODE_INVALID_ARGUMENTS);
return;
}
// Script engine initialization
try {
Script.DefaultOptions.UseLuaErrorLocations = true;
Script.DefaultOptions.ScriptLoader = new LuaScriptLoader()
{
ModulePaths = new string[] { "static:?" }
};
UserData.RegisterAssembly();
Script.WarmUp();
}
catch (Exception e) {
Console.WriteLine("Error while initializing the engine due " + e.Message);
Environment.Exit(EXIT_CODE_ENGINE_ERROR);
}
// Command line options
if (args[0] == "run")
{
if (!File.Exists(args[1]))
{
Console.WriteLine("File " + args[1] + " does not exist!");
Environment.Exit(EXIT_CODE_INVALID_FILE);
}
try {
new LuaRuntime(args[1]).Run();
}
catch (NotSupportedException e) {
Console.WriteLine("Package is not supported. " + e.Message);
}
return;
}
try {
var packageFilename = args[0];
string[] files = new string[args.Length - 1];
bool mainEntryFound = false;
for (int i = 1; i < args.Length; i++)
{
if (Path.GetFileName(args[i]) == "main.lua")
{
mainEntryFound = true;
}
files[i - 1] = args[i];
}
if (!mainEntryFound)
{
Console.WriteLine("WARNING! Main entry (main.lua) was not found.");
}
var package = new LuaPackage();
foreach (var filename in files)
{
if (!File.Exists(filename))
{
Console.WriteLine("File " + filename + " does not exist!");
Environment.Exit(EXIT_CODE_INVALID_FILE);
return;
}
var content = File.ReadAllText(filename);
var bytecode = LuaUtils.Compile(content).ToArray();
package.AddData("bin/" + Path.GetFileNameWithoutExtension(filename) + ".bin", bytecode);
}
File.WriteAllBytes(packageFilename, package.Finish());
Console.WriteLine("Packaging completed.");
}
catch (Exception e) {
Console.WriteLine("Error while packing the files due " + e.Message);
Environment.Exit(EXIT_CODE_GENERIC_ERROR);
}
}
private void registerEventPreconditions()
{
PyUtils.addEventPrecondition("hasmod", (key, values, location) =>
{
string mod = values.Replace("hasmod ", "").Replace(" ", "");
bool result = LuaUtils.hasMod(mod);
return(result);
});
PyUtils.addEventPrecondition("switch", (key, values, location) =>
{
return(LuaUtils.switches(values.Replace("switch ", "")));
});
PyUtils.addEventPrecondition("npcxy", (key, values, location) =>
{
var v = values.Split(' ');
var name = v[0];
if (v.Length == 1)
{
return(Game1.getCharacterFromName(name) is NPC npcp && npcp.currentLocation == location);
}
var x = int.Parse(v[1]);
if (v.Length == 2)
{
return(Game1.getCharacterFromName(name) is NPC npcx && npcx.currentLocation == location && npcx.getTileX() == x);
}
var y = int.Parse(v[2]);
return(Game1.getCharacterFromName(name) is NPC npc && npc.currentLocation == location && (x == -1 || npc.getTileX() == x) && (y == -1 || npc.getTileY() == y));
});
PyUtils.addEventPrecondition("items", (key, values, location) =>
{
var v = values.Split(',');
List <Item> items = new List <Item>(Game1.player.Items);
foreach (string pair in v)
{
var p = pair.Split(':');
var name = p[0];
var stack = p.Length == 1 ? 1 : int.Parse(p[1]);
int count = 0;
foreach (Item item in items)
{
if (item.Name == name)
{
count += item.Stack;
}
if (count >= stack)
{
return(true);
}
}
}
return(false);
});
PyUtils.addEventPrecondition("counter", (key, values, location) =>
{
var v = values.Split(' ');
var c = LuaUtils.counters(v[0]);
if (v.Length == 2)
{
return(c == int.Parse(v[1]));
}
else
{
return(PyUtils.calcBoolean("c " + values, new KeyValuePair <string, object>("c", c)));
}
});
PyUtils.addEventPrecondition("LC", (key, values, location) =>
{
return(PyUtils.checkEventConditions(values.Replace("%div", "/"), location, location));
});
}
public void runEvent(string functionName, params object[] parameters)
{
List <LuaParam> lParams = LuaUtils.createLuaParamList(parameters);
// player.playerSession.queuePacket(RunEventFunctionPacket.buildPacket(player.actorId, player.eventCurrentOwner, player.eventCurrentStarter, functionName, lParams), true, false);
}
public void sendGameMessage(Actor textIdOwner, ushort textId, byte log, uint displayId, params object[] msgParams)
{
if (msgParams.Length == 0)
{
queuePacket(GameMessagePacket.buildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, displayId, log));
}
else
{
queuePacket(GameMessagePacket.buildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, displayId, log, LuaUtils.createLuaParamList(msgParams)));
}
}
