java - 滞后套接字java

Question

我正在使用套接字在 Java 中制作多人贪吃蛇游戏。所有传输都通过服务器完成到所有连接的客户端。相同的代码尚未完全完成，但它完成了移动蛇的基本工作，并在特定客户吃了它的食物时增加分数。

我从服务器端为食物坐标生成随机数并将其转发给所有客户端。如果客户端按下一个键，则计算请求的移动并将移动方向发送到服务器，然后服务器将移动转发给所有客户端(包括发送它的客户端)，并且只有在收到移动信息后，客户端才会进行更改到移动的蛇。因此，每个 Action 都会通过网络进行跟踪，并且在收到之前，客户端本身不会做出任何移动决定，比如客户端“玩家 1”已请求移动。

我面临的问题是，即使有两名玩家，在蛇周围稍微移动后坐标似乎也有所不同。

我可以对我的代码应用哪些可能的补救措施，以消除蛇位置之间的这种明显滞后？

这是客户端代码:

package mycode;

import java.awt.Point;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Map;

import javax.swing.JOptionPane;

public class ConnectionManager implements Runnable {
    Socket socket;
    boolean start = false;
    DataInputStream in;
    DataOutputStream out;
    Map<String, Snake> map;

    ConnectionManager(String name, String IP, Map<String, Snake> m) {
        this.map = m;
        try {
            socket = new Socket(IP, 9977);
            in = new DataInputStream(new BufferedInputStream(
                    socket.getInputStream()));
            out = new DataOutputStream(new BufferedOutputStream(
                    socket.getOutputStream()));
            out.writeUTF(name);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
            JOptionPane.showMessageDialog(null, "Could Not Find Server",
                    "ERROR", JOptionPane.ERROR_MESSAGE);
            System.exit(0);
        }
    }

    void populateMap() {
        try {
            String name = in.readUTF();
            System.out.println("Name received: " + name);
            if (name.equals("start_game_9977")) {
                start = true;
                System.out.println("Game Started");
                return;
            } else if (name.equals("food_coord")) {
                Game.foodx = in.readInt();
                Game.foody = in.readInt();
                return;
            }
            map.put(name, new Snake(5));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    boolean start() {
        return start;
    }

    void increaseSnakeLength(String thisname){
        Snake temp = map.get(thisname);
        Point temp1=new Point(0,0);
        temp.length++;
        switch (temp.move) {
        case DOWN:
             temp1= new Point(temp.p[temp.length - 2].x,
                    temp.p[temp.length - 2].y+6);
             break;
        case LEFT:
            temp1= new Point(temp.p[temp.length - 2].x-6,
                    temp.p[temp.length - 2].y);
            break;
        case RIGHT:
            temp1= new Point(temp.p[temp.length - 2].x+6,
                    temp.p[temp.length - 2].y);
            break;
        case UP:
            temp1= new Point(temp.p[temp.length - 2].x,
                    temp.p[temp.length - 2].y-6);
            break;
        default:
            break;
        }
        if(temp1.y>Game.max)
            temp1.y=Game.min;
        if(temp1.x>Game.max)
            temp1.x=Game.min;
        if(temp1.y<Game.min)
            temp1.y=Game.max;
        if(temp1.x<Game.min)
            temp1.x=Game.max;
        temp.p[temp.length-1]=temp1;
    }

    void readMotion() {
        try {
            while (true) {
                if (Game.changedirection) {
                    String mov = "";
                    mov = Game.move.name();
                    // System.out.println(Game.move);
                    out.writeUTF(mov);
                    out.flush();
                    Game.changedirection = false;
                }
                if (Game.foodeaten) {
                    out.writeUTF("food_eaten");
                    out.flush();
                    Game.foodeaten = false;
                }
                Thread.sleep(50);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    void otherRunMethod() {
        try {
            while (true) {
                String mname = in.readUTF();
                String mov = in.readUTF();
                if (mov.equals("Resigned")) {
                    map.remove(mname);
                } else if (mov.length() >= 10) {
                    if (mov.substring(0, 10).equals("food_eaten")) {
                        String[] s = mov.split(",");
                        Game.foodx = Integer.parseInt(s[1]);
                        Game.foody = Integer.parseInt(s[2]);
                        int score = ++map.get(mname).score;
                        increaseSnakeLength(mname);
                        System.out.println(mname + ":" + score+" Length:"+map.get(mname).length);
                    }
                } else {
                    Game.move = Direction.valueOf(mov);
                    map.get(mname).move = Game.move;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true) {
            if (!start) {
                populateMap();
            } else if (start) {
                new Thread(new Runnable() {
                    public void run() {
                        otherRunMethod();
                    }
                }).start();
                readMotion();
                break;
            }
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

代码很长，所以我只放置管理连接的服务器端代码。

package mycode;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.util.Map;

public class Playerhandler implements Runnable {
    Socket player;
    String thisname;
    Map<String, Socket> map;
    DataInputStream in = null;
    DataOutputStream out = null;
    ObjectInputStream ob;
    Snake snake;

    Playerhandler(Socket player, Map<String, Socket> m) {
        this.player = player;
        this.map = m;
        try {
            in = new DataInputStream(new BufferedInputStream(
                    player.getInputStream()));
            thisname = in.readUTF();
            map.put(thisname, this.player);
            populatePlayers();
            System.out.println("Connected Client " + thisname);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    void populatePlayers() {
        try {
            out = new DataOutputStream(new BufferedOutputStream(
                    player.getOutputStream()));
            for (String name : map.keySet()) {
                out.writeUTF(name);
                out.flush();
            }

            for (String name : map.keySet()) {
                out = new DataOutputStream(new BufferedOutputStream(map.get(
                        name).getOutputStream()));
                out.writeUTF(thisname);
                out.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    void relay(String move) {
        try {
            if (move.equals("food_eaten")) {
                move = move + ","
                        + (Snakeserver.randomGenerator.nextInt(100) * 6) + ","
                        + (Snakeserver.randomGenerator.nextInt(100) * 6);

            }
            for (String name : map.keySet()) {
                out = new DataOutputStream(new BufferedOutputStream(map.get(
                        name).getOutputStream()));
                out.writeUTF(thisname);
                out.flush();
                out.writeUTF(move);
                // System.out.println(Direction.valueOf(move));
                out.flush();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void run() {
        while (true) {
            try {
                relay(in.readUTF());
            } catch (IOException e) {
                // TODO Auto-generated catch block
                System.out.println("Player " + thisname + " Resigned");
                map.remove(thisname);
                relay("Resigned");
                return;
            }
        }
    }

}

Answer 1

这个答案是为了重述对话以得出解决方案，并指出一些需要研究或尝试的其他领域。

主要的软件行为问题是，拥有多个客户端会导致多个客户端在多次移动后显示不同的蛇形位置。

在通过评论提出一些问题和答复后，问题的发布者修改了他们的软件，以便所有客户端都由服务器同步，将所有蛇的对象发送给所有客户端，以便所有客户端现在使用相同的蛇对象。以前，每个客户端都在维护自己的蛇对象数据，并且只接收蛇数据中的更改或增量。通过此更改，所有客户端现在都通过服务器传输的 snake 对象进行同步，但是仍然存在客户端显示略有不同位置的问题，该问题在一两分钟后得到纠正，因为每个客户端都会收到所有snakes，客户端再次同步。

下一步是研究一种不同的方法，以便客户端使用 UDP/IP 作为网络传输协议(protocol)而不是当前使用的 TCP/IP 来保持更紧密的同步。使用 UDP/IP 的预期结果是减少 TCP network transmission protocol 引入的各种延迟。为了提供TCP提供的面向连接的、有序的字节流。但是使用 UDP network transmission protocol要求 UDP 的用户必须假定 TCP 使用的某些传递机制以提供可靠的字节序列。

UDP 的一些问题是:(1) 数据包的接收顺序可能与发送的顺序不同，(2) 数据包可能被丢弃或丢失，因此可能无法接收到某些已发送的数据包，以及 ( 3) 使用UDP发送的数据必须显式放入数据包中进行传输，以便发送方和接收方看到的是数据包而不是字节流。

这款贪吃蛇游戏的基本架构如下所示。

客户端会向服务器发送蛇更新。此交互需要服务器向客户端发送回确认。如果客户端没有收到这样的确认，客户端将在一段时间后重新发送蛇更新。

服务器随后会更新其数据以反射(reflect)更改，并使用其客户端列表向所有客户端发送相同的数据包。每个收到数据包的客户端都会发送一个确认。通过发送确认，每个客户端通知服务器他们仍在游戏中。如果服务器不再收到客户端确认，它就会知道客户端可能已经离开游戏或存在某种网络问题。

每个数据包都有一个序列号，该序列号在发送数据包后递增。此序列号提供了一个唯一标识符，以便客户端和服务器可以检测是否丢失了数据包，或者接收到的数据包是否与已接收到的数据包重复。

对于 UDP，数据包最好尽可能小。大于底层 IP 网络协议(protocol)可以发送的 UDP 数据包将被拆分为多个 IP 数据包，多个 IP 数据包一次发送一个，然后在接收网络节点重新组合成 UDP 数据包。

这里有一些使用 Java 编程语言的 UDP 网络协议(protocol)资源。

Lesson: All about datagrams .

A simple Java UDP server and UDP client .

Stackoverflow: Send and receive serialize object on UDP in java .

Java-Gaming.org UDP vs TCP .

Gaffer On Games: What every programmer needs to know about game networking .

Gaffer On Games: Reliability and Flow control .

Stackoverflow: What are possible ways to send Game/Simulation state with javaNIO?