public void RpcEndAttack()
{
Destroy(attack);
vis.CmdColorNose(false);
attack = null;
look = LookState.Free;
}
private void CheckLookState()
{
float xPos = transform.position.x;
float xPosPlayer = player.position.x;
xDistance = xPosPlayer - xPos;
if (socialState == SocialState.looking)
{
if (xDistance < -2f)
{
lookState = LookState.leftFar;
}
else if (xDistance < -0.7f && xDistance >= -2f)
{
lookState = LookState.leftNear;
}
else if (xDistance >= -0.7f && xDistance <= 0.7f)
{
lookState = LookState.middle;
}
else if (xDistance > 0.7f && xDistance <= 2f)
{
lookState = LookState.rightNear;
}
else if (xDistance > 2f)
{
lookState = LookState.rightFar;
}
}
}
void FixedUpdate()
{
if (LookAtSth == LookState.LookToPlayer)
{
if (player == null)
{
LookAtSth = LookState.LookToDefault;
}
else
{
// sth wrong: mod will be in continuous rotation
// Quaternion quaDir = Quaternion.LookRotation(player.transform.position-reference.position, Vector3.up);
// transform.rotation = Quaternion.Lerp (reference.rotation, quaDir, Time.fixedDeltaTime * 2f);
// if (Quaternion.Angle (reference.rotation, quaDir) < 1) {LookAtSth = LookState.Stand;}
transform.LookAt(player); // just instantly followed
if (Vector3.Distance(transform.position, player.position) > 2)
{
LookAtSth = LookState.LookToDefault;
}
}
}
else if (LookAtSth == LookState.LookToDefault)
{
Quaternion quaDir = Quaternion.LookRotation(defaultLook, Vector3.up);
transform.rotation = Quaternion.Lerp(reference.rotation, quaDir, Time.fixedDeltaTime * 2f);
if (Quaternion.Angle(reference.rotation, quaDir) < 1)
{
LookAtSth = LookState.Stand;
}
}
}
void FindPlayer(Player player)
{
_lookState = LookState.Player;
if (OnFindPlayer != null)
{
OnFindPlayer(player);
}
}
private void Aim()
{
if (CurrentTarget == null)
{
State = LookState.AquiringTarget;
return;
}
transform.rotation = TargetingUtilities.SmoothRotation(CurrentTarget.position, transform, rotateSpeed, error);
}
// Use this for initialization
void Start()
{
mainCamera.enabled = true;
zoomCamera.enabled = false;
mouseSensitivity = lookMouseSensitivity;
_lookState = LookState.FreeLook;
}
private void Initialize()
{
UpdateError();
State = LookState.Targetless;
RandomizeLookDirection();
wiggleIntervalTimer = new Timer("Wiggle Timer", wiggleInterval, true, RandomizeLookDirection);
wiggleDurationTimer = new Timer("Wiggle Duration", wiggleDuration, false, OnTrackDelayFinish);
trackingDurationTimer = new Timer("Tracking Duration", trackingDuration, false, OnTrackingFinished);
}
private void AquireTarget()
{
alltargets = TargetingUtilities.FindAllTargets(transform.position, detectionRadius, targetLayer);
CurrentTarget = TargetingUtilities.FindNearestTarget(transform.position, alltargets);
if (CurrentTarget != null)
{
State = LookState.Aiming;
}
}
// Use this for initialization
void Start()
{
rb = GetComponent <Rigidbody>();
col = GetComponent <CapsuleCollider>();
hp = GetComponent <Health>();
current = PState.Free;
look = LookState.Free;
vis = GetComponent <Visuals>();
buffholder = GetComponent <BuffableLoose>();
}
public void SetExamineTarget(Transform to, Transform from)
{
if (to == null)
{
_lookState = LookState.FreeLook;
return;
}
_lookState = LookState.Examining;
examiningSourcePosition = from.position;
examiningSourceRotation = from.rotation;
examiningTargetPosition = to.position;
examiningTargetRotation = to.rotation;
}
public void SetCenterTarget(Transform target, InteractableGroup group)
{
Debug.Log("setting");
if (_lookState == LookState.FreeLook)
{
_lookState = LookState.ZoomingIn;
centering = 1f;
centeringGroup = group;
centeringTargetPosition = target.position;
centeringTargetRotation = target.rotation;
centeringSourcePosition = transform.position;
centeringSourceRotation = transform.rotation;
}
}
private void Awake()
{ //estas lineas son medio conflictivas para mí
chaseState = new ChaseState(this);
alertState = new AlertState(this);
patrolState = new PatrolState(this);
atackState = new AtackState(this);
lookState = new LookState(this);
//obteniendo el componente de navmesh
navMeshAgent = GetComponent <NavMeshAgent> ();
animator = GetComponent <Animator> ();
controladorVision = GetComponent <ControladorVision> ();
controladorNavMesh = GetComponent <ControladorNavMesh> ();
controladorAnimator = GetComponent <ControladorAnimator> ();
hashIDs = GetComponent <HashIDs> ();
}
public void ChangeLookState(LookState state)
{
switch (state)
{
case LookState.LockedInvisible:
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
break;
case LookState.VisibleMoveable:
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
break;
}
}
public void ResetCenterTarget(Transform target)
{
Debug.Log("resetting");
if (_lookState == LookState.ZoomedIn)
{
_lookState = LookState.ZoomingOut;
centering = 1f;
if (centeringGroup != null)
{
centeringGroup.OnUnCentered();
}
centeringTargetPosition = centeringSourcePosition;
centeringTargetRotation = centeringSourceRotation;
centeringSourcePosition = target.position;
centeringSourceRotation = target.rotation;
}
}
private void OnTrackingFinished()
{
ModifyStats();
State = LookState.None;
}
private void OnTrackDelayFinish()
{
ModifyStats();
State = LookState.AquiringTarget;
}
private LookState NewLook()
{
look = new LookState(transform, lookDistance, "Player", LookCallback);
return(look);
}
void Update()
{
//Debug.Log(_lookState.ToString());
switch (_lookState)
{
case LookState.FreeLook:
Cursor.lockState = CursorLockMode.Locked;
playerYaw += Input.GetAxis("Mouse X") * lookMouseSensitivity * Mathf.Deg2Rad;
playerPitch += Input.GetAxis("Mouse Y") * lookMouseSensitivity * Mathf.Deg2Rad;
transform.rotation = Quaternion.identity;
transform.Rotate(new Vector3(-playerPitch, playerYaw, 0), Space.World);
transform.Rotate(new Vector3(0, 0, BoatTilt._tiltAngle), Space.World);
break;
case LookState.Examining:
Cursor.lockState = CursorLockMode.Locked;
zoomYaw += Input.GetAxis("Mouse X") * zoomMouseSensitivity * Mathf.Deg2Rad;
zoomPitch += Input.GetAxis("Mouse Y") * zoomMouseSensitivity * Mathf.Deg2Rad;
zoomPitch = Mathf.Clamp(zoomPitch, -90f, 90f);
zoomCamera.transform.rotation = examiningSourceRotation;
zoomCamera.transform.position = examiningSourcePosition;
zoomCamera.transform.RotateAround(examiningTargetPosition, zoomCamera.transform.up, zoomYaw);
zoomCamera.transform.RotateAround(examiningTargetPosition, zoomCamera.transform.right, -zoomPitch);
break;
case LookState.ZoomedIn:
Cursor.lockState = CursorLockMode.None;
break;
case LookState.ZoomingIn:
case LookState.ZoomingOut:
Cursor.lockState = CursorLockMode.Locked;
transform.position = (centeringSourcePosition * centering) + (centeringTargetPosition * (1f - centering));
transform.rotation = Quaternion.Lerp(centeringSourceRotation, centeringTargetRotation, (1f - centering));
if (centering > .02f)
{
centering -= .01f;
}
else
{
centering = 0f;
if (_lookState == LookState.ZoomingIn)
{
_lookState = LookState.ZoomedIn;
if (centeringGroup != null)
{
centeringGroup.OnCentered();
}
}
else if (_lookState == LookState.ZoomingOut)
{
_lookState = LookState.FreeLook;
}
}
break;
case LookState.Paused:
Cursor.lockState = CursorLockMode.None;
break;
}
if (Input.GetKeyDown(KeyCode.Escape))
{
if (_lookState == LookState.Paused)
{
_lookState = _storedLookState;
}
else
{
_storedLookState = _lookState;
_lookState = LookState.Paused;
}
}
playerPitch = Mathf.Clamp(playerPitch, -90f, 90f);
if (Input.GetMouseButtonDown(1))
{
mainCamera.enabled = true;
zoomCamera.enabled = false;
}
}
void Miss()
{
_lookState = LookState.None;
}
void FixedUpdate()
{
if (isServer)
{
buffholder.computeStats();
if (registerHit)
{
registerHit = false;
if (attack)
{
RpcEndAttack();
}
if (hp.change(-hitDamage))
{
Destroy(gameObject);
}
else
{
RpcTakeHit(hitDirection * hitMag);
}
}
if (abil1CD > 0)
{
abil1CD -= Time.fixedDeltaTime;
}
if (abil2CD > 0)
{
abil2CD -= Time.fixedDeltaTime;
}
}
if (hasAuthority)
{
buffholder.computeStats();
ghost.renderCD(abil1CD, abil2CD);
bool movement = true;
Vector3 move = new Vector3();
switch (current)
{
#region states
case PState.Free:
if (!grounded)
{
current = PState.Air;
movement = false;
}
if (inp.jump) //here
{
rb.AddForce(Vector3.up * jumpForce);
current = PState.Air;
}
break;
case PState.Air:
if (grounded)
{
current = PState.Free;
}
else
{
movement = false;
}
break;
case PState.KB:
if (planeVel.magnitude <= KBRegain)
{
current = PState.Free;
}
//print(planeVel);
movement = false;
planeVel = planeVel.normalized * (planeVel.magnitude - KBDeteriorate * Time.fixedDeltaTime * (grounded ? 1 : 0.4f));
break;
#endregion
}
if (movement)
{
#region movement
if (inp.up)
{
move += new Vector3(0, 0, 1);
}
if (inp.down)
{
move += new Vector3(0, 0, -1);
}
if (inp.left)
{
move += new Vector3(-1, 0, 0);
}
if (inp.right)
{
move += new Vector3(1, 0, 0);
}
move.Normalize();
//rb.AddForce(move * moveForce * Time.fixedDeltaTime);
//if(planeVel.magnitude >= maxSpeed)
//{
// planeVel = planeVel.normalized * maxSpeed;
//}
if (!sprinting)
{
#region sprintS
if (move != Vector3.zero)
{
if (lastMove == move)
{
sprintBuildCurrent += Time.fixedDeltaTime;
}
else
{
float diff = (move - lastMove).magnitude;
if (diff > 1)
{
diff = 1;
}
Mathf.Pow(diff, 3);
//print(diff);
sprintBuildCurrent -= sprintChangeLoss * diff;
if (sprintBuildCurrent < 0)
{
sprintBuildCurrent = 0;
}
}
}
lastMove = move;
if (sprintBuildCurrent > sprintBuild)
{
//print("sprinting");
setSprint(true);
}
else
{
vis.CmdSprintAlpha(sprintPer);
}
#endregion
}
planeVel = ghost.spawnMutate(move) * maxSpeed * ((sprintSpeed) + 1);
#endregion
}
Vector3 dif;
switch (look)
{
case LookState.Free:
dif = inp.target - transform.position;
dif.y = 0;
transform.rotation = Quaternion.LookRotation(dif);
break;
case LookState.Attacking:
if (current != PState.Air)
{
dif = inp.target - transform.position;
dif.y = 0;
transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.LookRotation(dif), attackTurn * Time.fixedDeltaTime);
}
break;
}
if (look == LookState.Free && inp.attacking)
{
if (buffholder.buf("FullSprint") < 1)
{
setSprint(false);
}
if (inp.atk1)
{
look = LookState.Attacking;
CmdAtk(attackType.basic, inp.groundTarget);
}
else if (inp.atk2)
{
look = LookState.Attacking;
CmdAtk(attackType.heavy, inp.groundTarget);
}
else if (inp.abil1 && abil1CD <= 0)
{
look = LookState.Attacking;
CmdAtk(attackType.abil1, inp.groundTarget);
}
else if (inp.abil2 && abil2CD <= 0)
{
look = LookState.Attacking;
CmdAtk(attackType.abil2, inp.groundTarget);
}
}
vis.CmdPropagate();
}
}
