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); }