void PathfindingBehavior::MoveTo(RuntimeScene & scene, float x, float y)
{
if ( parentScene != &scene ) //Parent scene has changed
{
parentScene = &scene;
sceneManager = parentScene ? &ScenePathfindingObstaclesManager::managers[&scene] : NULL;
}
path.clear();
//First be sure that there is a path to compute.
int targetCellX = GDRound(x/(float)cellWidth);
int targetCellY = GDRound(y/(float)cellHeight);
int startCellX = GDRound(object->GetX()/(float)cellWidth);
int startCellY = GDRound(object->GetY()/(float)cellHeight);
if ( startCellX == targetCellX && startCellY == targetCellY ) {
path.push_back(sf::Vector2f(object->GetX(), object->GetY()));
path.push_back(sf::Vector2f(x, y));
EnterSegment(0);
pathFound = true;
return;
}
//Start searching for a path
//TODO: Customizable heuristic.
::SearchContext ctx(*sceneManager, allowDiagonals);
ctx.SetCellSize(cellWidth, cellHeight).SetStartPosition(object->GetX(), object->GetY());
ctx.SetObjectSize(object->GetX()-object->GetDrawableX()+extraBorder,
object->GetY()-object->GetDrawableY()+extraBorder,
object->GetWidth()-(object->GetX()-object->GetDrawableX())+extraBorder,
object->GetHeight()-(object->GetY()-object->GetDrawableY())+extraBorder);
if (ctx.ComputePathTo(x, y))
{
//Path found: memorize it
const ::Node * node = ctx.GetFinalNode();
while (node) {
path.push_back(sf::Vector2f(node->pos.x*(float)cellWidth, node->pos.y*(float)cellHeight));
node = node->parent;
}
std::reverse(path.begin(), path.end());
path[0] = sf::Vector2f(object->GetX(), object->GetY());
EnterSegment(0);
pathFound = true;
return;
}
//Not path found
pathFound = false;
}
bool RuntimeSpriteObject::SetAngle(float newAngle)
{
if ( currentAnimation >= GetAnimationsCount() ) return false;
if ( !animations[currentAnimation].Get().useMultipleDirections )
{
currentAngle = newAngle;
needUpdateCurrentSprite = true;
}
else
{
newAngle = static_cast<int>(newAngle)%360;
if ( newAngle < 0 ) newAngle += 360;
return SetDirection(static_cast<int>(GDRound(newAngle/45.f))%8);
}
return true;
}
double GD_API Round(double expression)
{
return GDRound(expression);
}
void PlatformerObjectBehavior::DoStepPreEvents(RuntimeScene& scene) {
if (parentScene != &scene) // Parent scene has changed
{
parentScene = &scene;
sceneManager =
parentScene ? &ScenePlatformObjectsManager::managers[&scene] : NULL;
floorPlatform = NULL;
}
if (!sceneManager) return;
double timeDelta =
static_cast<double>(object->GetElapsedTime(scene)) / 1000000.0;
// 0.1) Get the player input:
double requestedDeltaX = 0;
double requestedDeltaY = 0;
// Change the speed according to the player's input.
leftKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Left");
rightKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Right");
if (leftKey) currentSpeed -= acceleration * timeDelta;
if (rightKey) currentSpeed += acceleration * timeDelta;
// Take deceleration into account only if no key is pressed.
if (leftKey == rightKey) {
bool wasPositive = currentSpeed > 0;
currentSpeed -= deceleration * timeDelta * (wasPositive ? 1.0 : -1.0);
// Set the speed to 0 if the speed was top low.
if (wasPositive && currentSpeed < 0) currentSpeed = 0;
if (!wasPositive && currentSpeed > 0) currentSpeed = 0;
}
if (currentSpeed > maxSpeed) currentSpeed = maxSpeed;
if (currentSpeed < -maxSpeed) currentSpeed = -maxSpeed;
requestedDeltaX += currentSpeed * timeDelta;
// Compute the list of the objects that will be used
std::set<PlatformBehavior*> potentialObjects =
GetPotentialCollidingObjects(std::max(requestedDeltaX, maxFallingSpeed));
std::set<PlatformBehavior*> overlappedJumpThru =
GetJumpthruCollidingWith(potentialObjects);
// Check that the floor object still exists and is near the object.
if (isOnFloor &&
potentialObjects.find(floorPlatform) == potentialObjects.end()) {
isOnFloor = false;
floorPlatform = NULL;
}
// Check that the grabbed platform object still exists and is near the object.
if (isGrabbingPlatform &&
potentialObjects.find(grabbedPlatform) == potentialObjects.end()) {
ReleaseGrabbedPlatform();
}
// 0.2) Track changes in object size
// Stick the object to the floor if its height has changed.
if (trackSize && isOnFloor && oldHeight != object->GetHeight() &&
!scene.GetTimeManager().IsFirstLoop()) {
object->SetY(floorLastY - object->GetHeight() +
(object->GetY() - object->GetDrawableY()) - 1);
}
oldHeight = object->GetHeight();
// 1) X axis:
// Shift the object according to the floor movement.
if (isOnFloor) {
requestedDeltaX += floorPlatform->GetObject()->GetX() - floorLastX;
requestedDeltaY += floorPlatform->GetObject()->GetY() - floorLastY;
}
// Shift the object according to the grabbed platform movement.
if (isGrabbingPlatform) {
// This erases any other movement
requestedDeltaX =
grabbedPlatform->GetObject()->GetX() - grabbedPlatformLastX;
requestedDeltaY =
grabbedPlatform->GetObject()->GetY() - grabbedPlatformLastY;
}
// Ensure the object is not stuck
if (SeparateFromPlatforms(potentialObjects, true)) {
canJump =
true; // After being unstuck, the object must be able to jump again.
}
// Move the object on x axis.
double oldX = object->GetX();
if (requestedDeltaX != 0) {
object->SetX(object->GetX() + requestedDeltaX);
bool tryRounding = true;
// Colliding: Try to push out from the solid.
// Note that jump thru are never obstacle on X axis.
while (IsCollidingWith(
potentialObjects, floorPlatform, /*excludeJumpthrus=*/true)) {
if ((requestedDeltaX > 0 && object->GetX() <= oldX) ||
(requestedDeltaX < 0 && object->GetX() >= oldX)) {
object->SetX(oldX); // Unable to move the object without being stuck in
// an obstacle.
break;
}
// If on floor: try get up a bit to bypass not perfectly aligned floors.
if (isOnFloor) {
object->SetY(object->GetY() - 1);
if (!IsCollidingWith(
potentialObjects, floorPlatform, /*excludeJumpthrus=*/true))
break;
object->SetY(object->GetY() + 1);
}
if (tryRounding) {
// First try rounding the position as this might be sufficient to get
// the object out of the wall.
object->SetX(GDRound(object->GetX()));
tryRounding = false;
} else {
object->SetX(GDRound(object->GetX()) + (requestedDeltaX > 0 ? -1 : 1));
}
currentSpeed = 0; // Collided with a wall
}
}
// 2) Y axis:
// Go on a ladder
ladderKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Up");
if (ladderKey && IsOverlappingLadder(potentialObjects)) {
canJump = true;
isOnFloor = false;
floorPlatform = NULL;
currentJumpSpeed = 0;
currentFallSpeed = 0;
isOnLadder = true;
}
if (isOnLadder) {
upKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Up");
downKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Down");
if (upKey) requestedDeltaY -= 150 * timeDelta;
if (downKey) requestedDeltaY += 150 * timeDelta;
// Coming to an extremity of a ladder
if (!IsOverlappingLadder(potentialObjects)) {
isOnLadder = false;
}
}
// Fall
if (!isOnFloor && !isOnLadder && !isGrabbingPlatform) {
currentFallSpeed += gravity * timeDelta;
if (currentFallSpeed > maxFallingSpeed) currentFallSpeed = maxFallingSpeed;
requestedDeltaY += currentFallSpeed * timeDelta;
requestedDeltaY = std::min(requestedDeltaY, maxFallingSpeed * timeDelta);
}
// Grabbing a platform
if (canGrabPlatforms && requestedDeltaX != 0 && !isOnLadder && !isOnFloor) {
bool tryGrabbingPlatform = false;
object->SetX(object->GetX() +
(requestedDeltaX > 0 ? xGrabTolerance : -xGrabTolerance));
auto collidingObjects =
GetPlatformsCollidingWith(potentialObjects, overlappedJumpThru);
if (!collidingObjects.empty() &&
CanGrab(*collidingObjects.begin(), requestedDeltaY)) {
tryGrabbingPlatform = true;
}
object->SetX(object->GetX() +
(requestedDeltaX > 0 ? -xGrabTolerance : xGrabTolerance));
// Check if we can grab the collided platform
if (tryGrabbingPlatform) {
double oldY = object->GetY();
PlatformBehavior* collidingPlatform = *collidingObjects.begin();
object->SetY(collidingPlatform->GetObject()->GetY() +
collidingPlatform->GetYGrabOffset() - yGrabOffset);
if (!IsCollidingWith(potentialObjects, NULL, /*excludeJumpthrus=*/true)) {
isGrabbingPlatform = true;
grabbedPlatform = collidingPlatform;
requestedDeltaY = 0;
} else {
object->SetY(oldY);
}
}
}
releaseKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Down");
if (isGrabbingPlatform && !releaseKey) {
canJump = true;
currentJumpSpeed = 0;
currentFallSpeed = 0;
grabbedPlatformLastX = grabbedPlatform->GetObject()->GetX();
grabbedPlatformLastY = grabbedPlatform->GetObject()->GetY();
}
if (releaseKey) ReleaseGrabbedPlatform();
// Jumping
jumpKey |= !ignoreDefaultControls &&
(scene.GetInputManager().IsKeyPressed("LShift") ||
scene.GetInputManager().IsKeyPressed("RShift") ||
scene.GetInputManager().IsKeyPressed("Space"));
if (canJump && jumpKey) {
jumping = true;
canJump = false;
// isOnFloor = false; If floor is a very steep slope, the object could go
// into it.
isOnLadder = false;
currentJumpSpeed = jumpSpeed;
currentFallSpeed = 0;
isGrabbingPlatform = false;
// object->SetY(object->GetY()-1);
}
if (jumping) {
requestedDeltaY -= currentJumpSpeed * timeDelta;
currentJumpSpeed -= gravity * timeDelta;
if (currentJumpSpeed < 0) {
currentJumpSpeed = 0;
jumping = false;
}
}
// Follow the floor
if (isOnFloor) {
if (object->IsCollidingWith(floorPlatform->GetObject(),
ignoreTouchingEdges)) {
// Floor is getting up, as the object is colliding with it.
double oldY = object->GetY();
int step = 0;
bool stillInFloor = false;
do {
if (step >=
floor(std::abs(
requestedDeltaX *
slopeClimbingFactor))) // Slope is too step ( > max angle )
{
object->SetY(object->GetY() -
(std::abs(requestedDeltaX * slopeClimbingFactor) -
(double)step)); // Try to add the decimal part.
if (object->IsCollidingWith(floorPlatform->GetObject(),
ignoreTouchingEdges))
stillInFloor = true; // Too steep.
break;
}
// Try to get out of the floor.
object->SetY(object->GetY() - 1);
step++;
} while (object->IsCollidingWith(floorPlatform->GetObject(),
ignoreTouchingEdges));
if (stillInFloor) {
object->SetY(oldY); // Unable to follow the floor ( too steep ): Go
// back to the original position.
object->SetX(oldX); // And also revert the shift on X axis.
}
} else {
// Floor is flat or get down.
double oldY = object->GetY();
double tentativeStartY = object->GetY() + 1;
object->SetY(roundCoordinates ? GDRound(tentativeStartY)
: tentativeStartY);
int step = 0;
bool noMoreOnFloor = false;
while (!IsCollidingWith(potentialObjects)) {
if (step >
std::abs(requestedDeltaX *
slopeClimbingFactor)) // Slope is too step ( > 50% )
{
noMoreOnFloor = true;
break;
}
// Object was on floor, but no more: Maybe a slope, try to follow it.
object->SetY(object->GetY() + 1);
step++;
}
if (noMoreOnFloor)
object->SetY(oldY); // Unable to follow the floor: Go back to the
// original position. Fall will be triggered next
// tick.
else
object->SetY(object->GetY() -
1); // Floor touched: Go back 1 pixel over.
}
}
// Move the object on Y axis
if (requestedDeltaY != 0) {
double oldY = object->GetY();
object->SetY(object->GetY() + requestedDeltaY);
// Stop when colliding with an obstacle.
while ((requestedDeltaY < 0 &&
IsCollidingWith(potentialObjects,
NULL,
/*excludeJumpThrus=*/true)) // Jumpthru = obstacle
// <=> Never when going
// up
|| (requestedDeltaY > 0 &&
IsCollidingWith(potentialObjects,
overlappedJumpThru))) // Jumpthru = obstacle <=>
// Only if not already
// overlapped when goign
// down
{
jumping = false;
currentJumpSpeed = 0;
if ((requestedDeltaY > 0 && object->GetY() <= oldY) ||
(requestedDeltaY < 0 && object->GetY() >= oldY)) {
object->SetY(oldY); // Unable to move the object without being stuck in
// an obstacle.
break;
}
object->SetY(floor(object->GetY()) + (requestedDeltaY > 0 ? -1 : 1));
}
}
// 3) Update the current floor data for the next tick:
overlappedJumpThru = GetJumpthruCollidingWith(potentialObjects);
if (!isOnLadder) {
// Check if the object is on a floor:
// In priority, check if the last floor platform is still the floor.
double oldY = object->GetY();
object->SetY(object->GetY() + 1);
if (isOnFloor && object->IsCollidingWith(floorPlatform->GetObject(),
ignoreTouchingEdges)) {
// Still on the same floor
floorLastX = floorPlatform->GetObject()->GetX();
floorLastY = floorPlatform->GetObject()->GetY();
} else {
// Check if landing on a new floor: (Exclude already overlapped jump truh)
std::set<PlatformBehavior*> collidingObjects =
GetPlatformsCollidingWith(potentialObjects, overlappedJumpThru);
if (!collidingObjects.empty()) // Just landed on floor
{
isOnFloor = true;
canJump = true;
jumping = false;
currentJumpSpeed = 0;
currentFallSpeed = 0;
floorPlatform = *collidingObjects.begin();
floorLastX = floorPlatform->GetObject()->GetX();
floorLastY = floorPlatform->GetObject()->GetY();
ReleaseGrabbedPlatform(); // Ensure nothing is grabbed.
} else // In the air
{
canJump = false;
isOnFloor = false;
floorPlatform = NULL;
}
}
object->SetY(oldY);
}
// 4) Do not forget to reset pressed keys
leftKey = false;
rightKey = false;
ladderKey = false;
upKey = false;
downKey = false;
jumpKey = false;
releaseKey = false;
// 5) Track the movement
hasReallyMoved = std::abs(object->GetX() - oldX) >= 1;
}
