如何在SFML中实现基于网格的移动？求助优化32x32网格移动

Hey there! Let's tackle that choppy grid movement issue. Looking at your code snippet, the main problems are likely frame-rate dependent movement (no delta time) and pixel-by-pixel stepping which can look janky. Here's a revised approach that fixes both and gives you smooth, consistent movement:

First, Update Your Player Class Variables #

Add these to your player class (adjust as needed):

private:
    bool isMoving = false;          // Tracks if we're in the middle of a tile move
    sf::Vector2f targetPosition;    // The grid-aligned position we're moving towards
    float moveSpeed = 128.f;        // Pixels per second (adjust for faster/slower movement)
    int direction = 0;              // 1=Up, 2=Right, etc.

Revised Movement Update Function #

This version uses delta time to keep movement consistent across different frame rates, and smooth interpolation towards the target tile:

void player::updateMovement(float deltaTime) {
    // If we're not moving, check for input to start a new tile movement
    if (!isMoving) {
        sf::Vector2f currentPos = getPosition();
        
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
            targetPosition = {currentPos.x, currentPos.y - 32.f};
            direction = 1;
            isMoving = true;
        } 
        else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right) && canMoveRight) {
            targetPosition = {currentPos.x + 32.f, currentPos.y};
            direction = 2;
            isMoving = true;
        }
        else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
            targetPosition = {currentPos.x, currentPos.y + 32.f};
            direction = 3;
            isMoving = true;
        }
        else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left) && canMoveLeft) {
            targetPosition = {currentPos.x - 32.f, currentPos.y};
            direction = 4;
            isMoving = true;
        }
    }
    // If we are moving, interpolate towards the target tile
    else {
        sf::Vector2f directionVector = targetPosition - getPosition();
        float distanceToTarget = std::sqrt(directionVector.x * directionVector.x + directionVector.y * directionVector.y);
        
        // If we still have distance to cover
        if (distanceToTarget > 0.f) {
            // Normalize the direction vector (so we move at the same speed in all directions)
            sf::Vector2f moveDirection = directionVector / distanceToTarget;
            // Calculate how much we can move this frame
            sf::Vector2f moveStep = moveDirection * moveSpeed * deltaTime;
            
            // Check if moving this step would overshoot the target
            if (moveStep.x * moveStep.x + moveStep.y * moveStep.y >= distanceToTarget * distanceToTarget) {
                // Snap to the exact grid position to avoid floating point errors
                setPosition(targetPosition);
                isMoving = false;
            } else {
                // Move incrementally towards the target
                move(moveStep);
            }
        } else {
            // We're already at the target, stop moving
            isMoving = false;
        }
    }
}

How to Use This in Your Main Loop #

Don't forget to pass delta time from your main game loop—this is crucial for consistent speed:

sf::Clock clock;
while (window.isOpen()) {
    sf::Time deltaTime = clock.restart();
    float dt = deltaTime.asSeconds();
    
    // ... handle events ...
    
    // Update player movement with delta time
    player.updateMovement(dt);
    
    // ... draw everything ...
}

Key Improvements Explained #

• Delta Time Integration: By multiplying moveSpeed by deltaTime, your player moves the same distance per second regardless of frame rate. No more fast/slow movement on different systems!
• Smooth Interpolation: Instead of moving 1 pixel per frame, we calculate a smooth step towards the target tile. This makes movement look fluid rather than choppy.
• Grid Snapping: When we're close enough to the target, we snap directly to the grid position to avoid tiny floating-point offsets that can cause visual glitches.
• Clear State Management: The isMoving flag ensures we don't start a new movement until the current one finishes, which is perfect for tile-based games where you want to move one tile at a time.

Quick Tips #

• Adjust moveSpeed to get the feel you want: higher values mean faster tile traversal (try 96-192 pixels per second as a starting point).
• Make sure your canMoveRight/canMoveLeft checks are working correctly to prevent moving into walls or obstacles.
• If you want to add animations, trigger them when isMoving becomes true and stop them when it becomes false.

内容的提问来源于stack exchange，提问作者sfmlishard