protected override async Task Close(PipeEndpoint e, Endpoint ee = null, CancellationToken cancel = default(CancellationToken)) { MessageEntry m = new MessageEntry(MessageEntryType.PipeDisconnectReq, MemberName); m.AddElement("index", e.Index); MessageEntry ret = await stub.ProcessRequest(m, cancel); }
protected override void DeleteEndpoint(PipeEndpoint e) { lock (pipeendpointlock) { pipeendpoints[e.Endpoint].Remove(e.Index); } }
public override IEnumerator FlowBack(PipeEndpoint input) { yield return(new WaitForSeconds(flowThroughTime / 4)); isShaking = true; flowing = false; StartCoroutine(TurnLever()); }
public override IEnumerator FlowThrough(PipeEndpoint input) { flowing = true; isShaking = true; yield return(new WaitForSeconds(flowThroughTime)); endpointA.OutFlow(true); }
private void OnTriggerExit(Collider other) { PipeEndpoint endpoint = other.GetComponent <PipeEndpoint>(); if (endpoint != null) { connectedNeighbor = null; } }
protected override async Task Close(PipeEndpoint e, Endpoint ee, CancellationToken cancel = default(CancellationToken)) { MessageEntry m = new MessageEntry(MessageEntryType.PipeClosed, MemberName); m.AddElement("index", e.Index); await skel.SendPipeMessage(m, ee, cancel); DeleteEndpoint(e); }
public override IEnumerator FlowThrough(PipeEndpoint input) { yield return(new WaitForSeconds(flowThroughTime / 2)); isShaking = true; yield return(new WaitForSeconds(flowThroughTime / 2)); focusManager.ToggleState(false); gameboy.SetActive(true); }
public virtual IEnumerator FlowThrough(PipeEndpoint input) { canRotate = false; yield return(new WaitForSeconds(flowThroughTime / 2)); isShaking = true; yield return(new WaitForSeconds(flowThroughTime / 2)); PipeEndpoint output; if (input.Equals(endpointA)) { output = endpointB; } else { output = endpointA; } output.OutFlow(true); }
public virtual IEnumerator FlowBack(PipeEndpoint input) { yield return(new WaitForSeconds(flowThroughTime / 2)); isShaking = false; transform.position = originalPosition; yield return(new WaitForSeconds(flowThroughTime / 2)); canRotate = true; PipeEndpoint output; if (input.Equals(endpointA)) { output = endpointB; } else { output = endpointA; } output.OutFlow(false); }
protected bool DispatchPacket(MessageElement me, PipeEndpoint e, out uint packetnumber) { int index = Int32.Parse(me.ElementName); List <MessageElement> elems = ((MessageElementMap <string>)me.Data).Elements; packetnumber = (MessageElement.FindElement(elems, "packetnumber").CastData <uint[]>())[0]; object data; if (!rawelements) { data = UnpackAnyType(MessageElement.FindElement(elems, "packet")); } else { data = MessageElement.FindElement(elems, "packet"); } e.PipePacketReceived((T)data, packetnumber); bool requestack = (elems.Any(x => x.ElementName == "requestack")); return(requestack); }
public override async Task <PipeEndpoint> Connect(int index, CancellationToken cancel = default(CancellationToken)) { object connecting_key = new object(); connecting.Add(Tuple.Create(index, connecting_key)); int rindex = -1; try { MessageEntry m = new MessageEntry(MessageEntryType.PipeConnectReq, MemberName); m.AddElement("index", index); MessageEntry ret = await stub.ProcessRequest(m, cancel); rindex = (ret.FindElement("index").CastData <int[]>())[0]; PipeEndpoint e; if (early_endpoints.ContainsKey(rindex)) { e = early_endpoints[rindex]; early_endpoints.Remove(rindex); } else { e = new PipeEndpoint(this, rindex); } pipeendpoints.Add(rindex, e); return(e); } finally { connecting.RemoveAll(x => Object.ReferenceEquals(x.Item2, connecting_key)); if (connecting.Count == 0) { early_endpoints.Clear(); } } }
public override void PipePacketReceived(MessageEntry m, Endpoint e = null) { if (m.EntryType == MessageEntryType.PipeClosed) { try { int index = (m.FindElement("index").CastData <int[]>())[0]; pipeendpoints[index].RemoteClose(); } catch { }; } else if (m.EntryType == MessageEntryType.PipePacket) { List <MessageElement> ack = new List <MessageElement>(); foreach (MessageElement me in m.elements) { try { int index = Int32.Parse(me.ElementName); uint pnum; PipeEndpoint p = null; if (pipeendpoints.ContainsKey(index)) { p = pipeendpoints[index]; } else { if (early_endpoints.ContainsKey(index)) { p = early_endpoints[index]; } else if (connecting.Count > 0) { if (connecting.Any(x => x.Item1 == -1 || x.Item1 == index)) { p = new PipeEndpoint(this, index); early_endpoints.Add(index, p); } } } if (p == null) { continue; } if (DispatchPacket(me, p, out pnum)) { ack.Add(new MessageElement(me.ElementName, new uint[] { pnum })); } } catch (Exception) { } } try { if (ack.Count > 0) { MessageEntry mack = new MessageEntry(MessageEntryType.PipePacketRet, m.MemberName); mack.elements = ack; stub.SendPipeMessage(mack, default(CancellationToken)).IgnoreResult(); } } catch { } } else if (m.EntryType == MessageEntryType.PipePacketRet) { try { foreach (MessageElement me in m.elements) { int index = Int32.Parse(me.ElementName); DispatchPacketAck(me, pipeendpoints[index]); } } catch { } } }
protected abstract Task Close(PipeEndpoint e, Endpoint ee = null, CancellationToken cancel = default(CancellationToken));
public Task <MessageEntry> PipeCommand(MessageEntry m, Endpoint e) { lock (pipeendpointlock) { switch (m.EntryType) { case MessageEntryType.PipeConnectReq: { if (!pipeendpoints.Keys.Contains(e.LocalEndpoint)) { pipeendpoints.Add(e.LocalEndpoint, new Dictionary <int, PipeEndpoint>()); } Dictionary <int, PipeEndpoint> ep = pipeendpoints[e.LocalEndpoint]; int index = (m.FindElement("index").CastData <int[]>())[0]; if (index == -1) { index = (ep.Count == 0) ? 1 : (ep.Keys.Max() + 1); } if (ep.Keys.Contains(index)) { throw new Exception("Pipe endpoint index in use"); } PipeEndpoint p = new PipeEndpoint(this, index, e); ep.Add(index, p); try { if (callback != null) { callback(p); } } catch { } MessageEntry ret = new MessageEntry(MessageEntryType.PipeConnectRet, MemberName); ret.AddElement("index", index); return(Task.FromResult(ret)); } case MessageEntryType.PipeDisconnectReq: { if (!pipeendpoints.Keys.Contains(e.LocalEndpoint)) { throw new Exception("Invalid pipe"); } Dictionary <int, PipeEndpoint> ep = pipeendpoints[e.LocalEndpoint]; int index = (m.FindElement("index").CastData <int[]>())[0]; if (!ep.Keys.Contains(index)) { throw new Exception("Invalid pipe"); } ep.Remove(index); return(Task.FromResult(new MessageEntry(MessageEntryType.PipeDisconnectReq, MemberName))); } default: throw new Exception("Invalid Command"); } } }
protected override void DeleteEndpoint(PipeEndpoint e) { pipeendpoints.Remove(e.Index); }
protected void DispatchPacketAck(MessageElement me, PipeEndpoint e) { uint pnum = me.CastData <uint[]>()[0]; e.PipePacketAckReceived(pnum); }
protected abstract void DeleteEndpoint(PipeEndpoint e);