コード例 #1
0
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;
}
コード例 #2
0
void PlatformerObjectAutomatism::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>(scene.GetElapsedTime())/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 && sf::Keyboard::isKeyPressed( sf::Keyboard::Left );
    rightKey |= !ignoreDefaultControls && sf::Keyboard::isKeyPressed( sf::Keyboard::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<PlatformAutomatism*> potentialObjects = GetPotentialCollidingObjects(std::max(requestedDeltaX, maxFallingSpeed));
    std::set<PlatformAutomatism*> 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;
    }

    //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.IsFirstLoop() )
        object->SetY(object->GetY()+oldHeight-object->GetHeight());

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

    //Move the object on x axis.
    double oldX = object->GetX();
    if ( requestedDeltaX != 0 )
    {
        object->SetX(object->GetX()+requestedDeltaX);
        //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);
            }

            object->SetX(floor(object->GetX())+(requestedDeltaX > 0 ? -1 : 1));
            currentSpeed = 0; //Collided with a wall
        }
    }

    //2) Y axis:

    //Go on a ladder
    ladderKey |= !ignoreDefaultControls && sf::Keyboard::isKeyPressed(sf::Keyboard::Up);
    if (ladderKey && IsOverlappingLadder(potentialObjects))
    {
        canJump = true;
        isOnFloor = false;
        floorPlatform = NULL;
        currentJumpSpeed = 0;
        currentFallSpeed = 0;
        isOnLadder = true;
    }

    if ( isOnLadder )
    {
        upKey |= !ignoreDefaultControls && sf::Keyboard::isKeyPressed(sf::Keyboard::Up);
        downKey |= !ignoreDefaultControls && sf::Keyboard::isKeyPressed(sf::Keyboard::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)
    {
        currentFallSpeed += gravity*timeDelta;
        if ( currentFallSpeed > maxFallingSpeed ) currentFallSpeed = maxFallingSpeed;

        requestedDeltaY += currentFallSpeed*timeDelta;
        requestedDeltaY = std::min(requestedDeltaY, maxFallingSpeed*timeDelta);
    }

    //Jumping
    jumpKey |= !ignoreDefaultControls && (sf::Keyboard::isKeyPressed( sf::Keyboard::LShift ) || sf::Keyboard::isKeyPressed( sf::Keyboard::RShift ) );
    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;
        //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()) )
        {
            //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(abs(requestedDeltaX*slopeClimbingFactor)) ) //Slope is too step ( > max angle )
                {
                    object->SetY(object->GetY()-(abs(requestedDeltaX*slopeClimbingFactor)-(double)step)); //Try to add the decimal part.
                    if ( object->IsCollidingWith(floorPlatform->GetObject()) )
                        stillInFloor = true; //Too steep.

                    break;
                }

                //Try to get out of the floor.
                object->SetY(object->GetY()-1);
                step++;
            }
            while ( object->IsCollidingWith(floorPlatform->GetObject() ) );

            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();
            object->SetY(object->GetY()+1);
            int step = 0;
            bool noMoreOnFloor = false;
            while ( !IsCollidingWith(potentialObjects) )
            {
                if ( step > 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() ) )
        {
            //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<PlatformAutomatism*> collidingObjects = GetPlatformsCollidingWith(potentialObjects, overlappedJumpThru);
            if ( !collidingObjects.empty() ) //Just landed on floor
            {
                isOnFloor = true;
                canJump = true;
                jumping = false;
                currentJumpSpeed = 0;
                floorPlatform = *collidingObjects.begin();
                floorLastX = floorPlatform->GetObject()->GetX();
                floorLastY = floorPlatform->GetObject()->GetY();
                currentFallSpeed = 0;
            }
            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;

    //5) Track the movement
    hasReallyMoved = abs(object->GetX()-oldX) >= 1;
}