SFML：子弹停止

Question

我对SFML和C++非常新颖。我的问题是我成功地向老鼠发射了炮弹。但是当我移动鼠标时，射弹也会移动。

编辑：

好吧我解决了我以前的问题。然而，弹丸在到达鼠标位置时停止。子弹如何继续比目的地更远？

代码：

if (isFiring == true) { 

     sf::Vector2f startPos = sf::Vector2f(myPipe.getX(), myPipe.getY()); 
     sf::Vector2i mousePos = sf::Mouse::getPosition(window); 
     sf::Vector2f endPos = sf::Vector2f(mousePos.x, mousePos.y); 

     double projSpeed{0.3}; 
     //float projSpeed = projSpeed * (myPipe.getY() - mousePos.y)/100; 
     Projectile newProjectile(20, startPos, endPos, projSpeed); 
     projVec.push_back(newProjectile); 
     isFiring = false; 
    } 

    for (int i = 0; i < projVec.size(); i++) { 

     projVec[i].fire(delta.asMilliseconds()); 
     projVec[i].draw(window); 
     clock.restart(); 

    } 

防火功能：

void fire(float delta) { 
    sf::Vector2f pos = projectile.getPosition(); 
    float veloX = (_end.x - pos.x); 
    float veloY = (_end.y - pos.y); 
    float distance = sqrt((veloX*veloX + veloY * veloY)); 

    float dx = veloX/distance; 
    float dy = veloY/distance; 
    projectile.move(dx * delta, dy * delta); 
} 

还有一个问题，我在做它用增量乘以是否正确？子弹真的很渺茫和怪异。

Answer 1

（原答复:)

我没有足够的信誉发表评论，因此我得把它放在这儿......

所以，如果我理解正确的话，你是说你想要朝着鼠标的位置射击弹丸，但不希望它们一旦被解雇就追随它的位置？在这种情况下：

我看到你有代码在那个for-loop里面画出射弹，这让我相信你正在不断地调用循环。但是同样的循环也包含用于射弹的代码，这意味着你也在不断地调用这个“火”代码。因此，您在每次循环迭代中将射弹转向当前鼠标位置，这意味着它们将始终遵循当前鼠标位置。

你应该做的是移动代码来拍摄投射物并且只调用一次（你只能投射一次投射物，对吗？）所以一个投射物的方向矢量不会经常改变，导致你陈述的问题。

并确保始终分离逻辑和渲染。理想情况下，您应该以固定的时间间隔更新物理（例如弹丸更新），以便游戏在所有机器上运行相同，并分别绘制所有东西。

如果你想在弹丸始终跟随鼠标，你可以使用这个（半伪）代码（我用我的游戏之一这段代码）：

sf::Vector2f normalizedVector = normalize(mousePos - projectilePos); 
normalizedVector.x *= speed * deltaTime; 
normalizedVector.y *= speed * deltaTime; 

projectile.move(normalizedVector); 

---

（编辑:)

我做了一个快速的示例项目，工程。这并没有使用你的所有代码，但希望能给你一个想法如何做。

下面是一个简短的视频显示什么下面的代码所做的：https://webmshare.com/play/jQqvd

的main.cpp

#include <SFML/Graphics.hpp> 

#include "projectile.h" 

int main() { 
    const sf::FloatRect viewRect(0.0f, 0.0f, 800.0f, 600.0f); 

    sf::RenderWindow window(sf::VideoMode(viewRect.width, viewRect.height), "Test"); 
    window.setFramerateLimit(120); 
    window.setVerticalSyncEnabled(false); 
    window.setKeyRepeatEnabled(false); 

    sf::Clock deltaClock; 
    const sf::Time timePerFrame = sf::seconds(1.0f/60.0f); 
    sf::Time timeSinceLastUpdate = sf::Time::Zero; 

    std::vector<Projectile> projectiles; 

    while (window.isOpen()) { 

    timeSinceLastUpdate += deltaClock.restart(); 

    // process events 
    { 
     sf::Event evt; 
     while (window.pollEvent(evt)) { 
     switch (evt.type) { 
      case sf::Event::Closed: { window.close(); } break; 
      // shoot with left mouse button 
      case sf::Event::MouseButtonPressed: { switch (evt.mouseButton.button) { case sf::Mouse::Button::Left: { 
      const sf::Vector2f center(viewRect.left + viewRect.width/2, viewRect.top + viewRect.height/2); 
      const sf::Vector2f mousePos(window.mapPixelToCoords(sf::Mouse::getPosition(window))); 
      const float angle = atan2(mousePos.y - center.y, mousePos.x - center.x); 
      projectiles.push_back(Projectile(center, angle)); 
      } break; default: {} break; } } break; 
      default: {} break; 
     } 
     } 
    } 

    // update 
    { 
     while (timeSinceLastUpdate > timePerFrame) { 
     timeSinceLastUpdate -= timePerFrame; 
     // update projectiles 
     { 
      for (std::size_t i = 0; i < projectiles.size(); ++i) { 
      Projectile &proj = projectiles[i]; 
      proj.update(timePerFrame); 
      if (!viewRect.intersects(proj.getBoundingBox())) { proj.destroy(); } 
      } 
      projectiles.erase(std::remove_if(projectiles.begin(), projectiles.end(), [](Projectile const &p) { return p.getCanBeRemoved(); }), projectiles.end()); 
     } 
     } 
    } 

    // render 
    { 
     window.clear(); 
     for (std::size_t i = 0; i < projectiles.size(); ++i) { 
     window.draw(projectiles[i]); 
     } 
     window.display(); 
    } 

    } 

    return EXIT_SUCCESS; 
} 

弹。H：

#ifndef PROJECTILE_H_INCLUDED 
#define PROJECTILE_H_INCLUDED 

#include <SFML/Graphics.hpp> 

class Projectile : public sf::Drawable { 
public: 
    Projectile(); 
    Projectile(const sf::Vector2f pos, const float angle); 
    virtual ~Projectile(); 

    const bool &getCanBeRemoved() const; 
    const sf::FloatRect &getBoundingBox() const; 

    void destroy(); 
    void update(const sf::Time dt); 

private: 
    virtual void draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const; 

    bool canBeRemoved_; 
    sf::FloatRect boundingBox_; 
    float angle_; 
    float speed_; 

    sf::RectangleShape shape_; 

}; 

#endif 

projectile.cpp：

#include "projectile.h" 

Projectile::Projectile() : 
    canBeRemoved_(true), 
    boundingBox_(sf::FloatRect()), 
    angle_(0.0f), 
    speed_(0.0f) 
{ 
} 

Projectile::Projectile(const sf::Vector2f pos, const float angle) { 
    canBeRemoved_ = false; 
    boundingBox_ = sf::FloatRect(pos, sf::Vector2f(10.0f, 10.0f)); 
    angle_ = angle; 
    speed_ = 0.5f; 

    shape_.setPosition(sf::Vector2f(boundingBox_.left, boundingBox_.top)); 
    shape_.setSize(sf::Vector2f(boundingBox_.width, boundingBox_.height)); 
    shape_.setFillColor(sf::Color(255, 255, 255)); 
} 

Projectile::~Projectile() { 
} 

const bool &Projectile::getCanBeRemoved() const { 
    return canBeRemoved_; 
} 

const sf::FloatRect &Projectile::getBoundingBox() const { 
    return boundingBox_; 
} 

void Projectile::destroy() { 
    canBeRemoved_ = true; 
} 

void Projectile::update(const sf::Time dt) { 
    boundingBox_.left += static_cast<float>(std::cos(angle_) * speed_ * dt.asMilliseconds()); 
    boundingBox_.top += static_cast<float>(std::sin(angle_) * speed_ * dt.asMilliseconds()); 
    shape_.setPosition(boundingBox_.left, boundingBox_.top); 
} 

void Projectile::draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const { 
    renderTarget.draw(shape_); 
}