private void OnMessage <RequestPacket>(PacketHeader packetHeader, byte[] packetMessage)
where RequestPacket : IServerPacket
{
//Header는 여기서 사용해야할까?
//var requestPacket = MessagePackSerializer.Deserialize<dynamic>(packetMessage, MessagePack.Resolvers.ContractlessStandardResolver.Instance);
//IServerPacket serverPacket = requestPacket as IServerPacket;
var requestPacket = MessagePackSerializer.Typeless.Deserialize(packetMessage) as IServerPacket; //size 119
//MessagePackSerializer.Deserialize<IServerPacket>(bytes);
//여기에는 send로 온.. 데이터만 들어오는데..
IClientPacket clientPacket = ProcessManager.Run(requestPacket.PacketId, requestPacket);
byte[] bytes = MessagePack.MessagePackSerializer.Typeless.Serialize(clientPacket);
PacketHeader packetHeader2 = new PacketHeader
{
ContentsVersion = packetHeader.ContentsVersion,
LogicVersion = packetHeader.LogicVersion,
PacketID = requestPacket.PacketId,
PacketSize = bytes.Length,
EncriptKey = 0,
EncriptType = 0,
};
//response
IRequestItem requestItem = new PacketHolder(PacketHeaderConverter.CreateHeaderToBytes(packetHeader2), requestPacket.PacketId, bytes);
Send(requestItem);
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
string category = clientPacket.ReadString();
string data = clientPacket.ReadString();
//Send the categories..
if (string.IsNullOrEmpty(data))
{
IList <INavigatorCategory> categories =
await _navigatorController.GetNavigatorCategoriesAsync();
IList <INavigatorCategory> categoriesToSend = new List <INavigatorCategory>();
foreach (INavigatorCategory navCategory in categories)
{
if (navCategory.Category == category)
{
categoriesToSend.Add(navCategory);
}
}
await session.WriteAndFlushAsync(
new NavigatorSearchResultSetComposer(category, data, categoriesToSend));
}
}
public void Init(string host, int port, IClientPacket packet)
{
var talk = Dns.GetHostAddressesAsync(host);
talk.Wait();
IPAddress[] ips = talk.Result;
if (ips.Length == 0)
{
throw new BXException("get host's address error");
}
foreach (IPAddress item in ips)
{
if (item.AddressFamily == AddressFamily.InterNetwork ||
item.AddressFamily == AddressFamily.InterNetworkV6)
{
mIPAddress = item;
break;
}
}
mPort = port;
if (packet != null)
{
Packet = packet;
Packet.Completed = OnPacketCompleted;
}
}
public async Task HandleAsync(ISession session, IClientPacket clientPacket)
{
string rawData = clientPacket.ReadString();
string[] data = rawData.Split(' ');
uint itemId = uint.Parse(data[0]);
IRoom room = session.CurrentRoom;
if (session.Inventory.Items.TryGetValue(itemId, out IItem item))
{
//It's a floor item.
if (item.ItemTemplate.Type == "s")
{
int x = int.Parse(data[1]);
int y = int.Parse(data[2]);
uint rot = uint.Parse(data[3]);
item.ItemData.Position.X = x;
item.ItemData.Position.Y = y;
item.ItemData.Rotation = rot;
session.Inventory.Items.Remove(itemId);
await session.WriteAndFlushAsync(new ObjectAddComposer(item, session.Player.Username));
}
else
{
}
}
}
public async Task <Player> Go(Player player, IClientPacket packet = null, int count = 1)
{
_indexPacket = 0;
_packet = packet;
_count = count;
_player = player;
_gameOver = false;
try
{
using (socket = new ClientWebSocket())
{
await socket.ConnectAsync(new Uri(GameSettings.HOST), CancellationToken.None);
var authPack = _player.Url.ToAuth().ToPack();
await SendAsync(authPack);
byte[] buffer;
int buffer_len = 1024;
while (socket.State == WebSocketState.Open && !_gameOver)
{
buffer = new byte[buffer_len];
var result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
//if (!result.EndOfMessage)
//{
// buffer_len = BitConverter.ToInt32(buffer);
// continue;
//}264
var buffer2 = new byte[buffer.Length];
short type = BitConverter.ToInt16(buffer, 8);
Array.Copy(buffer, 10, buffer2, 0, buffer2.Length - 10);
_gameOver = await ResponceParse(type, buffer2);
//buffer_len = 4;
}
await Task.Delay(_delayTime);
}
}
catch (Exception ex)
{
_player.AuthResult = AuthResultType.ERROR_APP.ToString();
if (ex.Message.Contains("status code '502'"))
{
_player.AuthResult = AuthResultType.UPDATE_GAME.ToString();
}
Console.WriteLine($"[Go] Socket exception: {ex.Message}");
}
finally
{
Close();
}
return(_player);
}
// Sends a client packet to the server.
public void Send(IClientPacket packet)
{
if (!socket.Connected)
{
return;
}
MemoryStream ms = new MemoryStream();
using (PacketWriter writer = new PacketWriter(ms))
{
// Write the packet ID.
writer.Write((byte)packet.Id);
// Write a placeholder int32 for the length - we will overwrite this later.
writer.Write(0);
// Write the actual packet data
packet.Write(writer);
var data = ms.ToArray();
// Overwrite the length placeholder with the actual length
writer.WriteLength(data);
// Actually write the data to the socket.
stream.BeginWrite(data, 0, data.Length, OnWrite, null);
}
}
public IClientPacket Run(IServerPacket requestPacket, IClientPacket responsePacket)
{
RequestPacket request = requestPacket as RequestPacket;
ResponsePacket response = responsePacket as ResponsePacket;
return(process.Run(request, response));
}
public async Task HandleAsync(ISession session, IClientPacket clientPacket)
{
int roomId = clientPacket.ReadInt();
string password = clientPacket.ReadString();
IRoom room = await _roomController.GetRoomByIdAndPassword(roomId, password);
if (room != null)
{
await session.WriteAndFlushAsync(new OpenConnectionComposer());
await session.WriteAndFlushAsync(new RoomReadyComposer(room.RoomData.ModelName, room.RoomData.Id));
await session.WriteAndFlushAsync(new RoomRatingComposer(room.RoomData.Score));
if (!room.CycleActive)
{
room.SetupRoomCycle();
}
session.CurrentRoom = room;
}
else
{
await session.WriteAndFlushAsync(new CloseConnectionComposer());
}
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
string text = clientPacket.ReadString();
string[] splitText = text.Split(',');
IList <IHallOfFamer> hallOfFamers = await _landingController.GetHallOfFamersAsync();
if (string.IsNullOrEmpty(text) || splitText.Length < 2)
{
await session.WriteAndFlushAsync(new CampaignComposer("", ""));
await session.WriteAndFlushAsync(new HallOfFameComposer(hallOfFamers, ""));
return;
}
if (splitText[1] == "gamesmaker")
{
return;
}
await session.WriteAndFlushAsync(new CampaignComposer(text, splitText[1]));
await session.WriteAndFlushAsync(new HallOfFameComposer(hallOfFamers, ""));
}
public static CLIENT CreateClient <CLIENT>(IClientPacket packet, string host, int port) where CLIENT : IClient, new()
{
CLIENT client = new CLIENT();
client.Init(host, port, packet);
return(client);
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
await session.WriteAndFlushAsync(new MessengerInitComposer());
//TODO: Make friends.
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
IList <INavigatorCategory> categories =
await _navigatorController.GetNavigatorCategoriesAsync();
await session.WriteAndFlushAsync(new UserFlatCatsComposer(categories, session.Player.Rank));
}
public static CLIENT CreateSslClient <CLIENT>(IClientPacket packet, string host, int port, string serviceName) where CLIENT : IClient, new()
{
CLIENT client = new CLIENT();
client.Init(host, port, packet);
client.SSL = true;
client.SslServiceName = serviceName;
return(client);
}
public void OnMessage(PacketHeader packetHeader, byte[] packetMessage)
{
//token
IClientPacket responsePacket = MessagePack.MessagePackSerializer.Typeless.Deserialize(packetMessage) as IClientPacket; //size 119
clientRequester.Response(responsePacket);
//throw new NotImplementedException();
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
string uniqueId = clientPacket.ReadString();
session.UniqueId = uniqueId;
await session.WriteAndFlushAsync(new SetUniqueIdComposer(uniqueId));
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
await session.WriteAndFlushAsync(new CreditBalanceComposer(session.Player.Credits));
await session.WriteAndFlushAsync(
new ActivityPointsComposer(session.Player.Duckets, session.Player.Diamonds));
}
public async Task Handle(ISession session, IClientPacket clientPacket)
{
if (_asyncHandles.TryGetValue(clientPacket.OpCode, out IAsyncHandle handle))
{
await handle.Handle(session, clientPacket);
}
else
{
Console.WriteLine($"Unknown op code: {clientPacket.OpCode}");
}
}
public async Task TriggerEvent(ISession session, IClientPacket clientPacket)
{
if (_events.TryGetValue(clientPacket.Header, out IAsyncPacket eventHandler))
{
_logger.LogInformation($"Executing {eventHandler.GetType().Name} for header: {clientPacket.Header}.");
await eventHandler.HandleAsync(session, clientPacket);
}
else
{
_logger.LogError($"Unable to handle packet: {clientPacket.Header}.");
}
}
public Task HandleAsync(ISession session, IClientPacket clientPacket)
{
IRoom room = session.CurrentRoom;
if (room != null)
{
room.LeaveRoom(session);
}
//TODO: Send packets to close the connection.
return(Task.CompletedTask);
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
await session.WriteAndFlushAsync(new NavigatorMetaDataParserComposer());
await session.WriteAndFlushAsync(new NavigatorLiftedRoomsComposer());
await session.WriteAndFlushAsync(new NavigatorCollapsedCategoriesComposer());
await session.WriteAndFlushAsync(new NavigatorPreferencesComposer(session.PlayerSettings));
}
public Task HandleAsync(ISession session, IClientPacket clientPacket)
{
int x = clientPacket.ReadInt();
int y = clientPacket.ReadInt();
IList <Position> walkingPath = PathFinder.FindPath(
session.CurrentRoom.RoomGrid,
session.Entity.Position, new Position(x, y, 0));
walkingPath.RemoveAt(walkingPath.Count - 1);
session.Entity.PathToWalk = walkingPath;
return(Task.CompletedTask);
}
public static IClientPacket Run <RequestPacket>(Int32 packetId, RequestPacket requestPacket)
where RequestPacket : IServerPacket
{
IClientPacket clientPacket = packetRegister.ClientPacketList[packetId];
if (ProcessList.Count > 0)
{
Run <RequestPacket, IClientPacket>(packetId, requestPacket, ref clientPacket);
}
return(clientPacket);
}
public void SendMessage(IClientPacket packet)
{
try
{
writer.WritePacket(packet);
writer.Flush();
//GD.Print("OK");
}
catch (GodotError e)
{
//GD.Print($"Caught {e.Name}");
}
}
public AwaiterClient(string host, int port, IClientPacket packet, string sslServiceName = null)
{
if (sslServiceName == null)
{
mClient = SocketFactory.CreateClient <AsyncTcpClient>(packet, host, port);
}
else
{
mClient = SocketFactory.CreateSslClient <AsyncTcpClient>(packet, host, port, sslServiceName);
}
mClient.ClientError = OnError;
mClient.PacketReceive = OnPacketReceive;
}
public Task Handle(ISession session, IClientPacket clientPacket)
{
if (typeof(TArgs) == typeof(EmptyArgs))
{
return(Invoke(session, null));
}
TArgs args = new TArgs();
args.ParseArgs(clientPacket);
return(Invoke(session, args));
}
public async Task HandleAsync(ISession session, IClientPacket clientPacket)
{
IDictionary <uint, IItem> items;
//Initializes the inventory
if (session.Inventory == null)
{
items = await _itemController.GetItemsForPlayerAsync(session.Player.Id);
_itemController.InitializeInventoryForSession(session, items);
}
items = session.Inventory.Items;
await session.WriteAndFlushAsync(new FurniListComposer(items.Values));
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
string ssoTicket = clientPacket.ReadString();
IPlayer player = await _playerController.GetPlayerBySsoAsync(ssoTicket);
if (player != null)
{
session.Player = player;
IPlayerSettings playerSettings =
await _playerController.GetPlayerSettingsByIdAsync(player.Id);
if (playerSettings != null)
{
session.PlayerSettings = playerSettings;
}
else
{
await _playerController.AddPlayerSettingsAsync(player.Id);
session.PlayerSettings =
await _playerController.GetPlayerSettingsByIdAsync(player.Id);
}
await session.WriteAndFlushAsync(new AuthenticationOkComposer());
await session.WriteAndFlushAsync(new HomeRoomComposer(1));
await session.WriteAndFlushAsync(new FavouriteRoomsComposer());
await session.WriteAndFlushAsync(new FigureSetIdsComposer());
await session.WriteAndFlushAsync(new UserRightsComposer(session.Player.Rank));
await session.WriteAndFlushAsync(new AvailabilityStatusComposer());
await session.WriteAndFlushAsync(new BuildersClubMembershipComposer());
await session.WriteAndFlushAsync(new CfhTopicsInitComposer());
await session.WriteAndFlushAsync(new BadgeDefinitionsComposer());
await session.WriteAndFlushAsync(new PlayerSettingsComposer());
}
}
public async Task HandleAsync(ISession session, IClientPacket clientPacket)
{
IRoom room = session.CurrentRoom;
await session.WriteAndFlushAsync(new HeightMapComposer(room.RoomModel));
await session.WriteAndFlushAsync(new FloorHeightMapComposer(-1, room.RoomModel.RelativeHeightMap));
BaseEntity userEntity = _roomController.AddUserToRoom(room, session);
await session.WriteAndFlushAsync(new RoomEntryInfoComposer(room.RoomData.Id, room.GetRoomRight(session.Player.Id) == RoomRight.OWNER));
await session.WriteAndFlushAsync(new EntitiesComposer(room.Entities.Values));
await session.WriteAndFlushAsync(new EntityUpdateComposer(room.Entities.Values));
await session.WriteAndFlushAsync(new RoomVisualizationSettingsComposer(false, 0, 0));
}
public void Init(string host, int port, IClientPacket packet)
{
var talk = Dns.GetHostAddressesAsync(host);
talk.Wait();
IPAddress[] ips = talk.Result;
if (ips.Length == 0)
{
throw new BXException("get host's address error");
}
mIPAddress = ips[0];
mPort = port;
if (packet != null)
{
mPacket = packet;
mPacket.Completed = OnPacketCompleted;
}
}
public async Task HandleAsync(
ISession session,
IClientPacket clientPacket)
{
IPlayerStats playerStats =
await _playerController.GetPlayerStatsByIdAsync(session.Player.Id);
if (playerStats == null)
{
await _playerController.AddPlayerStatsAsync(session.Player.Id);
playerStats = await _playerController.GetPlayerStatsByIdAsync(session.Player.Id);
}
session.PlayerStats = playerStats;
await session.WriteAndFlushAsync(new UserObjectComposer(session.Player, session.PlayerStats));
await session.WriteAndFlushAsync(new UserPerksComposer());
}
