在游戏编程项目中，如何处理具有多个实例的多个项目？

Question

假设我有一个包含多种武器的 2 人游戏。在游戏开始时，玩家可以选择自己的武器并将其装备给自己的角色。所以如果现在，我有以下代码来实现上述场景：

public class Weapon {
    private String name;
    private int attackPoints;
    private int effectivity = 100;

    public Weapon(String name, int attackPoints) {
        this.name = name;
        this.attackPoints = attackPoints;
    }
    // ...
}

public class Character {
    private String name;
    private Weapon weapon;

    public Character(String name, Weapon weapon) {
        this.name = name;
        this.weapon = weapon;
    }
    // ...
}

public class Game {
    Scanner scanner = new Scanner(System.in);
    public void createCharacter() {
        String namePlayer = "Knight";
        String nameOpponent = "Thief";

        //Weapon Menu
        System.out.println("Select weapon");
        System.out.println("1. Dagger - Attack: 10");
        System.out.println("2. Sword - Attack 20");

        Character player;
        Character opponent;
        int choice = scanner.nextInt();

        //Weapon assignment
        switch (choice) {
        case 1:
            player = new Character(name, new Weapon("Dagger", 10));
            break;
        case 2:
            player = new Character(name, new Weapon("Sword", 20));
            break;
        }
    }
}

改写问题

我担心的是，如果我必须添加一个额外的武器，例如“15 伤害的斧头”，那么我必须修改武器菜单，同时在我的开关中添加一个额外的箱子陈述。是否有可能我只需要修改某种列表，它会处理可供玩家选择的武器列表，同时使武器的实例对玩家和对手角色？

老问题

我担心的是，每次我有了新武器，我都必须修改武器菜单，同时修改武器分配部分。有没有更好的方法来实现它？

Answer 1

你基本上需要一个WeaponFactory，它会知道所有可用的Weapons。该工厂还可以根据用户输入创建特定武器的新实例。这样，我认为，您将实现所需的一切

• 所有武器都在一个地方创建，
• 添加新的需要更改单个类。

这是一个简化的例子。

public static class WeaponFactory {
    public List<Weapon> availableWeapons() {
        return Arrays.asList(new Dagger(), new Rifle());
    }

    public Weapon create(int type) {
        return availableWeapons().get(type);
    }
}

public interface Weapon {
    public abstract double attack();
    public abstract String name();
}

public static abstract class WeaponAdapter implements Weapon {
    @Override public String toString() {  return name() + " - " + attack(); }
}

public static class Dagger extends WeaponAdapter {
    @Override public double attack() { return 10; }
    @Override public String name() { return "Dagger"; }
}

public static class Rifle extends WeaponAdapter {
    @Override public double attack() { return 80; }
    @Override public String name() { return "Rifle"; }
}

效率有点低，因为实际上并不需要创建Weapons 的新实例以便在Menu 中显示它们，但我认为对于这个示例来说已经足够了。

为了缓解这种情况，您可以使用一些反射或使用枚举。你基本上需要的是一个函数，它会根据它的类型创建一个 Weapon，所以它可能有点像

List<Class<? extends Weapon>> weapons = Arrays.asList(Dagger.class, Rifle.class);

public Weapon create(Class<Weapon> weaponType) {
    try {
        return weaponType.newInstance();
    } catch (InstantiationException | IllegalAccessException ex) {
        throw new RuntimeException("Not possible");
    }
}

同样，所有这些都是WeaponFactory 的一部分，这是所有Weapons 相关的一个地方。

Answer 2

是的，你可以..

..创建每个武器作为对象将它添加到一个数组（或列表等），所以你不必编码

System.out.println("Select weapon");
System.out.println("1. Dagger - Attack: 10");
System.out.println("2. Sword - Attack 20");

你可以去

    Weapon[] weapons = new Weapon[2];
    weapons[0] = new Weapon ("Dagger",10);
    weapons[1] = new Weapon ("Sword",20);
    for (int i = 0; i < weapons.length; i++) {
        System.out.println(i+1+". "weapons[i].getName+" - "+weapons[i].getAttackPoints);
    }
    int choice = scanner.nextInt();
    player = new Character(namePlayer, weapons[choice-1]);

只是为了照顾

• Weapon 类具有获取名称和攻击点的方法
• 数组以索引 0 开始，如下所示

Answer 3

你的角色类可以有一个这样的武器列表：

public class Character {
private String name;
private List<Weapon> weapons = new ArrayList<Weapon>();

 public Character(String name) { //keep this constructor. I know I have omitted weapons variable from this constructor.
    this.name = name;        
}
// down below you have getters and setters for name and weapons
}

然后当你初始化一个新角色时，这样做：

Character player1;
...

switch (choice) {
    case 1:
        Weapon w = new Weapon("Dagger", 10));
        player = new Character(name);
        player.getWeapons().add(w);
        break;