Add equip ability functions

Fix EquipAbility SQL query

FFXIVClassic Map Server/actors/director/Director.cs

@@ -15,26 +15,32 @@ namespace FFXIVClassic_Map_Server.actors.director
     {
         private uint directorId;
         private string directorScriptPath;
-        private List<Actor> childrenOwners = new List<Actor>();
+        private List<Actor> members = new List<Actor>();
         private bool isCreated = false;
+        private bool isDeleted = false;
+        private bool isDeleting = false;
 
-        public Director(uint id, Area zone, string directorPath)
+        private Script directorScript;
+        private Coroutine currentCoroutine;
+
+        public Director(uint id, Area zone, string directorPath, params object[] args)
             : base((6 << 28 | zone.actorId << 19 | (uint)id))
         {
             directorId = id;
             this.zone = zone;
-            directorScriptPath = directorPath;            
-            DoActorInit(directorScriptPath);
-            GenerateActorName((int)id);
+            this.zoneId = zone.actorId;
+            directorScriptPath = directorPath;
+
+            LoadLuaScript();
 
             eventConditions = new EventList();
             eventConditions.noticeEventConditions = new List<EventList.NoticeEventCondition>();
             eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("noticeEvent",  0xE,0x0));
             eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("noticeRequest", 0x0, 0x1));
-            eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("reqForChild", 0x0, 0x1));
+            eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("reqForChild", 0x0, 0x1));            
         }       
 
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket()
         {
             List<LuaParam> actualLParams = new List<LuaParam>();
             actualLParams.Insert(0, new LuaParam(2, classPath));
@@ -48,28 +54,30 @@ namespace FFXIVClassic_Map_Server.actors.director
             for (int i = 1; i < lparams.Count; i++)
                 actualLParams.Add(lparams[i]);
 
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, actualLParams);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, actualLParams);
         }
 
-        public override BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType)
+        public override List<SubPacket> GetSpawnPackets(ushort spawnType = 1)
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId, 0));
-            subpackets.AddRange(GetEventConditionPackets(playerActorId));
-            subpackets.Add(CreateSpeedPacket(playerActorId));
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0));
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));
-            subpackets.Add(CreateScriptBindPacket(playerActorId));
-            return BasePacket.CreatePacket(subpackets, true, false);
-        }        
+            subpackets.Add(CreateAddActorPacket(0));
+            subpackets.AddRange(GetEventConditionPackets());
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(0));
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.Add(CreateScriptBindPacket());
+            return subpackets;
+        }
 
-        public override BasePacket GetInitPackets(uint playerActorId)
+        public override List<SubPacket> GetInitPackets()
         {
+            List<SubPacket> subpackets = new List<SubPacket>();
             SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init");
             initProperties.AddTarget();
-            return BasePacket.CreatePacket(initProperties.BuildPacket(playerActorId, actorId), true, false);
+            subpackets.Add(initProperties.BuildPacket(actorId));
+            return subpackets;
         }
 
         public void OnTalkEvent(Player player, Npc npc)
@@ -80,45 +88,93 @@ namespace FFXIVClassic_Map_Server.actors.director
         public void OnCommandEvent(Player player, Command command)
         {
             LuaEngine.GetInstance().CallLuaFunction(player, this, "onCommandEvent", false, command);
-        }        
+        }   
 
-        public void DoActorInit(string directorPath)
+        public void StartDirector(bool spawnImmediate, params object[] args)
         {
-            List<LuaParam> lparams = LuaEngine.GetInstance().CallLuaFunctionForReturn(null, this, "init", false);            
+            object[] args2 = new object[args.Length + 1];
+            args2[0] = this;
+            Array.Copy(args, 0, args2, 1, args.Length);
+
+            List<LuaParam> lparams = CallLuaScript("init", args2);
             
             if (lparams.Count >= 1 && lparams[0].value is string)
             {
                 classPath = (string)lparams[0].value;
                 className = classPath.Substring(classPath.LastIndexOf("/") + 1);
+                GenerateActorName((int)directorId);
                 isCreated = true;
             }
+
+            if (isCreated && spawnImmediate)
+            {
+                foreach (Player p in GetPlayerMembers())
+                {
+                    p.QueuePackets(GetSpawnPackets());
+                    p.QueuePackets(GetInitPackets());
+                }
+            }
+
+            if (this is GuildleveDirector)
+                ((GuildleveDirector)this).LoadGuildleve();
+
+            StartCoroutine("main", this);
         }
 
-        public void AddChild(Actor actor)
+        public void EndDirector()
         {
-            if (!childrenOwners.Contains(actor))
-                childrenOwners.Add(actor);
-        }
+            isDeleting = true;
 
-        public void RemoveChild(Actor actor)
-        {
-            if (childrenOwners.Contains(actor))
-                childrenOwners.Remove(actor);
-            if (childrenOwners.Count == 0)
-                Server.GetWorldManager().GetZone(zoneId).DeleteDirector(actorId);
-        }
+            if (this is GuildleveDirector)
+                ((GuildleveDirector)this).EndGuildleveDirector();
 
-        public void RemoveChildren()
-        {
-            childrenOwners.Clear();
+            List<Actor> players = GetPlayerMembers();
+            foreach (Actor player in players)
+                ((Player)player).RemoveDirector(this);
+            members.Clear();
+            isDeleted = true;
             Server.GetWorldManager().GetZone(zoneId).DeleteDirector(actorId);
         }
+        
+        public void AddMember(Actor actor)
+        {
+            if (!members.Contains(actor))
+                members.Add(actor);
+        }
+
+        public void RemoveMember(Actor actor)
+        {
+            if (members.Contains(actor))
+                members.Remove(actor);
+            if (GetPlayerMembers().Count == 0 && !isDeleting)
+                EndDirector();
+        }
+
+        public List<Actor> GetMembers()
+        {
+            return members;
+        }
+
+        public List<Actor> GetPlayerMembers()
+        {
+            return members.FindAll(s => s is Player);
+        }
+
+        public List<Actor> GetNpcMembers()
+        {
+            return members.FindAll(s => s is Npc);
+        }
 
         public bool IsCreated()
         {
             return isCreated;
         }
 
+        public bool IsDeleted()
+        {
+            return isDeleted;
+        }
+
         public void GenerateActorName(int actorNumber)
         {            
             //Format Class Name
@@ -166,5 +222,45 @@ namespace FFXIVClassic_Map_Server.actors.director
             return directorScriptPath;
         }
 
+        private void LoadLuaScript()
+        {
+            string luaPath = String.Format(LuaEngine.FILEPATH_DIRECTORS, GetScriptPath());
+            directorScript = LuaEngine.LoadScript(luaPath);
+            if (directorScript == null)
+                Program.Log.Error("Could not find script for director {0}.", GetName());
+        }
+
+        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;
+        }
+
+        private List<LuaParam> StartCoroutine(string funcName, params object[] args)
+        {
+            if (directorScript != null)
+            {
+                if (!directorScript.Globals.Get(funcName).IsNil())
+                {
+                    currentCoroutine = directorScript.CreateCoroutine(directorScript.Globals[funcName]).Coroutine;
+                    DynValue value = currentCoroutine.Resume(args);
+                    LuaEngine.GetInstance().ResolveResume(null, currentCoroutine, value);
+                }
+                else
+                    Program.Log.Error("Could not find script for director {0}.", GetName());
+            }
+            return null;
+        }
+
     }    
-}
+}

FFXIVClassic Map Server/actors/director/GuildleveDirector.cs

@@ -0,0 +1,258 @@
+using FFXIVClassic.Common;
+using FFXIVClassic_Map_Server.actors.area;
+using FFXIVClassic_Map_Server.actors.director.Work;
+using FFXIVClassic_Map_Server.actors.group;
+using FFXIVClassic_Map_Server.Actors;
+using FFXIVClassic_Map_Server.dataobjects;
+using FFXIVClassic_Map_Server.utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Map_Server.actors.director
+{
+    class GuildleveDirector : Director
+    {
+        public uint guildleveId;
+        public Player guildleveOwner;        
+        public byte selectedDifficulty;
+        public ContentGroup contentGroup;
+
+        public GuildleveData guildleveData;
+        public GuildleveWork guildleveWork = new GuildleveWork();
+
+        public bool isEnded = false;
+        public uint completionTime = 0;
+
+        public GuildleveDirector(uint id, Area zone, string directorPath, uint guildleveId, byte selectedDifficulty, Player guildleveOwner, params object[] args)
+            : base(id, zone, directorPath, args)
+        {
+            this.guildleveId = guildleveId;
+            this.selectedDifficulty = selectedDifficulty;
+            this.guildleveData = Server.GetGuildleveGamedata(guildleveId);
+            this.guildleveOwner = guildleveOwner;
+
+            guildleveWork.aimNum[0] = guildleveData.aimNum[0];
+            guildleveWork.aimNum[1] = guildleveData.aimNum[1];
+            guildleveWork.aimNum[2] = guildleveData.aimNum[2];
+            guildleveWork.aimNum[3] = guildleveData.aimNum[3];
+
+            if (guildleveWork.aimNum[0] != 0)
+                guildleveWork.uiState[0] = 1;
+            if (guildleveWork.aimNum[1] != 0)
+                guildleveWork.uiState[1] = 1;
+            if (guildleveWork.aimNum[2] != 0)
+                guildleveWork.uiState[2] = 1;
+            if (guildleveWork.aimNum[3] != 0)
+                guildleveWork.uiState[3] = 1;
+
+            guildleveWork.aimNumNow[0] = guildleveWork.aimNumNow[1] = guildleveWork.aimNumNow[2] = guildleveWork.aimNumNow[3] = 0;
+        }
+
+        public void LoadGuildleve()
+        {
+            contentGroup = Server.GetWorldManager().CreateGLContentGroup(this, GetMembers());
+        }
+
+        public void StartGuildleve()
+        {
+            foreach (Actor p in GetPlayerMembers())
+            {
+                Player player = (Player) p;
+
+                //Set music
+                if (guildleveData.location == 1)
+                    player.ChangeMusic(22);
+                else if (guildleveData.location == 2)
+                    player.ChangeMusic(14);
+                else if (guildleveData.location == 3)
+                    player.ChangeMusic(26);
+                else if (guildleveData.location == 4)
+                    player.ChangeMusic(16);
+
+                //Show Start Messages
+                player.SendGameMessage(Server.GetWorldManager().GetActor(), 50022, 0x20, guildleveId, selectedDifficulty);
+                player.SendDataPacket("attention", Server.GetWorldManager().GetActor(), "", 50022, guildleveId, selectedDifficulty);
+                player.SendGameMessage(Server.GetWorldManager().GetActor(), 50026, 0x20, (object)(int)guildleveData.timeLimit);
+            }
+
+            guildleveWork.startTime = Utils.UnixTimeStampUTC();
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/start", this);
+            propertyBuilder.AddProperty("guildleveWork.startTime");
+            SendPacketsToPlayers(propertyBuilder.Done());            
+        }
+
+        public void EndGuildleve(bool wasCompleted)
+        {
+            if (isEnded)
+                return;
+            isEnded = true;
+
+            completionTime = Utils.UnixTimeStampUTC() - guildleveWork.startTime;
+
+            if (wasCompleted)
+            {
+                foreach (Actor a in GetPlayerMembers())
+                {
+                    Player player = (Player)a;
+                    player.MarkGuildleve(guildleveId, true, true);
+                    player.PlayAnimation(0x02000002, true);
+                    player.ChangeMusic(81);
+                    player.SendGameMessage(Server.GetWorldManager().GetActor(), 50023, 0x20, (object)(int)guildleveId);
+                    player.SendDataPacket("attention", Server.GetWorldManager().GetActor(), "", 50023, (object)(int)guildleveId);
+                }
+            }
+
+            foreach (Actor a in GetNpcMembers())
+            {
+                Npc npc = (Npc)a;
+                npc.Despawn();
+                RemoveMember(a);
+            }
+
+            guildleveWork.startTime = 0;
+            guildleveWork.signal = -1;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/signal", this);
+            propertyBuilder.AddProperty("guildleveWork.signal");
+            propertyBuilder.NewTarget("guildleveWork/start");
+            propertyBuilder.AddProperty("guildleveWork.startTime");
+            SendPacketsToPlayers(propertyBuilder.Done());
+            
+            if (wasCompleted)
+            {
+                Npc aetheryteNode = zone.SpawnActor(1200040, String.Format("{0}:warpExit", guildleveOwner.actorName), guildleveOwner.positionX, guildleveOwner.positionY, guildleveOwner.positionZ);
+                contentGroup.AddMember(aetheryteNode);
+
+                foreach (Actor a in GetPlayerMembers())
+                {
+                    Player player = (Player)a;
+                    player.SendGameMessage(Server.GetWorldManager().GetActor(), 50029, 0x20);
+                    player.SendGameMessage(Server.GetWorldManager().GetActor(), 50032, 0x20);
+                }
+            }
+        }   
+        
+        public void AbandonGuildleve()
+        {
+            foreach (Actor p in GetPlayerMembers())
+            {
+                Player player = (Player)p;                
+                player.SendGameMessage(Server.GetWorldManager().GetActor(), 50147, 0x20, (object)guildleveId);
+                player.MarkGuildleve(guildleveId, true, false);
+            }
+
+            EndGuildleve(false);
+            EndDirector();
+        }
+
+        //Delete ContentGroup, change music back
+        public void EndGuildleveDirector()
+        {
+            contentGroup.DeleteGroup();
+            foreach (Actor p in GetPlayerMembers())
+            {
+                Player player = (Player)p;
+                player.ChangeMusic(player.GetZone().bgmDay);
+            }
+        }
+
+        public void SyncAllInfo()
+        {
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
+
+            if (guildleveWork.aimNum[0] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[0]");
+            if (guildleveWork.aimNum[1] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[1]");
+            if (guildleveWork.aimNum[2] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[2]");
+            if (guildleveWork.aimNum[3] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[3]");
+
+            if (guildleveWork.aimNumNow[0] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[0]");
+            if (guildleveWork.aimNumNow[1] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[1]");
+            if (guildleveWork.aimNumNow[2] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[2]");
+            if (guildleveWork.aimNumNow[3] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[3]");
+
+            if (guildleveWork.uiState[0] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[0]");
+            if (guildleveWork.uiState[1] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[1]");
+            if (guildleveWork.uiState[2] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[2]");
+            if (guildleveWork.uiState[3] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[3]");
+
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void UpdateAimNumNow(int index, sbyte value)
+        {
+            guildleveWork.aimNumNow[index] = value;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
+            propertyBuilder.AddProperty(String.Format("guildleveWork.aimNumNow[{0}]", index));
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void UpdateUiState(int index, sbyte value)
+        {
+            guildleveWork.uiState[index] = value;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
+            propertyBuilder.AddProperty(String.Format("guildleveWork.uiState[{0}]", index));
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void UpdateMarkers(int markerIndex, float x, float y, float z)
+        {
+            guildleveWork.markerX[markerIndex] = x;
+            guildleveWork.markerY[markerIndex] = y;
+            guildleveWork.markerZ[markerIndex] = z;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/marker", this);
+            propertyBuilder.AddProperty(String.Format("guildleveWork.markerX[{0}]", markerIndex));
+            propertyBuilder.AddProperty(String.Format("guildleveWork.markerY[{0}]", markerIndex));
+            propertyBuilder.AddProperty(String.Format("guildleveWork.markerZ[{0}]", markerIndex));
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void SendPacketsToPlayers(List<SubPacket> packets)
+        {
+            List<Actor> players = GetPlayerMembers();
+            foreach (Actor p in players)
+            {
+                ((Player)p).QueuePackets(packets);
+            }
+        }
+
+        public static uint GlBorderIconIDToAnimID(uint iconId)
+        {
+	        return iconId - 20000;
+        }
+
+        public static uint GlPlateIconIDToAnimID(uint iconId)
+        {
+	        return iconId - 20020;
+        }
+
+        public static uint GetGLStartAnimationFromSheet(uint border, uint plate, bool isBoost)
+        {
+	        return GetGLStartAnimation(GlBorderIconIDToAnimID(border), GlPlateIconIDToAnimID(plate), isBoost);
+        }
+
+        public static uint GetGLStartAnimation(uint border, uint plate, bool isBoost)
+        {
+            uint borderBits = border;
+	        uint plateBits = plate << 7;
+
+            uint boostBits = isBoost ? (uint)0x8000 : (uint) 0;
+	        
+	        return 0x0B000000 | boostBits | plateBits | borderBits;
+        }
+	
+    }
+}

FFXIVClassic Map Server/actors/director/Work/GuildleveWork.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Map_Server.actors.director.Work
+{
+
+    class GuildleveWork
+    {
+        public uint startTime = 0;
+        public sbyte[] aimNum = new sbyte[4];
+        public sbyte[] aimNumNow = new sbyte[4];
+        public sbyte[] uiState = new sbyte[4];
+        public float[] markerX = new float[3];
+        public float[] markerY = new float[3];
+        public float[] markerZ = new float[3];
+        public sbyte signal;
+    }
+
+}