-
Notifications
You must be signed in to change notification settings - Fork 0
/
TCPClient.java
171 lines (147 loc) · 7.16 KB
/
TCPClient.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
import java.io.*;
import java.net.*;
import javax.swing.*;
import java.util.*;
public class TCPClient {
// TCPClient class is responsible for handling client-side communication with the server.
private Socket socket;
private PrintWriter writer;
public String userColor;
private InteractiveFillableColorGridGUI gameGui;
// Constructor initializes the client by establishing a connection to the server and creating a PrintWriter.
public TCPClient() throws IOException {
this.socket = new Socket("localhost", 7070);
this.writer = new PrintWriter(socket.getOutputStream(), true);
}
// Starts the threads for reading and writing data to the server.
public void startThreads() {
new ReadThread(socket, this).start(); // Pass this TCPClient instance
new WriteThread(socket).start();
}
// Initializes the GUI for the game with the user's color.
public void initializeGameGui(String color) {
gameGui = new InteractiveFillableColorGridGUI(this, color);
}
// Sends a message to the server to lock a specific box identified by its row and column.
public void lockBox(int row, int col) {
sendMessage("LOCK(" + (row * 8 + col) + ")");
}
// Sends a message to the server to claim a specific box identified by its row and column.
public void claimBox(int row, int col) {
sendMessage("CLAIM(" + (row * 8 + col) + ")");
}
// Sends a message to the server to unlock a specific box identified by its row and column.
public void unlockBox(int row, int col) {
sendMessage("UNLOCK(" + (row * 8 + col) + ")");
}
// Sends a message to the server.
public void sendMessage(String message) {
writer.println(message);
}
// Updates the GUI to lock a specific cell identified by its cell number.
public void lockCellInGui(int cellNumber) {
gameGui.lockCell(cellNumber);
}
// Updates the GUI to unlock a specific cell identified by its cell number.
public void unlockCellInGui(int cellNumber) {
gameGui.unlockCell(cellNumber);
}
// Updates the GUI to claim a specific cell identified by its cell number with the given owner color.
public void claimCellInGui(int cellNumber, String owner) {
gameGui.claimCell(cellNumber, owner);
}
// Main method to create a new TCPClient instance and start the client.
public static void main(String[] args) throws IOException {
new TCPClient();
}
}
// ReadThread class handles reading data from the server.
class ReadThread extends Thread {
private BufferedReader reader;
private TCPClient client; // added this to store reference to TCPClient
// Constructor initializes the ReadThread with the socket and a reference to the TCPClient instance.
public ReadThread(Socket socket, TCPClient client) {
this.client = client; // store the TCPClient instance
try {
InputStream input = socket.getInputStream();
reader = new BufferedReader(new InputStreamReader(input));
} catch (IOException ex) {
System.out.println("Error getting input stream: " + ex.getMessage());
ex.printStackTrace();
}
}
// The run method listens for incoming messages from the server.
public void run() {
while (true) {
try {
String response = reader.readLine();
System.out.println(response);
// Parse the server response and take appropriate actions based on the message received.
if (response.startsWith("YOUR_COLOR")) {
// The server informs the client about its color in the game.
// The color information is extracted from the message and used to initialize the GUI.
String color = response.substring(11, response.length() - 1);
javax.swing.SwingUtilities.invokeLater(() -> {
client.userColor = color;
client.initializeGameGui(color); // Initialize the GUI here
});
} else if (response.startsWith("LOCKED")) {
// The server informs that a box has been locked by another player.
// The cell number is extracted from the message and used to lock the cell in the GUI.
String cellStr = response.substring(7, response.length() - 1);
int cellNumber = Integer.parseInt(cellStr);
client.lockCellInGui(cellNumber);
} else if (response.startsWith("UNLOCKED")) {
// The server informs that a box has been unlocked by the previous owner.
// The cell number is extracted from the message and used to unlock the cell in the GUI.
String cellStr = response.substring(9, response.length() - 1);
int cellNumber = Integer.parseInt(cellStr);
client.unlockCellInGui(cellNumber);
} else if (response.startsWith("CLAIMED")) {
// The server informs that a box has been claimed by a player.
// The cell number and owner information are extracted from the message and used to update the GUI.
String[] parts = response.split(", ");
String cellStr = parts[0].substring(8);
String owner = parts[1].substring(0, parts[1].length() - 1);
int cellNumber = Integer.parseInt(cellStr);
client.claimCellInGui(cellNumber, owner);
} else if (response.startsWith("GAME_OVER")) {
// The server informs that the game is over, and the result is provided.
// A message dialog is shown with the result, and the client exits the application.
String result = response.substring(10, response.length() - 1);
javax.swing.SwingUtilities.invokeLater(() -> {
javax.swing.JOptionPane.showMessageDialog(null, result, "Game Over", javax.swing.JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
});
}
} catch (IOException ex) {
System.out.println("Error reading from server: " + ex.getMessage());
ex.printStackTrace();
break;
}
}
}
}
// WriteThread class handles writing data to the server.
class WriteThread extends Thread {
private PrintWriter writer;
// Constructor initializes the WriteThread with the socket.
public WriteThread(Socket socket) {
try {
OutputStream output = socket.getOutputStream();
writer = new PrintWriter(output, true);
} catch (IOException ex) {
System.out.println("Error getting output stream: " + ex.getMessage());
ex.printStackTrace();
}
}
// The run method listens for input from the console and sends it to the server.
public void run() {
Console console = System.console();
String text;
while (true) {
text = console.readLine("");
writer.println(text);
}
}
}