static void network_prepare_next_frame(void)
{
current_frame = (current_frame + 1) % frame_delta;
frame_to_play = (current_frame + 1) % frame_delta;
event_clear_list(&(frame_event_list[current_frame]));
event_register_event_list(&(frame_event_list[current_frame]));
interrupt_maincpu_trigger_trap(network_event_record_sync_test, (void *)0);
}
static void network_free_frame_event_list(void)
{
int i;
if (frame_event_list != NULL) {
for (i=0; i < frame_delta; i++)
event_clear_list(&(frame_event_list[i]));
lib_free(frame_event_list);
frame_event_list = NULL;
}
event_destroy_image_list();
}
static void network_client_connect_trap(WORD addr, void *data)
{
BYTE *buf;
size_t buf_size;
BYTE recv_buf4[4];
event_list_state_t *settings_list;
/* Set proper settings */
if (resources_set_event_safe() < 0)
ui_error("Warning! Failed to set netplay-safe settings.");
/* Receive settings that need to be same as on server */
if (network_recv_buffer(network_socket, recv_buf4, 4) < 0)
return;
buf_size = (size_t)util_le_buf4_to_int(recv_buf4);
buf = lib_malloc(buf_size);
if (network_recv_buffer(network_socket, buf, buf_size) < 0)
return;
settings_list = network_create_event_list(buf);
lib_free(buf);
event_playback_event_list(settings_list);
event_clear_list(settings_list);
lib_free(settings_list);
/* read the snapshot */
if (machine_read_snapshot(snapshotfilename, 0) != 0) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_OPEN_SNAPSHOT_FILE_S), snapshotfilename);
#else
ui_error(_("Cannot open snapshot file %s"), snapshotfilename);
#endif
lib_free(snapshotfilename);
return;
}
current_send_frame = 0;
last_received_frame = 0;
network_mode = NETWORK_CLIENT;
network_test_delay();
lib_free(snapshotfilename);
}
static void destroy_list(void)
{
event_clear_list(event_list);
lib_free(event_list);
event_destroy_image_list();
}
static void network_server_connect_trap(WORD addr, void *data)
{
FILE *f;
BYTE *buf;
size_t buf_size;
BYTE send_size4[4];
long i;
event_list_state_t settings_list;
vsync_suspend_speed_eval();
/* Create snapshot and send it */
snapshotfilename = archdep_tmpnam();
if (machine_write_snapshot(snapshotfilename, 1, 1, 0) == 0) {
f = fopen(snapshotfilename, MODE_READ);
if (f == NULL) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_LOAD_SNAPSHOT_TRANSFER));
#else
ui_error(_("Cannot load snapshot file for transfer"));
#endif
lib_free(snapshotfilename);
return;
}
buf_size = util_file_length(f);
buf = lib_malloc(buf_size);
fread(buf, 1, buf_size, f);
fclose(f);
#ifdef HAS_TRANSLATION
ui_display_statustext(translate_text(IDGS_SENDING_SNAPSHOT_TO_CLIENT), 0);
#else
ui_display_statustext(_("Sending snapshot to client..."), 0);
#endif
util_int_to_le_buf4(send_size4, (int)buf_size);
network_send_buffer(network_socket, send_size4, 4);
i = network_send_buffer(network_socket, buf, (int)buf_size);
lib_free(buf);
if (i < 0) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_SEND_SNAPSHOT_TO_CLIENT));
#else
ui_error(_("Cannot send snapshot to client"));
#endif
ui_display_statustext("", 0);
lib_free(snapshotfilename);
return;
}
network_mode = NETWORK_SERVER_CONNECTED;
/* Send settings that need to be the same */
event_register_event_list(&settings_list);
resources_get_event_safe_list(&settings_list);
buf_size = (size_t)network_create_event_buffer(&buf, &(settings_list));
util_int_to_le_buf4(send_size4, (int)buf_size);
network_send_buffer(network_socket, send_size4, 4);
network_send_buffer(network_socket, buf, (int)buf_size);
event_clear_list(&settings_list);
lib_free(buf);
current_send_frame = 0;
last_received_frame = 0;
network_test_delay();
} else {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_CREATE_SNAPSHOT_FILE_S), snapshotfilename);
#else
ui_error(_("Cannot create snapshot file %s"), snapshotfilename);
#endif
}
lib_free(snapshotfilename);
}
static void network_hook_connected_receive(void)
{
BYTE *remote_event_buf = NULL;
unsigned int recv_len;
BYTE recv_len4[4];
event_list_state_t *remote_event_list;
event_list_state_t *client_event_list, *server_event_list;
suspended = 0;
if (current_frame == frame_delta - 1)
frame_buffer_full = 1;
if (frame_buffer_full) {
do {
if (network_recv_buffer(network_socket, recv_len4, 4) < 0) {
ui_display_statustext(translate_text(IDGS_REMOTE_HOST_DISCONNECTED), 1);
network_disconnect();
return;
}
recv_len = util_le_buf4_to_int(recv_len4);
if (recv_len == 0 && suspended == 0) {
/* remote host suspended emulation */
ui_display_statustext(translate_text(IDGS_REMOTE_HOST_SUSPENDING), 0);
suspended = 1;
vsync_suspend_speed_eval();
}
} while (recv_len == 0);
if (suspended == 1)
ui_display_statustext("", 0);
remote_event_buf = lib_malloc(recv_len);
if (network_recv_buffer(network_socket, remote_event_buf,
recv_len) < 0) {
lib_free(remote_event_buf);
return;
}
#ifdef NETWORK_DEBUG
t3 = vsyncarch_gettime();
#endif
remote_event_list = network_create_event_list(remote_event_buf);
lib_free(remote_event_buf);
if (network_mode == NETWORK_SERVER_CONNECTED) {
client_event_list = remote_event_list;
server_event_list = &(frame_event_list[frame_to_play]);
} else {
server_event_list = remote_event_list;
client_event_list = &(frame_event_list[frame_to_play]);
}
/* test for sync */
if (client_event_list->base->type == EVENT_SYNC_TEST
&& server_event_list->base->type == EVENT_SYNC_TEST) {
int i;
for (i = 0; i < 5; i++) {
if (((DWORD *)client_event_list->base->data)[i]
!= ((DWORD *)server_event_list->base->data)[i]) {
ui_error(translate_text(IDGS_NETWORK_OUT_OF_SYNC));
network_disconnect();
/* shouldn't happen but resyncing would be nicer */
break;
}
}
}
/* replay the event_lists; server first, then client */
event_playback_event_list(server_event_list);
event_playback_event_list(client_event_list);
event_clear_list(remote_event_list);
lib_free(remote_event_list);
}
network_prepare_next_frame();
#ifdef NETWORK_DEBUG
t4 = vsyncarch_gettime();
#endif
}
