/// <summary> Returns a unit vector representing the chosen movement axis. </summary>
/// <param name="axis"></param>
/// <returns></returns>
public static Vector3 GetAxis(MovementAxis axis)
{
Vector3 res = Vector3.zero;
res[(int)axis] = 1;
return(res);
}
public void setActiveAxes(MovementAxis activeAxes)
{
clearSelection();
xAxisBox.Enabled = (activeAxes & MovementAxis.X) == MovementAxis.X;
yAxisBox.Enabled = (activeAxes & MovementAxis.Y) == MovementAxis.Y;
zAxisBox.Enabled = (activeAxes & MovementAxis.Z) == MovementAxis.Z;
}
public void setActivePlanes(MovementAxis axes, MovementPlane planes)
{
foreach (MovableObjectTools currentTools in movableObjects)
{
currentTools.setActiveAxes(axes);
currentTools.setActivePlanes(planes);
}
}
//---------------------------------------------------------------------------------------------------------------------------------------
// Monobehaviour
#region Monobehaviour
void Awake()
{
this.isInteractable = false;
this.actualMoveDirection = this.moveDirection;
this.SetMoveAxis(this.actualMoveDirection);
for (int i = 0; i < this.handles.Count; i++)
{
this.handles[i].ConnectTo(this);
}
}
public TurtleBot3JointInfo(JointType jointType, LinkType linkType, MovementType movementType, MovementAxis movementAxis, float minVal, float maxVal)
{
this.jointType = jointType;
// this.jointName = jointName;
this.linkType = linkType;
this.movementType = movementType;
this.movementAxis = movementAxis;
this.minVal = minVal;
this.maxVal = maxVal;
}
protected bool CanPlayAnimation(MovementAxis movementAxis)
{
if (((controller.slots.physicsObject.IsOnSurface() && !canMoveVertically) || (canMoveVertically && movementAxis == MovementAxis.Horizontal)) && controller.StateID() != id && controller.currentState.id != JumpState.idString && controller.currentState.id != LadderState.idString && controller.currentState.id != CrouchState.idString)
{
return(true);
}
else
{
return(false);
}
}
/// <summary> Retrieve the index (x, y or z) of the movementAxis. </summary>
/// <param name="axis"></param>
/// <returns></returns>
public static int AngleIndex(MovementAxis axis)
{
if (axis == MovementAxis.Y)
{
return(1);
}
if (axis == MovementAxis.Z)
{
return(2);
}
return(0);
}
/// <summary> Retrieve a Vector3 representation of this dial's rotation axis. </summary>
/// <param name="axis"></param>
/// <returns></returns>
public static Vector3 GetAxis(MovementAxis axis)
{
switch (axis)
{
case MovementAxis.X: return(new Vector3(1, 0, 0));
case MovementAxis.Y: return(new Vector3(0, 1, 0));
case MovementAxis.Z: return(new Vector3(0, 0, 1));
}
return(new Vector3(1, 0, 0));
}
/// <summary>
/// Sets parameter values based on enemy settings
/// </summary>
private void SetValues()
{
if (enemySettings.MovementDirection != MovementAxis.NaN) //if enemy has direction
{
isMoving = true;
movementAxis = enemySettings.MovementDirection;
moveSpeed = enemySettings.MoveSpeed;
moveDistance = enemySettings.MoveDistance;
if (movementAxis == MovementAxis.HORIZONTAL)
{
minPosition = transform.position.x - moveDistance;
maxPosition = transform.position.x + moveDistance;
}
else
{
minPosition = transform.position.z - moveDistance;
maxPosition = transform.position.z + moveDistance;
}
}
}
/// <summary> Set the moveDirection of this drawer. This method is cleaner than doing it via the public property </summary>
/// <param name="newAxis"></param>
public void SetMoveAxis(MovementAxis newAxis)
{
this.moveDirection = newAxis;
this.actualMoveDirection = newAxis;
this.moveAxis = (this.originalRot * this.MoveAxis()).normalized;
}
internal static Vector2 InternalCalculateOffset(ref Bounds viewBounds, ref Bounds contentBounds, MovementAxis moveDirection, MovementType movementType, ref Vector2 delta)
{
Vector2 offset = Vector2.zero;
if (movementType == MovementType.Unrestricted)
{
return(offset);
}
Vector2 min = contentBounds.min;
Vector2 max = contentBounds.max;
// min/max offset extracted to check if approximately 0 and avoid recalculating layout every frame (case 1010178)
if (moveDirection == MovementAxis.Horizontal)
{
min.x += delta.x;
max.x += delta.x;
float maxOffset = viewBounds.max.x - max.x;
float minOffset = viewBounds.min.x - min.x;
if (minOffset < -0.001f)
{
offset.x = minOffset;
}
else if (maxOffset > 0.001f)
{
offset.x = maxOffset;
}
}
else
{
min.y += delta.y;
max.y += delta.y;
float maxOffset = viewBounds.max.y - max.y;
float minOffset = viewBounds.min.y - min.y;
if (maxOffset > 0.001f)
{
offset.y = maxOffset;
}
else if (minOffset < -0.001f)
{
offset.y = minOffset;
}
}
return(offset);
}
protected void ApplyMovement(float _inputDirection, MovementAxis movementAxis)
{
bool isLockedForAttack = (controller.slots.physicsObject.IsOnSurface()) ? IsLockedForAttack(Attack.ActionType.GroundMoving) : IsLockedForAttack(Attack.ActionType.AirMoving);
bool isOverriddenByDash = controller.isDashing;
bool isRunning = false;
if (runSettings.canRun && controller.slots.input && controller.slots.input.isRunButtonDown)
{
if ((controller.slots.physicsObject.IsOnSurface() || runSettings.canInitiateInAir) || currentMoveType == MoveType.Running)
{
isRunning = true;
isSlowingDownFromRun = false;
if (runSettings.runAnimation && currentMoveType != MoveType.Running && Mathf.Abs(_inputDirection) != 0.0f && controller.slots.physicsObject.IsOnSurface() && controller.StateID() == idString)
{
PlaySecondaryAnimation(runSettings.runAnimation);
}
currentMoveType = MoveType.Running;
}
else
{
if (currentMoveType == MoveType.Running && Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) > movementProperties.speed)
{
isSlowingDownFromRun = true;
PlayAnimation();
}
currentMoveType = MoveType.Walking;
}
}
else
{
if (currentMoveType == MoveType.Running && Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) > movementProperties.speed)
{
isSlowingDownFromRun = true;
PlayAnimation();
}
currentMoveType = MoveType.Walking;
}
if (Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) <= movementProperties.speed)
{
isSlowingDownFromRun = false;
}
if (isOverriddenByDash || controller.isKnockbackActive || controller.isStunned || controller.StateID() == WallClingState.idString)
{
return;
}
bool isLockedIntoJump = (jumpState && !controller.slots.physicsObject.IsOnSurface() && jumpState.IsHorizontalMovementFrozen());
if (isLockedIntoJump)
{
ApplyHorizontalJump(jumpState);
return;
}
if (movementProperties == null)
{
return;
}
float baseSpeed = (isRunning) ? runProperties.speed : movementProperties.speed;
float baseAcceleration = (isRunning) ? runProperties.acceleration : movementProperties.acceleration;
float baseDeceleration = (isRunning || isSlowingDownFromRun) ? runProperties.deceleration : movementProperties.deceleration;
//If we're moving diagonally and willMaintainSpeedOnDiagonal is true, cut our speed in each direction in half to compensate
float diagonalMultiplier = 0.707f; //Moving in two directions at once is 1.4x faster than just one; therefore, we multiply speed in each direction by 0.707
bool isMovingDiagonally = (canMoveVertically && willMaintainSpeedOnDiagonal && Mathf.Abs(controller.axis.x) > 0.0f && Mathf.Abs(controller.axis.y) > 0.0f);
float speed = (isMovingDiagonally) ? baseSpeed * diagonalMultiplier : baseSpeed;
float acceleration = (isMovingDiagonally) ? baseAcceleration * diagonalMultiplier : baseAcceleration;
float deceleration = baseDeceleration;
if (controller.currentState.id == CrouchState.idString)
{
CrouchState crouchState = controller.GetComponent <CrouchState>();
if (crouchState)
{
if (crouchState.isSkidComplete && !crouchState.allowAccelerationOnMove)
{
acceleration = 0.0f;
deceleration = 0.0f;
}
if (crouchState.isSkidComplete)
{
speed = crouchState.moveSpeed;
}
}
}
if (_inputDirection != 0.0f && !controller.isKnockbackActive && !isLockedForAttack && !controller.IsOveriddenByCrouch() && !isSlowingDownFromRun)
{
if (movementAxis == MovementAxis.Horizontal) //Let the controller know that we turned around horizontally
{
Direction.Horizontal actorDirection = controller.direction.horizontal;
actorDirection = (_inputDirection > 0.0f) ? Direction.Horizontal.Right : Direction.Horizontal.Left;
controller.FaceDirection(actorDirection);
}
hasEnded = false; //We animate the sprite moving, but only if it's moving horizontally
if (CanPlayAnimation(movementAxis))
{
Begin();
}
if (controller.slots.actor.currentAttack != null && controller.slots.actor.currentAttack.canceledBy.onMove)
{
controller.slots.actor.currentAttack.Cancel();
}
if (acceleration != 0.0f) //Accelerate to the top speed
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.velocityCap.x = speed * _inputDirection;
controller.slots.physicsObject.properties.acceleration.x = acceleration * _inputDirection;
controller.slots.physicsObject.properties.deceleration.x = 0;
}
else
{
controller.slots.physicsObject.properties.velocityCap.y = speed * _inputDirection;
controller.slots.physicsObject.properties.acceleration.y = acceleration * _inputDirection;
controller.slots.physicsObject.properties.deceleration.y = 0;
}
}
else //Immediately go at top speed
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.velocityCap.x = speed * _inputDirection;
controller.slots.physicsObject.SetVelocityX(speed * _inputDirection);
controller.slots.physicsObject.properties.acceleration.x = 0.0f;
controller.slots.physicsObject.properties.deceleration.x = 0.0f;
}
else
{
controller.slots.physicsObject.properties.velocityCap.y = speed * _inputDirection;
controller.slots.physicsObject.SetVelocityY(speed * _inputDirection);
controller.slots.physicsObject.properties.acceleration.y = 0.0f;
controller.slots.physicsObject.properties.deceleration.y = 0.0f;
}
}
}
else //We can't move directly, but we can apply residual deceleration
{
if (deceleration != 0.0f) //Decelerate gradually to a stop
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.acceleration.x = 0.0f;
controller.slots.physicsObject.properties.deceleration.x = deceleration;
if (Mathf.Abs(controller.slots.physicsObject.properties.velocity.x) <= 0.0f && (controller.slots.physicsObject.IsOnSurface() || canMoveVertically))
{
if (!hasEnded)
{
if (!controller.isKnockbackActive && controller.StateID() != LadderState.idString)
{
controller.SetStateToDefault();
}
}
End();
}
}
else
{
controller.slots.physicsObject.properties.acceleration.y = 0.0f;
controller.slots.physicsObject.properties.deceleration.y = deceleration;
}
}
else //Stop immediately
{
if (movementAxis == MovementAxis.Horizontal)
{
controller.slots.physicsObject.properties.acceleration.x = 0.0f;
controller.slots.physicsObject.properties.deceleration.x = 0.0f;
controller.slots.physicsObject.SetVelocityX(0.0f);
if (!hasEnded)
{
if (!controller.isKnockbackActive && controller.StateID() != LadderState.idString && (controller.slots.physicsObject.IsOnSurface() || canMoveVertically) && controller.StateID() != CrouchState.idString)
{
//Default if:
//You are on the ground, AND !canMoveVertically
//Or, you are in the air
controller.SetStateToDefault();
}
}
//Debug.Log("Ending");
End();
}
else
{
controller.slots.physicsObject.properties.acceleration.y = 0.0f;
controller.slots.physicsObject.properties.deceleration.y = 0.0f;
controller.slots.physicsObject.SetVelocityY(0.0f);
}
}
}
}
// Update is called once per frame
void FixedUpdate()
{
Quaternion newRotation;
bool can_move = true;
float vAxis = Input.GetAxis("Vertical");
float hAxis = Input.GetAxis("Horizontal");
// de estar conectado el kinect vera el moviento y retornara lo que ha movido
// de no ser asi pasara los valores como estan
//comentar cuando se prueba sin kinect
if (sensor != null)
{
if (sensor.IsOpen != null && sensor.IsOpen)
{
MovementAxis movement_axis = moveWithKinect(hAxis, vAxis);
hAxis = (float)movement_axis.xAxis;
vAxis = (float)movement_axis.yAxis;
}
}
//movement = new Vector3 (hAxis, vAxis, 0)*speed;
movement = new Vector3(hAxis, vAxis, 0) * speed * Time.deltaTime;
if (rig.transform.position.x + movement.x > distanceMovementX || rig.transform.position.x + movement.x < -distanceMovementX)
{
hAxis = 0;
movement = new Vector3(hAxis, vAxis, 0) * speed;
}
if (rig.transform.position.y + movement.y > initialY || rig.transform.position.y + movement.y < 24)
{
vAxis = 0;
movement = new Vector3(hAxis, vAxis, 0) * speed;
}
//Debug.Log (movement);
//if (can_move) {
//rig.MovePosition (transform.position + movement);
rig.transform.position = transform.position + movement;
//}
//rig.AddForce ( movement);
//rig.velo
//esto es para controlar ña rotacion apenas se mueva el avion en cualquiera de las dos direcciones (X,y)
//if (hAxis == 0)
if (hAxis == 0 || vAxis == 0)
{
transform.Rotate(-vAxis * 0.5f, 0, -hAxis * 4);
}
if (useRestitution)
{
if (hAxis == 0 && vAxis == 0)
{
Vector3 startPos = transform.position;
Vector3 endPos = new Vector3(0, initialY, startPos.z);
transform.position = Vector3.Lerp(startPos, endPos, 0.05f);
}
}
newRotation = Quaternion.AngleAxis(0, Vector3.up);
transform.rotation = Quaternion.Slerp(transform.rotation, newRotation, .05f);
}
/// <summary> Project an absolute position onto the plane formed by the Hing Joint's normal. </summary>
/// <returns></returns>
public static Vector3 ProjectOnTranform2D(Vector3 absPos, Transform relativeTo, MovementAxis normal)
{
Vector3 res = ProjectOnTranform(absPos, relativeTo);
res[(int)normal] = 0;
return(res);
}
public void setActiveAxes(MovementAxis activeAxes)
{
moveTool.setActiveAxes(activeAxes);
}
