bool RuntimeObject::CursorOnObject(RuntimeScene &scene, bool) {
RuntimeLayer &theLayer = scene.GetRuntimeLayer(layer);
auto insideObject = [this](const sf::Vector2f &pos) {
return GetDrawableX() <= pos.x && GetDrawableX() + GetWidth() >= pos.x &&
GetDrawableY() <= pos.y && GetDrawableY() + GetHeight() >= pos.y;
};
for (std::size_t cameraIndex = 0; cameraIndex < theLayer.GetCameraCount();
++cameraIndex) {
const auto &view = theLayer.GetCamera(cameraIndex).GetSFMLView();
sf::Vector2f mousePos = scene.renderWindow->mapPixelToCoords(
scene.GetInputManager().GetMousePosition(), view);
if (insideObject(mousePos)) return true;
auto &touches = scene.GetInputManager().GetAllTouches();
for (auto &it : touches) {
sf::Vector2f touchPos =
scene.renderWindow->mapPixelToCoords(it.second, view);
if (insideObject(touchPos)) return true;
}
}
return false;
}
double GD_API GetCursorYPosition(RuntimeScene &scene,
const gd::String &layer,
std::size_t camera) {
if (scene.GetRuntimeLayer(layer).GetCameraCount() == 0) return 0;
if (camera >= scene.GetRuntimeLayer(layer).GetCameraCount()) camera = 0;
// Get view, and compute mouse position
const sf::View &view =
scene.GetRuntimeLayer(layer).GetCamera(camera).GetSFMLView();
return scene.renderWindow
->mapPixelToCoords(scene.GetInputManager().GetMousePosition(), view)
.y;
}
bool RuntimeSpriteObject::CursorOnObject(RuntimeScene & scene, bool accurate)
{
#if defined(ANDROID) //TODO: Accurate test leads to strange result with touches.
accurate = false;
#endif
RuntimeLayer & theLayer = scene.GetRuntimeLayer(layer);
auto insideObject = [this, accurate](const sf::Vector2f & pos) {
if (GetDrawableX() <= pos.x
&& GetDrawableX() + GetWidth() >= pos.x
&& GetDrawableY() <= pos.y
&& GetDrawableY() + GetHeight() >= pos.y)
{
int localX = static_cast<int>( pos.x - GetDrawableX() );
int localY = static_cast<int>( pos.y - GetDrawableY() );
return ( !accurate || GetCurrentSprite().GetSFMLTexture()->image.getPixel(localX , localY).a != 0);
}
};
for (std::size_t cameraIndex = 0;cameraIndex < theLayer.GetCameraCount();++cameraIndex)
{
const auto & view = theLayer.GetCamera(cameraIndex).GetSFMLView();
sf::Vector2f mousePos = scene.renderWindow->mapPixelToCoords(
scene.GetInputManager().GetMousePosition(), view);
if (insideObject(mousePos)) return true;
auto & touches = scene.GetInputManager().GetAllTouches();
for(auto & it : touches)
{
sf::Vector2f touchPos = scene.renderWindow->mapPixelToCoords(it.second, view);
if (insideObject(touchPos)) return true;
}
}
return false;
}
bool RuntimeObject::CursorOnObject(RuntimeScene & scene, bool)
{
RuntimeLayer & theLayer = scene.GetRuntimeLayer(layer);
for (std::size_t cameraIndex = 0;cameraIndex < theLayer.GetCameraCount();++cameraIndex)
{
sf::Vector2f mousePos = scene.renderWindow->mapPixelToCoords(
scene.GetInputManager().GetMousePosition(), theLayer.GetCamera(cameraIndex).GetSFMLView());
if (GetDrawableX() <= mousePos.x
&& GetDrawableX() + GetWidth() >= mousePos.x
&& GetDrawableY() <= mousePos.y
&& GetDrawableY() + GetHeight() >= mousePos.y)
{
return true;
}
}
return false;
}
bool RuntimeSpriteObject::CursorOnObject(RuntimeScene & scene, bool accurate)
{
RuntimeLayer & theLayer = scene.GetRuntimeLayer(layer);
for (std::size_t cameraIndex = 0;cameraIndex < theLayer.GetCameraCount();++cameraIndex)
{
sf::Vector2f mousePos = scene.renderWindow->mapPixelToCoords(
scene.GetInputManager().GetMousePosition(), theLayer.GetCamera(cameraIndex).GetSFMLView());
if (GetDrawableX() <= mousePos.x
&& GetDrawableX() + GetWidth() >= mousePos.x
&& GetDrawableY() <= mousePos.y
&& GetDrawableY() + GetHeight() >= mousePos.y)
{
int localX = static_cast<int>( mousePos.x - GetDrawableX() );
int localY = static_cast<int>( mousePos.y - GetDrawableY() );
return ( !accurate || GetCurrentSprite().GetSFMLTexture()->image.getPixel( localX , localY ).a != 0 );
}
}
return false;
}
void TopDownMovementRuntimeBehavior::DoStepPreEvents(RuntimeScene& scene) {
// Get the player input:
leftKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Left");
rightKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Right");
downKey |=
!ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Down");
upKey |= !ignoreDefaultControls && scene.GetInputManager().IsKeyPressed("Up");
int direction = -1;
float directionInRad = 0;
float directionInDeg = 0;
if (!allowDiagonals) {
if (upKey && !downKey)
direction = 6;
else if (!upKey && downKey)
direction = 2;
if (!upKey && !downKey) {
if (leftKey && !rightKey)
direction = 4;
else if (!leftKey && rightKey)
direction = 0;
}
} else {
if (upKey && !downKey) {
if (leftKey && !rightKey)
direction = 5;
else if (!leftKey && rightKey)
direction = 7;
else
direction = 6;
} else if (!upKey && downKey) {
if (leftKey && !rightKey)
direction = 3;
else if (!leftKey && rightKey)
direction = 1;
else
direction = 2;
} else {
if (leftKey && !rightKey)
direction = 4;
else if (!leftKey && rightKey)
direction = 0;
}
}
// Update the speed of the object
float timeDelta =
static_cast<double>(object->GetElapsedTime(scene)) / 1000000.0;
if (direction != -1) {
directionInRad = static_cast<float>(direction) * gd::Pi() / 4.0;
directionInDeg = static_cast<float>(direction) * 45;
xVelocity += acceleration * timeDelta * cos(directionInRad);
yVelocity += acceleration * timeDelta * sin(directionInRad);
} else {
directionInRad = atan2(yVelocity, xVelocity);
directionInDeg = atan2(yVelocity, xVelocity) * 180.0 / gd::Pi();
bool xVelocityWasPositive = xVelocity >= 0;
bool yVelocityWasPositive = yVelocity >= 0;
xVelocity -= deceleration * timeDelta * cos(directionInRad);
yVelocity -= deceleration * timeDelta * sin(directionInRad);
if ((xVelocity > 0) ^ xVelocityWasPositive) xVelocity = 0;
if ((yVelocity > 0) ^ yVelocityWasPositive) yVelocity = 0;
}
float speed = sqrt(xVelocity * xVelocity + yVelocity * yVelocity);
if (speed > maxSpeed) {
xVelocity = maxSpeed * cos(directionInRad);
yVelocity = maxSpeed * sin(directionInRad);
}
angularSpeed = angularMaxSpeed; // No acceleration for angular speed for now
// Position object
object->SetX(object->GetX() + xVelocity * timeDelta);
object->SetY(object->GetY() + yVelocity * timeDelta);
// Also update angle if needed
if ((xVelocity != 0 || yVelocity != 0)) {
angle = directionInDeg;
if (rotateObject) {
float angularDiff = GDpriv::MathematicalTools::angleDifference(
object->GetAngle(), directionInDeg + angleOffset);
bool diffWasPositive = angularDiff >= 0;
float newAngle = object->GetAngle() + (diffWasPositive ? -1.0 : 1.0) *
angularSpeed * timeDelta;
if ((GDpriv::MathematicalTools::angleDifference(
newAngle, directionInDeg + angleOffset) > 0) ^
diffWasPositive)
newAngle = directionInDeg + angleOffset;
object->SetAngle(newAngle);
if (object->GetAngle() !=
newAngle) // Objects like sprite in 8 directions
// does not handle small increments...
object->SetAngle(
directionInDeg +
angleOffset); //...so force them to be in the path angle anyway.
}
}
leftKey = false;
rightKey = false;
upKey = false;
downKey = false;
}
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;
}
int GD_API GetMouseWheelDelta(RuntimeScene &scene) {
return scene.GetInputManager().GetMouseWheelDelta();
}
bool GD_API MouseButtonReleased(RuntimeScene &scene, const gd::String &button) {
return scene.GetInputManager().IsMouseButtonReleased(button);
}
void GD_API CenterCursorVertically(RuntimeScene &scene) {
sf::Mouse::setPosition(
sf::Vector2i(scene.GetInputManager().GetMousePosition().x,
scene.renderWindow->getSize().y / 2),
*scene.renderWindow);
}
gd::String GD_API LastPressedKey(RuntimeScene & scene)
{
return scene.GetInputManager().GetLastPressedKey();
}
bool GD_API AnyKeyIsPressed(RuntimeScene & scene)
{
return scene.GetInputManager().AnyKeyIsPressed();
}
bool GD_API WasKeyReleased(RuntimeScene & scene, gd::String key)
{
return scene.GetInputManager().WasKeyReleased(key);
}
bool GD_API IsKeyPressed(RuntimeScene & scene, gd::String key)
{
return scene.GetInputManager().IsKeyPressed(key);
}
