public bool IsEmptyData()
{
bool isEmpty = false;
if (Name.Equals(DEFAULT_NAME))
{
if (Uuid.Equals(DEFAULT_UUID))
{
if (Rssi == DEFAULT_RSSI)
{
if (Status.Equals(DEFAULT_STATUS))
{
if (LocalName.Equals(DEFAULT_LOCAL_NAME))
{
if (Connectable.Equals(DEFAULT_CONNECTABLE))
{
isEmpty = true;
}
}
}
}
}
}
return(isEmpty);
}
public ConnectHandle Connect(IMessageSink <GrpcTransportMessage> sink, string routingKey)
{
Connectable <IMessageSink <GrpcTransportMessage> > forKey =
_sinks.GetOrAdd(routingKey ?? "", key => new Connectable <IMessageSink <GrpcTransportMessage> >());
return(forKey.Connect(sink));
}
private void HandleConnectPointConnected(ConnectPoint connectPt, Connectable connectable)
{
connectable.transform.SetParent(transform, true);
connectable.GetComponent <Damagable>().OnPartDestroyed.AddListener(HandleConnectedPartDestroyed);
Ship.RegisterConnectable(connectable);
ConnectedPart = connectable;
}
void Start()
{
line = gameObject.GetComponentInChildren <UILineRenderer>();
anchorPrev = transform.FindChild("Body").FindChild("FlowAnchorPrev").GetComponent <Connectable>();
anchorNext = transform.FindChild("Body").FindChild("FlowAnchorNext").GetComponent <Connectable>();
}
public TopicNode(StringComparer comparer)
{
_comparer = comparer;
_sinks = new Connectable <IMessageSink <GrpcTransportMessage> >();
_children = new ConcurrentDictionary <string, TopicNode>(comparer);
}
public override string Execute(string[] args, Connectable connected)
{
return("HELP: Show command list\n" +
"ACTIVATE: Activate nearby switch\n" +
"FILES: Show file list in connected device\n" +
"READ <file>: Read the named file");
}
public override string Execute(string[] args, Connectable connected)
{
if (connected == null || connected.files.Length == 0)
{
return("Not connected to any storage.");
}
File file = null;
string search = "";
for (int i = 1; i < args.Length; i++)
{
search += args[i] + " ";
}
foreach (File f in connected.files)
{
if (f.name.StartsWith(search.Trim()))
{
file = f;
}
}
if (file == null)
{
return("File not found.");
}
else
{
return(file.contents);
}
}
public Connection(Connectable starrRect, Connectable endRect, PathTypes connectType, Action <Connection> OnClickRemoveConnection)
{
inPoint = starrRect;
outPoint = endRect;
connectionType = connectType;
this.OnClickRemoveConnection = OnClickRemoveConnection;
}
internal Result(Connectable connectable, IEnumerable <T> data, int returnValue)
: base(data)
{
ReturnValue = returnValue;
_connectable = connectable;
Bag = new ExpandoObject();
}
public bool MouseDown(MouseEventArgs e)
{
if (IsSuspended)
{
return(false);
}
Connectable elem = null;
HitTestResult result = VisualTreeHelper.HitTest(Canvas, e.GetPosition(Canvas));
if (result.VisualHit != null)
{
elem = GetConnectable(result.VisualHit as Visual);
if (ShapeFactory.Exists(elem))
{
SelectionManager.SelectShape(elem);
movedShape = SelectionManager.SelectedShape as Connectable;
moving = true;
shift = e.GetPosition(movedShape);
initialPoint = new Point(Canvas.GetLeft(movedShape), Canvas.GetTop(movedShape));
ActivateTool();
return(true);
}
}
return(false);
}
public bool SpecialConnects(Tile t, int x, int y)
{
if (!t.active())
{
return(false);
}
if (t.frameX % 36 != 0)
{
x--;
}
if (t.frameY != 0)
{
y--;
}
if (this.ductType == DuctType.None)
{
return(false);
}
else
{
IConnectable conn = Connectable.Find(x, y);
if (conn != null)
{
return(conn.GetItems(this.ductType == DuctType.In ? ConnectableType.Input : ConnectableType.Output) != null);
}
}
return(false);
}
private static void RaiseOnShapeAdded(Connectable shape)
{
if (OnShapeAdded != null)
{
OnShapeAdded(null, new ShapeEventArgs(shape));
}
}
internal Result(Connectable connectable, DataTable dataTable, int returnValue)
: base(dataTable)
{
ReturnValue = returnValue;
_connectable = connectable;
Bag = new ExpandoObject();
}
public void Connect()
{
//grabber.RetractGrabber();
connected = closestConnectTransform.parent.gameObject;
transform.rotation = connected.transform.rotation;
Rigidbody2D thisRb = GetComponent <Rigidbody2D>();
Rigidbody2D thatRb = connected.GetComponent <Rigidbody2D>();
Vector2 weightedVelocity = (thisRb.mass * thisRb.velocity + thatRb.mass * thatRb.velocity) /
(thisRb.mass + thatRb.mass);
float weightedAngularVelocity = (thisRb.mass * thisRb.angularVelocity + thatRb.mass * thatRb.angularVelocity) /
(thisRb.mass + thatRb.mass);
isConnected = true;
canConnect = false;
connected.GetComponent <GravityApplier>().enabled = false;
connectedScript = connected.GetComponent <Connectable>();
Transform connectedTransform = connected.transform;
Destroy(closestConnectTransform.parent.gameObject.GetComponent <Rigidbody2D>());
connectedTransform.parent = transform;
connectedTransform.localEulerAngles = Vector3.zero;
connectedTransform.localPosition = connectedScript.offset;
thisRb.velocity = weightedVelocity;
thisRb.angularVelocity = weightedAngularVelocity;
}
private void BeingDraggedOrRemoteDrag(Connectable remoteBeingDraggedConnector = null)
{
if (remoteBeingDraggedConnector != null)
{
Debug.Assert(SameChainDuplex(this, remoteBeingDraggedConnector));
if (GameManager.DraggingConnectable == null)
{
_mouseDragOffset = this.transform.position - GetMouseWorldPos;
GameManager.DraggingConnectable = remoteBeingDraggedConnector;
}
else if (GameManager.DraggingConnectable == remoteBeingDraggedConnector)
{
this.transform.position = GetMouseWorldPos + _mouseDragOffset;
}
}
else
{
if (GameManager.DraggingConnectable == null)
{
_mouseDragOffset = this.transform.position - GetMouseWorldPos;
GameManager.DraggingConnectable = this;
}
else if (GameManager.DraggingConnectable == this)
{
this.transform.position = GetMouseWorldPos + _mouseDragOffset;
}
}
}
public void Disconnect()
{
if (!connected)
{
return;
}
StartCoroutine(ConnectTimeout(3f));
canConnect = false;
isConnected = false;
Rigidbody2D thisRb = GetComponent <Rigidbody2D>();
connected.transform.parent = null;
Rigidbody2D rb = connected.AddComponent <Rigidbody2D>();
rb.gravityScale = 0;
rb.drag = 0;
rb.angularDrag = 0;
connected.GetComponent <GravityApplier>().enabled = true;
rb.velocity = thisRb.velocity;
rb.angularVelocity = thisRb.angularVelocity;
connected.GetComponent <GravityApplier>().rb = rb;
connected = null;
connectedScript = null;
//rb.AddForce(transform.up * -1, ForceMode2D.Impulse);
GetComponent <Rigidbody2D>().AddForce(transform.up * 3f, ForceMode2D.Impulse);
}
private void ClearConnectionSelection()
{
selectedInPoint = null;
selectedOutPoint = null;
selectedType = PathTypes.NONE;
connecting = false;
}
public void DestroyConnected()
{
Destroy(connected);
connected = null;
isConnected = false;
connectedScript = null;
canConnect = true;
//StartCoroutine(ConnectTimeout(3f));
}
public InMemoryQueue(string name, int concurrencyLevel)
{
_name = name;
_consumers = new Connectable <IInMemoryQueueConsumer>();
_consumer = Util.TaskUtil.GetTask <IInMemoryQueueConsumer>();
_executor = new ChannelExecutor(concurrencyLevel, false);
}
public CodeFeatureStateCache(ICodeFeatureStateCacheProvider cacheProvider)
{
_cacheProvider = cacheProvider;
_cacheLoaded = new Connectable <IObserver <ICodeFeatureStateCacheLoaded> >();
_cacheUpdated = new Connectable <IObserver <ICodeFeatureStateCacheUpdated> >();
_cache = Task.Run(async() => await LoadCache()).Result;
}
private static bool IsConnectedToWarehouse(Connectable forCheck, List <Connectable> alreadyChecked)
{
if (forCheck == null)
{
return(false);
}
if (forCheck is Warehouse)
{
if ((forCheck as Warehouse).ResistanceCurrent > 0)
{
return(true);
}
else
{
alreadyChecked.Add(forCheck);
return(false);
}
}
if (alreadyChecked.Contains(forCheck))
{
return(false);
}
alreadyChecked.Add(forCheck);
if (forCheck is Road && (forCheck as Road).Terrain.Control == ControlType.PLAYER)
{
return(false);
}
if (IsConnectedToWarehouse(forCheck.Up, alreadyChecked))
{
return(true);
}
if (IsConnectedToWarehouse(forCheck.UpRight, alreadyChecked))
{
return(true);
}
if (IsConnectedToWarehouse(forCheck.DownRight, alreadyChecked))
{
return(true);
}
if (IsConnectedToWarehouse(forCheck.Down, alreadyChecked))
{
return(true);
}
if (IsConnectedToWarehouse(forCheck.DownLeft, alreadyChecked))
{
return(true);
}
if (IsConnectedToWarehouse(forCheck.UpLeft, alreadyChecked))
{
return(true);
}
return(false);
}
public override string Execute(string[] args, Connectable connected)
{
string output = "";
for (int i = 1; i < args.Length; i++)
{
output += args[i] + " ";
}
return(output);
}
public InMemoryQueue(string name, int concurrencyLevel)
{
_name = name;
_scheduler = new LimitedConcurrencyLevelTaskScheduler(concurrencyLevel);
_cancellationToken = new CancellationTokenSource();
_consumers = new Connectable <IInMemoryQueueConsumer>();
_consumer = Util.TaskUtil.GetTask <IInMemoryQueueConsumer>();
_cancellationToken.Token.Register(() => _consumer.TrySetCanceled());
}
public static bool DraggingConnectableNotNullNeitherSelf(Connectable self)
{
if (DraggingConnectable != null)
{
if (DraggingConnectable != self)
{
return(true);
}
}
return(false);
}
public override string Execute(string[] args, Connectable connected)
{
if (connected is Activatable)
{
return(((Activatable)connected).Activate(args.Length > 1 ? args[1] : null));
}
else
{
return("Nothing nearby to activate.");
}
}
public static bool DraggingSelfOrChainMember(Connectable self)
{
if (DraggingSelf(self))
{
return(true);
}
else
{
return(Connectable.SameChainDuplex(self, DraggingConnectable));
}
}
public void OnBeginDrag(PointerEventData eventData)
{
GameObject obj = new GameObject("anchor", new System.Type[] { typeof(RectTransform) });
tempConnectable = obj.AddComponent <Connectable>();
GetComponentInParent <Node>().next = tempConnectable;
tempConnectable.anchor = tempConnectable.transform;
tempConnectable.transform.SetParent(transform, true);
tempConnectable.GetComponent <RectTransform>().anchoredPosition = Vector2.zero;
// tempConnectable.GetComponent<RectTransform>().anchoredPosition = RectTransformExtension.switchToRectTransform(GetComponent<RectTransform>(), tempConnectable.GetComponent<RectTransform>());
}
public static void AddShape(Connectable shape, ShapeTypes type)
{
if (shape == null)
{
throw new ArgumentNullException("A null cannot be added to the shape collection.");
}
//the undo trick
AddShapeCommand cmd = new AddShapeCommand(shape, type, Canvas);
UndoManager.Execute(cmd);
RaiseOnShapeAdded(shape);
}
public void RegisterConnectable(Connectable connectable)
{
if (connectedParts.Contains(connectable))
{
return;
}
connectable.ConnectToShip(this);
connectedParts.Add(connectable);
connectable.ActivationKey = alphaKeyCodes[UnityEngine.Random.Range(0, alphaKeyCodes.Length)];
OnPartConnected(connectable);
Debug.Log($"assigned connectable to key {connectable.ActivationKey.ToString()}");
}
private void _beginAsync(Connectable connectable, AsyncCallback callback)
{
SqlConnection cn = new SqlConnection(connectable.ConnectionStringAsync);
cn.Open();
Importer.ExecuteBulkInsert(connectable, cn);
SqlCommand cmd = new SqlCommand(connectable.Sql, cn);
cmd.CommandTimeout = connectable.CommandTimeout;
Command = cmd;
AsyncResult1 = cmd.BeginExecuteReader(callback, this, CommandBehavior.CloseConnection);
}
