// network.c
// ============================================================================
-#include "libgame/platform.h"
-
-#if defined(NETWORK_AVALIABLE)
-
#include <signal.h>
#include <sys/time.h>
-#include "main.h"
-
#include "libgame/libgame.h"
#include "network.h"
#include "netserv.h"
+#include "main.h"
#include "game.h"
#include "tape.h"
#include "files.h"
static int nread = 0, nwrite = 0;
static boolean stop_network_game = FALSE;
+static void DrawNetworkTextExt(char *message, int font_nr, boolean initialize)
+{
+ static int xpos = 0, ypos = 0;
+ static int max_line_width = 0;
+ int font_width = getFontWidth(font_nr);
+ int font_height = getFontHeight(font_nr);
+ int ypos_1 = 120;
+ int ypos_2 = 150;
+
+ if (initialize)
+ {
+ if (game_status == GAME_MODE_LOADING)
+ {
+ max_line_width = WIN_XSIZE;
+
+ xpos = (max_line_width - getTextWidth(message, font_nr)) / 2;
+ ypos = ypos_1;
+
+ DrawText(xpos, ypos, message, font_nr);
+
+ xpos = 0;
+ ypos = ypos_2;
+ }
+ else
+ {
+ max_line_width = SXSIZE;
+
+ DrawTextSCentered(ypos_1, font_nr, message);
+
+ /* calculate offset to x position caused by rounding */
+ int max_chars_per_line = max_line_width / font_width;
+ int xoffset = (max_line_width - max_chars_per_line * font_width) / 2;
+
+ xpos = SX + xoffset;
+ ypos = SY + ypos_2;
+ }
+
+ Error(ERR_DEBUG, "========== %s ==========", message);
+ }
+ else
+ {
+ int max_chars_per_line = max_line_width / font_width;
+ int max_lines_per_text = 10;
+ int num_lines_spacing = (font_nr == FC_YELLOW ? 1 : 3);
+ int num_lines_printed = DrawTextBuffer(xpos, ypos, message, font_nr,
+ max_chars_per_line, -1,
+ max_lines_per_text, 0, -1,
+ TRUE, TRUE, FALSE);
+
+ ypos += (num_lines_printed + num_lines_spacing) * font_height;
+
+ Error(ERR_DEBUG, "%s", message);
+ }
+
+ BackToFront();
+}
+
+static void DrawNetworkText(char *message)
+{
+ DrawNetworkTextExt(message, FC_YELLOW, FALSE);
+}
+
+static void DrawNetworkText_Success(char *message)
+{
+ DrawNetworkTextExt(message, FC_GREEN, FALSE);
+}
+
+static void DrawNetworkText_Failed(char *message)
+{
+ DrawNetworkTextExt(message, FC_RED, FALSE);
+}
+
+static void DrawNetworkText_Title(char *message)
+{
+ DrawNetworkTextExt(message, FC_GREEN, TRUE);
+}
+
static void SendBufferToServer(int size)
{
- if (!options.network)
+ if (!network.enabled)
return;
realbuffer[0] = realbuffer[1] = realbuffer[2] = 0;
int server_host = 0;
int i;
+ DrawNetworkText_Title("Initializing Network");
+
if (port == 0)
port = DEFAULT_SERVER_PORT;
SDLNet_UDP_Send(udp, -1, &packet);
- Error(ERR_DEBUG, "doing UDP broadcast for local network server ...");
+ DrawNetworkText("Looking for local network server ...");
- if (SDLNet_CheckSockets(udp_socket_set, 1000) == 1)
+ /* wait for any local network server to answer UDP broadcast */
+ for (i = 0; i < 5; i++)
{
- int num_packets = SDLNet_UDP_Recv(udp, &packet);
-
- if (num_packets == 1)
+ if (SDLNet_CheckSockets(udp_socket_set, 0) == 1)
{
- Error(ERR_DEBUG, "network server found");
+ int num_packets = SDLNet_UDP_Recv(udp, &packet);
- server_host = SDLNet_Read32(&packet.address.host);
+ if (num_packets == 1)
+ {
+ DrawNetworkText_Success("Network server found!");
+
+ server_host = SDLNet_Read32(&packet.address.host);
+ }
+ else
+ {
+ DrawNetworkText_Failed("No answer from network server!");
+ }
+
+ break;
}
else
{
- Error(ERR_DEBUG, "no answer from network server");
+ Delay_WithScreenUpdates(100);
}
}
- else
- {
- Error(ERR_DEBUG, "no network server found");
- }
+
+ if (server_host == 0)
+ DrawNetworkText_Failed("No network server found!");
}
rfds = SDLNet_AllocSocketSet(1);
Error(ERR_EXIT, "cannot locate host '%s'", hostname);
else
server_host = SDLNet_Read32(&ip.host);
+
+ DrawNetworkText("Connecting to remote host ...");
}
else
{
SDLNet_Write32(server_host, &ip.host);
SDLNet_Write16(port, &ip.port);
+
+ DrawNetworkText("Connecting to local host ...");
}
Error(ERR_DEBUG, "trying to connect to network server at %d.%d.%d.%d ...",
if (sfd)
{
SDLNet_TCP_AddSocket(rfds, sfd);
+
+ DrawNetworkText_Success("Successfully connected!");
+
return TRUE;
}
else
{
+ DrawNetworkText_Failed("Failed to connect to network server!");
+
printf("SDLNet_TCP_Open(): %s\n", SDLNet_GetError());
}
if (hostname) /* connect to specified server failed */
return FALSE;
- printf("No rocksndiamonds server on localhost -- starting up one ...\n");
+ DrawNetworkText("Starting new local network server ...");
+
StartNetworkServer(port);
/* wait for server to start up and try connecting several times */
- for (i = 0; i < 6; i++)
+ for (i = 0; i < 30; i++)
{
- Delay(500); /* wait 500 ms == 0.5 seconds */
-
if ((sfd = SDLNet_TCP_Open(&ip))) /* connected */
{
+ DrawNetworkText_Success("Successfully connected!");
+
SDLNet_TCP_AddSocket(rfds, sfd);
return TRUE;
}
+
+ Delay_WithScreenUpdates(100);
}
+ DrawNetworkText_Failed("Failed to connect to network server!");
+
/* when reaching this point, connect to newly started server has failed */
return FALSE;
}
Error(ERR_EXIT, "sorry, more than %d players not allowed", MAX_PLAYERS);
Error(ERR_NETWORK_CLIENT, "you get client # %d", new_client_nr);
+
+ stored_player[new_index_nr].connected_network = TRUE;
}
static void Handle_OP_NUMBER_WANTED()
Error(ERR_NETWORK_CLIENT, "cannot switch -- you keep client # %d",
new_client_nr);
}
+
+ if (game_status == GAME_MODE_MAIN)
+ DrawNetworkPlayers();
}
static void Handle_OP_PLAYER_NAME(unsigned int len)
stored_player[index_nr].connected_locally = FALSE;
stored_player[index_nr].connected_network = FALSE;
+
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ char message[100];
+
+ sprintf(message, "Player %d left network server! Network game stopped!",
+ player_nr);
+
+ Request(message, REQ_CONFIRM | REQ_STAY_CLOSED);
+
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
+ else if (game_status == GAME_MODE_MAIN)
+ {
+ DrawNetworkPlayers();
+ }
}
static void Handle_OP_START_PLAYING()
if (game_status == GAME_MODE_PLAYING)
{
- if (buffer[2] == NETWORK_STOP_BY_PLAYER)
- Request("Network game stopped by player!", REQ_CONFIRM);
- else if (buffer[2] == NETWORK_STOP_BY_ERROR)
- Request("Network game stopped due to internal error!", REQ_CONFIRM);
- else
- Request("Network game stopped!", REQ_CONFIRM);
- }
+ int client_nr = buffer[0];
+ int index_nr = client_nr - 1;
+ struct PlayerInfo *client_player = &stored_player[index_nr];
+ boolean stopped_by_remote_player = (!client_player->connected_locally);
+ char message[100];
- SetGameStatus(GAME_MODE_MAIN);
+ sprintf(message, (buffer[2] == NETWORK_STOP_BY_PLAYER ?
+ "Network game stopped by player %d!" :
+ buffer[2] == NETWORK_STOP_BY_ERROR ?
+ "Network game stopped due to internal error!" :
+ "Network game stopped!"), client_nr);
- DrawMainMenu();
+ if (buffer[2] != NETWORK_STOP_BY_PLAYER || stopped_by_remote_player)
+ Request(message, REQ_CONFIRM | REQ_STAY_CLOSED);
+
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
}
static void Handle_OP_MOVE_PLAYER(unsigned int len)
SendToServer_StopPlaying(NETWORK_STOP_BY_ERROR);
}
-/* TODO */
+static char *HandleNetworkingPackets()
+{
+ while (1)
+ {
+ /* ---------- check network server for activity ---------- */
+
+ int num_active_sockets = SDLNet_CheckSockets(rfds, 1);
+
+ if (num_active_sockets < 0)
+ return "Error checking network sockets!";
+
+ if (num_active_sockets == 0)
+ break; // no active sockets, stop here
+
+ /* ---------- read packets from network server ---------- */
+
+ int num_bytes = SDLNet_TCP_Recv(sfd, readbuffer + nread, 1);
+
+ if (num_bytes < 0)
+ return "Error reading from network server!";
+
+ if (num_bytes == 0)
+ return "Connection to network server lost!";
+
+ nread += num_bytes;
+
+ HandleNetworkingMessages();
+ }
+
+ return NULL;
+}
+
+static void FreeNetworkClientPlayerInfo(struct NetworkClientPlayerInfo *player)
+{
+ if (player == NULL)
+ return;
+
+ if (player->next)
+ FreeNetworkClientPlayerInfo(player->next);
+
+ checked_free(player);
+}
+
+static void HandleNetworkingDisconnect()
+{
+ int i;
+
+ SDLNet_TCP_DelSocket(rfds, sfd);
+ SDLNet_TCP_Close(sfd);
+
+ network_playing = FALSE;
+
+ network.enabled = FALSE;
+ network.connected = FALSE;
+
+ setup.network_mode = FALSE;
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ stored_player[i].connected_network = FALSE;
+
+ FreeNetworkClientPlayerInfo(first_player.next);
+
+ first_player.nr = 0;
+ first_player.next = NULL;
+}
void HandleNetworking()
{
- int r = 0;
+ char *error_message = HandleNetworkingPackets();
- do
+ if (error_message != NULL)
{
- if ((r = SDLNet_CheckSockets(rfds, 1)) < 0)
- Error(ERR_EXIT, "HandleNetworking(): SDLNet_CheckSockets() failed");
+ HandleNetworkingDisconnect();
- if (r > 0)
+ if (game_status == GAME_MODE_PLAYING)
{
- r = SDLNet_TCP_Recv(sfd, readbuffer + nread, 1);
-
- if (r < 0)
- Error(ERR_EXIT, "error reading from network server");
+ Request(error_message, REQ_CONFIRM | REQ_STAY_CLOSED);
- if (r == 0)
- Error(ERR_EXIT, "connection to network server lost");
+ SetGameStatus(GAME_MODE_MAIN);
- nread += r;
+ DrawMainMenu();
+ }
+ else
+ {
+ Request(error_message, REQ_CONFIRM);
- HandleNetworkingMessages();
+ if (game_status == GAME_MODE_MAIN)
+ ClearNetworkPlayers();
}
}
- while (r > 0);
}
-#endif /* NETWORK_AVALIABLE */
+void DisconnectFromNetworkServer()
+{
+ DrawNetworkText_Title("Terminating Network");
+ DrawNetworkText("Disconnecting from network server ...");
+
+ HandleNetworkingDisconnect();
+
+ DrawNetworkText_Success("Successfully disconnected!");
+
+ /* short time to recognize result of network initialization */
+ Delay_WithScreenUpdates(1000);
+}