cassidy/project-meteor-server
1
0
Fork 0
mirror of https://bitbucket.org/Ioncannon/project-meteor-server.git synced 2025-04-02 19:42:05 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'packet_actortarget_rewrite' into guildleve

Browse Source
This commit is contained in:
Filip Maj 2017-06-29 11:39:02 -04:00
commit fc0c504c28
207 changed files with 749 additions and 850 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
FFXIVClassic Common Class Lib/SubPacket.cs
View File

@ -72,9 +72,9 @@ namespace FFXIVClassic.Common
offset += header.subpacketSize; offset += header.subpacketSize;
} }
public SubPacket(ushort opcode, uint sourceId, uint targetId, byte[] data) : this(true, opcode, sourceId, targetId, data) { } public SubPacket(ushort opcode, uint sourceId, byte[] data) : this(true, opcode, sourceId, data) { }
public SubPacket(bool isGameMessage, ushort opcode, uint sourceId, uint targetId, byte[] data) public SubPacket(bool isGameMessage, ushort opcode, uint sourceId, byte[] data)
{ {
header = new SubPacketHeader(); header = new SubPacketHeader();
@ -89,7 +89,7 @@ namespace FFXIVClassic.Common
} }
header.sourceId = sourceId; header.sourceId = sourceId;
header.targetId = targetId; header.targetId = 0;
if (isGameMessage) if (isGameMessage)
header.type = 0x03; header.type = 0x03;
@ -117,6 +117,11 @@ namespace FFXIVClassic.Common
data = original.data; data = original.data;
} }
public void SetTargetId(uint target)
{
this.header.targetId = target;
}
public byte[] GetHeaderBytes() public byte[] GetHeaderBytes()
{ {
var size = Marshal.SizeOf(header); var size = Marshal.SizeOf(header);

15
FFXIVClassic Lobby Server/PacketProcessor.cs
View File

@ -90,14 +90,15 @@ namespace FFXIVClassic_Lobby_Server
if (userId == 0) if (userId == 0)
{ {
ErrorPacket errorPacket = new ErrorPacket(sessionPacket.sequence, 0, 0, 13001, "Your session has expired, please login again."); ErrorPacket errorPacket = new ErrorPacket(sessionPacket.sequence, 0, 0, 13001, "Your session has expired, please login again.");
SubPacket subpacket = errorPacket.BuildPacket(); SubPacket subpacket = errorPacket.BuildPacket();
BasePacket errorBasePacket = BasePacket.CreatePacket(subpacket, true, false); subpacket.SetTargetId(0xe0006868);
BasePacket.EncryptPacket(client.blowfish, errorBasePacket); BasePacket errorBasePacket = BasePacket.CreatePacket(subpacket, true, false);
client.QueuePacket(errorBasePacket); BasePacket.EncryptPacket(client.blowfish, errorBasePacket);
client.QueuePacket(errorBasePacket);
Program.Log.Info("Invalid session, kicking..."); Program.Log.Info("Invalid session, kicking...");
return; return;
} }
Program.Log.Info("USER ID: {0}", userId); Program.Log.Info("USER ID: {0}", userId);

6
FFXIVClassic Lobby Server/packets/send/AccountListPacket.cs
View File

@ -61,7 +61,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
accountCount = 0; accountCount = 0;
} }
@ -88,7 +89,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
} }

2
FFXIVClassic Lobby Server/packets/send/CharaCreatorPacket.cs
View File

@ -59,7 +59,7 @@ namespace FFXIVClassic_Lobby_Server.packets
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
return new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); return new SubPacket(OPCODE, 0xe0006868, data);
} }
} }
} }

9
FFXIVClassic Lobby Server/packets/send/CharacterListPacket.cs
View File

@ -87,7 +87,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
characterCount = 0; characterCount = 0;
} }
@ -133,7 +134,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
characterCount = 0; characterCount = 0;
} }
@ -145,7 +147,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
} }

3
FFXIVClassic Lobby Server/packets/send/ErrorPacket.cs
View File

@ -38,7 +38,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
return subpacket; return subpacket;
} }
} }

6
FFXIVClassic Lobby Server/packets/send/ImportListPacket.cs
View File

@ -64,7 +64,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
namesCount = 0; namesCount = 0;
} }
@ -91,7 +92,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
} }

6
FFXIVClassic Lobby Server/packets/send/RetainerListPacket.cs
View File

@ -65,7 +65,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
retainerCount = 0; retainerCount = 0;
} }
@ -92,7 +93,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
} }

3
FFXIVClassic Lobby Server/packets/send/SelectCharacterConfirmPacket.cs
View File

@ -49,7 +49,8 @@ namespace FFXIVClassic_Lobby_Server.packets
data = memStream.GetBuffer(); data = memStream.GetBuffer();
} }
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
return subPackets; return subPackets;

6
FFXIVClassic Lobby Server/packets/send/WorldListPacket.cs
View File

@ -63,7 +63,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
serverCount = 0; serverCount = 0;
} }
@ -90,7 +91,8 @@ namespace FFXIVClassic_Lobby_Server.packets
byte[] data = memStream.GetBuffer(); byte[] data = memStream.GetBuffer();
binWriter.Dispose(); binWriter.Dispose();
memStream.Dispose(); memStream.Dispose();
SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data); SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
subpacket.SetTargetId(0xe0006868);
subPackets.Add(subpacket); subPackets.Add(subpacket);
} }

2
FFXIVClassic Map Server/CommandProcessor.cs
View File

@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server
private void SendMessage(Session session, String message) private void SendMessage(Session session, String message)
{ {
if (session != null) if (session != null)
session.GetActor().QueuePacket(SendMessagePacket.BuildPacket(session.id, session.id, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", message)); session.GetActor().QueuePacket(SendMessagePacket.BuildPacket(session.id, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", message));
} }
internal bool DoCommand(string input, Session session) internal bool DoCommand(string input, Session session)

9
FFXIVClassic Map Server/FFXIVClassic Map Server.csproj
View File

@ -159,7 +159,6 @@
<Compile Include="packets\send\actor\ActorDoEmotePacket.cs" /> <Compile Include="packets\send\actor\ActorDoEmotePacket.cs" />
<Compile Include="packets\send\actor\ActorInstantiatePacket.cs" /> <Compile Include="packets\send\actor\ActorInstantiatePacket.cs" />
<Compile Include="packets\send\actor\ActorSpecialGraphicPacket.cs" /> <Compile Include="packets\send\actor\ActorSpecialGraphicPacket.cs" />
<Compile Include="packets\send\actor\BattleAction1Packet.cs" />
<Compile Include="packets\send\actor\battle\BattleAction.cs" /> <Compile Include="packets\send\actor\battle\BattleAction.cs" />
<Compile Include="packets\send\actor\battle\BattleActionX00Packet.cs" /> <Compile Include="packets\send\actor\battle\BattleActionX00Packet.cs" />
<Compile Include="packets\send\actor\battle\BattleActionX18Packet.cs" /> <Compile Include="packets\send\actor\battle\BattleActionX18Packet.cs" />
@ -202,8 +201,7 @@
<Compile Include="packets\send\actor\SetActorIconPacket.cs" /> <Compile Include="packets\send\actor\SetActorIconPacket.cs" />
<Compile Include="packets\send\actor\SetActorSubStatPacket.cs" /> <Compile Include="packets\send\actor\SetActorSubStatPacket.cs" />
<Compile Include="packets\send\actor\SetActorStatusPacket.cs" /> <Compile Include="packets\send\actor\SetActorStatusPacket.cs" />
<Compile Include="packets\send\actor\_0xD9Packet.cs" /> <Compile Include="packets\send\actor\SetActorBGPropertiesPacket.cs" />
<Compile Include="packets\send\actor\_0xD8Packet.cs" />
<Compile Include="packets\send\actor\_0xFPacket.cs" /> <Compile Include="packets\send\actor\_0xFPacket.cs" />
<Compile Include="packets\send\groups\CreateNamedGroup.cs" /> <Compile Include="packets\send\groups\CreateNamedGroup.cs" />
<Compile Include="packets\send\groups\CreateNamedGroupMultiple.cs" /> <Compile Include="packets\send\groups\CreateNamedGroupMultiple.cs" />
@ -243,7 +241,6 @@
<Compile Include="packets\send\actor\MoveActorToPositionPacket.cs" /> <Compile Include="packets\send\actor\MoveActorToPositionPacket.cs" />
<Compile Include="packets\send\actor\SetActorAppearancePacket.cs" /> <Compile Include="packets\send\actor\SetActorAppearancePacket.cs" />
<Compile Include="packets\send\actor\SetActorPositionPacket.cs" /> <Compile Include="packets\send\actor\SetActorPositionPacket.cs" />
<Compile Include="packets\send\login\0x7ResponsePacket.cs" />
<Compile Include="packets\send\LogoutPacket.cs" /> <Compile Include="packets\send\LogoutPacket.cs" />
<Compile Include="packets\send\player\SetCompletedAchievementsPacket.cs" /> <Compile Include="packets\send\player\SetCompletedAchievementsPacket.cs" />
<Compile Include="packets\send\player\AchievementEarnedPacket.cs" /> <Compile Include="packets\send\player\AchievementEarnedPacket.cs" />
@ -338,8 +335,8 @@
</ItemGroup> </ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<PropertyGroup> <PropertyGroup>
<PostBuildEvent>xcopy "$(SolutionDir)data\map_config.ini" "$(SolutionDir)$(ProjectName)\$(OutDir)" /d <PostBuildEvent>
xcopy "$(SolutionDir)data\scripts" "$(SolutionDir)$(ProjectName)\$(OutDir)scripts\" /e /d /y /s</PostBuildEvent> </PostBuildEvent>
</PropertyGroup> </PropertyGroup>
<PropertyGroup> <PropertyGroup>
<PreBuildEvent> <PreBuildEvent>

52
FFXIVClassic Map Server/PacketProcessor.cs
View File

@ -35,7 +35,7 @@ namespace FFXIVClassic_Map_Server
public void ProcessPacket(ZoneConnection client, SubPacket subpacket) public void ProcessPacket(ZoneConnection client, SubPacket subpacket)
{ {
Session session = mServer.GetSession(subpacket.header.targetId); Session session = mServer.GetSession(subpacket.header.sourceId);
if (session == null && subpacket.gameMessage.opcode != 0x1000) if (session == null && subpacket.gameMessage.opcode != 0x1000)
return; return;
@ -59,7 +59,7 @@ namespace FFXIVClassic_Map_Server
SessionBeginPacket beginSessionPacket = new SessionBeginPacket(subpacket.data); SessionBeginPacket beginSessionPacket = new SessionBeginPacket(subpacket.data);
session = mServer.AddSession(subpacket.header.targetId); session = mServer.AddSession(subpacket.header.sourceId);
if (!beginSessionPacket.isLogin) if (!beginSessionPacket.isLogin)
Server.GetWorldManager().DoZoneIn(session.GetActor(), false, session.GetActor().destinationSpawnType); Server.GetWorldManager().DoZoneIn(session.GetActor(), false, session.GetActor().destinationSpawnType);
@ -80,7 +80,7 @@ namespace FFXIVClassic_Map_Server
Server.GetServer().RemoveSession(session.id); Server.GetServer().RemoveSession(session.id);
Program.Log.Info("{0} has been removed from the session list.", session.GetActor().customDisplayName); Program.Log.Info("{0} has been removed from the session list.", session.GetActor().customDisplayName);
client.QueuePacket(SessionEndConfirmPacket.BuildPacket(session, endSessionPacket.destinationZoneId), true, false); session.QueuePacket(SessionEndConfirmPacket.BuildPacket(session, endSessionPacket.destinationZoneId));
client.FlushQueuedSendPackets(); client.FlushQueuedSendPackets();
break; break;
//World Server - Party Synch //World Server - Party Synch
@ -92,14 +92,14 @@ namespace FFXIVClassic_Map_Server
case 0x0001: case 0x0001:
//subpacket.DebugPrintSubPacket(); //subpacket.DebugPrintSubPacket();
PingPacket pingPacket = new PingPacket(subpacket.data); PingPacket pingPacket = new PingPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(PongPacket.BuildPacket(session.id, pingPacket.time), true, false)); session.QueuePacket(PongPacket.BuildPacket(session.id, pingPacket.time));
session.Ping(); session.Ping();
break; break;
//Unknown //Unknown
case 0x0002: case 0x0002:
subpacket.DebugPrintSubPacket(); subpacket.DebugPrintSubPacket();
client.QueuePacket(_0x2Packet.BuildPacket(session.id), true, false); session.QueuePacket(_0x2Packet.BuildPacket(session.id));
client.FlushQueuedSendPackets(); client.FlushQueuedSendPackets();
break; break;
@ -115,14 +115,12 @@ namespace FFXIVClassic_Map_Server
} }
if (chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SAY || chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SHOUT) if (chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SAY || chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SHOUT)
session.GetActor().BroadcastPacket(SendMessagePacket.BuildPacket(session.id, session.id, chatMessage.logType, session.GetActor().customDisplayName, chatMessage.message), false); session.GetActor().BroadcastPacket(SendMessagePacket.BuildPacket(session.id, chatMessage.logType, session.GetActor().customDisplayName, chatMessage.message), false);
break; break;
//Langauge Code (Client safe to send packets to now) //Langauge Code (Client safe to send packets to now)
case 0x0006: case 0x0006:
LangaugeCodePacket langCode = new LangaugeCodePacket(subpacket.data); LangaugeCodePacket langCode = new LangaugeCodePacket(subpacket.data);
session = mServer.GetSession(subpacket.header.targetId);
LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onBeginLogin", true); LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onBeginLogin", true);
Server.GetWorldManager().DoZoneIn(session.GetActor(), true, 0x1); Server.GetWorldManager().DoZoneIn(session.GetActor(), true, 0x1);
LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onLogin", true); LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onLogin", true);
@ -150,7 +148,7 @@ namespace FFXIVClassic_Map_Server
SetTargetPacket setTarget = new SetTargetPacket(subpacket.data); SetTargetPacket setTarget = new SetTargetPacket(subpacket.data);
session.GetActor().currentTarget = setTarget.actorID; session.GetActor().currentTarget = setTarget.actorID;
session.GetActor().BroadcastPacket(SetActorTargetAnimatedPacket.BuildPacket(session.id, session.id, setTarget.actorID), true); session.GetActor().BroadcastPacket(SetActorTargetAnimatedPacket.BuildPacket(session.id, setTarget.actorID), true);
break; break;
//Lock Target //Lock Target
case 0x00CC: case 0x00CC:
@ -247,15 +245,15 @@ namespace FFXIVClassic_Map_Server
//Start Recruiting //Start Recruiting
case 0x01C3: case 0x01C3:
StartRecruitingRequestPacket recruitRequestPacket = new StartRecruitingRequestPacket(subpacket.data); StartRecruitingRequestPacket recruitRequestPacket = new StartRecruitingRequestPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(StartRecruitingResponse.BuildPacket(session.id, true), true, false)); session.QueuePacket(StartRecruitingResponse.BuildPacket(session.id, true));
break; break;
//End Recruiting //End Recruiting
case 0x01C4: case 0x01C4:
client.QueuePacket(BasePacket.CreatePacket(EndRecruitmentPacket.BuildPacket(session.id), true, false)); session.QueuePacket(EndRecruitmentPacket.BuildPacket(session.id));
break; break;
//Party Window Opened, Request State //Party Window Opened, Request State
case 0x01C5: case 0x01C5:
client.QueuePacket(BasePacket.CreatePacket(RecruiterStatePacket.BuildPacket(session.id, false, false, 0), true, false)); session.QueuePacket(RecruiterStatePacket.BuildPacket(session.id, false, false, 0));
break; break;
//Search Recruiting //Search Recruiting
case 0x01C7: case 0x01C7:
@ -271,7 +269,7 @@ namespace FFXIVClassic_Map_Server
details.subTaskId = 1; details.subTaskId = 1;
details.comment = "This is a test details packet sent by the server. No implementation has been Created yet..."; details.comment = "This is a test details packet sent by the server. No implementation has been Created yet...";
details.num[0] = 1; details.num[0] = 1;
client.QueuePacket(BasePacket.CreatePacket(CurrentRecruitmentDetailsPacket.BuildPacket(session.id, details), true, false)); session.QueuePacket(CurrentRecruitmentDetailsPacket.BuildPacket(session.id, details));
break; break;
//Accepted Recruiting //Accepted Recruiting
case 0x01C6: case 0x01C6:
@ -280,64 +278,64 @@ namespace FFXIVClassic_Map_Server
/* SOCIAL STUFF */ /* SOCIAL STUFF */
case 0x01C9: case 0x01C9:
AddRemoveSocialPacket addBlackList = new AddRemoveSocialPacket(subpacket.data); AddRemoveSocialPacket addBlackList = new AddRemoveSocialPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(BlacklistAddedPacket.BuildPacket(session.id, true, addBlackList.name), true, false)); session.QueuePacket(BlacklistAddedPacket.BuildPacket(session.id, true, addBlackList.name));
break; break;
case 0x01CA: case 0x01CA:
AddRemoveSocialPacket RemoveBlackList = new AddRemoveSocialPacket(subpacket.data); AddRemoveSocialPacket RemoveBlackList = new AddRemoveSocialPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(BlacklistRemovedPacket.BuildPacket(session.id, true, RemoveBlackList.name), true, false)); session.QueuePacket(BlacklistRemovedPacket.BuildPacket(session.id, true, RemoveBlackList.name));
break; break;
case 0x01CB: case 0x01CB:
int offset1 = 0; int offset1 = 0;
client.QueuePacket(BasePacket.CreatePacket(SendBlacklistPacket.BuildPacket(session.id, new String[] { "Test" }, ref offset1), true, false)); session.QueuePacket(SendBlacklistPacket.BuildPacket(session.id, new String[] { "Test" }, ref offset1));
break; break;
case 0x01CC: case 0x01CC:
AddRemoveSocialPacket addFriendList = new AddRemoveSocialPacket(subpacket.data); AddRemoveSocialPacket addFriendList = new AddRemoveSocialPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(FriendlistAddedPacket.BuildPacket(session.id, true, (uint)addFriendList.name.GetHashCode(), true, addFriendList.name), true, false)); session.QueuePacket(FriendlistAddedPacket.BuildPacket(session.id, true, (uint)addFriendList.name.GetHashCode(), true, addFriendList.name));
break; break;
case 0x01CD: case 0x01CD:
AddRemoveSocialPacket RemoveFriendList = new AddRemoveSocialPacket(subpacket.data); AddRemoveSocialPacket RemoveFriendList = new AddRemoveSocialPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(FriendlistRemovedPacket.BuildPacket(session.id, true, RemoveFriendList.name), true, false)); session.QueuePacket(FriendlistRemovedPacket.BuildPacket(session.id, true, RemoveFriendList.name));
break; break;
case 0x01CE: case 0x01CE:
int offset2 = 0; int offset2 = 0;
client.QueuePacket(BasePacket.CreatePacket(SendFriendlistPacket.BuildPacket(session.id, new Tuple<long, string>[] { new Tuple<long, string>(01, "Test2") }, ref offset2), true, false)); session.QueuePacket(SendFriendlistPacket.BuildPacket(session.id, new Tuple<long, string>[] { new Tuple<long, string>(01, "Test2") }, ref offset2));
break; break;
case 0x01CF: case 0x01CF:
client.QueuePacket(BasePacket.CreatePacket(FriendStatusPacket.BuildPacket(session.id, null), true, false)); session.QueuePacket(FriendStatusPacket.BuildPacket(session.id, null));
break; break;
/* SUPPORT DESK STUFF */ /* SUPPORT DESK STUFF */
//Request for FAQ/Info List //Request for FAQ/Info List
case 0x01D0: case 0x01D0:
FaqListRequestPacket faqRequest = new FaqListRequestPacket(subpacket.data); FaqListRequestPacket faqRequest = new FaqListRequestPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(FaqListResponsePacket.BuildPacket(session.id, new string[] { "Testing FAQ1", "Coded style!" }), true, false)); session.QueuePacket(FaqListResponsePacket.BuildPacket(session.id, new string[] { "Testing FAQ1", "Coded style!" }));
break; break;
//Request for body of a faq/info selection //Request for body of a faq/info selection
case 0x01D1: case 0x01D1:
FaqBodyRequestPacket faqBodyRequest = new FaqBodyRequestPacket(subpacket.data); FaqBodyRequestPacket faqBodyRequest = new FaqBodyRequestPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(FaqBodyResponsePacket.BuildPacket(session.id, "HERE IS A GIANT BODY. Nothing else to say!"), true, false)); session.QueuePacket(FaqBodyResponsePacket.BuildPacket(session.id, "HERE IS A GIANT BODY. Nothing else to say!"));
break; break;
//Request issue list //Request issue list
case 0x01D2: case 0x01D2:
GMTicketIssuesRequestPacket issuesRequest = new GMTicketIssuesRequestPacket(subpacket.data); GMTicketIssuesRequestPacket issuesRequest = new GMTicketIssuesRequestPacket(subpacket.data);
client.QueuePacket(BasePacket.CreatePacket(IssueListResponsePacket.BuildPacket(session.id, new string[] { "Test1", "Test2", "Test3", "Test4", "Test5" }), true, false)); session.QueuePacket(IssueListResponsePacket.BuildPacket(session.id, new string[] { "Test1", "Test2", "Test3", "Test4", "Test5" }));
break; break;
//Request if GM ticket exists //Request if GM ticket exists
case 0x01D3: case 0x01D3:
client.QueuePacket(BasePacket.CreatePacket(StartGMTicketPacket.BuildPacket(session.id, false), true, false)); session.QueuePacket(StartGMTicketPacket.BuildPacket(session.id, false));
break; break;
//Request for GM response message //Request for GM response message
case 0x01D4: case 0x01D4:
client.QueuePacket(BasePacket.CreatePacket(GMTicketPacket.BuildPacket(session.id, "This is a GM Ticket Title", "This is a GM Ticket Body."), true, false)); session.QueuePacket(GMTicketPacket.BuildPacket(session.id, "This is a GM Ticket Title", "This is a GM Ticket Body."));
break; break;
//GM Ticket Sent //GM Ticket Sent
case 0x01D5: case 0x01D5:
GMSupportTicketPacket gmTicket = new GMSupportTicketPacket(subpacket.data); GMSupportTicketPacket gmTicket = new GMSupportTicketPacket(subpacket.data);
Program.Log.Info("Got GM Ticket: \n" + gmTicket.ticketTitle + "\n" + gmTicket.ticketBody); Program.Log.Info("Got GM Ticket: \n" + gmTicket.ticketTitle + "\n" + gmTicket.ticketBody);
client.QueuePacket(BasePacket.CreatePacket(GMTicketSentResponsePacket.BuildPacket(session.id, true), true, false)); session.QueuePacket(GMTicketSentResponsePacket.BuildPacket(session.id, true));
break; break;
//Request to end ticket //Request to end ticket
case 0x01D6: case 0x01D6:
client.QueuePacket(BasePacket.CreatePacket(EndGMTicketPacket.BuildPacket(session.id), true, false)); session.QueuePacket(EndGMTicketPacket.BuildPacket(session.id));
break; break;
default: default:
Program.Log.Debug("Unknown command 0x{0:X} received.", subpacket.gameMessage.opcode); Program.Log.Debug("Unknown command 0x{0:X} received.", subpacket.gameMessage.opcode);

34
FFXIVClassic Map Server/WorldManager.cs
View File

@ -612,8 +612,8 @@ namespace FFXIVClassic_Map_Server
} }
//Send packets //Send packets
player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId), true, false); player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId));
player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10), true, false); player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10));
player.SendZoneInPackets(this, spawnType); player.SendZoneInPackets(this, spawnType);
player.playerSession.ClearInstance(); player.playerSession.ClearInstance();
player.SendInstanceUpdate(); player.SendInstanceUpdate();
@ -661,8 +661,8 @@ namespace FFXIVClassic_Map_Server
player.rotation = spawnRotation; player.rotation = spawnRotation;
//Send packets //Send packets
player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10), true, false); player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10));
player.playerSession.QueuePacket(player.CreateSpawnTeleportPacket(player.actorId, spawnType), true, false); player.playerSession.QueuePacket(player.CreateSpawnTeleportPacket(spawnType));
player.playerSession.LockUpdates(false); player.playerSession.LockUpdates(false);
player.SendInstanceUpdate(); player.SendInstanceUpdate();
@ -705,8 +705,8 @@ namespace FFXIVClassic_Map_Server
player.SendGameMessage(GetActor(), 34108, 0x20); player.SendGameMessage(GetActor(), 34108, 0x20);
//Send packets //Send packets
player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId), true, false); player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId));
player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10), true, false); player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10));
player.SendZoneInPackets(this, spawnType); player.SendZoneInPackets(this, spawnType);
player.playerSession.ClearInstance(); player.playerSession.ClearInstance();
player.SendInstanceUpdate(); player.SendInstanceUpdate();
@ -740,8 +740,8 @@ namespace FFXIVClassic_Map_Server
//Send packets //Send packets
if (!isLogin) if (!isLogin)
{ {
player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId), true, false); player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId));
player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x2), true, false); player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x2));
//player.SendZoneInPackets(this, spawnType); //player.SendZoneInPackets(this, spawnType);
} }
@ -876,55 +876,55 @@ namespace FFXIVClassic_Map_Server
public void RequestWorldLinkshellCreate(Player player, string name, ushort crest) public void RequestWorldLinkshellCreate(Player player, string name, ushort crest)
{ {
SubPacket packet = CreateLinkshellPacket.BuildPacket(player.playerSession, name, crest, player.actorId); SubPacket packet = CreateLinkshellPacket.BuildPacket(player.playerSession, name, crest, player.actorId);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellCrestModify(Player player, string name, ushort crest) public void RequestWorldLinkshellCrestModify(Player player, string name, ushort crest)
{ {
SubPacket packet = ModifyLinkshellPacket.BuildPacket(player.playerSession, 1, name, null, crest, 0); SubPacket packet = ModifyLinkshellPacket.BuildPacket(player.playerSession, 1, name, null, crest, 0);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellDelete(Player player, string name) public void RequestWorldLinkshellDelete(Player player, string name)
{ {
SubPacket packet = DeleteLinkshellPacket.BuildPacket(player.playerSession, name); SubPacket packet = DeleteLinkshellPacket.BuildPacket(player.playerSession, name);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellRankChange(Player player, string lsname, string memberName, byte newRank) public void RequestWorldLinkshellRankChange(Player player, string lsname, string memberName, byte newRank)
{ {
SubPacket packet = LinkshellRankChangePacket.BuildPacket(player.playerSession, memberName, lsname, newRank); SubPacket packet = LinkshellRankChangePacket.BuildPacket(player.playerSession, memberName, lsname, newRank);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellInviteMember(Player player, string lsname, uint invitedActorId) public void RequestWorldLinkshellInviteMember(Player player, string lsname, uint invitedActorId)
{ {
SubPacket packet = LinkshellInvitePacket.BuildPacket(player.playerSession, invitedActorId, lsname); SubPacket packet = LinkshellInvitePacket.BuildPacket(player.playerSession, invitedActorId, lsname);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellCancelInvite(Player player) public void RequestWorldLinkshellCancelInvite(Player player)
{ {
SubPacket packet = LinkshellInviteCancelPacket.BuildPacket(player.playerSession); SubPacket packet = LinkshellInviteCancelPacket.BuildPacket(player.playerSession);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellLeave(Player player, string lsname) public void RequestWorldLinkshellLeave(Player player, string lsname)
{ {
SubPacket packet = LinkshellLeavePacket.BuildPacket(player.playerSession, lsname, null, false); SubPacket packet = LinkshellLeavePacket.BuildPacket(player.playerSession, lsname, null, false);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellKick(Player player, string lsname, string kickedName) public void RequestWorldLinkshellKick(Player player, string lsname, string kickedName)
{ {
SubPacket packet = LinkshellLeavePacket.BuildPacket(player.playerSession, lsname, kickedName, true); SubPacket packet = LinkshellLeavePacket.BuildPacket(player.playerSession, lsname, kickedName, true);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
public void RequestWorldLinkshellChangeActive(Player player, string lsname) public void RequestWorldLinkshellChangeActive(Player player, string lsname)
{ {
SubPacket packet = LinkshellChangePacket.BuildPacket(player.playerSession, lsname); SubPacket packet = LinkshellChangePacket.BuildPacket(player.playerSession, lsname);
Server.GetWorldConnection().QueuePacket(packet, true, false); player.QueuePacket(packet);
} }
private void RequestWorldServerZoneChange(Player player, uint destinationZoneId, byte spawnType, float spawnX, float spawnY, float spawnZ, float spawnRotation) private void RequestWorldServerZoneChange(Player player, uint destinationZoneId, byte spawnType, float spawnX, float spawnY, float spawnZ, float spawnRotation)

153
FFXIVClassic Map Server/actors/Actor.cs
View File

@ -9,6 +9,7 @@ using System.Collections.Generic;
using FFXIVClassic_Map_Server.actors.area; using FFXIVClassic_Map_Server.actors.area;
using System.Reflection; using System.Reflection;
using System.ComponentModel; using System.ComponentModel;
using FFXIVClassic_Map_Server.packets.send.actor.battle;
namespace FFXIVClassic_Map_Server.Actors namespace FFXIVClassic_Map_Server.Actors
{ {
@ -75,66 +76,73 @@ namespace FFXIVClassic_Map_Server.Actors
} }
} }
public SubPacket CreateAddActorPacket(uint playerActorId, byte val) public SubPacket CreateAddActorPacket(byte val)
{ {
return AddActorPacket.BuildPacket(actorId, playerActorId, val); return AddActorPacket.BuildPacket(actorId, val);
} }
public SubPacket CreateNamePacket(uint playerActorId) public SubPacket CreateNamePacket()
{ {
return SetActorNamePacket.BuildPacket(actorId, playerActorId, displayNameId, displayNameId == 0xFFFFFFFF | displayNameId == 0x0 ? customDisplayName : ""); return SetActorNamePacket.BuildPacket(actorId, displayNameId, displayNameId == 0xFFFFFFFF | displayNameId == 0x0 ? customDisplayName : "");
} }
public SubPacket CreateSpeedPacket(uint playerActorId) public SubPacket CreateSpeedPacket()
{ {
return SetActorSpeedPacket.BuildPacket(actorId, playerActorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]); return SetActorSpeedPacket.BuildPacket(actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
} }
public SubPacket CreateSpawnPositonPacket(uint playerActorId, ushort spawnType) public SubPacket CreateSpawnPositonPacket(ushort spawnType)
{ {
return CreateSpawnPositonPacket(null, spawnType);
}
public SubPacket CreateSpawnPositonPacket(Player player, ushort spawnType)
{
//TODO: FIX THIS IF
uint playerActorId = player == null ? 0 : player.actorId; //Get Rid
SubPacket spawnPacket; SubPacket spawnPacket;
if (!spawnedFirstTime && playerActorId == actorId) if (!spawnedFirstTime && playerActorId == actorId)
spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0, positionX, positionY, positionZ, rotation, 0x1, false); spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0, positionX, positionY, positionZ, rotation, 0x1, false);
else if (playerActorId == actorId) else if (playerActorId == actorId)
spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, true); spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, true);
else else
{ {
if (this is Player) if (this is Player)
spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0, positionX, positionY, positionZ, rotation, spawnType, false); spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0, positionX, positionY, positionZ, rotation, spawnType, false);
else else
spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, actorId, positionX, positionY, positionZ, rotation, spawnType, false); spawnPacket = SetActorPositionPacket.BuildPacket(actorId, actorId, positionX, positionY, positionZ, rotation, spawnType, false);
} }
//return SetActorPositionPacket.BuildPacket(actorId, playerActorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE); //return SetActorPositionPacket.BuildPacket(actorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE);
spawnedFirstTime = true; spawnedFirstTime = true;
return spawnPacket; return spawnPacket;
} }
public SubPacket CreateSpawnTeleportPacket(uint playerActorId, ushort spawnType) public SubPacket CreateSpawnTeleportPacket(ushort spawnType)
{ {
SubPacket spawnPacket; SubPacket spawnPacket;
spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, false); spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, false);
//return SetActorPositionPacket.BuildPacket(actorId, playerActorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE); //return SetActorPositionPacket.BuildPacket(actorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE);
//spawnPacket.DebugPrintSubPacket(); //spawnPacket.DebugPrintSubPacket();
return spawnPacket; return spawnPacket;
} }
public SubPacket CreatePositionUpdatePacket(uint playerActorId) public SubPacket CreatePositionUpdatePacket()
{ {
return MoveActorToPositionPacket.BuildPacket(actorId, playerActorId, positionX, positionY, positionZ, rotation, moveState); return MoveActorToPositionPacket.BuildPacket(actorId, positionX, positionY, positionZ, rotation, moveState);
} }
public SubPacket CreateStatePacket(uint playerActorID) public SubPacket CreateStatePacket()
{ {
return SetActorStatePacket.BuildPacket(actorId, playerActorID, currentMainState, currentSubState); return SetActorStatePacket.BuildPacket(actorId, currentMainState, currentSubState);
} }
public List<SubPacket> GetEventConditionPackets(uint playerActorId) public List<SubPacket> GetEventConditionPackets()
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
@ -145,126 +153,147 @@ namespace FFXIVClassic_Map_Server.Actors
if (eventConditions.talkEventConditions != null) if (eventConditions.talkEventConditions != null)
{ {
foreach (EventList.TalkEventCondition condition in eventConditions.talkEventConditions) foreach (EventList.TalkEventCondition condition in eventConditions.talkEventConditions)
subpackets.Add(SetTalkEventCondition.BuildPacket(playerActorId, actorId, condition)); subpackets.Add(SetTalkEventCondition.BuildPacket(actorId, condition));
} }
if (eventConditions.noticeEventConditions != null) if (eventConditions.noticeEventConditions != null)
{ {
foreach (EventList.NoticeEventCondition condition in eventConditions.noticeEventConditions) foreach (EventList.NoticeEventCondition condition in eventConditions.noticeEventConditions)
subpackets.Add(SetNoticeEventCondition.BuildPacket(playerActorId, actorId, condition)); subpackets.Add(SetNoticeEventCondition.BuildPacket(actorId, condition));
} }
if (eventConditions.emoteEventConditions != null) if (eventConditions.emoteEventConditions != null)
{ {
foreach (EventList.EmoteEventCondition condition in eventConditions.emoteEventConditions) foreach (EventList.EmoteEventCondition condition in eventConditions.emoteEventConditions)
subpackets.Add(SetEmoteEventCondition.BuildPacket(playerActorId, actorId, condition)); subpackets.Add(SetEmoteEventCondition.BuildPacket(actorId, condition));
} }
if (eventConditions.pushWithCircleEventConditions != null) if (eventConditions.pushWithCircleEventConditions != null)
{ {
foreach (EventList.PushCircleEventCondition condition in eventConditions.pushWithCircleEventConditions) foreach (EventList.PushCircleEventCondition condition in eventConditions.pushWithCircleEventConditions)
subpackets.Add(SetPushEventConditionWithCircle.BuildPacket(playerActorId, actorId, condition)); subpackets.Add(SetPushEventConditionWithCircle.BuildPacket(actorId, condition));
} }
if (eventConditions.pushWithFanEventConditions != null) if (eventConditions.pushWithFanEventConditions != null)
{ {
foreach (EventList.PushFanEventCondition condition in eventConditions.pushWithFanEventConditions) foreach (EventList.PushFanEventCondition condition in eventConditions.pushWithFanEventConditions)
subpackets.Add(SetPushEventConditionWithFan.BuildPacket(playerActorId, actorId, condition)); subpackets.Add(SetPushEventConditionWithFan.BuildPacket(actorId, condition));
} }
if (eventConditions.pushWithBoxEventConditions != null) if (eventConditions.pushWithBoxEventConditions != null)
{ {
foreach (EventList.PushBoxEventCondition condition in eventConditions.pushWithBoxEventConditions) foreach (EventList.PushBoxEventCondition condition in eventConditions.pushWithBoxEventConditions)
subpackets.Add(SetPushEventConditionWithTriggerBox.BuildPacket(playerActorId, actorId, condition)); subpackets.Add(SetPushEventConditionWithTriggerBox.BuildPacket(actorId, condition));
} }
return subpackets; return subpackets;
} }
public BasePacket GetSetEventStatusPackets(uint playerActorId) public List<SubPacket> GetSetEventStatusPackets()
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
//Return empty list //Return empty list
if (eventConditions == null) if (eventConditions == null)
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
if (eventConditions.talkEventConditions != null) if (eventConditions.talkEventConditions != null)
{ {
foreach (EventList.TalkEventCondition condition in eventConditions.talkEventConditions) foreach (EventList.TalkEventCondition condition in eventConditions.talkEventConditions)
subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 1, condition.conditionName)); subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 1, condition.conditionName));
} }
if (eventConditions.noticeEventConditions != null) if (eventConditions.noticeEventConditions != null)
{ {
foreach (EventList.NoticeEventCondition condition in eventConditions.noticeEventConditions) foreach (EventList.NoticeEventCondition condition in eventConditions.noticeEventConditions)
subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 1, condition.conditionName)); subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 1, condition.conditionName));
} }
if (eventConditions.emoteEventConditions != null) if (eventConditions.emoteEventConditions != null)
{ {
foreach (EventList.EmoteEventCondition condition in eventConditions.emoteEventConditions) foreach (EventList.EmoteEventCondition condition in eventConditions.emoteEventConditions)
subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 3, condition.conditionName)); subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 3, condition.conditionName));
} }
if (eventConditions.pushWithCircleEventConditions != null) if (eventConditions.pushWithCircleEventConditions != null)
{ {
foreach (EventList.PushCircleEventCondition condition in eventConditions.pushWithCircleEventConditions) foreach (EventList.PushCircleEventCondition condition in eventConditions.pushWithCircleEventConditions)
subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 2, condition.conditionName)); subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 2, condition.conditionName));
} }
if (eventConditions.pushWithFanEventConditions != null) if (eventConditions.pushWithFanEventConditions != null)
{ {
foreach (EventList.PushFanEventCondition condition in eventConditions.pushWithFanEventConditions) foreach (EventList.PushFanEventCondition condition in eventConditions.pushWithFanEventConditions)
subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 2, condition.conditionName)); subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 2, condition.conditionName));
} }
if (eventConditions.pushWithBoxEventConditions != null) if (eventConditions.pushWithBoxEventConditions != null)
{ {
foreach (EventList.PushBoxEventCondition condition in eventConditions.pushWithBoxEventConditions) foreach (EventList.PushBoxEventCondition condition in eventConditions.pushWithBoxEventConditions)
subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 2, condition.conditionName)); subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 2, condition.conditionName));
} }
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
public SubPacket CreateIsZoneingPacket(uint playerActorId) public SubPacket CreateIsZoneingPacket()
{ {
return SetActorIsZoningPacket.BuildPacket(actorId, playerActorId, false); return SetActorIsZoningPacket.BuildPacket(actorId, false);
} }
public virtual SubPacket CreateScriptBindPacket(uint playerActorId) public virtual SubPacket CreateScriptBindPacket(Player player)
{ {
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, classParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, classParams);
} }
public virtual BasePacket GetSpawnPackets(uint playerActorId) public virtual SubPacket CreateScriptBindPacket()
{ {
return GetSpawnPackets(playerActorId, 0x1); return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, classParams);
} }
public virtual BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType) public virtual List<SubPacket> GetSpawnPackets(Player player, ushort spawnType)
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(playerActorId, 8)); subpackets.Add(CreateAddActorPacket(8));
subpackets.AddRange(GetEventConditionPackets(playerActorId)); subpackets.AddRange(GetEventConditionPackets());
subpackets.Add(CreateSpeedPacket(playerActorId)); subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(playerActorId, spawnType)); subpackets.Add(CreateSpawnPositonPacket(player, spawnType));
subpackets.Add(CreateNamePacket(playerActorId)); subpackets.Add(CreateNamePacket());
subpackets.Add(CreateStatePacket(playerActorId)); subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIsZoneingPacket(playerActorId)); subpackets.Add(CreateIsZoneingPacket());
subpackets.Add(CreateScriptBindPacket(playerActorId)); subpackets.Add(CreateScriptBindPacket(player));
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
public virtual BasePacket GetInitPackets(uint playerActorId) public virtual List<SubPacket> GetSpawnPackets()
{ {
return GetSpawnPackets(0x1);
}
public virtual List<SubPacket> GetSpawnPackets(ushort spawnType)
{
List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(8));
subpackets.AddRange(GetEventConditionPackets());
subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(null, spawnType));
subpackets.Add(CreateNamePacket());
subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIsZoneingPacket());
subpackets.Add(CreateScriptBindPacket());
return subpackets;
}
public virtual List<SubPacket> GetInitPackets()
{
List<SubPacket> packets = new List<SubPacket>();
SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init"); SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init");
initProperties.AddByte(0xE14B0CA8, 1); initProperties.AddByte(0xE14B0CA8, 1);
initProperties.AddByte(0x2138FD71, 1); initProperties.AddByte(0x2138FD71, 1);
initProperties.AddByte(0xFBFBCFB1, 1); initProperties.AddByte(0xFBFBCFB1, 1);
initProperties.AddTarget(); initProperties.AddTarget();
return BasePacket.CreatePacket(initProperties.BuildPacket(playerActorId, actorId), true, false); packets.Add(initProperties.BuildPacket(actorId));
return packets;
} }
public override bool Equals(Object obj) public override bool Equals(Object obj)
@ -299,8 +328,8 @@ namespace FFXIVClassic_Map_Server.Actors
public void ChangeState(ushort newState) public void ChangeState(ushort newState)
{ {
currentMainState = newState; currentMainState = newState;
SubPacket ChangeStatePacket = SetActorStatePacket.BuildPacket(actorId, actorId, newState, currentSubState); SubPacket ChangeStatePacket = SetActorStatePacket.BuildPacket(actorId, newState, currentSubState);
SubPacket battleActionPacket = BattleAction1Packet.BuildPacket(actorId, actorId); SubPacket battleActionPacket = BattleActionX01Packet.BuildPacket(actorId, actorId, actorId, 0x72000062, 1, 0, 0x05209, 0, 0);
zone.BroadcastPacketAroundActor(this, ChangeStatePacket); zone.BroadcastPacketAroundActor(this, ChangeStatePacket);
zone.BroadcastPacketAroundActor(this, battleActionPacket); zone.BroadcastPacketAroundActor(this, battleActionPacket);
} }
@ -308,7 +337,7 @@ namespace FFXIVClassic_Map_Server.Actors
public void ChangeSpeed(int type, float value) public void ChangeSpeed(int type, float value)
{ {
moveSpeeds[type] = value; moveSpeeds[type] = value;
SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]); SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
zone.BroadcastPacketAroundActor(this, ChangeSpeedPacket); zone.BroadcastPacketAroundActor(this, ChangeSpeedPacket);
} }
@ -318,7 +347,7 @@ namespace FFXIVClassic_Map_Server.Actors
moveSpeeds[1] = speedWalk; moveSpeeds[1] = speedWalk;
moveSpeeds[2] = speedRun; moveSpeeds[2] = speedRun;
moveSpeeds[3] = speedActive; moveSpeeds[3] = speedActive;
SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]); SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
zone.BroadcastPacketAroundActor(this, ChangeSpeedPacket); zone.BroadcastPacketAroundActor(this, ChangeSpeedPacket);
} }
@ -426,8 +455,8 @@ namespace FFXIVClassic_Map_Server.Actors
SetActorPropetyPacket changeProperty = new SetActorPropetyPacket(uiFunc); SetActorPropetyPacket changeProperty = new SetActorPropetyPacket(uiFunc);
changeProperty.AddProperty(this, name); changeProperty.AddProperty(this, name);
changeProperty.AddTarget(); changeProperty.AddTarget();
SubPacket subpacket = changeProperty.BuildPacket(player.actorId, player.actorId); SubPacket subpacket = changeProperty.BuildPacket(player.actorId);
player.playerSession.QueuePacket(subpacket, true, false); player.playerSession.QueuePacket(subpacket);
subpacket.DebugPrintSubPacket(); subpacket.DebugPrintSubPacket();
return true; return true;
} }
@ -444,8 +473,8 @@ namespace FFXIVClassic_Map_Server.Actors
SetActorPropetyPacket changeProperty = new SetActorPropetyPacket(uiFunc); SetActorPropetyPacket changeProperty = new SetActorPropetyPacket(uiFunc);
changeProperty.AddProperty(this, name); changeProperty.AddProperty(this, name);
changeProperty.AddTarget(); changeProperty.AddTarget();
SubPacket subpacket = changeProperty.BuildPacket(player.actorId, player.actorId); SubPacket subpacket = changeProperty.BuildPacket(player.actorId);
player.playerSession.QueuePacket(subpacket, true, false); player.playerSession.QueuePacket(subpacket);
subpacket.DebugPrintSubPacket(); subpacket.DebugPrintSubPacket();
return true; return true;
} }
@ -480,7 +509,7 @@ namespace FFXIVClassic_Map_Server.Actors
rotation = rot; rotation = rot;
// todo: handle zone? // todo: handle zone?
zone.BroadcastPacketAroundActor(this, MoveActorToPositionPacket.BuildPacket(this.actorId, this.actorId, x, y, z, rot, moveState)); zone.BroadcastPacketAroundActor(this, MoveActorToPositionPacket.BuildPacket(actorId, x, y, z, rot, moveState));
} }
public Area GetZone() public Area GetZone()

26
FFXIVClassic Map Server/actors/area/Area.cs
View File

@ -84,24 +84,24 @@ namespace FFXIVClassic_Map_Server.Actors
} }
} }
public override SubPacket CreateScriptBindPacket(uint playerActorId) public override SubPacket CreateScriptBindPacket()
{ {
List<LuaParam> lParams; List<LuaParam> lParams;
lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, "/Area/Zone/ZoneDefault", -1, (byte)1, true, false, false, false, false, false, false, false); lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, "/Area/Zone/ZoneDefault", -1, (byte)1, true, false, false, false, false, false, false, false);
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, "ZoneDefault", lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, "ZoneDefault", lParams);
} }
public override BasePacket GetSpawnPackets(uint playerActorId) public override List<SubPacket> GetSpawnPackets()
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(playerActorId, 0)); subpackets.Add(CreateAddActorPacket(0));
subpackets.Add(CreateSpeedPacket(playerActorId)); subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x1)); subpackets.Add(CreateSpawnPositonPacket(0x1));
subpackets.Add(CreateNamePacket(playerActorId)); subpackets.Add(CreateNamePacket());
subpackets.Add(CreateStatePacket(playerActorId)); subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIsZoneingPacket(playerActorId)); subpackets.Add(CreateIsZoneingPacket());
subpackets.Add(CreateScriptBindPacket(playerActorId)); subpackets.Add(CreateScriptBindPacket());
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
#region Actor Management #region Actor Management
@ -483,7 +483,7 @@ namespace FFXIVClassic_Map_Server.Actors
if (player != null && !zoneWide) if (player != null && !zoneWide)
{ {
player.QueuePacket(BasePacket.CreatePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime), true, false)); player.QueuePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime));
} }
if (zoneWide) if (zoneWide)
{ {
@ -494,7 +494,7 @@ namespace FFXIVClassic_Map_Server.Actors
if (actor.Value is Player) if (actor.Value is Player)
{ {
player = ((Player)actor.Value); player = ((Player)actor.Value);
player.QueuePacket(BasePacket.CreatePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime), true, false)); player.QueuePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime));
} }
} }
} }

6
FFXIVClassic Map Server/actors/area/PrivateArea.cs
View File

@ -41,7 +41,7 @@ namespace FFXIVClassic_Map_Server.actors.area
return parentZone; return parentZone;
} }
public override SubPacket CreateScriptBindPacket(uint playerActorId) public override SubPacket CreateScriptBindPacket()
{ {
List<LuaParam> lParams; List<LuaParam> lParams;
@ -50,8 +50,8 @@ namespace FFXIVClassic_Map_Server.actors.area
string realClassName = className.Substring(className.LastIndexOf("/") + 1); 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); 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, playerActorId, actorName, realClassName, lParams).DebugPrintSubPacket(); ActorInstantiatePacket.BuildPacket(actorId, actorName, realClassName, lParams).DebugPrintSubPacket();
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, realClassName, lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, realClassName, lParams);
} }

4
FFXIVClassic Map Server/actors/area/Zone.cs
View File

@ -51,13 +51,13 @@ namespace FFXIVClassic_Map_Server.actors.area
return null; return null;
} }
public override SubPacket CreateScriptBindPacket(uint playerActorId) public override SubPacket CreateScriptBindPacket()
{ {
bool isEntranceDesion = false; bool isEntranceDesion = false;
List<LuaParam> lParams; List<LuaParam> lParams;
lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, "", -1, canRideChocobo ? (byte)1 : (byte)0, canStealth, isInn, false, false, false, true, isInstanceRaid, isEntranceDesion); 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, playerActorId, actorName, className, lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
} }
public void AddSpawnLocation(SpawnLocation spawn) public void AddSpawnLocation(SpawnLocation spawn)

24
FFXIVClassic Map Server/actors/chara/Character.cs
View File

@ -63,30 +63,30 @@ namespace FFXIVClassic_Map_Server.Actors
charaWork.statusShownTime[i] = 0xFFFFFFFF; charaWork.statusShownTime[i] = 0xFFFFFFFF;
} }
public SubPacket CreateAppearancePacket(uint playerActorId) public SubPacket CreateAppearancePacket()
{ {
SetActorAppearancePacket setappearance = new SetActorAppearancePacket(modelId, appearanceIds); SetActorAppearancePacket setappearance = new SetActorAppearancePacket(modelId, appearanceIds);
return setappearance.BuildPacket(actorId, playerActorId); return setappearance.BuildPacket(actorId);
} }
public SubPacket CreateInitStatusPacket(uint playerActorId) public SubPacket CreateInitStatusPacket()
{ {
return (SetActorStatusAllPacket.BuildPacket(actorId, playerActorId, charaWork.status)); return (SetActorStatusAllPacket.BuildPacket(actorId, charaWork.status));
} }
public SubPacket CreateSetActorIconPacket(uint playerActorId) public SubPacket CreateSetActorIconPacket()
{ {
return SetActorIconPacket.BuildPacket(actorId, playerActorId, currentActorIcon); return SetActorIconPacket.BuildPacket(actorId, currentActorIcon);
} }
public SubPacket CreateIdleAnimationPacket(uint playerActorId) public SubPacket CreateIdleAnimationPacket()
{ {
return SetActorSubStatPacket.BuildPacket(actorId, playerActorId, 0, 0, 0, 0, 0, 0, animationId); return SetActorSubStatPacket.BuildPacket(actorId, 0, 0, 0, 0, 0, 0, animationId);
} }
public void SetQuestGraphic(Player player, int graphicNum) public void SetQuestGraphic(Player player, int graphicNum)
{ {
player.QueuePacket(SetActorQuestGraphicPacket.BuildPacket(player.actorId, actorId, graphicNum)); player.QueuePacket(SetActorQuestGraphicPacket.BuildPacket(actorId, graphicNum));
} }
public void SetCurrentContentGroup(ContentGroup group) public void SetCurrentContentGroup(ContentGroup group)
@ -98,7 +98,7 @@ namespace FFXIVClassic_Map_Server.Actors
currentContentGroup = group; currentContentGroup = group;
ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("charaWork/currentContentGroup", this, actorId); ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("charaWork/currentContentGroup", this);
propPacketUtil.AddProperty("charaWork.currentContentGroup"); propPacketUtil.AddProperty("charaWork.currentContentGroup");
zone.BroadcastPacketsAroundActor(this, propPacketUtil.Done()); zone.BroadcastPacketsAroundActor(this, propPacketUtil.Done());
@ -109,10 +109,10 @@ namespace FFXIVClassic_Map_Server.Actors
if (onlySelf) if (onlySelf)
{ {
if (this is Player) if (this is Player)
((Player)this).QueuePacket(PlayAnimationOnActorPacket.BuildPacket(actorId, actorId, animId)); ((Player)this).QueuePacket(PlayAnimationOnActorPacket.BuildPacket(actorId, animId));
} }
else else
zone.BroadcastPacketAroundActor(this, PlayAnimationOnActorPacket.BuildPacket(actorId, actorId, animId)); zone.BroadcastPacketAroundActor(this, PlayAnimationOnActorPacket.BuildPacket(actorId, animId));
} }
} }

59
FFXIVClassic Map Server/actors/chara/npc/Npc.cs
View File

@ -126,18 +126,17 @@ namespace FFXIVClassic_Map_Server.Actors
GenerateActorName((int)actorNumber); GenerateActorName((int)actorNumber);
} }
public SubPacket CreateAddActorPacket(uint playerActorId) public SubPacket CreateAddActorPacket()
{ {
return AddActorPacket.BuildPacket(actorId, playerActorId, 8); return AddActorPacket.BuildPacket(actorId, 8);
} }
int val = 0x0b00; int val = 0x0b00;
// actorClassId, [], [], numBattleCommon, [battleCommon], numEventCommon, [eventCommon], args for either initForBattle/initForEvent // actorClassId, [], [], numBattleCommon, [battleCommon], numEventCommon, [eventCommon], args for either initForBattle/initForEvent
public override SubPacket CreateScriptBindPacket(uint playerActorId) public override SubPacket CreateScriptBindPacket(Player player)
{ {
List<LuaParam> lParams; List<LuaParam> lParams;
Player player = Server.GetWorldManager().GetPCInWorld(playerActorId);
lParams = LuaEngine.GetInstance().CallLuaFunctionForReturn(player, this, "init", false); lParams = LuaEngine.GetInstance().CallLuaFunctionForReturn(player, this, "init", false);
if (uniqueIdentifier.Equals("1")) if (uniqueIdentifier.Equals("1"))
@ -161,8 +160,8 @@ namespace FFXIVClassic_Map_Server.Actors
string classNameFake = "PopulaceStandard"; string classNameFake = "PopulaceStandard";
lParams = LuaUtils.CreateLuaParamList(classPathFake, false, false, false, false, false, 0xF47F6, false, false, 0, 0); lParams = LuaUtils.CreateLuaParamList(classPathFake, false, false, false, false, false, 0xF47F6, false, false, 0, 0);
isStatic = true; isStatic = true;
//ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, classNameFake, lParams).DebugPrintSubPacket(); //ActorInstantiatePacket.BuildPacket(actorId, actorName, classNameFake, lParams).DebugPrintSubPacket();
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, classNameFake, lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, classNameFake, lParams);
} }
else else
{ {
@ -175,37 +174,37 @@ namespace FFXIVClassic_Map_Server.Actors
lParams.Insert(6, new LuaParam(0, (int)actorClassId)); lParams.Insert(6, new LuaParam(0, (int)actorClassId));
} }
//ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams).DebugPrintSubPacket(); //ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams).DebugPrintSubPacket();
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
} }
public override BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType) public override List<SubPacket> GetSpawnPackets(Player player, ushort spawnType)
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(playerActorId)); subpackets.Add(CreateAddActorPacket());
subpackets.AddRange(GetEventConditionPackets(playerActorId)); subpackets.AddRange(GetEventConditionPackets());
subpackets.Add(CreateSpeedPacket(playerActorId)); subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x0)); subpackets.Add(CreateSpawnPositonPacket(0x0));
if (isMapObj) if (isMapObj)
subpackets.Add(_0xD8Packet.BuildPacket(actorId, playerActorId, instance, layout)); subpackets.Add(SetActorBGPropertiesPacket.BuildPacket(actorId, instance, layout));
else else
subpackets.Add(CreateAppearancePacket(playerActorId)); subpackets.Add(CreateAppearancePacket());
subpackets.Add(CreateNamePacket(playerActorId)); subpackets.Add(CreateNamePacket());
subpackets.Add(CreateStatePacket(playerActorId)); subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIdleAnimationPacket(playerActorId)); subpackets.Add(CreateIdleAnimationPacket());
subpackets.Add(CreateInitStatusPacket(playerActorId)); subpackets.Add(CreateInitStatusPacket());
subpackets.Add(CreateSetActorIconPacket(playerActorId)); subpackets.Add(CreateSetActorIconPacket());
subpackets.Add(CreateIsZoneingPacket(playerActorId)); subpackets.Add(CreateIsZoneingPacket());
subpackets.Add(CreateScriptBindPacket(playerActorId)); subpackets.Add(CreateScriptBindPacket(player));
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
public override BasePacket GetInitPackets(uint playerActorId) public override List<SubPacket> GetInitPackets()
{ {
ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this, playerActorId); ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this);
//Potential //Potential
propPacketUtil.AddProperty("charaWork.battleSave.potencial"); propPacketUtil.AddProperty("charaWork.battleSave.potencial");
@ -259,7 +258,7 @@ namespace FFXIVClassic_Map_Server.Actors
propPacketUtil.AddProperty("npcWork.pushCommandPriority"); propPacketUtil.AddProperty("npcWork.pushCommandPriority");
} }
return BasePacket.CreatePacket(propPacketUtil.Done(), true, false); return propPacketUtil.Done();
} }
public string GetUniqueId() public string GetUniqueId()
@ -275,7 +274,7 @@ namespace FFXIVClassic_Map_Server.Actors
public void ChangeNpcAppearance(uint id) public void ChangeNpcAppearance(uint id)
{ {
LoadNpcAppearance(id); LoadNpcAppearance(id);
zone.BroadcastPacketAroundActor(this, CreateAppearancePacket(actorId)); zone.BroadcastPacketAroundActor(this, CreateAppearancePacket());
} }
public void LoadNpcAppearance(uint id) public void LoadNpcAppearance(uint id)
@ -393,7 +392,7 @@ namespace FFXIVClassic_Map_Server.Actors
public void PlayMapObjAnimation(Player player, string animationName) public void PlayMapObjAnimation(Player player, string animationName)
{ {
player.QueuePacket(PlayBGAnimation.BuildPacket(actorId, player.actorId, animationName)); player.QueuePacket(PlayBGAnimation.BuildPacket(actorId, animationName));
} }
public void Despawn() public void Despawn()

10
FFXIVClassic Map Server/actors/chara/player/Equipment.cs
View File

@ -63,24 +63,24 @@ namespace FFXIVClassic_Map_Server.actors.chara.player
} }
} }
toPlayer.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, toPlayer.actorId, 0x23, Inventory.EQUIPMENT_OTHERPLAYER)); toPlayer.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, 0x23, Inventory.EQUIPMENT_OTHERPLAYER));
int currentIndex = 0; int currentIndex = 0;
while (true) while (true)
{ {
if (items.Count - currentIndex >= 16) if (items.Count - currentIndex >= 16)
toPlayer.QueuePacket(InventoryListX16Packet.BuildPacket(owner.actorId, toPlayer.actorId, items, ref currentIndex)); toPlayer.QueuePacket(InventoryListX16Packet.BuildPacket(owner.actorId, items, ref currentIndex));
else if (items.Count - currentIndex > 1) else if (items.Count - currentIndex > 1)
toPlayer.QueuePacket(InventoryListX08Packet.BuildPacket(owner.actorId, toPlayer.actorId, items, ref currentIndex)); toPlayer.QueuePacket(InventoryListX08Packet.BuildPacket(owner.actorId, items, ref currentIndex));
else if (items.Count - currentIndex == 1) else if (items.Count - currentIndex == 1)
{ {
toPlayer.QueuePacket(InventoryListX01Packet.BuildPacket(owner.actorId, toPlayer.actorId, items[currentIndex])); toPlayer.QueuePacket(InventoryListX01Packet.BuildPacket(owner.actorId, items[currentIndex]));
currentIndex++; currentIndex++;
} }
else else
break; break;
} }
toPlayer.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId, toPlayer.actorId)); toPlayer.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
} }
public void SendFullEquipment(bool DoClear) public void SendFullEquipment(bool DoClear)

183
FFXIVClassic Map Server/actors/chara/player/Player.cs
View File

@ -249,17 +249,17 @@ namespace FFXIVClassic_Map_Server.Actors
lastPlayTimeUpdate = Utils.UnixTimeStampUTC(); lastPlayTimeUpdate = Utils.UnixTimeStampUTC();
} }
public List<SubPacket> Create0x132Packets(uint playerActorId) public List<SubPacket> Create0x132Packets()
{ {
List<SubPacket> packets = new List<SubPacket>(); List<SubPacket> packets = new List<SubPacket>();
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0xB, "commandForced")); packets.Add(_0x132Packet.BuildPacket(actorId, 0xB, "commandForced"));
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0xA, "commandDefault")); packets.Add(_0x132Packet.BuildPacket(actorId, 0xA, "commandDefault"));
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x6, "commandWeak")); packets.Add(_0x132Packet.BuildPacket(actorId, 0x6, "commandWeak"));
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x4, "commandContent")); packets.Add(_0x132Packet.BuildPacket(actorId, 0x4, "commandContent"));
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x6, "commandJudgeMode")); packets.Add(_0x132Packet.BuildPacket(actorId, 0x6, "commandJudgeMode"));
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x100, "commandRequest")); packets.Add(_0x132Packet.BuildPacket(actorId, 0x100, "commandRequest"));
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x100, "widgetCreate")); packets.Add(_0x132Packet.BuildPacket(actorId, 0x100, "widgetCreate"));
packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x100, "macroRequest")); packets.Add(_0x132Packet.BuildPacket(actorId, 0x100, "macroRequest"));
return packets; return packets;
} }
@ -274,10 +274,10 @@ namespace FFXIVClassic_Map_Server.Actors
* Timer Array - 20 Number * Timer Array - 20 Number
*/ */
public override SubPacket CreateScriptBindPacket(uint playerActorId) public override SubPacket CreateScriptBindPacket(Player requestPlayer)
{ {
List<LuaParam> lParams; List<LuaParam> lParams;
if (IsMyPlayer(playerActorId)) if (IsMyPlayer(requestPlayer.actorId))
{ {
if (loginInitDirector != null) if (loginInitDirector != null)
lParams = LuaUtils.CreateLuaParamList("/Chara/Player/Player_work", false, false, true, loginInitDirector, true, 0, false, timers, true); lParams = LuaUtils.CreateLuaParamList("/Chara/Player/Player_work", false, false, true, loginInitDirector, true, 0, false, timers, true);
@ -287,59 +287,59 @@ namespace FFXIVClassic_Map_Server.Actors
else else
lParams = LuaUtils.CreateLuaParamList("/Chara/Player/Player_work", false, false, false, false, false, true); lParams = LuaUtils.CreateLuaParamList("/Chara/Player/Player_work", false, false, false, false, false, true);
ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams).DebugPrintSubPacket(); ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams).DebugPrintSubPacket();
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
} }
public override BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType) public override List<SubPacket> GetSpawnPackets(Player requestPlayer, ushort spawnType)
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(playerActorId, 8)); subpackets.Add(CreateAddActorPacket(8));
if (IsMyPlayer(playerActorId)) if (IsMyPlayer(requestPlayer.actorId))
subpackets.AddRange(Create0x132Packets(playerActorId)); subpackets.AddRange(Create0x132Packets());
subpackets.Add(CreateSpeedPacket(playerActorId)); subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(playerActorId, spawnType)); subpackets.Add(CreateSpawnPositonPacket(this, spawnType));
subpackets.Add(CreateAppearancePacket(playerActorId)); subpackets.Add(CreateAppearancePacket());
subpackets.Add(CreateNamePacket(playerActorId)); subpackets.Add(CreateNamePacket());
subpackets.Add(_0xFPacket.BuildPacket(playerActorId, playerActorId)); subpackets.Add(_0xFPacket.BuildPacket(actorId));
subpackets.Add(CreateStatePacket(playerActorId)); subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIdleAnimationPacket(playerActorId)); subpackets.Add(CreateIdleAnimationPacket());
subpackets.Add(CreateInitStatusPacket(playerActorId)); subpackets.Add(CreateInitStatusPacket());
subpackets.Add(CreateSetActorIconPacket(playerActorId)); subpackets.Add(CreateSetActorIconPacket());
subpackets.Add(CreateIsZoneingPacket(playerActorId)); subpackets.Add(CreateIsZoneingPacket());
subpackets.AddRange(CreatePlayerRelatedPackets(playerActorId)); subpackets.AddRange(CreatePlayerRelatedPackets(requestPlayer.actorId));
subpackets.Add(CreateScriptBindPacket(playerActorId)); subpackets.Add(CreateScriptBindPacket(requestPlayer));
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
public List<SubPacket> CreatePlayerRelatedPackets(uint playerActorId) public List<SubPacket> CreatePlayerRelatedPackets(uint requestingPlayerActorId)
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
if (gcCurrent != 0) if (gcCurrent != 0)
subpackets.Add(SetGrandCompanyPacket.BuildPacket(actorId, playerActorId, gcCurrent, gcRankLimsa, gcRankGridania, gcRankUldah)); subpackets.Add(SetGrandCompanyPacket.BuildPacket(actorId, gcCurrent, gcRankLimsa, gcRankGridania, gcRankUldah));
if (currentTitle != 0) if (currentTitle != 0)
subpackets.Add(SetPlayerTitlePacket.BuildPacket(actorId, playerActorId, currentTitle)); subpackets.Add(SetPlayerTitlePacket.BuildPacket(actorId, currentTitle));
if (currentJob != 0) if (currentJob != 0)
subpackets.Add(SetCurrentJobPacket.BuildPacket(actorId, playerActorId, currentJob)); subpackets.Add(SetCurrentJobPacket.BuildPacket(actorId, currentJob));
if (IsMyPlayer(playerActorId)) if (IsMyPlayer(requestingPlayerActorId))
{ {
subpackets.Add(SetSpecialEventWorkPacket.BuildPacket(playerActorId, playerActorId)); subpackets.Add(SetSpecialEventWorkPacket.BuildPacket(actorId));
if (hasChocobo && chocoboName != null && !chocoboName.Equals("")) if (hasChocobo && chocoboName != null && !chocoboName.Equals(""))
{ {
subpackets.Add(SetChocoboNamePacket.BuildPacket(actorId, playerActorId, chocoboName)); subpackets.Add(SetChocoboNamePacket.BuildPacket(actorId, chocoboName));
subpackets.Add(SetHasChocoboPacket.BuildPacket(playerActorId, hasChocobo)); subpackets.Add(SetHasChocoboPacket.BuildPacket(actorId, hasChocobo));
} }
if (hasGoobbue) if (hasGoobbue)
subpackets.Add(SetHasGoobbuePacket.BuildPacket(playerActorId, hasGoobbue)); subpackets.Add(SetHasGoobbuePacket.BuildPacket(actorId, hasGoobbue));
subpackets.Add(SetAchievementPointsPacket.BuildPacket(playerActorId, achievementPoints)); subpackets.Add(SetAchievementPointsPacket.BuildPacket(actorId, achievementPoints));
subpackets.Add(Database.GetLatestAchievements(this)); subpackets.Add(Database.GetLatestAchievements(this));
subpackets.Add(Database.GetAchievementsPacket(this)); subpackets.Add(Database.GetAchievementsPacket(this));
} }
@ -347,9 +347,9 @@ namespace FFXIVClassic_Map_Server.Actors
return subpackets; return subpackets;
} }
public override BasePacket GetInitPackets(uint playerActorId) public override List<SubPacket> GetInitPackets()
{ {
ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this, playerActorId); ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this);
propPacketUtil.AddProperty("charaWork.eventSave.bazaarTax"); propPacketUtil.AddProperty("charaWork.eventSave.bazaarTax");
propPacketUtil.AddProperty("charaWork.battleSave.potencial"); propPacketUtil.AddProperty("charaWork.battleSave.potencial");
@ -494,7 +494,7 @@ namespace FFXIVClassic_Map_Server.Actors
propPacketUtil.AddProperty("playerWork.birthdayDay"); propPacketUtil.AddProperty("playerWork.birthdayDay");
propPacketUtil.AddProperty("playerWork.initialTown"); propPacketUtil.AddProperty("playerWork.initialTown");
return BasePacket.CreatePacket(propPacketUtil.Done(), true, false); return propPacketUtil.Done();
} }
public void SendSeamlessZoneInPackets() public void SendSeamlessZoneInPackets()
@ -505,14 +505,14 @@ namespace FFXIVClassic_Map_Server.Actors
public void SendZoneInPackets(WorldManager world, ushort spawnType) public void SendZoneInPackets(WorldManager world, ushort spawnType)
{ {
QueuePacket(SetActorIsZoningPacket.BuildPacket(actorId, actorId, false)); QueuePacket(SetActorIsZoningPacket.BuildPacket(actorId, false));
QueuePacket(_0x10Packet.BuildPacket(actorId, 0xFF)); QueuePacket(_0x10Packet.BuildPacket(actorId, 0xFF));
QueuePacket(SetMusicPacket.BuildPacket(actorId, zone.bgmDay, 0x01)); QueuePacket(SetMusicPacket.BuildPacket(actorId, zone.bgmDay, 0x01));
QueuePacket(SetWeatherPacket.BuildPacket(actorId, SetWeatherPacket.WEATHER_CLEAR, 1)); QueuePacket(SetWeatherPacket.BuildPacket(actorId, SetWeatherPacket.WEATHER_CLEAR, 1));
QueuePacket(SetMapPacket.BuildPacket(actorId, zone.regionId, zone.actorId)); QueuePacket(SetMapPacket.BuildPacket(actorId, zone.regionId, zone.actorId));
QueuePacket(GetSpawnPackets(actorId, spawnType)); QueuePackets(GetSpawnPackets(this, spawnType));
//GetSpawnPackets(actorId, spawnType).DebugPrintPacket(); //GetSpawnPackets(actorId, spawnType).DebugPrintPacket();
#region Inventory & Equipment #region Inventory & Equipment
@ -524,14 +524,14 @@ namespace FFXIVClassic_Map_Server.Actors
inventories[Inventory.MELDREQUEST].SendFullInventory(); inventories[Inventory.MELDREQUEST].SendFullInventory();
inventories[Inventory.LOOT].SendFullInventory(); inventories[Inventory.LOOT].SendFullInventory();
equipment.SendFullEquipment(false); equipment.SendFullEquipment(false);
playerSession.QueuePacket(InventoryEndChangePacket.BuildPacket(actorId), true, false); playerSession.QueuePacket(InventoryEndChangePacket.BuildPacket(actorId));
#endregion #endregion
playerSession.QueuePacket(GetInitPackets(actorId)); playerSession.QueuePacket(GetInitPackets());
BasePacket areaMasterSpawn = zone.GetSpawnPackets(actorId); List<SubPacket> areaMasterSpawn = zone.GetSpawnPackets();
BasePacket debugSpawn = world.GetDebugActor().GetSpawnPackets(actorId); List<SubPacket> debugSpawn = world.GetDebugActor().GetSpawnPackets();
BasePacket worldMasterSpawn = world.GetActor().GetSpawnPackets(actorId); List<SubPacket> worldMasterSpawn = world.GetActor().GetSpawnPackets();
playerSession.QueuePacket(areaMasterSpawn); playerSession.QueuePacket(areaMasterSpawn);
playerSession.QueuePacket(debugSpawn); playerSession.QueuePacket(debugSpawn);
@ -552,16 +552,14 @@ namespace FFXIVClassic_Map_Server.Actors
if (zone.GetWeatherDirector() != null) if (zone.GetWeatherDirector() != null)
{ {
BasePacket weatherDirectorSpawn = zone.GetWeatherDirector().GetSpawnPackets(actorId); playerSession.QueuePacket(zone.GetWeatherDirector().GetSpawnPackets());
playerSession.QueuePacket(weatherDirectorSpawn);
} }
foreach (Director director in ownedDirectors) foreach (Director director in ownedDirectors)
{ {
director.GetSpawnPackets(actorId).DebugPrintPacket(); QueuePackets(director.GetSpawnPackets());
QueuePacket(director.GetSpawnPackets(actorId)); QueuePackets(director.GetInitPackets());
QueuePacket(director.GetInitPackets(actorId));
} }
if (currentContentGroup != null) if (currentContentGroup != null)
@ -596,30 +594,24 @@ namespace FFXIVClassic_Map_Server.Actors
return actorId == otherActorId; return actorId == otherActorId;
} }
public void QueuePacket(BasePacket packet) public void QueuePacket(SubPacket packet)
{ {
playerSession.QueuePacket(packet); playerSession.QueuePacket(packet);
} }
public void QueuePacket(SubPacket packet)
{
playerSession.QueuePacket(packet, true, false);
}
public void QueuePackets(List<SubPacket> packets) public void QueuePackets(List<SubPacket> packets)
{ {
foreach (SubPacket subpacket in packets) playerSession.QueuePacket(packets);
playerSession.QueuePacket(subpacket, true, false);
} }
public void SendPacket(string path) public void SendPacket(string path)
{ {
try try
{ {
BasePacket packet = new BasePacket(path); // BasePacket packet = new BasePacket(path);
packet.ReplaceActorID(actorId); //packet.ReplaceActorID(actorId);
QueuePacket(packet); //QueuePacket(packet);
} }
catch (Exception e) catch (Exception e)
{ {
@ -655,14 +647,14 @@ namespace FFXIVClassic_Map_Server.Actors
{ {
if (flag) if (flag)
{ {
BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, actorId, SetActorIconPacket.DISCONNECTING), true); BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, SetActorIconPacket.DISCONNECTING), true);
} }
else else
{ {
if (isGM) if (isGM)
BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, actorId, SetActorIconPacket.ISGM), true); BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, SetActorIconPacket.ISGM), true);
else else
BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, actorId, 0), true); BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, 0), true);
} }
} }
@ -715,7 +707,7 @@ namespace FFXIVClassic_Map_Server.Actors
public void SendMessage(uint logType, string sender, string message) public void SendMessage(uint logType, string sender, string message)
{ {
QueuePacket(SendMessagePacket.BuildPacket(actorId, actorId, logType, sender, message)); QueuePacket(SendMessagePacket.BuildPacket(actorId, logType, sender, message));
} }
public void Logout() public void Logout()
@ -774,41 +766,41 @@ namespace FFXIVClassic_Map_Server.Actors
public void DoEmote(uint targettedActor, uint animId, uint descId) public void DoEmote(uint targettedActor, uint animId, uint descId)
{ {
BroadcastPacket(ActorDoEmotePacket.BuildPacket(actorId, actorId, targettedActor, animId, descId), true); BroadcastPacket(ActorDoEmotePacket.BuildPacket(actorId, targettedActor, animId, descId), true);
} }
public void SendGameMessage(Actor sourceActor, Actor textIdOwner, ushort textId, byte log, params object[] msgParams) public void SendGameMessage(Actor sourceActor, Actor textIdOwner, ushort textId, byte log, params object[] msgParams)
{ {
if (msgParams == null || msgParams.Length == 0) if (msgParams == null || msgParams.Length == 0)
{ {
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, sourceActor.actorId, textIdOwner.actorId, textId, log)); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, sourceActor.actorId, textIdOwner.actorId, textId, log));
} }
else else
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, sourceActor.actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams))); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, sourceActor.actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams)));
} }
public void SendGameMessage(Actor textIdOwner, ushort textId, byte log, params object[] msgParams) public void SendGameMessage(Actor textIdOwner, ushort textId, byte log, params object[] msgParams)
{ {
if (msgParams == null || msgParams.Length == 0) if (msgParams == null || msgParams.Length == 0)
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, log)); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, log));
else else
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams))); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams)));
} }
public void SendGameMessageCustomSender(Actor textIdOwner, ushort textId, byte log, string customSender, params object[] msgParams) public void SendGameMessageCustomSender(Actor textIdOwner, ushort textId, byte log, string customSender, params object[] msgParams)
{ {
if (msgParams == null || msgParams.Length == 0) if (msgParams == null || msgParams.Length == 0)
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, customSender, log)); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, customSender, log));
else else
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, customSender, log, LuaUtils.CreateLuaParamList(msgParams))); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, customSender, log, LuaUtils.CreateLuaParamList(msgParams)));
} }
public void SendGameMessageDisplayIDSender(Actor textIdOwner, ushort textId, byte log, uint displayId, params object[] msgParams) public void SendGameMessageDisplayIDSender(Actor textIdOwner, ushort textId, byte log, uint displayId, params object[] msgParams)
{ {
if (msgParams == null || msgParams.Length == 0) if (msgParams == null || msgParams.Length == 0)
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, displayId, log)); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, displayId, log));
else else
QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, displayId, log, LuaUtils.CreateLuaParamList(msgParams))); QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, displayId, log, LuaUtils.CreateLuaParamList(msgParams)));
} }
public void BroadcastWorldMessage(ushort worldMasterId, params object[] msgParams) public void BroadcastWorldMessage(ushort worldMasterId, params object[] msgParams)
@ -843,7 +835,7 @@ namespace FFXIVClassic_Map_Server.Actors
public void SendAppearance() public void SendAppearance()
{ {
BroadcastPacket(CreateAppearancePacket(actorId), true); BroadcastPacket(CreateAppearancePacket(), true);
} }
public void SendCharaExpInfo() public void SendCharaExpInfo()
@ -875,7 +867,7 @@ namespace FFXIVClassic_Map_Server.Actors
charaInfo1.AddTarget(); charaInfo1.AddTarget();
QueuePacket(charaInfo1.BuildPacket(actorId, actorId)); QueuePacket(charaInfo1.BuildPacket(actorId));
} }
else if (lastStep == 1) else if (lastStep == 1)
{ {
@ -906,7 +898,7 @@ namespace FFXIVClassic_Map_Server.Actors
charaInfo1.AddTarget(); charaInfo1.AddTarget();
QueuePacket(charaInfo1.BuildPacket(actorId, actorId)); QueuePacket(charaInfo1.BuildPacket(actorId));
} }
} }
@ -963,7 +955,7 @@ namespace FFXIVClassic_Map_Server.Actors
playerWork.restBonusExpRate = 0.0f; playerWork.restBonusExpRate = 0.0f;
ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("charaWork/stateForAll", this, actorId); ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("charaWork/stateForAll", this);
propertyBuilder.AddProperty("charaWork.parameterSave.state_mainSkill[0]"); propertyBuilder.AddProperty("charaWork.parameterSave.state_mainSkill[0]");
propertyBuilder.AddProperty("charaWork.parameterSave.state_mainSkillLevel"); propertyBuilder.AddProperty("charaWork.parameterSave.state_mainSkillLevel");
@ -1007,7 +999,7 @@ namespace FFXIVClassic_Map_Server.Actors
Database.SavePlayerAppearance(this); Database.SavePlayerAppearance(this);
BroadcastPacket(CreateAppearancePacket(actorId), true); BroadcastPacket(CreateAppearancePacket(), true);
} }
public Inventory GetInventory(ushort type) public Inventory GetInventory(ushort type)
@ -1404,7 +1396,7 @@ namespace FFXIVClassic_Map_Server.Actors
Database.SaveNpcLS(this, npcLSId, isCalling, isExtra); Database.SaveNpcLS(this, npcLSId, isCalling, isExtra);
ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/npcLinkshellChat", this, actorId); ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/npcLinkshellChat", this);
propPacketUtil.AddProperty(String.Format("playerWork.npcLinkshellChatExtra[{0}]", npcLSId)); propPacketUtil.AddProperty(String.Format("playerWork.npcLinkshellChatExtra[{0}]", npcLSId));
propPacketUtil.AddProperty(String.Format("playerWork.npcLinkshellChatCalling[{0}]", npcLSId)); propPacketUtil.AddProperty(String.Format("playerWork.npcLinkshellChatCalling[{0}]", npcLSId));
QueuePackets(propPacketUtil.Done()); QueuePackets(propPacketUtil.Done());
@ -1412,21 +1404,21 @@ namespace FFXIVClassic_Map_Server.Actors
private void SendQuestClientUpdate(int slot) private void SendQuestClientUpdate(int slot)
{ {
ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/journal", this, actorId); ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/journal", this);
propPacketUtil.AddProperty(String.Format("playerWork.questScenario[{0}]", slot)); propPacketUtil.AddProperty(String.Format("playerWork.questScenario[{0}]", slot));
QueuePackets(propPacketUtil.Done()); QueuePackets(propPacketUtil.Done());
} }
private void SendGuildleveClientUpdate(int slot) private void SendGuildleveClientUpdate(int slot)
{ {
ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("work/guildleve", this, actorId); ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("work/guildleve", this);
propPacketUtil.AddProperty(String.Format("work.guildleveId[{0}]", slot)); propPacketUtil.AddProperty(String.Format("work.guildleveId[{0}]", slot));
QueuePackets(propPacketUtil.Done()); QueuePackets(propPacketUtil.Done());
} }
private void SendGuildleveMarkClientUpdate(int slot) private void SendGuildleveMarkClientUpdate(int slot)
{ {
ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("work/guildleve", this, actorId); ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("work/guildleve", this);
propPacketUtil.AddProperty(String.Format("work.guildleveDone[{0}]", slot)); propPacketUtil.AddProperty(String.Format("work.guildleveDone[{0}]", slot));
propPacketUtil.AddProperty(String.Format("work.guildleveChecked[{0}]", slot)); propPacketUtil.AddProperty(String.Format("work.guildleveChecked[{0}]", slot));
QueuePackets(propPacketUtil.Done()); QueuePackets(propPacketUtil.Done());
@ -1449,16 +1441,15 @@ namespace FFXIVClassic_Map_Server.Actors
public void SendDirectorPackets(Director director) public void SendDirectorPackets(Director director)
{ {
director.GetSpawnPackets(actorId).DebugPrintPacket(); QueuePackets(director.GetSpawnPackets());
QueuePacket(director.GetSpawnPackets(actorId)); QueuePackets(director.GetInitPackets());
QueuePacket(director.GetInitPackets(actorId));
} }
public void RemoveDirector(Director director) public void RemoveDirector(Director director)
{ {
if (ownedDirectors.Contains(director)) if (ownedDirectors.Contains(director))
{ {
QueuePacket(RemoveActorPacket.BuildPacket(actorId, director.actorId)); QueuePacket(RemoveActorPacket.BuildPacket(director.actorId));
ownedDirectors.Remove(director); ownedDirectors.Remove(director);
director.RemoveMember(this); director.RemoveMember(this);
} }
@ -1505,15 +1496,15 @@ namespace FFXIVClassic_Map_Server.Actors
else else
return; return;
QueuePacket(InventoryBeginChangePacket.BuildPacket(toBeExamined.actorId, actorId)); QueuePacket(InventoryBeginChangePacket.BuildPacket(toBeExamined.actorId));
toBeExamined.GetEquipment().SendCheckEquipmentToPlayer(this); toBeExamined.GetEquipment().SendCheckEquipmentToPlayer(this);
QueuePacket(InventoryEndChangePacket.BuildPacket(toBeExamined.actorId, actorId)); QueuePacket(InventoryEndChangePacket.BuildPacket(toBeExamined.actorId));
} }
public void SendDataPacket(params object[] parameters) public void SendDataPacket(params object[] parameters)
{ {
List<LuaParam> lParams = LuaUtils.CreateLuaParamList(parameters); List<LuaParam> lParams = LuaUtils.CreateLuaParamList(parameters);
SubPacket spacket = InfoRequestResponsePacket.BuildPacket(actorId, actorId, lParams); SubPacket spacket = InfoRequestResponsePacket.BuildPacket(actorId, lParams);
spacket.DebugPrintSubPacket(); spacket.DebugPrintSubPacket();
QueuePacket(spacket); QueuePacket(spacket);
} }
@ -1541,7 +1532,7 @@ namespace FFXIVClassic_Map_Server.Actors
public void SetEventStatus(Actor actor, string conditionName, bool enabled, byte unknown) public void SetEventStatus(Actor actor, string conditionName, bool enabled, byte unknown)
{ {
QueuePacket(packets.send.actor.events.SetEventStatus.BuildPacket(actorId, actor.actorId, enabled, unknown, conditionName)); QueuePacket(packets.send.actor.events.SetEventStatus.BuildPacket(actor.actorId, enabled, unknown, conditionName));
} }
public void RunEventFunction(string functionName, params object[] parameters) public void RunEventFunction(string functionName, params object[] parameters)

22
FFXIVClassic Map Server/actors/debug/Debug.cs
View File

@ -18,24 +18,24 @@ namespace FFXIVClassic_Map_Server.Actors
this.className = "Debug"; this.className = "Debug";
} }
public override SubPacket CreateScriptBindPacket(uint playerActorId) public override SubPacket CreateScriptBindPacket()
{ {
List<LuaParam> lParams; List<LuaParam> lParams;
lParams = LuaUtils.CreateLuaParamList("/System/Debug.prog", false, false, false, false, true, 0xC51F, true, true); lParams = LuaUtils.CreateLuaParamList("/System/Debug.prog", false, false, false, false, true, 0xC51F, true, true);
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
} }
public override BasePacket GetSpawnPackets(uint playerActorId) public override List<SubPacket> GetSpawnPackets()
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(playerActorId, 0)); subpackets.Add(CreateAddActorPacket(0));
subpackets.Add(CreateSpeedPacket(playerActorId)); subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x1)); subpackets.Add(CreateSpawnPositonPacket(0x1));
subpackets.Add(CreateNamePacket(playerActorId)); subpackets.Add(CreateNamePacket());
subpackets.Add(CreateStatePacket(playerActorId)); subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIsZoneingPacket(playerActorId)); subpackets.Add(CreateIsZoneingPacket());
subpackets.Add(CreateScriptBindPacket(playerActorId)); subpackets.Add(CreateScriptBindPacket());
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
} }

37
FFXIVClassic Map Server/actors/director/Director.cs
View File

@ -40,7 +40,7 @@ namespace FFXIVClassic_Map_Server.actors.director
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>(); List<LuaParam> actualLParams = new List<LuaParam>();
actualLParams.Insert(0, new LuaParam(2, classPath)); actualLParams.Insert(0, new LuaParam(2, classPath));
@ -54,28 +54,30 @@ namespace FFXIVClassic_Map_Server.actors.director
for (int i = 1; i < lparams.Count; i++) for (int i = 1; i < lparams.Count; i++)
actualLParams.Add(lparams[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>(); List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(playerActorId, 0)); subpackets.Add(CreateAddActorPacket(0));
subpackets.AddRange(GetEventConditionPackets(playerActorId)); subpackets.AddRange(GetEventConditionPackets());
subpackets.Add(CreateSpeedPacket(playerActorId)); subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0)); subpackets.Add(CreateSpawnPositonPacket(0));
subpackets.Add(CreateNamePacket(playerActorId)); subpackets.Add(CreateNamePacket());
subpackets.Add(CreateStatePacket(playerActorId)); subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIsZoneingPacket(playerActorId)); subpackets.Add(CreateIsZoneingPacket());
subpackets.Add(CreateScriptBindPacket(playerActorId)); subpackets.Add(CreateScriptBindPacket());
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
public override BasePacket GetInitPackets(uint playerActorId) public override List<SubPacket> GetInitPackets()
{ {
List<SubPacket> subpackets = new List<SubPacket>();
SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init"); SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init");
initProperties.AddTarget(); 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) public void OnTalkEvent(Player player, Npc npc)
@ -108,9 +110,8 @@ namespace FFXIVClassic_Map_Server.actors.director
{ {
foreach (Player p in GetPlayerMembers()) foreach (Player p in GetPlayerMembers())
{ {
GetSpawnPackets(p.actorId).DebugPrintPacket(); p.QueuePackets(GetSpawnPackets());
p.QueuePacket(GetSpawnPackets(p.actorId)); p.QueuePackets(GetInitPackets());
p.QueuePacket(GetInitPackets(p.actorId));
} }
} }

12
FFXIVClassic Map Server/actors/director/GuildleveDirector.cs
View File

@ -79,7 +79,7 @@ namespace FFXIVClassic_Map_Server.actors.director
} }
guildleveWork.startTime = Utils.UnixTimeStampUTC(); guildleveWork.startTime = Utils.UnixTimeStampUTC();
ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/start", this, actorId); ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/start", this);
propertyBuilder.AddProperty("guildleveWork.startTime"); propertyBuilder.AddProperty("guildleveWork.startTime");
SendPacketsToPlayers(propertyBuilder.Done()); SendPacketsToPlayers(propertyBuilder.Done());
} }
@ -114,7 +114,7 @@ namespace FFXIVClassic_Map_Server.actors.director
guildleveWork.startTime = 0; guildleveWork.startTime = 0;
guildleveWork.signal = -1; guildleveWork.signal = -1;
ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/signal", this, actorId); ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/signal", this);
propertyBuilder.AddProperty("guildleveWork.signal"); propertyBuilder.AddProperty("guildleveWork.signal");
propertyBuilder.NewTarget("guildleveWork/start"); propertyBuilder.NewTarget("guildleveWork/start");
propertyBuilder.AddProperty("guildleveWork.startTime"); propertyBuilder.AddProperty("guildleveWork.startTime");
@ -160,7 +160,7 @@ namespace FFXIVClassic_Map_Server.actors.director
public void SyncAllInfo() public void SyncAllInfo()
{ {
ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this, actorId); ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
if (guildleveWork.aimNum[0] != 0) if (guildleveWork.aimNum[0] != 0)
propertyBuilder.AddProperty("guildleveWork.aimNum[0]"); propertyBuilder.AddProperty("guildleveWork.aimNum[0]");
@ -195,7 +195,7 @@ namespace FFXIVClassic_Map_Server.actors.director
public void UpdateAimNumNow(int index, sbyte value) public void UpdateAimNumNow(int index, sbyte value)
{ {
guildleveWork.aimNumNow[index] = value; guildleveWork.aimNumNow[index] = value;
ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this, actorId); ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
propertyBuilder.AddProperty(String.Format("guildleveWork.aimNumNow[{0}]", index)); propertyBuilder.AddProperty(String.Format("guildleveWork.aimNumNow[{0}]", index));
SendPacketsToPlayers(propertyBuilder.Done()); SendPacketsToPlayers(propertyBuilder.Done());
} }
@ -203,7 +203,7 @@ namespace FFXIVClassic_Map_Server.actors.director
public void UpdateUiState(int index, sbyte value) public void UpdateUiState(int index, sbyte value)
{ {
guildleveWork.uiState[index] = value; guildleveWork.uiState[index] = value;
ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this, actorId); ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
propertyBuilder.AddProperty(String.Format("guildleveWork.uiState[{0}]", index)); propertyBuilder.AddProperty(String.Format("guildleveWork.uiState[{0}]", index));
SendPacketsToPlayers(propertyBuilder.Done()); SendPacketsToPlayers(propertyBuilder.Done());
} }
@ -213,7 +213,7 @@ namespace FFXIVClassic_Map_Server.actors.director
guildleveWork.markerX[markerIndex] = x; guildleveWork.markerX[markerIndex] = x;
guildleveWork.markerY[markerIndex] = y; guildleveWork.markerY[markerIndex] = y;
guildleveWork.markerZ[markerIndex] = z; guildleveWork.markerZ[markerIndex] = z;
ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/marker", this, actorId); ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/marker", this);
propertyBuilder.AddProperty(String.Format("guildleveWork.markerX[{0}]", markerIndex)); propertyBuilder.AddProperty(String.Format("guildleveWork.markerX[{0}]", markerIndex));
propertyBuilder.AddProperty(String.Format("guildleveWork.markerY[{0}]", markerIndex)); propertyBuilder.AddProperty(String.Format("guildleveWork.markerY[{0}]", markerIndex));
propertyBuilder.AddProperty(String.Format("guildleveWork.markerZ[{0}]", markerIndex)); propertyBuilder.AddProperty(String.Format("guildleveWork.markerZ[{0}]", markerIndex));

16
FFXIVClassic Map Server/actors/group/ContentGroup.cs
View File

@ -84,7 +84,7 @@ namespace FFXIVClassic_Map_Server.actors.group
SubPacket test = groupWork.buildPacket(session.id, session.id); SubPacket test = groupWork.buildPacket(session.id, session.id);
test.DebugPrintSubPacket(); test.DebugPrintSubPacket();
session.QueuePacket(test, true, false); session.QueuePacket(test);
} }
public override void SendGroupPackets(Session session) public override void SendGroupPackets(Session session)
@ -92,26 +92,26 @@ namespace FFXIVClassic_Map_Server.actors.group
ulong time = Utils.MilisUnixTimeStampUTC(); ulong time = Utils.MilisUnixTimeStampUTC();
List<GroupMember> members = BuildMemberList(session.id); List<GroupMember> members = BuildMemberList(session.id);
session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false); session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false); session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
int currentIndex = 0; int currentIndex = 0;
while (true) while (true)
{ {
if (GetMemberCount() - currentIndex >= 64) if (GetMemberCount() - currentIndex >= 64)
session.QueuePacket(ContentMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(ContentMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else if (GetMemberCount() - currentIndex >= 32) else if (GetMemberCount() - currentIndex >= 32)
session.QueuePacket(ContentMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(ContentMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else if (GetMemberCount() - currentIndex >= 16) else if (GetMemberCount() - currentIndex >= 16)
session.QueuePacket(ContentMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(ContentMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else if (GetMemberCount() - currentIndex > 0) else if (GetMemberCount() - currentIndex > 0)
session.QueuePacket(ContentMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(ContentMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else else
break; break;
} }
session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false); session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
} }

16
FFXIVClassic Map Server/actors/group/Group.cs
View File

@ -120,33 +120,33 @@ namespace FFXIVClassic_Map_Server.actors.group
ulong time = Utils.MilisUnixTimeStampUTC(); ulong time = Utils.MilisUnixTimeStampUTC();
List<GroupMember> members = BuildMemberList(session.id); List<GroupMember> members = BuildMemberList(session.id);
session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false); session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false); session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
int currentIndex = 0; int currentIndex = 0;
while (true) while (true)
{ {
if (GetMemberCount() - currentIndex >= 64) if (GetMemberCount() - currentIndex >= 64)
session.QueuePacket(GroupMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(GroupMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else if (GetMemberCount() - currentIndex >= 32) else if (GetMemberCount() - currentIndex >= 32)
session.QueuePacket(GroupMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(GroupMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else if (GetMemberCount() - currentIndex >= 16) else if (GetMemberCount() - currentIndex >= 16)
session.QueuePacket(GroupMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(GroupMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else if (GetMemberCount() - currentIndex > 0) else if (GetMemberCount() - currentIndex > 0)
session.QueuePacket(GroupMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false); session.QueuePacket(GroupMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
else else
break; break;
} }
session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false); session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
} }
public void SendDeletePacket(Session session) public void SendDeletePacket(Session session)
{ {
if (session != null) if (session != null)
session.QueuePacket(DeleteGroupPacket.buildPacket(session.id, this), true, false); session.QueuePacket(DeleteGroupPacket.buildPacket(session.id, this));
} }
public virtual void SendInitWorkValues(Session session) public virtual void SendInitWorkValues(Session session)

2
FFXIVClassic Map Server/actors/group/MonsterParty.cs
View File

@ -51,7 +51,7 @@ namespace FFXIVClassic_Map_Server.actors.group
groupWork.setTarget("/_init"); groupWork.setTarget("/_init");
SubPacket test = groupWork.buildPacket(session.id, session.id); SubPacket test = groupWork.buildPacket(session.id, session.id);
session.QueuePacket(test, true, false); session.QueuePacket(test);
} }
public override uint GetTypeId() public override uint GetTypeId()

2
FFXIVClassic Map Server/actors/group/Relation.cs
View File

@ -70,7 +70,7 @@ namespace FFXIVClassic_Map_Server.actors.group
SubPacket test = groupWork.buildPacket(session.id, session.id); SubPacket test = groupWork.buildPacket(session.id, session.id);
test.DebugPrintSubPacket(); test.DebugPrintSubPacket();
session.QueuePacket(test, true, false); session.QueuePacket(test);
} }
} }

22
FFXIVClassic Map Server/actors/world/WorldMaster.cs
View File

@ -17,24 +17,24 @@ namespace FFXIVClassic_Map_Server.Actors
this.className = "WorldMaster"; this.className = "WorldMaster";
} }
public override SubPacket CreateScriptBindPacket(uint playerActorId) public override SubPacket CreateScriptBindPacket()
{ {
List<LuaParam> lParams; List<LuaParam> lParams;
lParams = LuaUtils.CreateLuaParamList("/World/WorldMaster_event", false, false, false, false, false, null); lParams = LuaUtils.CreateLuaParamList("/World/WorldMaster_event", false, false, false, false, false, null);
return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams); return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
} }
public override BasePacket GetSpawnPackets(uint playerActorId) public override List<SubPacket> GetSpawnPackets()
{ {
List<SubPacket> subpackets = new List<SubPacket>(); List<SubPacket> subpackets = new List<SubPacket>();
subpackets.Add(CreateAddActorPacket(playerActorId, 0)); subpackets.Add(CreateAddActorPacket(0));
subpackets.Add(CreateSpeedPacket(playerActorId)); subpackets.Add(CreateSpeedPacket());
subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x1)); subpackets.Add(CreateSpawnPositonPacket(0x1));
subpackets.Add(CreateNamePacket(playerActorId)); subpackets.Add(CreateNamePacket());
subpackets.Add(CreateStatePacket(playerActorId)); subpackets.Add(CreateStatePacket());
subpackets.Add(CreateIsZoneingPacket(playerActorId)); subpackets.Add(CreateIsZoneingPacket());
subpackets.Add(CreateScriptBindPacket(playerActorId)); subpackets.Add(CreateScriptBindPacket());
return BasePacket.CreatePacket(subpackets, true, false); return subpackets;
} }
} }
} }

28
FFXIVClassic Map Server/dataobjects/Session.cs
View File

@ -31,15 +31,16 @@ namespace FFXIVClassic_Map_Server.dataobjects
actorInstanceList.Add(playerActor); actorInstanceList.Add(playerActor);
} }
public void QueuePacket(BasePacket basePacket) public void QueuePacket(List<SubPacket> packets)
{ {
Server.GetWorldConnection().QueuePacket(basePacket); foreach (SubPacket s in packets)
QueuePacket(s);
} }
public void QueuePacket(SubPacket subPacket, bool isAuthed, bool isEncrypted) public void QueuePacket(SubPacket subPacket)
{ {
subPacket.header.targetId = id; subPacket.SetTargetId(id);
Server.GetWorldConnection().QueuePacket(subPacket, isAuthed, isEncrypted); Server.GetWorldConnection().QueuePacket(subPacket);
} }
public Player GetActor() public Player GetActor()
@ -80,7 +81,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
playerActor.rotation = rot; playerActor.rotation = rot;
playerActor.moveState = moveState; playerActor.moveState = moveState;
GetActor().zone.UpdateActorPosition(GetActor()); GetActor().GetZone().UpdateActorPosition(GetActor());
} }
long lastMilis = 0; long lastMilis = 0;
@ -107,7 +108,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
if (npc.GetUniqueId().Equals("1") && milliseconds - lastMilis > 1000) if (npc.GetUniqueId().Equals("1") && milliseconds - lastMilis > 1000)
{ {
lastMilis = milliseconds; lastMilis = milliseconds;
GetActor().QueuePacket(RemoveActorPacket.BuildPacket(playerActor.actorId, actorInstanceList[i].actorId)); QueuePacket(RemoveActorPacket.BuildPacket(actorInstanceList[i].actorId));
actorInstanceList.RemoveAt(i); actorInstanceList.RemoveAt(i);
continue; continue;
} }
@ -115,7 +116,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
if (!list.Contains(actorInstanceList[i])) if (!list.Contains(actorInstanceList[i]))
{ {
GetActor().QueuePacket(RemoveActorPacket.BuildPacket(playerActor.actorId, actorInstanceList[i].actorId)); QueuePacket(RemoveActorPacket.BuildPacket(actorInstanceList[i].actorId));
actorInstanceList.RemoveAt(i); actorInstanceList.RemoveAt(i);
} }
@ -135,13 +136,14 @@ namespace FFXIVClassic_Map_Server.dataobjects
if (actor is Character && ((Character)actor).isStatic) if (actor is Character && ((Character)actor).isStatic)
continue; continue;
GetActor().QueuePacket(actor.CreatePositionUpdatePacket(playerActor.actorId)); QueuePacket(actor.CreatePositionUpdatePacket());
} }
else else
{ {
GetActor().QueuePacket(actor.GetSpawnPackets(playerActor.actorId, 1)); QueuePacket(actor.GetSpawnPackets(playerActor, 1));
GetActor().QueuePacket(actor.GetInitPackets(playerActor.actorId));
GetActor().QueuePacket(actor.GetSetEventStatusPackets(playerActor.actorId)); QueuePacket(actor.GetInitPackets());
QueuePacket(actor.GetSetEventStatusPackets());
actorInstanceList.Add(actor); actorInstanceList.Add(actor);
if (actor is Npc) if (actor is Npc)

11
FFXIVClassic Map Server/dataobjects/ZoneConnection.cs
View File

@ -17,14 +17,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
private BlockingCollection<SubPacket> SendPacketQueue = new BlockingCollection<SubPacket>(1000); private BlockingCollection<SubPacket> SendPacketQueue = new BlockingCollection<SubPacket>(1000);
public int lastPartialSize = 0; public int lastPartialSize = 0;
public void QueuePacket(BasePacket packet) public void QueuePacket(SubPacket subpacket)
{
List<SubPacket> subPackets = packet.GetSubpackets();
foreach (SubPacket s in subPackets)
SendPacketQueue.Add(s);
}
public void QueuePacket(SubPacket subpacket, bool isAuthed, bool isEncrypted)
{ {
SendPacketQueue.Add(subpacket); SendPacketQueue.Add(subpacket);
} }
@ -68,7 +61,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
public void RequestZoneChange(uint sessionId, uint destinationZoneId, byte spawnType, float spawnX, float spawnY, float spawnZ, float spawnRotation) public void RequestZoneChange(uint sessionId, uint destinationZoneId, byte spawnType, float spawnX, float spawnY, float spawnZ, float spawnRotation)
{ {
WorldRequestZoneChangePacket.BuildPacket(sessionId, destinationZoneId, spawnType, spawnX, spawnY, spawnZ, spawnRotation).DebugPrintSubPacket(); WorldRequestZoneChangePacket.BuildPacket(sessionId, destinationZoneId, spawnType, spawnX, spawnY, spawnZ, spawnRotation).DebugPrintSubPacket();
QueuePacket(WorldRequestZoneChangePacket.BuildPacket(sessionId, destinationZoneId, spawnType, spawnX, spawnY, spawnZ, spawnRotation), true, false); QueuePacket(WorldRequestZoneChangePacket.BuildPacket(sessionId, destinationZoneId, spawnType, spawnX, spawnY, spawnZ, spawnRotation));
} }
} }
} }

3
FFXIVClassic Map Server/lua/LuaEngine.cs
View File

@ -605,9 +605,8 @@ namespace FFXIVClassic_Map_Server.lua
if (player == null) if (player == null)
return; return;
List<SubPacket> SendError = new List<SubPacket>(); List<SubPacket> SendError = new List<SubPacket>();
SendError.Add(EndEventPacket.BuildPacket(player.actorId, player.currentEventOwner, player.currentEventName));
player.SendMessage(SendMessagePacket.MESSAGE_TYPE_SYSTEM_ERROR, "", message); player.SendMessage(SendMessagePacket.MESSAGE_TYPE_SYSTEM_ERROR, "", message);
player.playerSession.QueuePacket(BasePacket.CreatePacket(SendError, true, false)); player.QueuePacket(EndEventPacket.BuildPacket(player.actorId, player.currentEventOwner, player.currentEventName));
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/CreateLinkshellPacket.cs
View File

@ -24,7 +24,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write((UInt32)master); binWriter.Write((UInt32)master);
} }
} }
return new SubPacket(true, OPCODE, 0, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/DeleteLinkshellPacket.cs
View File

@ -21,7 +21,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name)); binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name));
} }
} }
return new SubPacket(true, OPCODE, 0, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/GroupInviteResultPacket.cs
View File

@ -25,7 +25,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write((UInt32)result); binWriter.Write((UInt32)result);
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellChangePacket.cs
View File

@ -23,7 +23,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write(Encoding.ASCII.GetBytes(lsName), 0, Encoding.ASCII.GetByteCount(lsName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(lsName)); binWriter.Write(Encoding.ASCII.GetBytes(lsName), 0, Encoding.ASCII.GetByteCount(lsName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(lsName));
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellInviteCancelPacket.cs
View File

@ -17,7 +17,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
public static SubPacket BuildPacket(Session session) public static SubPacket BuildPacket(Session session)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellInvitePacket.cs
View File

@ -25,7 +25,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write(Encoding.ASCII.GetBytes(linkshellName), 0, Encoding.ASCII.GetByteCount(linkshellName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(linkshellName)); binWriter.Write(Encoding.ASCII.GetBytes(linkshellName), 0, Encoding.ASCII.GetByteCount(linkshellName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(linkshellName));
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellLeavePacket.cs
View File

@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write(Encoding.ASCII.GetBytes(lsName), 0, Encoding.ASCII.GetByteCount(lsName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(lsName)); binWriter.Write(Encoding.ASCII.GetBytes(lsName), 0, Encoding.ASCII.GetByteCount(lsName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(lsName));
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellRankChangePacket.cs
View File

@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write((Byte)rank); binWriter.Write((Byte)rank);
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/ModifyLinkshellPacket.cs
View File

@ -35,7 +35,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
} }
} }
return new SubPacket(true, OPCODE, 0, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/PartyInvitePacket.cs
View File

@ -25,7 +25,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name)); binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name));
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
public static SubPacket BuildPacket(Session session, uint actorId) public static SubPacket BuildPacket(Session session, uint actorId)
@ -39,7 +39,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write((UInt32)actorId); binWriter.Write((UInt32)actorId);
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/PartyLeavePacket.cs
View File

@ -23,7 +23,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write((UInt16)(isDisband ? 1 : 0)); binWriter.Write((UInt16)(isDisband ? 1 : 0));
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }

4
FFXIVClassic Map Server/packets/WorldPackets/Send/Group/PartyModifyPacket.cs
View File

@ -24,7 +24,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name)); binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name));
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
public static SubPacket BuildPacket(Session session, ushort command, uint actorId) public static SubPacket BuildPacket(Session session, ushort command, uint actorId)
@ -38,7 +38,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
binWriter.Write((UInt32)actorId); binWriter.Write((UInt32)actorId);
} }
} }
return new SubPacket(true, OPCODE, session.id, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/SessionBeginConfirmPacket.cs
View File

@ -21,7 +21,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send
binWriter.Write((UInt16)errorCode); binWriter.Write((UInt16)errorCode);
} }
} }
return new SubPacket(true, OPCODE, 0, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/SessionEndConfirmPacket.cs
View File

@ -22,7 +22,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send
binWriter.Write((UInt32)destinationZone); binWriter.Write((UInt32)destinationZone);
} }
} }
return new SubPacket(true, OPCODE, 0, session.id, data); return new SubPacket(true, OPCODE, session.id, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/WorldPackets/Send/WorldRequestZoneChangePacket.cs
View File

@ -31,7 +31,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send
} }
} }
return new SubPacket(OPCODE, sessionId, sessionId, data); return new SubPacket(OPCODE, sessionId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/ActorDoEmotePacket.cs
View File

@ -10,7 +10,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00E1; public const ushort OPCODE = 0x00E1;
public const uint PACKET_SIZE = 0x30; public const uint PACKET_SIZE = 0x30;
public static SubPacket BuildPacket(uint sourceActorId, uint targetActorId, uint targettedActorId, uint animationId, uint descriptionId) public static SubPacket BuildPacket(uint sourceActorId, uint targettedActorId, uint animationId, uint descriptionId)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -32,7 +32,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
SubPacket packet = new SubPacket(OPCODE, sourceActorId, targetActorId, data); SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
packet.DebugPrintSubPacket(); packet.DebugPrintSubPacket();
return packet; return packet;
} }

4
FFXIVClassic Map Server/packets/send/Actor/ActorInstantiatePacket.cs
View File

@ -13,7 +13,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00CC; public const ushort OPCODE = 0x00CC;
public const uint PACKET_SIZE = 0x128; public const uint PACKET_SIZE = 0x128;
public static SubPacket BuildPacket(uint sourceActorID, uint targetActorID, string objectName, string className, List<LuaParam> initParams) public static SubPacket BuildPacket(uint sourceActorId, string objectName, string className, List<LuaParam> initParams)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -33,7 +33,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, sourceActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/ActorSpecialGraphicPacket.cs
View File

@ -15,7 +15,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00E3; public const ushort OPCODE = 0x00E3;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, int iconCode) public static SubPacket BuildPacket(uint sourceActorId, int iconCode)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, targetActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/AddActorPacket.cs
View File

@ -9,12 +9,12 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00CA; public const ushort OPCODE = 0x00CA;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint actorID, byte val) public static SubPacket BuildPacket(uint sourceActorId, byte val)
{ {
byte[] data = new byte[PACKET_SIZE-0x20]; byte[] data = new byte[PACKET_SIZE-0x20];
data[0] = val; //Why? data[0] = val; //Why?
return new SubPacket(OPCODE, playerActorID, actorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

27
FFXIVClassic Map Server/packets/send/Actor/BattleAction1Packet.cs
View File

@ -1,27 +0,0 @@
using FFXIVClassic.Common;
using System.IO;
using FFXIVClassic.Common;
namespace FFXIVClassic_Map_Server.packets.send.actor
{
class BattleAction1Packet
{
public const ushort OPCODE = 0x0139;
public const uint PACKET_SIZE = 0x58;
public static SubPacket BuildPacket(uint sourceId, uint targetId)
{
byte[] data = new byte[PACKET_SIZE - 0x20];
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
}
}
return new SubPacket(OPCODE, sourceId, targetId, data);
}
}
}

4
FFXIVClassic Map Server/packets/send/Actor/DeleteAllActorsPacket.cs
View File

@ -9,9 +9,9 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x0007; public const ushort OPCODE = 0x0007;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID) public static SubPacket BuildPacket(uint sourceActorId)
{ {
return new SubPacket(OPCODE, playerActorID, playerActorID, new byte[8]); return new SubPacket(OPCODE, sourceActorId, new byte[8]);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/MoveActorToPositionPacket.cs
View File

@ -10,7 +10,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00CF; public const ushort OPCODE = 0x00CF;
public const uint PACKET_SIZE = 0x50; public const uint PACKET_SIZE = 0x50;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, float x, float y, float z, float rot, ushort moveState) public static SubPacket BuildPacket(uint sourceActorId, float x, float y, float z, float rot, ushort moveState)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
SubPacket packet = new SubPacket(OPCODE, playerActorID, targetActorID, data); SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
return packet; return packet;
} }

4
FFXIVClassic Map Server/packets/send/Actor/PlayAnimationOnActorPacket.cs
View File

@ -12,9 +12,9 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00DA; public const ushort OPCODE = 0x00DA;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint animationID) public static SubPacket BuildPacket(uint sourceActorId, uint animationID)
{ {
return new SubPacket(OPCODE, playerActorID, targetActorID, BitConverter.GetBytes((ulong)animationID)); return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes((ulong)animationID));
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/PlayBGAnimation.cs
View File

@ -12,7 +12,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00D9; public const ushort OPCODE = 0x00D9;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, string animName) public static SubPacket BuildPacket(uint sourceActorId, string animName)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -24,7 +24,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

6
FFXIVClassic Map Server/packets/send/Actor/RemoveActorPacket.cs
View File

@ -10,7 +10,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00CB; public const ushort OPCODE = 0x00CB;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint actorId) public static SubPacket BuildPacket(uint sourceActorId)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -18,11 +18,11 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
{ {
using (BinaryWriter binWriter = new BinaryWriter(mem)) using (BinaryWriter binWriter = new BinaryWriter(mem))
{ {
binWriter.Write((UInt32)actorId); binWriter.Write((UInt32)sourceActorId);
} }
} }
return new SubPacket(OPCODE, actorId, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorAppearancePacket.cs
View File

@ -53,7 +53,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
appearanceIDs = appearanceTable; appearanceIDs = appearanceTable;
} }
public SubPacket BuildPacket(uint playerActorID, uint actorID) public SubPacket BuildPacket(uint sourceActorId)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -74,7 +74,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
SubPacket packet = new SubPacket(OPCODE, playerActorID, actorID, data); SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
return packet; return packet;
} }

6
FFXIVClassic Map Server/packets/send/Actor/_0xD8Packet.cs → FFXIVClassic Map Server/packets/send/Actor/SetActorBGPropertiesPacket.cs
View File

@ -5,12 +5,12 @@ using System;
namespace FFXIVClassic_Map_Server.packets.send.actor namespace FFXIVClassic_Map_Server.packets.send.actor
{ {
class _0xD8Packet class SetActorBGPropertiesPacket
{ {
public const ushort OPCODE = 0x00D8; public const ushort OPCODE = 0x00D8;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint val1, uint val2) public static SubPacket BuildPacket(uint sourceActorId, uint val1, uint val2)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -23,7 +23,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorIconPacket.cs
View File

@ -14,7 +14,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x0145; public const ushort OPCODE = 0x0145;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint iconCode) public static SubPacket BuildPacket(uint sourceActorId, uint iconCode)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -26,7 +26,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorIsZoningPacket.cs
View File

@ -7,11 +7,11 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x017B; public const ushort OPCODE = 0x017B;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, bool isDimmed) public static SubPacket BuildPacket(uint sourceActorId, bool isDimmed)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
data[0] = (byte)(isDimmed ? 1 : 0); data[0] = (byte)(isDimmed ? 1 : 0);
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorNamePacket.cs
View File

@ -11,7 +11,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x013D; public const ushort OPCODE = 0x013D;
public const uint PACKET_SIZE = 0x48; public const uint PACKET_SIZE = 0x48;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint displayNameID, string customName) public static SubPacket BuildPacket(uint sourceActorId, uint displayNameID, string customName)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -29,7 +29,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
SubPacket packet = new SubPacket(OPCODE, playerActorID, targetActorID, data); SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
return packet; return packet;
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorPositionPacket.cs
View File

@ -19,7 +19,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort SPAWNTYPE_WARP_DUTY2 = 6; public const ushort SPAWNTYPE_WARP_DUTY2 = 6;
public const ushort SPAWNTYPE_WARP_LIGHT = 7; public const ushort SPAWNTYPE_WARP_LIGHT = 7;
public static SubPacket BuildPacket(uint sourceActorID, uint targetActorID, uint actorId, float x, float y, float z, float rotation, ushort spawnType, bool isZoningPlayer) public static SubPacket BuildPacket(uint sourceActorId, uint actorId, float x, float y, float z, float rotation, ushort spawnType, bool isZoningPlayer)
{ {
byte[] data = new byte[PACKET_SIZE-0x20]; byte[] data = new byte[PACKET_SIZE-0x20];
@ -41,7 +41,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, sourceActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorPropetyPacket.cs
View File

@ -209,14 +209,14 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
currentTarget = newTarget; currentTarget = newTarget;
} }
public SubPacket BuildPacket(uint playerActorID, uint actorID) public SubPacket BuildPacket(uint sourceActorId)
{ {
binWriter.Seek(0, SeekOrigin.Begin); binWriter.Seek(0, SeekOrigin.Begin);
binWriter.Write((byte)runningByteTotal); binWriter.Write((byte)runningByteTotal);
CloseStreams(); CloseStreams();
SubPacket packet = new SubPacket(OPCODE, actorID, playerActorID, data); SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
return packet; return packet;
} }

8
FFXIVClassic Map Server/packets/send/Actor/SetActorSpeedPacket.cs
View File

@ -14,7 +14,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const float DEFAULT_RUN = 5.0f; public const float DEFAULT_RUN = 5.0f;
public const float DEFAULT_ACTIVE = 5.0f; public const float DEFAULT_ACTIVE = 5.0f;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID) public static SubPacket BuildPacket(uint sourceActorId)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -40,10 +40,10 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, float stopSpeed, float walkSpeed, float runSpeed, float activeSpeed) public static SubPacket BuildPacket(uint sourceActorId, float stopSpeed, float walkSpeed, float runSpeed, float activeSpeed)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -69,7 +69,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorStatePacket.cs
View File

@ -30,10 +30,10 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x134; public const ushort OPCODE = 0x134;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetID, uint mainState, uint subState) public static SubPacket BuildPacket(uint sourceActorId, uint mainState, uint subState)
{ {
ulong combined = (mainState & 0xFF) | ((subState & 0xFF) << 8); ulong combined = (mainState & 0xFF) | ((subState & 0xFF) << 8);
return new SubPacket(OPCODE, playerActorID, targetID, BitConverter.GetBytes(combined)); return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes(combined));
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorStatusAllPacket.cs
View File

@ -11,7 +11,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x0179; public const ushort OPCODE = 0x0179;
public const uint PACKET_SIZE = 0x48; public const uint PACKET_SIZE = 0x48;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, ushort[] statusIds) public static SubPacket BuildPacket(uint sourceActorId, ushort[] statusIds)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -28,7 +28,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
SubPacket packet = new SubPacket(OPCODE, playerActorID, targetActorID, data); SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
return packet; return packet;
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorStatusPacket.cs
View File

@ -11,7 +11,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x0177; public const ushort OPCODE = 0x0177;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, ushort index, ushort statusCode) public static SubPacket BuildPacket(uint sourceActorId, ushort index, ushort statusCode)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -24,7 +24,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorSubStatPacket.cs
View File

@ -10,7 +10,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x144; public const ushort OPCODE = 0x144;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetID, byte breakage, int leftChant, int rightChant, int guard, int wasteStat, int statMode, uint idleAnimationId) public static SubPacket BuildPacket(uint sourceActorId, byte breakage, int leftChant, int rightChant, int guard, int wasteStat, int statMode, uint idleAnimationId)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -28,7 +28,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorTargetAnimatedPacket.cs
View File

@ -9,9 +9,9 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00D3; public const ushort OPCODE = 0x00D3;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint targetID) public static SubPacket BuildPacket(uint sourceActorId, uint targetID)
{ {
return new SubPacket(OPCODE, playerActorID, targetID, BitConverter.GetBytes((ulong)targetID)); return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes((ulong)targetID));
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/SetActorTargetPacket.cs
View File

@ -8,9 +8,9 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x00DB; public const ushort OPCODE = 0x00DB;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint targetID) public static SubPacket BuildPacket(uint sourceActorId, uint targetID)
{ {
return new SubPacket(OPCODE, playerActorID, targetID, BitConverter.GetBytes((ulong)targetID)); return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes((ulong)targetID));
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/_0x132Packet.cs
View File

@ -11,7 +11,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x132; public const ushort OPCODE = 0x132;
public const uint PACKET_SIZE = 0x48; public const uint PACKET_SIZE = 0x48;
public static SubPacket BuildPacket(uint playerActorID, ushort number, string function) public static SubPacket BuildPacket(uint sourceActorId, ushort number, string function)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -24,7 +24,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

29
FFXIVClassic Map Server/packets/send/Actor/_0xD9Packet.cs
View File

@ -1,29 +0,0 @@
using System.IO;
using FFXIVClassic.Common;
using System;
using System.Text;
namespace FFXIVClassic_Map_Server.packets.send.actor
{
class _0xD9Packet
{
public const ushort OPCODE = 0x00D9;
public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, string anim)
{
byte[] data = new byte[PACKET_SIZE - 0x20];
using (MemoryStream mem = new MemoryStream(data))
{
using (BinaryWriter binWriter = new BinaryWriter(mem))
{
binWriter.Write(Encoding.ASCII.GetBytes(anim), 0, Encoding.ASCII.GetByteCount(anim) >= 4 ? 4 : Encoding.ASCII.GetByteCount(anim));
}
}
return new SubPacket(OPCODE, playerActorID, targetActorID, data);
}
}
}

4
FFXIVClassic Map Server/packets/send/Actor/_0xFPacket.cs
View File

@ -9,7 +9,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
public const ushort OPCODE = 0x000F; public const ushort OPCODE = 0x000F;
public const uint PACKET_SIZE = 0x38; public const uint PACKET_SIZE = 0x38;
public static SubPacket BuildPacket(uint playerActorID, uint targetActorID) public static SubPacket BuildPacket(uint sourceActor)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -21,7 +21,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
} }
} }
return new SubPacket(OPCODE, playerActorID, targetActorID, data); return new SubPacket(OPCODE, sourceActor, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX00Packet.cs
View File

@ -32,7 +32,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.battle
} }
} }
return new SubPacket(OPCODE, sourceActorId, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX01Packet.cs
View File

@ -2,8 +2,6 @@
using System; using System;
using System.IO; using System.IO;
using FFXIVClassic.Common;
namespace FFXIVClassic_Map_Server.packets.send.actor.battle namespace FFXIVClassic_Map_Server.packets.send.actor.battle
{ {
class BattleActionX01Packet class BattleActionX01Packet
@ -41,7 +39,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.battle
} }
} }
return new SubPacket(OPCODE, sourceActorId, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX10Packet.cs
View File

@ -55,7 +55,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.battle
} }
} }
return new SubPacket(OPCODE, sourceActorId, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX18Packet.cs
View File

@ -55,7 +55,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.battle
} }
} }
return new SubPacket(OPCODE, sourceActorId, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/events/SetEmoteEventCondition.cs
View File

@ -13,7 +13,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
public const ushort OPCODE = 0x016C; public const ushort OPCODE = 0x016C;
public const uint PACKET_SIZE = 0x48; public const uint PACKET_SIZE = 0x48;
public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.EmoteEventCondition condition) public static SubPacket BuildPacket(uint sourceActorId, EventList.EmoteEventCondition condition)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
} }
} }
return new SubPacket(OPCODE, sourceActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/events/SetEventStatus.cs
View File

@ -11,7 +11,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
public const ushort OPCODE = 0x0136; public const ushort OPCODE = 0x0136;
public const uint PACKET_SIZE = 0x48; public const uint PACKET_SIZE = 0x48;
public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, bool enabled, byte unknown2, string conditionName) public static SubPacket BuildPacket(uint sourceActorId, bool enabled, byte unknown2, string conditionName)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -25,7 +25,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
} }
} }
return new SubPacket(OPCODE, sourceActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/events/SetNoticeEventCondition.cs
View File

@ -12,7 +12,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
public const ushort OPCODE = 0x016B; public const ushort OPCODE = 0x016B;
public const uint PACKET_SIZE = 0x48; public const uint PACKET_SIZE = 0x48;
public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.NoticeEventCondition condition) public static SubPacket BuildPacket(uint sourceActorId, EventList.NoticeEventCondition condition)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -26,7 +26,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
} }
} }
return new SubPacket(OPCODE, sourceActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/events/SetPushEventConditionWithCircle.cs
View File

@ -12,7 +12,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
public const ushort OPCODE = 0x016F; public const ushort OPCODE = 0x016F;
public const uint PACKET_SIZE = 0x58; public const uint PACKET_SIZE = 0x58;
public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.PushCircleEventCondition condition) public static SubPacket BuildPacket(uint sourceActorId, EventList.PushCircleEventCondition condition)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -31,7 +31,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
} }
} }
return new SubPacket(OPCODE, sourceActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

8
FFXIVClassic Map Server/packets/send/Actor/events/SetPushEventConditionWithFan.cs
View File

@ -12,7 +12,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
public const ushort OPCODE = 0x0170; public const ushort OPCODE = 0x0170;
public const uint PACKET_SIZE = 0x60; public const uint PACKET_SIZE = 0x60;
public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.PushFanEventCondition condition) public static SubPacket BuildPacket(uint sourceActorId, EventList.PushFanEventCondition condition)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -23,7 +23,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
binWriter.Write((Single)condition.radius); binWriter.Write((Single)condition.radius);
binWriter.Write((UInt32)0xbfc90fdb); binWriter.Write((UInt32)0xbfc90fdb);
binWriter.Write((UInt32)0x3f860a92); binWriter.Write((UInt32)0x3f860a92);
binWriter.Write((UInt32)sourceActorID); //Actor Id binWriter.Write((UInt32)sourceActorId); //Actor Id
binWriter.Write((Single)10.0f); binWriter.Write((Single)10.0f);
binWriter.Seek(4, SeekOrigin.Current); binWriter.Seek(4, SeekOrigin.Current);
binWriter.Write((Byte)(condition.outwards ? 0x11 : 0x1)); //If == 0x10, Inverted Bounding Box binWriter.Write((Byte)(condition.outwards ? 0x11 : 0x1)); //If == 0x10, Inverted Bounding Box
@ -32,8 +32,8 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
binWriter.Write(Encoding.ASCII.GetBytes(condition.conditionName), 0, Encoding.ASCII.GetByteCount(condition.conditionName) >= 0x24 ? 0x24 : Encoding.ASCII.GetByteCount(condition.conditionName)); binWriter.Write(Encoding.ASCII.GetBytes(condition.conditionName), 0, Encoding.ASCII.GetByteCount(condition.conditionName) >= 0x24 ? 0x24 : Encoding.ASCII.GetByteCount(condition.conditionName));
} }
} }
new SubPacket(OPCODE, sourceActorID, playerActorID, data).DebugPrintSubPacket(); new SubPacket(OPCODE, sourceActorId, data).DebugPrintSubPacket();
return new SubPacket(OPCODE, sourceActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/events/SetPushEventConditionWithTriggerBox.cs
View File

@ -12,7 +12,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
public const ushort OPCODE = 0x0175; public const ushort OPCODE = 0x0175;
public const uint PACKET_SIZE = 0x60; public const uint PACKET_SIZE = 0x60;
public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.PushBoxEventCondition condition) public static SubPacket BuildPacket(uint sourceActorId, EventList.PushBoxEventCondition condition)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -31,7 +31,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
} }
} }
return new SubPacket(OPCODE, sourceActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/events/SetTalkEventCondition.cs
View File

@ -12,7 +12,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
public const ushort OPCODE = 0x012E; public const ushort OPCODE = 0x012E;
public const uint PACKET_SIZE = 0x48; public const uint PACKET_SIZE = 0x48;
public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.TalkEventCondition condition) public static SubPacket BuildPacket(uint sourceActorId, EventList.TalkEventCondition condition)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.events
} }
} }
return new SubPacket(OPCODE, sourceActorID, playerActorID, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX01Packet.cs
View File

@ -23,7 +23,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, playerActorID, playerActorID, data); return new SubPacket(OPCODE, playerActorID, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX08Packet.cs
View File

@ -38,7 +38,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, playerActorId, playerActorId, data); return new SubPacket(OPCODE, playerActorId, data);
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX16Packet.cs
View File

@ -36,7 +36,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, playerActorId, playerActorId, data); return new SubPacket(OPCODE, playerActorId, data);
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX32Packet.cs
View File

@ -36,7 +36,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, playerActorId, playerActorId, data); return new SubPacket(OPCODE, playerActorId, data);
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX64Packet.cs
View File

@ -36,7 +36,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, playerActorId, playerActorId, data); return new SubPacket(OPCODE, playerActorId, data);
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryBeginChangePacket.cs
View File

@ -11,13 +11,13 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
{ {
byte[] data = new byte[8]; byte[] data = new byte[8];
data[0] = 2; data[0] = 2;
return new SubPacket(OPCODE, sourceActorId, targetActorId, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
public static SubPacket BuildPacket(uint playerActorID) public static SubPacket BuildPacket(uint playerActorID)
{ {
byte[] data = new byte[8]; byte[] data = new byte[8];
return new SubPacket(OPCODE, playerActorID, playerActorID, data); return new SubPacket(OPCODE, playerActorID, data);
} }
} }
} }

10
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryEndChangePacket.cs
View File

@ -7,14 +7,10 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
public const ushort OPCODE = 0x016E; public const ushort OPCODE = 0x016E;
public const uint PACKET_SIZE = 0x28; public const uint PACKET_SIZE = 0x28;
public static SubPacket BuildPacket(uint sourceActorId, uint targetActorId) public static SubPacket BuildPacket(uint sourceActorId)
{ {
return new SubPacket(OPCODE, sourceActorId, targetActorId, new byte[8]); return new SubPacket(OPCODE, sourceActorId, new byte[8]);
}
public static SubPacket BuildPacket(uint playerActorID)
{
return new SubPacket(OPCODE, playerActorID, playerActorID, new byte[8]);
} }
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryItemEndPacket.cs
View File

@ -30,7 +30,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
data = mem.GetBuffer(); data = mem.GetBuffer();
} }
return new SubPacket(OPCODE, playerActorID, playerActorID, data); return new SubPacket(OPCODE, playerActorID, data);
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryItemPacket.cs
View File

@ -30,7 +30,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
data = mem.GetBuffer(); data = mem.GetBuffer();
} }
return new SubPacket(OPCODE, playerActorID, playerActorID, data); return new SubPacket(OPCODE, playerActorID, data);
} }

11
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryListX01Packet.cs
View File

@ -9,13 +9,8 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
{ {
public const ushort OPCODE = 0x0148; public const ushort OPCODE = 0x0148;
public const uint PACKET_SIZE = 0x90; public const uint PACKET_SIZE = 0x90;
public static SubPacket BuildPacket(uint playerActorId, InventoryItem item) public static SubPacket BuildPacket(uint sourceActorId, InventoryItem item)
{
return BuildPacket(playerActorId, playerActorId, item);
}
public static SubPacket BuildPacket(uint sourceActorId, uint targetActorId, InventoryItem item)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -27,7 +22,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, sourceActorId, targetActorId, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }

11
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryListX08Packet.cs
View File

@ -11,13 +11,8 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
{ {
public const ushort OPCODE = 0x0149; public const ushort OPCODE = 0x0149;
public const uint PACKET_SIZE = 0x3A8; public const uint PACKET_SIZE = 0x3A8;
public static SubPacket BuildPacket(uint playerActorId, List<InventoryItem> items, ref int listOffset) public static SubPacket BuildPacket(uint sourceActorId, List<InventoryItem> items, ref int listOffset)
{
return BuildPacket(playerActorId, playerActorId, items, ref listOffset);
}
public static SubPacket BuildPacket(uint sourceActorId, uint targetActorId, List<InventoryItem> items, ref int listOffset)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -42,7 +37,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, sourceActorId, targetActorId, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

10
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryListX16Packet.cs
View File

@ -11,12 +11,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
public const ushort OPCODE = 0x014A; public const ushort OPCODE = 0x014A;
public const uint PACKET_SIZE = 0x720; public const uint PACKET_SIZE = 0x720;
public static SubPacket BuildPacket(uint playerActorId, List<InventoryItem> items, ref int listOffset) public static SubPacket BuildPacket(uint sourceActorId, List<InventoryItem> items, ref int listOffset)
{
return BuildPacket(playerActorId, playerActorId, items, ref listOffset);
}
public static SubPacket BuildPacket(uint sourceActorId, uint targetActorId, List<InventoryItem> items, ref int listOffset)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -38,7 +33,8 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, sourceActorId, targetActorId, data); return new SubPacket(OPCODE, sourceActorId, data);
} }
} }
} }

4
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryListX32Packet.cs
View File

@ -10,7 +10,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
{ {
public const ushort OPCODE = 0x014B; public const ushort OPCODE = 0x014B;
public const uint PACKET_SIZE = 0xE20; public const uint PACKET_SIZE = 0xE20;
public static SubPacket BuildPacket(uint playerActorID, List<InventoryItem> items, ref int listOffset) public static SubPacket BuildPacket(uint playerActorID, List<InventoryItem> items, ref int listOffset)
{ {
byte[] data = new byte[PACKET_SIZE - 0x20]; byte[] data = new byte[PACKET_SIZE - 0x20];
@ -33,7 +33,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, playerActorID, playerActorID, data); return new SubPacket(OPCODE, playerActorID, data);
} }
} }
} }

2
FFXIVClassic Map Server/packets/send/Actor/inventory/InventoryListX64Packet.cs
View File

@ -33,7 +33,7 @@ namespace FFXIVClassic_Map_Server.packets.send.actor.inventory
} }
} }
return new SubPacket(OPCODE, playerActorID, playerActorID, data); return new SubPacket(OPCODE, playerActorID, data);
} }
} }
} }

Some files were not shown because too many files have changed in this diff Show More