public static void Serialize(MemoryStream output, params object[] objs) { long initialPosition = output.Position; WriteSize(output, 0); // empty bytes foreach (object m in objs) { long initialPos = output.Position; WriteSize(output, 0); // empty bytes SerializeOne(output, m); long finalPos = output.Position; long objectSize = finalPos - initialPos - SizeSize; MyAssert.Assert(objectSize > 0); output.Position = initialPos; WriteSize(output, (int)objectSize); output.Position = finalPos; } long finalPosition = output.Position; long totalSize = finalPosition - initialPosition - SizeSize; output.Position = initialPosition; MyAssert.Assert(totalSize >= 0); if (objs.Length > 0) { MyAssert.Assert(totalSize > 0); } WriteSize(output, (int)totalSize); output.Position = finalPosition; }
// questionable design choices for sake of smoother application public void Respond(ref RemoteAction ra, Action <Response, Stream> followUp_) { followUp = followUp_; MyAssert.Assert(ra == null); ra = this; }
public void TriggerOnEmpty(Action a) { MyAssert.Assert(onClear == null); onClear = a; EmptyCheck(); }
protected void MessageServer(MessageType mt, params object[] arg) { MyAssert.Assert(serverHost != null); Host.TryConnectAsync(serverHost, ProcessServerDisconnect); Host.SendMessage(serverHost, mt, arg); }
public Node ConnectAsync(OverlayEndpoint theirInfo, Node.DisconnectProcessor dp) { dp = ProcessDisconnectWrap(dp); Node targetNode = FindNode(theirInfo); Handshake info = new Handshake(Address, theirInfo, extraHandshakeInfo); bool newConnection = (targetNode == null); if (newConnection) { targetNode = new Node(info, processQueue, dp); AddNode(targetNode); } MyAssert.Assert(targetNode.readerStatus != Node.ReadStatus.DISCONNECTED); MyAssert.Assert(targetNode.writerStatus != Node.WriteStatus.DISCONNECTED); MyAssert.Assert(!targetNode.IsClosed); if (targetNode.writerStatus == Node.WriteStatus.WRITING) { throw new NodeException("Already connected/connecting to " + targetNode.Address); } else { targetNode.ConnectAsync(); } if (newConnection) { onNewConnectionHook.Invoke(targetNode); } return(targetNode); }
public void SoftDisconnect(OverlayEndpoint theirInfo) { Node targetNode = FindNode(theirInfo); MyAssert.Assert(targetNode != null); targetNode.SoftDisconnect(); }
public void Remove(Guid id) { MyAssert.Assert(remotes.ContainsKey(id)); remotes.Remove(id); EmptyCheck(); }
public void SendMessage(OverlayEndpoint remote, NetworkMessage nm) { Node n = FindNode(remote); MyAssert.Assert(n != null); n.SendMessage(nm); }
public TimedAction(Action a, TimeSpan period) { MyAssert.Assert(period > TimeSpan.Zero); this.a = a; this.period = period; this.timeLeft = period; }
public override void NET_RemoveBlock(Point pos) { ITile t = this[pos]; MyAssert.Assert(t.IsEmpty()); MyAssert.Assert(walls[pos] != null); UnityEngine.Object.Destroy(walls[pos]); }
public void Close() { foreach (var n in GetAllNodes().ToArray()) { DisconnectNode(n); } MyAssert.Assert(!nodes.Any()); }
void OnStopValidating(Node n) { IPEndPoint addr = n.info.remote.addr; MyAssert.Assert(validatorPool.Contains(addr)); validatorPool.Remove(addr); Log.Dump(n.info.remote); }
public void Untrack() { --tracker; MyAssert.Assert(tracker >= 0); if (tracker == 0) { Unsubscribe(); } }
public void Add(Action a) { lock (syncLock) if (a != null && executeThreadId != null) { MyAssert.Assert(executeThreadId != Thread.CurrentThread.ManagedThreadId); } msgs.Add(a); }
public void FinalizeVerifier() { MyAssert.Assert(finalizing == false); finalizing = true; if (locked == null) { OnFinalizedVerifier(); } }
static public void Process(ref RemoteAction ra, Node n, Stream st) { Response r = Serializer.Deserialize <Response>(st); Guid id = Serializer.Deserialize <Guid>(st); MyAssert.Assert(ra.Id == id); ra.FollowUp(n, st, r); ra = null; }
void FollowUp(Node n, Stream st, Response r) { MyAssert.Assert(n.info.remote == remoteHost); if (l != null) { l.Unlock(); } followUp.Invoke(r, st); }
public void WorldAction(ForwardFunctionCall ffc, WorldInfo info) { if (!ValidateWorldInfo(info)) { return; } MyAssert.Assert(world != null); ffc.Apply(world); ffc.Apply(worldHook); }
public void Tick(TimeSpan tickPeriod) { MyAssert.Assert(a != null); timeLeft -= tickPeriod; if (timeLeft <= TimeSpan.Zero) { a.Invoke(); timeLeft = period; } }
static void WriteSize(Stream output, int size) { byte[] intBytes = BitConverter.GetBytes(size); MyAssert.Assert(intBytes.Length == sizeof(int)); if (BitConverter.IsLittleEndian) { Array.Reverse(intBytes); } output.Write(intBytes, 0, intBytes.Length); }
public bool TryCloseNode(OverlayEndpoint remote) { Node n = FindNode(remote); if (n != null) { MyAssert.Assert(!n.IsClosed); n.Disconnect(); return(true); } return(false); }
public void Remove(Guid player) { MyAssert.Assert(playerPositions.ContainsKey(player)); Point prevPos = playerPositions[player]; foreach (Point p in Point.SymmetricRange(Point.One)) { untrack.Invoke(prevPos + p); } playerPositions.Remove(player); }
void OnFinalizedVerifier() { MyAssert.Assert(finalizing == true); MyAssert.Assert(locked == null); if (playerData.IsConnected) { MessageWorld(playerData.world.Value, MessageType.PLAYER_DISCONNECT); OnDisconnect(); } MessageServer(MessageType.PLAYER_HOST_DISCONNECT, playerData); }
internal void NewIncomingConnection(Handshake info, Socket sck) { try { MyAssert.Assert(info.local.hostname == hostName); MemoryStream remoteExtraInfo = info.ExtraInfo; info.ExtraInfo = extraHandshakeInfo; Node targetNode = FindNode(info.remote); bool newConnection = (targetNode == null); if (newConnection) { targetNode = new Node(info, processQueue, null); AddNode(targetNode); } NodeProcessors proc = processorAssigner(targetNode, remoteExtraInfo); proc.Message = ProcessMessageWrap(proc.Message); proc.Disconnect = ProcessDisconnectWrap(proc.Disconnect); targetNode.notifyDisonnect = proc.Disconnect; MyAssert.Assert(targetNode.readerStatus != Node.ReadStatus.DISCONNECTED); MyAssert.Assert(targetNode.writerStatus != Node.WriteStatus.DISCONNECTED); MyAssert.Assert(!targetNode.IsClosed); if (targetNode.readerStatus != Node.ReadStatus.READY) { Log.Console("New connection {0} rejected: node already connected", info.remote); sck.Close(); return; } targetNode.AcceptReaderConnection(sck, proc.Message); if (newConnection) { onNewConnectionHook.Invoke(targetNode); } //if (targetNode.writerStatus == Node.WriteStatus.READY) // targetNode.ConnectAsync(); } catch (NodeException) // FIXME { sck.Close(); throw; } }
static internal int ReadSize(Stream input) { byte[] intBytes = new byte[sizeof(int)]; int c = input.Read(intBytes, 0, intBytes.Length); MyAssert.Assert(c == intBytes.Length); if (BitConverter.IsLittleEndian) { Array.Reverse(intBytes); } return(BitConverter.ToInt32(intBytes, 0)); }
static private void Tick(Aggregator all) { foreach (var id in timings.Keys.ToArray()) { timings[id]--; if (timings[id] <= 0) { int timeout = PlayerAiMove(all, id); MyAssert.Assert(timeout > 0 && timeout < 10); timings[id] = timeout; } } }
public OverlayHost NewHost(OverlayHostName hostName, OverlayHost.ProcessorAssigner messageProcessor, MemoryStream extraHandshakeInfo, TimeSpan inactivityPeriod) { MyAssert.Assert(!hosts.ContainsKey(hostName)); OverlayHost host = new OverlayHost(hostName, MyAddress, processQueue, messageProcessor, extraHandshakeInfo, tt, inactivityPeriod); hosts.Add(hostName, host); Log.EntryConsole(log, "New host: " + hostName); return(host); }
public void WorldInit(WorldInitializer init) { if (!ValidateWorldInfo(init.info)) { return; } MyAssert.Assert(world == null); world = data.generateWorld(init); foreach (WorldInfo inf in world.GetKnownNeighbors()) { data.recordWorldInfo(inf); } }
private void Unsubscribe() { if (isSubscribed) { isSubscribed = false; MyAssert.Assert(Info != null); data.unsubscribe(Info.Value); //data.host.ConnectSendMessage(Info.Value.host, MessageType.UNSUBSCRIBE); if (world != null) { world.Dispose(); world = null; } } }
public override void NET_RemovePlayer(Guid player, bool teleporting) { base.NET_RemovePlayer(player, teleporting); MyAssert.Assert(playerAvatars.ContainsKey(player)); GameObject avatar = playerAvatars.GetValue(player); if (teleporting) { NewTeleportAnimation(avatar.transform.position, avatar.renderer.material.color); } UnityEngine.Object.Destroy(avatar); playerAvatars.Remove(player); }