public override void OnUpdate(long msec)
{
var g2d = Graphics2D.GetInstance ();
var pos = g2d.GetMousePosition ();
if (Input.GetKeyDown (KeyCode.Mouse0)) {
var start = new Vector3 (pos.X, pos.Y, 1000);
var end = new Vector3 (pos.X, pos.Y, -1000);
var node = World.Pick (start, end);
if (node != null) {
this.picked = node;
this.delta = pos - new Vector2 (node.Position.X, node.Position.Y);
}
}
if (Input.GetKeyUp(KeyCode.Mouse0)) {
this.picked = null;
}
if (picked != null) {
var t = pos - delta;
picked.Translation = new Vector3(t.X, t.Y, 0);
}
base.OnUpdate (msec);
}
public void SendPing()
{
engine.Add(node);
engine.TimeOut = TimeSpan.FromMilliseconds(75);
ManualResetEvent handle = new ManualResetEvent(false);
engine.MessageLoop.QuerySent += delegate(object o, SendQueryEventArgs e) {
if (!e.TimedOut && e.Query is Ping)
handle.Set();
if (!e.TimedOut || !(e.Query is Ping))
return;
PingResponse response = new PingResponse(node.Id, e.Query.TransactionId);
listener.RaiseMessageReceived(response, e.EndPoint);
};
Assert.AreEqual(NodeState.Unknown, node.State, "#1");
DateTime lastSeen = node.LastSeen;
Assert.IsTrue(handle.WaitOne(1000, false), "#1a");
Node nnnn = node;
node = engine.RoutingTable.FindNode(nnnn.Id);
Assert.IsTrue (lastSeen < node.LastSeen, "#2");
Assert.AreEqual(NodeState.Good, node.State, "#3");
}
public Comment(Node hostNode)
{
HostNode = hostNode;
var scrollViewer = new ScrollViewer
{
HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled,
VerticalScrollBarVisibility = ScrollBarVisibility.Visible,
Height = 70,
CanContentScroll = true
};
var textBlock = new TextBlock
{
Background = Brushes.Transparent,
TextWrapping = TextWrapping.Wrap,
Margin = new Thickness(5),
FontSize = 12
};
Child = scrollViewer;
CornerRadius = new CornerRadius(5);
scrollViewer.Content = textBlock;
var bindingTextToTextBlock = new Binding("Text")
{
Source = this,
Mode = BindingMode.OneWay
};
textBlock.SetBinding(TextBlock.TextProperty, bindingTextToTextBlock);
hostNode.SpaceCanvas.Children.Add(this);
}
public void SelectNode(Node node)
{
GameObject connection = Instantiate(Resources.Load("Connection")) as GameObject;
Connection connection_component = connection.GetComponent<Connection>();
connection_component.InitializeWithStartNode(node);
m_connection = connection_component;
}
public Node()
{
left = null;
right = null;
filled = false;
this.Rectangle = null;
}
public override void OnMailBox(Node from, string address, object letter)
{
for (var i = 0; i < lineCount-1; i++) {
GetComponent<Label> (i).Text = GetComponent<Label> (i + 1).Text;
}
GetComponent<Label> (lineCount - 1).Text = (string)letter;
}
public void PutTest()
{
Node node1 = new Node(mSkynet);
Node node2 = new Node(mSkynet);
Node node3 = new Node(mSkynet);
node2.parent = node1.selfNode;
node2.parentModifiedTime = Skynet.Utils.Utils.UnixTimeNow();
Task.Run(async () => {
ToxResponse response = await RequestProxy.sendRequest(mSkynet, new ToxRequest {
uuid = Guid.NewGuid().ToString(),
url = "node/" + node3.selfNode.uuid + "/grandParents",
content = JsonConvert.SerializeObject(node1.selfNode),
method = "put",
fromNodeId = node2.selfNode.uuid,
fromToxId = node2.selfNode.toxid,
toNodeId = node3.selfNode.uuid,
toToxId = node3.selfNode.toxid,
time = node2.parentModifiedTime
});
NodeResponse res = JsonConvert.DeserializeObject<NodeResponse>(response.content);
Assert.AreEqual(node1.selfNode.uuid, node3.grandParents.uuid);
Assert.AreEqual(node2.parentModifiedTime, node3.grandParentsModifiedTime);
}).GetAwaiter().GetResult();
}
public static void magix_viewport_load_viewport(object sender, ActiveEventArgs e)
{
Node ip = Ip(e.Params);
if (ShouldInspect(ip))
{
AppendInspectFromResource(
ip["inspect"],
"Magix.tiedown",
"Magix.tiedown.hyperlisp.inspect.hl",
"[magix.viewport.load-viewport-dox].value");
return;
}
Node node = new Node();
node["file"].Value = "plugin:magix.file.load-from-resource";
node["file"]["assembly"].Value = "Magix.tiedown";
node["file"]["resource-name"].Value = "Magix.tiedown.hyperlisp.load-viewport.hl";
RaiseActiveEvent(
"magix.execute.execute-script",
node);
Control ctrl = ModuleControllerLoader.Instance.LoadActiveModule(node["params"]["viewport"].Get<string>());
e.Params["viewport"].Value = ctrl;
}
int GetDistance(Node nodeA, Node nodeB) {
int dstX = Mathf.Abs (nodeA.gridX - nodeB.gridX);
int dstY = Mathf.Abs (nodeA.gridY - nodeB.gridY);
if (dstX > dstY)
return 14 * dstY + 10 * (dstX - dstY);
return 14 * dstX + 10 * (dstY - dstX);
}
public Bullet(Node parent, string name)
: base(parent, name)
{
Render = new ImageRender(this, "Render");
Render.SetTexture(GetRoot<State>().GetService<AssetCollector>().GetAsset<Texture2D>("bullet"));
Render.Layer = .1f;
Render.Scale = new Vector2(.1f);
Render.Color = Color.White;
Render.LinkDependency(ImageRender.DEPENDENCY_BODY, Body);
//Make our collision rectangles the size of the rendered sprite.
Body.Bounds = Render.Bounds;
Body.Origin = new Vector2(Render.Texture.Width / 2f, Render.Texture.Height / 2f);
Shape = new Circle(this, "Shape", Body.Width / 2);
Shape.Offset = new Vector2(Body.Width / 2, Body.Height / 2);
Shape.LinkDependency(Circle.DEPENDENCY_BODY, Body);
Collision.Group.AddMask(1);
Collision.Pair.AddMask(2);
Collision.Immovable = true;
Collision.CollideEvent += collision => Recycle();
Collision.LinkDependency(Collision.DEPENDENCY_SHAPE, Shape);
Shape.LinkDependency(Circle.DEPENDENCY_COLLISION, Collision);
DeathTimer = new Timer(this, "DeathTimer");
DeathTimer.Milliseconds = 2000;
DeathTimer.LastEvent += Recycle;
DeathTimer.LastEvent += DeathTimer.Stop;
}
public SolverValidator(Solver solver, NodeCollection nodes, Node root, IPositionLookupTable<Node> transpositionTable)
{
this.solver = solver;
this.nodes = nodes;
this.root = root;
this.transpositionTable = transpositionTable;
}
public Tilemap(Node parent, string name, Texture2D tileTexture, Point size, Point tileSize)
: base(parent, name)
{
Body = new Body(this, "Body");
Render = new TilemapRender(this, "TilemapRender", tileTexture, size, tileSize);
Render.LinkDependency(TilemapRender.DEPENDENCY_BODY, Body);
}
public void doNeighborListUpdate(Node.NodeList neighborList)
{
Debug.WriteLine("doNeighborListUpdate");
lock (neighborListLock)
{
neighborListView.Items.Clear();
neighborListView.BeginUpdate();
Debug.WriteLine("Looping through neighbors");
foreach (Haggle.Node neighbor in neighborList.AsArray())
{
string ifaceStr = "";
Debug.WriteLine("Adding neighbor " + neighbor.GetName());
ListViewItem neighItem = new ListViewItem(neighbor.GetName());
foreach (Node.Interface iface in neighbor.InterfacesArray())
{
ifaceStr += iface.GetIdentifierStr() + ",";
}
char[] tc = { ',' };
neighItem.SubItems.Add(ifaceStr.TrimEnd(tc));
neighborListView.Items.Add(neighItem);
}
neighborListView.EndUpdate();
Debug.WriteLine("Neighborlist update end");
}
}
private static void SaveAllConncectedComponents(Node<int> node,
HashSet<int> visitedNodes, List<string> connectedComponents)
{
string graphs = string.Empty;
Stack<Node<int>> nodesStack = new Stack<Node<int>>();
nodesStack.Push(node);
while (nodesStack.Count > 0)
{
Node<int> currentNode = nodesStack.Pop();
visitedNodes.Add(currentNode.Value);
graphs += " -> " + currentNode.Value;
foreach (var child in currentNode.Children)
{
if (!visitedNodes.Contains(child.Value))
{
visitedNodes.Add(child.Value);
nodesStack.Push(child);
}
}
}
connectedComponents.Add(graphs.Substring(4));
}
public static void ElecticityUpdate(Game game, Node center)
{
Node tmp = center;
int Volt = game.getScore();
int In = game.getScore();
ElectricityCalcul(tmp, ref Volt, In, true, tmp);
}
static void ElectricityCalcul(Node actual, ref int VoltageColector, int Intensity, bool previous, Node From)
{
if (VoltageColector <= 0 || previous == false || actual._activatedByPlayer == false || Intensity == 0)
{
actual._activated = false;
}
else
{
if (VoltageColector < actual.getCost())
{
actual._activated = false;
}
else
{
actual._activated = true;
actual._intensity = Intensity;
VoltageColector = VoltageColector - actual.getCost();
}
}
int localVoltage = VoltageColector;
actual._peerOut.ForEach(delegate(Node other)
{
if (other != From)
ElectricityCalcul(other, ref localVoltage, (int)actual.energyDiv(), actual._activated, actual);
});
VoltageColector = localVoltage;
}
/*
* actual implementation of sandbox
*/
private static void SandboxCode(Node pars, Node ip)
{
// storing and clearing old whitelist
// and checking to see that no keyword not previously whitelisted has been whitelisted
Node oldWhitelist = null;
if (pars.Contains("_whitelist"))
{
foreach (Node idx in ip["whitelist"])
{
if (!pars["_whitelist"].Contains(idx.Name))
throw new HyperlispExecutionErrorException("cannot [whitelist] an active event that was blacklisted in a previous [sandbox]");
}
oldWhitelist = pars["_whitelist"].Clone();
pars["_whitelist"].Clear();
}
// setting new whitelist
pars["_whitelist"].AddRange(ip["whitelist"].Clone());
try
{
pars["_ip"].Value = ip["code"];
RaiseActiveEvent(
"magix.execute",
pars);
}
finally
{
pars["_whitelist"].UnTie();
if (oldWhitelist != null)
pars["_whitelist"].AddRange(oldWhitelist);
}
}
internal Node AddNode()
{
var nd = new Node();
nd.Index = Nodes.Count;
Nodes.Add(nd);
return nd;
}
//sets the ai nodes
void setNodes(Node n,Node e,Node s,Node w)
{
this.n = n;
this.e = e;
this.s = s;
this.w = w;
}
public static void Run()
{
// Initialize scene object
Scene scene = new Scene();
// Initialize Node class object
Node cubeNode = new Node("cube");
// Call Common class create mesh method to set mesh instance
Mesh mesh = Common.CreateMesh();
// Point node to the Mesh geometry
cubeNode.Entity = mesh;
// Set rotation
cubeNode.Transform.Rotation = Quaternion.FromRotation(new Vector3(0, 1, 0), new Vector3(0.3, 0.5, 0.1));
// Set translation
cubeNode.Transform.Translation = new Vector3(0, 0, 20);
// Add cube to the scene
scene.RootNode.ChildNodes.Add(cubeNode);
// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_GeometryAndHierarchy();
MyDir = MyDir + "TransformationToNode.fbx";
// Save 3D scene in the supported file formats
scene.Save(MyDir, FileFormat.FBX7400ASCII);
Console.WriteLine("\nTransformation added successfully to node.\nFile saved at " + MyDir);
}
public void Test_Distance()
{
var node1 = new Node ("Node1");
var col1 = new CollisionObject ();
col1.Shape = new BoxShape (1, 1, 1);
node1.Attach (col1);
var node2 = new Node ("Node2");
var col2 = new CollisionObject ();
col2.Shape = new BoxShape (1, 1, 1);
node2.Attach (col2);
var wld = new World ();
wld.AddChild (node1);
wld.AddChild (node2);
node1.Translate (0, 0, 0);
node2.Translate (0, 0, 0);
Assert.AreEqual (0, wld.Distance (node1, node2));
node1.Translate (0, 0, 0);
node2.Translate (10, 0, 0);
Assert.AreEqual (8, wld.Distance (node1, node2), 0.01f);
node1.Rotate (0, 0, 0, 0);
node2.Rotate (45, 0, 0, 1);
Assert.AreEqual (7.6f, wld.Distance (node1, node2), 0.01f);
node1.Detach (col1);
node2.Detach (col2);
Assert.AreEqual (Single.NaN, wld.Distance (node1, node2), 0.01f);
}
public void Test_Overlap()
{
var node1 = new Node ("Node1");
var col1 = new CollisionObject ();
col1.Shape = new BoxShape (1, 1, 1);
node1.Attach (col1);
var node2 = new Node ("Node1");
var col2 = new CollisionObject ();
col2.Shape = new BoxShape (1, 1, 1);
node2.Attach (col2);
var wld = new World ();
wld.AddChild (node1);
wld.AddChild (node2);
node1.Translate (0, 0, 0);
node2.Translate (0, 0, 0);
Assert.AreEqual (true, wld.Overlap (node1, node2));
node1.Translate (0, 0, 0);
node2.Translate (10, 0, 0);
Assert.AreEqual (false, wld.Overlap (node1, node2));
node1.Rotate (0, 0, 0, 0);
node2.Rotate (45, 0, 0, 1);
Assert.AreEqual (false, wld.Overlap (node1, node2));
node1.Detach (col1);
node2.Detach (col2);
Assert.AreEqual (false, wld.Overlap (node1, node2));
}
public DoorSensor(Node node)
: base(node)
{
node.GetCommandClass<Basic>().Changed += Basic_Changed;
node.GetCommandClass<SensorBinary>().Changed += SensorBinary_Changed;
node.GetCommandClass<SensorAlarm>().Changed += SensorAlarm_Changed;
}
private void CreateControls(Node node)
{
foreach(Node idx in node)
{
string caption = idx["Caption"].Get<string>();
string value = idx["Value"].Get<string>();
string type = idx["Type"].Get<string>();
int position = idx["Position"].Get<int>();
Panel pnl = new Panel();
pnl.CssClass = "bordered-panel";
Label cpt = new Label();
cpt.CssClass = "label-caption";
cpt.Text = caption;
pnl.Controls.Add(cpt);
Label val = new Label();
val.CssClass = "label-value";
val.Text = value;
pnl.Controls.Add(val);
// Rooting...
wrpPnl.Controls.Add(pnl);
}
}
/// <summary>
/// Validates and constructs generic entities out of an ambiguous generic definition entity.
/// </summary>
private IEntity ConstructAmbiguousEntity(Node constructionNode, Ambiguous ambiguousDefinition, IType[] typeArguments)
{
var checker = new GenericConstructionChecker(typeArguments, constructionNode);
var matches = new List<IEntity>(ambiguousDefinition.Entities);
bool reportErrors = false;
foreach (Predicate<IEntity> check in checker.Checks)
{
matches = matches.Collect(check);
if (matches.Count == 0)
{
Errors.Add(checker.Errors[0]); // only report first error, assuming the rest are superfluous
return TypeSystemServices.ErrorEntity;
}
if (reportErrors)
checker.ReportErrors(Errors);
checker.DiscardErrors();
// We only want full error reporting once we get down to a single candidate
if (matches.Count == 1)
reportErrors = true;
}
IEntity[] constructedMatches = Array.ConvertAll<IEntity, IEntity>(matches.ToArray(), def => MakeGenericEntity(def, typeArguments));
return Entities.EntityFromList(constructedMatches);
}
public void Test_CollideWith()
{
var node1 = new Node ("Node1");
node1.Attach(new CollisionObject ());
node1.CollisionObject.Shape = new BoxShape (1, 1, 1);
node1.GroupID = 1;
var node2 = new Node ("Node2");
node2.Attach (new CollisionObject ());
node2.CollisionObject.Shape = new BoxShape (1, 1, 1);
node2.GroupID = 2;
var wld = new World ();
wld.AddChild (node1);
wld.AddChild (node2);
node1.CollisionObject.CollideWith = -1;
Assert.AreEqual (true, wld.Overlap (node1, node2));
node1.CollisionObject.CollideWith = 1;
Assert.AreEqual (false, wld.Overlap (node1, node2));
node1.CollisionObject.CollideWith = 2;
Assert.AreEqual (true, wld.Overlap (node1, node2));
node1.CollisionObject.CollideWith = 2;
node1.CollisionObject.IgnoreWith = 2;
Assert.AreEqual (false, wld.Overlap (node1, node2));
}
public MoshParser(ILexer lexer)
{
m_startRuleToken = new Token { TokenType = TokenType.NEW_RULE };
m_tree = new Node<string>();
m_lexer = lexer;
m_consumed = new Stack<Token>();
m_err = new Queue<Error>();
// Setup rule pre-calling conditions
m_rulePreHook = name =>
{
if (m_tree.Value == null)
{
m_tree.Value = name;
return m_tree;
}
var tempNode = m_tree;
var newTopNode = m_tree.AddChild(name);
m_tree = newTopNode;
return tempNode;
};
// Setup rule post-calling conditions
m_rulePostHook = node => m_tree = node;
}
public void Setup()
{
listener = new TestListener();
node = new Node(NodeId.Create(), new IPEndPoint(IPAddress.Any, 0));
engine = new DhtEngine(listener);
//engine.Add(node);
}
public NodeViewModel(Node node, Vector location, IControlTypesResolver controlTypesResolver)
{
Node = node;
Title = node.Title;
Location = new CanvasPoint(location);
ControlTypesResolver = controlTypesResolver;
foreach (var pin in node.InputPins)
{
AddInputPin(pin);
}
foreach (var pin in node.OutputPins)
{
AddOutputPin(pin);
}
node.Processed += OnNodeProcessed;
node.PinsChanged += OnNodePinsChanged;
_disposable = Disposable.Create(() =>
{
node.PinsChanged -= OnNodePinsChanged;
node.Processed -= OnNodeProcessed;
});
}
public void CircularDependency_ThrowsCircularDependencyException_Test()
{
var a = new Node<object>("a");
var b = new Node<object>("b");
var c = new Node<object>("c");
var d = new Node<object>("d");
var e = new Node<object>("e");
a.Edges.Add(b); // a depends on b
a.Edges.Add(d); // a depends on d
b.Edges.Add(c); // b depends on c
b.Edges.Add(e); // b depends on e
c.Edges.Add(d); // c depends on d
c.Edges.Add(e); // c depends on e
d.Edges.Add(b); // d depends on b
var resolved = new List<Node<object>>();
CircularDependencyException<object> exception = null;
try
{
a.ResolveDependencies();
}
catch (CircularDependencyException<object> ex)
{
exception = ex;
}
Assert.NotNull(exception);
Assert.Equal(d, exception.A);
Assert.Equal(b, exception.B);
}
private void GrowTable(Tables tables)
{
const int maxArrayLength = 0X7FEFFFFF;
var locksAcquired = 0;
try
{
// The thread that first obtains _locks[0] will be the one doing the resize operation
AcquireLocks(0, 1, ref locksAcquired);
// Make sure nobody resized the table while we were waiting for lock 0:
if (tables != _tables)
{
// We assume that since the table reference is different, it was already resized (or the budget
// was adjusted). If we ever decide to do table shrinking, or replace the table for other reasons,
// we will have to revisit this logic.
return;
}
// Compute the (approx.) total size. Use an Int64 accumulation variable to avoid an overflow.
long approxCount = 0;
for (var i = 0; i < tables.CountPerLock.Length; i++)
{
approxCount += tables.CountPerLock[i];
}
//
// If the bucket array is too empty, double the budget instead of resizing the table
//
if (approxCount < tables.Buckets.Length / 4)
{
_budget = 2 * _budget;
if (_budget < 0)
{
_budget = int.MaxValue;
}
return;
}
// Compute the new table size. We find the smallest integer larger than twice the previous table size, and not divisible by
// 2,3,5 or 7. We can consider a different table-sizing policy in the future.
var newLength = 0;
var maximizeTableSize = false;
try
{
checked
{
// Double the size of the buckets table and add one, so that we have an odd integer.
newLength = tables.Buckets.Length * 2 + 1;
// Now, we only need to check odd integers, and find the first that is not divisible
// by 3, 5 or 7.
while (newLength % 3 == 0 || newLength % 5 == 0 || newLength % 7 == 0)
{
newLength += 2;
}
Debug.Assert(newLength % 2 != 0);
if (newLength > maxArrayLength)
{
maximizeTableSize = true;
}
}
}
catch (OverflowException)
{
maximizeTableSize = true;
}
if (maximizeTableSize)
{
newLength = maxArrayLength;
// We want to make sure that GrowTable will not be called again, since table is at the maximum size.
// To achieve that, we set the budget to int.MaxValue.
//
// (There is one special case that would allow GrowTable() to be called in the future:
// calling Clear() on the ConcurrentHashSet will shrink the table and lower the budget.)
_budget = int.MaxValue;
}
// Now acquire all other locks for the table
AcquireLocks(1, tables.Locks.Length, ref locksAcquired);
var newLocks = tables.Locks;
// Add more locks
if (_growLockArray && tables.Locks.Length < MaxLockNumber)
{
newLocks = new object[tables.Locks.Length * 2];
Array.Copy(tables.Locks, 0, newLocks, 0, tables.Locks.Length);
for (var i = tables.Locks.Length; i < newLocks.Length; i++)
{
newLocks[i] = new object();
}
}
var newBuckets = new Node[newLength];
var newCountPerLock = new int[newLocks.Length];
// Copy all data into a new table, creating new nodes for all elements
for (var i = 0; i < tables.Buckets.Length; i++)
{
var current = tables.Buckets[i];
while (current != null)
{
var next = current.Next;
GetBucketAndLockNo(current.Hashcode, out int newBucketNo, out int newLockNo, newBuckets.Length, newLocks.Length);
newBuckets[newBucketNo] = new Node(current.Item, current.Hashcode, newBuckets[newBucketNo]);
checked
{
newCountPerLock[newLockNo]++;
}
current = next;
}
}
// Adjust the budget
_budget = Math.Max(1, newBuckets.Length / newLocks.Length);
// Replace tables with the new versions
_tables = new Tables(newBuckets, newLocks, newCountPerLock);
}
finally
{
// Release all locks that we took earlier
ReleaseLocks(0, locksAcquired);
}
}
public void Filter(List <string> companyNames)
{
List <Company> retainedCompanies = new List <Company>();
List <Division> retainedDivisions = new List <Division>();
List <Station> retainedStations = new List <Station>();
List <Station> stationsToRemove = new List <Station>();
List <Node> retainedNodes = new List <Node>();
List <Node> nodesToRemove = new List <Node>();
List <LineSegment> lineSegmentsToRemove = new List <LineSegment>();
List <TransmissionLine> transmissionLinesToRemove = new List <TransmissionLine>();
List <CircuitBreaker> circuitBreakersToRemove = new List <CircuitBreaker>();
List <Shunt> shuntsToRemove = new List <Shunt>();
List <Transformer> transformersToRemove = new List <Transformer>();
List <TransformerTap> retainedTaps = new List <TransformerTap>();
List <ParentTransformer> parentTransformersToRemove = new List <ParentTransformer>();
Console.WriteLine("1");
// Line segments, companies, stations
Parallel.ForEach(m_lineSegments, (lineSegment) =>
{
string fromNodeId = $"{lineSegment.FromStationName}_{lineSegment.FromNodeId}";
string toNodeId = $"{lineSegment.ToStationName}_{lineSegment.ToNodeId}";
Node fromNode = m_nodes.Find(x => $"{x.StationName}_{x.Id}" == fromNodeId);
Node toNode = m_nodes.Find(x => $"{x.StationName}_{x.Id}" == toNodeId);
Company fromCompany = GetNodeCompany(fromNode);
Company toCompany = GetNodeCompany(toNode);
Station fromStation = m_stations.Find(x => x.Name == lineSegment.FromStationName);
Station toStation = m_stations.Find(x => x.Name == lineSegment.ToStationName);
if (companyNames.Contains(fromCompany.Name) || companyNames.Contains(toCompany.Name))
{
if (!retainedStations.Contains(fromStation))
{
retainedStations.Add(fromStation);
}
if (!retainedStations.Contains(toStation))
{
retainedStations.Add(toStation);
}
if (!retainedNodes.Contains(fromNode))
{
retainedNodes.Add(fromNode);
}
if (!retainedNodes.Contains(toNode))
{
retainedNodes.Add(toNode);
}
if (!retainedCompanies.Contains(fromCompany))
{
retainedCompanies.Add(fromCompany);
}
if (!retainedCompanies.Contains(toCompany))
{
retainedCompanies.Add(toCompany);
}
}
else
{
if (!lineSegmentsToRemove.Contains(lineSegment))
{
lineSegmentsToRemove.Add(lineSegment);
}
if (!stationsToRemove.Contains(fromStation))
{
stationsToRemove.Add(fromStation);
}
if (!stationsToRemove.Contains(toStation))
{
stationsToRemove.Add(toStation);
}
}
});
Console.WriteLine("2");
// Transmission Lines
foreach (LineSegment lineSegment in lineSegmentsToRemove)
{
TransmissionLine transmissionLine = m_transmissionLines.Find(x => x.Id == lineSegment.TransmissionLineId);
if (!transmissionLinesToRemove.Contains(transmissionLine))
{
transmissionLinesToRemove.Add(transmissionLine);
}
}
Console.WriteLine("3");
// Nodes
foreach (Station station in stationsToRemove)
{
List <Node> stationNodes = m_nodes.FindAll(x => x.StationName == station.Name);
foreach (Node node in stationNodes)
{
if (!nodesToRemove.Contains(node))
{
nodesToRemove.Add(node);
}
}
}
Console.WriteLine("4");
// Divisions
foreach (Station station in retainedStations)
{
List <Node> stationNodes = m_nodes.FindAll(x => x.StationName == station.Name);
foreach (Node node in stationNodes)
{
Division division = m_divisions.Find(x => x.Name == node.DivisionName);
if (!retainedDivisions.Contains(division))
{
retainedDivisions.Add(division);
}
}
}
Console.WriteLine("5");
// Circuit breakers
foreach (CircuitBreaker breaker in m_circuitBreakers)
{
Station parentStation = m_stations.Find(x => x.Name == breaker.StationName);
if (stationsToRemove.Contains(parentStation))
{
if (!circuitBreakersToRemove.Contains(breaker))
{
circuitBreakersToRemove.Add(breaker);
}
}
}
Console.WriteLine("6");
// shunts
foreach (Shunt shunt in m_shunts)
{
Station parentStation = m_stations.Find(x => x.Name == shunt.StationName);
if (stationsToRemove.Contains(parentStation))
{
if (!shuntsToRemove.Contains(shunt))
{
shuntsToRemove.Add(shunt);
}
}
}
Console.WriteLine("7");
// Transformers and Transformer Taps
foreach (Transformer transformer in m_transformers)
{
Station parentStation = m_stations.Find(x => x.Name == transformer.StationName);
if (stationsToRemove.Contains(parentStation))
{
if (!transformersToRemove.Contains(transformer))
{
transformersToRemove.Add(transformer);
}
}
else
{
TransformerTap fromTap = m_transformerTaps.Find(x => x.Id == transformer.FromNodeTap);
TransformerTap toTap = m_transformerTaps.Find(x => x.Id == transformer.ToNodeTap);
if (!retainedTaps.Contains(fromTap))
{
retainedTaps.Add(fromTap);
}
if (!retainedTaps.Contains(toTap))
{
retainedTaps.Add(toTap);
}
}
}
Console.WriteLine("8");
// Parent Transformer
foreach (Transformer transformer in transformersToRemove)
{
ParentTransformer parentTransformer = m_parentTransformers.Find(x => x.Id == transformer.Parent);
if (!parentTransformersToRemove.Contains(parentTransformer))
{
parentTransformersToRemove.Add(parentTransformer);
}
}
m_companies = retainedCompanies;
m_divisions = retainedDivisions;
m_transformerTaps = retainedTaps;
Console.WriteLine("9");
foreach (Station station in stationsToRemove)
{
m_stations.Remove(station);
}
foreach (LineSegment lineSegment in lineSegmentsToRemove)
{
m_lineSegments.Remove(lineSegment);
}
foreach (Node node in nodesToRemove)
{
m_nodes.Remove(node);
}
foreach (Shunt shunt in shuntsToRemove)
{
m_shunts.Remove(shunt);
}
foreach (CircuitBreaker breaker in circuitBreakersToRemove)
{
m_circuitBreakers.Remove(breaker);
}
foreach (Transformer transformer in transformersToRemove)
{
m_transformers.Remove(transformer);
}
foreach (ParentTransformer transformer in parentTransformersToRemove)
{
m_parentTransformers.Remove(transformer);
}
foreach (TransmissionLine transmissionLine in transmissionLinesToRemove)
{
m_transmissionLines.Remove(transmissionLine);
}
}
void Update()
{
//Clear influecing nodes!
foreach (Node node in nodes)
{
node.InfluencingAttractors.Clear();
}
List <int> attractorRemovalIndexes = new List <int>();
List <Node> addedNodes = new List <Node>(); //All new nodes
//Debug.Log("Amount of attractors [" + attractors.Count + "], Anmount of nodes [" + nodes.Count + "]", gameObject);
//Check every attractor on nearby nodes
for (int attractorIndex = 0; attractorIndex < attractors.Count; attractorIndex++)
{
Attractor attractor = attractors[attractorIndex];
attractor.AttractingNode = null;
//Check if there was an previous distance
float shortestDistanceSquared = float.MaxValue;
if (attractor.PreviousAttractingNode != null)
{
shortestDistanceSquared = (attractor.Position - attractor.PreviousAttractingNode.Position).sqrMagnitude;
//Debug.Log("Previous node found! Tested distance squared= " + shortestDistanceSquared, gameObject);
}
bool removed = false;
//Get closest node -> Influencing nodes
for (int nodeIndex = 0; nodeIndex < nodes.Count; nodeIndex++)
{
Node node = nodes[nodeIndex];
float newDistanceSquared = (attractor.Position - node.Position).SqrMagnitude();
//Debug.Log("New distance towards attractor" + newDistanceSquared, gameObject);
//Check if attractor needs to be removed
if (newDistanceSquared <= attractorKillDistance)
{
//Debug.Log("Attractor will be removed", gameObject);
attractorRemovalIndexes.Add(attractorIndex);
removed = true;
break;
}
//Check if attractor is in attraction radius
if (newDistanceSquared <= attractionRadius)
{
if (shortestDistanceSquared >= newDistanceSquared)
{
//Debug.Log("Attractor will attract node", gameObject);
shortestDistanceSquared = newDistanceSquared;
if (attractor.AttractingNode != null)
{
attractor.AttractingNode.InfluencingAttractors.Remove(attractor);
}
attractor.AttractingNode = node;
node.InfluencingAttractors.Add(attractor);
}
}
}
if (!removed)
{
//If there was no new node found (could be because of a smaller distance) but there was a previous valid node
//BUG SPLASH!!!!
//if (attractor.AttractingNode == null && attractor.PreviousAttractingNode != null)
//{
// GameObject newBranch = Instantiate(branch, gameObject.transform.position + (Vector3)attractor.PreviousAttractingNode.Position, new Quaternion(), attractor.PreviousAttractingNode.Branch.transform);
// GrowingSpline branchSpline = newBranch.GetComponent<GrowingSpline>();
// branchSpline.GrowthDirection = (attractor.Position - attractor.PreviousAttractingNode.Position).normalized;
// branchSpline.SpriteShape = branchGrowthController.gameObject.GetComponent<GrowingSpline>().SpriteShape;
// BranchController newBranchController = newBranch.GetComponent<BranchController>();
// addedNodes.Add(newBranchController.BranchTopNode);
// newBranchController.NodeOffset = attractor.PreviousAttractingNode.Position;
//}
}
else
{
attractor.AttractingNode = null; // node got deleted! Needs to be here otherwise next frame a new branch would appear
}
//Set previous node for next frame
if (attractor.AttractingNode != null)
{
attractor.PreviousAttractingNode = new Node(attractor.AttractingNode);
}
else
{
attractor.PreviousAttractingNode = null;
}
}
//Remove the attractors that need to be removed
foreach (int removalIndex in attractorRemovalIndexes)
{
attractors.RemoveAt(removalIndex);
}
//Add all new nodes
foreach (Node node in addedNodes)
{
nodes.Add(node);
}
//Check if still growing branches
if (GetComponentInChildren <GrowingSpline>() == null)
{
Destroy(gameObject);
}
}
/// <summary> /// Finds all current nodes. /// </summary> /// <param name="expression">The expression.</param> /// <returns>The current nodes.</returns> public IEnumerable <VariableNode> CurrentNodes(Node expression) => Build(expression).Where(n => n.NodeType == NodeTypes.Current);
/// <summary> /// Finds all voltage nodes. /// </summary> /// <param name="expression">The expression node.</param> /// <returns>The voltage nodes.</returns> public IEnumerable <VariableNode> VoltageNodes(Node expression) => Build(expression).Where(n => n.NodeType == NodeTypes.Voltage);
public Node CreateNodeClient(NodeConnectionParameters parameters)
{
return(Node.Connect(Network.RegTest, "127.0.0.1:" + this.ports[0].ToString(), parameters));
}
public Node CreateNodeClient()
{
return(Node.Connect(Network.RegTest, "127.0.0.1:" + this.ports[0].ToString()));
}
public Node(Node other)
{
this.Position = other.Position;
this.Branch = other.Branch;
}
private void Arg_OnValueUpdated(Node n)
{
UpdateInputs();
}
private void SelectedFunction_OnOutputSet(Node n)
{
UpdateInputs();
}
private void SelectedFunction_OnArgRemoved(Node n)
{
n.OnValueUpdated -= Arg_OnValueUpdated;
UpdateInputs();
}
private void SelectedFunction_OnArgAdded(Node n)
{
n.OnValueUpdated += Arg_OnValueUpdated;
UpdateInputs();
}
// Update is called once per frame
void Update()
{
if (player != null)
{
if (player.IsAtTarget())
{
Node node = GetOverlap(player);
if (node != null && node.risk > 0 && node != actionedNode)
{
actionedNode = node;
}
if (node != null)
{
Goal goal = node.gameObject.GetComponent <Goal>();
if (goal != null)
{
reachedGoal = goal;
}
Pickup pickup = node.pickup;
if (pickup != null && !pickup.consumed)
{
if (pickup.type == Pickup.PickupType.HEALTH)
{
pickup.Consume();
node.UpdateRiskText();
explosionHandler.PickupPlant(pickup.gameObject.transform.position + new Vector3(0, 0.4f, 0.4f));
playerHealth += pickup.amount;
}
}
GameInfo gameInfo = node.gameObject.GetComponentInChildren <GameInfo>();
if (gameInfo != null && !gameInfo.isShown)
{
ConvoHandler convoHandler = FindObjectOfType <ConvoHandler>();
convoHandler.ShowInfo(gameInfo);
gameInfo.Consume();
}
}
}
if (waypoints.Count > 0)
{
if (waypoints.Count > 1)
{
player.targetPos = waypoints[waypoints.Count - 1].transform.position;
}
else
{
if (selectedNode != null && selectedNode.risk > 0)
{
Vector3 direction = Vector3.Normalize(selectedNode.transform.position - selectedPlayer.transform.position);
selectedPlayer.targetPos = selectedNode.transform.position - (direction * 1f);
}
else
{
player.targetPos = waypoints[waypoints.Count - 1].transform.position;
}
}
if (player.IsAtTarget())
{
waypoints.Remove(waypoints[waypoints.Count - 1]);
}
}
}
if (isRolling)
{
diceResult = UnityEngine.Random.Range(1, 7);
}
else
{
diceResult = -100;
}
}
public override void AssignParentNode(Node n)
{
base.AssignParentNode(n);
OnParentSet();
}
private bool AddInternal(T item, int hashcode, bool acquireLock)
{
while (true)
{
var tables = _tables;
GetBucketAndLockNo(hashcode, out int bucketNo, out int lockNo, tables.Buckets.Length, tables.Locks.Length);
var resizeDesired = false;
var lockTaken = false;
try
{
if (acquireLock)
Monitor.Enter(tables.Locks[lockNo], ref lockTaken);
// If the table just got resized, we may not be holding the right lock, and must retry.
// This should be a rare occurrence.
if (tables != _tables)
{
continue;
}
// Try to find this item in the bucket
Node previous = null;
for (var current = tables.Buckets[bucketNo]; current != null; current = current.Next)
{
Debug.Assert(previous == null && current == tables.Buckets[bucketNo] || previous.Next == current);
if (hashcode == current.Hashcode && _comparer.Equals(current.Item, item))
{
return false;
}
previous = current;
}
// The item was not found in the bucket. Insert the new item.
Volatile.Write(ref tables.Buckets[bucketNo], new Node(item, hashcode, tables.Buckets[bucketNo]));
checked
{
tables.CountPerLock[lockNo]++;
}
//
// If the number of elements guarded by this lock has exceeded the budget, resize the bucket table.
// It is also possible that GrowTable will increase the budget but won't resize the bucket table.
// That happens if the bucket table is found to be poorly utilized due to a bad hash function.
//
if (tables.CountPerLock[lockNo] > _budget)
{
resizeDesired = true;
}
}
finally
{
if (lockTaken)
Monitor.Exit(tables.Locks[lockNo]);
}
//
// The fact that we got here means that we just performed an insertion. If necessary, we will grow the table.
//
// Concurrency notes:
// - Notice that we are not holding any locks at when calling GrowTable. This is necessary to prevent deadlocks.
// - As a result, it is possible that GrowTable will be called unnecessarily. But, GrowTable will obtain lock 0
// and then verify that the table we passed to it as the argument is still the current table.
//
if (resizeDesired)
{
GrowTable(tables);
}
return true;
}
}
public static bool InvalidateByNode(Node node)
{
return ApplicationStorage.Instance.InvalidateByNodeInternal(node);
}
public async Task<Measure> GetBatteryLevel()
{
var value = (await Node.GetCommandClass<Battery>().Get()).Value;
return new Measure(value, Unit.Percentage);
}
public Company GetNodeCompany(Node node)
{
return(m_companies.Find(x => x.Name == node.CompanyName));
}
public async Task<TimeSpan> GetWakeUpInterval()
{
return (await Node.GetCommandClass<WakeUp>().GetInterval()).Interval;
}
public async Task Sleep()
{
await Node.GetCommandClass<WakeUp>().NoMoreInformation();
}
private Dictionary<ExitPoint, List<Node>> findPathsToEnd(Node endNode, Cluster endCluster)
{
return null;
}
public async Task SetWakeUpInterval(TimeSpan value)
{
var controllerNodeID = await Node.Controller.GetNodeId();
await Node.GetCommandClass<WakeUp>().SetInterval(value, controllerNodeID);
}
internal void ReloadMapping(RelayNodeClusterDefinition relayNodeClusterDefinition, RelayNodeConfig newConfig, ForwardingConfig forwardingConfig)
{
_minimumId = relayNodeClusterDefinition.MinId;
_maximumId = relayNodeClusterDefinition.MaxId;
//figure out if anything changed. if it did, rebuild
bool rebuild = false;
ushort newLocalZone = newConfig.GetLocalZone();
if (newLocalZone != _localZone)
{
rebuild = true;
_localZone = newLocalZone;
}
else
{
if ((_zoneDefinitions == null && newConfig.RelayNodeMapping.ZoneDefinitions != null) ||
(_zoneDefinitions != null && newConfig.RelayNodeMapping.ZoneDefinitions == null) ||
(_zoneDefinitions != null && !_zoneDefinitions.Equals(newConfig.RelayNodeMapping.ZoneDefinitions)))
{
rebuild = true;
_zoneDefinitions = newConfig.RelayNodeMapping.ZoneDefinitions;
}
}
int effectiveSize = (!_meInThisCluster ? Nodes.Count : Nodes.Count + 1);
//if there's a different number of nodes, we definitely have to rebuild
if (relayNodeClusterDefinition.RelayNodes.Length != effectiveSize)
{
if (log.IsInfoEnabled)
{
log.InfoFormat("Number of nodes in a cluster in group {0} changed from {1} to {2}, rebuilding", _nodeGroup.GroupName, effectiveSize, relayNodeClusterDefinition.RelayNodes.Length);
}
rebuild = true;
}
else
{
//if any of the nodes we do have aren't in the config, rebuild
foreach (Node node in Nodes)
{
if (!relayNodeClusterDefinition.ContainsNode(node.EndPoint.Address, node.EndPoint.Port))
{
if (log.IsInfoEnabled)
{
log.InfoFormat("Node {0} is no longer found in its cluster in group {1}, rebuilding.",
node, _nodeGroup.GroupName);
}
rebuild = true;
break;
}
}
if (!rebuild && _meInThisCluster)
{
if (!relayNodeClusterDefinition.ContainsNode(Me.EndPoint.Address, Me.EndPoint.Port))
{
if (log.IsInfoEnabled)
{
log.InfoFormat("Node {0} (this machine) is no longer found in its cluster in group {1}, rebuilding.",
Me, _nodeGroup.GroupName);
}
rebuild = true;
}
}
//or if there are any nodes in the config that aren't here, rebuild
if (!rebuild)
{
foreach (RelayNodeDefinition nodeDefinition in relayNodeClusterDefinition.RelayNodes)
{
if (!ContainsNode(nodeDefinition))
{
if (log.IsInfoEnabled)
{
log.InfoFormat("Node {0} is defined in the new config but does not exist in this cluster in group {1}, rebuilding.",
nodeDefinition, _nodeGroup.GroupName);
}
rebuild = true;
break;
}
}
}
}
if (rebuild)
{
List <Node> newNodes = new List <Node>();
RelayNodeDefinition meDefinition = newConfig.GetMyNode();
DispatcherQueue nodeInQueue, nodeOutQueue;
if (meDefinition != null)
{
GetMessageQueuesFor(GetMessageQueueNameFor(meDefinition), relayNodeClusterDefinition,
NodeManager.Instance.InMessageDispatcher, NodeManager.Instance.OutMessageDispatcher,
out nodeInQueue, out nodeOutQueue);
//Me is in the new config
//Either create it new or overwrite the old one
Me = new Node(meDefinition, _nodeGroup, this, forwardingConfig,
nodeInQueue, nodeOutQueue);
}
else
{
//me is NOT in the new config.
Me = null;
}
ushort maxDetectedZone = _localZone;
foreach (RelayNodeDefinition nodeDefinition in relayNodeClusterDefinition.RelayNodes)
{
if (nodeDefinition != meDefinition)
{
GetMessageQueuesFor(GetMessageQueueNameFor(nodeDefinition), relayNodeClusterDefinition,
NodeManager.Instance.InMessageDispatcher, NodeManager.Instance.OutMessageDispatcher,
out nodeInQueue, out nodeOutQueue);
Node node = new Node(nodeDefinition, _nodeGroup, this, forwardingConfig,
nodeInQueue, nodeOutQueue);
newNodes.Add(node);
if (node.Zone > maxDetectedZone)
{
maxDetectedZone = node.Zone;
}
}
}
Nodes = newNodes;
_nodesByZone = CalculateNodesByZone(Nodes, maxDetectedZone);
lock (_chooseLock)
{
ChosenNode = null;
}
ChosenZoneNodes = new Dictionary <ushort, Node>();
}
else
{
//just reload the configs to get any new network or queue settings
bool hitMe = false;
string meString = String.Empty;
if (Me != null)
{
meString = Me.ToString();
}
for (int i = 0; i < relayNodeClusterDefinition.RelayNodes.Length; i++)
{
string definitionString = relayNodeClusterDefinition.RelayNodes[i].Host + ":" + relayNodeClusterDefinition.RelayNodes[i].Port;
if (definitionString == meString && Me != null)
{
hitMe = true;
Me.ReloadMapping(relayNodeClusterDefinition.RelayNodes[i], forwardingConfig);
}
else
{
Nodes[(hitMe ? i - 1 : i)].ReloadMapping(relayNodeClusterDefinition.RelayNodes[i], forwardingConfig);
}
}
lock (_chooseLock)
{
ChosenNode = null;
}
}
}
public BatteryDevice(Node node)
: base(node)
{
node.GetCommandClass<WakeUp>().Changed += WakeUp_Changed;
}
public override IAnalysisSet GetMember(Node node, AnalysisUnit unit, string name)
{
IAnalysisSet res = null;
switch (name)
{
case "Any":
res = AnalysisSet.Empty;
break;
case "Callable":
case "Generic":
case "Optional":
case "Tuple":
case "Union":
case "Container":
case "ItemsView":
case "Iterable":
case "Iterator":
case "KeysView":
case "Mapping":
case "MappingView":
case "MutableMapping":
case "MutableSequence":
case "MutableSet":
case "Sequence":
case "ValuesView":
case "Dict":
case "List":
case "Set":
case "FrozenSet":
case "NamedTuple":
case "Generator":
case "ClassVar":
res = new TypingTypeInfo(name, _inner.GetMember(node, unit, name)?.FirstOrDefault());
break;
case "AbstractSet": break;
case "GenericMeta": break;
// As our purposes are purely informational, it's okay to
// "round up" to the nearest type. That said, proper protocol
// support would be nice to implement.
case "ContextManager": break;
case "Hashable": break;
case "Reversible": break;
case "SupportsAbs": break;
case "SupportsBytes": res = GetBuiltin(BuiltinTypeId.Bytes); break;
case "SupportsComplex": res = GetBuiltin(BuiltinTypeId.Complex); break;
case "SupportsFloat": res = GetBuiltin(BuiltinTypeId.Float); break;
case "SupportsInt": res = GetBuiltin(BuiltinTypeId.Int); break;
case "SupportsRound": break;
case "Sized": break;
case "Counter": res = Import("collections", "Counter", node, unit); break;
case "Deque": res = Import("collections", "deque", node, unit); break;
case "DefaultDict": res = Import("collections", "defaultdict", node, unit); break;
case "Type": res = GetBuiltin(BuiltinTypeId.Type); break;
case "ByteString": res = GetBuiltin(BuiltinTypeId.Bytes); break;
case "AnyStr": res = GetBuiltin(BuiltinTypeId.Unicode).Union(GetBuiltin(BuiltinTypeId.Bytes), canMutate: false); break;
case "Text": res = GetBuiltin(BuiltinTypeId.Str); break;
// TypeVar is not actually a synonym for NewType, but it is close enough for our purposes
case "TypeVar":
case "NewType": res = GetFunction(node, unit, name, NewType_Call); break;
// The following are added depending on presence
// of their non-generic counterparts in stdlib:
// Awaitable
// AsyncIterator
// AsyncIterable
// Coroutine
// Collection
// AsyncGenerator
// AsyncContextManager
}
return(res ?? _inner.GetMember(node, unit, name));
}
private Dictionary<ExitPoint, List<Node>> findPathsFromStart(Node startNode, Cluster startCluster)
{
return null;
}
protected override void OnContextMenuOpening(ContextMenuEventArgs e) {
if (Node != null)
Node.ShowContextMenu(e);
}
//Export excel as json
public byte[] ExportFileAsJson(byte[] file)
{
try
{
Node startNode = new Node(), aux, lastNode = startNode, endNode = null;
startNode.name = "ROOT";
byte[] bin = file;
List <string> excelData = new List <string>();
//create a new Excel package in a memorystream
using (MemoryStream stream = new MemoryStream(bin))
using (ExcelPackage excelPackage = new ExcelPackage(stream))
{
//loop all worksheets
foreach (ExcelWorksheet worksheet in excelPackage.Workbook.Worksheets)
{
//loop all rows
for (int i = 2; i <= worksheet.Dimension.End.Row; i++)
{
//loop all columns in a row
for (int j = worksheet.Dimension.Start.Column; j <= worksheet.Dimension.End.Column; j++)
{
//add the cell data to the List
if (worksheet.Cells[i, j].Value != null)
{
string[] rowReader;
//check if first or second column
if (j % 2 != 0)
{
//split first row by '.'
rowReader = worksheet.Cells[i, j].Value.ToString().Split('.');
for (int k = 0; k < rowReader.Length; k++)
{
if (!lastNode.childs.ContainsKey(rowReader[k]))
{
aux = new Node();
aux.name = rowReader[k];
aux.parent = lastNode;
aux.height = aux.parent.height + 1;
aux.getNumber = lastNode.childsNumber + 1;
lastNode.childs.Add(aux.name, aux);
lastNode.childsNumber++;
lastNode = aux;
endNode = aux;
}
else
{
lastNode = lastNode.childs[rowReader[k]];
endNode = lastNode;
}
}
lastNode = startNode;
}
else
{
endNode.value = worksheet.Cells[i, j].Value.ToString();
}
}
}
}
}
}
// Set a variable to the Documents path.
string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
BinaryFormatter bf = new BinaryFormatter();
using (var convertByte = new MemoryStream())
{
string testFail = PrintTree(startNode, true, startNode.childsNumber);
Console.WriteLine(testFail);
//Convert tree to json in string
//Convert the string to json object
JObject o = JObject.Parse(PrintTree(startNode, true, startNode.childsNumber));
bf.Serialize(convertByte, JsonConvert.SerializeObject(o));
return(convertByte.ToArray());
}
}
catch (Exception e)
{
throw new Exception("Error! Something went wrong!" + e);
}
}
private void MovePlayerAction(Player player, Node node)
{
lastValidPosition = player.transform.position;
player.targetPos = node.transform.position;
}
public Node(T item, int hashcode, Node next)
{
Item = item;
Hashcode = hashcode;
Next = next;
}
