public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var u = swap16(BitConverter.ToUInt16(request.Data, 0));
// This is very similar to the area server handler
// If this is zero, show the guild category breakdown (basically)
// otherwise, show them all the guilds
if (u == 0)
{
// Tell them we have ONE guild listing
responses.Add(request.CreateResponse(0x7734, new byte[] { 0x00, 0x01 }));
// This should print "ALL" on the game
responses.Add(request.CreateResponse(0x7736, new byte[] { 0x00, 0x01, 0x41, 0x6c, 0x6c, 0x00 }));
}
else
{
var listOfGuilds = guildManagementService.GetListOfGuilds();
responses.Add(request.CreateResponse(0x7737, BitConverter.GetBytes(swap16((ushort)listOfGuilds.Count))));
foreach (var guildName in listOfGuilds)
{
responses.Add(request.CreateResponse(0x7738, guildName));
}
}
return(Task.FromResult <IEnumerable <ResponseContent> >(responses));
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var u = swap16(BitConverter.ToUInt16(request.Data, 0));
if (u == 0)
{
var categoryList = await bulletinBoardService.GetCategoriesAsync();
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_BBS_CATEGORYLIST, BitConverter.GetBytes(swap16((ushort)categoryList.Count))));
foreach (var category in categoryList)
{
var categoryData = await bulletinBoardService.ConvertCategoryToBytesAsync(category);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_BBS_ENTRY_CATEGORY, categoryData));
}
}
else
{
var categoryID = Convert.ToInt32(u);
var threadsList = await bulletinBoardService.GetThreadsAsync(categoryID);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_BBS_THREADLIST, BitConverter.GetBytes(swap16((ushort)threadsList.Count))));
foreach (var thread in threadsList)
{
var threadData = await bulletinBoardService.ConvertThreadToBytesAsync(thread);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_BBS_ENTRY_THREAD, threadData));
}
}
return(responses);
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var u = swap16(BitConverter.ToUInt16(request.Data, 0));
if (u == 0)// Guild Member Category List
{
List <byte[]> listOfClasses = GetClassList();
responses.Add(request.CreateResponse(0x7611, BitConverter.GetBytes(swap16((ushort)listOfClasses.Count))));
foreach (var className in listOfClasses)
{
responses.Add(request.CreateResponse(0x7613, className));
}
}
else //MemberList in that Category
{
List <byte[]> memberList = guildManagementService.GetGuildMembersListByClass(request.Client._guildID, u, request.Client._characterPlayerID);
responses.Add(request.CreateResponse(0x7614, BitConverter.GetBytes(swap16((ushort)memberList.Count))));
foreach (var member in memberList)
{
responses.Add(request.CreateResponse(0x7615, member));
}
}
return(Task.FromResult <IEnumerable <ResponseContent> >(responses));
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var nonGuildLobbies = new List <LobbyChatRoom>(lobbyChatService.Lobbies.Values.Where(c => c.Type == OpCodes.LOBBY_TYPE_MAIN));
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_LOBBY_LOBBYLIST, BitConverter.GetBytes(swap16((ushort)nonGuildLobbies.Count))));
foreach (var room in nonGuildLobbies)
{
var m = new MemoryStream();
await m.WriteAsync(BitConverter.GetBytes(swap16(room.ID)), 0, 2);
foreach (char c in room.Name)
{
m.WriteByte((byte)c);
}
m.WriteByte(0);
await m.WriteAsync(BitConverter.GetBytes(swap16((ushort)room.Clients.Count)), 0, 2);
await m.WriteAsync(BitConverter.GetBytes(swap16((ushort)(room.Clients.Count + 1))), 0, 2);
// looks like some form of padding to align the message
while (((m.Length + 2) % 8) != 0)
{
m.WriteByte(0);
}
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_LOBBY_ENTRY_LOBBY, m.ToArray()));
}
return(responses);
}
public override async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
if (request.DataOpCode == OpCodes.OPCODE_DATA_LOBBY_FAVORITES_AS_INQUIRY)
{
logger.LogData(request.Data, request.OpCode, request.Client.ClientIndex, "Get Bookmark", 0, 0);
var encoding = Encoding.GetEncoding("Shift-JIS");
var areaServers = clientProviderService.AreaServers;
responses.Add(request.CreateResponse(0x7859, BitConverter.GetBytes(((ushort)areaServers.Count).Swap())));
// Now we need to send all the area servers to the client
foreach (var client in areaServers)
{
var m = new MemoryStream();
m.WriteByte(0);
if (client.ipEndPoint.Address == request.Client.ipEndPoint.Address)
{
await m.WriteAsync(client.ipdata, 0, 6);
}
else
{
await m.WriteAsync(client.externalIPAddress, 0, 6);
}
var buff = BitConverter.GetBytes((client.as_usernum.Swap()));
int pos = 0;
while (client.publish_data_1[pos++] != 0)
{
;
}
pos += 4;
client.publish_data_1[pos++] = buff[0];
client.publish_data_1[pos++] = buff[1];
await m.WriteAsync(client.publish_data_1, 0, client.publish_data_1.Length);
while (m.Length < 45)
{
m.WriteByte(0);
}
var usr = encoding.GetString(BitConverter.GetBytes((client.as_usernum.Swap())));
var pup1 = encoding.GetString(client.publish_data_1);
var pup2 = encoding.GetString(client.publish_data_2);
logger.Debug($"AREA SERVER: {pup1}; {pup2}; {usr}", pup1, pup2, usr);
responses.Add(request.CreateResponse(0x786A, m.ToArray()));
}
return(responses);
}
else
{
return(await base.HandleIncomingRequestAsync(request));
}
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
bool isNew = await _newsService.CheckIfNewNewsForSaveId(_encoding.GetString(request.Client.save_id));
if (isNew)
{
return(new[] { request.CreateResponse(OpCodes.OPCODE_DATA_NEWCHECK_OK, new byte[] { 0x00, 0x01 }) }); // send the new flag
}
else
{
return(new[] { request.CreateResponse(OpCodes.OPCODE_DATA_NEWCHECK_OK, new byte[] { 0x00, 0x00 }) }); // there are no new articles to read
}
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
if (request.Data[1] == OpCodes.OPCODE_DATA_SERVERKEY_CHANGE)
{
_logger.Information("Client #{@clientIndex} has identified itself as an Area Server", request.Client.ClientIndex);
request.Client.isAreaServer = true;
return(Task.FromResult <IEnumerable <ResponseContent> >(new[] { request.CreateResponse(OpCodes.OPCODE_DATA_AREASERVER_OK, new byte[] { 0xDE, 0xAD }) }));
}
else
{
_logger.Information("Client #{@clientIndex} has identified itself as a Game Client (PS2 / PCSX2)", request.Client.ClientIndex);
return(Task.FromResult <IEnumerable <ResponseContent> >(new[] { request.CreateResponse(OpCodes.OPCODE_DATA_LOGON_RESPONSE, new byte[] { 0x74, 0x32 }) }));
}
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var guildId = swap16(BitConverter.ToUInt16(request.Data, 0));
var listOfItemsForGeneralStore = guildManagementService.GetGuildItems(guildId, true);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_GUILD_ITEMS_COUNT, BitConverter.GetBytes(swap16((ushort)listOfItemsForGeneralStore.Count))));
foreach (var item in listOfItemsForGeneralStore)
{
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_GUILD_ITEM_DETAILS, item));
}
return(Task.FromResult <IEnumerable <ResponseContent> >(responses));
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var accountId = ReadAccountID(request.Data, 0);
var mail = await mailService.GetMailAsync(accountId);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_MAIL_GETOK, BitConverter.GetBytes(swap32((uint)mail.Count))));
foreach (var item in mail)
{
var mailContent = await mailService.ConvertMailMetaIntoBytes(item);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_MAIL_GET_NEWMAIL_HEADER, mailContent));
}
return(responses);
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
LobbyChatRoom room;
var currentLobbyIndex = (short)swap16(BitConverter.ToUInt16(request.Data, 0));
var currentLobbyType = swap16(BitConverter.ToUInt16(request.Data, 2));
logger.Verbose("Lobby Room ID: {@room_index}", currentLobbyIndex);
logger.Verbose("Lobby Type ID: {@lobbyType}", currentLobbyType);
if (currentLobbyType == OpCodes.LOBBY_TYPE_GUILD) //Guild Room
{
//TODO add Guild Specific Code
room = lobbyChatService.GetOrAddLobby((ushort)currentLobbyIndex, "Guild Room", OpCodes.LOBBY_TYPE_GUILD, out var _);
}
else
{
lobbyChatService.TryGetLobby((ushort)currentLobbyIndex, out room);
}
var response = request.CreateResponse(OpCodes.OPCODE_DATA_LOBBY_ENTERROOM_OK, BitConverter.GetBytes(swap16((ushort)room.Clients.Count)));
await room.ClientJoinedLobbyAsync(request.Client);
logger.Information("Client #{@clientIndex} has joined Lobby {@lobbyName}. There are now {@lobbySize} client(s) in the room", new { clientIndex = request.Client.ClientIndex, lobbyName = room.Name, lobbySize = room.Clients.Count });
return(new[] { response });
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var i = swap32(BitConverter.ToUInt32(request.Data, 0));
var threadID = Convert.ToInt32(i);
var postMetaList = await bulletinBoardService.GetThreadDetailsAsync(threadID);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_BBS_THREAD_LIST, BitConverter.GetBytes(swap32((uint)postMetaList.Count))));
foreach (var meta in postMetaList)
{
var postMetaBytes = await bulletinBoardService.ConvertThreadDetailsToBytesAsync(meta);
responses.Add(request.CreateResponse(OpCodes.OPCODE_DATA_BBS_ENTRY_POST_META, postMetaBytes));
}
return(responses);
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
uint rankPlayerID = BitConverter.ToUInt32(request.Data, 0).Swap();
ResponseContent response = request.CreateResponse(0x7839, _rankingManagementService.GetRankingPlayerInfo(rankPlayerID));
return(Task.FromResult <IEnumerable <ResponseContent> >(new [] { response }));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
List <ResponseContent> responseList = new List <ResponseContent>();
LobbyChatRoom room;
var currentLobbyIndex = (short)swap16(BitConverter.ToUInt16(request.Data, 0));
var currentLobbyType = swap16(BitConverter.ToUInt16(request.Data, 2));
logger.Verbose("Lobby Room ID: {@room_index}", currentLobbyIndex);
logger.Verbose("Lobby Type ID: {@lobbyType}", currentLobbyType);
if (currentLobbyType == OpCodes.LOBBY_TYPE_GUILD) //Guild Room
{
//TODO add Guild Specific Code
room = lobbyChatService.GetOrAddLobby((ushort)currentLobbyIndex, "Guild Room", OpCodes.LOBBY_TYPE_GUILD, out var _);
}
else
{
lobbyChatService.TryGetLobby((ushort)currentLobbyIndex, out room);
}
responseList.Add(request.CreateResponse(OpCodes.OPCODE_DATA_LOBBY_ENTERROOM_OK, BitConverter.GetBytes(swap16((ushort)room.Clients.Count))));
responseList.AddRange(room.ClientJoinedLobbyPacketHandler(request.Client, request));
logger.Information("Client #{0} has joined Lobby {1}. There are now {2} client(s) in the room", request.Client.ClientIndex, room.Name, room.Clients.Count);
return(Task.FromResult <IEnumerable <ResponseContent> >(responseList));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
return(Task.FromResult <IEnumerable <ResponseContent> >(new[]
{
request.CreateResponse(0x787a,
_guildManagementService.GetItemDonationSettings(request.Client.isGuildMaster))
}));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
return(Task.FromResult <IEnumerable <ResponseContent> >(new[]
{
request.CreateResponse(0x7713,
_guildManagementService.SetItemVisibilityAndPrice(request.Data))
}));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
List <ResponseContent> responseContents = new List <ResponseContent>();
var u = BitConverter.ToUInt16(request.Data, 0).Swap();
List <byte[]> membersItemList = _guildManagementService.GetGuildItems(u, false);
responseContents.Add(request.CreateResponse(0x7709,
BitConverter.GetBytes(((ushort)membersItemList.Count).Swap()))); // number of items
foreach (var item in membersItemList)
{
responseContents.Add(request.CreateResponse(0x770a, item));
}
return(Task.FromResult <IEnumerable <ResponseContent> >(responseContents));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
return(Task.FromResult <IEnumerable <ResponseContent> >(new[]
{
request.CreateResponse(0x761D,
_guildManagementService.UpdateGuildEmblemComment(request.Data, request.Client._guildID))
}));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var u = guildManagementService.CreateGuild(request.Data, request.Client._characterPlayerID);
request.Client._guildID = u;
request.Client.isGuildMaster = true;
return(Task.FromResult <IEnumerable <ResponseContent> >(new[] { request.CreateResponse(0x7601, BitConverter.GetBytes(swap16(u))) }));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
return(Task.FromResult <IEnumerable <ResponseContent> >(new[]
{
request.CreateResponse(0x7617,
_guildManagementService.LeaveGuild(request.Client._guildID, request.Client._characterPlayerID))
}));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
List <ResponseContent> responseContents = new List <ResponseContent>();
var u = BitConverter.ToUInt16(request.Data, 0).Swap();
List <byte[]> allGuildItems = _guildManagementService.GetAllGuildItemsWithSettings(u);
responseContents.Add(request.CreateResponse(0x7729,
BitConverter.GetBytes(((ushort)allGuildItems.Count).Swap()))); // number of items
foreach (var item in allGuildItems)
{
responseContents.Add(request.CreateResponse(0x772A, item));
}
return(Task.FromResult <IEnumerable <ResponseContent> >(responseContents));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>
{
request.CreateResponse(0x770D, guildManagementService.BuyItemFromGuild(request.Data))
};
return(Task.FromResult <IEnumerable <ResponseContent> >(responses));
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var mailId = (int)swap32(BitConverter.ToUInt32(request.Data, 4));
var messageBodyModel = await mailService.GetMailContent(mailId);
var messageBody = await mailService.ConvertMailBodyIntoBytes(messageBodyModel);
return(new[] { request.CreateResponse(OpCodes.OPCODE_DATA_MAIL_GET_MAIL_BODY_RESPONSE, messageBody) });
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>();
var ms = new MemoryStream();
await ms.WriteAsync(new byte[] { 0x76, 0xB0, 0x54, 0x45, 0x53, 0x54, 0x00 });
if (request.Data[1] == 0x08) //accepted the invitation
{
DBAccess.getInstance().EnrollPlayerInGuild(request.Client.currentGuildInvitaionSelection, request.Client._characterPlayerID, false);
responses.Add(request.CreateResponse(0x760A, ms.ToArray())); // send guild ID
}
else
{
// rejected
responses.Add(request.CreateResponse(0x760A, ms.ToArray())); // send guild ID
}
return(responses);
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
request.Client._itemDontationID = BitConverter.ToUInt32(request.Data, 2).Swap();
request.Client._itemDonationQuantity = BitConverter.ToUInt16(request.Data, 6).Swap();
return(Task.FromResult <IEnumerable <ResponseContent> >(new [] { request.CreateResponse(0x7704,
_guildManagementService.GetPriceOfItemToBeDonated(request.Client._guildID,
request.Client._itemDontationID)) }));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var responses = new List <ResponseContent>
{
request.CreateResponse(0x761A, guildManagementService.DestroyGuild(request.Client._guildID))
};
return(Task.FromResult <IEnumerable <ResponseContent> >(responses));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
uint playerToKick = BitConverter.ToUInt32(request.Data, 0).Swap();
return(Task.FromResult <IEnumerable <ResponseContent> >(new[]
{
request.CreateResponse(0x7865,
_guildManagementService.KickPlayerFromGuild(request.Client._guildID, playerToKick))
}));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
uint assigningPlayerID = BitConverter.ToUInt32(request.Data, 0).Swap();
return(Task.FromResult <IEnumerable <ResponseContent> >(new[]
{
request.CreateResponse(0x788E,
_guildManagementService.LeaveGuildAndAssignMaster(request.Client._guildID, assigningPlayerID))
}));
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var guildId = swap16(BitConverter.ToUInt16(request.Data, 0));
return(Task.FromResult <IEnumerable <ResponseContent> >(
new[]
{
request.CreateResponse(OpCodes.OPCODE_DATA_GET_GUILD_INFO_RESPONSE, guildManagementService.GetGuildInfo(guildId))
}));
}
public async Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
bool isNew = await Task.Run(() =>
DBAccess.getInstance().checkForNewMailByAccountID(Extensions.ReadAccountId(request.Data, 0)));
ResponseContent responseContent;
if (isNew)
{
responseContent = request.CreateResponse(OpCodes.OPCODE_DATA_MAILCHECK_OK,
new byte[] { 0x00, 0x00, 0x01, 0x00 });
}
else
{
responseContent = request.CreateResponse(OpCodes.OPCODE_DATA_MAILCHECK_OK, new byte[] { 0x00, 0x01 });
}
return(new[] { responseContent });
}
public Task <IEnumerable <ResponseContent> > HandleIncomingRequestAsync(RequestContent request)
{
var u = BitConverter.ToUInt16(request.Data, 0).Swap();
request.Client.currentGuildInvitaionSelection = u;
return(Task.FromResult <IEnumerable <ResponseContent> >(new[]
{
request.CreateResponse(0x772D,
_guildManagementService.GetGuildInfo(u))
}));
}