• 实现微服务：匹配系统（中）

    目录

    1、同步两个玩家的位置思路解析

    2、实现了三个棋盘的同步原理

    3、初始化一下我们的playerAplayerB

    4、什么是线程为什么要用多线程？

    5、如何去实现等待两名玩家输入

    6、前端向后端发消息

    7、在数据库中创建表record

    1、同步两个玩家的位置思路解析

     除了地图同步以外、我们还需要同步两个玩家的位置
    同步玩家的位置我们可以标记一下、至于谁在A谁在B我们需要在云端确定
    确定完之后我们会把每一个玩家的位置传给前端，我们可以傻瓜式的确定a在左下角b在
    右上角、我们在存地图的时候需要存一下玩家的id和位置
    在game这个类里我们需要加一个player类来维护玩家的位置信息
    一般开发思路需要用什么定义什么、先定义需要用到的各种函数
    有参构造函数无参构造函数、存一下每个玩家每一次的指令是什么


    2、实现了三个棋盘的同步原理

    现在有三个棋盘、还有一个在云端
    有两个浏览器就是有两个client、状态同步的机制
    client向云端发送消息表示这个蛇动了一下、当服务器接收到两个蛇的移动之后
    服务器就会把两个蛇移动的信息分别返回给Client1client2
    同步给两名玩家、这样我们就实现了三个棋盘的同步 


    3、初始化一下我们的playerAplayerB

    首先我们构造map的时候传入两名玩家的userid、初始化一下我们的playerAplayerB
    为了需要访问到我们的player、我们需要写两个函数
    后端就可以把两个玩家的信息传过去、前端做出相应修改

     


    4、什么是线程为什么要用多线程？

    Game不能作为单线程来处理、线程：一个人干就是单线程，两个人干就是多线程
    涉及到两个线程之间的通信以及加锁的问题
    我们需要先把game变成一个支持多线程的类
    就变成多线程了、我们需要实现thread类的一个入口函数
    alt+insert就可以实现、重载run函数
    start函数就是thread函数的一个api、可以另起一个线程来执行这个函数
    为了方便我们需要先把我们的game存放到这个类里面
    我们的线程就要一步一步等待下一步操作的操作
    这里设计到两个线程同时读写一个变量、这样就会有读写冲突、涉及到顺序问题 


    5、如何去实现等待两名玩家输入

    两名玩家都输入我们就进行下一步
    如果超过一定时间之后两名玩家还没有输入的话
    我们要结束这个操作、告诉我们哪个玩家没有输入
    就输了、可以用sleep函数、如果是正在进行中的话
    我们应该将这一步操作广播给两位玩家、需要同步一下
    我们从服务器分别接收到两名玩家的输入之后、需要将两名玩家的输入分别广
    播给两个人、比如说我们两个玩家，同时都向服务器发送了请求
    c1不知道c2的操作s向c1c2广播操作 


    6、前端向后端发消息

    当我们移动的时候、之前我们是在gamemap里面判断的
    两个线程同时操纵一个变量、至少有一个变量是写的话那就需要加锁子
    前端写完之后后端需要接收到这个请求
    gameobject需要存下来才能访问到蛇、每一个新的游戏都会new一个新的类
    都会开一个新的线程 


    7、在数据库中创建表record

    record表用来记录每局对战的信息

    表中的列：

    id: int
    a_id: int
    a_sx: int
    a_sy: int
    b_id: int
    b_sx: int
    b_sy: int
    a_steps: varchar(1000)
    b_steps: varchar(1000)
    map: varchar(1000)
    loser: varchar(10)
    createtime: datetime

     

    联机对战：同步玩家的操作

    文件结构

    backend
        consumer
            utils
                Cell.java
                Player.java

    src
        components
            ResultBoard.vue

    1.后端：同步玩家位置信息

    玩家类:需要联机对战肯定就有玩家，因此建立玩家类 

    1. package com.kill9.backend.consumer.utils;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. import java.util.List;
    8.  
    9. @NoArgsConstructor
    10. @AllArgsConstructor
    11. @Data
    12. public class Player {
    13.     private Integer id;
    14.     private Integer sx;
    15.     private Integer sy;
    16.     //每一次的指令
    17.     private List steps;
    18. }

    游戏类

    一场游戏包含两名玩家

    1.  private final Player playerA,playerB;
    2.  
    3.  
    4.     final int[][] g;
    5.  
    6.     public Game(
    7.             Integer rows,
    8.             Integer cols,
    9.             Integer innerWallsCount,
    10.             Integer idA,
    11.             Integer idB)
    12.     {
    13.         this.rows = rows;
    14.         this.cols = cols;
    15.         this.innerWallsCount = innerWallsCount;
    16.         this.g = new int[rows][cols];
    17.         playerA = new Player(idA,rows-2,1,new ArrayList<>());
    18.         playerB = new Player(idB,1,cols-2,new ArrayList<>());
    19.  
    20.     }
    21.  
    22. public Player getPlayerA() {
    23.         return playerA;
    24.     }
    25.  
    26.     public Player getPlayerB() {
    27.         return playerB;
    28.     }

    websocket操作类

    在匹配完之后，初始化地图时，将玩家传给Game构造函数

    1. Game game = new Game(13,14,20,a.getId(),b.getId());
    2.             game.createMap();
    3.  
    4.             //封装游戏信息
    5.             JSONObject respGame = new JSONObject();
    6.             respGame.put("a_id",game.getPlayerA().getId());
    7.             respGame.put("a_sx",game.getPlayerA().getSx());
    8.             respGame.put("a_sy",game.getPlayerA().getSy());
    9.             respGame.put("b_id",game.getPlayerB().getId());
    10.             respGame.put("b_sx",game.getPlayerB().getSx());
    11.             respGame.put("b_sy",game.getPlayerB().getSy());
    12.             respGame.put("map",game.getG());
    13.  respA.put("game",respGame);
    14. respB.put("game",respGame);

    2.前端：接收两名玩家位置以及地图信息

    pk类的存储

    1. import ModuleUser from './user'
    2. export default {
    3.     state: {
    4.         socket:null ,//ws连接
    5.         opponent_username:"",
    6.         opponent_photo:"",
    7.         status:"matching",matching表示匹配界面，playing表示对战界面
    8.         gamemap:null,
    9.         a_id:0,
    10.         a_sx:0,
    11.         a_sy:0,
    12.         b_id:0,
    13.         b_sx:0,
    14.         b_sy:0,
    15.     },
    16.     getters: {
    17.  
    18.     },
    19.     mutations: {
    20.         updateSocket(state,socket){
    21.             state.socket = socket;
    22.         },
    23.         updateOpponent(state,opponent){
    24.             state.opponent_username = opponent.username,
    25.             state.opponent_photo = opponent.photo;
    26.         },
    27.         updateStatus(state,status){
    28.             state.status = status;
    29.         },
    30.         updateGame(state,game){
    31.             state.gamemap = game.map;
    32.             state.a_id = game.a_id;
    33.             state.a_sx = game.a_sx;
    34.             state.a_sy = game.a_sy;
    35.             state.b_id = game.b_id;
    36.             state.b_sx = game.b_sx;
    37.             state.b_sy = game.b_sy;
    38.         }
    39.     },
    40.     actions: {
    41.  
    42.  
    43.     },
    44.     modules: {
    45.         user: ModuleUser,
    46.     }
    47. }

    pk界面

    修改pk界面的接收地图相关参数

    1. export default {
    2.     ...
    3.  
    4.     setup() {
    5.         ...
    6.  
    7.         onMounted(() => {
    8.             ...
    9.  
    10.             // 回调函数：接收到后端信息调用
    11.             socket.onmessage = msg => {
    12.                 // 返回的信息格式由后端框架定义，django与spring定义的不一样
    13.                 const data = JSON.parse(msg.data);
    14.                 if(data.event === "start-matching") {
    15.                     ...
    16.  
    17.                     setTimeout(() => {
    18.                         store.commit("updateStatus", "playing");
    19.                     }, 200);
    20.  
    21.                     store.commit("updateGame", data.game);
    22.                 }
    23.             }
    24.  
    25.             ...
    26.         });
    27.  
    28.         ...
    29.     }
    30. }

     

     

    3.后端：一局游戏的逻辑

    Webscoket操作类

    将Game作为一局游戏的一个线程，使Game线程启动 

    1.  private Game game = null;
    2.  
    3.     ...
    4.  
    5.     private void startMatching() {
    6.         System.out.println("start matching!");
    7.         matchPool.add(this.user);
    8.  
    9.         while(matchPool.size() >= 2) {
    10.             ...
    11.  
    12.             game.createMap();
    13.             // 一局游戏一个线程，会执行game类的run方法
    14.             game.start();
    15.  
    16.             users.get(a.getId()).game = game;
    17.             users.get(b .getId()).game = game;
    18.  
    19.             ...
    20.         }
    21.     }
    22.

    游戏类

    一局游戏的操作，首先执行run方法。只有读写、写写有冲突，此处关于nextStep，我们会接收前端的nextStep输入 或 bots代码的输入，而且会频繁的读，因此需要加锁。

    Game.java

    1. package com.kill9.backend.consumer.utils;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Random;
    5. import java.util.concurrent.locks.ReentrantLock;
    6.  
    7. //支持多线程
    8. public class Game extends  Thread{
    9.     private final Integer rows;
    10.     private final Integer cols;
    11.     private final Integer innerWallsCount;
    12.  
    13.     private  final static int[] dx = {-1,0,1,0},dy={0,1,0,-1};
    14.  
    15.     private final Player playerA,playerB;
    16.     private Integer nextStepA = null;
    17.     private Integer nextStepB = null;
    18.     //定义锁
    19.     private ReentrantLock lock = new ReentrantLock();
    20.  
    21.  
    22.     final int[][] g;
    23.  
    24.     public Game(
    25.             Integer rows,
    26.             Integer cols,
    27.             Integer innerWallsCount,
    28.             Integer idA,
    29.             Integer idB)
    30.     {
    31.         this.rows = rows;
    32.         this.cols = cols;
    33.         this.innerWallsCount = innerWallsCount;
    34.         this.g = new int[rows][cols];
    35.         playerA = new Player(idA,rows-2,1,new ArrayList<>());
    36.         playerB = new Player(idB,1,cols-2,new ArrayList<>());
    37.  
    38.     }
    39.     public int[][] getG(){
    40.         return g;
    41.     }
    42.  
    43.     public Player getPlayerA(){
    44.         return playerA;
    45.     }
    46.     public Player getPlayerB(){
    47.         return playerB;
    48.     }
    49.  
    50.     public void setNextStepA(Integer nextStepA){
    51.         //上锁
    52.         lock.lock();
    53.         try{
    54.             this.nextStepA = nextStepA;
    55.         }finally {
    56.             lock.unlock();
    57.         }
    58.  
    59.     }
    60.     public void setNextStepB(Integer nextStepB){
    61.         //上锁
    62.         lock.lock();
    63.         try{
    64.             this.nextStepB = nextStepB;
    65.         }finally {
    66.             lock.unlock();
    67.         }
    68.     }
    69.     //判断连通性 flood fill
    70.     private boolean check_connectivity(int sx,int sy,int tx,int ty){
    71.         if(sx==tx&&sy==ty) return true;
    72.         g[sx][sy] = 1;
    73.         for(int i = 0;i<4;i++){
    74.             int x = sx+dx[i],y = sy+dy[i];
    75.             if(x<this.rows && x>=0 && y<this.cols && y>=0 && g[x][y]==0){
    76.                 if(check_connectivity(x,y,tx,ty)){
    77.                     //恢复原来的数组
    78.                     g[sx][sy] = 0;
    79.                     return true;
    80.                 }
    81.             }
    82.         }
    83.         //恢复现场
    84.         g[sx][sy] = 0;
    85.         return  false;
    86.     }
    87.     //画地图
    88.     private  boolean draw(){
    89.         //初始化
    90.         for(int i = 0;i<this.rows;i++){
    91.             for(int j = 0;j<this.cols;j++){
    92.                 g[i][j] = 0;
    93.             }
    94.         }
    95.  
    96.         //给四周加墙
    97.         for(int r = 0;r<this.rows;r++){
    98.             g[r][0] = g[r][this.cols-1] = 1;
    99.         }
    100.         for(int c = 0;c<this.cols;c++){
    101.             g[0][c] = g[this.rows-1][c] = 1;
    102.         }
    103.         Random random = new Random();
    104.         for(int i = 0;i<this.innerWallsCount/2;i++){
    105.             for(int j = 0;j<1000;j++){
    106.                 int r = random.nextInt(this.rows);
    107.                 int c = random.nextInt(this.cols);
    108.  
    109.                 //画过的不画
    110.                 if(g[r][c]==1||g[this.rows-1-r][this.cols-1-c]==1) continue;
    111.                 g[r][c] = g[this.rows-1-r][this.cols-1-c] = 1;
    112.                 break;
    113.             }
    114.         }
    115.         return check_connectivity(this.rows-2,1,1,this.cols-2);
    116.     }
    117.  
    118.     public void createMap(){
    119.         for(int i = 0;i<1000;i++){
    120.             if(draw()) break;
    121.         }
    122.     }
    123.  
    124.     private boolean nextStep(){
    125.         //每秒五步操作，因此第一步操作是在200ms后判断是否接收到输入。并给地图初始化时间
    126.         //如果两名玩家操作非常快 比如1s操作了50次，但是返回前端，每动完一格之后才会去判断下一步，
    127.         //如果我们在动一格的期间获取了很多下一步的操作的话，我们就会把中间结果都覆盖掉，在前端渲染的时候就会遗漏一些步数
    128.         //所以在进行下一步操作时先睡200ms  ，因为200ms才能走一格，如果200ms内多输入了很多，它之只会留最后一步，就会 覆盖掉
    129.         try {
    130.             Thread.sleep(200);
    131.         } catch (InterruptedException e) {
    132.             throw new RuntimeException(e);
    133.         }
    134.         //等待两名玩家的下一步操作，上锁
    135.             for(int i = 0;i<5;i++){
    136.                 //此循环循环了5000ms，也就是5s，前端是一秒移动5步，
    137.                 //后端接收玩家键盘输入是5s内玩家的一个输入，若在一方先输入，
    138.                 //一方还未输入，输入的一方多此操作，以最后一次为准。
    139.                 try {
    140.                     Thread.sleep(1000);
    141.                     //等待玩家输入
    142.                     lock.lock();//读玩家输入要上锁
    143.                     try{
    144.                         if(nextStepA != null && nextStepB != null){
    145.                             playerA.getSteps().add(nextStepA);
    146.                             playerB.getSteps().add(nextStepB);
    147.                             return true;
    148.                         }
    149.                     }finally {
    150.                         //由于报异常的话 可能不会解锁，所以要在finally解锁
    151.                         lock.unlock();
    152.                     }
    153.                 } catch (InterruptedException e) {
    154.                     e.printStackTrace();
    155.                 }
    156.             }
    157.             return false;
    158.     }
    159.     //入口函数
    160.     @Override
    161.     public void run() {
    162.         super.run();
    163.     }
    164. }

    先搭好整体框架 

    1.  private void sendResult(){ //向两名玩家返回结果
    2.         
    3.     }
    4.     private void judge(){//判断两名玩家是否合法操作
    5.         
    6.     }
    7.     private void sendMove(){ //向两个client公布信息
    8.         
    9.     }
    10.     //入口函数
    11.     @Override
    12.     public void run() {
    13.         for(int i = 0;i<1000;i++){
    14.             //先判断是否获取两条蛇的下一步操作
    15.             if(nextStep()){ // 是否获取了两条蛇的下一步的操作
    16.                 judge();
    17.                 if(status.equals("playing")){
    18.                     //将每名玩家的操作广播给两名玩家，实现同步
    19.                     sendMove();
    20.                 }else{
    21.                     //向前端返回结果
    22.                     sendResult();
    23.                     break;
    24.                 }
    25.             }else{
    26.                 //这里也要加锁 涉及到nextStep的读 防止边界情况 ，在超时的边界输入
    27.                 lock.lock();
    28.                 status = "finished";
    29.                 try{
    30.                     if(nextStepA == null && nextStepB == null){
    31.                         loser = "all";
    32.                     }else if(nextStepA == null){
    33.                         loser =  "A";
    34.                     }else{
    35.                         loser = "B";
    36.                     }     
    37.                 }finally {
    38.                     lock.unlock();
    39.                 }
    40.                 sendResult();
    41.                 break;// 表示整个游戏结束
    42.             }
    43.         }
    44.     }
    45. }
    1.   private void sendAllMessage(String message){
    2.         WebSocketServer.users.get(playerA.getId()).sendMessage(message);
    3.         WebSocketServer.users.get(playerB.getId()).sendMessage(message);
    4.         
    5.     }
    6.     private void sendResult(){ //向两名玩家返回结果
    7.         //向本局的两名玩家分别广播
    8.         JSONObject resp = new JSONObject();
    9.         resp.put("event","result");
    10.         resp.put("loser",loser);
    11.         sendAllMessage(resp.toJSONString());
    12.     }
    13.     private void judge(){//判断两名玩家是否合法操作
    14.  
    15.     }
    16.     private void sendMove(){ //向两个client公布信息
    17.         lock.lock();
    18.         try{
    19.             JSONObject resp = new JSONObject();
    20.             resp.put("event","move");
    21.             resp.put("a_direction",nextStepA);
    22.             resp.put("b_direction",nextStepB);
    23.             //清空操作
    24.             nextStepA = nextStepB = null;
    25.         }finally {
    26.             lock.unlock();
    27.         }
    28.         
    29.     }

    4.前端: 发送移动指令给后端

    GameMap.js

    1. add_listening_events() {
    2.         this.ctx.canvas.focus();
    3.         this.ctx.canvas.addEventListener("keydown", e => {
    4.             let d = -1;
    5.             if(e.key === 'w') d = 0;
    6.             else if(e.key === 'd') d = 1;
    7.             else if(e.key === 's') d = 2;
    8.             else if(e.key === 'a') d = 3;
    9.             // else if(e.key === 'ArrowUp') snake1.set_direction(0);
    10.             // else if(e.key === 'ArrowRight') snake1.set_direction(1);
    11.             // else if(e.key === 'ArrowDown') snake1.set_direction(2);
    12.             // else if(e.key === 'ArrowLeft') snake1.set_direction(3);
    13.  
    14.             // 若移动了，发送给后端
    15.             if(d >= 0) {
    16.                 this.store.state.pk.socket.send(JSON.stringify({
    17.                     event: "move",
    18.                     direction: d,
    19.                 }));
    20.             }
    21.         });
    22.     }

    5.后端处理接收移动的事件

    1. private void move(int d){
    2.  
    3.         if(game.getPlayerA().getId().equals(user.getId())) {
    4.             game.setNextStepA(d);
    5.         }else if(game.getPlayerB().getId().equals(user.getId())){
    6.             game.setNextStepB(d);
    7.         }
    8.  
    9.     }
    10.  
    11.     //路由
    12.     @OnMessage
    13.     public void onMessage(String message, Session session) {
    14.         // 从Client接收消息
    15.         System.out.println("receive message!");
    16.         //将字符串转换成json对象
    17.         JSONObject data = JSONObject.parseObject(message);
    18.         String event = data.getString("event");
    19.         //防止空指针
    20.         if("start-matching".equals(event)){
    21.             startMatching();
    22.         }else if("stop-matching".equals(event)){
    23.             stopMatching();
    24.         }else if("move".equals(event)){
    25.             move(data.getInteger("direction"));
    26.         }
    27.     }

    6前端接收后端发送过来的移动事件

    设立GameMap的存储

    1. src/store/pk.js
    2.  
    3. export default {
    4.   state: {
    5.     ...
    6.  
    7.     gameObject: null,
    8.   },
    9.   getters: {
    10.   },
    11.   mutations: {
    12.     ...
    13.  
    14.     updateGameObject(state, gameobject) {
    15.         state.gameObject = gameobject;
    16.     }
    17.   },
    18.   actions: {
    19.  
    20.   },
    21.   modules: {
    22.   }
    23. }

    GameMap存储

    1. src/components/GameMap.vue
    2.  
    4.  
    6.

    Pk页面：接收后端的移动事件

    1. src/views/pk/PkIndexView.vue
    2.  
    4.  
    6.  
    8.

    7.前端：根据后端返回结果将死了的蛇变白

    Snake.js

    删除前端判断蛇的操作是否有效

    1. export class Snake extends AcGameObject {
    2.     ...
    3.  
    4.     // 将蛇状态变为走下一步
    5.     next_step() {
    6.         ...
    7.  
    8.         // 让蛇在下一回合长一个格子
    9.         const k = this.cells.length;
    10.         for(let i = k; i > 0; i--) {
    11.             this.cells[i] = JSON.parse(JSON.stringify(this.cells[i - 1]));
    12.         }
    13.  
    14.         // 删除前端判断蛇的操作是否有效
    15.     }
    16.  
    17.     ...
    18. }

    PkIndexView.vue

    根据后端结果将失败的一方颜色变白

    1. // 回调函数：接收到后端信息调用
    2.             socket.onmessage = msg => {
    3.                 // 返回的信息格式由后端框架定义，django与spring定义的不一样
    4.                 const data = JSON.parse(msg.data);
    5.                 if(data.event === "start-matching") {
    6.                     ...
    7.                 } else if(data.event === "move") {
    8.                     ...
    9.                 } else if(data.event === "result") {
    10.                     console.log(data);
    11.                     const game = store.state.pk.gameObject;
    12.                     const [snake0, snake1] = game.snakes;
    13.  
    14.                     if(data.loser === "all" || data.loser === "A") {
    15.                         snake0.status = "die";
    16.                     }
    17.                     if(data.loser === "all" || data.loser === "B") {
    18.                         snake1.status = "die";
    19.                     }
    20.                 }
    21.             }

    8.后端：将前端的裁判程序移到后端

    注意，此地方有两处代码有迷惑性，分别是：
    1. 在Player.java的getCells函数里为什么删除的是第0个元素
    2. 在Game.java的check_valid函数里为什么不判断最后一个元素是否重合
    以上两个答案在下方代码的关键处有解释

    Cell.java

    1. package com.kill9.backend.consumer.utils;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. @Data
    8. @AllArgsConstructor
    9. @NoArgsConstructor
    10. public class Cell {
    11.     private Integer x;
    12.     private Integer y;
    13. }

    Player.java 

    1. package com.kill9.backend.consumer.utils;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. import java.util.ArrayList;
    8. import java.util.List;
    9.  
    10. @NoArgsConstructor
    11. @AllArgsConstructor
    12. @Data
    13. public class Player {
    14.     private Integer id;
    15.     private Integer sx;
    16.     private Integer sy;
    17.     //每一次的指令
    18.     private List steps;
    19.     private boolean check_tail_increasing(int step){//检验当前回合蛇的长度是否增加
    20.         if(step<=10) return true;
    21.         return step % 3 == 1;
    22.     }
    23.  
    24.     public List getCells(){
    25.         List res = new ArrayList<>();
    26.         int[] dx={-1,0,1,0},dy = {0,1,0,-1};
    27.         int x = sx,y = sy;
    28.         int step = 0;
    29.         /**
    30.          * 每一步移动都会把蛇头移动到下一个格子(注：蛇头有两个cell，详看前端Snake.js的next_step()与update_move()逻辑)，
    31.          * 若当前长度增加，蛇头正好移到新的一个格子，剩下的蛇身长度不变，因此长度 + 1；若长度不增加，则删除蛇尾
    32.          */
    33.         res.add(new Cell(x,y));
    34.         for(int d: steps){
    35.             x += dx[d];
    36.             y += dy[d];
    37.             res.add(new Cell(x,y));
    38.             if(!check_tail_increasing(++step)){
    39.                 /**
    40.                  * 关键：
    41.                  * 为什么此处删除0呢，首先存储蛇身、且判定是否增加、且画蛇的逻辑此时还是在前端，我们只是将
    42.                  * 判断蛇是否撞到 墙和蛇身 移到后端。并且我们在后端保存的是是蛇头的x、y坐标和蛇身相对
    43.                  * 于上一步操作的方向，但是在我们做了第一个操作后蛇尾才是蛇头，意思就是res逆序才是蛇
    44.                  * 头到蛇尾的位置！
    45.                  */
    46.                 res.remove(0);//删掉蛇尾
    47.             }
    48.             return  res;
    49.         }
    50.     }
    51.  
    52. }

     Game.java

    1. public class Game extends Thread {
    2.     ...
    3.  
    4.     private boolean check_valid(List cellsA, List cellsB) {
    5.         int n = cellsA.size();
    6.         Cell cell = cellsA.get(n - 1);
    7.         // 如果是墙，则非法
    8.         if(g[cell.x][cell.y] == 1) return false;
    9.  
    10.         // 遍历A除最后一个Cell
    11.         /**
    12.          * 关键：
    13.          * 首先我在Player中已经解释getCells的函数返回的res是蛇尾到蛇头的位置。
    14.          * 因此以下两个for循环分别判断的是蛇头是否和两条蛇的蛇身重合！
    15.          * 那么为什么不用判断两个蛇头是否重合呢？可能是地图大小为13 * 14，
    16.          * 两个蛇头的位置初始为(1, 1)和(11, 12)，两个蛇头的位置横纵之和分别为偶数
    17.          * 和奇数，因此两个蛇头永远不会走到同一个格子！
    18.          */
    19.         for(int i = 0; i < n - 1; i++) {
    20.             // 和蛇身是否重合
    21.             if(cellsA.get(i).x == cell.x && cellsA.get(i).y == cell.y) {
    22.                 return false;
    23.             }
    24.         }
    25.  
    26.         // 遍历B除最后一个Cell
    27.         for(int i = 0; i < n - 1; i++) {
    28.             // 和B蛇身是否重合
    29.             if(cellsB.get(i).x == cell.x && cellsB.get(i).y == cell.y) {
    30.                 return false;
    31.             }
    32.         }
    33.         return true;
    34.     }
    35.  
    36.     private void judge() {      // 判断两名玩家操作是否合法
    37.         List cellsA = playerA.getCells();
    38.         List cellsB = playerB.getCells();
    39.  
    40.         boolean validA = check_valid(cellsA, cellsB);
    41.         boolean valibB = check_valid(cellsB, cellsA);
    42.  
    43.         if(!validA || !valibB) {
    44.             status = "finished";
    45.             if(!validA && !valibB) {
    46.                 loser = "all";
    47.             } else if(!validA) {
    48.                 loser = "A";
    49.             } else {
    50.                 loser = "B";
    51.             }
    52.         }
    53.     }
    54.  
    55.     private void senAllMessage(String message) {
    56.         ...
    57.     }
    58.  
    59.     private void sendMove() {   // 向两名玩家传递移动信息
    60.         ...
    61.     }
    62.  
    63.     private void sendResult() {     // 向两名玩家发送游戏结果
    64.         ...
    65.     }
    66.  
    67.     @Override
    68.     public void run() {
    69.         ...
    70.     }
    71. }
    72.

    9.结果板的实现

    pk信息存储类

    1. src/store/pk.js
    2.  
    3. export default {
    4.   state: {
    5.     ...
    6.     loser: "none",  // all、A、B
    7.   },
    8.   getters: {
    9.   },
    10.   mutations: {
    11.     ...
    12.     updateLoser(state, loser) {
    13.         state.loser = loser;
    14.     }
    15.   },
    16.   actions: {
    17.  
    18.   },
    19.   modules: {
    20.   }
    21. }

     ResultBoard.vue

    1. src/components/ResultBoard.vue

    Pk页面

    1. src/views/pk/PkIndexView.vue
    2.  
    4.  
    6.

    完善pk页面 对局中添加玩家头像，确认自己是哪条蛇

    PlayGround.vue

    2.  
    4.

    对局回放

    通过保存对局每个状态的信息实现对局的回放功能

    backend
        pojo
            Record.java
        mapper
            RecordMapper.java 

    创建数据库

     

    Record.java

    1. package com.kill9.backend.pojo;
    2.  
    3. import com.baomidou.mybatisplus.annotation.IdType;
    4. import com.baomidou.mybatisplus.annotation.TableId;
    5. import com.fasterxml.jackson.annotation.JsonFormat;
    6. import lombok.AllArgsConstructor;
    7. import lombok.Data;
    8. import lombok.NoArgsConstructor;
    9.  
    10. import java.util.Date;
    11.  
    12. @Data
    13. @AllArgsConstructor
    14. @NoArgsConstructor
    15. public class Record {
    16.     @TableId(type = IdType.AUTO)
    17.     private Integer id;
    18.     private Integer aId;
    19.     private Integer aSx;
    20.     private Integer aSy;
    21.     private Integer bId;
    22.     private Integer bSx;
    23.     private Integer bSy;
    24.     private String aSteps;
    25.     private String bSteps;
    26.     private String map;
    27.     private String loser;
    28.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
    29.     private Date createtime;
    30. }

    RecordMapper.java

    1. package com.kill9.backend.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.kill9.backend.pojo.Record;
    5. import org.apache.ibatis.annotations.Mapper;
    6.  
    7. @Mapper
    8. public interface RecordMapper extends BaseMapper {
    9. }

    WebSocketServer.java

    注入RecordMapper，为了保存对局信息

    1. @Component
    2. // url链接：ws://127.0.0.1:3000/websocket/**
    3. @ServerEndpoint("/websocket/{token}")  // 注意不要以'/'结尾
    4. public class WebSocketServer {
    5.     ...
    6.  
    7.     private static UserMapper userMapper;
    8.     public static RecordMapper recordMapper;
    9.  
    10.     ...
    11.  
    12.     @Autowired
    13.     public void setRecordMapper(RecordMapper recordMapper) {
    14.         WebSocketServer.recordMapper = recordMapper;
    15.     }
    16.  
    17.     ...
    18.  
    19. }

     Player.java

    将玩家的蛇的方向偏移量转化成String

    1. @Data
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. public class Player {
    5.  
    6.     ...
    7.  
    8.     public String getStepsString() {
    9.         StringBuilder res = new StringBuilder();
    10.         for(int d : steps) {
    11.             res.append(d);
    12.         }
    13.         return res.toString();
    14.     }
    15. }

    Game.java

    将对局信息保存至数据库

    1. public class Game extends Thread {
    2.  
    3.     ...
    4.  
    5.     private String getMapString() {
    6.         StringBuilder res = new StringBuilder();
    7.         for(int i = 0; i < rows; i++) {
    8.             for(int j = 0; j < cols; j++) {
    9.                 res.append(g[i][j]);
    10.             }
    11.         }
    12.         return res.toString();
    13.     }
    14.  
    15.     private void saveToDataBase() {
    16.         Record record = new Record(
    17.                 null,
    18.                 playerA.getId(),
    19.                 playerA.getSx(),
    20.                 playerA.getSy(),
    21.                 playerB.getId(),
    22.                 playerB.getSx(),
    23.                 playerB.getSy(),
    24.                 playerA.getStepsString(),
    25.                 playerB.getStepsString(),
    26.                 getMapString(),
    27.                 loser,
    28.                 new Date()
    29.         );
    30.         WebSocketServer.recordMapper.insert(record);
    31.     }
    32.  
    33.     private void sendResult() {     // 向两名玩家发送游戏结果
    34.         ...
    35.  
    36.         saveToDataBase();
    37.         senAllMessage(resp.toJSONString());
    38.     }
    39.  
    40.     ...
    41. }
    42.

     完成～～

  • 相关阅读:
    CSS 选择器
    uni-app——网络请求、数据缓存
    华为云两台机器内网互联
    链表的基本操作
    小巧有劲的按摩好手，能装兜里的护理工具，小鸟斗士筋膜枪体验
    【美团3.18校招真题2】
    c++后端开发书籍推荐
    Qt扩展-KDDockWidgets 的使用
    刷题-最长回文子串-C++解法
    网站页头被挂马状态及新增了index.html文件解决思路
  • 原文地址：https://blog.csdn.net/weixin_49884716/article/details/127949262