protected override void OnUpdate()
{
const float FallMultiplier = 0.0036f;
const float Bounce = -0.2f;
base.OnUpdate();
if (fall == FallDirection.Right)
{
if (angleVel > 0 && IsPositionBlocked())
{
if (bouncesLeft > 0)
{
if (bouncesLeft == BouncesMax)
{
angleVelLast = angleVel;
}
bouncesLeft--;
angleVel = Bounce * bouncesLeft * angleVelLast;
}
else
{
fall = FallDirection.Fallen;
}
}
else
{
angleVel += FallMultiplier * Time.TimeMult;
Transform.Angle += angleVel * Time.TimeMult;
}
}
else if (fall == FallDirection.Left)
{
if (angleVel < 0 && IsPositionBlocked())
{
if (bouncesLeft > 0)
{
if (bouncesLeft == BouncesMax)
{
angleVelLast = angleVel;
}
bouncesLeft--;
angleVel = Bounce * bouncesLeft * angleVelLast;
}
else
{
fall = FallDirection.Fallen;
}
}
else
{
angleVel -= FallMultiplier * Time.TimeMult;
Transform.Angle += angleVel * Time.TimeMult;
}
}
}
void UpdateFallDirection()
{
// Fall direction
if (!isFalling)
{
m_FallDirection = FallDirection.None;
}
else if (Mathf.Abs(m_Rigidbody.velocity.y) < 6f)
{
m_FallDirection = FallDirection.Side;
}
else if (m_Rigidbody.velocity.y > 0)
{
m_FallDirection = FallDirection.Up;
}
else
{
m_FallDirection = FallDirection.Down;
}
if (m_FallDirection != m_FallDirectionPrev)
{
if (m_FallDirection == FallDirection.None)
{
if (OnFall != null)
{
OnFall(0);
}
}
else if (m_FallDirection == FallDirection.Side)
{
if (OnFall != null)
{
OnFall(3);
}
}
else if (m_FallDirection == FallDirection.Up)
{
if (OnFall != null)
{
OnFall(1);
}
}
else if (m_FallDirection == FallDirection.Down)
{
if (OnFall != null)
{
OnFall(2);
}
}
}
m_FallDirectionPrev = m_FallDirection;
}
private void Fall(FallDirection dir)
{
if (fall != FallDirection.None)
{
return;
}
fall = dir;
isInvulnerable = true;
CollisionFlags |= CollisionFlags.IsSolidObject;
}
public override void OnHandleCollision(ActorBase other)
{
//base.HandleCollision(other);
AmmoBase ammo = other as AmmoBase;
if (ammo != null)
{
if (fall == FallDirection.None)
{
fall = (ammo.Speed.X < 0 ? FallDirection.Left : FallDirection.Right);
}
ammo.DecreaseHealth(1, this);
}
}
public void UpdateGravity(FallDirection _direction)
{
if (gravity.FallDirection == _direction)
{
return;
}
gravity.PreviousFallDirection = gravity.FallDirection;
gravity.FallDirection = _direction;
playerMovement.isGrounded = false;
rigbod.constraints = RigidbodyConstraints.None;
switch (gravity.FallDirection)
{
case FallDirection.XPos:
gravity.GravityDirection = Vector3.right;
break;
case FallDirection.XNeg:
gravity.GravityDirection = Vector3.left;
break;
case FallDirection.YPos:
gravity.GravityDirection = Vector3.up;
break;
case FallDirection.YNeg:
gravity.GravityDirection = Vector3.down;
break;
case FallDirection.ZPos:
gravity.GravityDirection = Vector3.forward;
break;
case FallDirection.ZNeg:
gravity.GravityDirection = Vector3.back;
break;
default:
break;
}
rigbod.AddForce(gravity.GetForce());
}
public bool TakeDamage(int damage)
{
if (!isDead && !isHit)
{
health -= damage;
animator.SetBool("IsHit", true);
if (health <= 0)
{
//Dead
healthBar.value = 0;
Die();
}
else
{
//Update health bar here
healthBar.value = health;
}
//hit animations here
FallDirection fallDirection = GetFallingDirection();
if (fallDirection == FallDirection.Front)
{
animator.SetTrigger("HitFront");
}
else if (fallDirection == FallDirection.Back)
{
animator.SetTrigger("HitBack");
}
isHit = true;
StartCoroutine(StopHitAnimation());
}
return(isDead);
}
void VerticalCollisions(ref Vector2 velocity)
{
float directionY = Mathf.Sign(velocity.y);
float rayLength = Mathf.Abs(velocity.y) + m_buffer + m_skinWidth;
bool hitCollision = false;
for (int i = 0; i < m_verticalRayCount; i++)
{
Vector2 rayOrigin = (directionY == -1)?m_raycastOrigins.bottomLeft:m_raycastOrigins.topLeft;
rayOrigin += Vector2.right * (m_verticalRaySpacing * i + velocity.x);
RaycastHit2D [] hitL = Physics2D.RaycastAll(rayOrigin, Vector2.up * directionY, rayLength, CollisionMask);
foreach (RaycastHit2D hit in hitL)
{
if (!hit.collider.isTrigger && !(hit.collider.gameObject == gameObject))
{
if (JumpThruTag(hit.collider.gameObject) && (velocity.y > 0 || dropThruTime > 0f)) //|| handleStairs(hit,velocity))){
{
}
else
{
hitCollision = true;
velocity.y = (hit.distance + m_skinWidth - (0.25f * m_buffer)) * directionY;
rayLength = hit.distance;
if (m_collisions.climbingSlope)
{
velocity.x = velocity.y / Mathf.Tan(m_collisions.slopeAngle * Mathf.Deg2Rad) * Mathf.Sign(velocity.x);
}
m_collisions.below = directionY == -1;
m_collisions.above = directionY == 1;
break;
}
}
}
}
OnGround = false;
rayLength = rayLength + 0.1f;
FallDir = FallDirection.NONE;
bool collide = false;
bool started = false;
rayLength = 0.3f;
for (int i = 0; i < m_verticalRayCount; i++)
{
Vector2 rayOrigin = m_raycastOrigins.bottomLeft; //true ? raycastOrigins.bottomLeft : raycastOrigins.topLeft;
rayOrigin += Vector2.right * (m_verticalRaySpacing * i + velocity.x);
RaycastHit2D [] hitL = Physics2D.RaycastAll(rayOrigin, Vector2.up * -1f, rayLength, CollisionMask);
foreach (RaycastHit2D hit in hitL)
{
if (FallDir == FallDirection.RIGHT)
{
FallDir = FallDirection.NONE;
}
if (JumpThruTag(hit.collider.gameObject) && (dropThruTime > 0f))
{
}
else
{
if (!hit.collider.isTrigger && hit.collider.gameObject != gameObject)
{
Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.red);
OnGround = true;
if (started && !collide)
{
FallDir = FallDirection.LEFT;
}
collide = true;
break;
}
else
{
Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.green);
if (started && collide && FallDir != FallDirection.LEFT)
{
FallDir = FallDirection.RIGHT;
}
}
}
}
started = true;
}
if (directionY < 0f && hitCollision)
{
m_timeCollided [Direction.DOWN] += Time.fixedDeltaTime;
}
else
{
m_timeCollided [Direction.DOWN] = 0f;
}
if (directionY > 0f && hitCollision)
{
m_timeCollided [Direction.UP] += Time.fixedDeltaTime;
}
else
{
m_timeCollided [Direction.UP] = 0f;
}
}
public override void OnFixedUpdate(float timeMult)
{
const float FallMultiplier = 0.0036f;
const float Bounce = -0.2f;
base.OnFixedUpdate(timeMult);
if (fall != FallDirection.Left && fall != FallDirection.Right)
{
return;
}
fallTime += timeMult;
if (fall == FallDirection.Right)
{
if (angleVel > 0 && IsPositionBlocked())
{
if (bouncesLeft > 0)
{
if (bouncesLeft == BouncesMax)
{
angleVelLast = angleVel;
}
bouncesLeft--;
angleVel = Bounce * bouncesLeft * angleVelLast;
}
else
{
fall = FallDirection.Fallen;
if (fallTime < 10)
{
CollisionFlags &= ~CollisionFlags.IsSolidObject;
}
}
}
else
{
angleVel += FallMultiplier * timeMult;
Transform.Angle += angleVel * timeMult;
}
}
else if (fall == FallDirection.Left)
{
if (angleVel < 0 && IsPositionBlocked())
{
if (bouncesLeft > 0)
{
if (bouncesLeft == BouncesMax)
{
angleVelLast = angleVel;
}
bouncesLeft--;
angleVel = Bounce * bouncesLeft * angleVelLast;
}
else
{
fall = FallDirection.Fallen;
if (fallTime < 10)
{
CollisionFlags &= ~CollisionFlags.IsSolidObject;
}
}
}
else
{
angleVel -= FallMultiplier * timeMult;
Transform.Angle += angleVel * timeMult;
}
}
}
void VerticalCollisions(ref Vector2 velocity)
{
float directionY = Mathf.Sign(velocity.y);
float rayLength = Mathf.Abs(velocity.y) + m_skinWidth;
for (int i = 0; i < m_verticalRayCount; i++)
{
Vector2 rayOrigin = (directionY == -1)?m_raycastOrigins.bottomLeft:m_raycastOrigins.topLeft;
rayOrigin += Vector2.right * (m_verticalRaySpacing * i + velocity.x);
//RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up * directionY, rayLength, CollisionMask);
RaycastHit2D [] hitL = Physics2D.RaycastAll(rayOrigin, Vector2.up * directionY, rayLength, CollisionMask);
//Debug.Log (hitL.Length + " : " + gameObject);
foreach (RaycastHit2D hit in hitL)
{
if (!hit.collider.isTrigger)
{
if (JumpThruTag(hit.collider.gameObject) && (velocity.y > 0 || dropThruTime > 0f)) //|| handleStairs(hit,velocity))){
{
}
else
{
velocity.y = (hit.distance - m_skinWidth) * directionY;
rayLength = hit.distance;
if (m_collisions.climbingSlope)
{
velocity.x = velocity.y / Mathf.Tan(m_collisions.slopeAngle * Mathf.Deg2Rad) * Mathf.Sign(velocity.x);
}
m_collisions.below = directionY == -1;
m_collisions.above = directionY == 1;
break;
}
}
}
}
FallDir = FallDirection.NONE;
OnGround = false;
rayLength = rayLength + 0.1f;
if (true)
{
bool collide = false;
bool started = false;
rayLength = 0.3f;
for (int i = 0; i < m_verticalRayCount; i++)
{
Vector2 rayOrigin = m_raycastOrigins.bottomLeft; //true ? raycastOrigins.bottomLeft : raycastOrigins.topLeft;
rayOrigin += Vector2.right * (m_verticalRaySpacing * i + velocity.x);
RaycastHit2D [] hitL = Physics2D.RaycastAll(rayOrigin, Vector2.up * -1f, rayLength, CollisionMask);
foreach (RaycastHit2D hit in hitL)
{
if (JumpThruTag(hit.collider.gameObject) && (dropThruTime > 0f))
{
}
else
{
if (!hit.collider.isTrigger && hit.collider.gameObject != gameObject)
{
////Debug.Log (hit.collider.gameObject);
Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.red);
OnGround = true;
if (started && !collide)
{
FallDir = FallDirection.LEFT;
}
collide = true;
break;
}
else
{
Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.green);
if (started && collide)
{
FallDir = FallDirection.RIGHT;
}
}
}
}
started = true;
}
}
}