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()); }