public Boolean CheckNetworkUndirected(INetworkInfo network)
        {
            var        sourceColumn  = network.EdgeTable.GetStringColumn("source");
            var        targetColumn  = network.EdgeTable.GetStringColumn("target");
            List <int> noDoubleCheck = new List <int> {
            };
            Boolean found            = false;

            for (int row = 0; row < network.EdgeTable.RowCount; row++)
            {
                found = false;
                if (noDoubleCheck.Exists(element => element == row))
                {
                }
                else
                {
                    for (int row2 = 0; row2 < network.EdgeTable.RowCount; row2++)
                    {
                        if (sourceColumn[row] == targetColumn[row2] && targetColumn[row] == sourceColumn[row2])
                        {
                            noDoubleCheck.Add(row2);
                            found = true;
                            break;
                        }
                    }
                    if (!found)
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
Beispiel #2
0
 public NetworkVm(INetworkInfo info, bool isConnected)
 {
     _info       = info;
     Name        = $"{info.Mac}({info.Channel})";
     _children   = new ObservableCollection <NetworkVm>();
     IsConnected = isConnected;
 }
        /// <summary>
        /// Initialize the defualt values.
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            m_TrailRenderer = GetComponent <TrailRenderer>();
            if (m_TrailRenderer != null)
            {
                m_TrailRenderer.enabled = false;
            }
            m_ParticleSystem = GetComponent <ParticleSystem>();
            if (m_ParticleSystem != null)
            {
                m_ParticleSystem.Stop();
            }

            // The Rigidbody is only used to notify Unity that the object isn't static. The Rigidbody doesn't control any movement.
            var rigidbody = GetComponent <Rigidbody>();

            rigidbody.mass        = m_Mass;
            rigidbody.isKinematic = true;
            rigidbody.constraints = RigidbodyConstraints.FreezeAll;
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo         = GetComponent <INetworkInfo>();
            m_DestructibleMonitor = GetComponent <IDestructibleMonitor>();
#endif

            if (m_DestroyOnCollision && m_BounceMode != BounceMode.None)
            {
                Debug.LogWarning("Warning: The Destructible " + name + " will be destroyed on collision but does not have a Bounce Mode set to None.");
                m_BounceMode = BounceMode.None;
            }
        }
Beispiel #4
0
        public static void UniqueNodes(this INetworkInfo network, string[] ids, Func <double[], double> combineNumeric, Func <string[], string> combineString, Func <string[][], string[]> combineCategory,
                                       Func <double[][], double[]> combineMultiNumeric)
        {
            var data           = network.NodeTable;
            var order          = ArrayUtils.Order(ids);
            var uniqueIdx      = new List <int>();
            var lastId         = "";
            var idxsWithSameId = new List <int>();

            foreach (int j in order)
            {
                var id = ids[j];
                if (id == lastId)
                {
                    idxsWithSameId.Add(j);
                }
                else
                {
                    CombineRows(data, idxsWithSameId, combineNumeric, combineString, combineCategory, combineMultiNumeric);
                    network.RemoveNode(idxsWithSameId);
                    uniqueIdx.Add(j);
                    idxsWithSameId.Clear();
                    idxsWithSameId.Add(j);
                }
                lastId = id;
            }
            CombineRows(data, idxsWithSameId, combineNumeric, combineString, combineCategory, combineMultiNumeric);
            data.ExtractRows(uniqueIdx.ToArray());
        }
Beispiel #5
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        private void Awake()
        {
            if (m_Targets == null || m_Targets.Length == 0)
            {
                Debug.LogError("Error: An IInteractableTarget must be specified in the Targets field.");
                return;
            }

            m_InteractableTargets = new IInteractableTarget[m_Targets.Length];
            for (int i = 0; i < m_Targets.Length; ++i)
            {
                if (m_Targets[i] == null || !(m_Targets[i] is IInteractableTarget))
                {
                    Debug.LogError("Error: element " + i + " of the Targets array is null or does not subscribe to the IInteractableTarget iterface.");
                }
                else
                {
                    m_InteractableTargets[i] = m_Targets[i] as IInteractableTarget;
                }
            }

#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo         = gameObject.GetCachedComponent <INetworkInfo>();
            m_NetworkInteractable = gameObject.GetCachedComponent <INetworkInteractableMonitor>();
            if (m_NetworkInfo != null && m_NetworkInteractable == null)
            {
                Debug.LogError("Error: The object " + gameObject.name + " must have a NetworkInteractableMonitor component.");
            }
#endif

            m_IKTargets = GetComponentsInChildren <AbilityIKTarget>();
        }
Beispiel #6
0
        /// <summary>
        /// Initialize the defualt values.
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            m_TrailRenderer = GetComponent <TrailRenderer>();
            if (m_TrailRenderer != null)
            {
                m_TrailRenderer.enabled = false;
            }
            m_ParticleSystem = GetComponent <ParticleSystem>();
            if (m_ParticleSystem != null)
            {
                m_ParticleSystem.Stop();
            }

            // The Rigidbody is only used to notify Unity that the object isn't static. The Rigidbody doesn't control any movement.
            var destructableRigidbody = GetComponent <Rigidbody>();

            if (destructableRigidbody != null)
            {
                destructableRigidbody.mass        = m_Mass;
                destructableRigidbody.isKinematic = true;
                destructableRigidbody.constraints = RigidbodyConstraints.FreezeAll;
            }
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo         = GetComponent <INetworkInfo>();
            m_DestructibleMonitor = GetComponent <IDestructibleMonitor>();
#endif

            if (m_DestroyOnCollision && m_CollisionMode != CollisionMode.Collide && GetType() != typeof(MagicProjectile))
            {
                Debug.LogWarning($"Warning: The Destructible {name} will be destroyed on collision but does not have a Collision Mode set to Collide.");
                m_CollisionMode = CollisionMode.Collide;
            }
        }
Beispiel #7
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            m_GameObject            = gameObject;
            m_Transform             = transform;
            m_CharacterLocomotion   = m_GameObject.GetCachedComponent <UltimateCharacterLocomotion>();
            m_CharacterLayerManager = m_GameObject.GetCachedComponent <CharacterLayerManager>();
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo = m_GameObject.GetCachedComponent <INetworkInfo>();
#endif

            if (m_Feet == null)
            {
                InitializeHumanoidFeet(false);
            }

            if (m_Feet != null && m_Feet.Length != 0)
            {
                for (int i = 0; i < m_Feet.Length; ++i)
                {
                    if (m_Feet[i].Object == null)
                    {
                        continue;
                    }

                    // The FeetGrouping list should be at least the size of the current group index.
                    while (m_Feet[i].Group >= m_FeetGrouping.Count)
                    {
                        m_FeetGrouping.Add(new List <Transform>());
                    }
                    m_FeetGrouping[m_Feet[i].Group].Add(m_Feet[i].Object);
                    // The Transform should only be added to the set if the footprint is flipped. If the Transform is not in the set then the footprint is not flipped.
                    if (m_Feet[i].FlippedFootprint)
                    {
                        m_FlippedFootprints.Add(m_Feet[i].Object);
                    }
                }
            }
            else
            {
                m_FeetGrouping.Add(new List <Transform>());
                m_FeetGrouping[0].Add(m_Transform);
            }

            if (m_FootstepMode == FootstepPlacementMode.Trigger || m_FootstepMode == FootstepPlacementMode.CameraBob || m_FootstepMode == FootstepPlacementMode.None)
            {
                // The component doesn't need to be enabled if using a trigger - the FootstepTrigger component will detect the footstep. The CameraBob will enable the component
                // when the look source is attached.
                enabled = false;
            }
            else if (m_Feet != null)
            {
                PrepareVerticalOffsetLists();
            }

            EventHandler.RegisterEvent <ILookSource>(m_GameObject, "OnCharacterAttachLookSource", OnAttachLookSource);
            EventHandler.RegisterEvent <bool>(m_GameObject, "OnCharacterMoving", OnMoving);
        }
Beispiel #8
0
 public NetworkClient(INetworkInfo networkInfo)
 {
     if (networkInfo == null)
     {
         throw new ArgumentNullException("NetworkInfo is null");
     }
     this.networkInfo = networkInfo;
 }
Beispiel #9
0
        /// <summary>
        /// Private ctor since we're cheezy and use a singleton.
        /// </summary>
        private NetworkStatus()
        {
            m_nListUtil = PlatformTypes.New <INetworkInfo>();

            m_nListUtil.ConnectionStateChanged += () =>
            {
                ConnectionStateChanged?.Invoke();
            };
        }
Beispiel #10
0
        public ProfitInfo(IMarketManager marketManager, INetworkInfo networkInfo, IPoolConfig poolConfig)
        {
            _logger = Log.ForContext<ProfitInfo>().ForContext("Component", poolConfig.Coin.Name);

            _poolConfig = poolConfig;
            _networkInfo = networkInfo;
            _marketManager = marketManager;
            _marketManager.Update += OnMarketUpdate;
        }
Beispiel #11
0
        public ProfitInfo(IMarketManager marketManager, INetworkInfo networkInfo, IPoolConfig poolConfig)
        {
            _logger = Log.ForContext <ProfitInfo>().ForContext("Component", poolConfig.Coin.Name);

            _poolConfig            = poolConfig;
            _networkInfo           = networkInfo;
            _marketManager         = marketManager;
            _marketManager.Update += OnMarketUpdate;
        }
Beispiel #12
0
        public IProfitInfo GetProfitInfo(INetworkInfo networkInfo, IPoolConfig poolConfig)
        {
            var @params = new NamedParameterOverloads
            {
                { "poolConfig", poolConfig },
                { "networkInfo", networkInfo },
            };

            return(_applicationContext.Container.Resolve <IProfitInfo>(@params));
        }
        public UdpDeviceDetection(INetworkInfo networkInfo = null)
        {
            if (networkInfo == null)
            {
                this._networkInfo = new DefaultNetworkInfo();
                return;
            }

            this._networkInfo = networkInfo;
        }
Beispiel #14
0
        public MainViewModel(IAppInfo app, IBatteryInfo battery, INetworkInfo network, IHardwareInfo hardware)
        {
            this.App      = app;
            this.Battery  = battery;
            this.Network  = network;
            this.Hardware = hardware;

            this.ClearApp     = new Command(this.AppEvents.Clear);
            this.ClearBattery = new Command(this.BatteryEvents.Clear);
            this.ClearNetwork = new Command(this.NetworkEvents.Clear);
        }
Beispiel #15
0
 public NetworkVm(string name, IEnumerable <NetworkVm> networkVms)
 {
     Name      = name;
     _info     = new NetworkInfo();
     _children = new ObservableCollection <NetworkVm>(networkVms);
     foreach (var networkVm in _children)
     {
         networkVm.PropertyChanged += NetworkVmOnPropertyChanged;
     }
     IsConnected = networkVms.Any(vm => vm.IsConnected);
 }
Beispiel #16
0
 public static void RemoveEdge(this INetworkInfo network, List <int> rowIdxs)
 {
     if (rowIdxs.Count <= 1)
     {
         return;
     }
     for (int i = 0; i < rowIdxs.Count - 1; i++)
     {
         var edge = network.EdgeIndex.FirstOrDefault(x => x.Value == rowIdxs[i]).Key;
         network.Graph.RemoveEdges(edge);
     }
 }
        private Dictionary <INode, Boolean> DoBFS(Dictionary <INode, Boolean> queue, INetworkInfo network)
        {
            var unvis = queue.FirstOrDefault(x => x.Value == false).Key;

            while (unvis != null)
            {
                queue[unvis] = true;                                            //update current node as visited
                queue        = PushNeighborsToQueue(queue, unvis, network);     // push neighbors to queue
                unvis        = queue.FirstOrDefault(x => x.Value == false).Key; //search for next unvisited node
            }
            return(queue);
        }
Beispiel #18
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        public override void Awake()
        {
            base.Awake();

            m_CharacterIK = m_GameObject.GetCachedComponent <CharacterIKBase>();

#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo = m_GameObject.GetCachedComponent <INetworkInfo>();
#endif

            EventHandler.RegisterEvent(m_GameObject, "OnAnimatorInteract", DoInteract);
            EventHandler.RegisterEvent(m_GameObject, "OnAnimatorInteractComplete", InteractComplete);
        }
Beispiel #19
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        protected virtual void Awake()
        {
            m_GameObject = gameObject;
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo      = m_GameObject.GetCachedComponent <INetworkInfo>();
            m_NetworkCharacter = m_GameObject.GetCachedComponent <INetworkCharacter>();
#endif

            DetermineSlotCount();

            EventHandler.RegisterEvent <Vector3, Vector3, GameObject>(m_GameObject, "OnDeath", OnDeath);
            EventHandler.RegisterEvent(m_GameObject, "OnRespawn", OnRespawn);
        }
Beispiel #20
0
        public AccountManager(IFileSystem filesystem, INetworkInfo networkInfo)
        {
            if (filesystem == null)
            {
                throw new ArgumentNullException("Filesystem is null");
            }
            this.filesystem = filesystem;
            this.user       = new User();
            this.client     = new NetworkClient(networkInfo);
            loadLogin();

            /*this.user = new User (){ Username = "******", UserID = "0" };
             * LoggedIn = true;*/
        }
Beispiel #21
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        private void Awake()
        {
            m_GameObject  = gameObject;
            m_Transform   = transform;
            m_AudioSource = GetComponent <AudioSource>();
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo = GetComponent <INetworkInfo>();
#endif

            // A turret head is required.
            if (m_TurretHead == null)
            {
                m_TurretHead = m_Transform;
            }
        }
        public Boolean CheckNetworkConnected(INetworkInfo network)
        {
            IGraph g        = network.Graph;
            var    nodeEnum = g.GetEnumerator();

            //for every node: Do weak connectivity BFS -> in whole: strong connectivity BFS
            while (nodeEnum.MoveNext())
            {
                Dictionary <INode, Boolean> queue = new Dictionary <INode, Boolean>
                {
                    [nodeEnum.Current] = false
                };
                queue = DoBFS(queue, network);
                if (queue.Count != g.NumberOfNodes)
                {
                    return(false);
                }
            }
            return(true);
        }
Beispiel #23
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            m_GameObject = gameObject;
            m_Item       = m_GameObject.GetCachedComponent <Item>();
            var characterLocomotion = m_GameObject.GetCachedParentComponent <UltimateCharacterLocomotion>();

            m_Character = characterLocomotion.gameObject;
            m_Inventory = m_Character.GetCachedComponent <InventoryBase>();
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo      = m_Character.GetCachedComponent <INetworkInfo>();
            m_NetworkCharacter = m_Character.GetCachedComponent <INetworkCharacter>();
            if (m_NetworkInfo != null && m_NetworkCharacter == null)
            {
                Debug.LogError("Error: The character " + m_Character.name + " must have a NetworkCharacter component.");
            }
#endif

            var perspectiveProperties = GetComponents <ItemPerspectiveProperties>();
            for (int i = 0; i < perspectiveProperties.Length; ++i)
            {
                // The perspective properties Action ID must match. The ID allows multiple ItemActions/PerpsectiveProperties to be added to the same item.
                // An action ID of -1 can be used with any action.
                if (m_ID != perspectiveProperties[i].ActionID && perspectiveProperties[i].ActionID != -1)
                {
                    continue;
                }
                if (perspectiveProperties[i].FirstPersonItem)
                {
                    m_FirstPersonPerspectiveProperties = perspectiveProperties[i];
                }
                else
                {
                    m_ThirdPersonPerspectiveProperties = perspectiveProperties[i];
                }
            }
            m_ActivePerspectiveProperties = characterLocomotion.FirstPersonPerspective ? m_FirstPersonPerspectiveProperties : m_ThirdPersonPerspectiveProperties;

            EventHandler.RegisterEvent <bool>(m_Character, "OnCharacterChangePerspectives", OnChangePerspectives);
        }
Beispiel #24
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        private void Awake()
        {
#if THIRD_PERSON_CONTROLLER
            // If the third person Perspective Monitor exists then that component will manage the remote player's perspective.
            var perspectiveMonitor = gameObject.GetComponent <ThirdPersonController.Character.PerspectiveMonitor>();
            if (perspectiveMonitor != null)
            {
                Destroy(this);
                return;
            }
#endif
            m_GameObject  = gameObject;
            m_NetworkInfo = m_GameObject.GetComponent <INetworkInfo>();
            if (m_NetworkInfo == null)
            {
                Debug.LogError("Error: The character must have a NetworkInfo object.");
                return;
            }

            EventHandler.RegisterEvent <ILookSource>(m_GameObject, "OnCharacterAttachLookSource", OnAttachLookSource);
        }
Beispiel #25
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            m_GameObject          = gameObject;
            m_Transform           = transform;
            m_CharacterLocomotion = m_GameObject.GetCachedComponent <UltimateCharacterLocomotion>();
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo             = m_GameObject.GetCachedComponent <INetworkInfo>();
            m_NetworkRespawnerMonitor = m_GameObject.GetCachedComponent <INetworkRespawnerMonitor>();
            if (m_NetworkInfo != null && m_NetworkRespawnerMonitor == null)
            {
                Debug.LogError("Error: The object " + m_GameObject.name + " must have a NetworkRespawnerMonitor component.");
            }
#endif

            m_StartPosition = m_Transform.position;
            m_StartRotation = m_Transform.rotation;

            EventHandler.RegisterEvent <Vector3, Vector3, GameObject>(m_GameObject, "OnDeath", OnDeath);
        }
Beispiel #26
0
        /// <summary>
        /// Initialize the default values.
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            m_GameObject       = gameObject;
            m_Transform        = transform;
            m_ForceObject      = m_GameObject.GetCachedComponent <IForceObject>();
            m_Rigidbody        = m_GameObject.GetCachedComponent <Rigidbody>();
            m_AttributeManager = GetComponent <AttributeManager>();
            if (!string.IsNullOrEmpty(m_HealthAttributeName))
            {
                m_HealthAttribute = m_AttributeManager.GetAttribute(m_HealthAttributeName);
            }
            if (!string.IsNullOrEmpty(m_ShieldAttributeName))
            {
                m_ShieldAttribute = m_AttributeManager.GetAttribute(m_ShieldAttributeName);
            }
            m_AliveLayer = m_GameObject.layer;
#if ULTIMATE_CHARACTER_CONTROLLER_MULTIPLAYER
            m_NetworkInfo          = m_GameObject.GetCachedComponent <INetworkInfo>();
            m_NetworkHealthMonitor = m_GameObject.GetCachedComponent <INetworkHealthMonitor>();
            if (m_NetworkInfo != null && m_NetworkHealthMonitor == null)
            {
                Debug.LogError("Error: The object " + m_GameObject.name + " must have a NetworkHealthMonitor component.");
            }
#endif

            if (m_Hitboxes != null && m_Hitboxes.Length > 0)
            {
                m_ColliderHitboxMap = new Dictionary <Collider, Hitbox>();
                for (int i = 0; i < m_Hitboxes.Length; ++i)
                {
                    m_ColliderHitboxMap.Add(m_Hitboxes[i].Collider, m_Hitboxes[i]);
                }
                m_RaycastHits        = new RaycastHit[m_MaxHitboxCollisionCount];
                m_RaycastHitComparer = new Utility.UnityEngineUtility.RaycastHitComparer();
            }

            EventHandler.RegisterEvent(m_GameObject, "OnRespawn", OnRespawn);
        }
Beispiel #27
0
        public static void UniqueEdges(this INetworkInfo network, string[] id1, string[] id2, Func <double[], double> combineNumeric, Func <string[], string> combineString, Func <string[][], string[]> combineCategory,
                                       Func <double[][], double[]> combineMultiNumeric)
        {
            var           data = network.EdgeTable;
            List <Triple> list = new List <Triple>();

            for (int i = 0; i < id1.Length; i++)
            {
                list.Add(new Triple()
                {
                    One = id1[i], Two = id2[i], Index = i
                });
            }
            list.Sort();
            var uniqueIdx      = new List <int>();
            var lastId1        = "";
            var lastId2        = "";
            var idxsWithSameId = new List <int>();

            foreach (Triple id in list)
            {
                if (id.One == lastId1 && id.Two == lastId2)
                {
                    idxsWithSameId.Add(id.Index);
                }
                else
                {
                    CombineRows(data, idxsWithSameId, combineNumeric, combineString, combineCategory, combineMultiNumeric);
                    network.RemoveEdge(idxsWithSameId);
                    uniqueIdx.Add(id.Index);
                    idxsWithSameId.Clear();
                    idxsWithSameId.Add(id.Index);
                }
                lastId1 = id.One;
                lastId2 = id.Two;
            }
            CombineRows(data, idxsWithSameId, combineNumeric, combineString, combineCategory, combineMultiNumeric);
            data.ExtractRows(uniqueIdx.ToArray());
        }
Beispiel #28
0
        public MomentsManager(IFileSystem filesystem, ILocationManager locationManager, INetworkInfo networkInfo)
        {
            if (filesystem == null)
            {
                throw new ArgumentNullException("Filesystem is null");
            }
            if (locationManager == null)
            {
                throw new ArgumentNullException("LocationManager is null");
            }
            if (networkInfo == null)
            {
                throw new ArgumentNullException("NetworkInfo is null");
            }

            this.fileSystem           = filesystem;
            this.locationManager      = locationManager;
            this.networkInfo          = networkInfo;
            this.momentsNetworkClient = new NetworkClient(networkInfo);
            this.Moments        = new List <Moment> ();
            this.AccountManager = new AccountManager(fileSystem, networkInfo);
            Poll();
        }
 /**
  * Set the delegate implementation.
  *
  * @param _delegate The delegate implementing platform specific functions.
  */
 public void SetDelegate(INetworkInfo _delegate)
 {
     this._delegate = _delegate;
 }
 /**
  * Constructor with delegate.
  *
  * @param _delegate The delegate implementing platform specific functions.
  */
 public NetworkInfoBridge(INetworkInfo _delegate) : base()
 {
     this._delegate = _delegate;
 }
 public ConnectionInfo(INetworkInfo monitor)
 {
     _monitor = monitor;
 }
        public IProfitInfo GetProfitInfo(INetworkInfo networkInfo, IPoolConfig poolConfig)
        {
            var @params = new NamedParameterOverloads
            {
                {"poolConfig", poolConfig},
                {"networkInfo", networkInfo},
            };

            return _applicationContext.Container.Resolve<IProfitInfo>(@params);
        }
        private Dictionary <INode, Boolean> PushNeighborsToQueue(Dictionary <INode, Boolean> queue, INode node, INetworkInfo netw)
        {
            List <INode> neighbors = GetNeighbors(node);

            foreach (var neighbor in neighbors)
            {
                if (!queue.ContainsKey(neighbor))
                {
                    queue[neighbor] = false;
                }
            }
            return(queue);
        }