塔防游戏带射程的子弹发射逻辑及代码实现技术问询

Alright, let's get your tower defense shooting logic sorted out so towers only fire at enemies within their range. I'll walk through the missing pieces and update your code to include proper range checks, cooldown timing, and bullet targeting.

Key Logic We Need to Add #

First, let's outline the critical pieces your current code is missing:

• A range property for each tower (so we know how far it can shoot)
• A cooldown timer to control how often towers fire (no spamming bullets every frame!)
• Range detection to check if an enemy is within the tower's reach before firing
• Bullet targeting so bullets actually move toward the enemy
• Cleanup for bullets once they hit their target or go out of bounds

Updated Code Implementation #

1. First, Update Your Tower Class #

Make sure your Tower class has a range attribute and getter:

class Tower {
public:
    // Your existing methods (getPosX, getPosY, etc.)
    float getRange() const { return range; } // New: Getter for tower range

    // Constructor example (initialize range here)
    Tower(float x, float y, float towerRange) 
        : pos(x, y), range(towerRange) {}

private:
    sf::Vector2f pos;
    float range; // New: Stores how far the tower can shoot (e.g., 150.0f)
    // Your other tower properties (row, texture, etc.)
};

2. Update the Tower_shot Class for Targeting #

Give your bullet class a target position and movement logic:

class Tower_shot {
public:
    sf::Sprite tower_shot;
    float startingX, startingY;
    sf::Vector2f targetPos; // New: Where the bullet is heading
    float speed; // New: How fast the bullet moves

    // Updated constructor to accept start position and target
    Tower_shot(sf::Texture* texture, sf::Vector2u frameCount, int row, sf::Vector2f startPos, sf::Vector2f target) 
        : targetPos(target), speed(6.0f) { // Adjust speed as needed
        tower_shot.setTexture(*texture);
        // Your existing frame setup code here
        tower_shot.setPosition(startPos);
        startingX = startPos.x;
        startingY = startPos.y;
    }

    // New: Update bullet movement each frame
    void update(float deltaTime) {
        // Calculate direction to target
        sf::Vector2f direction = targetPos - tower_shot.getPosition();
        float distance = sqrt(direction.x * direction.x + direction.y * direction.y);
        
        if (distance > 0) {
            direction /= distance; // Normalize direction to move at constant speed
            tower_shot.move(direction * speed * deltaTime);
        }
    }
};

3. Main Shooting Logic with Range Checks #

Add a cooldown timer to control fire rate, then only generate bullets for towers that have enemies in range:

// In your game loop setup (outside the update loop)
float shotCooldown = 0.0f;
const float COOLDOWN_TIME = 1.2f; // Adjust how often towers fire (1.2 seconds here)

// Inside your game's update loop (with deltaTime being time since last frame)
shotCooldown += deltaTime;

if (shotCooldown >= COOLDOWN_TIME) {
    shotCooldown = 0.0f; // Reset cooldown

    // Loop through each tower
    for (auto& tower : towerVec) {
        sf::Vector2f towerPos(tower.getPosX(), tower.getPosY());
        float towerRange = tower.getRange();
        sf::Vector2f targetPos;
        bool hasValidTarget = false;

        // Check each enemy to see if it's in range
        for (auto& enemy : enemyVec) {
            sf::Vector2f enemyPos(enemy.getPosX(), enemy.getPosY());
            
            // Use squared distance to avoid expensive sqrt() call (better performance)
            float distanceSquared = pow(enemyPos.x - towerPos.x, 2) + pow(enemyPos.y - towerPos.y, 2);
            float rangeSquared = pow(towerRange, 2);

            if (distanceSquared <= rangeSquared) {
                targetPos = enemyPos;
                hasValidTarget = true;
                break; // Lock onto first enemy in range (remove break to target all)
            }
        }

        // Only spawn a bullet if there's an enemy in range
        if (hasValidTarget) {
            Tower_shot newShot(&bulletTexture, sf::Vector2u(1, 3), tower.row, towerPos, targetPos);
            tshotVec.push_back(newShot);
        }
    }
}

4. Update and Clean Up Bullets #

Make sure bullets move each frame and get removed when they hit their target:

// Inside your update loop (after handling shooting)
for (auto it = tshotVec.begin(); it != tshotVec.end(); ) {
    it->update(deltaTime);

    // Check if bullet has reached target (or is close enough)
    sf::Vector2f currentPos = it->tower_shot.getPosition();
    float distanceToTarget = sqrt(pow(currentPos.x - it->targetPos.x, 2) + pow(currentPos.y - it->targetPos.y, 2));
    
    if (distanceToTarget < 4.0f) { // Consider hit when within 4 pixels
        // Add enemy damage logic here (e.g., enemy.takeDamage(10))
        it = tshotVec.erase(it); // Remove bullet from list
    } else {
        ++it;
    }
}

// Draw bullets in your render loop
for (auto& shot : tshotVec) {
    window.draw(shot.tower_shot);
}

Key Explanations #

• Squared Distance Check: Using distanceSquared <= rangeSquared avoids the sqrt() function, which is slower—critical when you have lots of towers and enemies.
• Cooldown Timer: Prevents towers from spawning hundreds of bullets per frame, keeping the game balanced and performant.
• Normalized Direction: Ensures bullets move at a constant speed toward their target, regardless of how far away the enemy is.
• Bullet Cleanup: Removing bullets after they hit prevents your tshotVec from growing indefinitely, which would cause memory issues over time.

You can extend this further by adding logic to target the closest enemy, lowest-health enemy, or even multiple enemies per tower shot—just adjust the enemy selection loop!

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