internal sealed override void Deserialize(byte[] buffer) { using (var packetWriter = ByteArrayReaderWriter.Get(buffer)) { Action = packetWriter.ReadByte(); var haveSendTime = packetWriter.ReadByte(); var havePayload = packetWriter.ReadByte(); if (havePayload == 0x1) { _payloadLen = packetWriter.ReadUInt16(); } SendType = (GProtocolSendType)packetWriter.ReadByte(); Hash = (long)packetWriter.ReadUInt64(); if (havePayload == 0x1) { Payload = packetWriter.ReadBytes(_payloadLen); } if (haveSendTime == 0x1) { ClientSendTime = packetWriter.ReadInt64(); } } }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { var memberId = GetStringFromBuffer(packet.Payload); RealTimeEventHandlers.MemberId?.Invoke(this, memberId); RealTimeEventHandlers.Authorized?.Invoke(this, packet.Hash); }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { try { var dataPayload = new DataPayload(packet.Payload); RealTimeEventHandlers.NewMessageReceived?.Invoke(this, new MessageReceiveEvent { MessageInfo = new MessageInfo { MessageType = MessageType.Public, SendType = type, ClientReceiveTime = packet.ClientReceiveTime }, Message = new Message { Data = dataPayload.Payload, ReceiverId = dataPayload.ReceiverId, SenderId = dataPayload.SenderId } }); } catch (Exception e) { e.LogException <PublicMessageResponseHandler>(DebugLocation.RealTime, "HandleResponse"); } }
public Packet(long hash, int action, GProtocolSendType sendType = GProtocolSendType.UnReliable, byte[] payload = null) { Hash = hash; Action = action; Payload = payload; SendType = sendType; }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { var member = JsonConvert.DeserializeObject <Member>(GetStringFromBuffer(packet.Payload)); RealTimeEventHandlers.LeftRoom?.Invoke(this, member); if (member.User.IsMe) { RealTimeEventHandlers.LeftDispose?.Invoke(this, null); } }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { var joinData = JsonConvert.DeserializeObject <JoinData>(GetStringFromBuffer(packet.Payload)); RealTimeEventHandlers.JoinedRoom?.Invoke(this, new JoinEvent { Type = GSLiveType.RealTime, JoinData = joinData }); }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { if (GsLiveRealTime.InAutoMatch) { GsLiveRealTime.InAutoMatch = false; } CoreEventHandlers.Error?.Invoke(this, new ErrorEvent { Type = GSLiveType.RealTime, Error = GetStringFromBuffer(packet.Payload) }); }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { try { var dataPayload = new DataPayload(packet.Payload); var shotsFromBuffer = GsSerializer.Object.GetSnapShotsFromBuffer(dataPayload.Payload); GsSerializer.OnNewSnapShotReceived?.Invoke(this, shotsFromBuffer); } catch (Exception e) { e.LogException <SnapShotResponseHandler>(DebugLocation.RealTime, "HandleResponse"); } }
internal override void Send(Packet packet, GProtocolSendType type, bool canSendBigSize = false, bool isCritical = false, bool isEvent = false) { try { if (IsConnected()) { packet.SendType = type; var buffer = PacketSerializable.Serialize(packet, null, false); if (!canSendBigSize && !PacketUtil.CheckPacketSize(buffer)) { throw new GameServiceException("this Packet Is Too Big!,Max Packet Size is " + RealTimeConst.MaxPacketSize + " bytes.") .LogException <GsUdpClient>(DebugLocation.RealTime, "Send"); } switch (type) { case GProtocolSendType.UnReliable: Client?.SendUnReliable(buffer); break; case GProtocolSendType.Reliable: if (isCritical) { Client?.SendCommand(buffer); } else { Client?.SendReliable(buffer, isEvent); } break; default: throw new ArgumentOutOfRangeException(nameof(type), type, null); } } else { DebugUtil.LogError <GsUdpClient>(DebugLocation.RealTime, "Send", "Client not Connected!"); } } catch (Exception e) { e.LogException <GsUdpClient>(DebugLocation.RealTime, "Send"); } }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { try { var dataPayload = new DataPayload(packet.Payload); GsSerializer.OnNewEventHandler?.Invoke(this, new EventData { Caller = dataPayload.ExtraData, Data = dataPayload.Payload, SenderId = dataPayload.SenderId, ReceiverId = dataPayload.ReceiverId }); } catch (Exception e) { e.LogException <NewEventResponseHandler>(DebugLocation.RealTime, "HandleResponse"); } }
private void Send(Packet packet, GProtocolSendType type, bool isCritical = false, bool canSendBigSize = false, bool isEvent = false) { if (!_observer.Increase(isCritical)) { throw new GameServiceException("Too Many Requests, You Can Send " + RealTimeConst.RealTimeSendLimit + " Requests Per Second") .LogException <RealTimeHandler>(DebugLocation.RealTime, "Send"); } if (IsAvailable(isCritical)) { _connGateway.Send(packet, type, canSendBigSize, isCritical, isEvent); } else if (!isCritical) { throw new GameServiceException("GameService Not Available") .LogException <RealTimeHandler>(DebugLocation.RealTime, "Send"); } }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { var dataPayload = new DataPayload(packet.Payload); RealTimeEventHandlers.NewMessageReceived?.Invoke(this, new MessageReceiveEvent { MessageInfo = new MessageInfo { MessageType = MessageType.Private, SendType = type, ClientReceiveTime = packet.ClientReceiveTime }, Message = new Message { Data = dataPayload.Payload, ReceiverId = dataPayload.ReceiverId, SenderId = dataPayload.SenderId } }); }
public override void SendPublicMessage(byte[] data, GProtocolSendType sendType) { if (GameService.IsGuest) { throw new GameServiceException("This Function Not Working In Guest Mode").LogException <GsLiveRealTime>( DebugLocation.RealTime, "SendPublicMessage"); } if (data == null) { throw new GameServiceException("data Cant Be Null").LogException <GsLiveRealTime>(DebugLocation.RealTime, "SendPublicMessage"); } if (GameService.GSLive.GetGsHandler().RealTimeHandler == null) { throw new GameServiceException("You Must Create or Join Room First").LogException <GsLiveRealTime>( DebugLocation.RealTime, "SendPublicMessage"); } GameService.GSLive.GetGsHandler().RealTimeHandler.Request(SendPublicMessageHandler.Signature, sendType, new DataPayload { Payload = data }); }
internal override void SendEvent(byte[] caller, byte[] data, GProtocolSendType sendType) { if (GameService.IsGuest) { throw new GameServiceException("This Function Not Working In Guest Mode").LogException <GsLiveRealTime>( DebugLocation.RealTime, "SendEvent"); } if (caller == null || data == null) { throw new GameServiceException("caller or data Cant Be Null").LogException <GsLiveRealTime>( DebugLocation.RealTime, "SendEvent"); } if (GameService.GSLive.GetGsHandler().RealTimeHandler == null) { throw new GameServiceException("You Must Create or Join Room First").LogException <GsLiveRealTime>( DebugLocation.RealTime, "SendEvent"); } GameService.GSLive.GetGsHandler().RealTimeHandler.Request(NewEventHandler.Signature, sendType, new DataPayload { Payload = data, ExtraData = caller }, false, true, true); }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { try { var(ownerId, payloads) = GsSerializer.Object.GetObserver(packet.Payload); while (payloads.Count > 0) { var dataPayload = new DataPayload(payloads.Dequeue()); GsSerializer.OnNewEventHandler?.Invoke(this, new EventData { Caller = dataPayload.ExtraData, Data = dataPayload.Payload, SenderId = ownerId }); } } catch (Exception e) { e.LogException <ObserverResponseHandler>(DebugLocation.RealTime, "HandleResponse"); } }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { var roomData = JsonConvert.DeserializeObject <RoomData>(GetStringFromBuffer(packet.Payload)); RealTimeEventHandlers.CurrentRoomInfoReceived?.Invoke(this, roomData); }
internal void Request(string handlerName, GProtocolSendType type, object payload = null, bool isCritical = false, bool canSendBigSize = false, bool isEvent = false) { Send(_requestHandlers[handlerName]?.HandleAction(payload), type, isCritical, canSendBigSize, isEvent); }
protected abstract void HandleResponse(Packet packet, GProtocolSendType type);
public virtual void HandlePacket(Packet packet, GProtocolSendType type) { HandleResponse(packet, type); }
internal abstract void Send(Packet packet, GProtocolSendType type, bool canSendBigSize = false, bool isCritical = false, bool isEvent = false);
protected override void HandleResponse(Packet packet, GProtocolSendType type) { var peerConfig = JsonConvert.DeserializeObject <PeerConfig>(GetStringFromBuffer(packet.Payload)); RealTimeEventHandlers.PeerConfig?.Invoke(this, peerConfig); }
internal abstract void SendEvent(byte[] caller, byte[] data, GProtocolSendType sendType);
/// <summary> /// Send A Data To All Players in Room. /// </summary> /// <param name="data">(NOTNULL) Data To BroadCast </param> /// <param name="sendType">Send Type </param> public abstract void SendPublicMessage(byte[] data, GProtocolSendType sendType);
protected override void HandleResponse(Packet packet, GProtocolSendType type) { RealTimeEventHandlers.MemberConnectionStateChanged?.Invoke(this, JsonConvert.DeserializeObject <MemberConnectionState>(GetStringFromBuffer(packet.Payload))); }
protected override void HandleResponse(Packet packet, GProtocolSendType type) { RealTimeEventHandlers.RoomMembersDetailReceived?.Invoke(this, JsonConvert.DeserializeObject <List <Member> >(GetStringFromBuffer(packet.Payload))); }