public Write ( |
||
endPoint | ||
return | void |
public void Write(NetBuffer om) { if (MetaData == null) MetaData = "Null"; om.Write(MetaData); om.Write(Data.Length); om.Write(Data); }
internal void DoSendDiscoveryRequest( IPEndPoint endPoint, bool useBroadcast, NetDiscoveryRequest request, float interval, float timeout) { if (!m_netBase.m_isBound) m_netBase.Start(); if (request == null) { m_netBase.LogVerbose("Creating discovery request " + m_nextRequestNumber); request = new NetDiscoveryRequest(endPoint, m_nextRequestNumber++, useBroadcast, interval, timeout); if (m_requests == null) m_requests = new List<NetDiscoveryRequest>(); m_requests.Add(request); } string appIdent = m_netBase.m_config.ApplicationIdentifier; NetBuffer data = new NetBuffer(appIdent.Length + 8); // write app identifier data.Write(appIdent); // write netbase identifier to avoid self-discovery data.Write(m_netBase.m_randomIdentifier); // write request number data.Write((ushort)request.Number); m_netBase.LogWrite("Discovering " + endPoint.ToString() + "..."); m_netBase.QueueSingleUnreliableSystemMessage(NetSystemType.Discovery, data, endPoint, useBroadcast); }
public override void Write(NetBuffer om) { base.Write(om); om.Write(FollowerId.Count); foreach(var obj in FollowerId) { om.Write(obj); } }
public void Write(NetBuffer om) { if (Address == null) Address = string.Empty; if (ConnectName == null) ConnectName = string.Empty; if (Information == null) ConnectName = string.Empty; om.Write(Address); om.Write(ConnectName); om.Write(Information); }
public override void Write(NetBuffer om) { base.Write(om); om.Write(Followers.Count); foreach(var obj in Followers) { om.Write(obj.Key); om.Write(obj.Value); } }
public void Write(NetBuffer om) { om.Write(MessagePacketId); om.Write(Number); if (Bytes != null) { om.Write(Bytes.Length); om.Write(Bytes); } else { om.Write(0); } }
public void Write(NetBuffer om) { if(Plugins != null) { om.Write(Plugins.Count); foreach (var obj in Plugins) { om.Write(obj); } } else { om.Write(0); } }
internal void Encode(NetBuffer intoBuffer) { Debug.Assert(m_sequenceNumber != -1); // message type, netchannel and sequence number intoBuffer.Write((byte)((int)m_type | ((int)m_sequenceChannel << 3))); intoBuffer.Write((ushort)m_sequenceNumber); // payload length int len = m_data.LengthBytes; intoBuffer.WriteVariableUInt32((uint)len); // copy payload intoBuffer.Write(m_data.Data, 0, len); return; }
internal void WriteStringTable(NetBuffer buffer, string str) { // Bits: // 0: Does the actual string follows? (if so, send confirmation) // 1: Is the value contained in the following 6 bits ONLY? (false = use one more byte for 14 bits total) // 2-7: value // 8-15: (possibly) value int val; if (!m_stringTable.TryGetValue(str, out val)) { // new value val = m_stringTable.Count; if (val >= c_maxTabledStrings) { val = 0; } else { m_stringTableLookUp[val] = str; val |= (1 << 16); // 1 means not acknowledged yet m_stringTable[str] = val; } } // is it known at destination? bool known = (val < (1 << 16)); ushort actualVal = (ushort)val; buffer.Write(known); if (actualVal < 64) { buffer.Write(false); buffer.Write(actualVal, 6); } else { buffer.Write(true); buffer.Write(actualVal, 6 + 8); } if (!known) buffer.Write(str); }
public void HandlesAllItemsOnTheMessage() { var msg = new Message() { Items = { new Item() { Type = ItemType.SuccessfulJoin, Data = 143 }, new Item() { Type = ItemType.NewClient, Data = 3 }, new Item() { Type = ItemType.Player, Data = new Frenetic.Player.PlayerState() } } }; NetBuffer buffer = new NetBuffer(); buffer.Write(msg); stubNetClient.Stub(me => me.CreateBuffer()).Return(buffer); stubNetClient.Stub(me => me.ReadMessage(Arg<NetBuffer>.Is.Equal(buffer), out Arg<NetMessageType>.Out(NetMessageType.Data).Dummy)).Return(true); clientNetworkSession.ClientJoined += delegate { }; var unprocessedMsg = clientNetworkSession.ReadNextMessage(); Assert.AreEqual(1, unprocessedMsg.Items.Count); Assert.AreEqual(ItemType.Player, unprocessedMsg.Items[0].Type); }
public NetBuffer ToBuffer() { if(IsComplete) { var Buffer = new NetBuffer(); var t = from p in PacketList orderby p.Number select p; foreach(var obj in t) { Buffer.Write(obj.Bytes); } return Buffer; } return null; }
public void ServerReceivesDataFromClientAndCreatesMessage() { NetBuffer tmpBuffer = new NetBuffer(); tmpBuffer.Write(new Message() { Items = { new Item() { Type = ItemType.NewClient, Data = 10 } } }); stubNetServer.Stub(x => x.CreateBuffer()).Return(tmpBuffer); stubNetServer.Stub(x => x.ReadMessage(Arg<NetBuffer>.Is.Anything, out Arg<NetMessageType>.Out(NetMessageType.Data).Dummy, out Arg<INetConnection>.Out(stubNetConnection).Dummy)) .Return(true); Message msg = serverNetworkSession.ReadNextMessage(); stubNetServer.AssertWasCalled(x => x.ReadMessage(Arg<NetBuffer>.Is.Equal(tmpBuffer), out Arg<NetMessageType>.Out(NetMessageType.Data).Dummy, out Arg<INetConnection>.Out(stubNetConnection).Dummy)); Assert.AreEqual(ItemType.NewClient, msg.Items[0].Type); Assert.AreEqual(10, msg.Items[0].Data); }
internal string ReadStringTable(NetBuffer buffer) { byte b = buffer.ReadByte(); bool stringFollows = ((b & 1) == 0); bool shortVal = ((b & 2) == 0); int val = 0; if (shortVal) val = b >> 2; else val = ((b & (255 << 2)) << 6) | buffer.ReadByte(); string retval = string.Empty; if (stringFollows) { retval = buffer.ReadString(); m_stringTable[retval] = val; m_stringTableLookUp[val] = retval; // // Send confirmation // NetBuffer buf = new NetBuffer(2); buf.Write((ushort)val); m_owner.QueueSingleUnreliableSystemMessage( NetSystemType.StringTableAck, buf, m_remoteEndPoint, false ); return retval; } if (!m_stringTableLookUp.TryGetValue(val, out retval)) { // Ack! Failed to find string table value! throw new Exception("ACK!"); } return retval; }
public void Write(NetBuffer om) { om.Write(PluginName); om.Write(MethodName); om.Write(RspType); if (RspType == StringDataType) { om.Write(StringCommandRsp); } else if (RspType == BinaryDataType) { om.Write(BinaryCommandRsp.Length); om.Write(BinaryCommandRsp); } }
static unsafe void Main(string[] args) { // JIT stuff NetBuffer msg = new NetBuffer(20); msg.Write((short)short.MaxValue); // Go double timeStart = NetTime.Now; msg = new NetBuffer(20); for (int n = 0; n < 10000; n++) { msg.Reset(); msg.Write((short)short.MaxValue); msg.Write((short)short.MinValue); msg.Write((short)-42); msg.Write(421); msg.Write((byte)7); msg.Write(-42.8f); if (msg.LengthBytes != 15) throw new Exception("Bad message length"); msg.Write("duke of earl"); int bytesWritten; bytesWritten = msg.WriteVariableInt32(-1); bytesWritten = msg.WriteVariableInt32(5); bytesWritten = msg.WriteVariableInt32(-18); bytesWritten = msg.WriteVariableInt32(42); bytesWritten = msg.WriteVariableInt32(-420); msg.Write((uint)9991); // byte boundary kept until here msg.Write(true); msg.Write((uint)3, 5); msg.Write(8.111f); msg.Write("again"); byte[] arr = new byte[] { 1, 6, 12, 24 }; msg.Write(arr); msg.Write((byte)7, 7); msg.Write(Int32.MinValue); msg.Write(UInt32.MaxValue); msg.WriteRangedSingle(21.0f, -10, 50, 12); // test reduced bit signed writing msg.Write(15, 5); msg.Write(2, 5); msg.Write(0, 5); msg.Write(-1, 5); msg.Write(-2, 5); msg.Write(-15, 5); msg.Write(UInt64.MaxValue); msg.Write(Int64.MaxValue); msg.Write(Int64.MinValue); msg.Write(42); msg.WritePadBits(); int numBits = msg.WriteRangedInteger(0, 10, 5); if (numBits != 4) throw new Exception("Ack WriteRangedInteger failed"); // verify msg.Position = 0; short a = msg.ReadInt16(); short b = msg.ReadInt16(); short c = msg.ReadInt16(); if (a != short.MaxValue || b != short.MinValue || c != -42) throw new Exception("Ack thpth short failed"); if (msg.ReadInt32() != 421) throw new Exception("Ack thphth 1"); if (msg.ReadByte() != (byte)7) throw new Exception("Ack thphth 2"); if (msg.ReadSingle() != -42.8f) throw new Exception("Ack thphth 3"); if (msg.ReadString() != "duke of earl") throw new Exception("Ack thphth 4"); if (msg.ReadVariableInt32() != -1) throw new Exception("ReadVariableInt32 failed 1"); if (msg.ReadVariableInt32() != 5) throw new Exception("ReadVariableInt32 failed 2"); if (msg.ReadVariableInt32() != -18) throw new Exception("ReadVariableInt32 failed 3"); if (msg.ReadVariableInt32() != 42) throw new Exception("ReadVariableInt32 failed 4"); if (msg.ReadVariableInt32() != -420) throw new Exception("ReadVariableInt32 failed 5"); if (msg.ReadUInt32() != 9991) throw new Exception("Ack thphth 4.5"); if (msg.ReadBoolean() != true) throw new Exception("Ack thphth 5"); if (msg.ReadUInt32(5) != (uint)3) throw new Exception("Ack thphth 6"); if (msg.ReadSingle() != 8.111f) throw new Exception("Ack thphth 7"); if (msg.ReadString() != "again") throw new Exception("Ack thphth 8"); byte[] rrr = msg.ReadBytes(4); if (rrr[0] != arr[0] || rrr[1] != arr[1] || rrr[2] != arr[2] || rrr[3] != arr[3]) throw new Exception("Ack thphth 9"); if (msg.ReadByte(7) != 7) throw new Exception("Ack thphth 10"); if (msg.ReadInt32() != Int32.MinValue) throw new Exception("Ack thphth 11"); if (msg.ReadUInt32() != UInt32.MaxValue) throw new Exception("Ack thphth 12"); float v = msg.ReadRangedSingle(-10, 50, 12); // v should be close to, but not necessarily exactly, 21.0f if ((float)Math.Abs(21.0f - v) > 0.1f) throw new Exception("Ack thphth *RangedSingle() failed"); if (msg.ReadInt32(5) != 15) throw new Exception("Ack thphth ReadInt32 1"); if (msg.ReadInt32(5) != 2) throw new Exception("Ack thphth ReadInt32 2"); if (msg.ReadInt32(5) != 0) throw new Exception("Ack thphth ReadInt32 3"); if (msg.ReadInt32(5) != -1) throw new Exception("Ack thphth ReadInt32 4"); if (msg.ReadInt32(5) != -2) throw new Exception("Ack thphth ReadInt32 5"); if (msg.ReadInt32(5) != -15) throw new Exception("Ack thphth ReadInt32 6"); UInt64 longVal = msg.ReadUInt64(); if (longVal != UInt64.MaxValue) throw new Exception("Ack thphth UInt64"); if (msg.ReadInt64() != Int64.MaxValue) throw new Exception("Ack thphth Int64"); if (msg.ReadInt64() != Int64.MinValue) throw new Exception("Ack thphth Int64"); if (msg.ReadInt32() != 42) throw new Exception("Ack thphth end"); msg.SkipPadBits(); if (msg.ReadRangedInteger(0, 10) != 5) throw new Exception("Ack thphth ranged integer"); } // test writevariableuint64 NetBuffer largeBuffer = new NetBuffer(100 * 8); UInt64[] largeNumbers = new ulong[100]; for (int i = 0; i < 100; i++) { largeNumbers[i] = ((ulong)NetRandom.Instance.NextUInt() << 32) | (ulong)NetRandom.Instance.NextUInt(); largeBuffer.WriteVariableUInt64(largeNumbers[i]); } largeBuffer.Position = 0; for (int i = 0; i < 100; i++) { UInt64 ln = largeBuffer.ReadVariableUInt64(); if (ln != largeNumbers[i]) throw new Exception("large fail"); } // // Extended tests on padbits // for (int i = 1; i < 31; i++) { NetBuffer buf = new NetBuffer(); buf.Write((int)1, i); if (buf.LengthBits != i) throw new Exception("Bad length!"); buf.WritePadBits(); int wholeBytes = buf.LengthBits / 8; if (wholeBytes * 8 != buf.LengthBits) throw new Exception("WritePadBits failed! Length is " + buf.LengthBits); } NetBuffer small = new NetBuffer(100); byte[] rnd = new byte[24]; int[] bits = new int[24]; for (int i = 0; i < 24; i++) { rnd[i] = (byte)NetRandom.Instance.Next(0, 65); bits[i] = NetUtility.BitsToHoldUInt((uint)rnd[i]); small.Write(rnd[i], bits[i]); } small.Position = 0; for (int i = 0; i < 24; i++) { byte got = small.ReadByte(bits[i]); if (got != rnd[i]) throw new Exception("Failed small allocation test"); } double timeEnd = NetTime.Now; double timeSpan = timeEnd - timeStart; Console.WriteLine("Trivial tests passed in " + (timeSpan * 1000.0) + " milliseconds"); Console.WriteLine("Creating client and server for live testing..."); NetConfiguration config = new NetConfiguration("unittest"); config.Port = 14242; NetServer server = new NetServer(config); NetBuffer serverBuffer = new NetBuffer(); server.Start(); config = new NetConfiguration("unittest"); NetClient client = new NetClient(config); client.SetMessageTypeEnabled(NetMessageType.Receipt, true); NetBuffer clientBuffer = client.CreateBuffer(); client.Start(); client.Connect("127.0.0.1", 14242); List<string> events = new List<string>(); double end = double.MaxValue; double disconnect = double.MaxValue; while (NetTime.Now < end) { double now = NetTime.Now; NetMessageType nmt; NetConnection sender; // // client // if (client.ReadMessage(clientBuffer, out nmt)) { switch (nmt) { case NetMessageType.StatusChanged: Console.WriteLine("Client: " + client.Status + " (" + clientBuffer.ReadString() + ")"); events.Add("CStatus " + client.Status); if (client.Status == NetConnectionStatus.Connected) { // send reliable message NetBuffer buf = client.CreateBuffer(); buf.Write(true); buf.Write((int)52, 7); buf.Write("Hallon"); client.SendMessage(buf, NetChannel.ReliableInOrder1, new NetBuffer("kokos")); } if (client.Status == NetConnectionStatus.Disconnected) end = NetTime.Now + 1.0; // end in one second break; case NetMessageType.Receipt: events.Add("CReceipt " + clientBuffer.ReadString()); break; case NetMessageType.ConnectionRejected: case NetMessageType.BadMessageReceived: throw new Exception("Failed: " + nmt); case NetMessageType.DebugMessage: // silently ignore break; default: // ignore Console.WriteLine("Ignored: " + nmt); break; } } // // server // if (server.ReadMessage(serverBuffer, out nmt, out sender)) { switch (nmt) { case NetMessageType.StatusChanged: events.Add("SStatus " + sender.Status); Console.WriteLine("Server: " + sender.Status + " (" + serverBuffer.ReadString() + ")"); break; case NetMessageType.ConnectionRejected: case NetMessageType.BadMessageReceived: throw new Exception("Failed: " + nmt); case NetMessageType.Data: events.Add("DataRec " + serverBuffer.LengthBits); bool shouldBeTrue = serverBuffer.ReadBoolean(); int shouldBeFifthTwo = serverBuffer.ReadInt32(7); string shouldBeHallon = serverBuffer.ReadString(); if (shouldBeTrue != true || shouldBeFifthTwo != 52 || shouldBeHallon != "Hallon") throw new Exception("Bad data transmission"); disconnect = now + 1.0; break; case NetMessageType.DebugMessage: // silently ignore break; default: // ignore Console.WriteLine("Ignored: " + nmt); break; } } if (now > disconnect) { server.Connections[0].Disconnect("Bye", 0.1f); disconnect = double.MaxValue; } } // verify events string[] expected = new string[] { "CStatus Connecting", "SStatus Connecting", "CStatus Connected", "SStatus Connected", "DataRec 64", "CReceipt kokos", "SStatus Disconnecting", "CStatus Disconnecting", "SStatus Disconnected", "CStatus Disconnected" }; if (events.Count != expected.Length) throw new Exception("Mismatch in events count! Expected " + expected.Length + ", got " + events.Count); for(int i=0;i<expected.Length;i++) { if (events[i] != expected[i]) throw new Exception("Event " + i + " (" + expected[i] + ") mismatched!"); } Console.WriteLine("All tests successful"); Console.ReadKey(); server.Shutdown("App exiting"); client.Shutdown("App exiting"); }
public static void Main(string[] args) { setupNetwork(); // create a buffer to read data into NetBuffer buffer = client.CreateBuffer(); s_keepGoing = true; while (s_keepGoing) { NetMessageType type; // check if any messages has been received while (client.ReadMessage(buffer, out type)) { switch (type) { case NetMessageType.ServerDiscovered: // just connect to any server found! // make hail NetBuffer buf = client.CreateBuffer(); buf.Write("Hail from " + Environment.MachineName); client.Connect(buffer.ReadIPEndPoint(), buf.ToArray()); break; case NetMessageType.ConnectionRejected: Console.WriteLine("Rejected: " + buffer.ReadString()); break; case NetMessageType.DebugMessage: case NetMessageType.VerboseDebugMessage: Console.WriteLine(buffer.ReadString()); break; case NetMessageType.StatusChanged: string statusMessage = buffer.ReadString(); Console.WriteLine("New status: (" + statusMessage + ")"); break; case NetMessageType.Data: // The server sent this data! string msg = buffer.ReadString(); Console.WriteLine(msg); break; } } update(); if (client.Status == NetConnectionStatus.Connected) { NetBuffer sendBuffer = new NetBuffer(); sendBuffer.Write(" ApacheNetworkObject:VBS2:foo:" + _x + ":" + _y + ":" + _z + ":" + _pitch + ":" + _yaw + ":" + _roll); client.SendMessage(sendBuffer, NetChannel.ReliableInOrder14); } else { Console.Out.WriteLine("Client lost connection...."); s_keepGoing = false; } Thread.Sleep(10); } client.Shutdown("Application exiting"); }
/* ============= SV_EmitPacketEntities Writes a delta update of an entityState_t list to the message. ============= */ void EmitPacketEntities(clientSnapshot_t from, clientSnapshot_t to, NetBuffer msg) { int fromnumentities = 0; if (from != null) fromnumentities = from.num_entities; Common.entityState_t oldent = null, newent = null; int oldindex = 0, newindex = 0; int newnum, oldnum; while (newindex < to.num_entities || oldindex < fromnumentities) { if (newindex >= to.num_entities) newnum = 9999; else { newent = snapshotEntities[(to.first_entity + newindex) % numSnapshotEntities]; newnum = newent.number; } if (oldindex >= fromnumentities) oldnum = 9999; else { oldent = snapshotEntities[(from.first_entity + oldindex) % numSnapshotEntities]; oldnum = oldent.number; } if (newnum == oldnum) { // delta update from old position // because the force parm is qfalse, this will not result // in any bytes being emited if the entity has not changed at all Net.Instance.MSG_WriteDeltaEntity(msg, ref oldent, ref newent, false); oldindex++; newindex++; continue; } if (newnum < oldnum) { // this is a new entity, send it from the baseline Net.Instance.MSG_WriteDeltaEntity(msg, ref sv.svEntities[newnum].baseline, ref newent, true); newindex++; continue; } if (newnum > oldnum) { // the old entity isn't present in the new message Common.entityState_t nullEnt = null; Net.Instance.MSG_WriteDeltaEntity(msg, ref oldent, ref nullEnt, true); oldindex++; continue; } } msg.Write(1023); // end of packetentities }
private void WriteRoundStartMessage(NetBuffer buffer, Player player) { if (player == null) { buffer.Write(false); // player is not ready buffer.Write(true); // player needs field state } else { buffer.Write(player.IsReady); buffer.Write(player.needsFieldState); } }
private void WriteRoundEndMessage(NetBuffer buffer, Player player) { buffer.Write(player.IsReady); buffer.Write(player.needsRoundResults); }
void WriteSnapshotToClient(client_t cl, NetBuffer msg) { // this is the snapshot we are creating clientSnapshot_t frame = cl.frames[cl.netchan.outgoingSequence & 31]; // try to use a previous frame as the source for delta compressing the snapshot clientSnapshot_t oldframe = null; int lastframe; if (cl.deltaMessage <= 0 || cl.state != clientState_t.CS_ACTIVE) { // client is asking for a retransmit oldframe = null; lastframe = 0; } else if (cl.netchan.outgoingSequence - cl.deltaMessage >= (32 - 3)) { // client hasn't gotten a good message through in a long time Common.Instance.WriteLine("{0}: Delta request from out of date packet.", cl.name); oldframe = null; lastframe = 0; } else { // we have a valid snapshot to delta from oldframe = cl.frames[cl.deltaMessage & 31]; lastframe = cl.netchan.outgoingSequence - cl.deltaMessage; // the snapshot's entities may still have rolled off the buffer, though if (oldframe.first_entity <= nextSnapshotEntities - numSnapshotEntities) { Common.Instance.WriteLine("{0}: Delta request from out of date entities.", cl.name); oldframe = null; lastframe = 0; } } msg.Write((byte)svc_ops_e.svc_snapshot); // send over the current server time so the client can drift // its view of time to try to match if (cl.oldServerTime > 0) { // The server has not yet got an acknowledgement of the // new gamestate from this client, so continue to send it // a time as if the server has not restarted. Note from // the client's perspective this time is strictly speaking // incorrect, but since it'll be busy loading a map at // the time it doesn't really matter. msg.Write((int)(sv.time + cl.oldServerTime)); } else msg.Write((int)sv.time); // what we are delta'ing from msg.Write((byte)lastframe); int snapFlags = snapFlagServerBit; if (cl.rateDelayed) snapFlags |= SNAPFLAG_RATE_DELAYED; if (cl.state != clientState_t.CS_ACTIVE) snapFlags |= SNAPFLAG_NOT_ACTIVE; msg.Write((byte)snapFlags); // send over the areabits msg.Write((byte)frame.areabytes); msg.Write(frame.areabits); // delta encode the playerstate if (oldframe != null) Net.WriteDeltaPlayerstate(msg, oldframe.ps, frame.ps); else Net.WriteDeltaPlayerstate(msg, null, frame.ps); // delta encode the entities EmitPacketEntities(oldframe, frame, msg); }
static void Main(string[] args) { // create a client with a default configuration NetConfiguration config = new NetConfiguration("chatApp"); NetClient client = new NetClient(config); client.SetMessageTypeEnabled(NetMessageType.ConnectionRejected, true); client.SetMessageTypeEnabled(NetMessageType.DebugMessage, true); //client.SetMessageTypeEnabled(NetMessageType.VerboseDebugMessage, true); client.Start(); // Wait half a second to allow server to start up if run via Visual Studio Thread.Sleep(500); // Emit discovery signal client.DiscoverLocalServers(14242); // create a buffer to read data into NetBuffer buffer = client.CreateBuffer(); // current input string string input = ""; // keep running until the user presses a key Console.WriteLine("Type 'quit' to exit client"); Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress); s_keepGoing = true; while (s_keepGoing) { NetMessageType type; // check if any messages has been received while (client.ReadMessage(buffer, out type)) { switch (type) { case NetMessageType.ServerDiscovered: // just connect to any server found! // make hail NetBuffer buf = client.CreateBuffer(); buf.Write("Hail from " + Environment.MachineName); client.Connect(buffer.ReadIPEndPoint(), buf.ToArray()); break; case NetMessageType.ConnectionRejected: Console.WriteLine("Rejected: " + buffer.ReadString()); break; case NetMessageType.DebugMessage: case NetMessageType.VerboseDebugMessage: Console.WriteLine(buffer.ReadString()); break; case NetMessageType.StatusChanged: string statusMessage = buffer.ReadString(); NetConnectionStatus newStatus = (NetConnectionStatus)buffer.ReadByte(); Console.WriteLine("New status: " + newStatus + " (" + statusMessage + ")"); break; case NetMessageType.Data: // The server sent this data! string msg = buffer.ReadString(); Console.WriteLine(msg); break; } } while (Console.KeyAvailable) { ConsoleKeyInfo ki = Console.ReadKey(); if (ki.Key == ConsoleKey.Enter) { if (!string.IsNullOrEmpty(input)) { if (input == "quit") { // exit application s_keepGoing = false; } else { // Send chat message NetBuffer sendBuffer = new NetBuffer(); sendBuffer.Write(input); client.SendMessage(sendBuffer, NetChannel.ReliableInOrder1); input = ""; } } } else { input += ki.KeyChar; } } Thread.Sleep(1); } client.Shutdown("Application exiting"); }
public virtual void Write(NetBuffer om) { om.Position = 0; om.Write(Id); om.WriteAllProperties(this); }
/* ================== SV_UpdateServerCommandsToClient (re)send all server commands the client hasn't acknowledged yet ================== */ void UpdateServerCommandsToClient(client_t cl, NetBuffer msg) { // write any unacknowledged serverCommands for (int i = cl.reliableAcknowledge+1; i <= cl.reliableSequence; i++) { msg.Write((byte)svc_ops_e.svc_serverCommand); msg.Write(i); msg.Write(cl.reliableCommands[i & 63]); } cl.reliableSent = cl.reliableSequence; }
public void WriteToBuffer(NetBuffer buffer) { buffer.Write((byte)CommandType.ParticleUpdate); buffer.Write(this.game.Time.NumericValue); buffer.Write((byte)this.parameters.Count); foreach (var p in this.parameters) { buffer.Write(p); } }
public void Write(NetBuffer om) { om.Write(Command); }
// TODO: Use this with TRUE isLibraryThread for internal sendings (acks etc) internal void SendMessage(NetBuffer data, NetChannel channel, NetBuffer receiptData, bool isLibraryThread) { if (m_status != NetConnectionStatus.Connected) { throw new NetException("Status must be Connected to send messages"); } if (data.LengthBytes > m_owner.m_config.m_maximumTransmissionUnit) { // // Fragmented message // int dataLen = data.LengthBytes; int chunkSize = m_owner.m_config.m_maximumTransmissionUnit - 10; // header int numFragments = dataLen / chunkSize; if (chunkSize * numFragments < dataLen) { numFragments++; } ushort fragId = m_nextSendFragmentId++; for (int i = 0; i < numFragments; i++) { OutgoingNetMessage fmsg = m_owner.CreateOutgoingMessage(); fmsg.m_type = NetMessageLibraryType.UserFragmented; fmsg.m_msgType = NetMessageType.Data; NetBuffer fragBuf = m_owner.CreateBuffer(); fragBuf.Write(fragId); fragBuf.WriteVariableUInt32((uint)i); fragBuf.WriteVariableUInt32((uint)numFragments); if (i < numFragments - 1) { // normal fragment fragBuf.Write(data.Data, i * chunkSize, chunkSize); } else { // last fragment int bitsInLast = data.LengthBits - (chunkSize * (numFragments - 1) * 8); int bytesInLast = dataLen - (chunkSize * (numFragments - 1)); fragBuf.Write(data.Data, i * chunkSize, bytesInLast); // add receipt only to last message fmsg.m_receiptData = receiptData; } fmsg.m_data = fragBuf; fmsg.m_data.m_refCount = 1; // since it's just been created fmsg.m_numSent = 0; fmsg.m_nextResend = double.MaxValue; fmsg.m_sequenceChannel = channel; fmsg.m_sequenceNumber = -1; if (isLibraryThread) { m_unsentMessages.Enqueue(fmsg); } else { lock (m_lockedUnsentMessages) m_lockedUnsentMessages.Enqueue(fmsg); } } // TODO: recycle the original, unfragmented data return; } // // Normal, unfragmented, message // OutgoingNetMessage msg = m_owner.CreateOutgoingMessage(); msg.m_msgType = NetMessageType.Data; msg.m_type = NetMessageLibraryType.User; msg.m_data = data; msg.m_data.m_refCount++; // it could have been sent earlier also msg.m_numSent = 0; msg.m_nextResend = double.MaxValue; msg.m_sequenceChannel = channel; msg.m_sequenceNumber = -1; msg.m_receiptData = receiptData; if (isLibraryThread) { m_unsentMessages.Enqueue(msg); } else { lock (m_lockedUnsentMessages) m_lockedUnsentMessages.Enqueue(msg); } }
public void Write(NetBuffer om) { om.Write(ConnectionType); }
/* ================== MSG_WriteDeltaEntity Writes part of a packetentities message, including the entity number. Can delta from either a baseline or a previous packet_entity If to is NULL, a remove entity update will be sent If force is not set, then nothing at all will be generated if the entity is identical, under the assumption that the in-order delta code will catch it. ================== */ public void MSG_WriteDeltaEntity(NetBuffer msg, ref Common.entityState_t from, ref Common.entityState_t to, bool force) { int msgStart = msg.LengthBits; // a NULL to is a delta remove message if (to == null) { if (from == null) return; msg.Write(from.number); msg.Write(true); return; } if (to.number < 0 || to.number >= 1024) { Common.Instance.Error("MSG_WriteDeltaEntity: Bad entity number: " + to.number); } NetBuffer buf = new NetBuffer(); //NetBuffer buf = msg; int lc = 0; //if (from.number != to.number) { lc = 1; buf.Write(true); buf.Write(to.number); } else { buf.Write(false); } if (from.eType != to.eType) { lc = 2; buf.Write(true); buf.Write(to.eType); } else { buf.Write(false); } if (from.eFlags != to.eFlags) { lc = 3; buf.Write(true); buf.Write((int)to.eFlags); } else { buf.Write(false); } int middle = buf.LengthBits; if (from.pos.trBase.X != to.pos.trBase.X) { lc = 4; buf.Write(true); buf.Write(to.pos.trBase.X); } else { buf.Write(false); } if (from.pos.trBase.Y != to.pos.trBase.Y) { lc = 5; buf.Write(true); buf.Write(to.pos.trBase.Y); } else { buf.Write(false); } if (from.pos.trBase.Z != to.pos.trBase.Z) { lc = 6; buf.Write(true); buf.Write(to.pos.trBase.Z); } else { buf.Write(false); } if (from.pos.trDelta.X != to.pos.trDelta.X) { lc = 7; buf.Write(true); buf.Write(to.pos.trDelta.X); } else { buf.Write(false); } if (from.pos.trDelta.Y != to.pos.trDelta.Y) { lc = 8; buf.Write(true); buf.Write(to.pos.trDelta.Y); } else { buf.Write(false); } if (from.pos.trDelta.Z != to.pos.trDelta.Z) { lc = 9; buf.Write(true); buf.Write(to.pos.trDelta.Z); } else { buf.Write(false); } if (from.pos.trDuration != to.pos.trDuration) { lc = 10; buf.Write(true); buf.Write(to.pos.trDuration); } else { buf.Write(false); } if (from.pos.trTime != to.pos.trTime) { lc = 11; buf.Write(true); buf.Write(to.pos.trTime); } else { buf.Write(false); } if (from.pos.trType != to.pos.trType) { lc = 12; buf.Write(true); buf.Write((int)to.pos.trType); } else { buf.Write(false); } if (from.apos.trBase.X != to.apos.trBase.X) { lc = 13; buf.Write(true); buf.Write(to.apos.trBase.X); } else { buf.Write(false); } if (from.apos.trBase.Y != to.apos.trBase.Y) { lc = 14; buf.Write(true); buf.Write(to.apos.trBase.Y); } else { buf.Write(false); } if (from.apos.trBase.Z != to.apos.trBase.Z) { lc = 15; buf.Write(true); buf.Write(to.apos.trBase.Z); } else { buf.Write(false); } if (from.apos.trDelta.X != to.apos.trDelta.X) { lc = 16; buf.Write(true); buf.Write(to.apos.trDelta.X); } else { buf.Write(false); } if (from.apos.trDelta.Y != to.apos.trDelta.Y) { lc = 17; buf.Write(true); buf.Write(to.apos.trDelta.Y); } else { buf.Write(false); } if (from.apos.trDelta.Z != to.apos.trDelta.Z) { lc = 18; buf.Write(true); buf.Write(to.apos.trDelta.Z); } else { buf.Write(false); } if (from.apos.trDuration != to.apos.trDuration) { lc = 19; buf.Write(true); buf.Write(to.apos.trDuration); } else { buf.Write(false); } if (from.apos.trTime != to.apos.trTime) { lc = 20; buf.Write(true); buf.Write(to.apos.trTime); } else { buf.Write(false); } if (from.apos.trType != to.apos.trType) { lc = 21; buf.Write(true); buf.Write((int)to.apos.trType); } else { buf.Write(false); } if (from.time != to.time) { lc = 22; buf.Write(true); buf.Write(to.time); } else { buf.Write(false); } if (from.time2 != to.time2) { lc = 23; buf.Write(true); buf.Write(to.time2); } else { buf.Write(false); } if (from.origin.X != to.origin.X) { lc = 24; buf.Write(true); buf.Write(to.origin.X); } else { buf.Write(false); } if (from.origin.Y != to.origin.Y) { lc = 25; buf.Write(true); buf.Write(to.origin.Y); } else { buf.Write(false); } if (from.origin.Z != to.origin.Z) { lc = 26; buf.Write(true); buf.Write(to.origin.Z); } else { buf.Write(false); } if (from.origin2.X != to.origin2.X) { lc = 27; buf.Write(true); buf.Write(to.origin2.X); } else { buf.Write(false); } if (from.origin2.Y != to.origin2.Y) { lc = 28; buf.Write(true); buf.Write(to.origin2.Y); } else { buf.Write(false); } if (from.origin2.Z != to.origin2.Z) { lc = 29; buf.Write(true); buf.Write(to.origin2.Z); } else { buf.Write(false); } if (from.angles.X != to.angles.X) { lc = 30; buf.Write(true); buf.Write(to.angles.X); } else { buf.Write(false); } if (from.angles.Y != to.angles.Y) { lc = 31; buf.Write(true); buf.Write(to.angles.Y); } else { buf.Write(false); } if (from.angles.Z != to.angles.Z) { lc = 32; buf.Write(true); buf.Write(to.angles.Z); } else { buf.Write(false); } if (from.angles2.X != to.angles2.X) { lc = 33; buf.Write(true); buf.Write(to.angles2.X); } else { buf.Write(false); } if (from.angles2.Y != to.angles2.Y) { lc = 34; buf.Write(true); buf.Write(to.angles2.Y); } else { buf.Write(false); } if (from.angles2.Z != to.angles2.Z) { lc = 35; buf.Write(true); buf.Write(to.angles2.Z); } else { buf.Write(false); } if (from.otherEntityNum != to.otherEntityNum) { lc = 36; buf.Write(true); buf.Write(to.otherEntityNum); } else { buf.Write(false); } if (from.otherEntityNum2 != to.otherEntityNum2) { lc = 37; buf.Write(true); buf.Write(to.otherEntityNum2); } else { buf.Write(false); } if (from.groundEntityNum != to.groundEntityNum) { lc = 38; buf.Write(true); buf.Write(to.groundEntityNum); } else { buf.Write(false); } if (from.modelindex != to.modelindex) { lc = 39; buf.Write(true); buf.Write(to.modelindex); } else { buf.Write(false); } if (from.clientNum != to.clientNum) { lc = 40; buf.Write(true); buf.Write(to.clientNum); } else { buf.Write(false); } if (from.frame != to.frame) { lc = 41; buf.Write(true); buf.Write(to.frame); } else { buf.Write(false); } if (from.solid != to.solid) { lc = 42; buf.Write(true); buf.Write(to.solid); } else { buf.Write(false); } if (from.generic1 != to.generic1) { lc = 43; buf.Write(true); buf.Write(to.generic1); } else { buf.Write(false); } if (lc == 0) { // nothing at all changed if (!force) { return; // nothing at all } // write two bits for no change msg.Write(to.number); msg.Write(false); // not removed msg.Write(false); // no delta return; } msg.Write(to.number); msg.Write(false); // not removed msg.Write(true); // we have a delta //msg.Write(lc); // # of changes //msg.CopyFrom(buf); int msgPos = msg.LengthBits; //msg.Write(buf.Data); WriteDeltaEntityHags(msg, ref from,ref to); msg.Write(buf.LengthBits); //Common.Instance.WriteLine("MSG_WriteDeltaEntity: Wrote {0} bits", msg.LengthBits - msgStart); }
//public static void WriteMessageToRemotePlayer(NetPeer peer, GameOptions gameOpts) //{ // byte[] serializedGameOptions; // MemoryStream ms = new MemoryStream(); // BinaryFormatter bf1 = new BinaryFormatter(); // bf1.Serialize(ms, gameOpts); // serializedGameOptions = ms.ToArray(); // NetBuffer buffer = new NetBuffer(serializedGameOptions); // peer.SendToAll(buffer, NetChannel.ReliableInOrder1); //} public static void WriteMessageToRemotePlayer(NetPeer peer, String msg) { Lidgren.Network.NetBuffer buff = new Lidgren.Network.NetBuffer(); buff.Write(msg); peer.SendToAll(buff, Lidgren.Network.NetChannel.ReliableInOrder1); }
private static void SendPacket() { NetBuffer buf = m_client.CreateBuffer(); buf.EnsureBufferSize(m_nextSize * 8); int cnt = m_nextSize / 4; for (int i = 0; i < cnt; i++) buf.Write(i); NativeMethods.AppendText(m_mainForm.richTextBox1, "Sending " + m_nextSize + " byte packet"); // any receipt data will do NetBuffer receipt = new NetBuffer(4); receipt.Write(m_nextSize); m_client.SendMessage(buf, NetChannel.ReliableInOrder4, receipt); }
void SendClientSnapshot(client_t client, int index) { // build the snapshot BuildClientSnapshot(client, index); NetBuffer msg = new NetBuffer(); // let the client know which reliable clientCommands we have received msg.Write(client.lastClientCommand); // (re)send any reliable server commands UpdateServerCommandsToClient(client, msg); // send over all the relevant entityState_t // and the playerState_t WriteSnapshotToClient(client, msg); SendMessageToClient(msg, client); }
protected override NetBuffer ProcessInboundMessage(NetBuffer message) { switch(cryptoState) { case CryptoHostState.Connected: { int code = message.ReadInt32(); if (code == RSA_KEY_MESSAGE) { XmlSerializer s = new XmlSerializer(typeof(RSAParameters)); string b = message.ReadString(); StringReader reader = new StringReader(b); RSAKey = (RSAParameters)s.Deserialize(reader); RSA = new RSACryptoServiceProvider(); RSA.ImportParameters(RSAKey); NetBuffer msg = new NetBuffer(); msg.Write((Int32)CRYPTO_SECRET_MESSAGE); byte[] secret = RSA.Encrypt(MakeSecret(),false); msg.Write((Int32)secret.Length); msg.Write(secret); client.SendMessage(msg,NetChannel.ReliableInOrder1); cryptoState = CryptoHostState.SentSecret; } else { cryptoState = CryptoHostState.Invalid; client.Disconnect("Bad Crypto"); } } return null; case CryptoHostState.SentSecret: { int code = message.ReadInt32(); if (code == CRYPTO_SECRET_VERIFY) { // set em as real and let the base class call any events it needs to string verify = new UTF8Encoding().GetString(DecryptBuffer(message.ReadBytes(message.ReadInt32()))); NetBuffer b = new NetBuffer(); b.Write(CRYPTO_SECRET_VERIFY); byte[] cryptoBuffer = EncryptBuffer(new UTF8Encoding().GetBytes(verify)); b.Write(cryptoBuffer.Length); b.Write(cryptoBuffer); client.SendMessage(b, NetChannel.ReliableInOrder1); cryptoState = CryptoHostState.SentVerify; } else { cryptoState = CryptoHostState.Invalid; client.Disconnect("Bad Crypto"); } } return null; case CryptoHostState.SentVerify: { int code = message.ReadInt32(); if (code == CRYPTO_ACCEPT) { cryptoState = CryptoHostState.Authenticated; base.Connected(message); } else { cryptoState = CryptoHostState.Invalid; client.Disconnect("Bad Crypto"); } } return null; case CryptoHostState.Authenticated: return new NetBuffer(DecryptBuffer(message.ReadBytes(message.LengthBytes))); } return message; }