// Update is called once per frame
public virtual void update(IGravityClient object_)
{
if (!reset)
{
y_velocity = y_velocity + gravity * Time.deltaTime * (isFalling()? multiplyYVelocityDown : multiplyYVelocityUp);
yFallDistance = y_velocity * Time.deltaTime + 0.5f * gravity * (Time.deltaTime * Time.deltaTime);
if (!checkForCollision(object_))
{
moveEntity(object_, yFallDistance);
}
else
{
if (isNotFalling())
{
y_velocity = 0.00f;
}
else
{
reset = true;
yFallDistance = 0.0f;
distanceTravelled.x = 0.0f;
distanceTravelled.y = 0.0f;
distanceTravelled.z = 0.0f;
y_velocity = 0.00f;
}
}
}
else
{
_reset(object_);
}
}
public override void update(AICharacter character)
{
IGravityClient gravityClient = character.getEntity().getGravityClient();
KeysPressed keysPressed = character.getEntity().getKeysPressed();
RayInformation rayInformation = character.getEntity().getGravityClient().getRayInformation();
RayHitboxes rayHitboxes = gravityClient.getRayHitboxes();
gravityClient.getRayInformation().checkRaysFront(gravityClient, 0.0f, character.getEntity().getTransform().eulerAngles.z + 0.0f, layermask, false);
gravityClient.getRayInformation().checkRaysBelow(gravityClient, 0.0f, character.getEntity().getTransform().eulerAngles.z + 270.0f, layermask, false);
float minimalSpaceBetweenTileBelow = rayInformation.MinimalSpaceBetweenTileBelow;
float topFrontDistance = (rayHitboxes.HitTopFront.distance * 0.9f);
bool turned = false;
gravityClient.getRayInformation().checkRaysFront(gravityClient, 0.0f, character.getEntity().getTransform().eulerAngles.z + 0.0f, layermask, true);
keysPressed = turnIfWallIsNear(gravityClient, topFrontDistance,
rayInformation.MinimalSpaceBetweenTileFront, keysPressed, out turned);
if (!turned && (rayHitboxes.HitMiddleBelow.collider.tag.CompareTo("Slope") != 0))
{
keysPressed = turnIfOnAnEdge(keysPressed, minimalSpaceBetweenTileBelow, character);
}
character.setKeysPressed(keysPressed);
}
public float checkRaysTop(IGravityClient gameObject, float yAangle, float zAngle, int layersToIgnore = 0)
{
RaycastHit2D hitLeftTop;
RaycastHit2D hitMiddleTop;
RaycastHit2D hitRightTop;
float distanceTop = checkRay(gameObject, posRayLeftTop,
1000.0f, yAangle, zAngle, out hitLeftTop, Color.red, layersToIgnore);
float tmpDistanceTop = checkRay(gameObject, posRayMiddleTop,
1000.0f, yAangle, zAngle, out hitMiddleTop, Color.red, layersToIgnore);
distanceTop = (distanceTop < tmpDistanceTop) ? distanceTop : tmpDistanceTop;
tmpDistanceTop = checkRay(gameObject, posRayRightTop,
1000.0f, yAangle, zAngle, out hitRightTop, Color.red, layersToIgnore);
distanceTop = (distanceTop < tmpDistanceTop) ? distanceTop : tmpDistanceTop;
RayHitboxes rayHitboxes = gameObject.getRayHitboxes();
rayHitboxes.HitLeftTop = hitLeftTop;
rayHitboxes.HitMiddleTop = hitMiddleTop;
rayHitboxes.HitRightTop = hitRightTop;
rayHitboxes.DistanceTop = distanceTop;
gameObject.setRayHitboxes(rayHitboxes);
return(distanceTop);
}
public virtual bool checkObjectHitsFloor(IGravityClient object_)
{
#if USE_3D_RAYS
RayInformation3D rayInformation = object_.getRayInformation3D();
RayHitboxes3D rayHitboxes = object_.getRayHitboxes3D();
#else
RayInformation rayInformation = object_.getRayInformation();
RayHitboxes rayHitboxes = object_.getRayHitboxes();
#endif
rayInformation.checkRaysBelow(object_, 0.0f,
object_.getTransform().eulerAngles.z + 270.0f,
layermask);
float correction = 0.0f;
float minimalSpaceBetweenTileBelow = rayInformation.MinimalSpaceBetweenTileBelow;
bool objectOnFloor = (rayHitboxes.DistanceBelow <
minimalSpaceBetweenTileBelow * rayInformation.BelowTolerance) ? true :
((multiplyYVelocityDown * yFallDistance) > (rayHitboxes.DistanceBelow -
minimalSpaceBetweenTileBelow)) ? true : false;
if (objectOnFloor)
{
correction = -(rayHitboxes.DistanceBelow -
rayInformation.MinimalSpaceBetweenTileBelow);
moveEntity(object_, correction);
}
return(objectOnFloor);
}
protected virtual KeysPressed turnIfWallIsNear(IGravityClient gravityClient, float topFrontDistance,
float minimalSpaceBetweenTileFront, KeysPressed keysPressed, out bool turned)
{
turned = false;
if (!gravityClient.isFlipped() &&
topFrontDistance <= minimalSpaceBetweenTileFront)
{
turned = true;
keysPressed.left = true;
keysPressed.right = false;
}
else if (!gravityClient.isFlipped() &&
topFrontDistance > minimalSpaceBetweenTileFront)
{
keysPressed.left = false;
keysPressed.right = true;
}
if (gravityClient.isFlipped() &&
topFrontDistance <= minimalSpaceBetweenTileFront)
{
turned = true;
keysPressed.left = false;
keysPressed.right = true;
}
else if (gravityClient.isFlipped() &&
topFrontDistance > minimalSpaceBetweenTileFront)
{
keysPressed.left = true;
keysPressed.right = false;
}
return(keysPressed);
}
private KeysPressed turnIfOnAnEdge(KeysPressed keysPressed,
float minimalSpaceBetweenTileBelow, AICharacter character)
{
IGravityClient gravityClient = character.getEntity().getGravityClient();
RayHitboxes rayHitboxes = gravityClient.getRayHitboxes();
if (gravityClient.isFlipped() && rayHitboxes.HitLeftBelow.distance > 1.0f)
{
keysPressed.left = false;
keysPressed.right = true;
}
else if (gravityClient.isFlipped() &&
rayHitboxes.HitLeftBelow.distance <= minimalSpaceBetweenTileBelow)
{
keysPressed.left = true;
keysPressed.right = false;
}
if (!gravityClient.isFlipped() &&
rayHitboxes.HitRightBelow.distance > 1.0f)
{
keysPressed.left = true;
keysPressed.right = false;
}
else if (!gravityClient.isFlipped() &&
rayHitboxes.HitRightBelow.distance <= minimalSpaceBetweenTileBelow)
{
keysPressed.left = false;
keysPressed.right = true;
}
return(keysPressed);
}
public bool checkLeftRayBelowForSlope(IGravityClient gameObject, float yAangle, float zAngle, int layersToIgnore = 0)
{
RaycastHit2D hitLeftBelow;
checkRay(gameObject, PosRayLeftBelow, 1000.0f, yAangle, zAngle, out hitLeftBelow, Color.gray, layersToIgnore + (1 << slopeLayerNumber));
return(hitLeftBelow.collider.tag.CompareTo("Slope") == 0);
}
public override void update(IEntity entity)
{
Gravity gravity = entity.getGravity();
KeysPressed keysPressed = entity.getKeysPressed();
IGravityClient gravityClient = entity.getGravityClient();
moveEntity(entity, keysPressed, gravity, entity.getMovementSpeed());
switchState(entity, keysPressed, gravity, gravityClient);
}
public bool moveEntityDown(IEntity entity, KeysPressed keysPressed, Gravity gravity, float movementSpeed)
{
IGravityClient gravityClient = entity.getGravityClient();
bool moving = false;
#if USE_3D_RAYS
RayHitboxes3D rayHitboxes = gravityClient.getRayHitboxes3D();
#else
RayHitboxes rayHitboxes = gravityClient.getRayHitboxes();
#endif
Vector3 angles = new Vector3(entity.getTransform().eulerAngles.x,
entity.getTransform().eulerAngles.y,
entity.getTransform().eulerAngles.z);
#if USE_3D_RAYS
RayInformation3D rayInformation = gravityClient.getRayInformation3D();
#else
RayInformation rayInformation = gravityClient.getRayInformation();
#endif
if (!keysPressed.up && keysPressed.down)
{
rayInformation.checkRaysBelow(gravityClient, 0.0f, angles.z + 270.0f, layermask);
}
bool isWalking = !entity.getGravity().isFalling() && !entity.getGravity().Jumping;
float frontDistance = rayHitboxes.DistanceBelow;
if (frontDistance > rayInformation.MinimalSpaceBetweenTileBelow)
{
if (!keysPressed.up && keysPressed.down)
{
moving = true;
if (!entity.getRotateHorizontalMovement())
{
Vector3 pos = entity.getTransform().position;
if (angles.z > 90.0f && angles.z < 270.0f)
{
pos.y -= ((frontDistance - rayInformation.MinimalSpaceBetweenTileBelow) < movementSpeed * Time.fixedDeltaTime) ?
(frontDistance - rayInformation.MinimalSpaceBetweenTileBelow) : movementSpeed * Time.fixedDeltaTime;
}
else
{
pos.y -= ((frontDistance - rayInformation.MinimalSpaceBetweenTileBelow) < movementSpeed * Time.fixedDeltaTime) ?
(frontDistance - rayInformation.MinimalSpaceBetweenTileBelow) : movementSpeed * Time.fixedDeltaTime;
}
entity.getTransform().position = pos;
}
gravity.Reset = false;
}
}
return(moving);
}
public virtual void moveEntity(IGravityClient object_, float moveDistance)
{
Vector3 newPosition = object_.getTransform().position;
Vector3 distance = Quaternion.Euler(
new Vector3(object_.getTransform().eulerAngles.x,
object_.getTransform().eulerAngles.y,
object_.getTransform().eulerAngles.z)) * new Vector3(0.0f, moveDistance, 0.0f);
distanceTravelled += distance;
newPosition += distance;
object_.getTransform().position = newPosition;
}
public float checkRaysFront(IGravityClient gameObject, float yAangle, float zAngle, int layerMask = 0, bool ignoreSlope = false)
{
RaycastHit2D hitTopFront;
RaycastHit2D hitMiddleFront;
RaycastHit2D hitBelowFront;
float distance = (gameObject.isFlipped()) ? -1000.0f : 1000.0f;
float distanceFront = (!gameObject.isFlipped()) ? checkRay(gameObject, posRayTopFront,
distance, yAangle, zAngle, out hitTopFront, Color.green, layerMask + ((ignoreSlope)? 0 : (1 << slopeLayerNumber))) :
checkRayFlipped(gameObject, posRayTopFront,
distance, yAangle, zAngle, out hitTopFront, Color.green, layerMask + ((ignoreSlope) ? 0 : (1 << slopeLayerNumber)));
float tmpDistanceFront = (!gameObject.isFlipped()) ? checkRay(gameObject, posRayMiddleFront,
distance, yAangle, zAngle, out hitMiddleFront, Color.green, layerMask + ((ignoreSlope) ? 0 : (1 << slopeLayerNumber))) :
checkRayFlipped(gameObject, posRayMiddleFront,
distance, yAangle, zAngle, out hitMiddleFront, Color.green, layerMask + ((ignoreSlope) ? 0 : (1 << slopeLayerNumber)));
distanceFront = (distanceFront < tmpDistanceFront) ? distanceFront : tmpDistanceFront;
RayHitboxes rayHitboxes = gameObject.getRayHitboxes();
if (rayHitboxes.HitMiddleFront.collider != null &&
rayHitboxes.HitMiddleFront.collider.tag.CompareTo("Slope") != 0)
{
tmpDistanceFront = (!gameObject.isFlipped()) ? checkRay(gameObject, posRayBelowFront,
distance, yAangle, zAngle, out hitBelowFront, Color.green, layerMask) :
checkRayFlipped(gameObject, posRayBelowFront,
distance, yAangle, zAngle, out hitBelowFront, Color.green, layerMask);
rayHitboxes.HitBelowFront = hitBelowFront;
if (rayHitboxes.HitBelowFront.collider != null &&
rayHitboxes.HitBelowFront.collider.tag.CompareTo("Slope") != 0)
{
distanceFront = (distanceFront < tmpDistanceFront) ? distanceFront : tmpDistanceFront;
}
}
else
{
hitBelowFront = new RaycastHit2D();
hitBelowFront.distance = -1.0f;
rayHitboxes.HitBelowFront = hitBelowFront;
}
rayHitboxes.HitMiddleFront = hitMiddleFront;
rayHitboxes.HitTopFront = hitTopFront;
rayHitboxes.DistanceFront = distanceFront;
gameObject.setRayHitboxes(rayHitboxes);
return(distanceFront);
}
public override void update(IEntity entity)
{
Gravity gravity = entity.getGravity();
KeysPressed keysPressed = entity.getKeysPressed();
if (keysPressed.attack)
{
Player player = entity.getTransform().gameObject.GetComponent <Player>();
IBehaviourStateFactory behaviourStateFactory = entity.getBehaviourStateFactory();
if (player != null && player.IsNearShop)
{
if (keysPressed.actionButtonOne)
{
entity.setState(((BehaviourStateFactory)behaviourStateFactory).getShopState(entity));
}
}
else
{
int direction = (!keysPressed.left && !keysPressed.right && !keysPressed.up && !keysPressed.down) ? -1 : getDirection(keysPressed);
entity.setState(((BehaviourStateFactory)behaviourStateFactory).getAttackState(entity, direction));
}
}
else
{
IGravityClient gravityClient = entity.getGravityClient();
bool moving = false;
moving = moveEntityUp(entity, keysPressed, gravity, entity.getMovementSpeed());
if (!moving)
{
moving = moveEntityDown(entity, keysPressed, gravity, entity.getMovementSpeed());
}
if (moveEntity(entity, keysPressed, gravity, entity.getMovementSpeed()))
{
moving = true;
}
entity.setMoving(moving);
if (!keysPressed.left && !keysPressed.right && !keysPressed.up && !keysPressed.down)
{
goIdle(entity);
}
}
}
public float checkAttackRay(IGravityClient gameObject, Vector3 startPosRay, Vector3 endPosRay, string tag)
{
float result = -1.0f;
RaycastHit2D attackRayResult = Physics2D.Raycast(startPosRay, endPosRay);
if (attackRayResult.collider.tag.CompareTo(tag) == 0)
{
result = attackRayResult.distance;
}
RayHitboxes rayHitboxes = gameObject.getRayHitboxes();
rayHitboxes.AttackRayResult = attackRayResult;
gameObject.setRayHitboxes(rayHitboxes);
return(result);
}
public float checkRaysFront(IGravityClient gameObject, float yAangle, float zAngle, int layersToIgnore = 0)
{
RaycastHit hitTopFront;
RaycastHit hitMiddleFront;
RaycastHit hitBelowFront;
float distance = (gameObject.isFlipped()) ? -1000.0f : 1000.0f;
float distanceFront = (!gameObject.isFlipped()) ? checkRay(gameObject, posRayTopFront,
distance, yAangle, zAngle, out hitTopFront, Color.green, layersToIgnore) :
checkRayFlipped(gameObject, posRayTopFront,
distance, yAangle, zAngle, out hitTopFront, Color.green, layersToIgnore);
float tmpDistanceFront = (!gameObject.isFlipped()) ? checkRay(gameObject, posRayMiddleFront,
distance, yAangle, zAngle, out hitMiddleFront, Color.green, layersToIgnore) :
checkRayFlipped(gameObject, posRayMiddleFront,
distance, yAangle, zAngle, out hitMiddleFront, Color.green, layersToIgnore);
distanceFront = (distanceFront < tmpDistanceFront) ? distanceFront : tmpDistanceFront;
RayHitboxes3D rayHitboxes = gameObject.getRayHitboxes3D();
if (rayHitboxes.HitMiddleFront.collider != null &&
rayHitboxes.HitMiddleFront.collider.tag.CompareTo("Slope") != 0)
{
tmpDistanceFront = (!gameObject.isFlipped()) ? checkRay(gameObject, posRayBelowFront,
distance, yAangle, zAngle, out hitBelowFront, Color.green, layersToIgnore) :
checkRayFlipped(gameObject, posRayBelowFront,
distance, yAangle, zAngle, out hitBelowFront, Color.green, layersToIgnore);
rayHitboxes.HitBelowFront = hitBelowFront;
if (rayHitboxes.HitBelowFront.collider != null &&
rayHitboxes.HitBelowFront.collider.tag.CompareTo("Slope") != 0)
{
distanceFront = (distanceFront < tmpDistanceFront) ? distanceFront : tmpDistanceFront;
}
}
rayHitboxes.HitMiddleFront = hitMiddleFront;
rayHitboxes.HitTopFront = hitTopFront;
rayHitboxes.DistanceFront = distanceFront;
gameObject.setRayHitboxes3D(rayHitboxes);
return(distanceFront);
}
public bool moveEntityUp(IEntity entity, KeysPressed keysPressed, Gravity gravity, float movementSpeed)
{
IGravityClient gravityClient = entity.getGravityClient();
bool moving = false;
#if USE_3D_RAYS
RayHitboxes3D rayHitboxes = gravityClient.getRayHitboxes3D();
#else
RayHitboxes rayHitboxes = gravityClient.getRayHitboxes();
#endif
Vector3 angles = new Vector3(entity.getTransform().eulerAngles.x,
entity.getTransform().eulerAngles.y,
entity.getTransform().eulerAngles.z);
#if USE_3D_RAYS
RayInformation3D rayInformation = gravityClient.getRayInformation3D();
#else
RayInformation rayInformation = gravityClient.getRayInformation();
#endif
if (keysPressed.up && !keysPressed.down)
{
rayInformation.checkRaysTop(gravityClient, 0.0f, angles.z + 90.0f, layermask);
}
bool isWalking = !entity.getGravity().isFalling() && !entity.getGravity().Jumping;
float frontDistance = rayHitboxes.DistanceTop;
if (frontDistance > rayInformation.MinimalSpaceBetweenTileTop)
{
if (keysPressed.up && !keysPressed.down)
{
moving = true;
Vector3 pos = entity.getTransform().position;
pos.y += ((frontDistance - rayInformation.MinimalSpaceBetweenTileTop) < movementSpeed * Time.fixedDeltaTime) ?
(frontDistance - rayInformation.MinimalSpaceBetweenTileTop) : movementSpeed * Time.fixedDeltaTime;
entity.getTransform().position = pos;
gravity.Reset = false;
}
}
return(moving);
}
public float checkRaysBelow(IGravityClient gameObject, float yAangle, float zAngle, int layersToIgnore, bool doIgnoreSlope = true)
{
RaycastHit2D hitMiddleBelow;
RaycastHit2D hitLeftBelow;
RaycastHit2D hitRightBelow;
float distanceBelow = checkRay(gameObject, posRayMiddleBelow,
1000.0f, yAangle, zAngle, out hitMiddleBelow, Color.blue, layersToIgnore + (1 << slopeLayerNumber));
float belowTolerance = ((hitMiddleBelow.collider.tag.CompareTo("Slope") == 0) ? this.belowTolerance : 1.0f);
bool rightRayOnSlope = checkRightRayBelowForSlope(gameObject, yAangle, zAngle, out hitRightBelow, layersToIgnore);
bool leftRayOnSlope = checkLeftRayBelowForSlope(gameObject, yAangle, zAngle, out hitLeftBelow, layersToIgnore);
float leftDistanceBelow = checkRay(gameObject, posRayLeftBelow, 1000.0f, yAangle,
zAngle, out hitLeftBelow, Color.gray, layersToIgnore + ((doIgnoreSlope) ? 0 : (1 << slopeLayerNumber)));
float rightDistanceBelow = checkRay(gameObject, posRayRightBelow, 1000.0f, yAangle,
zAngle, out hitRightBelow, Color.green, layersToIgnore + ((doIgnoreSlope) ? 0 : (1 << slopeLayerNumber)));
if (!doIgnoreSlope ||
(doIgnoreSlope && distanceBelow >= (minimalSpaceBetweenTileBelow * belowTolerance)))
{
if (leftDistanceBelow < distanceBelow)
{
distanceBelow = leftDistanceBelow;
}
if (distanceBelow > rightDistanceBelow)
{
distanceBelow = rightDistanceBelow;
}
}
RayHitboxes rayHitboxes = gameObject.getRayHitboxes();
rayHitboxes.HitMiddleBelow = hitMiddleBelow;
rayHitboxes.HitLeftBelow = hitLeftBelow;
rayHitboxes.HitRightBelow = hitRightBelow;
rayHitboxes.DistanceBelow = distanceBelow;
gameObject.setRayHitboxes(rayHitboxes);
return(distanceBelow);
}
//https://docs.unity3d.com/ScriptReference/Physics.Raycast.html?_ga=2.69651992.960042701.1515280206-1316818202.1483563338
public float checkRayFlipped(IGravityClient gameObject, Vector3 positionRay, float distance,
float yAngle, float zAngle, out RaycastHit hit, Color color, int layersToIgnore = 0)
{
float result = float.MaxValue;
Vector3 startRay = new Vector2(positionRay.x, positionRay.y);
Vector3 endRay = new Vector2(positionRay.x + distance, positionRay.y);
Vector3 dir = Vector3.left;
Vector3 eulerVector = new Vector3(0.0f, 0.0f, 0.0f);
startRay = Quaternion.Euler(eulerVector) * (startRay);
endRay = Quaternion.Euler(eulerVector) * (endRay);
dir = Quaternion.Euler(eulerVector) * (dir);
eulerVector.z = zAngle;
startRay = Quaternion.Euler(eulerVector) * (startRay);
endRay = Quaternion.Euler(eulerVector) * (endRay);
dir = Quaternion.Euler(eulerVector) * (dir);
startRay += gameObject.getPosition();
endRay += gameObject.getPosition();
int layerMask = ~(1 << gameObject.getLayer() | layersToIgnore);
if (yAngle > 0.0f)
{
dir = Vector3.back;
}
if (yAngle < 0.0f)
{
dir = Vector3.forward;
}
if (Physics.Raycast(startRay, dir, out hit, 1000000.0f, layerMask))
{
result = hit.distance;
}
Debug.DrawRay(startRay, dir, color, 0.2f, false);
return(result);
}
public virtual float checkRay(IGravityClient gameObject, Vector3 positionRay, float distance, float yAngle, float zAngle, out RaycastHit2D hit, Color color, int layersToIgnore = 0)
{
float result = float.MaxValue;
Vector3 startRay = new Vector2(positionRay.x, positionRay.y);
Vector3 endRay = new Vector2(positionRay.x + distance, positionRay.y);
Vector2 dir = Vector2.right;
Vector3 eulerVector = new Vector3(0.0f, 0.0f, 0.0f);
startRay = Quaternion.Euler(eulerVector) * (startRay);
endRay = Quaternion.Euler(eulerVector) * (endRay);
dir = Quaternion.Euler(eulerVector) * (dir);
eulerVector.y = yAngle;
eulerVector.z = zAngle;
startRay = Quaternion.Euler(eulerVector) * (startRay);
endRay = Quaternion.Euler(eulerVector) * (endRay);
dir = Quaternion.Euler(eulerVector) * (dir);
startRay += gameObject.getPosition();
endRay += gameObject.getPosition();
int layerMask = layersToIgnore;
hit = Physics2D.Raycast(startRay, dir, 1000000.0f, layerMask);
if (hit.collider != null)
{
result = hit.distance;
Debug.DrawLine(startRay, hit.point, color);
}
else
{
Debug.DrawLine(startRay, endRay, color);
}
return(result);
}
public override void update(IEntity entity)
{
Gravity gravity = entity.getGravity();
KeysPressed keysPressed = entity.getKeysPressed();
IGravityClient gravityClient = entity.getGravityClient();
#if USE_3D_RAYS
gravityClient.getRayInformation3D().checkRaysFront(gravityClient, 0.0f, entity.getTransform().eulerAngles.z + 0.0f, entity.getGravityClient().getLayerToIgnore());
#else
gravityClient.getRayInformation().checkRaysFront(gravityClient, 0.0f, entity.getTransform().eulerAngles.z + 0.0f, layermask);
#endif
if (keysPressed.jump && (gravity.isStanding() ||
#if USE_3D_RAYS
(gravityClient.getRayHitboxes().DistanceBelow <= (gravityClient.getRayInformation3D().MinimalSpaceBetweenTileBelow))) &&
#else
(gravityClient.getRayHitboxes().DistanceBelow <= (gravityClient.getRayInformation().MinimalSpaceBetweenTileBelow))) &&
#endif
entity.getJumpedReleased())
{
IBehaviourStateFactory behaviourStateFactory = entity.getBehaviourStateFactory();
entity.setState(behaviourStateFactory.getJumpUpState(entity));
moveEntity(entity, keysPressed, gravity, entity.getMovementSpeed());
}
public float checkRaysBelow(IGravityClient gameObject, float yAangle, float zAngle, int layersToIgnore = 0)
{
RaycastHit hitMiddleBelow;
RaycastHit hitLeftBelow;
RaycastHit hitRightBelow;
float distanceBelow = checkRay(gameObject, posRayMiddleBelow,
1000.0f, yAangle, zAngle, out hitMiddleBelow, Color.blue, layersToIgnore);
float leftDistanceBelow = checkRay(gameObject, posRayLeftBelow,
1000.0f, yAangle, zAngle, out hitLeftBelow, Color.gray, layersToIgnore);
float rightDistanceBelow = checkRay(gameObject, posRayRightBelow,
1000.0f, yAangle, zAngle, out hitRightBelow, Color.blue, layersToIgnore);
if (checkDistanceBetweenRays(hitLeftBelow, hitMiddleBelow))
{
distanceBelow = leftDistanceBelow;
}
if (leftDistanceBelow > rightDistanceBelow)
{
if (checkDistanceBetweenRays(hitRightBelow, hitMiddleBelow))
{
distanceBelow = rightDistanceBelow;
}
}
RayHitboxes3D rayHitboxes = gameObject.getRayHitboxes3D();
rayHitboxes.HitMiddleBelow = hitMiddleBelow;
rayHitboxes.HitLeftBelow = hitLeftBelow;
rayHitboxes.HitRightBelow = hitRightBelow;
rayHitboxes.DistanceBelow = distanceBelow;
gameObject.setRayHitboxes3D(rayHitboxes);
return(distanceBelow);
}
protected virtual void init()
{
currectZ = transform.localRotation.eulerAngles.z;
IGravityFactory gravityFactory = new GravityFactory();
#if USE_3D_RAYS
rayHitboxes3D = gravityFactory.getRayHitboxes3D();
#else
rayHitboxes = gravityFactory.getRayHitboxes();
#endif
setGravity();
gravityClient = gravityFactory.getGravityClient(this);
if (castsShadows)
{
spriteRenderer.shadowCastingMode = ShadowCastingMode.TwoSided;
spriteRenderer.receiveShadows = true;
}
LayersLookup layersLookup = GameObject.FindGameObjectWithTag("GameManager").GetComponent <LayersLookup>();
layermask = (1 << layersLookup.giveLayerNumber("Tile") | 1 << layersLookup.giveLayerNumber("Default"));
}
public virtual bool checkObjectHitsPlatform(float yModifier, IGravityClient object_)
{
#if USE_3D_RAYS
RayInformation3D rayInformation = object_.getRayInformation3D();
RayHitboxes3D rayHitboxes = object_.getRayHitboxes3D();
#else
RayInformation rayInformation = object_.getRayInformation();
RayHitboxes rayHitboxes = object_.getRayHitboxes();
#endif
rayInformation.checkRaysTop(object_, 0.0f, object_.getTransform().eulerAngles.z + 90.0f, layermask);
bool objectHitTop = (rayHitboxes.DistanceTop <
rayInformation.MinimalSpaceBetweenTileTop) ? true :
(yModifier > (rayHitboxes.DistanceTop -
rayInformation.MinimalSpaceBetweenTileTop)) ? true : false;
if (objectHitTop)
{
float correction = -(rayHitboxes.DistanceTop -
rayInformation.MinimalSpaceBetweenTileTop);
moveEntity(object_, correction);
checkObjectHitsFloor(object_);
}
return(objectHitTop);
}
// Update is called once per frame
public override void update(IGravityClient object_)
{
#if (DEBUG)
// Debug.Log("Update method is empty!");
#endif
}
public virtual bool checkForCollision(IGravityClient object_)
{
return((yFallDistance > 0.0f) ? checkObjectHitsPlatform(yFallDistance, object_) : checkObjectHitsFloor(object_));
}
public virtual void _reset(IGravityClient object_)
{
y_velocity = (jumping) ? object_.getJumpForce() : y_velocity_reset;
}
protected virtual void switchState(IEntity entity, KeysPressed keysPressed, Gravity gravity, IGravityClient gravityClient)
{
if (!keysPressed.jump)
{
if (gravity.Y_velocity >= 0.0f && (gravityClient.getJumpForce() * 0.85f) > gravity.Y_velocity)
{
gravity.Y_velocity = -0.01f;
}
}
if (gravity.isFalling() || gravity.isStanding())
{
gravity.Jumping = false;
IBehaviourStateFactory behaviourStateFactory = entity.getBehaviourStateFactory();
entity.setState(behaviourStateFactory.getFallState(entity));
}
}
