/// <summary> /// Respond to an animation event. /// </summary> /// <param name='state'> /// State. /// </param> /// <param name='previousState'> /// Previous state. /// </param> public void CharacterAnimationEvent (CharacterState state, CharacterState previousState) { currentState = state; this.previousState = previousState; transform.localPosition = rootOffset; switch (state) { case CharacterState.IDLE: Idle(previousState); break; case CharacterState.WALKING: Walk(); break; case CharacterState.RUNNING: Run(); break; case CharacterState.SLIDING: Slide(); break; case CharacterState.JUMPING: Jump(); break; case CharacterState.AIRBORNE: Airborne(); break; case CharacterState.FALLING: Fall(); break; case CharacterState.DOUBLE_JUMPING: Jump(); break; case CharacterState.WALL_JUMPING: Jump(); break; case CharacterState.HOLDING: Hold(previousState); break; case CharacterState.CLIMBING: Climb(); break; case CharacterState.CLIMB_TOP_OF_LADDER_UP: ClimbTopUp(); break; case CharacterState.CLIMB_TOP_OF_LADDER_DOWN: ClimbTopDown(); break; case CharacterState.LEDGE_HANGING: LedgeHang(); break; case CharacterState.LEDGE_CLIMBING: LedgeClimb(); break; case CharacterState.LEDGE_CLIMB_FINISHED: Idle (previousState); break; case CharacterState.ROPE_CLIMBING: RopeClimb(); break; case CharacterState.ROPE_SWING: RopeSwing();break; case CharacterState.ROPE_HANGING: RopeHang();break; case CharacterState.WALL_SLIDING: WallSlide(); break; case CharacterState.CROUCHING: Crouch(); break; case CharacterState.CROUCH_SLIDING: CrouchSlide(); break; case CharacterState.STUNNED: Stunned(previousState); break; case CharacterState.PUSHING: Push(); break; case CharacterState.PULLING: Pull(); break; } }
private CharacterState serverLastState; //SERVER: Store last state #endregion Fields #region Methods /// <summary> /// All Clients: Deserialize the state from network /// </summary> /// <param name="reader"></param> /// <param name="initialState"></param> public override void OnDeserialize(NetworkReader reader, bool initialState) { CharacterState state = new CharacterState(); state.state = reader.ReadInt32(); state.position = reader.ReadVector3(); state.rotation = reader.ReadQuaternion(); //Client: Received a new state for the local player, treat it as an ACK and do reconciliation if (isLocalPlayer) { SendMessage("ServerState", state, SendMessageOptions.DontRequireReceiver); } else { //Other Clients: Received a state, treat it like a new position snapshot from authority if (initialState) { //Others Clients: First state, just snap to new position transform.position = state.position; transform.rotation = state.rotation; } else if (networkInterpolation != null) { //Others Clients: Interpolate between received positions networkInterpolation.ReceiveState(state); } } }
//protected BaseCharacter _baseCharacter; //virtual public void Awake() //{ // _baseCharacter = gameObject.GetComponent<BaseCharacter>(); //} public virtual void ChangeAnimation(CharacterState state) { switch (state) { case CharacterState.IDLE: m_skeletonAnimation.state.SetAnimation(0, idleAnimName, true); break; case CharacterState.RUN: m_skeletonAnimation.state.SetAnimation(0, runAnimName, true); break; case CharacterState.UP: m_skeletonAnimation.state.SetAnimation(0, upAnimName, false); break; case CharacterState.DOWN: m_skeletonAnimation.state.SetAnimation(0, downAnimName, false); break; case CharacterState.LAND: m_skeletonAnimation.state.SetAnimation(0, landAnimName, false); break; case CharacterState.BEGIN: m_skeletonAnimation.state.SetAnimation(0, beginAnimName, false); break; default: Debug.LogError("sprite state is not correct! " + state); break; } }
public CharacterActionSet(string n, CharacterState s, CharacterActionSetChangeFactor f, object o) { animname = n; state = s; switch (f) { case CharacterActionSetChangeFactor.AnimationCompleted: break; case CharacterActionSetChangeFactor.ArriveTarget: target = (Vector2)o; break; case CharacterActionSetChangeFactor.Time: duration = (double)o; break; case CharacterActionSetChangeFactor.ArriveAttackTarget: interactive = (Character)o; break; case CharacterActionSetChangeFactor.ArriveInteractiveTarget: interactive = (Character)o; break; case CharacterActionSetChangeFactor.EffectCompleted: effectname = (string)o; break; } factor = f; }
public FollowAction(GameObject actor, GameObject targetCharacter, float maximumDistance, float minimumDistance, Reason reason, bool canStartDialogueWithAgents) : base(actor) { InitInteractionInfo(true, canStartDialogueWithAgents); this.targetCharacter = targetCharacter; this.targetCharacterState = (CharacterState)targetCharacter.GetComponent("CharacterState"); this.maximumDistance = maximumDistance; this.minimumDistance = minimumDistance; this.reason = reason; switch(reason) { case Reason.SEX: targetCharacterState.SetTask(CharacterState.Task.SEX, actor); TaskHelp.ShowHelp(TaskHelp.SEX, actor); break; case Reason.DANCE: targetCharacterState.SetTask(CharacterState.Task.DANCE, actor); TaskHelp.ShowHelp(TaskHelp.DANCE, null); break; case Reason.POKER_WITHOUT_MONEY: targetCharacterState.SetTask(CharacterState.Task.POKER, actor); TaskHelp.ShowHelp(TaskHelp.POKER, null); break; case Reason.POKER_WITH_MONEY: targetCharacterState.SetTask(CharacterState.Task.POKER, actor); TaskHelp.ShowHelp(TaskHelp.POKER, null); break; case Reason.DRINK: targetCharacterState.SetTask(CharacterState.Task.DRINK, actor); TaskHelp.ShowHelp(TaskHelp.DRINK, actor); break; } ending = false; }
public void Aim() { if (snowBallInstanceScript != null) { snowBallInstanceScript.Aim (); } state = CharacterState.IS_AIMING; }
public void SetSpeed(float speed) { this.speed = speed; if(!crouch) { if(speed > minimumRunSpeed) { //SendMessage("SetWalk", false, SendMessageOptions.DontRequireReceiver); _characterState = CharacterState.Running; } else if(speed > minimumWalkSpeed) { //SendMessage("SetWalk", true, SendMessageOptions.DontRequireReceiver); _characterState = CharacterState.Walking; } else { //SendMessage("SetIdle", true, SendMessageOptions.DontRequireReceiver); _characterState = CharacterState.Idle; } } else { if(speed > minimumRunSpeed) { //SendMessage("SetCrouch", true, SendMessageOptions.DontRequireReceiver); //SendMessage("SetWalk", false, SendMessageOptions.DontRequireReceiver); _characterState = CharacterState.Walking_crouch; } else if(speed > minimumWalkSpeed) { //SendMessage("SetCrouch", true, SendMessageOptions.DontRequireReceiver); //SendMessage("SetWalk", true, SendMessageOptions.DontRequireReceiver); _characterState = CharacterState.Walking_crouch; } else { //SendMessage("SetCrouch", true, SendMessageOptions.DontRequireReceiver); //SendMessage("SetIdle", true, SendMessageOptions.DontRequireReceiver); _characterState = CharacterState.Idle_crouch; } } }
public override void OnUpdate(CharacterState owner) { #if UNITY_EDITOR || UNITY_STANDALONE owner.transform.position += owner.transform.forward * Time.deltaTime * speed; #else //Server AI Logic accumTime += Time.deltaTime; if (accumTime > updateAccumTime) { if (owner.GetType() == typeof(MonsterCharacter)) { MonsterCharacter monster = (MonsterCharacter)owner; monster.SetStateIdle(); } //Console.WriteLine("AIStateWalk.OnUpdate"); accumTime = 0.0f; } else { //owner.PosZ += speed * Time.deltaTime; //Vector3.Forward of XnaGeometry is -Z //so you should multiply -1 for serverside code owner.transform.position += owner.transform.forward * Time.deltaTime * speed; } #endif }
void Awake() { coords = new int[2]; lastCoords = new int[2]; canSee = new List<Player> (); m_AttackAxisInUse = false; tr = transform; CombatMode = false; pos = transform.position; currentPath = new List<Vector2> (); controller = GetComponent<PlayerController>(); workingAI = new AIBase (this); lastInput = Vector3.one; playerStats = new PlayerStats (); currentState = CharacterState.Still; controller.SetSpeed (playerStats.GetSpeed()); isStuck = 0; canAttack = "Enemy"; coolDownLimit = playerStats.GetAttackCooldown(); currentAttackCoolDown = 0; inventory = GetComponent<InventoryBase>(); weaponController = GetComponentInChildren<WeaponController> (); anim = GetComponent<Animator>(); spriteRen = GetComponent<SpriteRenderer> (); //seeker = GetComponent<Seeker> (); }
// Camera myCam = GameObject.Find("_cameraMain"); // Use this for initialization void Awake() { animation = GetComponent<Animation> (); contr = GetComponent<PlayerController>(); _state = CharacterState.Idle; // myCamera = GameObject.Find ("_cameraMain").camera; }
// Use this for initialization void Awake() { CS = CharacterState.Idle; tr = GetComponent<Transform> (); ani = GameObject.Find ("Character1").GetComponent<Animation> (); GetComponent<Rigidbody> ().WakeUp (); }
public virtual void Awake() { _character = GetComponent<CharacterState>(); _sprite = GetComponent<Sprite>(); _transform = this.transform; _collisionHandler = GetComponent<AbstractCollisionHandler>(); }
public virtual void AddState(CharacterState state) { bool changed = (this._state & state) != state; if (changed) { this._state |= state; switch (state) { case CharacterState.OnGround: this.RemoveState(CharacterState.OnJump); break; case CharacterState.OnJump: this.RemoveState(CharacterState.OnGround); this.RemoveState(CharacterState.OnWall); break; case CharacterState.Initialized: case CharacterState.OnWall: case CharacterState.Shooting: case CharacterState.Damage: default: break; } this.OnStateChange(state, true); } }
public void SetCharacterStateUI(CharacterState characterState){ switch(characterState){ case CharacterState.FULL: spriteRenderer.sprite = _characterSprite[3]; emotionRenderer.sprite = _emotionSprite[3]; SetEmotionScaleRate(0.005f); _hungerLevelBar.mainTexture = _hungerBar[(int)HungerBarState.HUNGER_BAR_100]; break; case CharacterState.SATISFIED: spriteRenderer.sprite = _characterSprite[2]; emotionRenderer.sprite = _emotionSprite[2]; SetEmotionScaleRate(0.006f); _hungerLevelBar.mainTexture = _hungerBar[(int)HungerBarState.HUNGER_BAR_60]; break; case CharacterState.HUNGRY: spriteRenderer.sprite = _characterSprite[1]; emotionRenderer.sprite = _emotionSprite[1]; SetEmotionScaleRate(0.008f); _hungerLevelBar.mainTexture = _hungerBar[(int)HungerBarState.HUNGER_BAR_30]; break; case CharacterState.DYING: spriteRenderer.sprite = _characterSprite[0]; emotionRenderer.sprite = _emotionSprite[0]; SetEmotionScaleRate(0.012f); _hungerLevelBar.mainTexture = _hungerBar[(int)HungerBarState.HUNGER_BAR_0]; break; default: break; } }
public void AddState(CharacterState state) { if (dictionary.ContainsKey(state.Name) || dictionary.ContainsValue(state)) return; list.Add(state); dictionary.Add(state.Name, state); }
public override void OnEnter(CharacterState owner) { base.OnEnter(owner); UnityEngine.Debug.Log("StateAttack.OnEnter"); }
protected void FixedUpdate() { this.forcesVec = Vector3.zero; this.moveVec = Vector3.zero; forcesVec += this.Gravity(); forcesVec += this.Forces(); Vector3 scale = transform.localScale; this.transform.localScale = scale; if (this.state != CharacterState.Attacking && this.state != CharacterState.Stunned && this.state != CharacterState.Dying) { var flags = controller.Move(forcesVec * Time.fixedDeltaTime); grounded = (flags & CollisionFlags.CollidedBelow) != 0; if (this.moveVec.z == 0 && forcesVec.z == 0 && this.moveVec.x == 0 && forcesVec.x == 0) { this.state = CharacterState.Standing; } else { this.state = CharacterState.Moving; } } else if (this.state == CharacterState.Stunned) { this.stunned = true; StartCoroutine(this.WaitForStun()); } }
public AbstractAction(GameObject actor) { this.actor = actor; state = actor.GetComponent(typeof(CharacterState)) as CharacterState; animator = actor.GetComponent(typeof(CharacterAnimator)) as CharacterAnimator; mover = actor.GetComponent(typeof(CharacterMover)) as CharacterMover; actionRunner = actor.GetComponent(typeof(ActionRunner)) as ActionRunner; animationName = null; wrapMode = WrapMode.Once; emotionBodyParts = Emotion.BodyParts.NONE; canStartDialogueWithPC = true; canStartDialogueWithAgents = true; canEndAnyTime = true; //canCancelDuringMovement = true; quickReaction = null; moveToAction = null; started = false; endedASAP = false; endNextRound = false; finished = false; }
public static void SendToAllClient_MonsterState(CharacterState character, State state) { Packet.GCAckMonsterState packet = new Packet.GCAckMonsterState(); packet.uniqueID = ((MonsterCharacter)character).UniqueID; packet.typeID = 1;// packet.state = state.ID; packet.posX = character.transform.position.X.ToString(); packet.posY = character.transform.position.Y.ToString(); packet.posZ = character.transform.position.Z.ToString(); packet.dirX = character.transform.forward.X.ToString(); packet.dirY = character.transform.forward.Y.ToString(); packet.dirZ = character.transform.forward.Z.ToString(); string jsonPacket = JsonMapper.ToJson(packet); try { lock (GameServer.Program.ms_ClientList) { foreach (GameServer.UserObject obj in GameServer.Program.ms_ClientList) { obj.Send(jsonPacket); } } } catch(Exception ex) { Console.WriteLine(ex); } }
protected void Start() { moveVec = Vector3.zero; this.controller = (CharacterController)GetComponent(typeof(CharacterController)); this.state = CharacterState.Standing; this.health = this.GetComponent<Health>(); }
protected override void Start() { base.Start(); m_curState = CharacterState.IDLING; m_navAgent = GetComponent<NavMeshAgent>(); m_moveTargetPos = Vector3.zero; m_height = transform.position.y; }
public override void Awake() { base.Awake(); _character = GetComponent<CharacterState>(); _transform = this.transform; _colliderBoundsOffsetX = this.collider.bounds.extents.x; _colliderBoundsOffsetY = this.collider.bounds.extents.y; }
public override void OnEnter(CharacterState owner) { base.OnEnter(owner); //type your own code. UnityEngine.Debug.Log("StateIdle.OnEnter"); }
// Use this for initialization void Start () { Debug.Log ("NAME" + GameConfig.instance.name); state = CharacterState.Start; Debug.Log ("STATE" + state); capsuleCollider = gameObject.GetComponent<CapsuleCollider> (); animator = gameObject.GetComponent<Animator> (); }
// End a jump and transition to a falling state (ignore if already grounded) void Fall() { if (controller.Grounded) { return; } state = CharacterState.Falling; }
public void LeftPunch(string punchName) { if (!IsBusy()) { currentState = CharacterState.LeftPunch; anim.SetTrigger(punchName); } }
public Character() { this.isDead = false; this.currentState = CharacterState.IDLE; this.lastState = currentState; this.childObjects = new List<GameObject>(); health = healthMaximum; }
public void OnNormalAlphaStart() { if(!IsBusy()) { currentState = CharacterState.MoveA; anim.SetTrigger("OnMoveA"); } }
void SetCharacterDeath(bool isEaten){ if(!IsCharacterDead()){ _nutritionAmount = 0; _characterState = CharacterState.DEAD; _characterUI.HideCharacterUI(isEaten); VoteManager.Instance.ReduceMinVoteCount(); UIManager.Instance.HideDrumPosition(_characterIndex); } }
public virtual void RemoveState(CharacterState state) { bool changed = (this._state & state) == state; if (changed) { this._state &= ~state; this.OnStateChange(state, false); } }
public override void OnStateEnter(CharacterState previousState) { MeatShopManager.Instance.CustomersWalkingToShop.Add(this); }
public override void OnExit(CharacterState characterState, Animator animator, AnimatorStateInfo stateInfo) { animator.SetInteger("transitionIndex", 0); }
public ProjectileAnimation(Texture2D texture, int X, int Y, int Width, int Height, int Frames, int columns, float frameLength, CharacterState characterState, int timeLength, Direction direction) : base(texture, X, Y, Width, Height, Frames, columns, frameLength, characterState) { TimerLength = timeLength; PlayOnce = false; }
public override void OnExit(CharacterState characterState, Animator animator, AnimatorStateInfo stateInfo) { animator.SetBool(AI_Walk_Transition.start_walking.ToString(), false); }
bool WallRun(Vector3 movement, CharacterState state) { if (!canWallRun && photonView.isMine) { return(false); } //if (isGrounded) return false; if (lastTimeOnWall + 1.0f > Time.time) { return(false); } if (_rb.velocity.sqrMagnitude < 0.2f) { if (characterState == CharacterState.WallRunning) { characterState = CharacterState.Jumping; lastTimeOnWall = Time.time; } return(false); } //Debug.Log (movement); RaycastHit leftH, rightH, frontH; bool leftW = Physics.Raycast(myTransform.position, myTransform.right * -1, out leftH, capsule.radius + 0.2f, wallRunLayers); bool rightW = Physics.Raycast(myTransform.position, myTransform.right, out rightH, capsule.radius + 0.2f, wallRunLayers); bool frontW = Physics.Raycast(myTransform.position, myTransform.forward, out frontH, capsule.radius + 0.2f, wallRunLayers); /*Debug.DrawRay (myTransform.position , * myTransform.right * -1 ); * * Debug.DrawRay (myTransform.position, * myTransform.right ); * * Debug.DrawRay (myTransform.position, * myTransform.forward);*/ Vector3 tangVect = Vector3.zero; if (!animator.animator.IsInTransition(0) && !_rb.isKinematic) { if (leftW) { tangVect = Vector3.Cross(leftH.normal, Vector3.up); //tangVect = Vector3.Project(movement,tangVect).normalized; _rb.velocity = tangVect * wallRunSpeed + myTransform.up * wallRunSpeed / 3; if (!(characterState == CharacterState.WallRunning)) { wallState = WallState.WallL; characterState = CharacterState.WallRunning; //animator.SetBool("WallRunL", true); StartCoroutine(WallRunCoolDown(3f)); // Exclude if not needed } if (state == CharacterState.Jumping) { _rb.velocity = myTransform.up * movement.y + leftH.normal * movement.y; StartCoroutine(WallJump(1f)); // Exclude if not needed } } else if (rightW) { tangVect = -Vector3.Cross(rightH.normal, Vector3.up); //tangVect = Vector3.Project(movement,tangVect).normalized; _rb.velocity = tangVect * wallRunSpeed + myTransform.up * wallRunSpeed / 3; if (!(characterState == CharacterState.WallRunning)) { wallState = WallState.WallR; characterState = CharacterState.WallRunning; StartCoroutine(WallRunCoolDown(3f)); // Exclude if not needed } if (state == CharacterState.Jumping) { _rb.velocity = myTransform.up * movement.y + rightH.normal * movement.y; StartCoroutine(WallJump(1f)); // Exclude if not needed } } else if (frontW) { _rb.velocity = myTransform.up * wallRunSpeed / 1.5f; tangVect = frontH.normal * -1; if (!(characterState == CharacterState.WallRunning)) { wallState = WallState.WallF; characterState = CharacterState.WallRunning; StartCoroutine(WallRunCoolDown(3f)); // Exclude if not needed } if (state == CharacterState.Jumping) { _rb.velocity = (myTransform.up + myTransform.forward * -1).normalized * movement.y; StartCoroutine(WallJump(1f)); // Exclude if not needed } } else { if (characterState == CharacterState.WallRunning) { characterState = CharacterState.Jumping; lastTimeOnWall = Time.time; } } forwardRotation = tangVect * 5; //Debug.DrawLine(myTransform.position,forwardRotation); //animator.WallAnimation(leftW,rightW,frontW); return(leftW || rightW || frontW); } return(false); }
void Start() { healthBar = GetComponent <Image>(); characterState = transform.parent.parent.gameObject.GetComponent <CharacterState>(); }
void SetAnimatorState(Animator animator, CharacterState state) { animator.SetInteger("state", (int)state); }
public void updateCharacterState(int playerNum, CharacterState characterState) { }
public override void OnLeave(CharacterState owner) { }
public override void OnExit(CharacterState characterState, Animator animator, AnimatorStateInfo stateInfo) { animator.SetInteger(TransitionParameter.TransitionIndex.ToString(), 0); }
public CharacterAction(CharacterAction targetCharacterAction) { _action = targetCharacterAction.Action; _priority = targetCharacterAction.Priority; _finishtime = new Gametime(targetCharacterAction.FinishTime); }
public CharacterAction(CharacterState actionValue, int priorityValue, Gametime finishTimeValue) { _action = actionValue; _priority = priorityValue; _finishtime = new Gametime(finishTimeValue); }
void ApplyInput(CharacterInput input) { predictedState = CharacterState.Move(predictedState, input, character.Speed, 0); }
public Character(GameObject obj, string name) { gameObject = obj; gameObject.name = name; state = CharacterState.OnCoastR; }
public override void Excute(CharacterState cs, float mCurValue) { base.Excute(cs, mCurValue); cs.RecieveMagicDamage = false; }
public Character(Model model, PlayScene parent) { this.parent = parent; skinnedModel = new CSkinnedModel(model); State = CharacterState.None; }
public override void UpdateAbility(CharacterState characterState, Animator animator, AnimatorStateInfo stateInfo) { }
public void Stand() { State = CharacterState.Stand; skinnedModel.SwitchClip(CharacterClip.Stand); timeline = PlayScene.Random.Next(120, 360); }
///<summary> /// Changing character state by detecting what kind of layer it touches ///</summary> protected virtual void ChangeState(CharacterState charState) { return; }
public override void OnExit(CharacterState characterState, Animator animator, AnimatorStateInfo stateInfo) { }
public void SendCharacterState(int nextrpcState, int nextwallState) { wallState = (WallState)nextwallState; nextState = (CharacterState)nextrpcState; }
public override void OnStateExit(CharacterState nextState) { }
private void Spawn(ProjectileInfo info, Vector3 position, Vector3 direction, string target, CharacterState own) { if (count == capacity) { return; } const float angle = 15f; Quaternion rot = Quaternion.identity; for (int i = 0; i < info.spreadAmount; i++) { if (count == capacity) { break; } projectiles[count].position = position; projectiles[count].direction = rot * direction; projectiles[count].distance = 0f; projectiles[count].info = info; projectiles[count].target = target; projectiles[count].own = own; count++; rot = Quaternion.AngleAxis(Random.Range(-angle, angle), Vector3.up) * Quaternion.AngleAxis(Random.Range(-angle, angle), Vector3.right) * Quaternion.AngleAxis(Random.Range(-angle, angle), Vector3.forward); } }
public override void OnStateExit(CharacterState nextState) { base.OnStateExit(nextState); MeatShopManager.Instance.CustomersWalkingToShop.Remove(this); }
void UpdateSmoothedMovementDirection() { Transform cameraTransform = Camera.main.transform; bool grounded = IsGrounded(); // Forward vector relative to the camera along the x-z plane Vector3 forward = cameraTransform.TransformDirection(Vector3.forward); forward.y = 0; forward = forward.normalized; // Right vector relative to the camera // Always orthogonal to the forward vector Vector3 right = new Vector3(forward.z, 0, -forward.x); float v = Input.GetAxisRaw("Vertical"); float h = Input.GetAxisRaw("Horizontal"); // Are we moving backwards or looking backwards if (v < -0.2f) { movingBack = true; } else { movingBack = false; } bool wasMoving = isMoving; isMoving = Mathf.Abs(h) > 0.1f || Mathf.Abs(v) > 0.1f; // Target direction relative to the camera Vector3 targetDirection = h * right + v * forward; // Grounded controls if (grounded) { // Lock camera for short period when transitioning moving & standing still lockCameraTimer += Time.deltaTime; if (isMoving != wasMoving) { lockCameraTimer = 0.0f; } // We store speed and direction seperately, // so that when the character stands still we still have a valid forward direction // moveDirection is always normalized, and we only update it if there is user input. if (targetDirection != Vector3.zero) { // If we are really slow, just snap to the target direction if (moveSpeed < walkSpeed * 0.9f && grounded) { PhotonView phView = GetComponent <PhotonView>(); Debug.Log("Moving..." + phView.viewID); moveDirection = targetDirection.normalized; } // Otherwise smoothly turn towards it else { moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000); moveDirection = moveDirection.normalized; } } // Smooth the speed based on the current target direction float curSmooth = speedSmoothing * Time.deltaTime; // Choose target speed //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways float targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0f); _characterState = CharacterState.Idle; // Pick speed modifier if (Input.GetKey(KeyCode.LeftShift) | Input.GetKey(KeyCode.RightShift)) { targetSpeed *= runSpeed; _characterState = CharacterState.Running; } else if (Time.time - trotAfterSeconds > walkTimeStart) { targetSpeed *= trotSpeed; _characterState = CharacterState.Trotting; } else { targetSpeed *= walkSpeed; _characterState = CharacterState.Walking; } moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth); // Reset walk time start when we slow down if (moveSpeed < walkSpeed * 0.3f) { walkTimeStart = Time.time; } } // In air controls else { // Lock camera while in air if (jumping) { lockCameraTimer = 0.0f; } if (isMoving) { inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration; } } }
void OnJump() // Start a jump { canLand = false; state = CharacterState.Jumping; }
private void Start() { state = GetComponent <CharacterState>(); state.OnChangeHealth += OnChangeHealth; }
void Update() { if (isControllable) { if (Input.GetButtonDown("Jump")) { lastJumpButtonTime = Time.time; } UpdateSmoothedMovementDirection(); // Apply gravity // - extra power jump modifies gravity // - controlledDescent mode modifies gravity ApplyGravity(); // Apply jumping logic ApplyJumping(); // Calculate actual motion Vector3 movement = moveDirection * moveSpeed + new Vector3(0, verticalSpeed, 0) + inAirVelocity; movement *= Time.deltaTime; // Move the controller CharacterController controller = GetComponent <CharacterController>(); collisionFlags = controller.Move(movement); } velocity = (transform.position - lastPos) * 25; // ANIMATION sector if (_animation) { if (_characterState == CharacterState.Jumping) { PhotonView phView = GetComponent <PhotonView>(); Debug.Log("Jumping!..." + phView.viewID); if (!jumpingReachedApex) { _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed; _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever; _animation.CrossFade(jumpPoseAnimation.name); } else { _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed; _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever; _animation.CrossFade(jumpPoseAnimation.name); } } else { if (this.isControllable && velocity.sqrMagnitude < 0.001f) { _characterState = CharacterState.Idle; _animation.CrossFade(idleAnimation.name); } else { if (_characterState == CharacterState.Idle) { _animation.CrossFade(idleAnimation.name); } else if (_characterState == CharacterState.Running) { _animation[runAnimation.name].speed = runMaxAnimationSpeed; if (this.isControllable) { _animation[runAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, runMaxAnimationSpeed); } _animation.CrossFade(runAnimation.name); } else if (_characterState == CharacterState.Trotting) { _animation[walkAnimation.name].speed = trotMaxAnimationSpeed; if (this.isControllable) { _animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, trotMaxAnimationSpeed); } _animation.CrossFade(walkAnimation.name); } else if (_characterState == CharacterState.Walking) { _animation[walkAnimation.name].speed = walkMaxAnimationSpeed; if (this.isControllable) { _animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, walkMaxAnimationSpeed); } _animation.CrossFade(walkAnimation.name); } } } } // ANIMATION sector // Set rotation to the move direction if (IsGrounded()) { transform.rotation = Quaternion.LookRotation(moveDirection); } else { /* This causes choppy behaviour when colliding with SIDES * Vector3 xzMove = velocity; * xzMove.y = 0; * if (xzMove.sqrMagnitude > 0.001f) * { * transform.rotation = Quaternion.LookRotation(xzMove); * }*/ } // We are in jump mode but just became grounded if (IsGrounded()) { lastGroundedTime = Time.time; inAirVelocity = Vector3.zero; if (jumping) { jumping = false; SendMessage("DidLand", SendMessageOptions.DontRequireReceiver); } } lastPos = transform.position; }
public CharacterAction() { _action = CharacterState.Undefined; _priority = -1; _finishtime = new Gametime(); }
public void SetCharacterState(CharacterState stateToSet) { _state = stateToSet; }