GetComponents() public method

public GetComponents ( Type type ) : UnityEngine.Component[]
type System.Type
return UnityEngine.Component[]
Example #1
0
    void enablePlayer(GameObject player)
    {
        foreach (MonoBehaviour obj in player.GetComponents<MonoBehaviour>())
            obj.enabled = true;

        foreach (CharacterController obj in player.GetComponents<CharacterController>())
            obj.enabled = true;
    }
Example #2
0
    private ItemData CreateItemDataFromGameObject(GameObject gameObject)
    {
        ValidateGameObject (gameObject);

        ItemData itemData = new ItemData ();
        itemData.transformData.position = gameObject.transform.position;
        itemData.transformData.rotation = gameObject.transform.eulerAngles;
        itemData.transformData.scale = gameObject.transform.localScale;
        itemData.name = gameObject.name;

        foreach (IPersistable persistable in gameObject.GetComponents<IPersistable>()) {

          SerializableDictionary<string, object> componentConfiguration = new SerializableDictionary<string, object> ();
          foreach (FieldInfo field in persistable.GetType().GetFields()) {
        componentConfiguration.Add (field.Name, field.GetValue (persistable));
          }

          string componentName = persistable.GetType ().FullName;

          itemData.componentData.configurations.Add (componentName, componentConfiguration);
        }

        foreach (Transform child in gameObject.transform) {
          if (child.GetComponents<IPersistable> ().Length > 0) {
        itemData.children.Add (CreateItemDataFromGameObject (child.gameObject));
          }
        }

        return itemData;
    }
Example #3
0
    /// <summary>
    /// This adds a new target game object. 
    /// </summary>
    /// <param name="gameObject">
    /// The game object to target.
    /// </param>
    public void AddGameObject(GameObject gameObject)
    {
        //make sure this game object is not null and is not already in the list
        if (gameObject != null && targetGameObjects.Contains(gameObject) == false)
        {
            //warn if the game object being added is the parent of this component
            if (gameObject == this)
            {
                Debug.LogWarning("You are adding a game object to a modifier that is the parent of this modifier.  This may have unexpected results.");
            }

            //add the game object
            targetGameObjects.Add(gameObject);

            //get all MonoBehavior components on this target game object
            MonoBehaviour[] behaviours = gameObject.GetComponents<MonoBehaviour>();
            for (int j = 0; j < behaviours.Length; j++)
            {
                //make sure the found behavior is not this behavior, and it is a IVisModifierTarget
                if (behaviours[j] != this && behaviours[j] is IVisModifierTarget)
                {
                    //get the modifier target and add to the ValueUpdate event
                    IVisModifierTarget modifierTarget = behaviours[j] as IVisModifierTarget;
                    if (modifierTarget != null)
                        ValueUpdated += modifierTarget.OnValueUpdated;
                }
            }
        }
    }
    public SIHJR_PVFS_Grid(GameObject _boundary, float influenceWidth)
    {
        Collider2D collider = _boundary.GetComponents<Collider2D> () [0];
        _bounds = collider.bounds;
        _left = collider.bounds.min.x;
        _bottom = collider.bounds.min.y;
        _right = collider.bounds.max.x;
        _top = collider.bounds.max.y;
        _influenceWidth = influenceWidth;

        //create new grid
        _gridWidthCellCount = (int)Mathf.Ceil (collider.bounds.size.x / _influenceWidth);
        _gridHeightCellCount = (int)Mathf.Ceil (collider.bounds.size.y / _influenceWidth);
        //Debug.Log ("gridW: " + _gridWidthCellCount + " -- gridH: " + _gridHeightCellCount);
        //Debug.Log ("grid L: " + _left + " -- grid R: " + _right);
        //Debug.Log ("grid Cell Width: " + _influenceWidth);

        _gridArray = new IList[_gridWidthCellCount + 1, _gridHeightCellCount + 1];

        /*
        _particles = new LinkedList<List<List<SIHJR_PVFS_Particle>>>(xCount);
        for (int i = 0; i < xCount; i++) {
            //create list
            _particles[i] = new LinkedList<List<SIHJR_PVFS_Particle>>(yCount);

            for (int j = 0; j < yCount; j++) {
                _particles[j] = new LinkedList<SIHJR_PVFS_Particle>();
            }

            //create nested lists
        }
        */
    }
Example #5
0
        public static string GetGameObjectBehaviors(GameObject gameObject)
        {
            if (gameObject == null)
            {
                return "GameObject is null";
            }

            var components = gameObject.GetComponents<Component>();
            string list = "";
            foreach (var component in components)
            {
                string behaviorString = "";
                UnityEngine.Behaviour behavior = component as UnityEngine.Behaviour;
                if (behavior != null)
                {
                    behaviorString = " (Behavior)";
                    if (!behavior.enabled)
                    {
                        behaviorString += " (disabled)";
                    }
                }
                list += "Type: " + component.GetType() + behaviorString + "\n";
            }
            return list;
        }
Example #6
0
        // NOTE: This method will not return components that are within a GameObjectContext
        public static IEnumerable<Component> GetInjectableComponentsBottomUp(
            GameObject gameObject, bool recursive)
        {
            var context = gameObject.GetComponent<GameObjectContext>();

            if (context != null)
            {
                yield return context;
                yield break;
            }

            if (recursive)
            {
                foreach (Transform child in gameObject.transform)
                {
                    foreach (var component in GetInjectableComponentsBottomUp(child.gameObject, recursive))
                    {
                        yield return component;
                    }
                }
            }

            foreach (var component in gameObject.GetComponents<Component>())
            {
                yield return component;
            }
        }
Example #7
0
		private void ApplyRecursive(GameObject go)
		{
			foreach(Graphic graphic in go.GetComponents<Graphic>())
				style.Apply(graphic);

			foreach(Selectable selectable in go.GetComponents<Selectable>())
				style.Apply(selectable);

			foreach(Transform t in go.transform)
			{
				if(t.gameObject.GetComponent<pb_GUIStyleApplier>() != null)
					continue;

				ApplyRecursive(t.gameObject);
			}
		}
Example #8
0
    //Beware: This assumes that it's safe to just play sounds using free audio sources.
    // It's a replacement for NGUITools.PlaySound
    public static AudioSource PlaySoundOn(AudioClip clip, GameObject go, float volume = 1.0f)
    {
        if (clip == null || go == null)
        {
            return null;
        }

        AudioSource[] sources = go.GetComponents<AudioSource>();
        AudioSource source = null;

        for (int i=0; i<sources.Length; ++i)
        {
            source = sources[i];
            if (!source.isPlaying || source.clip == clip)
            {
                source.PlayClip(clip, volume);
                return source;
            }
        }

        source = go.AddComponent<AudioSource>();
        source.playOnAwake = false;
        source.PlayClip(clip, volume);
        return source;
    }
 void SetVisiible(GameObject obj, bool visible)
 {
     foreach (Renderer component in obj.GetComponents<Renderer>())
     {
         component.enabled = visible;
     }
 }
    private static XmlElement GameObjectToXmlElement(GameObject gameObject, XmlDocument document)
    {
        XmlElement entityElement = document.CreateElement("entity");
        entityElement.SetAttribute("name",gameObject.name);

        Object[] outputComponents = gameObject.GetComponents(typeof(OutputComponent));

        for (int j = 0; j < outputComponents.Length; j++)
        {
            OutputComponent oc = (OutputComponent)outputComponents[j];
            XmlElement outputElement = oc.ToXmlElement(document);

            entityElement.AppendChild(outputElement);
            outputElement.SetAttribute("uid","" + oc.uid);
        }

        for (int i = 0; i < gameObject.transform.GetChildCount(); i++)
        {
            GameObject child = gameObject.transform.GetChild(i).gameObject;

            int childOutputComponents = child.GetComponents(typeof(OutputComponent)).Length;

            if (childOutputComponents > 0)
            {
                XmlElement childXmlElement = GameObjectToXmlElement(child, document);
                entityElement.AppendChild(childXmlElement);
            }
        }

        return entityElement;
    }
Example #11
0
 public static void InjectGameObject(DiContainer container, GameObject gameObj)
 {
     foreach (var monoBehaviour in gameObj.GetComponents<MonoBehaviour>())
     {
         InjectMonoBehaviour(container, monoBehaviour);
     }
 }
 private static void FindInGO(GameObject g)
 {
     go_count++;
     Component[] components = g.GetComponents<Component>();
     for (int i = 0; i < components.Length; i++)
     {
         components_count++;
         if (components[i] == null)
         {
             missing_count++;
             string s = g.name;
             Transform t = g.transform;
             while (t.parent != null) 
             {
                 s = t.parent.name +"/"+s;
                 t = t.parent;
             }
             Debug.Log (s + " has an empty script attached in position: " + i, g);
         }
     }
     // Now recurse through each child GO (if there are any):
     foreach (Transform childT in g.transform)
     {
         //Debug.Log("Searching " + childT.name  + " " );
         FindInGO(childT.gameObject);
     }
 }
	// Use this for initialization
	void Start () {
		ConsoleLog.SLog ("PlayerGameManager Start()");

		anim = GetComponent<Animator> ();
		cardboardCamera = GameObject.FindGameObjectWithTag("PlayerHead");
		cardboardHead = cardboardCamera.GetComponent<CardboardHead> ();
		headPos = GameObject.FindGameObjectWithTag ("CameraPos").transform;
		gun = GameObject.FindGameObjectWithTag ("MyGun");
		gunProperties = gun.GetComponent<GunProperties> ();
		gunAudio = gun.GetComponents<AudioSource> ();
		gunLight = GameObject.FindGameObjectWithTag ("GunLight");
		gunFlashEmitter = GameObject.FindGameObjectWithTag ("GunFlash").GetComponent<EllipsoidParticleEmitter>();
		gunFlashEmitter.emit = false;
		footstepsAudio = GetComponent<AudioSource> ();
		bulletHoleArray = new ArrayList (bulletHoleMaxAmount);

		//HUD
		HUD = GameObject.FindGameObjectWithTag("HUD");
		healthBar = HUD.transform.GetChild (0) as Transform;
		bulletText = HUD.transform.GetChild (1).GetComponent<TextMesh>();
		reloadText = HUD.transform.GetChild (2).GetComponent<TextMesh>();
		grenadeText = HUD.transform.GetChild (3).GetComponent<TextMesh>();
		HUDCanvas = HUD.transform.GetChild (4).gameObject;
		deadText = HUDCanvas.transform.GetChild (0).gameObject;
		endRoundText = HUDCanvas.transform.GetChild (1).gameObject;
		endGameText = HUDCanvas.transform.GetChild (2).gameObject;

		bulletText.text = gunProperties.bulletLoadCurrent + "/" + gunProperties.bulletStoreCurrent;
		grenadeText.text = grenadeStore + "";
	}
Example #14
0
    public void Setup(GameObject targetType, int inputNumber)
    {
        if (playerShip != null)
        {
            Destroy(playerShip);
            playerShip = null;
        }

        playerShip = (GameObject)Instantiate(targetType, Vector3.zero, Quaternion.identity);

        var scripts = playerShip.GetComponents<MonoBehaviour>();
        for (int i = 0; i < scripts.Length; i++)
        {
            MonoBehaviour data = scripts[i];
            Controller controller = data as Controller;
            if (controller != null)
            {
                controller.horizontalAxis = "Horizontal"+inputNumber;
                controller.verticalAxis = "Vertical"+inputNumber;
                controller.accelerate = "Accelerate" + inputNumber;
                controller.otherAxis = "Other"+inputNumber;
                controller.AssignCamera(GetComponent<Camera>());

            }
        }
    }
    private void CacheMethodsForGameObject(GameObject go, System.Type parameterType) {
        List<string> cachedMethods = new List<string>();
        cache[go].Add( parameterType, cachedMethods );

        List<System.Type> addedTypes = new List<System.Type>();
        MonoBehaviour[] behaviours = go.GetComponents<MonoBehaviour>();
        foreach (MonoBehaviour beh in behaviours) {
            System.Type type = beh.GetType();
            if (addedTypes.IndexOf(type) == -1) {
                System.Reflection.MethodInfo[] methods = type.GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
                foreach (System.Reflection.MethodInfo method in methods) {
                    // Only add variables added by user, i.e. we don't want functions from the base UnityEngine baseclasses or lower
                    string moduleName = method.DeclaringType.Assembly.ManifestModule.Name;
                    if (!moduleName.Contains("UnityEngine") && !moduleName.Contains("mscorlib") &&
                        !method.ContainsGenericParameters && 
                        System.Array.IndexOf(ignoredMethodNames, method.Name) == -1) {
                        System.Reflection.ParameterInfo[] paramInfo = method.GetParameters();
                        if (paramInfo.Length == 0) {
                            cachedMethods.Add(method.Name);
                        }
                        else if (paramInfo.Length == 1 && paramInfo[0].ParameterType == parameterType) {
                            cachedMethods.Add(method.Name);
                        }
                    }
                }
            }
        }
    }
        /// <summary>
        ///   Collects a list of usable routed events from the specified target game object.
        /// </summary>
        /// <param name="target">Game object to get all usable routes events of.</param>
        /// <returns>Usable routed events from the specified target game object.</returns>
        protected override List<Entry> GetApplicableMembers(GameObject target)
        {
            MonoBehaviour[] components = target.GetComponents<MonoBehaviour>();

            List<Entry> list = new List<Entry>();

            foreach (MonoBehaviour monoBehaviour in components)
            {
                if (monoBehaviour == null)
                {
                    continue;
                }

                FieldInfo[] fields = monoBehaviour.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public);

                foreach (FieldInfo info in fields)
                {
                    if (info.FieldType != typeof(ViewEvent))
                    {
                        continue;
                    }

                    Entry entry = new Entry { Target = monoBehaviour, MemberName = info.Name };
                    list.Add(entry);
                }
            }
            return list;
        }
Example #17
0
 public void SetAllCollidersStatus(bool active, GameObject box)
 {
     foreach (Collider2D c in box.GetComponents<Collider2D>())
     {
         c.enabled = active;
     }
 }
Example #18
0
 // Use this for initialization
 void Start()
 {
     audio = GameObject.FindWithTag("Audio");
     a = audio.GetComponents<AudioSource>();
     m = GameObject.FindWithTag("Contador");
     marcador = m.GetComponent<GUIText>();
 }
Example #19
0
    public void GrabThis(int id)
    {
        Debug.Log("client grab this " + id.ToString());
        if (id != 0) {
            if (RHClone != null) {
                networkView.RPC("DoppelgangerDestroyThis", RPCMode.AllBuffered, RHClone.networkView.viewID);
                //Network.Destroy(RHClone);
            }
            Jitika = GetComponent<GameInv>().gInv[id];

            RHClone = Network.Instantiate(Jitika, RightHand.transform.position, RightHand.transform.rotation, 0) as GameObject;
            Debug.Log("Grabbing " + RHClone.name);
            RHClone.transform.parent = RightHand.transform;
            RHClone.transform.localPosition = Vector3.zero;
            Debug.Log("Grabbed at " + RightHand.transform.position);
            MonoBehaviour[] scriptComps =  RHClone.GetComponents<MonoBehaviour>();
            foreach (MonoBehaviour script in scriptComps) {
                script.enabled = true;
            }
            networkView.RPC("DoppelgangerGrabThis", RPCMode.AllBuffered, gameObject.networkView.viewID, RHClone.networkView.viewID);
        } else {
            if (RHClone != null) {
                networkView.RPC("DoppelgangerDestroyThis", RPCMode.AllBuffered, RHClone.networkView.viewID);
                //Network.Destroy(RHClone);
            }
        }
    }
	/// <summary>
	/// Collect a list of usable delegates from the specified target game object.
	/// The delegates must be of type "void Delegate()".
	/// </summary>

	static List<Entry> GetMethods (GameObject target)
	{
		MonoBehaviour[] comps = target.GetComponents<MonoBehaviour>();

		List<Entry> list = new List<Entry>();

		for (int i = 0, imax = comps.Length; i < imax; ++i)
		{
			MonoBehaviour mb = comps[i];
			if (mb == null) continue;

			MethodInfo[] methods = mb.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public);

			for (int b = 0; b < methods.Length; ++b)
			{
				MethodInfo mi = methods[b];

				if (mi.GetParameters().Length == 0 && mi.ReturnType == typeof(void))
				{
					if (mi.Name != "StopAllCoroutines" && mi.Name != "CancelInvoke")
					{
						Entry ent = new Entry();
						ent.target = mb;
						ent.method = mi;
						list.Add(ent);
					}
				}
			}
		}
		return list;
	}
Example #21
0
        private string ShowComponents(SerializedObject objTarget, GameObject gameObject)
        {
            var targetComponentAssemblyName = objTarget.FindProperty("targetComponentAssemblyName");
            var targetComponentFullname = objTarget.FindProperty("targetComponentFullname");
            var targetComponentText = objTarget.FindProperty("targetComponentText");
            var objComponents = gameObject.GetComponents<Component>();
            var objTypesAssemblynames = (from objComp in objComponents select objComp.GetType().AssemblyQualifiedName).ToList();
            var objTypesName = (from objComp in objComponents select objComp.GetType().Name).ToList();

            int index = objTypesAssemblynames.IndexOf(targetComponentAssemblyName.stringValue);

            index = EditorGUILayout.Popup("Target Component", index, objTypesName.ToArray());

            if (index != -1)
            {
                targetComponentAssemblyName.stringValue = objTypesAssemblynames[index];
                targetComponentFullname.stringValue = objComponents.GetType().FullName;
                targetComponentText.stringValue = objTypesName[index];
            }
            else
            {
                targetComponentAssemblyName.stringValue = null;
            }

            objTarget.ApplyModifiedProperties();

            return targetComponentAssemblyName.stringValue;
        }
    private string[] GetMethod(GameObject obj)
    {
        List<string> methodName = new List<string>();

        Component[] allComponents = obj.GetComponents<Component>();

        if (allComponents.Length>0){
            foreach( Component comp in allComponents){
                if (comp!=null){
                if (comp.GetType().IsSubclassOf( typeof(MonoBehaviour))){
                    MethodInfo[] methodInfos = comp.GetType().GetMethods();
                    foreach( MethodInfo methodInfo in methodInfos){
                        if ((methodInfo.DeclaringType.Namespace == null) || (!methodInfo.DeclaringType.Namespace.Contains("Unity") && !methodInfo.DeclaringType.Namespace.Contains("System"))){
                            if (methodInfo.IsPublic){
                                methodName.Add( methodInfo.Name );
                            }
                        }

                    }
                }
                }
            }
        }
        //
        return methodName.ToArray();
    }
        public override void draw(GameObject gameObject, QObjectList objectList, Rect selectionRect, Rect curRect)
        {
            bool foundCustomComponent = false;
            if (ignoreUnityMonobehaviour)
            {
                Component[] components = gameObject.GetComponents<MonoBehaviour>();
                for (int i = components.Length - 1; i >= 0; i--)
                {
                    if (components[i] != null && !components[i].GetType().FullName.Contains("UnityEngine"))
                    {
                        foundCustomComponent = true;
                        break;
                    }
                }
            }
            else
            {
                foundCustomComponent = gameObject.GetComponent<MonoBehaviour>() != null;
            }

            if (foundCustomComponent)
            {
                int ident = Mathf.FloorToInt(selectionRect.x / TREE_STEP_WIDTH) - 1;

                curRect.x      = 1 + ident * TREE_STEP_WIDTH;
                curRect.y      = selectionRect.y;
                curRect.width  = TREE_STEP_WIDTH;
                curRect.height = selectionRect.height;

                GUI.DrawTexture(curRect, gameObject.transform.childCount > 0 ? monoBehaviourIconParentTexture : monoBehaviourIconTexture);
            }
        }
Example #24
0
 // Pause
 public void PauseParticle(GameObject PSGO)
 {
     ParticleSystem[] ParticleSys;
     ParticleSys = PSGO.GetComponents<ParticleSystem>();
     foreach(ParticleSystem temp in ParticleSys)
         temp.Pause();
 }
 public static void FillMethodsList(List<string> methodsList, GameObject go)
 {
     methodsList.Clear();
     MonoBehaviour[] components = go.GetComponents<MonoBehaviour>();
     foreach (MonoBehaviour mb in components)
     {
         Type t = mb.GetType();
         MethodInfo[] mis = t.GetMethods();
         foreach (MethodInfo mi in mis)
         {
             if (mi.ReturnType == typeof(TaskStatus))
             {
                 ParameterInfo[] pis = mi.GetParameters();
                 if (pis.Length == 1)
                 {
                     if (pis[0].ParameterType == typeof(GameObject))
                     {
                         string type = t.ToString();
                         string methodName = mi.Name;
                         string newMethod = type + "." + methodName;
                         methodsList.Add(newMethod);
                     }
                 }
             }
         }
     }
 }
Example #26
0
    void RecursiveCopy(GameObject src, GameObject dst)
    {
        Debug.Log("Copying from " + src.name + " to " + dst.name);

        Component[] src_components = src.GetComponents(typeof(Component));

        foreach (Component comp in src_components) {
          if (comp is Transform || comp is Renderer || comp is Animation)
        continue;

          //Debug.Log("Adding " + comp.GetType().Name + " to " + dst.name);
          Component dst_comp = dst.AddComponent(comp.GetType());

          SerializedObject src_ser_obj = new SerializedObject(comp);
          SerializedObject dst_ser_obj = new SerializedObject(dst_comp);
          src_ser_obj.Update();
          dst_ser_obj.Update();

          SerializedProperty ser_prop = src_ser_obj.GetIterator();

          bool enterChildren = true;
          while (ser_prop.Next(enterChildren)) {
        enterChildren = true;
        string path = ser_prop.propertyPath;

        bool skip = false;
        foreach (string blacklisted_path in propertyBlacklist) {
          if (path.EndsWith(blacklisted_path)) {
            skip = true;
            break;
          }
        }
        if (skip) {
          enterChildren = false;
          continue;
        }

        //Debug.Log(path);
        SerializedProperty dst_ser_prop = dst_ser_obj.FindProperty(path);
        AssignSerializedProperty(ser_prop, dst_ser_prop);
          }

          dst_ser_obj.ApplyModifiedProperties();
        }

        foreach (Transform child_transform in src.transform) {
          GameObject child = child_transform.gameObject;

          string dst_object_name = namePrefix + child.name;
          GameObject dst_object = findChildWithName(dst, dst_object_name);

          if (dst_object == null) {
        Debug.LogWarning("Didn't find matching GameObject for " + child.name);
        continue;
          }

          RecursiveCopy(child, dst_object);
        }
    }
	void SetCollidable( GameObject obj, bool collidable )
	{
		foreach( Collider component in obj.GetComponents<Collider>() )
			component.enabled = collidable;
	
		foreach( Collider child in obj.GetComponentsInChildren<Collider>() )
			child.enabled = collidable;
	}
 public void PlayClip( AudioClip clip)
 {
     SoundManager = GameObject.Find ("SoundManager");
     Audio = SoundManager.GetComponents<AudioSource> ();
     SFX = Audio [1];
     SFX.clip = clip;
     SFX.Play ();
 }
Example #29
0
 // Disables all scripts in the child objects
 void disableAll(GameObject cam)
 {
     // Disable the object
     cam.SetActive(false);
     foreach (Behaviour comp in cam.GetComponents<Behaviour>()) {
         comp.enabled = false;
     }
 }
    /// <summary>
    /// Check if a component as a missing script
    /// </summary>
    /// <param name="obj">Object to check</param>
    /// <returns>True if there is at least one missing component</returns>
    private bool CheckForMissingScripts(GameObject obj)
    {
        if (obj == null)
            return false;

        Component[] components = obj.GetComponents<Component>();
        return components != null ? components.Any(c => c == null) : false;
    }