如何实现Projectile碰撞后brickwall逐步切换Sprite并最终消失？

问题说明 #

需求是：当Fireball（Projectile子类）与BrickWall碰撞时，BrickWall逐步切换4张损坏状态的Sprite，最终消失。现有代码无法实现该效果，以下是问题分析和修正方案。

原代码核心问题 #

1. 碰撞后的Sprite切换逻辑错误：碰撞时直接遍历sprites数组，仅在counter==4时设置Sprite，导致瞬间完成切换而非逐步动画，且逻辑仅会设置最后一张Sprite。
2. Wall类继承错误：wall类继承了PApplet，不符合Processing设计逻辑，墙对象不应作为主类实例，绘图应通过传入的PApplet实例完成。
3. BrickWall状态判断失效：wallExist()始终返回true，无法在墙体完全损坏后停止碰撞检测。
4. Sprite字段重复定义：BrickWall中重新定义了sprite字段，覆盖父类的protected字段，导致绘图逻辑异常。
5. 火球移除后的索引问题：for循环中移除火球后未调整索引，会跳过下一个元素的检测。
6. tick方法无帧率控制：BrickWall的tick()方法每次调用都会切换Sprite，导致动画瞬间完成，没有过渡效果。

修正后的完整代码 #

1. Projectile类（无核心问题，保持原样） #

public abstract class Projectile {
    protected int x;
    protected int y;
    protected PImage sprite;

    public Projectile(int x, int y){
        this.x = x;
        this.y = y;
    }
    public void draw(PApplet app) {
        app.image(this.sprite, this.x, this.y);
    }
    public void setSprite(PImage sprite) {
        this.sprite = sprite;
    }
    public abstract void Up();
    public abstract void Down();
    public abstract void Left();
    public abstract void Right();
    public int getX(){
        return this.x;
    }
    public int getY(){
        return this.y;
    }
}

2. Fireball类（无核心问题，保持原样） #

public class Fireball extends Projectile {
    public char dir = 'n';
    public Fireball(int x, int y) {
        super(x, y);
    }

    public void Right() {
        this.x += 4;
    }
    public void Left(){
        this.x -= 4;
    }
    public void Up() {
        this.y -= 4;
    }
    public void Down() {
        this.y += 4;
    }
}

3. 修正Wall父类（移除PApplet继承） #

import processing.core.PImage;
import processing.core.PApplet;

public abstract class Wall { // 类名首字母大写，符合Java规范
    protected int x;
    protected int y;
    protected PImage sprite;
    protected int size;

    public Wall(int x, int y){
        this.x = x;
        this.y = y;
    }

    public void setSprite(PImage sprite) {
        this.sprite = sprite;
    }

    public void draw(PApplet app){
        if(sprite != null){ // 为空时不绘制
            app.image(this.sprite, this.x, this.y);
        }
    }

    public int getX(){
        return this.x;
    }

    public int getY(){
        return this.y;
    }

    public abstract void tick();
    public abstract boolean wallExist();
}

4. 修正BrickWall类（修复状态控制和动画逻辑） #

import processing.core.PImage;

public class BrickWall extends Wall { // 类名首字母大写
    public int damageCounter = 0;
    public int animationTimer = 0;
    public static final int ANIMATION_DELAY = 15; // 每15帧切换一次Sprite
    protected PImage[] destroyedSprites; // 重命名更清晰
    private boolean isDestroying = false;

    public BrickWall(int x, int y, PImage[] destroyedSprites){
        super(x, y);
        this.destroyedSprites = destroyedSprites;
        // 初始化墙体为完整状态（假设destroyedSprites[0]是完整Sprite，1-3是损坏过程）
        this.sprite = destroyedSprites[0];
    }

    @Override
    public boolean wallExist(){
        return sprite != null;
    }

    // 触发墙体损坏流程
    public void startDestroying(){
        if(!isDestroying){
            isDestroying = true;
            damageCounter = 1; // 从第一张损坏Sprite开始
        }
    }

    @Override
    public void tick(){
        if(!isDestroying) return;

        animationTimer++;
        if(animationTimer >= ANIMATION_DELAY){
            animationTimer = 0;
            if(damageCounter < destroyedSprites.length){
                this.sprite = destroyedSprites[damageCounter];
                damageCounter++;
            } else {
                // 所有损坏Sprite切换完成，墙体消失
                this.sprite = null;
                isDestroying = false;
            }
        }
    }
}

5. 修正主循环的碰撞检测逻辑 #

// 假设这是Processing主类中的draw()或update()方法内的代码
for(int i = 0; i < this.fireballs.size(); i++){
    Fireball fireball = fireballs.get(i);
    if(this.brickWall.wallExist()){
        // 基于精灵实际尺寸的碰撞检测，更准确
        int wallWidth = brickWall.sprite.width;
        int wallHeight = brickWall.sprite.height;
        int fireballWidth = fireball.sprite.width;
        int fireballHeight = fireball.sprite.height;

        boolean isColliding = 
            fireball.getX() < brickWall.getX() + wallWidth &&
            fireball.getX() + fireballWidth > brickWall.getX() &&
            fireball.getY() < brickWall.getY() + wallHeight &&
            fireball.getY() + fireballHeight > brickWall.getY();

        if(isColliding){
            fireballs.remove(i);
            i--; // 移除元素后调整索引，避免跳过下一个火球
            this.brickWall.startDestroying(); // 触发墙体损坏动画
        }
    }
}

// 主循环中必须调用brickWall的tick()方法更新动画
this.brickWall.tick();
// 绘制墙体
this.brickWall.draw(this);

关键修正点说明 #

• 动画控制：通过animationTimer和ANIMATION_DELAY控制Sprite切换帧率，实现逐步过渡效果。
• 状态管理：用isDestroying标记墙体是否处于损坏状态，避免重复触发。
• 碰撞检测优化：基于精灵实际尺寸判断碰撞，替代固定像素范围，准确性更高。
• 类结构修正：Wall类不再继承PApplet，遵循Processing依赖注入的绘图方式。
• 索引修正：移除火球后递减索引，避免遍历过程中遗漏元素。

内容的提问来源于stack exchange，提问作者Minh Long Duong