internal override void Read(NetIncomingMessage Message) { Name = Message.ReadString(); if (!Guid.TryParse(Message.ReadString(), out CurrentConfigurationID)) { throw new Exception("Unable to parse GUID for CurrentConfig in server info."); } }
public override void FromNetMsg(NetIncomingMessage netMsg) { // Here we assume that typeID was read before to determine which kind of message it was. m_senderName = netMsg.ReadString(); m_group = netMsg.ReadString(); m_message = netMsg.ReadString(); }
internal override void Read(NetIncomingMessage Message) { base.Read(Message); Language = (CodeLanguage)Enum.Parse(typeof(CodeLanguage), Message.ReadString()); Location = (CodeLocation)Enum.Parse(typeof(CodeLocation), Message.ReadString()); Source = Message.ReadString(); }
/// <summary> /// Reads the transport into the contents of this type. /// </summary> public void ReadPayload(NetIncomingMessage message) { Identity = message.ReadString(); NovaId = message.ReadString(); PasswordHash = message.ReadString(); PublicEndPoint = message.ReadIPEndpoint(); PrivateEndPoint = message.ReadIPEndpoint(); }
public override void onclientrecieve(NetIncomingMessage message) { string id = message.ReadString(); string text = message.ReadString(); Console.WriteLine(text); base.onclientrecieve(message); }
public ConnectionMessage(NetIncomingMessage msg) { string encryptedUsername = msg.ReadString(); string encryptedPassword = msg.ReadString(); byte[] xUsername = Xor(Encoding.UTF8.GetBytes(encryptedUsername), EncryptionKey); byte[] xPassword = Xor(Encoding.UTF8.GetBytes(encryptedPassword), EncryptionKey); Username = Encoding.UTF8.GetChars(xUsername).ToString(); Password = Encoding.UTF8.GetChars(xPassword).ToString(); }
public void Decode(NetIncomingMessage im) { this.Username = im.ReadString(); this.Password = im.ReadString(); this.Color = ColorExtensions.ColorFromHSV(im.ReadInt16(), Client.IO.ColorSaturation / 255f, Client.IO.ColorValue / 255f); if (Username.Length > Settings.MaxNameLength) //Clamp name length Username = Username.Truncate(Settings.MaxNameLength); }
public virtual S2C.Message.NotifySend NotifySend(NetIncomingMessage im) { Message.NotifySend data = new Message.NotifySend(); data.from_id = im.ReadString(); data.message = im.ReadString(); if(OnNotifySend != null) OnNotifySend(im, data); return data; }
public virtual C2S.Message.ReqSend ReqSend(NetIncomingMessage im) { Message.ReqSend data = new Message.ReqSend(); data.to_id = im.ReadString(); data.message = im.ReadString(); if(OnReqSend != null) OnReqSend(im, data); return data; }
public static PlayerInformation Read(NetIncomingMessage packet) { Byte slot = packet.ReadByte(); TeamType team = (TeamType)packet.ReadByte(); String callsign = packet.ReadString(); String tag = packet.ReadString(); return new PlayerInformation(slot, callsign, tag, team); }
public override void onserverrecieve(NetIncomingMessage message) { var chat = PacketWriter.write<Packet_Chat>(NetEndpoint.SERVER); chat.outgoingmessage.Write(message.ReadString()); chat.outgoingmessage.Write(message.ReadString()); chat.send(); base.onserverrecieve(message); }
public virtual S2C.Message.ResSend ResSend(NetIncomingMessage im) { Message.ResSend data = new Message.ResSend(); data.ret = im.ReadInt16(); data.ret_message = im.ReadString(); data.to_id = im.ReadString(); if(OnResSend != null) OnResSend(im, data); return data; }
public override void OnDataReceived(NetIncomingMessage incMsg) { NetDataType type = (NetDataType)incMsg.ReadByte(); if (type == NetDataType.eDATA_REQUEST_LOGIN) { string accountName = incMsg.ReadString(); string password = incMsg.ReadString(); Login(accountName, password, incMsg.SenderConnection); } }
protected void IncomingChangeLevel(NetIncomingMessage msg) { string levelName = msg.ReadString(); string levelData = msg.ReadString(); double delayTime = double.Parse(msg.ReadString()); double recieveTime = msg.ReceiveTime / 1000; double actualDelayTime = delayTime - recieveTime; DownloadLevel(levelName, levelData); OnChangedLevel(levelName, actualDelayTime); }
public void Decode(NetIncomingMessage im) { this.ServerName = im.ReadString(); this.Description = im.ReadString(); this.Intro = im.ReadString(); this.Online = im.ReadByte(); int roomsLength = im.ReadByte(); for (int i = 0; i < roomsLength; i++) { Rooms.Add(new LobbySaveData(im.ReadString(), im.ReadInt16(), im.ReadString(), im.ReadByte(), im.ReadInt16(), im.ReadDouble())); } }
public void PopulateFromMsg(NetIncomingMessage msg) { m_serverName = msg.ReadString(); m_serverType = (NetServerType)msg.ReadByte(); m_serverInternalAdress = msg.ReadIPEndPoint(); m_serverExternalAdress = msg.SenderEndPoint; m_currentNbPlayers = msg.ReadInt32(); m_maxPlayers = msg.ReadInt32(); m_NATtoken = msg.ReadString(); m_lastContact = DateTime.Now; }
// TODO: Merge opcodes for move direction, something like that: Move(LookDirection) void DataProcessing(NetIncomingMessage message, ref Client client) { switch (message.ReadByte()) { case (byte)MessageType.ClientMessage.NeedMap: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Need map ! Let's give it to him :)"); ReceiveNeedMap(client); break; case (byte)MessageType.ClientMessage.MapSelection: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Has selected a map to play ! :)"); ReceiveMapSelection(client, message.ReadString()); break; case (byte)MessageType.ClientMessage.Credentials: ReceiveCredentials(client, message.ReadString(), message.ReadString()); break; case (byte)MessageType.ClientMessage.Ready: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Ready message !"); ReceiveReady(client, message.ReadBoolean()); break; case (byte)MessageType.ClientMessage.WantToStartGame: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] WantToStartGame message !"); ReceiveWantToStartGame(); break; case (byte)MessageType.ClientMessage.HasMap: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] HasMap message !"); ReceiveHasMap(client); break; case (byte)MessageType.ClientMessage.MoveDown: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move down !"); ReceiveMovePlayer(client, LookDirection.Down); break; case (byte)MessageType.ClientMessage.MoveLeft: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move left !"); ReceiveMovePlayer(client, LookDirection.Left); break; case (byte)MessageType.ClientMessage.MoveRight: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move right !"); ReceiveMovePlayer(client, LookDirection.Right); break; case (byte)MessageType.ClientMessage.MoveUp: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move up !"); ReceiveMovePlayer(client, LookDirection.Up); break; case (byte)MessageType.ClientMessage.Standing: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to stay here !"); ReceiveMovePlayer(client, LookDirection.Idle, message.ReadTime(client.ClientConnection, true)); break; case (byte)MessageType.ClientMessage.PlaceBomb: Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to place bomb !"); ReceiveBombPlacing(client); break; } }
public override void onclientrecieve(NetIncomingMessage message) { Client.print("info", "Recieve qb packet"); StopwatchUtil.startclient("qbpacket", "Building qb model"); int junk = message.ReadInt32(); QbModel model = new QbModel(message.ReadString()); int matrixcount = message.ReadInt32(); model.setmatrixcount((uint)matrixcount); foreach (var m in model.matrices) { m.name = message.ReadString(); m.position = new OpenTK.Vector3(message.ReadFloat(), message.ReadFloat(), message.ReadFloat()); m.setsize((int)message.ReadFloat(), (int)message.ReadFloat(), (int)message.ReadFloat()); int colorcount = message.ReadInt32(); for (int i = 0; i < colorcount; i++) { m.GetColorIndex(message.ReadFloat(), message.ReadFloat(), message.ReadFloat()); } int voxelcount = message.ReadInt32(); for (int i = 0; i < voxelcount; i++) { int colorindex = message.ReadInt32(); byte alphamask = message.ReadByte(); int x = message.ReadInt32(); int y = message.ReadInt32(); int z = message.ReadInt32(); m.voxels.GetOrAdd(m.GetHash(x, y, z), new Voxel((short)x, (short)y, (short)z, alphamask, (short)colorindex)); } } Client.OpenGLContextThread.Add(() => { model.GenerateVertexBuffers(); model.FillVertexBuffers(); Singleton<QbManager>.INSTANCE.AddModel(model); StopwatchUtil.stopclient("qbpacket", "End building qb model"); }); base.onclientrecieve(message); }
public void Decode(NetIncomingMessage im) { this.Value = (ResultOfAttack) im.ReadInt32(); this.Text = im.ReadString(); this.Row = im.ReadInt32(); this.Col = im.ReadInt32(); }
public override void Read(NetIncomingMessage msg) { Id = msg.ReadUInt16(); int count = msg.ReadInt32(); for(int i = 0; i < count; ++i) Cards.Add(msg.ReadString()); }
private void ReadData(AttributeTypeID Type, NetIncomingMessage Message) { switch(Type) { case AttributeTypeID.Float: Data = Message.ReadFloat(); break; case AttributeTypeID.Int: Data = Message.ReadInt32(); break; case AttributeTypeID.List: Console.WriteLine("AttributeSystem: List<> Type not supported on network sync"); break; case AttributeTypeID.Long: Data = Message.ReadInt64(); break; case AttributeTypeID.Rectangle: Data = Message.ReadRectangle(); break; case AttributeTypeID.String: Data = Message.ReadString(); break; case AttributeTypeID.Vector2: Data = Message.ReadVector2(); break; case AttributeTypeID.Bool: Data = Message.ReadBoolean(); break; default: Console.WriteLine("Invalid Attribute Type: {0}", Type.ToString()); break; } }
internal void Read(NetIncomingMessage Message) { if (!Guid.TryParse(Message.ReadString(), out TextureID)) { throw new Exception("Failed to parse Guid in FSTextureReference"); } Location = (BlockSide)Message.ReadInt32(); }
public void Read(NetIncomingMessage nim) { if (!Guid.TryParse(nim.ReadString(), out BlockTypeID)) { throw new Exception("Failed to read GUID"); } Level = nim.ReadInt32(); }
protected override void ReadData(NetIncomingMessage Message) { if (!Guid.TryParse(Message.ReadString(), out parent)) { throw new Exception("Failed to pare parent for folder"); } folder.Read(Message); }
protected override void ReadData(NetIncomingMessage Message) { if (!Guid.TryParse(Message.ReadString(), out parent)) { throw new Exception("Could not parse parent guid for block type"); } blockType.Read(Message); }
public void HandleData(NetIncomingMessage msg) { string data = msg.ReadString(); NetCommand[] commands = NetParser.Parse(data); foreach (var command in commands) { switch (command.Type) { case 'a': // Add a new player into the mix break; case 'd': // deletes a player from the mix break; case 'i': // Intention update Players[command.PlayerIndex].Movement.Intention = new Intention(data.Substring(2, 4)); break; case 'r': // Refresh Player string[] bits = command.Value.Split(','); Players[command.PlayerIndex].Movement.Area.X = Int32.Parse(bits[0]); Players[command.PlayerIndex].Movement.Area.Y = Int32.Parse(bits[1]); break; case 'c': // Chat Message break; case 'p': // Pushback break; } } }
public void Decode(NetIncomingMessage im) { this.Username = im.ReadString(); this.ID = im.ReadByte(); this.Me = im.ReadBoolean(); this.Color = new Color(im.ReadByte(), im.ReadByte(), im.ReadByte()); }
public override void onclientrecieve(NetIncomingMessage message) { int matrixid = message.ReadInt32(); string name = message.ReadString(); base.onclientrecieve(message); }
private void Data(NetIncomingMessage inc) { var packetType = (PacketType) inc.ReadByte(); var gameRoom = GetGameRoomById(inc.ReadString()); var command = PacketFactory.GetCommand(packetType); command.Run(_managerLogger, this,inc, null, gameRoom); }
public void Decode(NetIncomingMessage im) { this.ID = im.ReadByte(); this.Message = im.ReadString(); if (Message.Length > Networking.Messages.ChatMessage.MaxLength) Message= Message.Truncate(Networking.Messages.ChatMessage.MaxLength); }
internal void ReceivedHandshake(NetMessageType tp, int ptr, int payloadLength) { m_peer.VerifyNetworkThread(); byte[] hail; switch (tp) { case NetMessageType.Connect: if (m_status == NetConnectionStatus.None) { // Whee! Server full has already been checked bool ok = ValidateHandshakeData(ptr, payloadLength, out hail); if (ok) { if (hail != null) { m_remoteHailMessage = m_peer.CreateIncomingMessage(NetIncomingMessageType.Data, hail); m_remoteHailMessage.LengthBits = (hail.Length * 8); } else { m_remoteHailMessage = null; } if (m_peerConfiguration.IsMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval)) { // ok, let's not add connection just yet NetIncomingMessage appMsg = m_peer.CreateIncomingMessage(NetIncomingMessageType.ConnectionApproval, (m_remoteHailMessage == null ? 0 : m_remoteHailMessage.LengthBytes)); appMsg.m_senderConnection = this; appMsg.m_senderEndpoint = this.m_remoteEndpoint; if (m_remoteHailMessage != null) { appMsg.Write(m_remoteHailMessage.m_data, 0, m_remoteHailMessage.LengthBytes); } m_peer.ReleaseMessage(appMsg); return; } SendConnectResponse(true); } return; } if (m_status == NetConnectionStatus.RespondedConnect) { // our ConnectResponse must have been lost SendConnectResponse(true); return; } m_peer.LogDebug("Unhandled Connect: " + tp + ", status is " + m_status + " length: " + payloadLength); break; case NetMessageType.ConnectResponse: switch (m_status) { case NetConnectionStatus.InitiatedConnect: // awesome bool ok = ValidateHandshakeData(ptr, payloadLength, out hail); if (ok) { if (hail != null) { m_remoteHailMessage = m_peer.CreateIncomingMessage(NetIncomingMessageType.Data, hail); m_remoteHailMessage.LengthBits = (hail.Length * 8); } else { m_remoteHailMessage = null; } m_peer.AcceptConnection(this); SendConnectionEstablished(); return; } break; case NetConnectionStatus.RespondedConnect: // hello, wtf? break; case NetConnectionStatus.Disconnecting: case NetConnectionStatus.Disconnected: case NetConnectionStatus.None: // wtf? anyway, bye! break; case NetConnectionStatus.Connected: // my ConnectionEstablished must have been lost, send another one SendConnectionEstablished(); return; } break; case NetMessageType.ConnectionEstablished: switch (m_status) { case NetConnectionStatus.Connected: // ok... break; case NetConnectionStatus.Disconnected: case NetConnectionStatus.Disconnecting: case NetConnectionStatus.None: // too bad, almost made it break; case NetConnectionStatus.InitiatedConnect: // weird, should have been ConnectResponse... break; case NetConnectionStatus.RespondedConnect: // awesome m_peer.AcceptConnection(this); InitializePing(); SetStatus(NetConnectionStatus.Connected, "Connected to " + NetUtility.ToHexString(m_remoteUniqueIdentifier)); return; } break; case NetMessageType.Disconnect: // ouch string reason = "Ouch"; try { NetIncomingMessage inc = m_peer.SetupReadHelperMessage(ptr, payloadLength); reason = inc.ReadString(); } catch { } SetStatus(NetConnectionStatus.Disconnected, reason); break; default: m_peer.LogDebug("Unhandled type during handshake: " + tp + " length: " + payloadLength); break; } }
internal void ReceivedHandshake(double now, NetMessageType tp, int ptr, int payloadLength) { m_peer.VerifyNetworkThread(); byte[] hail; switch (tp) { case NetMessageType.Connect: if (m_status == NetConnectionStatus.ReceivedInitiation) { // Whee! Server full has already been checked bool ok = ValidateHandshakeData(ptr, payloadLength, out hail); if (ok) { if (hail != null) { m_remoteHailMessage = m_peer.CreateIncomingMessage(NetIncomingMessageType.Data, hail); m_remoteHailMessage.LengthBits = (hail.Length * 8); } else { m_remoteHailMessage = null; } if (m_peerConfiguration.IsMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval)) { // ok, let's not add connection just yet NetIncomingMessage appMsg = m_peer.CreateIncomingMessage(NetIncomingMessageType.ConnectionApproval, (m_remoteHailMessage == null ? 0 : m_remoteHailMessage.LengthBytes)); appMsg.m_receiveTime = now; appMsg.m_senderConnection = this; appMsg.m_senderEndPoint = this.m_remoteEndPoint; if (m_remoteHailMessage != null) { appMsg.Write(m_remoteHailMessage.m_data, 0, m_remoteHailMessage.LengthBytes); } SetStatus(NetConnectionStatus.RespondedAwaitingApproval, "Awaiting approval"); m_peer.ReleaseMessage(appMsg); return; } SendConnectResponse((float)now, true); } return; } if (m_status == NetConnectionStatus.RespondedAwaitingApproval) { m_peer.LogWarning("Ignoring multiple Connect() most likely due to a delayed Approval"); return; } if (m_status == NetConnectionStatus.RespondedConnect) { // our ConnectResponse must have been lost SendConnectResponse((float)now, true); return; } m_peer.LogDebug("Unhandled Connect: " + tp + ", status is " + m_status + " length: " + payloadLength); break; case NetMessageType.ConnectResponse: HandleConnectResponse(now, tp, ptr, payloadLength); break; case NetMessageType.ConnectionEstablished: switch (m_status) { case NetConnectionStatus.Connected: // ok... break; case NetConnectionStatus.Disconnected: case NetConnectionStatus.Disconnecting: case NetConnectionStatus.None: // too bad, almost made it break; case NetConnectionStatus.ReceivedInitiation: // uh, a little premature... ignore break; case NetConnectionStatus.InitiatedConnect: // weird, should have been RespondedConnect... break; case NetConnectionStatus.RespondedConnect: // awesome NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength); InitializeRemoteTimeOffset(msg.ReadSingle()); m_peer.AcceptConnection(this); InitializePing(); SetStatus(NetConnectionStatus.Connected, "Connected to " + NetUtility.ToHexString(m_remoteUniqueIdentifier)); return; } break; case NetMessageType.Disconnect: // ouch string reason = "Ouch"; try { NetIncomingMessage inc = m_peer.SetupReadHelperMessage(ptr, payloadLength); reason = inc.ReadString(); } catch { } ExecuteDisconnect(reason, false); break; case NetMessageType.Discovery: m_peer.HandleIncomingDiscoveryRequest(now, m_remoteEndPoint, ptr, payloadLength); return; case NetMessageType.DiscoveryResponse: m_peer.HandleIncomingDiscoveryResponse(now, m_remoteEndPoint, ptr, payloadLength); return; case NetMessageType.Ping: // silently ignore return; default: m_peer.LogDebug("Unhandled type during handshake: " + tp + " length: " + payloadLength); break; } }
// received a library message while Connected internal void ReceivedLibraryMessage(NetMessageType tp, int ptr, int payloadLength) { double now = NetTime.Now; switch (tp) { case NetMessageType.Connect: m_peer.LogDebug("Received handshake message (" + tp + ") despite connection being in place"); break; case NetMessageType.ConnectResponse: // handshake message must have been lost HandleConnectResponse(now, tp, ptr, payloadLength); break; case NetMessageType.ConnectionEstablished: // do nothing, all's well break; case NetMessageType.LibraryError: m_peer.ThrowOrLog("LibraryError received by ReceivedLibraryMessage; this usually indicates a malformed message"); break; case NetMessageType.Disconnect: NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength); m_disconnectRequested = true; m_disconnectMessage = msg.ReadString(); m_disconnectReqSendBye = false; //ExecuteDisconnect(msg.ReadString(), false); break; case NetMessageType.Acknowledge: for (int i = 0; i < payloadLength; i += 3) { NetMessageType acktp = (NetMessageType)m_peer.m_receiveBuffer[ptr++]; // netmessagetype int seqNr = m_peer.m_receiveBuffer[ptr++]; seqNr |= (m_peer.m_receiveBuffer[ptr++] << 8); // need to enqueue this and handle it in the netconnection heartbeat; so be able to send resends together with normal sends m_queuedIncomingAcks.Enqueue(new NetTuple <NetMessageType, int>(acktp, seqNr)); } break; case NetMessageType.Ping: int pingNr = m_peer.m_receiveBuffer[ptr++]; SendPong(pingNr); break; case NetMessageType.Pong: NetIncomingMessage pmsg = m_peer.SetupReadHelperMessage(ptr, payloadLength); int pongNr = pmsg.ReadByte(); float remoteSendTime = pmsg.ReadSingle(); ReceivedPong(now, pongNr, remoteSendTime); break; case NetMessageType.ExpandMTURequest: SendMTUSuccess(payloadLength); break; case NetMessageType.ExpandMTUSuccess: if (m_peer.Configuration.AutoExpandMTU == false) { m_peer.LogDebug("Received ExpandMTURequest altho AutoExpandMTU is turned off!"); break; } NetIncomingMessage emsg = m_peer.SetupReadHelperMessage(ptr, payloadLength); int size = emsg.ReadInt32(); HandleExpandMTUSuccess(now, size); break; case NetMessageType.NatIntroduction: // Unusual situation where server is actually already known, but got a nat introduction - oh well, lets handle it as usual m_peer.HandleNatIntroduction(ptr); break; default: m_peer.LogWarning("Connection received unhandled library message: " + tp); break; } }
// received a library message while Connected internal void ReceivedLibraryMessage(NetMessageType tp, int ptr, int payloadLength) { m_peer.VerifyNetworkThread(); float now = (float)NetTime.Now; switch (tp) { case NetMessageType.Disconnect: NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength); ExecuteDisconnect(msg.ReadString(), false); break; case NetMessageType.Acknowledge: for (int i = 0; i < payloadLength; i += 3) { NetMessageType acktp = (NetMessageType)m_peer.m_receiveBuffer[ptr++]; // netmessagetype int seqNr = m_peer.m_receiveBuffer[ptr++]; seqNr |= (m_peer.m_receiveBuffer[ptr++] << 8); // need to enqueue this and handle it in the netconnection heartbeat; so be able to send resends together with normal sends m_queuedIncomingAcks.Enqueue(new NetTuple <NetMessageType, int>(acktp, seqNr)); } break; case NetMessageType.Ping: int pingNr = m_peer.m_receiveBuffer[ptr++]; SendPong(pingNr); break; case NetMessageType.Pong: NetIncomingMessage pmsg = m_peer.SetupReadHelperMessage(ptr, payloadLength); int pongNr = pmsg.ReadByte(); float remoteSendTime = pmsg.ReadSingle(); ReceivedPong(now, pongNr, remoteSendTime); break; case NetMessageType.ExpandMTURequest: SendMTUSuccess(payloadLength); break; case NetMessageType.ExpandMTUSuccess: NetIncomingMessage emsg = m_peer.SetupReadHelperMessage(ptr, payloadLength); int size = emsg.ReadInt32(); HandleExpandMTUSuccess(now, size); break; case NetMessageType.NatIntroduction: // Unusual situation where server is actually already known, but got a nat introduction - oh well, lets handle it as usual m_peer.HandleNatIntroduction(ptr); break; case NetMessageType.ConnectResponse: // Lidgren bug fix -AR // ConnectionEstablished (from handshake) must have been lost, send another one m_peer.LogDebug("Resending ConnectionEstablished..."); SendConnectionEstablished(); break; default: m_peer.LogWarning("Connection received unhandled library message: " + tp); break; } }