GuessTheNumberServer.java

//package student-interview.JAVA.src;
import java.io.*;
import java.net.*;
import java.util.concurrent.*;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.List;
import java.util.ArrayList;

public class GuessTheNumberServer {
    private static final int PORT = 12347;
    private static final int MAX_PLAYERS = 4;
    private static final List<PlayerHandler> players = new ArrayList<>();
    private static volatile boolean gameRunning;
    private static volatile int currentPlayerIndex = 0;
    private static final Object lock = new Object();
    private static volatile int playersWantingRestart = 0;
    private static int targetNumber;
    private static final int MAX_NUMBER = 100;
    private static final Random random = new Random();
    private static Set<Integer> guessedNumbers;

    // Method to find largest prime number less than 17
    private static int findLargestPrimeLessThan17() {
        int[] primes = {13, 11, 7, 5, 3, 2};
        return primes[random.nextInt(primes.length)];
    }

    // Method to reverse digits
    private static int reverseDigits(int number) {
        int reversed = 0;
        while (number != 0) {
            int digit = number % 10;
            reversed = reversed * 10 + digit;
            number /= 10;
        }
        return reversed;
    }

    // Method to transform guess according to rules
    private static int transformGuess(int guess) {
        int transformed;
        
        // Step 1: Transform based on odd/even
        if (guess % 2 == 1) {
            // For odd numbers, add random prime less than 17
            transformed = guess + findLargestPrimeLessThan17();
        } else {
            // For even numbers, reverse digits
            transformed = reverseDigits(guess);
        }
        
        // Step 2: Apply range-based transformation
        if (transformed >= 100) {
            transformed = transformed / 2;
        } else if (transformed < 50) {
            transformed = transformed * 2;
        }
        
        return transformed;
    }

    // Method to generate prefix messages
    private static String generatePrefix(int guess) {
        int formatChoice = random.nextInt(3);
        StringBuilder prefix = new StringBuilder();

        switch (formatChoice) {
            case 0:
                prefix.append(guess % 2 == 0
                        ? "The number you selected is " + guess + " and it is even!"
                        : "The number you selected is " + guess + " and it is odd!");
                break;
            case 1:
                prefix.append(guess > MAX_NUMBER
                        ? "You selected " + guess + ", a number greater than " + MAX_NUMBER + "!"
                        : "You selected " + guess + ", which is a small number!");
                break;
            case 2:
                int randomFact = random.nextInt(MAX_NUMBER) + 1;
                prefix.append("The number ").append(guess)
                      .append(" has a special fact: ").append(randomFact)
                      .append(" is a random number generated.");
                break;
            default:
                prefix.append("You selected ").append(guess).append(".");
        }

        prefix.append("\n");
        if (guess >= 0 && guess <= 50) {
            prefix.append("Status: Your guess is within the safe zone!");
        } else if (guess > 50 && guess <= 150) {
            prefix.append("Status: Be careful! Your guess is in the uncertain range.");
        } else {
            prefix.append("Status: Warning! Your guess is in the high-risk zone!");
        }

        return prefix.toString();
    }

    private static class PlayerHandler {
        Socket socket;
        BufferedReader in;
        PrintWriter out;
        int playerNumber;
        boolean wantsRestart;

        PlayerHandler(Socket socket, int playerNumber) throws IOException {
            this.socket = socket;
            this.in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            this.out = new PrintWriter(socket.getOutputStream(), true);
            this.playerNumber = playerNumber;
            this.wantsRestart = false;
        }

        void sendMessage(String message) {
            out.println(message);
        }
    }

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("Number Guessing Game Server is running on port " + PORT);
            ExecutorService pool = Executors.newCachedThreadPool();
            guessedNumbers = new HashSet<>();

            while (true) {
                Socket playerSocket = serverSocket.accept();
                synchronized (lock) {
                    if (players.size() >= MAX_PLAYERS) {
                        PrintWriter tempOut = new PrintWriter(playerSocket.getOutputStream(), true);
                        tempOut.println("Game is full. Please try again later.");
                        playerSocket.close();
                        continue;
                    }

                    int playerNumber = players.size() + 1;
                    PlayerHandler player = new PlayerHandler(playerSocket, playerNumber);
                    players.add(player);
                    player.sendMessage("You are Player " + playerNumber);
                    System.out.println("Player " + playerNumber + " connected.");

                    if (players.size() >= 2) {
                        if (!gameRunning) {
                            targetNumber = random.nextInt(MAX_NUMBER) + 1;
                            gameRunning = true;
                            currentPlayerIndex = 0;
                            System.out.println("Game starting with target number: " + targetNumber);
                            broadcastMessage("Game starting! Try to guess a number that will transform to " + targetNumber);
                        } else {
                            broadcastMessage("Player " + playerNumber + " joined the game!");
                            player.sendMessage("Current game in progress. Please wait for your turn.");
                        }
                    } else {
                        player.sendMessage("Waiting for more players to join...");
                    }
                    lock.notifyAll();

                    final int playerIndex = playerNumber - 1;
                    pool.execute(() -> handlePlayer(player, playerIndex));
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlePlayer(PlayerHandler player, int playerIndex) {
        try {
            while (true) {
                synchronized (lock) {
                    if (players.size() < 2) {
                        player.sendMessage("Waiting for more players...");
                        lock.wait();
                        continue;
                    }

                    if (!gameRunning) {
                        if (!player.wantsRestart) {
                            player.sendMessage("Game over. Do you want to play again? (y/n)");
                            String answer = player.in.readLine().trim().toLowerCase();
                            
                            if (answer.equals("y")) {
                                player.wantsRestart = true;
                                playersWantingRestart++;
                                broadcastMessage("Player " + (playerIndex + 1) + " voted to play again. (" + 
                                              playersWantingRestart + "/" + players.size() + " votes)");
                            } else {
                                broadcastMessage("Player " + (playerIndex + 1) + " voted not to continue.");
                                player.sendMessage("Game ended. Goodbye!");
                                return;
                            }
                        }
                        
                        lock.notifyAll();
                        
                        if (playersWantingRestart < players.size()) {
                            lock.wait();
                            continue;
                        }
                        
                        if (playersWantingRestart == players.size()) {
                            if (playerIndex == 0) {
                                resetGame();
                                broadcastMessage("New game started! Try to guess a number that will transform to " + targetNumber);
                            }
                            continue;
                        }
                        
                        player.sendMessage("Some players chose not to continue. Game ended. Goodbye!");
                        return;
                    }

                    if (currentPlayerIndex != playerIndex) {
                        player.sendMessage("Waiting for Player " + (currentPlayerIndex + 1) + "'s guess...");
                        lock.wait();
                        continue;
                    }

                    player.sendMessage("Enter your guess (1-" + MAX_NUMBER + "):");
                    String input = player.in.readLine();
                    if (input == null) throw new IOException("Player disconnected");
                    
                    try {
                        int guess = Integer.parseInt(input.trim());
                        
                        if (guess < 1 || guess > MAX_NUMBER) {
                            player.sendMessage("Invalid guess. Please enter a number between 1 and " + MAX_NUMBER);
                            continue;
                        }
                        
                        if (guessedNumbers.contains(guess)) {
                            player.sendMessage("Number " + guess + " was already guessed! Try a different number.");
                            continue;
                        }
                        
                        guessedNumbers.add(guess);
                        int transformedGuess = transformGuess(guess);
                        
                        // Generate and send prefix first
                        String prefixMessage = generatePrefix(guess);
                        broadcastMessage(prefixMessage);
                        
                        // Then handle the guess result
                        if (transformedGuess == targetNumber) {
                            broadcastMessage("Player " + (playerIndex + 1) + " wins! Their guess " + guess + 
                                          " transformed to " + targetNumber);
                            gameRunning = false;
                        } else {
                            String message = String.format("Player %d guessed %d which transformed to %d. " +
                                                        "Target is %s. Guessed numbers: %s",
                                                        playerIndex + 1, guess, transformedGuess,
                                                        transformedGuess < targetNumber ? "higher" : "lower",
                                                        guessedNumbers.toString());
                            broadcastMessage(message);
                            currentPlayerIndex = (currentPlayerIndex + 1) % players.size();
                        }
                        lock.notifyAll();
                    } catch (NumberFormatException e) {
                        player.sendMessage("Invalid input. Please enter a number.");
                    }
                }
            }
        } catch (IOException | InterruptedException e) {
            handlePlayerDisconnection(player);
        }
    }

    private static void handlePlayerDisconnection(PlayerHandler player) {
        synchronized (lock) {
            players.remove(player);
            if (player.wantsRestart) {
                playersWantingRestart--;
            }
            broadcastMessage("Player " + player.playerNumber + " disconnected!");
            if (players.size() < 2) {
                gameRunning = false;
                broadcastMessage("Not enough players to continue. Game over!");
            }
            currentPlayerIndex = currentPlayerIndex % players.size();
            lock.notifyAll();
        }
    }

    private static void resetGame() {
        targetNumber = random.nextInt(MAX_NUMBER) + 1;
        gameRunning = true;
        currentPlayerIndex = 0;
        playersWantingRestart = 0;
        guessedNumbers.clear();
        for (PlayerHandler player : players) {
            player.wantsRestart = false;
        }
        System.out.println("New game started with target number: " + targetNumber);
    }

    private static void broadcastMessage(String message) {
        synchronized(lock) {
            ArrayList<PlayerHandler> disconnectedPlayers = new ArrayList<>();
            for (PlayerHandler player : players) {
                try {
                    player.sendMessage(message);
                } catch (Exception e) {
                    disconnectedPlayers.add(player);
                }
            }
            for (PlayerHandler player : disconnectedPlayers) {
                handlePlayerDisconnection(player);
            }
        }
    }
}