Coursework 2：World of Zuul中文版

import java.util.Set;
import java.util.HashMap;

/**
 * Room（房间）类 - 冒险游戏中的一个房间。
 * 这个类 是 "祖尔的世界" 应用程序的一部分。
 * "祖尔的世界" 是一个非常简单的、基于文本的冒险游戏。
 * 一个 "Room"（"房间"）代表游戏场景中的一个位置。
 * 它通过出口与其他房间相连。
 * 对于每一个现有的出口，房间都会存储一个对邻近房间的引用。
 *
 * @author Michael Kölling and David J. Barnes
 * @version 2016.02.29
 */

public class Room {
    private String description;
    private HashMap<String, Room> exits;        // 储存这个房间的出口们
    //    private Map<String, Room> exits = new HashMap<>();
    // ----------添加的代码 1 Start----------
    private Item item = null;
    private Trap trap = null;
    // ----------添加的代码 1 End----------
    /**
     * 创建一个描述 "description"（"描述"） 的房间。
     * 最初，它没有出口。"description" 是 "一个厨房" 或 "一个开放的庭院" 之类的东西。
     *
     * @param description 该房间的描述。
     */
    public Room(String description) {
        this.description = description;
        exits = new HashMap<>();
    }
    // ----------添加的代码 2 Start----------
    public Room(String description, Item item) {
        this(description);
        this.item = item;
    }

    //    public Room(String description, Item thing, Trap trap) {
    public Room(String description, Item item, Trap trap) {
        this(description);
        this.item = item;
        this.trap = trap;
    }

    public Room(String description, Trap trap) {
        this(description);
        this.trap = trap;
    }
    // ----------添加的代码 2 End----------

    /**
     * 定义这个房间的一个出口。
     *
     * @param direction 出口的方向。
     * @param neighbor  出口所通往的房间。
     */
    public void setExit(String direction, Room neighbor) {
        exits.put(direction, neighbor);
    }

    /**
     * @return 房间的简短描述
     * （就是在构造函数中定义的那个）。
     */
    public String getShortDescription() {
        return description;
    }

    /**
     * 以此格式返回对房间的描述：
     * 你正在厨房。
     * 出口：北西
     *
     * @return 这个房间的长篇描述
     */
    public String getLongDescription() {
        return "You are " + description + ".\n" + getExitString();
    }

    /**
     * 返回一个描述房间出口的字符串，例如
     * "出口：北西"。
     *
     * @return 房间出口的详细信息。
     */
    private String getExitString() {
        String returnString = "出口：";
        Set<String> keys = exits.keySet();
        for (String exit : keys) {
            returnString += " " + exit;
        }
        return returnString;
    }

    /**
     * 返回如果我们从这个房间向方向 "direction" 走，就会到达的这个房间。
     * 如果在这个方向上没有房间，则返回 null。
     *
     * @param direction 出口的方向。
     * @return 指定方向的房间。
     */
    public Room getExit(String direction) {
        return exits.get(direction);
    }

    // ----------添加的代码 3 Start----------
    public void printExits() {
        System.out.print("方向： ");
        exits.keySet().stream().forEach(key -> System.out.print(key + " "));
        System.out.println();
    }

    public Room goNext(String direction) {
        return exits.get(direction);
    }

    public Item getItem() {
        return this.item;

    }

    public void removeItem() {
        this.item = null;
    }

    public Trap getTrap() {
        return this.trap;
    }

    public void removeTrap() {
        this.trap = null;
    }
    // ----------添加的代码 3 End----------
}

public class Item {
    private String name;
    private int score;
    private int life;

    public Item(String name, int score, int life) {
        this.name = name;
        this.score = score;
        this.life = life;
    }

    public int getScore() {
        return this.score;
    }

    public String getName() {
        return this.name;
    }

    public String toString() {
        return "[名称：" + name + "，分数：" + score + "，生命：" + life + "]";
    }

    public int getLife() {
        return this.life;
    }
}

public class Trap {
    private String name;
    private int strengthDown;
    private int lifeDown;

    public Trap(String name, int strengthDown, int lifeDown) {
        this.name = name;
        this.strengthDown = strengthDown;
        this.lifeDown = lifeDown;
    }

    public int getStrengthDown() {
        return this.strengthDown;
    }

    public int getLifeDown() {
        return this.lifeDown;
    }

    public String getName() {
        return this.name;
    }
}

/**
 * 这个类是 "祖尔的世界" 应用程序的一部分。
 * "祖尔的世界" 是一个非常简单的、基于文本的冒险游戏。
 * <p>
 * 该类持有关于用户发布的一项命令的信息。
 * 一个命令目前由两个字符串组成：一个命令字和第二个字
 * （例如，如果命令是 "take map" ("采取地图")，那么这两个字符串显然是 "take" 和 "map"）。
 * <p>
 * 其使用方法是：命令已经被检查为有效的命令字。
 * 如果用户输入了一个无效的命令（一个不知道的字），那么这个命令字就是<null>。
 * <p>
 * 如果该命令只有一个字，那么第二个字就是<null>。
 *
 * @author Michael Kölling and David J. Barnes
 * @version 2016.02.29
 */

public class Command {
    // ------------修改1 Start------------
//    private String commandWord;  // 命令字
    private Word commandWord;  // 命令字
    // ------------修改1 End------------
    private String secondWord;  // 第二个单词

    // -----------修改代码2 Start---------------------------------------
    /**
     * 创建一个命令对象。必须提供第一个和第二个字，但其中一个（或两个）可以是 null 的。
     *
     * @param firstWord  命令的第一个字。Null 如果该命令是未被识别。
     * @param secondWord 命令的第二个字。
     */
    public Command(String firstWord, String secondWord) {
//        commandWord = firstWord;
//        this.secondWord = secondWord;
        commandWord = Enum.valueOf(Word.class, firstWord.toUpperCase());
        this.secondWord = secondWord;
    }
    // -----------修改代码2 End---------------------------------------

    // -----------修改代码3 Start---------------------------------------
    /**
     * 返回该命令的命令字（第一个字）。
     * 如果该命令未被理解，则结果为 null。
     *
     * @return 命令字
     */
//    public String getCommandWord() {
//        return commandWord;
//    }
    public Word getCommandWord() {
        return commandWord;
    }
    // -----------修改代码3 End---------------------------------------

    /**
     * @return 这个命令的第二个字。
     * 如果没有第二个词，则返回 null。
     */
    public String getSecondWord() {
        return secondWord;
    }

    /**
     * @return true，如果这个命令不被理解。
     */
    public boolean isUnknown() {
        return (commandWord == null);
    }

    /**
     * @return true，如果该命令有第二个字。
     */
    public boolean hasSecondWord() {
        return (secondWord != null);
    }
}

/**
 * @ClassName: Player
 * @Description: TODO
 * @Author: AndersonHJB
 * @date: 2022/11/30 21:20
 * @Version: V1.0
 * @Blog: https://bornforthis.cn
 */

import java.util.*;

public class Player {
    private int strength = 160;
    private int life = 100;
    private Map<String, Item> bag = new HashMap<>();

    public int getLife() {
        return life;
    }

    public void step() {
        strength -= 5;
        System.out.println("你消耗了5点体力。");
        System.out.println("你现在有" + strength + "点体力。");
    }

    private void decideEnd() {
        if (strength % 10 == 2) {
            System.out.println("你使用了所有石碑，放弃了拯救家园的机会。成为了黑咒岛新一任的主人。");
            System.out.println("恭喜你，游戏通关，达成结局一");
        } else if (strength % 10 == 9) {
            System.out.println("你献祭了诅咒之物。作为交换，神会解除对你的族人诅咒");
            System.out.println("恭喜你，游戏通关，达成结局二");
        }
    }

    public void pick(Item item) {
        bag.put(item.getName(), item);
    }

    public void use(String name) {
        Item item = bag.get(name);
        bag.remove(name);
        if (item != null) {
            System.out.println("你使用了" + name + "。");
            if (item.getScore() != 0) {
                int lastStrength = strength;
                strength += item.getScore();
                if (strength > 100) {
                    strength = 100;
                }
                if (strength - lastStrength < 0)
                    System.out.println("你失去了" + (lastStrength - strength) + "点体力。");
                else
                    System.out.println("你获得了" + (strength - lastStrength) + "点体力。");
                System.out.println("你现在有" + strength + "点体力。");
            }
            if (item.getLife() != 0) {
                int lastLife = life;
                life += item.getLife();
                if (life > 100) {
                    life = 100;
                }
                if (life - lastLife < 0)
                    System.out.println("你失去了" + (lastLife - life) + "点生命。");
                else
                    System.out.println("你获得了" + (life - lastLife) + "点生命。");
                System.out.println("你现在有" + life + "点生命。");
            }
        } else {
            System.out.println("你没有" + name + "这样物品。");
        }
    }

    public boolean isDead() {
        if (strength <= 0) {
            System.out.println("你体力耗尽了！随着一阵晕眩，你昏倒在地。");
            System.out.println("黑暗很快将筋疲力尽的你彻底吞没了");
            return true;
        } else if (life <= 0) {
            System.out.println("你受到了重创！");
            System.out.println("黑暗很快将奄奄一息的你彻底吞没了");
            return true;
        } else return false;
    }

    public void lookItem() {
        System.out.print("你有");
        bag.keySet().stream().forEach(key -> System.out.println(key + "【分数：" + bag.get(key).getScore() + ",生命：" + bag.get(key).getLife() + "】 "));
    }

    public void harm(Trap trap) {
        System.out.println("你受到了" + trap.getName() + "的攻击。");
        if (trap.getStrengthDown() != 0) {
            strength -= trap.getStrengthDown();
            System.out.println("你失去了" + trap.getStrengthDown() + "点体力。");
            System.out.println("你现在有" + strength + "点体力。");
        }

        if (trap.getLifeDown() != 0) {
            life -= trap.getLifeDown();
            System.out.println("你失去了" + trap.getLifeDown() + "点生命。");
            System.out.println("你现在有" + life + "点生命。");
        }

    }
}

/**
 * 该类是 "祖尔的世界" 应用程序的主类。
 * "祖尔的世界" 是一个非常简单的、基于文本的冒险游戏。
 * 用户可以在一些场景中散步。这就是全部。它真的应该被扩展，以使其更有趣!
 * 要玩这个游戏，需要创建这个类的一个实例，并调用 "play" 方法。
 * 这个主类创建并初始化所有其他的类：
 * 它创建所有的房间，创建解析器并启动游戏。
 * 它还评估和执行解析器返回的命令。
 *
 * @author Michael Kölling and David J. Barnes
 * @version 2016.02.29
 */

public class Game {
    private Parser parser;  // parser 中文为：解析器
    private Room currentRoom;  // 当前房间
    private Player player;  // 添加玩家

    /**
     * 创建游戏并初始化其内部地图。
     */
    public Game() {
        createRooms();
        parser = new Parser();
        player = new Player();  // 实例化玩家
    }

    /**
     * 创建所有的房间并将它们的出口连接在一起。
     */
    private void createRooms() {
        Room entrance, roomTwo, roomThree, roomFour, roomFive, roomSix, roomSeven, roomEight, roomNine, roomTen, roomEleven, roomTwelve, roomThirteen, roomFourteen, roomFifteen, roomSixteen, roomSeventeen, roomEighteen, roomNineteen, roomTwenty, roomTwentyone, roomTwentytwo, roomTwentythree, roomTwentyfour;

        //create the rooms
        entrance = new Room("你来到了黑咒岛外围，岛屿四周都是悬崖峭壁，只有北面有一座破败，残损的古朴石雕大门。里面似乎有人在召唤着你，你早已去意已决。");
        roomTwo = new Room("你进入了无凯旋者的庭院，你知道自己已无退路，神已经离开你的家园很久了，");
        roomThree = new Room("你进入了羡月楼，你现在必须找到众神以拯救自己的家园");
        roomFour = new Room("你进入了怨嗟之监房");
        roomFive = new Room("你进入了逢魔的螺旋,神秘碑文：黑咒岛被黑暗笼罩无法成为锚", new Item("诅咒之物", 29, 0));
        roomSix = new Room("你进入了混入虚实的仓库，这世间唯一与神有关的，只有这传说中被神万世诅咒永堕黑暗的的黑咒岛");
        roomSeven = new Room("你进入了悲叹的水脉，");
        roomEight = new Room("你进入了战士的休息所,神秘碑文：没有锚，众神的摩天巨轮无法在这个世界停泊", new Item("神秘碑文一", 17, 0));
        roomNine = new Room("你进入了知晓虚假的真理的祠");
        roomTen = new Room("你进入了虚心回廊");
        roomEleven = new Room("你进入了追忆之城砦");
        roomTwelve = new Room("你进入了行者的炎道，神秘碑文：黑咒岛不是死物，它会为自己挑选主人", new Item("神秘碑文二", 17, 0));
        roomThirteen = new Room("你进入了背叛者处刑塔");
        roomFourteen = new Room("你进入了充满瘴气的圣堂，你发现了神秘碑文。", new Item("神秘碑文六", 17, 0));
        roomFifteen = new Room("你进入了墓碑铭回廊,墓碑上写着：我要那诸神，烟消云散！", new Item("神秘碑文三", 17, 0));
        roomSixteen = new Room("你进入了腐朽的贮藏库");
        roomSeventeen = new Room("你进入了被遗忘的厂间");
        roomEighteen = new Room("你进入了血液干涸之狱舍");
        roomNineteen = new Room("你进入了觉者的隐蔽之家,神秘碑文：神会侵蚀人的人性，扶植人的奴性", new Item("神秘碑文四", 17, 0));
        roomTwenty = new Room("你进入了无退路的修炼所");
        roomTwentyone = new Room("你进入了异邦之落都，你在这里发现了一位形如枯骨的老人，他向你阐述当年神与人的渊源。眼前这座古都曾是神在这世间的落脚之地，人的贪婪想索取神的一切，神的傲慢想奴役人的一切。当人发现第一个死去的神的时候，野心便在心底疯狂滋长，神也发现曾经的下等生命翅膀变硬了。战争爆发了，最终古都被灭国，神也失去了这个世界的坐标，古都的居民遭到神的诅咒四处流亡，这诅咒便是你的家园现今遭受的苦难。", new Item("古都秘史", 0, 10));
        roomTwentytwo = new Room("你进入了黑咒之祭坛,祭坛之下的碑文写着：将诅咒之物奉献，可永远得到神的祝福。做出你的选择。结局视你通过使用物品获得的最后的分数而定");
        roomTwentythree = new Room("你进入了畏惧之天穹，神秘碑文：黑咒岛是众神的锚", new Item("神秘碑文五", 17, 0));
        roomTwentyfour = new Room("你进入了魔伽蓝,神秘碑文：这是陷阱！", new Trap("腐龙", 100, 100));


        entrance.setExit("north", roomTwo);  // 黑咒岛>>>无凯旋者的庭院 north: 北方
        entrance.setExit("west", roomFifteen);  // 黑咒岛>>>墓碑铭回廊 west：西方
        entrance.setExit("east", roomTen);   // 黑咒岛>>>虚心回廊 east：东方
        roomTwo.setExit("north", roomThree);  // roomTwo 无凯旋者的庭院>>>羡月楼
        roomTwo.setExit("south", entrance);  // south：南方
        roomThree.setExit("east", roomFour);
        roomThree.setExit("south", roomTwo);
        roomThree.setExit("west", roomTwentythree);
        roomThree.setExit("north", roomSix);
        roomFour.setExit("north", roomFive);
        roomFour.setExit("west", roomThree);
        roomFive.setExit("south", roomFour);
        roomSix.setExit("north", roomSeven);
        roomSix.setExit("south", roomThree);
        roomSeven.setExit("west", roomEight);
        roomSeven.setExit("south", roomSix);
        roomSeven.setExit("north", roomNine);
        roomEight.setExit("east", roomSeven);
        roomNine.setExit("west", roomTen);
        roomNine.setExit("south", roomSeven);
        roomTen.setExit("west", roomEleven);
        roomTen.setExit("north", entrance);
        roomTen.setExit("east", roomNine);
        roomEleven.setExit("south", roomThirteen);
        roomEleven.setExit("west", roomTwentyfour);
        roomEleven.setExit("north", roomTwelve);
        roomEleven.setExit("east", roomTen);
        roomTwelve.setExit("south", roomEleven);
        roomThirteen.setExit("south", roomFourteen);
        roomThirteen.setExit("north", roomEleven);
        roomFourteen.setExit("north", roomThirteen);
        roomFourteen.setExit("south", roomFifteen);
        roomFifteen.setExit("west", roomSixteen);
        roomFifteen.setExit("north", roomFourteen);
        roomFifteen.setExit("south", entrance);
        roomSixteen.setExit("south", roomSeventeen);
        roomSixteen.setExit("east", roomFifteen);
        roomSeventeen.setExit("north", roomSixteen);
        roomSeventeen.setExit("south", roomEighteen);
        roomEighteen.setExit("south", roomTwenty);
        roomEighteen.setExit("east", roomNineteen);
        roomEighteen.setExit("north", roomSeventeen);
        roomNineteen.setExit("west", roomEighteen);
        roomTwenty.setExit("north", roomEighteen);
        roomTwenty.setExit("east", roomTwentyone);
        roomTwentyone.setExit("west", roomTwenty);
        roomTwentyone.setExit("east", roomTwentytwo);
        roomTwentytwo.setExit("west", roomTwentyone);
        roomTwentytwo.setExit("east", entrance);
        roomTwentythree.setExit("east", roomThree);
        roomTwentyfour.setExit("east", roomEleven);

        currentRoom = entrance;  // start game outside
    }

    /**
     * 主要的游戏程序。 循环，直到游戏结束。
     */
    public void play() {
        printWelcome();  // 游戏开场白

        // 进入主命令循环。
        // 在这里，我们反复读取命令并执行它们，直到游戏结束。

        boolean finished = false;
        while (!finished) {
            Command command = parser.getCommand();
            finished = processCommand(command);
        }
        System.out.println("谢谢您的游玩。 再见。");
    }

    // -------------修改1 Start----------------------

    /**
     * 打印出给玩家的开场白。
     */
    private void printWelcome() {
        System.out.println();
        System.out.println("经过漫长的旅行，");
        System.out.println("你终于找到了传说中冒险者的禁地——黑咒岛");
        System.out.println("岛如其名，整座岛屿被笼罩在黑暗的诅咒当中");
        System.out.println("即使在阳光之下，你也伸手不见五指");
        System.out.println();
        System.out.println(currentRoom.getLongDescription());
        currentRoom.printExits();
    }
    // -------------修改1 End----------------------

    // -------------修改2 Start----------------------

    /**
     * 给出一条命令，处理（即：执行）该命令。
     *
     * @param command 要处理的命令。
     * @return true 如果该命令结束游戏，否则 return false
     */
    private boolean processCommand(Command command) {
        boolean wantToQuit = false;
        boolean gameOver = false; // 游戏结束

        if (command.isUnknown()) {
            System.out.println("我不知道你什么意思。o(╯□╰)o");
            return false;
        }

//        String commandWord = command.getCommandWord();
        Word commandWord = command.getCommandWord();
        switch (commandWord) {
            case HELP:
                printHelp();
                break;
            case GO:
                goRoom(command);
                wantToQuit = gameOver();
                break;
            case QUIT:
                wantToQuit = quit(command);
                break;
            case LOOK:
                look();
                break;
            case PICK:
                pickThing();
                break;
            case CHECK:
                check();
                break;
            case USE:
                use(command);
                wantToQuit = gameOver();
                break;
        }
//        // else 命令不被识别。
//        return wantToQuit;
        if (gameOver || wantToQuit) {
            return true;
        } else return false;
    }

    // 用户命令的实现：

    /**
     * 打印出一些帮助信息。
     * 在这里，我们打印一些愚蠢的、隐秘的信息和一个包含着命令字的列表。
     */
//    private void printHelp() {
//        System.out.println("你迷失了。你是孤独的。你徘徊着");
//        System.out.println("在大学里四处奔波。");
//        System.out.println();
//        System.out.println("你的命令字是：");
//        parser.showCommands();
//    }
    private void printHelp() {
        System.out.println("你迷路了。你孤身一人徘徊在迷宫中。");
        System.out.println();
        System.out.println("你可以输入的命令词有：");
        System.out.println("   go quit help look pick check use");
    }

    /**
     * 尝试向一个方向进入。如果有一个出口，就进入新的房间，否则就打印一个错误信息。
     */
    private void goRoom(Command command) {
        if (!command.hasSecondWord()) {
            // 如果没有第二个字，我们就不知道该去哪里了...
            System.out.println("去哪？");
            return;
        }

        String direction = command.getSecondWord(); // 获取第二个字

        // 试着离开目前的房间。
        Room nextRoom = currentRoom.getExit(direction);

        if (nextRoom == null) {
            System.out.println("没有门!");
        } else {
            currentRoom = nextRoom;
            System.out.println(currentRoom.getLongDescription());
            currentRoom.printExits();
            player.step();
            if (currentRoom.getTrap() != null) {
                player.harm(currentRoom.getTrap());
                currentRoom.removeTrap();
//            }
            }
        }
    }

    private void look() {
        Item item = currentRoom.getItem();
        if (item != null) {
            System.out.println("你找到了" + item.getName() + "。");
        } else {
            System.out.println("你什么也没找到。");
        }
    }

    private void pickThing() {
        Item item = currentRoom.getItem();
        if (item != null) {
            player.pick(item);
            currentRoom.removeItem();
            System.out.println("你获得了" + item.getName() + "。" + item.toString());
        } else {
            System.out.println("这里没有什么东西。");
        }
    }

    private void check() {
        player.lookItem();
    }

    private void use(Command command) {
        if (!command.hasSecondWord()) {
            System.out.println("吃什么？");
            return;
        }

        String name = command.getSecondWord();
        player.use(name);
    }
    /*
     * 游戏结束
     * */

    private boolean gameOver() {
        if (player.isDead()) {
            return true;
        } else return false;
    }


    /**
     * 输入了 "Quit"（"退出"）。检查命令的其余部分，看看我们是否真的退出了游戏。
     *
     * @return true 如果这个命令退出游戏，否则 return false。
     */
    private boolean quit(Command command) {
        if (command.hasSecondWord()) {
            System.out.println("冒险者！你要放弃了吗？");
            return false;
        } else {
            return true;  // 我们想退出的信号
        }
    }

    // 运行代码
    public static void main(String[] args) {
        Game game = new Game();
        game.play();
    }
}

/**
     * Given a command, process (that is: execute) the command.
     * 给定一个命令，处理(即:执行)该命令。
     *
     * @param command The command to be processed.
     * @return true If the command ends the game, false otherwise.
     */
    private boolean processCommand(Command command) {
        boolean wantToQuit = false;
        boolean gameOver = false;

        if (command.isUnknown()) {
            System.out.println("我不知道你什么意思。o(╯□╰)o");
            return false;
        }

        Word commandWord = command.getCommandWord();
        switch (commandWord) {
            case HELP:
                printHelp();
                break;
            case GO:
                goRoom(command);
                wantToQuit = gameOver();
                break;
            case QUIT:
                wantToQuit = quit(command);
                break;
            case LOOK:
                look();
                break;
            case PICK:
                pickThing();
                break;
            case CHECK:
                check();
                break;
            case USE:
                use(command);
                wantToQuit = gameOver();
                break;
        }
        if (gameOver || wantToQuit) {
            return true;
        } else return false;
    }