基于JavaFX实现的葫芦娃大战妖精游戏设计

目录
基于 Java 的葫芦娃大战妖精 1
1 项目介绍 1
1.1 项目简介 1
1.2 运行方式 2
1.3 实现效果 3
对局结束后显示提示信息 6
2 设计思想 6
2.1 类的设计 6
3 实现细节 7
3.1 图形界面 7
3.2 网络通信 8
3.3 游戏流程控制和用户交互 11
3.4 战斗逻辑 12
3.5 回放功能 14
4 总结 16
4.1 一点优点 16
4.2 一点反思 16
4.3 可改进的地方 16
1 项目介绍
1.1 项目简介
本项目使用 Java 语言编程，运用图形框架 JavaFX，结合网络编程（C/S 架构），实现可供多名玩家在线匹配的 1v1 联机游戏《葫芦娃大战妖精》。
游戏规则：
1.
玩家首先要输入运行服务器的主机 IP 地址与服务器连接，在成功连接服务器后可以通过鼠标点击选择：
1）匹配玩家：选择当前已连接服务器的某一玩家 id（最小为 0）并发送对战邀请，如果对方同意则可以直接进入游戏；相应的，在接受其他玩家发出的对战邀请后也可以直接进入游戏。
2）战斗回放：选择某一用于记录战局的*.xml 文件（文件名为对局时间）可以读取文件内容，并按文件中记录的内容进行战斗回放。
3）退出游戏
在成功匹配玩家后，游戏在 59 的二维空间战场上进行，分为葫芦娃阵营和妖精阵营。游戏开始时葫芦娃阵营（包含七兄弟、老爷爷和穿山甲）与妖精阵营（包括蛇精、蝎子精和小喽啰等）以特定阵型在左右两侧分列站队。玩家可以用键盘的“1”-“9”键选中对应编号的游戏角色；使用"W", “S”, ”A", "D"键控制角色进行上，下，左，右方向的移动；使用“J”键进行攻击（仅能攻击人物朝向的相邻位置的角色），使敌方角色掉血；人物上方的红色血条显示人物剩余血量，血量为 0 时角色死亡，当某一方生物全部死亡时，游戏结束，对局过程将保存到文件中，同时有弹窗提示对局结果。
在进行战斗回放时，会跳出文件选择对话框，选择记录对局过程的.xml 文件即可进行战斗回放。*.xml 文件通常以时间命名，如提交版本中录制的对局：target/2021-01-02 11_34_46.xml
注：需要使用鼠标进行功能选择，并没有添加使用按键的空格键开始对局，"L"键进行战斗回放的交互方式。本文来自：http://www.biyezuopin.vip/onews.asp?id=16768
1.2 运行方式
Tip：CalabashServer 类和 Main 类中都有 main 函数，分别是服务器和客户端的入口。
先运行服务器，可以直接运行 CalabashServer 中的 main 函数，也可以将 pom.xml 文件中的 artifactId 改为 CalabashServer,将 mainClass 修改为 sample.CalabashServer 后打包成 CalabashServer-1.0.jar 后直接运行 target 目录下的 jar 包。即如下修改：
CalabashServer
…



sample.CalabashServer



…
成功运行服务器后，可以在不同的主机上运行客户端，即运行 target 目录下的 jar 包 CalabashWar-1.0.jar。
（生成 CalabashWar-1.0.jar：将 pom.xml 文件中的 artifactId 改为 CalabashWar,将 mainClass 修改为 sample.Main 后执行 mvn package 指令）
（因为 pom.xml 文件的后期修改失误，提交版本中 target 目录下名字为 CalabashServer-1.0.jar 和 CalabashWar-1.0.jar 其实对应的都是客户端的 jar 包，即指定主类为 Main 的 jar 包）

package sample;

import java.io.File;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import javax.xml.transform.TransformerException;

import java.util.Arrays;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
import javafx.scene.image.ImageView;
import javafx.scene.image.Image;
import javafx.scene.layout.Pane;
import javafx.application.Platform;
import javafx.scene.control.Label;
import javafx.scene.control.TextInputDialog;
import javafx.scene.input.MouseEvent;
import javafx.scene.input.KeyEvent;
import javafx.scene.input.KeyCode;
import javafx.scene.control.Alert;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.ChoiceDialog;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.stage.FileChooser;
import javafx.stage.StageStyle;

public class Main extends Application {
    // connect
    int myID;// 自己的id
    int matchPlayerID = -1;// 想匹配的玩家ID
    int enemyID = -1;//
    boolean started = false;
    String serverIP;// 服务器ip地址
    List players = new ArrayList<>();// 当前与服务器连接的可匹配玩家
    // UI
    Pane canvas = new Pane();
    Stage stage = new Stage();
    Scene scene = new Scene(canvas, Attributes.width, Attributes.height);
    double mouseX;
    double mouseY;
    CalabashClient calabashClient;
    Battle battle = new Battle();
    List picsList;
    ArrayList pics = new ArrayList<>();
    ArrayList picsDead = new ArrayList<>();
    ArrayList labels = new ArrayList<>();
    AtomicBoolean playing = new AtomicBoolean(false);

    @Override
    public void init() throws Exception {
        Attributes.init();
    }

    // step1:连接服务器
    void connectServer(int flag) {
        TextInputDialog dialog = new TextInputDialog(Attributes.localServerIP);
        dialog.setTitle("连接服务器");
        if (flag == 0) {
            dialog.setHeaderText("输入服务器IP地址后，按“确定”键连接服务器");
        } else {
            dialog.setHeaderText("服务器连接失败! 请检查服务器是否正在运行及服务器IP地址是否正确后重新输入");
        }
        dialog.setContentText("服务器IP地址：");
        Optional result = dialog.showAndWait();
        if (result.isPresent()) {
            serverIP = result.get();
            calabashClient = new CalabashClient(this);
            if (calabashClient.connect(serverIP)) {
                startInterface();
            } else {
                connectServer(1);
            }
        }
    }

    // step2：选择开始游戏or回放or退出
    public void startInterface() {
        // 背景
        ImageView start = new ImageView(Attributes.images.get(Attributes.START));
        start.setFitHeight(Attributes.height);
        start.setFitWidth(Attributes.width);
        canvas.getChildren().add(start);
        //开始游戏按钮
        ImageView startGame = new ImageView(Attributes.images.get(Attributes.STARTICON));
        startGame.setFitHeight(54);
        startGame.setFitWidth(175);
        Label startLabel = new Label("",startGame);
        startLabel.setLayoutX(350);
        startLabel.setLayoutY(550);
        startLabel.setOnMouseClicked((MouseEvent e)->{ matchPlayer(); });
        canvas.getChildren().add(startLabel);

        //退出按钮
        ImageView exitImage = new ImageView(Attributes.images.get(Attributes.EXITICON));
        exitImage.setFitHeight(54);
        exitImage.setFitWidth(175);
        Label exitLabel = new Label("",exitImage);
        exitLabel.setMaxSize(350,109);
        exitLabel.setLayoutX(950);
        exitLabel.setLayoutY(550);
        exitLabel.setOnMouseClicked((MouseEvent e)->{ System.exit(0); });
        canvas.getChildren().add(exitLabel);

        // 读取进度按钮
        ImageView loadfile = new ImageView(Attributes.images.get(Attributes.LOADICON));
        loadfile.setFitHeight(54);
        loadfile.setFitWidth(175);
        Label loadLabel = new Label("", loadfile);
        loadLabel.setLayoutX(650);
        loadLabel.setLayoutY(550);
        loadLabel.setOnMouseClicked((MouseEvent e) -> {
            try {
                loadProgress();
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        });
        canvas.getChildren().add(loadLabel);

    }

    // step3-1：选择开始游戏后匹配玩家
    void matchPlayer() {
        List choices = new ArrayList<>();
        for (Player p : players) {
            System.out.println(p.id);
            choices.add(Integer.toString(p.id));
        }
        String defaultPlayer;
        if (choices.size() > 0)
            defaultPlayer = choices.get(0);
        else
            defaultPlayer = "--";
        ChoiceDialog dialog = new ChoiceDialog<>(defaultPlayer, choices);
        dialog.setTitle("匹配玩家");
        dialog.setHeaderText("选择当前在线玩家进行战斗吧！若想刷新新玩家请点击“取消”后再按“START“");
        dialog.setContentText("请选择想匹配的玩家id：");
        Optional result = dialog.showAndWait();
        if (result.isPresent() && result.get() != "--") {
            matchPlayerID = Integer.parseInt(result.get());
            InviteMessage message = new InviteMessage(myID, matchPlayerID);
            calabashClient.send(message);
            /*
             * enemyID=matchPlayerID; started=true;
             */
        }
        if (started == true)
            enterBattle();

        // The Java 8 way to get the response value (with lambda expression).
        // result.ifPresent(letter -> System.out.println("Your choice: " + letter));

    }

    //
    void processInvitation(int playerID) {
        Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
        alert.setTitle("玩家邀请");
        alert.setHeaderText("玩家" + Integer.toString(playerID) + "邀请您加入战斗");
        alert.setContentText("是否同意邀请？");
        Optional result = alert.showAndWait();
        if (result.get() == ButtonType.OK) {
            enemyID = playerID;
            battle = new Battle();
            battle.setCamp(Camp.MONSTER);
            started = true;
            enterBattle();
            ReplyMessage r = new ReplyMessage(myID, playerID, 1);
            calabashClient.send(r);
        } else {
            ReplyMessage r = new ReplyMessage(myID, playerID, 0);
            calabashClient.send(r);
        }

    }

    void invitationRefused() {
        Alert alert = new Alert(Alert.AlertType.INFORMATION);
        alert.setTitle("匹配失败");
        alert.setHeaderText(null);
        alert.setContentText("玩家" + Integer.toString(matchPlayerID) + "拒绝了您的邀请，请重新匹配！");
        alert.showAndWait();
    }

    int xToPixel(int x) {// 地图格X坐标转换为像素横坐标
        return Attributes.mapLeft + x * Attributes.gridWidth;
    }

    int yToPixel(int y) {// 地图格Y坐标转换为像素纵坐标
        return Attributes.mapTop + y * Attributes.gridHeight;
    }

    void moveRole(int id,int x,int y){
        //角色图片
        labels.get(id).setLayoutX(xToPixel(x));
        labels.get(id).setLayoutY(yToPixel(y));
        //血量
        labels.get(id + Attributes.hpoffset).setLayoutX(xToPixel(x));
        labels.get(id + Attributes.hpoffset).setLayoutY(yToPixel(y)-3);

        //本地记录移动动作
        battle.gameprogress.writeIn(ActionType.MOVE, id + " " + x + " " + y);
    }

    void waitStart() {// 等待其他玩家进入后开局
        ImageView start = new ImageView(Attributes.images.get(Attributes.START));
        start.setFitHeight(Attributes.height);
        start.setFitWidth(Attributes.width);
        canvas.getChildren().add(start);
        // calabashClient.connect(Attributes.serverIP);
        enterBattle();
    }

    ///
    /**
     * Runs the specified {@link Runnable} on the JavaFX application thread and
     * waits for completion.
     *
     * @param action the {@link Runnable} to run
     * @throws NullPointerException if {@code action} is {@code null}
     */
    static void runAndWait(Runnable action) {
        if (action == null)
            throw new NullPointerException("action");

        // run synchronously on JavaFX thread
        if (Platform.isFxApplicationThread()) {
            action.run();
            return;
        }

        // queue on JavaFX thread and wait for completion
        final CountDownLatch doneLatch = new CountDownLatch(1);
        Platform.runLater(() -> {
            try {
                action.run();
                // new Thread(action).start();
            } finally {
                doneLatch.countDown();
            }
        });

        try {
            doneLatch.await();
        } catch (InterruptedException e) {
            // ignore exception
        }
    }

    /
    void loadProgress() throws InterruptedException {
        FileChooser chooser = new FileChooser();
        chooser.getExtensionFilters().addAll(new FileChooser.ExtensionFilter("Xml Files", "*.xml"));
        File file = chooser.showOpenDialog(stage);
        if (file != null) {
            Playback autoplay = new Playback(file.getPath(), this);
            // autoplay.run();

            //A版本：
            Thread t1 = new Thread(autoplay);
            t1.start();
            // t1.join();
            // startInterface();
            System.out.println("回退");

            // runAndWait(autoplay);
            // final CountDownLatch doneLatch = new CountDownLatch(1);
            // try {
            // new Thread(autoplay).start();
            // } finally {
            // doneLatch.countDown();
            // startInterface();
            // System.out.println("回到主界面");
            // }

        }
        // while (true) {
        //     if (playing.get() == false) {
        //         startInterface();
        //         System.out.println("回到主界面");
        //         break;
        //     }
        // }

    }

    void decorateStage() {
        labels.clear();
        pics.clear();
        picsDead.clear();

        // 显示地图
        ImageView map = new ImageView(Attributes.images.get(Attributes.MAP));
        map.setFitHeight(Attributes.height);
        map.setFitWidth(Attributes.width);
        canvas.getChildren().add(map);

        // 加载角色图片
        picsList = Arrays.asList(new ImageView(Attributes.images.get(Attributes.CALABASH1)),
                new ImageView(Attributes.images.get(Attributes.CALABASH2)),
                new ImageView(Attributes.images.get(Attributes.CALABASH3)),
                new ImageView(Attributes.images.get(Attributes.CALABASH4)),
                new ImageView(Attributes.images.get(Attributes.CALABASH5)),
                new ImageView(Attributes.images.get(Attributes.CALABASH6)),
                new ImageView(Attributes.images.get(Attributes.CALABASH7)),
                new ImageView(Attributes.images.get(Attributes.GRANDPA)),
                new ImageView(Attributes.images.get(Attributes.PANGOLIN)),
                new ImageView(Attributes.images.get(Attributes.SCORPION)),
                new ImageView(Attributes.images.get(Attributes.SNAKE)),
                new ImageView(Attributes.images.get(Attributes.MINION3)),
                new ImageView(Attributes.images.get(Attributes.MINION4)),
                new ImageView(Attributes.images.get(Attributes.MINION5)),
                new ImageView(Attributes.images.get(Attributes.MINION6)),
                new ImageView(Attributes.images.get(Attributes.MINION7)),
                new ImageView(Attributes.images.get(Attributes.MINION8)),
                new ImageView(Attributes.images.get(Attributes.MINION9)));

        pics.addAll(picsList);
        ///
        List picsListDead = Arrays.asList(new ImageView(Attributes.images.get(Attributes.CALABASH1_DEAD)),
                new ImageView(Attributes.images.get(Attributes.CALABASH2_DEAD)),
                new ImageView(Attributes.images.get(Attributes.CALABASH3_DEAD)),
                new ImageView(Attributes.images.get(Attributes.CALABASH4_DEAD)),
                new ImageView(Attributes.images.get(Attributes.CALABASH5_DEAD)),
                new ImageView(Attributes.images.get(Attributes.CALABASH6_DEAD)),
                new ImageView(Attributes.images.get(Attributes.CALABASH7_DEAD)),
                new ImageView(Attributes.images.get(Attributes.GRANDPA_DEAD)),
                new ImageView(Attributes.images.get(Attributes.PANGOLIN_DEAD)),
                new ImageView(Attributes.images.get(Attributes.SCORPION_DEAD)),
                new ImageView(Attributes.images.get(Attributes.SNAKE_DEAD)),
                new ImageView(Attributes.images.get(Attributes.MINION_DEAD)),
                new ImageView(Attributes.images.get(Attributes.MINION_DEAD)),
                new ImageView(Attributes.images.get(Attributes.MINION_DEAD)),
                new ImageView(Attributes.images.get(Attributes.MINION_DEAD)),
                new ImageView(Attributes.images.get(Attributes.MINION_DEAD)),
                new ImageView(Attributes.images.get(Attributes.MINION_DEAD)),
                new ImageView(Attributes.images.get(Attributes.MINION_DEAD)));
        // ArrayList picsDead=new ArrayList<>();
        picsDead.addAll(picsListDead);
        
        for (int i = 0; i < 2 * Attributes.rolesNum; i++) {
            pics.get(i).setFitWidth(100);
            pics.get(i).setFitHeight(100);
            picsDead.get(i).setFitHeight(100);
            picsDead.get(i).setFitWidth(100);
        }
        // 人物的显示
        for (int i = 0; i < 2 * Attributes.rolesNum; i++) {
            Label label = new Label("", pics.get(i));
            label.setLayoutX(Attributes.mapLeft + battle.roles.get(i).curX.get() * Attributes.gridWidth);
            label.setLayoutY(Attributes.mapTop + battle.roles.get(i).curY.get() * Attributes.gridHeight);
            labels.add(label);
            canvas.getChildren().add(label);
        }
        // 血量条的显示
        for (int i = 0; i < 2 * Attributes.rolesNum; i++) {
            battle.hpbars.get(i).setBar(battle.roles.get(i));
            Label labelbar = new Label("", battle.hpbars.get(i));
            labelbar.setLayoutX(Attributes.mapLeft + battle.roles.get(i).curX.get() * Attributes.gridWidth);
            labelbar.setLayoutY(Attributes.mapTop + battle.roles.get(i).curY.get() * Attributes.gridHeight - 3);
            labels.add(labelbar);
            canvas.getChildren().add(labelbar);
        }
        System.out.println("show 地图");
    }

    public void enterBattle() {
        decorateStage();
        battle.enemyId = enemyID;
        if (battle.myCamp == Camp.MONSTER)
            battle.selected = 9;
        else
            battle.selected = 0;

        // 响应键盘，控制角色移动和攻击
        scene.setOnKeyPressed(new EventHandler() {
            @Override
            public void handle(KeyEvent event) {
                int selected = battle.selected;
                String key = event.getText();
                if (key.length() > 0 && key.charAt(0) >= '1' && key.charAt(0) <= '9') {
                    selected = key.charAt(0) - '1';
                    if (battle.myCamp == Camp.MONSTER)
                        selected += 9;
                    battle.selected = selected;
                    System.out.println(selected);
                }
                if (battle.roles.get(selected).alive == false)
                    return;
                if (key.equals("a")) {
                    battle.roles.get(selected).move(Direction.LEFT);
                } else if (key.equals("d")) {
                    battle.roles.get(selected).move(Direction.RIGHT);
                } else if (key.equals("w")) {
                    battle.roles.get(selected).move(Direction.UP);
                } else if (key.equals("s")) {
                    battle.roles.get(selected).move(Direction.DOWN);

                } else if (key.equals("j")) {
                    Direction dir = Direction.RIGHT;
                    if (battle.roles.get(selected).camp == Camp.MONSTER)
                        dir = Direction.LEFT;
                    if (battle.roles.get(selected).healer == false) {
                        int atkid = battle.roles.get(selected).useGnrAtk(dir);
                        AttackMessage message = new AttackMessage(enemyID, selected, dir);
                        battle.gameprogress.writeIn(ActionType.GNRATK, selected + " " + battle.dir2str(dir));
                        calabashClient.send(message);
                        if (atkid != -1) {
                            System.out.println("攻击" + atkid + "血量为" + battle.roles.get(atkid).HP);
                            if (battle.roles.get(atkid).alive == false) {
                                battle.enemyDeadCount++;
                                setDead(atkid);
                                if (battle.enemyDeadCount == Attributes.rolesNum) {
                                    gameOver(true);
                                }
                            }
                        }
                    } else {// 治愈者无攻击能力，按j使用的是治愈术
                        int healid = battle.roles.get(selected).useHealing(dir);
                        AttackMessage message = new AttackMessage(enemyID, selected, dir);
                        battle.gameprogress.writeIn(ActionType.HEAL, selected + " " + battle.dir2str(dir));
                        calabashClient.send(message);
                        if (healid != -1) {
                            System.out.println("治愈" + healid + "血量为" + battle.roles.get(healid).HP);
                        }
                    }
                }
                int x = battle.roles.get(selected).curX.get();
                int y = battle.roles.get(selected).curY.get();
                moveRole(selected, x, y);
                //向服务器发送移动消息
                RoleMoveMessage message=new RoleMoveMessage(enemyID,selected,x,y);
                calabashClient.send(message);
            }
        });

    }

    // step3-3:游戏结束
    void gameOver(boolean winFlag) {
        try {
            battle.gameprogress.saveFile();
        } catch (TransformerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Alert alert = new Alert(Alert.AlertType.INFORMATION);
        alert.setTitle("对战结果");
        alert.setHeaderText(null);
        if (winFlag) {
            alert.setContentText("恭喜您，取得胜利!");
        } else {
            alert.setContentText("很遗憾，对局失败...");
        }

        labels.clear();
        pics.clear();
        picsDead.clear();

        started = false;
        alert.showAndWait();
        startInterface();
    }

    void setDead(int roleID) {
        // labels.get(roleID).setGraphic(picsDead.get(roleID));
        labels.get(roleID).setVisible(false);
        labels.get(roleID).setManaged(false);
        labels.get(roleID + Attributes.hpoffset).setVisible(false);
        labels.get(roleID + Attributes.hpoffset).setManaged(false);
    }

    @Override
    public void start(Stage primaryStage) throws Exception {
        // Parent root = FXMLLoader.load(getClass().getResource("sample.fxml"));
        primaryStage.setTitle("Calabash VS Monster");

        primaryStage.setScene(scene);
        primaryStage.show();

        this.stage = primaryStage;
        canvas.setOnMousePressed((MouseEvent e) -> {
            mouseX = e.getSceneX();
            mouseY = e.getSceneY();
        });
        canvas.setOnMouseDragged((MouseEvent e) -> {
            primaryStage.setX(e.getScreenX() - mouseX);
            primaryStage.setY(e.getScreenY() - mouseY);

        });

        startInterface();
        connectServer(0);
    }

    public static void main(String[] args) {
        launch(args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513