我正在使用套接字在java中制作一个多玩家蛇游戏。所有传输都通过服务器完成到所有连接的客户端。相同的代码还没有完全完成，但它的基本工作是移动蛇并增加分数，如果一个特定的客户吃它的食物。
我从服务器端生成食物坐标的随机数，并将其转发给所有客户端。如果客户端按下一个键，则计算所请求的移动并将移动方向发送到服务器，然后服务器将移动中继到所有客户端（包括发送它的人），并且仅在收到移动信息时客户端进行更改移动的蛇。因此，每个动作都通过网络进行跟踪，客户端本身不会做出任何动作决定，直到它收到，即客户'player1'要求移动。
我面临的问题是，即使有两个玩家，在稍微移动一下蛇之后坐标似乎也会有所不同。
我可以将哪些可能的补救措施应用于我的代码，以消除这种明显的蛇位置之间的滞后？
这是客户端代码：
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;
}
}
}
}
答案 0 :(得分：2)
这个答案是回顾对话框以找到解决方案，并指出一些其他领域进行研究或试用。
主要的软件行为问题是，拥有多个客户端导致各个客户在多次移动后显示不同的蛇位置。
在通过评论提出一些问题和回复之后，问题的海报修改了他们的软件，以便所有客户端通过服务器同步将所有蛇的对象发送给所有客户端，以便所有客户端客户端现在使用相同的蛇对象。以前，每个客户端都维护自己的蛇对象数据，只接收蛇数据中的更改或增量。通过此更改，所有客户端现在通过服务器传输的snake对象进行同步，但是客户端仍然存在问题，显示稍微不同的位置，在一两分钟后更正，因为每个客户端都收到所有客户端的更新蛇，客户再次同步。
下一步是研究一种不同的方法，以便客户端使用UDP / IP作为网络传输协议而不是当前使用的TCP / IP更紧密地保持同步。使用UDP / IP的预期结果是减少TCP network transmission protocol引入的各种滞后，以便提供由TCP提供的面向连接的顺序字节流。但是，使用UDP network transmission protocol要求TCP使用的某些传递机制必须由UDP用户承担。
UDP的一些问题是：（1）数据包可能不会以与发送数据包相同的顺序接收，（2）数据包可能被丢弃或丢失，因此可能无法接收发送的某些数据包，以及（ 3）使用UDP发送的数据必须明确地放入数据包进行传输，以便发送方和接收方看到数据包而不是字节流。
这个蛇游戏的基本架构如下所示。
客户端会将蛇更新发送到服务器。此交互需要服务器发送回客户端的确认。如果客户端没有收到这样的确认，客户端将在一段时间后重新发送蛇更新。
然后，服务器将更新其数据以反映更改并使用其客户端列表，将相同的数据包发送到所有客户端。接收数据包的每个客户端都会发送确认。通过发送确认，每个客户端通知服务器他们仍然在游戏中。如果服务器不再接收客户端确认，它将知道客户端可能已离开游戏或存在某种网络问题。
每个数据包都有一个序列号，在发送数据包后会递增。此序列号提供唯一标识符，以便客户端和服务器可以检测是否丢失了数据包，或者收到的数据包是否与已接收数据包重复。
使用UDP时，最好是数据包尽可能小。大于可以在底层IP网络协议中发送的UDP数据包的UDP数据包将被分成多个IP数据包，一次一个地发送多个IP数据包，然后在接收网络节点重新组装成UDP数据包。
以下是使用Java编程语言的UDP网络协议的一些资源。
A simple Java UDP server and UDP client
Stackoverflow: Send and receive serialize object on UDP in java
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?
答案 1 :(得分：0)
我之前从未实现过网络多人游戏，但我认为这里使用最广泛的“解决方案”就是作弊。
我认为它被称为“航位推算”，尽管蛇无论如何都是这样的。
http://www.gamasutra.com/view/feature/3230/dead_reckoning_latency_hiding_for_.php
基本上，您将游戏循环与网络更新分离。让每个客户保持自己的状态，并简单地预测对手在每一帧的位置。然后，当来自服务器的更新到达时，您可以将对手调整到他们的真实位置。为了隐藏这种差异，我认为通常会在几毫秒之前呈现游戏状态，而不是当前状态。通过这种方式，网络更新有更准确的机会赶上游戏循环，因此它看起来不那么波动。
正如我所说的，我自己从未真正实现过这个YMMV。这是游戏开发中较难的问题之一。
答案 2 :(得分：0)
我倾向于添加一个setTcpNoDelay（true）的显式调用。这样可以确保http://en.wikipedia.org/wiki/Nagle%27s_algorithm处于关闭状态，因此请禁用优化，以提高效率，通常会增加一小段延迟。