LibGDX教程：实现敌人定时射击与子弹轨迹控制

import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Vector2;

public class Ghost {
    private Texture topGhostTexture, bottomGhostTexture;
    private Vector2 posTopGhost;
    private Vector2 posBotGhost;
    private int width; // Ghost width
    // ... 其他Ghost相关成员变量 ...

    private Texture bulletTexture; // 子弹纹理
    private Vector2 bulletPosition; // 子弹当前位置
    private float shootTimer; // 射击计时器
    private static final float SHOOT_COOLDOWN = 2.0f; // 射击冷却时间（秒）
    private float bulletSpeed = 200.0f; // 子弹速度（像素/秒）
    private boolean isBulletActive; // 子弹是否处于激活状态（正在飞行）

    public Ghost(float x, float y) {
        // 初始化Ghost纹理和位置
        topGhostTexture = new Texture("Bird.png");
        bottomGhostTexture = new Texture("Bird.png");
        width = topGhostTexture.getWidth();
        posTopGhost = new Vector2(x, y);
        posBotGhost = new Vector2(x, y - 100); // 示例位置

        // 初始化子弹相关
        bulletTexture = new Texture("bullet.png"); // 假设有一个子弹纹理
        bulletPosition = new Vector2(); // 初始化为0,0，将在射击时设置
        shootTimer = 0;
        isBulletActive = false;
    }

    // ... 其他Ghost方法，如reposition ...
}

public class Ghost {
    // ... 成员变量 ...

    /**
     * 更新Ghost的逻辑，包括射击计时和子弹飞行
     * @param dt 两次渲染之间的时间间隔
     */
    public void update(float dt) {
        // 更新射击计时器
        shootTimer += dt;

        // 如果计时器达到冷却时间，则触发射击
        if (shootTimer >= SHOOT_COOLDOWN) {
            shootTimer = 0; // 重置计时器
            shoot();        // 执行射击动作
        }

        // 如果子弹处于激活状态，则更新其飞行轨迹
        if (isBulletActive) {
            updateBulletFlight(dt);
        }
    }

    /**
     * 触发射击动作，初始化子弹状态
     */
    private void shoot() {
        // 设置子弹的初始位置，例如从顶部Ghost的中心射出
        // 假设子弹从顶部Ghost的右侧中心射出
        bulletPosition.set(posTopGhost.x + topGhostTexture.getWidth(), 
                            posTopGhost.y + topGhostTexture.getHeight() / 2);
        isBulletActive = true; // 激活子弹，使其开始飞行
    }

    /**
     * 更新子弹的飞行轨迹
     * @param dt 两次渲染之间的时间间隔
     */
    private void updateBulletFlight(float dt) {
        // 子弹沿X轴向右移动，速度为bulletSpeed像素/秒
        bulletPosition.x += bulletSpeed * dt;

        // 检查子弹是否飞出屏幕，如果飞出则将其禁用
        if (bulletPosition.x > Gdx.graphics.getWidth() + bulletTexture.getWidth()) {
            isBulletActive = false; // 子弹飞出屏幕，设置为非激活状态
        }
        // 也可以添加碰撞检测等逻辑
    }

    // ... 其他Ghost方法 ...
}

import com.badlogic.gdx.Gdx; // 用于获取屏幕宽度

public class Ghost {
    // ... 成员变量和update/shoot/updateBulletFlight方法 ...

    /**
     * 渲染Ghost和其发射的子弹
     * @param batch SpriteBatch实例
     */
    public void render(SpriteBatch batch) {
        batch.draw(topGhostTexture, posTopGhost.x, posTopGhost.y);
        batch.draw(bottomGhostTexture, posBotGhost.x, posBotGhost.y);

        // 如果子弹激活，则绘制子弹
        if (isBulletActive) {
            batch.draw(bulletTexture, bulletPosition.x, bulletPosition.y);
        }
    }

    // 提供getter方法，如果需要在外部访问子弹状态
    public Vector2 getBulletPosition() {
        return bulletPosition;
    }

    public boolean isBulletActive() {
        return isBulletActive;
    }
}

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;

public class MyGdxGame extends ApplicationAdapter {
    SpriteBatch batch;
    Ghost enemyGhost;

    @Override
    public void create () {
        batch = new SpriteBatch();
        enemyGhost = new Ghost(100, Gdx.graphics.getHeight() / 2); // 示例位置
    }

    @Override
    public void render () {
        // 获取dt
        float dt = Gdx.graphics.getDeltaTime();

        // 更新游戏逻辑
        enemyGhost.update(dt);

        Gdx.gl.glClearColor(0, 0, 0, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        // 渲染游戏元素
        batch.begin();
        enemyGhost.render(batch);
        batch.end();
    }

    @Override
    public void dispose () {
        batch.dispose();
        // 记得dispose所有Texture
    }
}