Estou a desenvolver um pequeno jogo (faculdade) num ambiente Cliente-Servidor.
Visto que é um jogo com personagens que se movem constantemente ou seja, não é um jogo de tabuleiro, preciso de actualizar os clientes a cada momento.
Mas a minha dúvida é como o fazer?
Eu nas aulas dei o método para Serializar e Sockets. Nada mais para resolver este tipo de problema. Sendo assim, o código que recebe e manda é o seguinte:
import java.net.Socket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.File;
import java.io.FileInputStream;
public class FileClient {
private Socket socket;
public FileClient() {
try {
this.socket = new Socket(InetAddress.getLocalHost(), 9191);
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
FileClient fc = new FileClient();
fc.comeca();
}
private void comeca() {
while(true){
enviaJogo();
}
}
private void enviaJogo() {
try {
FileOutputStream fos = new FileOutputStream("jogo.ser");
ObjectOutputStream out = new ObjectOutputStream(fos);
Objecto um = new Objecto("Blabla", 1);
out.writeObject(um);
out.close();
} catch (IOException ex) {
ex.printStackTrace();
}
File f = new File("jogo.ser");
try {
ObjectOutputStream out = new ObjectOutputStream(
socket.getOutputStream());
System.out.println("Transferindo o arquivo: " + f.getName());
out.writeUTF(f.getName());
out.writeLong(f.length());
FileInputStream in = new FileInputStream(f);
byte[] buf = new byte[4096];
while (true) {
int len = in.read(buf);
if (len == -1)
break;
out.write(buf, 0, len);
}
out.close();
socket.close();
System.out.println("Pronto.");
} catch (Exception e) {
e.printStackTrace();
}
}
}
import java.net.ServerSocket;
import java.net.Socket;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.FileOutputStream;
public class FileServer {
private ServerSocket ss;
private Socket socket;
public FileServer() {
try {
ss = new ServerSocket(9191);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
FileServer fs = new FileServer();
fs.comeca();
}
private void comeca() {
try {
socket = ss.accept();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
while(true){
recebeJogo();
}
}
private void recebeJogo() {
try {
System.out.println("Esperando por arquivos.");
ObjectInputStream in = new ObjectInputStream(
socket.getInputStream());
String fileName = in.readUTF();
long size = in.readLong();
System.out.println("Processando arquivo: " + fileName + " - "
+ size + " bytes.");
FileOutputStream fos = new FileOutputStream(fileName);
byte[] buf = new byte[4096];
while (true) {
int len = in.read(buf);
if (len == -1)
break;
fos.write(buf, 0, len);
}
fos.flush();
fos.close();
System.out.println("Pronto.");
} catch (Exception ex) {
ex.printStackTrace();
}
try {
FileInputStream fis = new FileInputStream("jogo.ser");
ObjectInputStream in = new ObjectInputStream(fis);
Objecto novo = (Objecto) in.readObject();
System.out.println(novo.getNome());
in.close();
} catch (IOException ex) {
ex.printStackTrace();
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
}
}
Isto é um pequeno exemplo de como mando um Objecto entre o Cliente e o Servidor. Funciona se mandar um Objecto uma vez por outra. Mas como preciso de estar constantemente a actualizar utilizei o While(true) que podia ser, por exemplo, um while(!jogoFinished); Mas nesse caso dá erro... Há outra solução possível? Usando apenas Sockets e Serialização?
eu agradeço a ajuda, mas ao menos tentem ler a minha dúvida, não se trata de como se usa um socket… o código que fiz funciona perfeitamente. Envia, recebe o mesmo objecto.