/// <summary>
        /// Applies coulomb repulsion to both points
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="k">coefficient of attraction</param>
        /// <param name="f1">Force at point a</param>
        /// <param name="f2">Force at point b</param>
        public static void ApplyCoulombRepulsion(NodeState a, NodeState b, double k)
        {
            double dx = a.Position.X - b.Position.X;
            double dy = a.Position.Y - b.Position.Y;
            double sqDist = dx * dx + dy * dy;
            if (sqDist == 0)
                return;
            double d = Math.Sqrt(sqDist);

            double mag = 1.0 / sqDist; // Force magnitude

            mag -= AttractionConstant * d; // plus WEAK attraction

            mag *= k;

            if (mag > MAGNITUDE_MAX)
                mag = MAGNITUDE_MAX; // Clip maximum

            double tempX = mag * (dx / d);
            double tempY = mag * (dy / d);

            if (!a.IsFrozen)
            {
                a.Force.X += tempX;
                a.Force.Y += tempY;
            }

            if (!b.IsFrozen)
            {
                b.Force.X -= tempX;
                b.Force.Y -= tempY;
            }
        }

 public NodeComponent(string myLevelName,string myLevelID,NodeState myNodeState,List<string> myConnectedTo)
 {
     this.name = "NodeComponent";
     levelName = myLevelName;
     id = myLevelID;
     nodeState = myNodeState;
 }

        /// <summary>
        /// Initializes the object as a collection of counters which change value on read.
        /// </summary>
        protected override void OnAfterCreate(ISystemContext context, NodeState node)
        {
            base.OnAfterCreate(context, node);

            UpdateStateVariable(context, Objects.ExclusiveLimitStateMachineType_High, CurrentState);
            UpdateTransitionVariable(context, 0, LastTransition);
        }

        /// <summary>
        /// Initializes the object as a collection of counters which change value on read.
        /// </summary>
        protected override void OnAfterCreate(ISystemContext context, NodeState node)
        {
            base.OnAfterCreate(context, node);

            this.Simulation.OnAfterTransition = OnControlSimulation;
            m_random = new Random();
        }

			public float findMaxUtility(NodeState futureState)
			{
				float maxUtility = float.MinValue;
		

				if (futureState.RValue != 0 && futureState.RValue > maxUtility  /*&& x_diff != -1*/) {
					maxUtility = futureState.RValue;
				}
				if (futureState.LValue != 0 && futureState.LValue > maxUtility /*&& x_diff != 1*/) {
						maxUtility = futureState.LValue;
				}
				if (futureState.FValue != 0 &&futureState.FValue > maxUtility /*&& z_diff != -1*/  ) {
						maxUtility = futureState.FValue;
				}
				if (futureState.BValue != 0 &&futureState.BValue > maxUtility/*  && z_diff != 1 */) {
						maxUtility = futureState.BValue;
				}

				if (maxUtility == float.MinValue) {
					maxUtility = float.Epsilon;
				}

				return maxUtility;

			}

        /// <summary>
        /// Initializes the object as a collection of counters which change value on read.
        /// </summary>
        protected override void OnAfterCreate(ISystemContext context, NodeState node)
        {
            base.OnAfterCreate(context, node);

            InitializeVariable(context, BooleanValue, TestData.Variables.UserScalarValueObjectType_BooleanValue);
            InitializeVariable(context, SByteValue, TestData.Variables.UserScalarValueObjectType_SByteValue);
            InitializeVariable(context, ByteValue, TestData.Variables.UserScalarValueObjectType_ByteValue);
            InitializeVariable(context, Int16Value, TestData.Variables.UserScalarValueObjectType_Int16Value);
            InitializeVariable(context, UInt16Value, TestData.Variables.UserScalarValueObjectType_UInt16Value);
            InitializeVariable(context, Int32Value, TestData.Variables.UserScalarValueObjectType_Int32Value);
            InitializeVariable(context, UInt32Value, TestData.Variables.UserScalarValueObjectType_UInt32Value);
            InitializeVariable(context, Int64Value, TestData.Variables.UserScalarValueObjectType_Int64Value);
            InitializeVariable(context, UInt64Value, TestData.Variables.UserScalarValueObjectType_UInt64Value);
            InitializeVariable(context, FloatValue, TestData.Variables.UserScalarValueObjectType_FloatValue);
            InitializeVariable(context, DoubleValue, TestData.Variables.UserScalarValueObjectType_DoubleValue);
            InitializeVariable(context, StringValue, TestData.Variables.UserScalarValueObjectType_StringValue);
            InitializeVariable(context, DateTimeValue, TestData.Variables.UserScalarValueObjectType_DateTimeValue);
            InitializeVariable(context, GuidValue, TestData.Variables.UserScalarValueObjectType_GuidValue);
            InitializeVariable(context, ByteStringValue, TestData.Variables.UserScalarValueObjectType_ByteStringValue);
            InitializeVariable(context, XmlElementValue, TestData.Variables.UserScalarValueObjectType_XmlElementValue);
            InitializeVariable(context, NodeIdValue, TestData.Variables.UserScalarValueObjectType_NodeIdValue);
            InitializeVariable(context, ExpandedNodeIdValue, TestData.Variables.UserScalarValueObjectType_ExpandedNodeIdValue);
            InitializeVariable(context, QualifiedNameValue, TestData.Variables.UserScalarValueObjectType_QualifiedNameValue);
            InitializeVariable(context, LocalizedTextValue, TestData.Variables.UserScalarValueObjectType_LocalizedTextValue);
            InitializeVariable(context, StatusCodeValue, TestData.Variables.UserScalarValueObjectType_StatusCodeValue);
            InitializeVariable(context, VariantValue, TestData.Variables.UserScalarValueObjectType_VariantValue);
        }

        /// <summary>
        /// Called after a node is created.
        /// </summary>
        protected override void OnAfterCreate(ISystemContext context, NodeState node)
        {
            base.OnAfterCreate(context, node);

            if (this.ShelvingState != null)
            {
                if (this.ShelvingState.UnshelveTime != null)
                {
                    this.ShelvingState.UnshelveTime.OnSimpleReadValue = OnReadUnshelveTime;
                    this.ShelvingState.UnshelveTime.MinimumSamplingInterval = 1000;
                }

                this.ShelvingState.OneShotShelve.OnCallMethod = OnOneShotShelve;
                this.ShelvingState.OneShotShelve.OnReadExecutable = IsOneShotShelveExecutable;
                this.ShelvingState.OneShotShelve.OnReadUserExecutable = IsOneShotShelveExecutable;

                this.ShelvingState.TimedShelve.OnCall = OnTimedShelve;
                this.ShelvingState.TimedShelve.OnReadExecutable = IsTimedShelveExecutable;
                this.ShelvingState.TimedShelve.OnReadUserExecutable = IsTimedShelveExecutable;

                this.ShelvingState.Unshelve.OnCallMethod = OnUnshelve;
                this.ShelvingState.Unshelve.OnReadExecutable = IsTimedShelveExecutable;
                this.ShelvingState.Unshelve.OnReadUserExecutable = IsTimedShelveExecutable;
            }
        }

        /// <summary>
        /// Initializes the object as a collection of counters which change value on read.
        /// </summary>
        protected override void OnAfterCreate(ISystemContext context, NodeState node)
        {
            base.OnAfterCreate(context, node);

            UpdateStateVariable(context, Objects.ProgramStateMachineType_Ready, CurrentState);
            UpdateTransitionVariable(context, 0, LastTransition);

            Start.OnCallMethod = OnStart;
            Start.OnReadExecutable = IsStartExecutable;
            Start.OnReadUserExecutable = IsStartUserExecutable;

            Suspend.OnCallMethod = OnSuspend;
            Suspend.OnReadExecutable = IsSuspendExecutable;
            Suspend.OnReadUserExecutable = IsSuspendUserExecutable;

            Resume.OnCallMethod = OnResume;
            Resume.OnReadExecutable = IsResumeExecutable;
            Resume.OnReadUserExecutable = IsResumeUserExecutable;

            Halt.OnCallMethod = OnHalt;
            Halt.OnReadExecutable = IsHaltExecutable;
            Halt.OnReadUserExecutable = IsHaltUserExecutable;

            Reset.OnCallMethod = OnReset;
            Reset.OnReadExecutable = IsResetExecutable;
            Reset.OnReadUserExecutable = IsResetUserExecutable;
        }

 /// <summary>
 /// Creates a new browser object with a set of filters.
 /// </summary>
 public Browser(
     ISystemContext context,
     ViewDescription view,
     NodeId referenceType,
     bool includeSubtypes,
     BrowseDirection browseDirection,
     QualifiedName browseName,
     IEnumerable<IReference> additionalReferences,
     bool internalOnly,
     Opc.Ua.Client.Session client,
     NamespaceMapper mapper,
     NodeState source,
     NodeId rootId)
 :
     base(
         context,
         view,
         referenceType,
         includeSubtypes,
         browseDirection,
         browseName,
         additionalReferences,
         internalOnly)
 {
     m_client = client;
     m_mapper = mapper;
     m_source = source;
     m_rootId = rootId;
     m_stage = Stage.Begin;
 }

        /// <summary>
        /// Initializes the object as a collection of counters which change value on read.
        /// </summary>
        protected override void OnAfterCreate(ISystemContext context, NodeState node)
        {
            base.OnAfterCreate(context, node);

            UpdateStateVariable(context, Objects.ShelvedStateMachineType_Unshelved, CurrentState);
            UpdateTransitionVariable(context, 0, LastTransition);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Core.Controllers.AStar.Node"/> class. 
 /// It set the positionI of the Node, set the node state to open and calculate the travel cost to the destination tile.
 /// </summary>
 /// <param name="location">Current PositionI of the Node.</param>
 /// <param name="endLocation">PositionI of the destination tile.</param>
 public Node(PositionI location, PositionI endLocation)
 {
     Location = location;
     State = NodeState.Open;
     H = GetTraversalCost(Location, endLocation);
     G = 0;
 }

 public PathNode(Vector2 point, bool isWalkable, Vector2 destination)
 {
     Point = point;
     this.State = NodeState.Untested;
     this.IsWalkable = isWalkable;
     this.H = GetTransversalCost(this.Point, destination);
     this.G = 0;
 }

		void AttachedNode_StateChanged(Node node, NodeState oldState)
		{
			if(!node.IsConnected)
			{
				_Parent._ConnectedNodes.Remove(AttachedNode);
				_Parent.StartConnecting();
			}
		}

        internal Node(string id, string name, NodeState state,	List<IPAddress> public_ips,
				List<IPAddress> private_ips, NodeDriver driver)
            : base(id, name, driver)
        {
            State = state;
            PublicIPs = public_ips;
            PrivateIPs = private_ips;
        }

 public NodeDescriptor(IAcDomain acDomain, NodeState node)
 {
     this._acDomain = acDomain;
     if (node == null)
     {
         throw new ArgumentNullException("node");
     }
     this.Node = node;
 }

 void Update()
 {
     if(timeToLoneliness > 0) {
         timeToLoneliness -= Time.deltaTime;
         if(timeToLoneliness <= 0) {
             nodeState = NodeState.visited;
         }
     }
 }

        /// <summary>
        /// Initializes the instance with its defalt attribute values.
        /// </summary>
        public BaseObjectState(NodeState parent) : base(NodeClass.Object, parent)
        {
            m_eventNotifier = EventNotifiers.None;

            if (parent != null)
            {
                ReferenceTypeId = Opc.Ua.ReferenceTypeIds.HasComponent;
            }
        }

 /// <summary>
 /// Initializes the instance with the context for the node being monitored.
 /// </summary>
 public MonitoredNode(
     IServerInternal server,
     INodeManager nodeManager,
     NodeState node)
 {
     m_server = server;
     m_nodeManager = nodeManager;
     m_node = node;
 }

        /// <summary>
        /// Called after a node is created.
        /// </summary>
        protected override void OnAfterCreate(ISystemContext context, NodeState node)
        {
            base.OnAfterCreate(context, node);

            if (this.Respond != null)
            {
                this.Respond.OnCall = OnRespondCalled;
            }
        }

 public OctreeNode(Vect3 center, Double size, NodeState state, int level, int maxLevel)
 {
     Center = center;
     Size = size;
     State = state;
     Level = level;
     MaxLevel = maxLevel;
     Children = Enumerable.Empty<OctreeNode>();
     Color = Color.Purple;
 }