05程序是怎么跑起来的

18/* Starts the game: load the data, then open the window. */
19public class Main extends Application {
20 
21    @Override
222    public void start(Stage stage) {
23        GameData data;
24        try {
253            data = new GameDataReader().read(getParameters().getRaw());
26        } catch (IOException | IllegalArgumentException e) {
27            /* Stop before opening the game if the data cannot be loaded,
28             * for example "Error loading mokepon.game".
29             */
30            System.out.println("Error loading " + e.getMessage());
31            Platform.exit();
32            return;
33        }
34 
354        List<Mokepon> mokepons = new MokeponParser().parse(data);
364        GameMap map = new MapParser().parse(data);
374        GameImages images = new ImageParser().parse(data);
385        GameWindow gameWindow = new GameWindow(stage, mokepons, map, images);
396        gameWindow.show();
40    }
41 
42    public static void main(String[] args) {
432        launch(args);
44    }
45}

20javafx {
21    version = "25"
221    modules = listOf("javafx.controls")
23}
24 
25application {
262    mainModule.set("au.edu.unimelb.swen.oop.mokepon")
273    mainClass.set("au.edu.unimelb.swen.oop.mokepon.Main")
28 
29    applicationDefaultJvmArgs = listOf(
304        "--enable-native-access=javafx.graphics"
31    )
32}
33 
34tasks.named<JavaExec>("run") {
355    args("data=mokepon.game")
36}

1module au.edu.unimelb.swen.oop.mokepon {
21    requires javafx.controls;
3 
42    exports au.edu.unimelb.swen.oop.mokepon;
5}

19public class Main extends Application {
20 
21    @Override
223    public void start(Stage stage) {
⋯ 省略第 23–41 行
421    public static void main(String[] args) {
432        launch(args);
44    }

1mokepon.0.name=Sealance
2mokepon.0.image=assets/Sealance.png
3mokepon.0.hp=180
4mokepon.0.energy=10
5mokepon.0.strength=55
6mokepon.0.accuracy=70
7mokepon.0.defence=75
8mokepon.0.dodge=45
9mokepon.0.skills=Bite|Wait
10mokepon.0.type=WATER
11 

10/* Reads the game data file named on the command line. */
11public class GameDataReader {
12    private static final String ARGUMENT_PREFIX = "data=";
13 
14    /* The first argument must look like data=relativeFilePath.
15     * If the file is missing, the exception message is its path, for example mokepon.game.
16     */
17    public GameData read(List<String> arguments) throws IOException {
181        if (arguments.isEmpty() || !arguments.getFirst().startsWith(ARGUMENT_PREFIX)) {
19            throw new IllegalArgumentException(
20                    "data file: missing argument in the form data=relativeFilePath");
21        }
22 
23        String argument = arguments.getFirst();
242        Path dataFile = Path.of(argument.substring(ARGUMENT_PREFIX.length()));
253        Properties properties = new Properties();
264        try (InputStream input = Files.newInputStream(dataFile)) {
27            properties.load(input);
28        }
29 
30        /* Remove spaces around values before the numbers are converted. */
315        for (String key : properties.stringPropertyNames()) {
32            properties.setProperty(key, properties.getProperty(key).trim());
33        }
346        return new GameData(properties);
35    }
36}

22    public void start(Stage stage) {
23        GameData data;
24        try {
251            data = new GameDataReader().read(getParameters().getRaw());
262        } catch (IOException | IllegalArgumentException e) {
27            /* Stop before opening the game if the data cannot be loaded,
28             * for example "Error loading mokepon.game".
29             */
303            System.out.println("Error loading " + e.getMessage());
314            Platform.exit();
325            return;
33        }
34 
35        List<Mokepon> mokepons = new MokeponParser().parse(data);
36        GameMap map = new MapParser().parse(data);
37        GameImages images = new ImageParser().parse(data);
38        GameWindow gameWindow = new GameWindow(stage, mokepons, map, images);
39        gameWindow.show();
40    }

6/* The values loaded from the data file, with helpers that turn them into
7 * numbers and positions. All parsers read the file through this class.
8 */
9public class GameData {
10    private final Properties properties;
11 
12    public GameData(Properties properties) {
13        this.properties = properties;
14    }
15 
16    public boolean has(String key) {
171        return properties.containsKey(key);
18    }
19 
20    public String getText(String key) {
212        return properties.getProperty(key);
22    }
23 
24    public int getNumber(String key) {
253        return Integer.parseInt(getText(key));
26    }
27 
28    /* A position is written as x,y, for example 10,18. */
29    public Position getPosition(String key) {
304        String[] parts = getText(key).split(",");
31        return new Position(Integer.parseInt(parts[0].trim()), Integer.parseInt(parts[1].trim()));
32    }
33 
34    /* Count numbered entries such as mokepon.0.name, mokepon.1.name and so on.
35     * Numbers start at 0 and have no gaps, so stop at the first missing one.
36     */
37    public int countEntries(String prefix, String suffix) {
38        int count = 0;
395        while (has(prefix + count + suffix)) {
40            count++;
41        }
42        return count;
43    }
44}

5/* Every skill in the game. The data file only gives skill names, and this class
6 * finds the skill object with that name. Skills never change after they are made,
7 * so all Mokepon can share the same skill objects.
8 * To add a new skill, write a new subclass and add one object of it to this list.
9 */
10public class SkillCatalogue {
111    private static final List<Skill> SKILLS = List.of(
12            new Bite(), new Tackle(), new Lance(), new Stun(), new PocketSand(),
13            new Bunker(), new Aim(), new Swole(), new Nimble(), new Wait());
14 
15    /* Find a skill by its exact, case-sensitive name. */
162    public static Skill find(String name) {
17        for (Skill skill : SKILLS) {
18            if (skill.getName().equals(name)) {
19                return skill;
20            }
21        }
223        throw new IllegalArgumentException("Unknown skill: " + name);
23    }
24}

25    public GameMap parse(GameData data) {
261        Terrain[][] tiles = parseTiles(data);
272        Position startPosition = data.getPosition("map.player.startingPos");
28 
29        /* Each marker group has its own way of choosing the enemy. */
30        List<MapObject> objects = new ArrayList<>();
313        objects.addAll(parseMarkers(data, "map.mokeponRandom", new RandomEnemyPicker()));
324        objects.addAll(parseMarkers(data, "map.mokeponStrong",
33                new TerrainEnemyPicker(TerrainEffect.ADVANTAGE)));
345        objects.addAll(parseMarkers(data, "map.mokeponWeak",
35                new TerrainEnemyPicker(TerrainEffect.DISADVANTAGE)));
366        objects.addAll(parseMysteryBoxes(data));
377        objects.add(parseExit(data));
38 
39        return new GameMap(tiles, startPosition, objects);
40    }

42    /* Each row is a string with one letter per tile, and map.tiles.0 is the top row. */
43    private Terrain[][] parseTiles(GameData data) {
441        int rowCount = data.countEntries(TILES_PREFIX, "");
452        Terrain[][] tiles = new Terrain[rowCount][];
46        for (int row = 0; row < rowCount; row++) {
473            String letters = data.getText(TILES_PREFIX + row);
484            tiles[row] = new Terrain[letters.length()];
49            for (int column = 0; column < letters.length(); column++) {
505                tiles[row][column] = Terrain.fromSymbol(letters.charAt(column));
51            }
52        }
53        return tiles;
54    }

4public enum Terrain {
56    BARRIER('B', false),
6    FOREST('F', true),
7    GRASS('G', true),
8    OCEAN('O', false),
9    PATH('P', true),
10    ROCKS('R', true),
11    WATER('W', true);
12 
137    private final char symbol;
14    private final boolean walkable;
15 
168    Terrain(char symbol, boolean walkable) {
17        this.symbol = symbol;
18        this.walkable = walkable;
19    }
⋯ 省略第 20–24 行
25    /* Find the terrain for one letter of a map.tiles row. */
26    public static Terrain fromSymbol(char symbol) {
27        for (Terrain terrain : values()) {
289            if (terrain.symbol == symbol) {
29                return terrain;
30            }
31        }
3210        throw new IllegalArgumentException("Unknown tile: " + symbol);
33    }

56    /* All markers in one group share the same image, colour and picker. */
57    private List<MapObject> parseMarkers(GameData data, String group, EnemyPicker picker) {
581        Sprite sprite = new Sprite(data.getText(group + ".image"), data.getText(group + ".colour"));
59        List<MapObject> markers = new ArrayList<>();
602        int count = data.countEntries(group + ".", "");
61        for (int index = 0; index < count; index++) {
623            Position position = data.getPosition(group + "." + index);
634            markers.add(new Marker(position, sprite, picker));
64        }
65        return markers;
66    }

14    public GameImages parse(GameData data) {
15        Map<MokeponType, String> typeImages =
161                readImages(data, "mokepon.type.", MokeponType.values());
172        Map<Terrain, String> tileImages = readImages(data, "map.tiles.images.", Terrain.values());
18        Map<Direction, String> buttonImages =
193                readImages(data, "map.buttons.", Direction.values());
204        return new GameImages(typeImages, tileImages, buttonImages, readItemImages(data),
215                data.getText("map.player.image"));
22    }
23 
24    /* Generic method: read one image for each value of an enum. The key ends with the
25     * value's name in lower case, for example map.tiles.images.grass for GRASS.
26     * A value without a key is left out, which is how the normal type has no image.
27     */
28    private <T extends Enum<T>> Map<T, String> readImages(GameData data, String prefix,
29                                                          T[] values) {
30        Map<T, String> images = new HashMap<>();
31        for (T value : values) {
326            String key = prefix + value.name().toLowerCase();
337            if (data.has(key)) {
34                images.put(value, data.getText(key));
35            }
36        }
37        return images;
38    }
39 
40    /* Each item knows the end of its image key, for example heal for items.heal. */
41    private Map<Item, String> readItemImages(GameData data) {
42        Map<Item, String> images = new HashMap<>();
43        for (Item item : ItemCatalogue.getAll()) {
44            images.put(item, data.getText("items." + item.getImageName()));
45        }
46        return images;
47    }

40    /* Each item knows the end of its image key, for example heal for items.heal. */
41    private Map<Item, String> readItemImages(GameData data) {
42        Map<Item, String> images = new HashMap<>();
43        for (Item item : ItemCatalogue.getAll()) {
44            images.put(item, data.getText("items." + item.getImageName()));
45        }
46        return images;
47    }

15    @Override
16    public void start(Stage stage) throws IOException {
17 
18        Properties gameData;
19        try {
201            gameData = loadPropertiesFromArgument();
21        } catch (IOException | IllegalArgumentException e) {
22            // Stop before opening the game if the data cannot be loaded.
23            System.out.println("Error loading: " + e.getMessage());
24            javafx.application.Platform.exit();
25            return;
26        }
27 
282        List<Mokepon> mokepons = generateMokepon(gameData);
29 
303        GameWindow gameWindow = new GameWindow(mokepons);
31        gameWindow.show();
32    }

22    public void start(Stage stage) {
23        GameData data;
24        try {
251            data = new GameDataReader().read(getParameters().getRaw());
26        } catch (IOException | IllegalArgumentException e) {
27            /* Stop before opening the game if the data cannot be loaded,
28             * for example "Error loading mokepon.game".
29             */
30            System.out.println("Error loading " + e.getMessage());
31            Platform.exit();
32            return;
33        }
34 
352        List<Mokepon> mokepons = new MokeponParser().parse(data);
362        GameMap map = new MapParser().parse(data);
372        GameImages images = new ImageParser().parse(data);
383        GameWindow gameWindow = new GameWindow(stage, mokepons, map, images);
39        gameWindow.show();
40    }

19    public GameMenu(GameNavigator navigator) {
201        runAway = new MenuItem("Run away");
21        runAway.setAccelerator(new KeyCodeCombination(KeyCode.R, KeyCombination.CONTROL_DOWN));
22        runAway.setOnAction(event -> navigator.runAway());
23 
242        mainMenu = new MenuItem("Main menu");
25        mainMenu.setAccelerator(new KeyCodeCombination(KeyCode.B, KeyCombination.CONTROL_DOWN));
26        mainMenu.setOnAction(event -> navigator.returnToMainMenu());
27 
283        MenuItem exit = new MenuItem("Exit");
29        exit.setAccelerator(new KeyCodeCombination(KeyCode.F4, KeyCombination.ALT_DOWN));
30        exit.setOnAction(event -> navigator.quit());
31 
32        Menu gameMenu = new Menu("Game");
33        gameMenu.getItems().addAll(runAway, mainMenu, new SeparatorMenuItem(), exit);
34 
35        menuBar = new MenuBar(gameMenu);
36        menuBar.setPrefWidth(UiStyle.GAME_WIDTH);
37    }
⋯ 省略第 38–42 行
43    /* Turn the options on or off to match the screen being shown.
44     * A disabled option also ignores its keyboard shortcut.
45     */
46    public void update(GameScreen screen) {
47        runAway.setDisable(!screen.canRunAway());
48        mainMenu.setDisable(!screen.canReturnToMainMenu());
49    }

211    /* One button for each Mokepon, in a list that scrolls when it is too long. */
212    private ScrollPane createMokeponList(List<Mokepon> mokepons) {
213        VBox buttonColumn = new VBox(LIST_GAP);
214        Font font = UiStyle.loadGameFont(LIST_FONT_SIZE);
215        for (Mokepon mokepon : mokepons) {
2161            GameButton button = new GameButton(mokepon.getName(), font, BUTTON_RADIUS);
217            button.setPrefWidth(LIST_BUTTON_WIDTH);
2182            button.setOnAction(event -> select(mokepon, button));
219            buttonColumn.getChildren().add(button);
220        }