// Use this for initialization void Start() { m_RootRef = gameObject; m_TransformRef = new TransformCache(m_RootRef.transform); m_ScaleFactor = (-m_RootRef.transform.localScale.x) / m_RootRef.transform.localScale.x; m_State = AnimationState.Idle; }
void OnEnable() { MyAnimation = MyTransform.GetComponent<Animation>(); MyAnimation.wrapMode = MyWarpMode; MyAnimationState = MyAnimation[MyAnimation.animation.clip.name]; MyAnimationStateTime = 0.0f; }
/// <summary> /// Constructor that specifies a starting state for the animation /// </summary> /// <param name="startingState">Only Showing or Hiding should be used</param> public Animator(UserControl animateControl, AnimationState startingState) { InitializeTimer(); animatedControl = animateControl; state = startingState; tmrAnimate.Start(); }
public void ChangeAnimationState(AnimationState _NextState, float _DelayTime, bool _RestoreTransform = false) { if (m_NextState != _NextState) { m_NextState = _NextState; StartCoroutine(PerformChangeAnimationState(_NextState, _DelayTime, _RestoreTransform)); } }
// Use this for initialization void Start() { lastPosition = transform.position; walk = animation["walk"]; walk.enabled = true; walk.weight = 0; }
// Use this for initialization void Start() { animation.Stop(); // By default loop all animations animation.wrapMode = WrapMode.Loop; // Jump animation are in a higher layer: // Thus when a jump animation is playing it will automatically override all other animations until it is faded out. // This simplifies the animation script because we can just keep playing the walk / run / idle cycle without having to spcial case jumping animations. int jumpingLayer = 1; AnimationState jump = animation["jump"]; jump.layer = jumpingLayer; jump.speed *= jumpAnimationSpeedModifier; jump.wrapMode = WrapMode.Once; AnimationState jumpFall = animation["jumpFall"]; jumpFall.layer = jumpingLayer; jumpFall.wrapMode = WrapMode.ClampForever; AnimationState jumpLand = animation["jumpLand"]; jumpLand.layer = jumpingLayer; jumpLand.speed *= jumpLandAnimationSpeedModifier; jumpLand.wrapMode = WrapMode.Once; //AnimationState buttStomp = animation["buttStomp"]; run = animation["run"]; run.speed *= runAnimationSpeedModifier; AnimationState walk = animation["walk"]; walk.speed *= walkAnimationSpeedModifier; }
// Run as the scene is initializing void Awake() { player = GameObject.FindWithTag("Player"); playerStart = GameObject.Find ("PlayerStart"); door = GameObject.FindWithTag("BedroomDoor"); cinematic = player.animation["Beginning_Cinematic"]; }
public virtual void Update(GameTime gameTime) { //_Sprite.Update(gameTime); if (_AnimationState == AnimationState.Waiting) { if (_AnimationDelayCount >= _AnimationDelayInterval) PreAnimation(); } else if (_AnimationState == AnimationState.Animate) { StartSiblingAnimations(FireTime.AtStart); if (_AnimationDelayCount < _AnimationDelayInterval) _AnimationDelayCount += gameTime.ElapsedGameTime.Milliseconds; else { if (_AnimationCount < _AnimationInterval) { _AnimationCount = MathHelper.Clamp(_AnimationCount + gameTime.ElapsedGameTime.Milliseconds, 0, _AnimationInterval); AnimationLogic(); } else { PostAnimation(); _AnimationState = AnimationState.End; StartSiblingAnimations(FireTime.AtEnd); } } } }
// Use this for initialization void Start () { lat = animation[lateralClip.name]; vert = animation[verticalClip.name]; lat.layer = 1; vert.layer = 2; lat.speed = 0; vert.speed = 0; lat.blendMode = AnimationBlendMode.Blend; vert.blendMode = AnimationBlendMode.Additive; lat.enabled = true; vert.enabled = true; animation.Play(lat.name); animation.Play(vert.name); // we have to sample the frames to determine the min and max extent in each direction lat.time = 0; vert.time = 0; animation.Sample(); minOffset = endpoint.position; lat.normalizedTime = 1; vert.normalizedTime = 1; animation.Sample(); maxOffset = endpoint.position; vertMin = minOffset.y; minOffset.y = startpoint.position.y; float maxY = maxOffset.y; maxOffset.y = startpoint.position.y; latMin = Vector3.Distance(startpoint.position, minOffset); // float maxRange = Vector3.Distance(startpoint.position, maxOffset); latScale = 1.0f/(Vector3.Distance(minOffset, maxOffset)); // so time = scale * (range-min); vertScale = 1.0f/(maxY - vertMin); }
void Update() { if (Input.GetButton("Fire3")) { animationState = AnimationState.Falling; } switch (animationState) { case AnimationState.NotAnimated: break; case AnimationState.Falling: FallDown(); break; case AnimationState.LayingDown: float vertical = CrossPlatformInputManager.GetAxis("Vertical"); if (vertical != 0) { animationState = AnimationState.GettingUp; } break; case AnimationState.GettingUp: GetUp(); break; default: break; } }
// Update is called once per frame void Update() { if (Input.GetAxis("Horizontal")>0) { animationState=AnimationState.walkRight; currentIdleTime=0.0f; startIdleTime=true; } else if (Input.GetAxis("Horizontal")<0) { animationState=AnimationState.walkLeft; currentIdleTime=0.0f; startIdleTime=true; } else if (Input.GetAxis("Vertical")>0) { animationState=AnimationState.walkBack; currentIdleTime=0.0f; startIdleTime=true; } else if (Input.GetAxis("Vertical")<0) { animationState=AnimationState.walkFront; currentIdleTime=0.0f; startIdleTime=true; } if (startIdleTime) { UpdateToIdleAnimations(); } UpdateAnimation(); }
public void OnStateAnimationChange(AnimationState previousState, AnimationState actualState) { bool change = false; switch (actualState) { case AnimationState.WALK: case AnimationState.CHASE: case AnimationState.RUN_AWAY: if (settedFX) break; settedFX = true; change = true; break; default: if (!settedFX) break; settedFX = false; change = true; break; } if (change) { foreach (ParticleSystem system in walkingFX.GetComponentsInChildren<ParticleSystem>()) { ParticleSystem.EmissionModule emission = system.emission; emission.enabled = settedFX; } } }
public void Start() { animState = animation[animation.clip.name]; animState.speed = 0; fogColor = RenderSettings.fogColor; ambientLight = RenderSettings.ambientLight; }
protected void Initialise() { // The Animation Controller feeds on AnimationStates. You've got to assign your animations to variables so that you can call them from the controller // GetComponent<Animation>()["Attack1"].speed = 2.0f; GetComponent<Animation>()["Attack2"].speed = 2.0f; // // animationAttack1Anticipation = GetComponent<Animation>()["Attack1Anticipation"]; animationAttack1 = GetComponent<Animation>()["Attack1"]; // animationAttack2Anticipation = GetComponent<Animation>()["Attack2Anticipation"]; animationAttack2 = GetComponent<Animation>()["Attack2"]; animationAttack3 = GetComponent<Animation>()["WhirlwindAttack"]; // animationWhirlwind = GetComponent<Animation>()["Whirlwind"]; animationIdle = GetComponent<Animation>()["Idle"]; animationIdle.speed = 0.4f; animationRespawn = GetComponent<Animation>()["Resurection"]; animationRespawn.speed = 0.8f; animationAttack3.speed = 0.8f; // leftSwipe.SetTime (0.0f, 0, 1); rightSwipe.SetTime (0.0f, 0, 1); // }
// Use this for initialization void Start() { mOctopusAnim = GetComponent<Animator>(); mOctopusAnim.SetFloat(mBlendTree, 1.0f); mRandomRange = Random.Range(minAttackTime, maxAttackTime); mAnimState = AnimationState.Idle; }
public void Start () { anim = GetComponent<Animation>(); animState = anim[anim.clip.name]; // reset effects percent = 0; Sample(); }
// public void CrossfadeAnimation(AnimationState state, float fadeTime) { // ** This function is exactly like the Unity Animation.Crossfade() method // if (currentState == state) return; animationFadeTime = fadeTime; for (int i = 0; i < fadingStates.Count; i++) { if (state.name == fadingStates[i].name) { fadingStates.RemoveAt (i); if (currentState != null) fadingStates.Add (currentState); currentState = state; return; } } // if (currentState != null) fadingStates.Add (currentState); // currentState = state; currentState.weight = 0; currentState.time = currentStateTime = 0; currentState.enabled = true; // }
void Start() { if (Timer == null) Timer = GetComponent<CountdownTimer>(); if (Timer == null) { enabled = false; return; } if (Target == null) Target = animation; if (Target == null) { enabled = false; return; } cl = animation.GetClip(AnimationName); if (cl == null) { Debug.LogError("Animation " + AnimationName + " not found on object"); return; } if (!Blend) { animation.Play(AnimationName); } else { animation.Blend(AnimationName, BlendWeight, 0f); } st = animation[AnimationName]; st.speed = 0; }
public void GetAnimationState(Entity entity) { Entity = entity; State = Entity.GetAnimationState(StateName); State.Loop = Loop; State.Weight = 0; }
public void Start () { anim = animation; animState = anim[anim.clip.name]; // reset effects percent = 0; Sample(); }
// Use this for initialization void Start() { _transform = transform; _lastPosition = _transform.position; _walk = animation["walk"]; _walk.layer = 2; }
// Use this for initialization void Start() { walk = animation["walking"]; foreach (AnimationState state in animation) { state.speed = 4f; } }
void Start() { lifeValue = life.getBloodValue(); life.addBloodValueChangeCallback(lifeChangedCall); fire1AnimationState = myAnimation["fire1"]; fire2AnimationState = myAnimation["fire2"]; }
void Start() { float frames = _animation.frameRate * _animation.length;//��ȡ֡�� _startN = _start/frames;//0-1 �淶�� _endN = _end/frames;//0-1 �淶�� _animationState = animation[_animation.name]; _trail.Emit = false; }
void Start() { state = AnimationState.IDLE; status = Status.NOT_FOUND; // RunTowards (new Vector3(transform.position.x +10f, transform.position.y, transform.position.z)); }
void Start() { float frames = _animation.frameRate * _animation.length; _startN = _start / frames; _endN = _end / frames; _animationState = GetComponent<Animation>()[_animation.name]; _trail.Emit = false; }
public Animation (IAnimationDrawer drawer, uint duration, Easing easing, Blocking blocking) { this.Drawer = drawer; this.Duration = duration; this.Easing = easing; this.Blocking = blocking; this.AnimationState = AnimationState.Coming; }
private void LoadAnimations() { walkAnimationList = Resources.LoadAll<Sprite>("DwarfWalk").ToList(); otherAnimationList = Resources.LoadAll<Sprite>("DwarfOther").ToList(); spriteDirection = SpriteDirection.Down; animationState = AnimationState.IdleDown; }
// set current animation and restart if it's a different animation public void setAnimationState(AnimationState animation) { if (currentAnimation != animation) { currentAnimation = animation; animationStateTime = 0; } }
public void Attacking(Actor self, Target target) { State = AnimationState.Attacking; if (anim.HasSequence("shoot")) anim.PlayThen("shoot", () => State = AnimationState.Idle); else if (anim.HasSequence("heal")) anim.PlayThen("heal", () => State = AnimationState.Idle); }
public AnimationState(AnimationStateSet parent, AnimationState rhs) : this(OgrePINVOKE.new_AnimationState__SWIG_3(AnimationStateSet.getCPtr(parent), AnimationState.getCPtr(rhs)), true) { if (OgrePINVOKE.SWIGPendingException.Pending) { throw OgrePINVOKE.SWIGPendingException.Retrieve(); } }
/// <summary> /// This method loads the animation from the animation name /// </summary> private void LoadAnimation() { animationState = robot.GameEntity.GetAnimationState(animationName); animationState.Loop = true; animationState.Enabled = true; }
void Update() { // Animation combo system if (ComboAttackLists.Length <= 0) // if have no combo list { return; } comboList = ComboAttackLists[WeaponType].Split(","[0]); // Get list of animation index from combolists split by WeaponType if (comboList.Length > attackStep) { int poseIndex = int.Parse(comboList[attackStep]); // Read index of current animation from combo array if (poseIndex < PoseAttackNames.Length) { // checking index of PoseAttackNames list AnimationState attackState = this.gameObject.GetComponent <Animation>()[PoseAttackNames[poseIndex]]; // get animation PoseAttackNames[poseIndex] attackState.layer = 2; attackState.blendMode = AnimationBlendMode.Blend; attackState.speed = SpeedAttack; if (attackState.time >= attackState.length * 0.1f) { // set attacking to True when time of attack animation is running to 10% of animation attacking = true; } if (attackState.time >= PoseAttackTime[poseIndex]) { // if the time of attack animation is running to marking point (PoseAttackTime[poseIndex]) // calling CharacterAttack.cs to push a damage out if (!diddamaged) { // push a damage out this.gameObject.GetComponent <CharacterAttack>().DoDamage(); } } if (attackState.time >= attackState.length * 0.8f) { // if the time of attack animation is running to 80% of animation. It's should be Finish this pose. attackState.normalizedTime = attackState.length; diddamaged = true; attacking = false; attackStep += 1; if (attackStack > 1) { // checking if a calling attacking is stacked fightAnimation(); } else { if (attackStep >= comboList.Length) { // finish combo and reset to idle pose resetCombo(); this.gameObject.GetComponent <Animation>().Play(PoseIdle); } } // reset character damage system this.gameObject.GetComponent <CharacterAttack>().StartDamage(); } } } if (hited) // Freeze when got hit { if (frozetime > 0) { frozetime--; } else { hited = false; this.gameObject.GetComponent <Animation>().Play(PoseIdle); } } if (Time.time > attackStackTimeTemp + 2) { resetCombo(); } }
void Update() { //If we're not idle, calculate the progress through the current motion. if (currentState != AnimationState.Idle) { movementProgress = (Time.time - movementStartTime) / movementTime; //Cap at 1 if needed. if (movementProgress > 1f) { movementProgress = 1f; } } //Perform location calculations based on the current state. switch (currentState) { case AnimationState.Idle: //Do nothing if idle. break; case AnimationState.SingleMovement1: //We're moving towards the character. newXPosition = ((1 - movementProgress) * movementStartPosition.x) + (movementProgress * objectTarget1.transform.position.x); newYPosition = ((1 - movementProgress) * movementStartPosition.y) + (movementProgress * objectTarget1.transform.position.y); //Update hand position. deathHandObject.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); //Have we finished the movement? if (movementProgress == 1f) { //Move to the next stage, SingleMovement2. currentState = AnimationState.SingleMovement2; movementStartPosition = deathHandObject.transform.position; movementStartTime = Time.time; //Toggle hand to closed. handAnimator.SetTrigger("ToggleHandState"); } break; case AnimationState.SingleMovement2: //We're moving towards the destination. newXPosition = ((1 - movementProgress) * movementStartPosition.x) + (movementProgress * destination1.transform.position.x); newYPosition = ((1 - movementProgress) * movementStartPosition.y) + (movementProgress * destination1.transform.position.y); //Update hand and character position. deathHandObject.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); objectTarget1.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); //Have we finished the movement? if (movementProgress == 1f) { //In the case of eliminating the last remaining character, we'll already be at the starting location. In that case, we can just enter idle. if (deathHandObject.transform.position == startingLocation.transform.position) { //We are at the start. Enter the idle state. currentState = AnimationState.Idle; } else { //We aren't at the start, so move to the next stage, Returning. currentState = AnimationState.Returning; movementStartPosition = deathHandObject.transform.position; movementStartTime = Time.time; } //Toggle hand to open. handAnimator.SetTrigger("ToggleHandState"); } break; case AnimationState.DuoMovement1: //We're moving towards the first character. newXPosition = ((1 - movementProgress) * movementStartPosition.x) + (movementProgress * objectTarget1.transform.position.x); newYPosition = ((1 - movementProgress) * movementStartPosition.y) + (movementProgress * objectTarget1.transform.position.y); //Update hand position. deathHandObject.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); //Have we finished the movement? if (movementProgress == 1f) { //Move to the next stage, DuoMovement2. currentState = AnimationState.DuoMovement2; movementStartPosition = deathHandObject.transform.position; movementStartTime = Time.time; //Toggle hand to closed. handAnimator.SetTrigger("ToggleHandState"); } break; case AnimationState.DuoMovement2: //We're moving towards the first destination. newXPosition = ((1 - movementProgress) * movementStartPosition.x) + (movementProgress * destination1.transform.position.x); newYPosition = ((1 - movementProgress) * movementStartPosition.y) + (movementProgress * destination1.transform.position.y); //Update hand and character position. deathHandObject.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); objectTarget1.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); //Have we finished the movement? if (movementProgress == 1f) { //Move to the next stage, DuoMovement3. currentState = AnimationState.DuoMovement3; movementStartPosition = deathHandObject.transform.position; movementStartTime = Time.time; //Toggle hand to open. handAnimator.SetTrigger("ToggleHandState"); } break; case AnimationState.DuoMovement3: //We're moving towards the second character. newXPosition = ((1 - movementProgress) * movementStartPosition.x) + (movementProgress * objectTarget2.transform.position.x); newYPosition = ((1 - movementProgress) * movementStartPosition.y) + (movementProgress * objectTarget2.transform.position.y); //Update hand position. deathHandObject.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); //Have we finished the movement? if (movementProgress == 1f) { //Move to the next stage, DuoMovement4. currentState = AnimationState.DuoMovement4; movementStartPosition = deathHandObject.transform.position; movementStartTime = Time.time; //Toggle hand to closed. handAnimator.SetTrigger("ToggleHandState"); } break; case AnimationState.DuoMovement4: //We're moving towards the second destination. newXPosition = ((1 - movementProgress) * movementStartPosition.x) + (movementProgress * destination2.transform.position.x); newYPosition = ((1 - movementProgress) * movementStartPosition.y) + (movementProgress * destination2.transform.position.y); //Update hand and character position. deathHandObject.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); objectTarget2.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); //Have we finished the movement? if (movementProgress == 1f) { //Move to the next stage, Returning. currentState = AnimationState.Returning; movementStartPosition = deathHandObject.transform.position; movementStartTime = Time.time; //Toggle hand to open. handAnimator.SetTrigger("ToggleHandState"); } break; case AnimationState.Returning: //We're returning to the start position. newXPosition = ((1 - movementProgress) * movementStartPosition.x) + (movementProgress * startingLocation.transform.position.x); newYPosition = ((1 - movementProgress) * movementStartPosition.y) + (movementProgress * startingLocation.transform.position.y); //Update hand position. deathHandObject.transform.position = new Vector3(newXPosition, newYPosition, startingLocation.transform.position.z); //Have we finished the movement? if (movementProgress == 1f) { //Return to the idle state. currentState = AnimationState.Idle; } break; default: Debug.Log("Animation controller in an unrecognized state."); break; } }
protected override void OnDestroy() { m_animation = null; m_currentAnimationState = null; base.OnDestroy(); }
public void init(AnimationState ms) { play(ms); }
public bool isSame(AnimationState mX, AnimationState mY) { return(motionX == mX && motionY == mY); }
public bool isSame(AnimationState m) { return(motionY == null && motionX == m); }
private void ExportMeshAnimation() { AnimationClip[] animationClips = exportParams.AnimationClips; string[] animationClipNames = exportParams.AnimationNames; GameObject instanceObj = Instantiate(fbx) as GameObject; UnityEngine.Animation animation = instanceObj.GetComponentInChildren <UnityEngine.Animation>(); SkinnedMeshRenderer[] skinnedMeshRenders = instanceObj.GetComponentsInChildren <SkinnedMeshRenderer>(); int subMeshLength = skinnedMeshRenders.Length; Mesh[] subMeshArr = new Mesh[subMeshLength]; for (int i = 0; i < subMeshLength; i++) { subMeshArr[i] = skinnedMeshRenders[i].sharedMesh; } float interval = 1.0f / exportParams.FrameRate; if (File.Exists(exportParams.OutputFilePath)) { File.Delete(exportParams.OutputFilePath); } ExportMeshAnimationData meshAnimationData = ScriptableObject.CreateInstance <ExportMeshAnimationData>(); meshAnimationData.GenerateNormal = exportParams.GenerateNormal; meshAnimationData.SubMeshLength = subMeshLength; meshAnimationData.Fps = exportParams.FrameRate; meshAnimationData.SubMeshData = new ExportMeshAnimationData.AnimationSubMeshData[subMeshLength]; for (int i = 0; i < subMeshLength; i++) { meshAnimationData.SubMeshData[i].ClipDatas = new ExportMeshAnimationData.AnimationClipData[animationClips.Length]; meshAnimationData.SubMeshData[i].FrameRate = exportParams.FrameRate; for (int j = 0; j < animationClips.Length; j++) { AnimationClip clip = animationClips[j]; if (clip == null) { return; } animation.AddClip(clip, animationClipNames[j]); animation.clip = clip; AnimationState state = animation[animationClipNames[j]]; state.enabled = true; state.weight = 1; List <float> frameTimes = GetFrameTimes(clip.length, interval); meshAnimationData.SubMeshData[i].ClipDatas[j].FrameDatas = new ExportMeshAnimationData.AnimationFrameData[frameTimes.Count]; meshAnimationData.SubMeshData[i].ClipDatas[j].ClipName = animationClipNames[j]; for (int k = 0; k < frameTimes.Count; k++) { state.time = frameTimes[k]; animation.Play(); animation.Sample(); Matrix4x4 matrix4X4 = skinnedMeshRenders[i].transform.localToWorldMatrix; Mesh backMesh = BakeFrameAfterMatrixTransform(skinnedMeshRenders[i], matrix4X4); meshAnimationData.SubMeshData[i].ClipDatas[j].FrameDatas[k].Vertexs = backMesh.vertices; backMesh.Clear(); DestroyImmediate(backMesh); animation.Stop(); } } meshAnimationData.SubMeshData[i].UVs = subMeshArr[i].uv; meshAnimationData.SubMeshData[i].Triangles = subMeshArr[i].triangles; } AssetDatabase.CreateAsset(meshAnimationData, GetAssetPath(exportParams.OutputFilePath) + fbx.name + ".asset"); AssetDatabase.Refresh(); }
public virtual void playMotion(AnimationState ms) { }
public void Enter() { this.CurrentState = AnimationState.EnterStart; }
internal void MoveSingleCharacterToLocation(AnimationObject objectTarget, AnimationLocation targetLocation) { //Set our values used for actual movement. //Set reference start position. movementStartPosition = startingLocation.transform.position; //Set the target. switch (objectTarget) { case AnimationObject.Player: objectTarget1 = playerObject; break; case AnimationObject.AI1: objectTarget1 = AI1Object; break; case AnimationObject.AI2: objectTarget1 = AI2Object; break; case AnimationObject.AI3: objectTarget1 = AI3Object; break; default: Debug.Log("Animation controller attempting to move a non-existent object."); break; } //Set the destination. switch (targetLocation) { case AnimationLocation.Pump: destination1 = pumpLocation; break; case AnimationLocation.PlayerLocation: destination1 = playerLocation; break; case AnimationLocation.AI1Location: destination1 = AI1Location; break; case AnimationLocation.AI2Location: destination1 = AI2Location; break; case AnimationLocation.AI3Location: destination1 = AI3Location; break; case AnimationLocation.StartingLocation: destination1 = startingLocation; break; default: Debug.Log("Animation controller attempting to move to a non-existent location."); break; } //Set the controller to do a single movement. movementStartTime = Time.time; currentState = AnimationState.SingleMovement1; }
internal void MoveDoubleCharacterToLocations(AnimationObject firstTarget, AnimationLocation firstDestination, AnimationObject secondTarget, AnimationLocation secondDestination) { //Set our values used for actual movement. //Set reference start position. movementStartPosition = startingLocation.transform.position; //Set the first target. switch (firstTarget) { case AnimationObject.Player: objectTarget1 = playerObject; break; case AnimationObject.AI1: objectTarget1 = AI1Object; break; case AnimationObject.AI2: objectTarget1 = AI2Object; break; case AnimationObject.AI3: objectTarget1 = AI3Object; break; default: Debug.Log("Animation controller attempting to move a non-existent object."); break; } //Set the first destination. switch (firstDestination) { case AnimationLocation.Pump: destination1 = pumpLocation; break; case AnimationLocation.PlayerLocation: destination1 = playerLocation; break; case AnimationLocation.AI1Location: destination1 = AI1Location; break; case AnimationLocation.AI2Location: destination1 = AI2Location; break; case AnimationLocation.AI3Location: destination1 = AI3Location; break; case AnimationLocation.StartingLocation: destination1 = startingLocation; break; default: Debug.Log("Animation controller attempting to move to a non-existent location."); break; } //Set the second target. switch (secondTarget) { case AnimationObject.Player: objectTarget2 = playerObject; break; case AnimationObject.AI1: objectTarget2 = AI1Object; break; case AnimationObject.AI2: objectTarget2 = AI2Object; break; case AnimationObject.AI3: objectTarget2 = AI3Object; break; default: Debug.Log("Animation controller attempting to move a non-existent object."); break; } //Set the second destination. switch (secondDestination) { case AnimationLocation.Pump: destination2 = pumpLocation; break; case AnimationLocation.PlayerLocation: destination2 = playerLocation; break; case AnimationLocation.AI1Location: destination2 = AI1Location; break; case AnimationLocation.AI2Location: destination2 = AI2Location; break; case AnimationLocation.AI3Location: destination2 = AI3Location; break; case AnimationLocation.StartingLocation: destination2 = startingLocation; break; default: Debug.Log("Animation controller attempting to move to a non-existent location."); break; } //Set the controller to do a duo movement. movementStartTime = Time.time; currentState = AnimationState.DuoMovement1; }
/// <summary> /// Convenience method for duplicating a skeleton's current active skin so changes to it will not affect other skeleton instances. .</summary> public static Skin UnshareSkin(this Skeleton skeleton, bool includeDefaultSkin, bool unshareAttachments, AnimationState state = null) { // 1. Copy the current skin and set the skeleton's skin to the new one. var newSkin = skeleton.GetClonedSkin("cloned skin", includeDefaultSkin, unshareAttachments, true); skeleton.SetSkin(newSkin); // 2. Apply correct attachments: skeleton.SetToSetupPose + animationState.Apply if (state != null) { skeleton.SetToSetupPose(); state.Apply(skeleton); } // 3. Return unshared skin. return(newSkin); }
// Update is called once per frame void Update() { if (Player.name == "Player 1") { RunSpeed = Perks.GetComponent <PerkScript>().Player1RunSpeed; JumpSpeed = Perks.GetComponent <PerkScript>().Player1JumpSpeed; ReloadTime = Perks.GetComponent <PerkScript>().Player1ReloadSpeed; } else { RunSpeed = Perks.GetComponent <PerkScript>().Player2RunSpeed; JumpSpeed = Perks.GetComponent <PerkScript>().Player2JumpSpeed; ReloadTime = Perks.GetComponent <PerkScript>().Player2ReloadSpeed; } switch (animationState) { case AnimationState.NONE: animator.SetBool("isIdle", false); animator.SetBool("isRunning", false); animator.SetBool("isJumping", false); animator.SetBool("isCrouch", false); animator.SetBool("ShootLow", false); break; case AnimationState.IDLE: animator.SetBool("isIdle", true); animator.SetBool("isRunning", false); animator.SetBool("isJumping", false); animator.SetBool("isCrouch", false); animator.SetBool("ShootLow", false); break; case AnimationState.RUNNING: animator.SetBool("isIdle", false); animator.SetBool("isRunning", true); animator.SetBool("isJumping", false); animator.SetBool("isCrouch", false); animator.SetBool("ShootLow", false); break; case AnimationState.JUMP: animator.SetBool("isIdle", false); animator.SetBool("isRunning", false); animator.SetBool("isJumping", true); animator.SetBool("isCrouch", false); animator.SetBool("ShootLow", false); break; case AnimationState.CROUCH: animator.SetBool("isIdle", false); animator.SetBool("isRunning", false); animator.SetBool("isJumping", false); animator.SetBool("isCrouch", true); animator.SetBool("ShootLow", false); break; case AnimationState.SHOOTLOW: animator.SetBool("isIdle", false); animator.SetBool("isRunning", false); animator.SetBool("isJumping", false); animator.SetBool("isCrouch", false); animator.SetBool("ShootLow", true); break; default: break; } if (Player.gameObject.name == "Player 1") { isPaused = GetComponent <PauseMenuScript>().isPaused; } else { isPaused = Enemy.GetComponent <PauseMenuScript>().isPaused; } EnemyCover = Enemy.GetComponent <Players>().InCover; // checks if the enemy is in cover MuzzleFlashFunct(); //Function that handles muzzle flashes //***************This makes the player pull out their gun when comming out of cover*************************** if (InCover) { // Gun.SetActive(false); } else { // Gun.SetActive(true); } if (InCover && !ChooseJump && !ChooseRun) { animationState = AnimationState.CROUCH; } Aiming(); //***************************Resets the game for testing purposes************************************************************************ if (Input.GetKeyDown(Reset)) { Player.transform.position = new Vector2(Spawn.transform.position.x, Spawn.transform.position.y); CoverPosition = 0; Enemy.GetComponent <Players>().InCover = true; ChooseRun = false; ChooseJump = false; jumping = false; InCover = false; } //****************************This handles when a player hits another player ****************************** if (((DeadTime1 - DeadTime2) > BulletHitTime) && ShotLow && !EnemyCover && !Enemy.GetComponent <Players>().ChooseJump) //Determines the delay between bullet firing and hitting target { Enemy.transform.position = Enemy.GetComponent <Players>().Spawn.transform.position; //Respawns the hit player //resets variables Enemy.GetComponent <Players>().CoverPosition = 0; Enemy.GetComponent <Players>().CanShoot = true; Enemy.GetComponent <Players>().InCover = false; Enemy.GetComponent <Players>().ChooseRun = false; Enemy.GetComponent <Players>().jumping = false; Enemy.GetComponent <Players>().ChooseJump = false; ShotLow = false; AudioManager.instance.PlaySFX(2); } else if (((DeadTime1 - DeadTime2) > BulletMissTime)) //This means the bullet has passed and wont hit the player { ShotLow = false; } //This just does the same thing as the statement above but for when the player jumps if (((DeadTime1 - DeadTime2) > BulletHitTime) & ShotHigh && !EnemyCover && Enemy.GetComponent <Players>().ChooseJump) { Enemy.transform.position = Enemy.GetComponent <Players>().Spawn.transform.position; //respawns enemy //reset variables Enemy.GetComponent <Players>().CoverPosition = 0; Enemy.GetComponent <Players>().jumping = false; Enemy.GetComponent <Players>().CanShoot = true; ShotHigh = false; Enemy.GetComponent <Players>().InCover = true; Enemy.GetComponent <Players>().ChooseRun = false; Enemy.GetComponent <Players>().ChooseJump = false; AudioManager.instance.PlaySFX(2); } else if (((DeadTime1 - DeadTime2) > 0.6f)) { ShotHigh = false; } PlayerChoosesRun(); PlayerChoosesJump(); //*************************This determines whether the character is able to move to the next cover position for running******************** if (Input.GetKeyDown(Run) && InCover == false && !reloading && !ChooseJump && !isPaused) { if (CoverPosition == 0) { CanShoot = false; ChooseRun = true; // Player.transform.position = new Vector2(Player.transform.position.x, Player.transform.position.y - .7f); } else if (CoverPosition == 1) { ChooseRun = true; CanShoot = false; // Player.transform.position = new Vector2(Player.transform.position.x, Player.transform.position.y - .7f); } else if (CoverPosition <= 2) { ChooseRun = true; CanShoot = false; // Player.transform.position = new Vector2(Player.transform.position.x, Player.transform.position.y - .7f); } else if (CoverPosition <= 3) { CanShoot = false; ChooseRun = true; // Player.transform.position = new Vector2(Player.transform.position.x, Player.transform.position.y - .7f); } } if (Input.GetKeyDown(Jump) && InCover == false && !reloading && !ChooseRun && !isPaused) { if (CoverPosition == 0) { CanShoot = false; ChooseJump = true; } else if (CoverPosition == 1) { ChooseJump = true; CanShoot = false; } else if (CoverPosition <= 2) { ChooseJump = true; CanShoot = false; } else if (CoverPosition <= 3) { CanShoot = false; ChooseJump = true; } } //**********************This moves the player in and out of cover************************************** if (Input.GetKeyDown(Peak) && InCover == true && CanShoot && !isPaused) { // Player.transform.position = new Vector2(Player.transform.position.x, Player.transform.position.y + .7f); InCover = false; // Debug.Log("test1"); animationState = AnimationState.IDLE; } if (Input.GetKeyDown(Duck) && InCover == false && CanShoot && !isPaused) { // Player.transform.position = new Vector2(Player.transform.position.x, Player.transform.position.y - .7f); InCover = true; //animationState = AnimationState.Crouch; // Debug.Log("test"); } rlt1 = Time.fixedTime; if (Input.GetKeyDown(Reload) && InCover && !reloading && !isPaused && !BulletLoaded) { Debug.Log("reloading"); reloading = true; rlt2 = Time.fixedTime; } else if ((rlt1 - rlt2) >= ReloadTime && reloading && !BulletLoaded) { Debug.Log("reloading complete"); reloading = false; BulletLoaded = true; AudioManager.instance.PlaySFX(1); } }
public void Start(AnimationState state, int trackIndex) { #if !WINDOWS_STOREAPP Console.WriteLine(trackIndex + " " + state.GetCurrent(trackIndex) + ": start"); #endif }
private AnimationState Play(AnimationData anim) { currState = target[anim.name]; target.CrossFade(anim.name, 0.1f, PlayMode.StopAll); return(currState); }
public void Complete(AnimationState state, int trackIndex, int loopCount) { #if !WINDOWS_STOREAPP Console.WriteLine(trackIndex + " " + state.GetCurrent(trackIndex) + ": complete " + loopCount); #endif }
public void OnSit() { animState = AnimationState.Sitting; }
public void OnStand() { animState = AnimationState.Standing; }
public void Event(AnimationState state, int trackIndex, Event e) { #if !WINDOWS_STOREAPP Console.WriteLine(trackIndex + " " + state.GetCurrent(trackIndex) + ": event " + e); #endif }
private void RemoveCore(AnimatedWidget widget, uint duration, Easing easing, Blocking blocking, bool use_easing, bool use_blocking) { if (duration > 0) { widget.Duration = duration; } if (use_easing) { widget.Easing = easing; } if (use_blocking) { widget.Blocking = blocking; } if (widget.AnimationState == AnimationState.Coming) { widget.AnimationState = AnimationState.IntendingToGo; } else { if (widget.Easing == Easing.QuadraticIn) { widget.Easing = Easing.QuadraticOut; } else if (widget.Easing == Easing.QuadraticOut) { widget.Easing = Easing.QuadraticIn; } else if (widget.Easing == Easing.ExponentialIn) { widget.Easing = Easing.ExponentialOut; } else if (widget.Easing == Easing.ExponentialOut) { widget.Easing = Easing.ExponentialIn; } widget.AnimationState = AnimationState.Going; stage.Add(widget, widget.Duration); } duration = widget.Duration; easing = widget.Easing; active_count--; if (active_count == 0) { if (border_state == AnimationState.Coming) { border_bias = Percent; } else { border_easing = easing; border_bias = 1.0; } border_state = AnimationState.Going; border_stage.Reset((uint)(duration * border_bias)); } }
private void OnAnimationStateChanged(AnimationState state) { playShortcutButton.Checked = state == AnimationState.Playing || state == AnimationState.AnimationRecording; }
public void SetState(AnimationState animationState) { _animationState = animationState; }
public void fly() { animationState = ammunitionModel.GetAnimationState("flying"); animationState.Loop = true; animationState.Enabled = true; }
public static Skin UnshareSkin(this Skeleton skeleton, bool includeDefaultSkin, bool unshareAttachments, AnimationState state = null) { Skin newSkin = skeleton.GetClonedSkin("cloned skin", includeDefaultSkin, unshareAttachments, true); skeleton.SetSkin(newSkin); if (state != null) { skeleton.SetToSetupPose(); state.Apply(skeleton); } return(newSkin); }
public void update() { if (remainingTime <= 0.0f) { return; } if (remainingTime > 0.0f) { remainingTime -= GM.t.delta; if (remainingTime <= 0.0f) { if (msCurrent) { msCurrent.weight = 1.0f; } if (msPrev) { msPrev.enabled = false; msPrev = null; } if (msPrePrev) { msPrePrev.enabled = false; msPrePrev = null; } } else { var t = remainingTime; var _dt = t * t * totalTimePowerR; var preprevweight = 0.0f; if (msCurrent) { msCurrent.weight = 1.0f - _dt; } if (msPrePrev) { msPrePrev.weight -= GM.t.delta * totalTimePowerR; preprevweight = msPrePrev.weight; if (preprevweight <= 0.0f) { msPrePrev.enabled = false; msPrePrev = null; } } if (msPrev) { msPrev.weight = _dt - preprevweight; } } } }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(AnimationState obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public MotionUnit2D(AnimationState m, float time, float targ, bool isVec) : this(m, null, time, targ, isVec) { }
public void OnPulse() { if (!LastLoop.IsRunning) { LastLoop.Start(); } if (!LastFullEvaluation.IsRunning) { LastFullEvaluation.Start(); } if (!ZetaDia.IsInGame || !ZetaDia.Me.IsValid || ZetaDia.Me.IsDead || ZetaDia.IsLoadingWorld) { return; } AnimationState aState = ZetaDia.Me.CommonData.AnimationState; if (aState == AnimationState.Attacking || aState == AnimationState.Casting || aState == AnimationState.Channeling || aState == AnimationState.Dead || aState == AnimationState.TakingDamage) { return; } // FUGLY HACK // DB .302+ runs through the stashing routine like Flash Gordon... Can't use a soft hook like the Potion method... // TODO: Look into overloading the TownRun routine and appending stash checks on TownRuns... if (Zeta.Internals.UIElements.StashWindow.IsVisible) { // Stash Checks Diagnostic("UIElement Detected: StashWindow, Initiating Stash Checks..."); if (bCheckStash) { // Spam Prevention (Can not run more than once per 3 minutes) double _tempLastStashCheck = DateTime.Now.Subtract(_lastStashCheck).TotalSeconds; Diagnostic("Last potion was purchased " + _tempLastStashCheck + " seconds ago"); if (_tempLastStashCheck < 180) { Diagnostic("CheckPotions can not run again for another " + (180 - _tempLastStashCheck) + " seconds"); } else { BotMain.PauseWhile(CheckStash, 0, new TimeSpan?(TimeSpan.FromSeconds(30.0))); } } } // Spam Prevention (Can not run more than once per 3 Seconds) if (LastLoop.ElapsedMilliseconds > 3000) { LastLoop.Restart(); try { if (LastFullEvaluation.ElapsedMilliseconds > 300000) { LastFullEvaluation.Restart(); bNeedFullItemUpdate = true; } if (currentLevel != ZetaDia.Me.Level) { LastFullEvaluation.Restart(); bNeedFullItemUpdate = true; currentLevel = ZetaDia.Me.Level; } if (Zeta.Internals.UIElements.VendorWindow.IsVisible) { // Vendor Checks Diagnostic("UIElement Detected: VendorWindow, Initiating Potion Checks..."); if (bBuyPots) { // Spam Prevention (Can not run more than once per 1 minute) double _tempLastBuy = DateTime.Now.Subtract(_lastBuy).TotalSeconds; Diagnostic("Last potion was purchased " + _tempLastBuy + " seconds ago"); if (_tempLastBuy < 60) { Diagnostic("CheckPotions can not run again for another " + (60 - _tempLastBuy) + " seconds"); } else { BotMain.PauseWhile(CheckPotions, 0, new TimeSpan?(TimeSpan.FromSeconds(30.0))); } } } else if (Zeta.Internals.UIElements.StashWindow.IsVisible) { // Stash Checks // Moved outside of the spam prevention loop... So that it will check on every pulse.. } else { // Backpack Checks CheckBackpack(); } } catch (System.AccessViolationException ex) { // Maybe someday the DB core will stop throwing this error.... O_o throw; } catch (Exception ex) { Log("An exception occured: " + ex.ToString()); //throw; } } }