Question

我试图管理游戏中的能量提升。

让我们说我有7个平台＆＃39;在我的游戏中，我想随机产生每个平台最多1个的加电（这是一个垂直滚动的无限＆＃39;类型的游戏）。

所以，我有5种不同的电源，我可以做这样的事情（PowerUp是一个有效的类） - ＆＃39; 7＆＃39;这里传递给构造函数的是各个对象中的精灵数量（即，它们是精灵批次） - 7因此我们可以在每个平台上放置一个并根据需要打开和关闭它们（我有一个＆＃39 ; drawable＆＃39;布尔数组，允许我为批处理中的单个精灵执行此操作。）

PowerUP powerUp1 = new PowerUp(7);
PowerUP powerUp2 = new PowerUp(7);
PowerUP powerUp3 = new PowerUp(7);
PowerUP powerUp4 = new PowerUp(7);
PowerUP powerUp5 = new PowerUp(7);

然后我只需将它们添加到要绘制的对象列表中：

powerUpsList.add(powerUp1); //etc...

我可以这样做：

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

    if (powerUpsList.get(i).hasBeenCollected();
            powerUpsList.get(i).runPowerUp(); //Carry out the specific code for this powerup if it has been activated
}

我唯一的问题是，我实际上创造了35个精灵（5个批次的7个） - 当我添加更多的powreup时更多。我将仅一次最多使用7个精灵。

因此，我尝试做的事情是这样的：

 powerUp = new PowerUp(7);

然后，当我产生一个上电后，在它被随机输入后（例如，powerUp1），而不是简单地在相关批次中打开相关的，我正在改变特定的属性批处理内的精灵。因此，如果spawn时的平台编号是7，我将批处理中第7个sprite的框架设置为相关的，然后我想运行代码。

但是，在运行相关逻辑之前，我似乎必须使用switch语句来打开对象枚举。

switch (PowerUpType){

    case PowerUpType.powerup1: {logicForPowerUp1;break}
    case PowerUpType.powerup2: {logicForPowerUp2;break}

    //etc

}

有没有什么方法可以根据使用这批7个精灵的对象的枚举干净地运行逻辑？我似乎无法找到一种方法来做这个并使用开关，老实说，我发现它很乱。

Answer 1

你可以像这样对枚举进行一些修改，假设logicForPowerUp1 / logicForPowerUp2等是具有switch语句的类中的方法

public class PowerUpUser {
    private PowerUpType powerUpType;

    public PowerUpUser(PowerUpType powerUpType) {
        this.powerUpType = powerUpType;
    }

    public void usePowerUp() {
        // this replaces the switch statement
        powerUpType.execute(this);
    }

    private void logicForPowerUp1() {

    }

    private void logicForPowerUp2() {

    }

    private enum PowerUpType {
        PowerUp1 {
            @Override
            public void execute(PowerUpUser powerUpUser) {
                powerUpUser.logicForPowerUp1();
            }
        },
        PowerUp2 {
            @Override
            public void execute(PowerUpUser powerUpUser) {
                powerUpUser.logicForPowerUp2();
            }
        };

        public abstract void execute(PowerUpUser powerUpUser);
    }
}

Answer 2

您可以对powerup进行子类化，然后使用静态工厂返回它们。由于方法覆盖，您可以执行以下操作： abstract public class BasePowerUp { abstract public void calculatePowerUp(); abstract public void performPowerUp(GameState state); abstract public void handleFrameBuffer(FrameBuffer fb); } //arbitrary methods, fill in what you would do... public PowerUp1 extends BasePowerUp { @Override public void calculatePowerUp() { /* ... */ } // and so on }

然后，无论在哪里，也许在BasePowerUp中都有如下方法： public static BasePowerUp getPowerUp(int which) { switch (which) { case 1: return new PowerUp1(); //etc } }

如果你正确设置方法，那么每当你调用calculatePowerUp()时，都会调用正确的实现！

根据对象的“类型”在对象中运行不同的方法

2 个答案: