コード例 #1
0
            public void OnGUI()
            {
                if (!Hook.config.DebugMenu.Value)
                {
                    return;
                }
                var id = target.GetHashCode() + 0x14243;

                var    animator = target;
                string title    = string.Format("DEBUG/IOLipsync/{0}", target.gameObject.name);

                if (!windows.TryGetValue(id, out var lastWindow))
                {
                    lastWindow = new Rect(20, 20, 480, 480);
                }

                var window = GUILayout.Window(
                    id, lastWindow,
                    (id1) =>
                {
                    GUI.DragWindow();
                    //GUILayout.BeginArea(new Rect(0, 0, 240, 480));
                    GUILayout.BeginVertical();
                    GUILayout.Label(title);
                    var cnt = animator.layerCount;
                    for (var i = 0; i < cnt; i++)
                    {
                        var toggle = new EnabledToggleKey {
                            id = id, layer = i
                        };
                        if (!enabledKeys.TryGetValue(toggle, out var value))
                        {
                            value = new EnabledToggleValue {
                                enabled = false, value = 0
                            };
                        }

                        GUILayout.BeginHorizontal();
                        float layerWeight = animator.GetLayerWeight(i);
                        value.enabled     = GUILayout.Toggle(value.enabled, string.Format("{0}", animator.GetLayerName(i), layerWeight), GUILayout.Width(90));
                        GUILayout.Label(string.Format("{0}", layerWeight), GUILayout.Width(90));
                        value.value = GUILayout.HorizontalSlider(value.value, 0, 1);
                        GUILayout.EndHorizontal();

                        if (value.enabled)
                        {
                            animator.SetLayerWeight(i, value.value);
                        }

                        enabledKeys[toggle] = value;
                    }

                    GUILayout.EndVertical();
                    //GUILayout.EndArea();
                },
                    title);

                windows[id] = window;
            }
コード例 #2
0
        public override int GetHashCode()
        {
            int hash = 17;

            hash = hash * 23 + (animClip ? animClip.GetHashCode(): 0);
            hash = hash * 23 + (animator ? animator.GetHashCode(): 0);
            return(hash);
        }
コード例 #3
0
        public override int GetHashCode()
        {
            int hash = 17;

            hash = hash * 23 + (controller ? controller.GetHashCode(): 0);
            hash = hash * 23 + (animator ? animator.GetHashCode(): 0);
            return(hash);
        }
コード例 #4
0
 public override int GetHashCode()
 {
     unchecked
     {
         var hashCode = (Animator != null ? Animator.GetHashCode() : 0);
         hashCode = (hashCode * 397) ^ (OriginalController != null ? OriginalController.GetHashCode() : 0);
         hashCode = (hashCode * 397) ^ (OverrideCollections != null ? OverrideCollections.GetHashCode() : 0);
         return(hashCode);
     }
 }
コード例 #5
0
	public static MecanimEvent[] GetEvents(int animatorControllerId, Animator animator) {
		List<MecanimEvent> allEvents = new List<MecanimEvent>();
		
		int animatorHash = animator.GetHashCode();
		if (!lastStates.ContainsKey(animatorHash))
			lastStates[animatorHash] = new Dictionary<int, AnimatorStateInfo>();
		
		int layerCount = animator.layerCount;
		
		Dictionary<int, AnimatorStateInfo> lastLayerState = lastStates[animatorHash];
		
		for (int layer = 0; layer < layerCount; layer++) {
			if (!lastLayerState.ContainsKey(layer)) {
				lastLayerState[layer] = new AnimatorStateInfo();
			}
			
			AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(layer);
			
			int lastLoop = (int)lastLayerState[layer].normalizedTime;
			int currLoop = (int)stateInfo.normalizedTime;
			float lastNormalizedTime = lastLayerState[layer].normalizedTime - lastLoop;
			float currNormalizedTime = stateInfo.normalizedTime - currLoop;
			
			if (lastLayerState[layer].nameHash == stateInfo.nameHash) {
				if (stateInfo.loop == true) {
					if (lastLoop == currLoop) {
						allEvents.AddRange(CollectEvents(animator, animatorControllerId, layer, stateInfo.nameHash, stateInfo.tagHash, lastNormalizedTime, currNormalizedTime));
					}
					else {
						allEvents.AddRange(CollectEvents(animator, animatorControllerId, layer, stateInfo.nameHash, stateInfo.tagHash, lastNormalizedTime, 1.00001f));
						allEvents.AddRange(CollectEvents(animator, animatorControllerId, layer, stateInfo.nameHash, stateInfo.tagHash, 0.0f, currNormalizedTime));
					}
				}
				else {
					float start = Mathf.Clamp01(lastLayerState[layer].normalizedTime);
					float end = Mathf.Clamp01(stateInfo.normalizedTime);
					
					if (lastLoop == 0 && currLoop == 0) {
						if (start != end)
							allEvents.AddRange(CollectEvents(animator, animatorControllerId, layer, stateInfo.nameHash, stateInfo.tagHash, start, end));
					}
					else if (lastLoop == 0 && currLoop > 0) {
						allEvents.AddRange(CollectEvents(animator, animatorControllerId, layer, lastLayerState[layer].nameHash, lastLayerState[layer].tagHash, start, 1.00001f));
					}
					else {
						
					}
				}
			}
			else {
				
				allEvents.AddRange(CollectEvents(animator, animatorControllerId, layer, stateInfo.nameHash, stateInfo.tagHash, 0.0f, currNormalizedTime));
			
				if (!lastLayerState[layer].loop) {
					allEvents.AddRange(CollectEvents(animator, animatorControllerId, layer, lastLayerState[layer].nameHash, lastLayerState[layer].tagHash, lastNormalizedTime, 1.00001f, true));
				}
			}
			
			lastLayerState[layer] = stateInfo;
		}
		
		return allEvents.ToArray();
	}
コード例 #6
0
ファイル: MecanimEventManager.cs プロジェクト: iMouath/Knight
    public static MecanimEvent[] GetEvents(
        Dictionary <int, Dictionary <int, Dictionary <int, List <MecanimEvent> > > > contextLoadedData,
        Dictionary <int, Dictionary <int, AnimatorStateInfo> > contextLastStates,
        int animatorControllerId, Animator animator)
    {
        var allEvents = new List <MecanimEvent>();

        var animatorHash = animator.GetHashCode();

        if (!contextLastStates.ContainsKey(animatorHash))
        {
            contextLastStates[animatorHash] = new Dictionary <int, AnimatorStateInfo>();
        }

        var layerCount = animator.layerCount;

        var lastLayerState = contextLastStates[animatorHash];

        for (var layer = 0; layer < layerCount; layer++)
        {
            if (!lastLayerState.ContainsKey(layer))
            {
                lastLayerState[layer] = new AnimatorStateInfo();
            }

            var stateInfo = animator.GetCurrentAnimatorStateInfo(layer);

            var lastLoop           = (int)lastLayerState[layer].normalizedTime;
            var currLoop           = (int)stateInfo.normalizedTime;
            var lastNormalizedTime = lastLayerState[layer].normalizedTime - lastLoop;
            var currNormalizedTime = stateInfo.normalizedTime - currLoop;

            if (lastLayerState[layer].fullPathHash == stateInfo.fullPathHash)
            {
                if (stateInfo.loop)
                {
                    if (lastLoop == currLoop)
                    {
                        allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer,
                                                         stateInfo.fullPathHash, stateInfo.tagHash, lastNormalizedTime,
                                                         currNormalizedTime));
                    }
                    else
                    {
                        allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer,
                                                         stateInfo.fullPathHash, stateInfo.tagHash, lastNormalizedTime,
                                                         1.00001f));
                        allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer,
                                                         stateInfo.fullPathHash, stateInfo.tagHash, 0.0f,
                                                         currNormalizedTime));
                    }
                }
                else
                {
                    var start = Mathf.Clamp01(lastLayerState[layer].normalizedTime);
                    var end   = Mathf.Clamp01(stateInfo.normalizedTime);

                    if (lastLoop == 0 && currLoop == 0)
                    {
                        if (start != end)
                        {
                            allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer,
                                                             stateInfo.fullPathHash, stateInfo.tagHash, start, end));
                        }
                    }
                    else if (lastLoop == 0 && currLoop > 0)
                    {
                        allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer,
                                                         lastLayerState[layer].fullPathHash,
                                                         lastLayerState[layer].tagHash, start, 1.00001f));
                    }
                }
            }
            else
            {
                allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer,
                                                 stateInfo.fullPathHash, stateInfo.tagHash, 0.0f, currNormalizedTime));

                if (!lastLayerState[layer].loop)
                {
                    allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer,
                                                     lastLayerState[layer].fullPathHash, lastLayerState[layer].tagHash,
                                                     lastNormalizedTime, 1.00001f, true));
                }
            }

            lastLayerState[layer] = stateInfo;
        }

        return(allEvents.ToArray());
    }
コード例 #7
0
	public static MecanimEvent[] GetEvents(Dictionary<int, Dictionary<int, Dictionary<int, List<MecanimEvent>>>> contextLoadedData,
	                                       Dictionary<int, Dictionary<int, AnimatorStateInfo>> contextLastStates,
	                                       int animatorControllerId, Animator animator)
	{
		List<MecanimEvent> allEvents = new List<MecanimEvent>();
		
		int animatorHash = animator.GetHashCode();
		if (!contextLastStates.ContainsKey(animatorHash))
			contextLastStates[animatorHash] = new Dictionary<int, AnimatorStateInfo>();
		
		int layerCount = animator.layerCount;
		
		Dictionary<int, AnimatorStateInfo> lastLayerState = contextLastStates[animatorHash];
		
		for (int layer = 0; layer < layerCount; layer++) {
			if (!lastLayerState.ContainsKey(layer)) {
				lastLayerState[layer] = new AnimatorStateInfo();
			}
			
			AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(layer);
			
			int lastLoop = (int)lastLayerState[layer].normalizedTime;
			int currLoop = (int)stateInfo.normalizedTime;
			float lastNormalizedTime = lastLayerState[layer].normalizedTime - lastLoop;
			float currNormalizedTime = stateInfo.normalizedTime - currLoop;
			
			if (lastLayerState[layer].fullPathHash == stateInfo.fullPathHash) {
				if (stateInfo.loop == true) {
					if (lastLoop == currLoop) {
						allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer, stateInfo.fullPathHash, stateInfo.tagHash, lastNormalizedTime, currNormalizedTime));
					}
					else {
						allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer, stateInfo.fullPathHash, stateInfo.tagHash, lastNormalizedTime, 1.00001f));
						allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer, stateInfo.fullPathHash, stateInfo.tagHash, 0.0f, currNormalizedTime));
					}
				}
				else {
					float start = Mathf.Clamp01(lastLayerState[layer].normalizedTime);
					float end = Mathf.Clamp01(stateInfo.normalizedTime);
					
					if (lastLoop == 0 && currLoop == 0) {
						if (start != end)
							allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer, stateInfo.fullPathHash, stateInfo.tagHash, start, end));
					}
					else if (lastLoop == 0 && currLoop > 0) {
						allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer, lastLayerState[layer].fullPathHash, lastLayerState[layer].tagHash, start, 1.00001f));
					}
					else {
						
					}
				}
			}
			else {
				
				allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer, stateInfo.fullPathHash, stateInfo.tagHash, 0.0f, currNormalizedTime));
				
				if (!lastLayerState[layer].loop) {
					allEvents.AddRange(CollectEvents(contextLoadedData, animator, animatorControllerId, layer, lastLayerState[layer].fullPathHash, lastLayerState[layer].tagHash, lastNormalizedTime, 1.00001f, true));
				}
			}
			
			lastLayerState[layer] = stateInfo;
		}
		
		return allEvents.ToArray();
	}
コード例 #8
0
    public static List <MecanimEvent> GetEvents(Dictionary <int, Dictionary <int, Dictionary <int, List <MecanimEvent> > > > contextLoadedData, Dictionary <int, Dictionary <int, AnimatorStateInfo> > contextLastStates, int animatorControllerId, Animator animator)
    {
        int hashCode = animator.GetHashCode();

        if (!contextLastStates.ContainsKey(hashCode))
        {
            contextLastStates[hashCode] = new Dictionary <int, AnimatorStateInfo>();
        }
        int layerCount = animator.layerCount;
        Dictionary <int, AnimatorStateInfo> dictionary = contextLastStates[hashCode];

        for (int i = 0; i < layerCount; i++)
        {
            if (!dictionary.ContainsKey(i))
            {
                dictionary[i] = default(AnimatorStateInfo);
            }
            AnimatorStateInfo currentAnimatorStateInfo = animator.GetCurrentAnimatorStateInfo(i);
            int   num  = (int)dictionary[i].normalizedTime;
            int   num2 = (int)currentAnimatorStateInfo.normalizedTime;
            float normalizedTimeStart = dictionary[i].normalizedTime - (float)num;
            float normalizedTimeEnd   = currentAnimatorStateInfo.normalizedTime - (float)num2;
            if (dictionary[i].fullPathHash == currentAnimatorStateInfo.fullPathHash)
            {
                if (currentAnimatorStateInfo.loop)
                {
                    if (num == num2)
                    {
                        MecanimEventManager.CollectEvents(MecanimEventManager.allEvents, contextLoadedData, animator, animatorControllerId, i, currentAnimatorStateInfo.fullPathHash, currentAnimatorStateInfo.tagHash, normalizedTimeStart, normalizedTimeEnd, false);
                    }
                    else
                    {
                        MecanimEventManager.CollectEvents(MecanimEventManager.allEvents, contextLoadedData, animator, animatorControllerId, i, currentAnimatorStateInfo.fullPathHash, currentAnimatorStateInfo.tagHash, normalizedTimeStart, 1.00001f, false);
                        MecanimEventManager.CollectEvents(MecanimEventManager.allEvents, contextLoadedData, animator, animatorControllerId, i, currentAnimatorStateInfo.fullPathHash, currentAnimatorStateInfo.tagHash, 0f, normalizedTimeEnd, false);
                    }
                }
                else
                {
                    float num3 = Mathf.Clamp01(dictionary[i].normalizedTime);
                    float num4 = Mathf.Clamp01(currentAnimatorStateInfo.normalizedTime);
                    if (num == 0 && num2 == 0)
                    {
                        if (num3 != num4)
                        {
                            MecanimEventManager.CollectEvents(MecanimEventManager.allEvents, contextLoadedData, animator, animatorControllerId, i, currentAnimatorStateInfo.fullPathHash, currentAnimatorStateInfo.tagHash, num3, num4, false);
                        }
                    }
                    else if (num == 0 && num2 > 0)
                    {
                        MecanimEventManager.CollectEvents(MecanimEventManager.allEvents, contextLoadedData, animator, animatorControllerId, i, dictionary[i].fullPathHash, dictionary[i].tagHash, num3, 1.00001f, false);
                    }
                }
            }
            else
            {
                MecanimEventManager.CollectEvents(MecanimEventManager.allEvents, contextLoadedData, animator, animatorControllerId, i, currentAnimatorStateInfo.fullPathHash, currentAnimatorStateInfo.tagHash, 0f, normalizedTimeEnd, false);
                if (!dictionary[i].loop)
                {
                    MecanimEventManager.CollectEvents(MecanimEventManager.allEvents, contextLoadedData, animator, animatorControllerId, i, dictionary[i].fullPathHash, dictionary[i].tagHash, normalizedTimeStart, 1.00001f, true);
                }
            }
            dictionary[i] = currentAnimatorStateInfo;
        }
        return(MecanimEventManager.allEvents);
    }
コード例 #9
0
    private void Update()
    {
        if (!isLocalPlayer)
        {
            return;
        }

        if (BuffedSpeed())
        {
            Speed = BUFFED_SPEED;
        }
        else
        {
            Speed = INIT_SPEED;
        }

        if (Cursor.lockState != CursorLockMode.Locked)
        {
            Cursor.lockState = CursorLockMode.Locked;
        }

        if (Input.GetKeyDown(KeyCode.P))
        {
            ApplyDamage(100);
        }

        ammotext.text = weapon.ActualCapacity.ToString() + " / " + weapon.MaxCapacity.ToString();
        if ((float)weapon.ActualCapacity / (float)weapon.MaxCapacity <= 0.15F)
        {
            ammotext.color = Color.red;
        }
        else
        {
            ammotext.color = Color.yellow;
        }

        healthBarTransform.fillAmount = currentHealth / 100;

        if (weapon == null)
        {
            searcher.FindObjectwithTag("Weapon");
            weapon      = searcher.actors[0].GetComponent <Weapon>();
            bulletSpawn = weapon.Origin;
            return;
        }

        float move = Input.GetAxis("Vertical");

        anim.SetFloat("Speed", move);
        anim.SetBool("isBackwards", Input.GetKey(KeyCode.S));

        CheckShoot();

        if (anim.GetCurrentAnimatorStateInfo(0).IsName("jump_inPlace"))
        {
            anim.GetHashCode();
        }

        if (Input.GetKeyDown(KeyCode.Space) && isGrounded())
        {
            playerRigidBody.AddForce(Vector3.up * jumpSpeed, ForceMode.Impulse);
            anim.SetTrigger(jumpHash);
        }
    }
コード例 #10
0
    // Token: 0x0600159D RID: 5533 RVA: 0x00078EA8 File Offset: 0x000770A8
    public static ICollection <MecanimEvent> GetEvents(int animatorControllerId, Animator animator)
    {
        List <MecanimEvent> list = new List <MecanimEvent>();
        int hashCode             = animator.GetHashCode();

        if (!MecanimEventManager.lastStates.ContainsKey(hashCode))
        {
            MecanimEventManager.lastStates[hashCode] = new Dictionary <int, AnimatorStateInfo>();
        }
        int layerCount = animator.layerCount;
        Dictionary <int, AnimatorStateInfo> dictionary = MecanimEventManager.lastStates[hashCode];

        for (int i = 0; i < layerCount; i++)
        {
            if (!dictionary.ContainsKey(i))
            {
                dictionary[i] = default(AnimatorStateInfo);
            }
            AnimatorStateInfo animatorStateInfo        = dictionary[i];
            AnimatorStateInfo currentAnimatorStateInfo = animator.GetCurrentAnimatorStateInfo(i);
            int   num  = (int)animatorStateInfo.normalizedTime;
            int   num2 = (int)currentAnimatorStateInfo.normalizedTime;
            float normalizedTimeStart = animatorStateInfo.normalizedTime - (float)num;
            float normalizedTimeEnd   = currentAnimatorStateInfo.normalizedTime - (float)num2;
            if (animatorStateInfo.nameHash == currentAnimatorStateInfo.nameHash)
            {
                if (currentAnimatorStateInfo.loop)
                {
                    if (num == num2)
                    {
                        list.AddRange(MecanimEventManager.CollectEvents(animator, animatorControllerId, i, currentAnimatorStateInfo.nameHash, currentAnimatorStateInfo.tagHash, normalizedTimeStart, normalizedTimeEnd, false));
                    }
                    else
                    {
                        list.AddRange(MecanimEventManager.CollectEvents(animator, animatorControllerId, i, currentAnimatorStateInfo.nameHash, currentAnimatorStateInfo.tagHash, normalizedTimeStart, 1.00001f, false));
                        list.AddRange(MecanimEventManager.CollectEvents(animator, animatorControllerId, i, currentAnimatorStateInfo.nameHash, currentAnimatorStateInfo.tagHash, 0f, normalizedTimeEnd, false));
                    }
                }
                else
                {
                    float num3 = Mathf.Clamp01(animatorStateInfo.normalizedTime);
                    float num4 = Mathf.Clamp01(currentAnimatorStateInfo.normalizedTime);
                    if (num == 0 && num2 == 0)
                    {
                        if (num3 != num4)
                        {
                            list.AddRange(MecanimEventManager.CollectEvents(animator, animatorControllerId, i, currentAnimatorStateInfo.nameHash, currentAnimatorStateInfo.tagHash, num3, num4, false));
                        }
                    }
                    else if (num == 0 && num2 > 0)
                    {
                        list.AddRange(MecanimEventManager.CollectEvents(animator, animatorControllerId, i, animatorStateInfo.nameHash, animatorStateInfo.tagHash, num3, 1.00001f, false));
                    }
                }
            }
            else
            {
                list.AddRange(MecanimEventManager.CollectEvents(animator, animatorControllerId, i, currentAnimatorStateInfo.nameHash, currentAnimatorStateInfo.tagHash, 0f, normalizedTimeEnd, false));
                if (!animatorStateInfo.loop)
                {
                    list.AddRange(MecanimEventManager.CollectEvents(animator, animatorControllerId, i, animatorStateInfo.nameHash, animatorStateInfo.tagHash, normalizedTimeStart, 1.00001f, true));
                }
            }
            dictionary[i] = currentAnimatorStateInfo;
        }
        return(list);
    }