Question

我正在用Java编写RTS游戏并遇到了一些多态问题。为了描述我的问题，我将在游戏中列出一些对象/类:(我将在括号内说明他们每个人应该做什么）

坦克（可以移动，可以攻击）
塔（可以攻击）
工厂（可以建坦克）
树（可以养殖）
老虎（可以移动，可以攻击，可以养殖）

在我眼中这样做的理想方式是每个独特能力的类别，即可移动，可攻击，可燃，可构造。这是所有列出的对象具有的不同能力。它们都是GameObject（层次结构中的最高级别，包含所有对象的公共数据）。

Movable保存用于移动对象的所有代码（计算速度，方向，新位置等）。 Attackable包含跟踪目标，射击，更新射击等的代码。其他能力类也是如此。

所以在我眼里，这将是完美的：

public class Tank extends Movable, Attackable, GameObject {}
public class Tiger extends Movable, Attackable, Farmable, GameObject {}

显然，Java不允许扩展多个类。我不知道如何使用接口来解决我的多态性和类层次结构问题。

有什么想法吗？目标当然不是重复游戏中几个对象共享的代码。

Answer 1

Movable ，可攻击是对象的各种可能行为，因此最好是接口。

至于那些行为的实现 - 为了解决重复代码的问题，你可以为每个行为设置单独的类 - 让它们命名为服务 - 例如。 MoveService ， AttackService 。

然后，您可以将这些服务注入您正在创建的对象（例如 new Tank（myMoveService））或将对象传递给这些服务，例如。 MoveService.instance（）。move（myTank）

您可以通过调用委托方法为每个类运行一些自定义代码。

实施例

interface Movable { public void onMove(); }

class Tank implements Movable {
    public void onMove() { 
        //tank moved! 
    }
}

class MoveService {
    public void move(Movable m) {
        // do what you need to do to move
        // invoke custom code by running a delegate method
        m.onMove();
    }
}

Answer 2

我建议接口和组合的组合。这是一个工厂的例子，它使用泛型来保存一些代码。

interface UnitFactory<U extends Unit> {
    public U newUnit();
}

abstract class UnitFactoryBuilding<U, F extends AbstractUnitFactory<U>>
extends Building // assume 'Building extends GameObject'
implements UnitFactory<U> {

    final F factory;

    UnitFactoryBuilding(F factory) {
        this.factory = factory;
    }

    MapPosition getExitPoint() {
        /* return the point for the 'door' on the model */
    }

    @Override
    public U newUnit() {
        U unit = factory.newUnit();

        /* assume Building has a method that
         * returns the player that 'owns' it
         */
        getPlayer().deductResources(unit.getResourceCost());

        return unit;
    }
}

abstract class AbstractUnitFactory<U>
implements UnitFactory<U> {
    final Building owner;

    AbstractUnitFactory(Building owner) {
        this.owner = owner;
    }

    MapPosition getPositionForNewUnit() {
        return owner.getExitPoint();
    }
}

class TankFactory
extends AbstractUnitFactory<Tank> {

    TankFactory(TankFactoryBuilding owner) {
        super(owner);
    }

    @Override
    public Tank newUnit() {
        return new Tank(getPositionForNewUnit());
    }
}

class TankFactoryBuilding
extends UnitFactoryBuilding<Tank, TankFactory> {

    TankFactoryBuilding() {
        super(new TankFactory(this));
    }
}

它有点复杂，但类似的东西可以让你保持你的实现分离，而不必复制大量的代码。创建一种新的工厂只需要编写最后两个类。

您不必使用泛型来处理此类问题，但这样做非常方便，因为TankFactoryBuilding可以factory访问其TankFactory成员。

Answer 3

Movable和Attackable只是属性。

考虑一个具有“隐身”能力的单位，当它隐身时不会受到攻击，但是当它不存在时可以被攻击。

对象树是关于行为的。

Terrain，Unit，Building等课程更有意义，因为他们会有大致相似的行为。

RTS游戏中对象的多态性和类层次问题

3 个答案: