14战斗界面是怎么画出来的

33    /* The player's scroll in the lower left. */
341    private static final int PLAYER_X = 50;
35    private static final int PLAYER_Y = 272;
36    private static final int PLAYER_WIDTH = 550;
37    private static final int PLAYER_HEIGHT = 455;
38    private static final int PLAYER_CONTENT_X = PLAYER_X + 42;
39    /* The enemy's scroll in the upper right. */
402    private static final int ENEMY_X = 900;
41    private static final int ENEMY_Y = 40;
42    private static final int ENEMY_WIDTH = 330;
43    private static final int ENEMY_HEIGHT = 450;
44    private static final int ENEMY_CONTENT_X = ENEMY_X + 37;
45    /* The skill buttons on the right side of the player's scroll. */
463    private static final int ACTIONS_X = PLAYER_X + 326;
47    private static final int ACTIONS_LABEL_Y = PLAYER_Y + 96;
48    private static final int ACTIONS_FONT_SIZE = 24;
49    private static final int SKILLS_Y = PLAYER_Y + 136;
50    private static final int SKILL_WIDTH = 180;
51    private static final int SKILL_HEIGHT = 48;
52    private static final int SKILL_GAP = 8;
53    private static final int SKILL_FONT_SIZE = 18;
54    /* The item buttons above the player's scroll. */
554    private static final int ITEM_WIDTH = 68;
56    private static final int ITEM_HEIGHT = 94;
57    private static final int ITEM_ICON_SIZE = 32;
58    private static final int ITEM_GAP = 8;
59    private static final int ITEM_FONT_SIZE = 24;
60    /* The log fills the space between the player's scroll and the right edge. */
615    private static final int LOG_X = PLAYER_X + PLAYER_WIDTH + 9;
62    private static final int LOG_Y = 506;
63    private static final int LOG_HEIGHT = 220;
64    private static final int LOG_FONT_SIZE = 14;

227        area.setLayoutX(LOG_X);
228        area.setLayoutY(LOG_Y);
2291        area.setPrefWidth(ENEMY_X + ENEMY_WIDTH - LOG_X);
230        area.setPrefHeight(LOG_HEIGHT);

33    /* The scroll fills the area, and the picture and bars start at contentX.
34     * Only the player's bars write their numbers on top, so showNumbers is false
35     * for the enemy.
36     */
37    public FighterPanel(Fighter fighter, Rectangle2D area, double contentX,
38                        boolean showNumbers) {
39        this.fighter = fighter;
40        double top = area.getMinY();
411        scroll = new FighterScroll(area.getMinX(), top, area.getWidth(), area.getHeight());
423        portrait = UiStyle.createImageView(UiStyle.loadImage(fighter.getImagePath()),
43                contentX, top + PORTRAIT_OFFSET, PORTRAIT_SIZE, PORTRAIT_SIZE);
442        name = UiStyle.createCenteredLabel(fighter.getName(),
45                UiStyle.loadGameFont(NAME_FONT_SIZE), area.getMinX(), top + NAME_OFFSET,
46                area.getWidth());
47 
48        double hpY = top + HP_BAR_OFFSET;
49        double energyY = top + ENERGY_BAR_OFFSET;
50        if (showNumbers) {
514            hpBar = new LabelledStatBar(contentX, hpY, HP_COLOUR,
52                    fighter.getHp(), fighter.getMaxHp());
535            energyBar = new LabelledStatBar(contentX, energyY, ENERGY_COLOUR,
54                    fighter.getEnergy(), fighter.getMaxEnergy());
55        } else {
56            hpBar = new StatBar(contentX, hpY, HP_COLOUR, fighter.getHp(), fighter.getMaxHp());
57            energyBar = new StatBar(contentX, energyY, ENERGY_COLOUR,
58                    fighter.getEnergy(), fighter.getMaxEnergy());
59        }
60    }

7/* A coloured bar showing how much HP or energy is left. */
8public class StatBar {
9    protected static final int WIDTH = 256;
10    protected static final int HEIGHT = 22;
11 
12    /* Keep a small sliver visible for any value above zero. */
13    private static final double MIN_VISIBLE_RATIO = 0.03;
14 
15    private final ProgressBar bar;
16 
17    /* Create the bar already showing the starting value. */
18    public StatBar(double x, double y, String colour, int current, int max) {
192        bar = new ProgressBar(calculateRatio(current, max));
20        bar.setPrefWidth(WIDTH);
21        bar.setPrefHeight(HEIGHT);
22        bar.setStyle("-fx-accent: " + colour + ";");
23        bar.setLayoutX(x);
24        bar.setLayoutY(y);
25    }
26 
27    /* Show the current value out of the maximum. */
28    public void update(int current, int max) {
29        bar.setProgress(calculateRatio(current, max));
30    }
31 
32    /* The parts to add to the screen. */
33    public List<Node> getNodes() {
34        return List.of(bar);
35    }
36 
37    private double calculateRatio(int current, int max) {
38        if (current <= 0) {
39            return 0;
40        }
411        return Math.max(MIN_VISIBLE_RATIO, current * 1.0 / max);
42    }
43}

10/* A stat bar that also writes the numbers on top of it, for example "180 / 180". */
11public class LabelledStatBar extends StatBar {
12    private static final String SEPARATOR = " / ";
13    private static final int FONT_SIZE = 14;
14 
15    private final Label numbers;
16 
17    public LabelledStatBar(double x, double y, String colour, int current, int max) {
181        super(x, y, colour, current, max);
192        numbers = UiStyle.createLabel(current + SEPARATOR + max,
20                UiStyle.createMonospaceFont(FontWeight.BOLD, FONT_SIZE));
21        numbers.setLayoutX(x);
22        numbers.setLayoutY(y);
23        numbers.setPrefSize(WIDTH, HEIGHT);
24        numbers.setAlignment(Pos.CENTER);
25    }
26 
27    @Override
28    public void update(int current, int max) {
293        super.update(current, max);
304        numbers.setText(current + SEPARATOR + max);
31    }
32 
33    /* The numbers go after the bar so they are drawn on top of it. */
34    @Override
35    public List<Node> getNodes() {
36        List<Node> nodes = new ArrayList<>(super.getNodes());
37        nodes.add(numbers);
38        return nodes;
39    }
40}

8/* The scroll behind a fighter, with a red tint that covers it when the fighter faints. */
9public class FighterScroll {
101    private static final Color FAINT_TINT = Color.web("#b41e1e", 0.35);
11 
12    private final ImageView scroll;
13    private final Rectangle faintMask;
14 
15    public FighterScroll(double x, double y, double width, double height) {
16        Image scrollImage = UiStyle.loadImage(UiStyle.SCROLL_FILE);
17        scroll = UiStyle.createImageView(scrollImage, x, y, width, height);
18        faintMask = createFaintMask(scrollImage, x, y, width, height);
19    }
20 
21    public ImageView getScroll() {
22        return scroll;
23    }
24 
25    /* The mask is returned separately so it can be drawn on top of everything else. */
26    public Rectangle getFaintMask() {
27        return faintMask;
28    }
29 
30    public void setFainted(boolean fainted) {
312        faintMask.setVisible(fainted);
32    }
33 
34    /* Clip a red rectangle to the scroll's shape so only the scroll turns red. */
35    private Rectangle createFaintMask(Image scrollImage, double x, double y,
36                                      double width, double height) {
373        Rectangle mask = new Rectangle(width, height, FAINT_TINT);
38        ImageView scrollShape = new ImageView(scrollImage);
39        scrollShape.setFitWidth(width);
40        scrollShape.setFitHeight(height);
41 
42        mask.setLayoutX(x);
43        mask.setLayoutY(y);
444        mask.setClip(scrollShape);
45        mask.setVisible(false);
46        return mask;
47    }

181    /* One button per skill, showing its energy cost, e.g. "Bite [1]". */
182    private VBox createSkillButtons(List<Skill> skills) {
1831        VBox buttonColumn = new VBox(SKILL_GAP);
184        buttonColumn.setLayoutX(ACTIONS_X);
185        buttonColumn.setLayoutY(SKILLS_Y);
186 
187        Font font = UiStyle.loadGameFont(SKILL_FONT_SIZE);
188        for (Skill skill : skills) {
1892            GameButton button = new GameButton(skill.getName() + " [" + skill.getEnergyCost()
190                    + "]", font, BUTTON_RADIUS);
1913            button.setPrefSize(SKILL_WIDTH, SKILL_HEIGHT);
192            button.addPressEffect();
1934            button.setOnAction(event -> useSkill(skill));
194            skillButtons.add(button);
195            buttonColumn.getChildren().add(button);
196        }
197        return buttonColumn;
198    }

200    /* One button per kind of item, with its image above its quantity.
201     * The row is centred above the player's scroll.
202     */
203    private HBox createItemButtons(GameImages images) {
204        HBox buttonRow = new HBox(ITEM_GAP);
205        buttonRow.setAlignment(Pos.CENTER);
206        buttonRow.setLayoutX(PLAYER_X);
207        buttonRow.setLayoutY(PLAYER_Y - ITEM_HEIGHT - ITEM_GAP);
208        buttonRow.setPrefWidth(PLAYER_WIDTH);
209 
210        Font font = UiStyle.loadGameFont(ITEM_FONT_SIZE);
2111        for (Item item : ItemCatalogue.getBattleOrder()) {
212            GameButton button = new GameButton("", font, ITEM_WIDTH / 2);
2132            button.setGraphic(UiStyle.createIcon(UiStyle.loadImage(images.getItemImage(item)),
214                    ITEM_ICON_SIZE));
2153            button.setContentDisplay(ContentDisplay.TOP);
2164            button.setPrefSize(ITEM_WIDTH, ITEM_HEIGHT);
217            button.addPressEffect();
218            button.setOnAction(event -> useItem(item));
219            itemButtons.put(item, button);
220            buttonRow.getChildren().add(button);
221        }
222        return buttonRow;
223    }

225    private TextArea createLogArea() {
226        TextArea area = new TextArea();
2271        area.setLayoutX(LOG_X);
228        area.setLayoutY(LOG_Y);
229        area.setPrefWidth(ENEMY_X + ENEMY_WIDTH - LOG_X);
230        area.setPrefHeight(LOG_HEIGHT);
231        area.setEditable(false);
2322        area.setFont(UiStyle.createMonospaceFont(FontWeight.NORMAL, LOG_FONT_SIZE));
233        return area;
234    }

167    /* Show the winning or the losing dialog.
168     * The battle is over, so the menu is updated to turn off "Run away".
169     */
170    private void showResult() {
171        getNavigator().updateMenu();
172        if (battle.hasPlayerWon()) {
1732            ModalDialog dialog = new ModalDialog("You Win");
1743            dialog.addButton("Back to it!", event -> getNavigator().winBattle());
175            showDialog(dialog);
176        } else {
177            showDialog(createGameEndDialog("Game Over"));
178        }
179    }

87    /* A dialog for the end of a game, with buttons to go back to the menu or to quit. */
88    protected ModalDialog createGameEndDialog(String heading) {
89        ModalDialog endDialog = new ModalDialog(heading);
905        endDialog.addButton("Return to Main Menu", event -> navigator.returnToMainMenu());
916        endDialog.addButton("Quit", event -> navigator.quit());
92        return endDialog;
93    }

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) {
471        runAway.setDisable(!screen.canRunAway());
482        mainMenu.setDisable(!screen.canReturnToMainMenu());
49    }

99    /* The battle screen is the only screen where the player can run away.
100     * Running away cancels the battle, so it is not possible once the battle is over.
101     */
102    @Override
103    public boolean canRunAway() {
1041        return !battle.isFinished();
105    }

41    /* Whether the "Run away" option can be used. Only the battle screen allows it. */
42    public boolean canRunAway() {
43        return false;
44    }
45 
46    /* Whether the "Main menu" option can be used. Most screens allow it. */
47    public boolean canReturnToMainMenu() {
482        return true;
49    }