/// <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;
}
