szerver

package domino;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class DominoServer {
    private static ServerSocket server;

    public static void acceptClients(int clientNumber, String inFilename, String outFilename) {
        try {
            if (server == null) {
                server = new ServerSocket(60504);
            }
            List<Socket> clients = new ArrayList<>();
            for (int i = 0; i < clientNumber; ++i) {
                Socket s = server.accept();
                clients.add(s);
            }
            new Game(clients, inFilename, outFilename).start();
        } catch (Exception e) {
            System.err.println("Hiba a kliensek fogadasakor.");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
        	int playersNumber;
        	/*try {

                int tempNumber = Integer.parseInt(args[0]); // játékosok száma
                if (2 <= tempNumber && tempNumber <=4) {
                    playersNumber = tempNumber;
                } else {
                    System.err.println("Nem megfelelo a jatekosok szama.");
                    playersNumber = 2;
                }
            } catch (NumberFormatException e) {
                playersNumber = 2;
            }
            acceptClients(playersNumber,args[1],args[2]);*/
            acceptClients(3, "input1.txt", "tesztOutput.txt");
        } catch (Exception e) {
            System.err.println("Hiba a szerver inditasanal.");
            e.printStackTrace();
        }
    }

}

class Game extends Thread {
	Map<Integer, ObjectOutputStream> osMap;
	Map<Integer, ObjectInputStream> isMap;
	Map<Integer,Socket> sockets;
	List<Domino> talon;
	String filename;
	String outputFileName;
	Integer lastDomino = null;
	int firstEmptyIndex = 0;
	Map<Integer,String> players;
	private boolean stop = false;

	public Game(List<Socket> clients, String filename, String outFilename) throws IOException {
		Integer i = 0;
		osMap = new HashMap<>();
		isMap = new HashMap<>();
		players = new HashMap<>();
		sockets = new HashMap<>();
		this.outputFileName = outFilename;
		this.filename = filename;
		for (Socket s : clients) {
			++i;
			sockets.put(i,s);
			osMap.put(i, new ObjectOutputStream(s.getOutputStream()));
			isMap.put(i, new ObjectInputStream(s.getInputStream()));

		}

	}

	public boolean handleClients(Map<Integer, ObjectOutputStream> osMap, Map<Integer, ObjectInputStream> isMap,
			String outputFileName, BufferedWriter writer) throws IOException {

		try {
			boolean isAnswer = false;
			int newRequests = 0;
			for (Integer ind : osMap.keySet()) {
				if(!stop){


				System.out.println(ind + ". clienttől akarok olvasni");
				StringBuilder line = new StringBuilder();
					Object obj = isMap.get(ind).readObject();

				line.append(players.get(ind)).append(" : ");
				if (obj instanceof String && ((String) obj).equals("NYERTEM")) {
					line.append(obj.toString());
					handleIfPlayerWins(osMap, ind);
				}
				if (obj instanceof String && ((String) obj).equals("UJ")) {
					line.append(obj.toString());
					newRequests++;
					isAnswer = true;
					handleIfTalonIsEmpty(osMap, newRequests, ind,writer);
					handleIfTalonIsNotEmpty(osMap, ind);

					if (!isAnswer && talon.isEmpty()) {
						osMap.get(ind).writeObject(new String("VEGE"));
						stop = true;
					}
				}

				if (obj instanceof Integer) {
					line.append(obj.toString());
					isAnswer = true;
					lastDomino = (Integer) obj;
					if (ind == osMap.size()) {
						osMap.get(1).writeObject(obj);
					} else {
						osMap.get(ind + 1).writeObject(obj);
					}
				}
				//if (!stop) {
					writer.write(line.toString() + "\n");
					writer.newLine();
					System.out.println(line.toString());
				//}

			}

			stopServer(osMap, isAnswer);
			}
		} catch (IOException | ClassNotFoundException e) {
			e.printStackTrace();
		}
		return true;
	}

	private void stopServer(Map<Integer, ObjectOutputStream> osMap, boolean isAnswer) throws IOException {
		if (!isAnswer) {
			for (Integer ind : osMap.keySet()) {
				osMap.get(ind).writeObject(new String("VEGE"));
			}
			stop = true;
		} else {
			isAnswer = false;
		}
	}

	private void handleIfPlayerWins(Map<Integer, ObjectOutputStream> osMap, Integer ind) throws IOException {

		for (Integer ind2 : osMap.keySet()) {
			if (ind != ind2) {
				osMap.get(ind2).writeObject(new String("VEGE"));
			}
		}
		stop = true;
	}

	private void handleIfTalonIsNotEmpty(Map<Integer, ObjectOutputStream> osMap, Integer ind) throws IOException {
		if (!talon.isEmpty()) {
			osMap.get(ind).writeObject(talon.get(0));
			if (ind == osMap.size()) {
				osMap.get(1).writeObject(lastDomino);
			} else {
				osMap.get(ind + 1).writeObject(lastDomino);
			}
			talon.remove(talon.get(0));
		}
	}

	private void handleIfTalonIsEmpty(Map<Integer, ObjectOutputStream> osMap, int newRequests, Integer ind,BufferedWriter writer)
			throws IOException {
		if (talon.isEmpty()) {
			osMap.get(ind).writeObject(new String("NINCS"));
			if (newRequests == osMap.size()) {
				for (Integer number : osMap.keySet()) {
					osMap.get(number).writeObject(new String("VEGE"));

				}
				writer.write("DONTETLEN");
				System.out.println("DONTETLEN");
				stop = true;
			} else {
				if (ind == osMap.size()) {
					osMap.get(1).writeObject(lastDomino);

				} else {
					osMap.get(ind + 1).writeObject(lastDomino);
				}

			}

		}
	}

	@Override
	public void run() {
		try (BufferedWriter bw = new BufferedWriter(new FileWriter(outputFileName))) {
			readFromFile(filename);

			for(Integer ind : isMap.keySet()){
				String name = (String) isMap.get(ind).readObject();
				players.put(ind, name);
			}
			divideDominos();
			String start = "START";
			osMap.get(1).writeObject(start);
			while (!stop) {
				handleClients(osMap, isMap, outputFileName, bw);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	private void readFromFile(String filename) throws FileNotFoundException {
		FileInputStream fis = new FileInputStream(new File(filename));
		Scanner sc = new Scanner(fis);
		talon = new ArrayList<>();

		while (sc.hasNext()) {
			String[] array = sc.nextLine().split("\\s+");
			talon.add(new Domino(Integer.parseInt(array[0]), Integer.parseInt(array[1])));
		}
		sc.close();
	}

	private void divideDominos() throws IOException {
		for (Integer key : osMap.keySet()) {
			int counter = 0;
			Iterator<Domino> iter = talon.iterator();
			while (iter.hasNext() && counter < 7) {
				osMap.get(key).writeObject(iter.next());
				iter.remove();
				++counter;
			}

		}
	}
}