mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-09 21:45:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removing silly foo_ names used to help migration.

Browse Source
This commit is contained in:
Gregor Richards 2016-12-10 20:38:59 -05:00
parent 53c46530aa
commit 2cc8c5c467
3 changed files with 28 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
network/netplay/netplay.c
View File

@ -305,7 +305,7 @@ static void hangup(netplay_t *netplay, struct netplay_connection *connection)
if (netplay->is_server) if (netplay->is_server)
{ {
uint32_t payload[2]; uint32_t payload[2];
payload[0] = htonl(netplay->foo_read_frame_count[connection->player]); payload[0] = htonl(netplay->read_frame_count[connection->player]);
payload[1] = htonl(connection->player); payload[1] = htonl(connection->player);
netplay_send_raw_cmd_all(netplay, connection, NETPLAY_CMD_MODE, payload, sizeof(payload)); netplay_send_raw_cmd_all(netplay, connection, NETPLAY_CMD_MODE, payload, sizeof(payload));
} }
@ -362,10 +362,10 @@ static void update_unread_ptr(netplay_t *netplay)
for (player = 0; player < MAX_USERS; player++) for (player = 0; player < MAX_USERS; player++)
{ {
if (!(netplay->connected_players & (1<<player))) continue; if (!(netplay->connected_players & (1<<player))) continue;
if (netplay->foo_read_frame_count[player] < new_unread_frame_count) if (netplay->read_frame_count[player] < new_unread_frame_count)
{ {
new_unread_ptr = netplay->foo_read_ptr[player]; new_unread_ptr = netplay->read_ptr[player];
new_unread_frame_count = netplay->foo_read_frame_count[player]; new_unread_frame_count = netplay->read_frame_count[player];
} }
} }
@ -715,20 +715,20 @@ static bool netplay_get_cmd(netplay_t *netplay,
if (player >= MAX_USERS || !(netplay->connected_players & (1<<player))) if (player >= MAX_USERS || !(netplay->connected_players & (1<<player)))
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
if (buffer[0] < netplay->foo_read_frame_count[player]) if (buffer[0] < netplay->read_frame_count[player])
{ {
/* We already had this, so ignore the new transmission */ /* We already had this, so ignore the new transmission */
break; break;
} }
else if (buffer[0] > netplay->foo_read_frame_count[player]) else if (buffer[0] > netplay->read_frame_count[player])
{ {
/* Out of order = out of luck */ /* Out of order = out of luck */
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
} }
/* The data's good! */ /* The data's good! */
dframe = &netplay->buffer[netplay->foo_read_ptr[player]]; dframe = &netplay->buffer[netplay->read_ptr[player]];
if (!netplay_delta_frame_ready(netplay, dframe, netplay->foo_read_frame_count[player])) if (!netplay_delta_frame_ready(netplay, dframe, netplay->read_frame_count[player]))
{ {
/* FIXME: Catastrophe! */ /* FIXME: Catastrophe! */
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
@ -736,14 +736,14 @@ static bool netplay_get_cmd(netplay_t *netplay,
dframe->have_remote[player] = true; dframe->have_remote[player] = true;
memcpy(dframe->remote_input_state[player], buffer + 2, memcpy(dframe->remote_input_state[player], buffer + 2,
WORDS_PER_INPUT*sizeof(uint32_t)); WORDS_PER_INPUT*sizeof(uint32_t));
netplay->foo_read_ptr[player] = NEXT_PTR(netplay->foo_read_ptr[player]); netplay->read_ptr[player] = NEXT_PTR(netplay->read_ptr[player]);
netplay->foo_read_frame_count[player]++; netplay->read_frame_count[player]++;
/* If this was server data, advance our server pointer too */ /* If this was server data, advance our server pointer too */
if (!netplay->is_server && (buffer[1] & NETPLAY_CMD_INPUT_BIT_SERVER)) if (!netplay->is_server && (buffer[1] & NETPLAY_CMD_INPUT_BIT_SERVER))
{ {
netplay->server_ptr = netplay->foo_read_ptr[player]; netplay->server_ptr = netplay->read_ptr[player];
netplay->server_frame_count = netplay->foo_read_frame_count[player]; netplay->server_frame_count = netplay->read_frame_count[player];
} }
break; break;
} }
@ -797,7 +797,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
if (connection->mode == NETPLAY_CONNECTION_PLAYING) if (connection->mode == NETPLAY_CONNECTION_PLAYING)
{ {
/* The frame we haven't received is their end frame */ /* The frame we haven't received is their end frame */
payload[0] = htonl(netplay->foo_read_frame_count[connection->player]); payload[0] = htonl(netplay->read_frame_count[connection->player]);
/* Mark them as not playing anymore */ /* Mark them as not playing anymore */
connection->mode = NETPLAY_CONNECTION_SPECTATING; connection->mode = NETPLAY_CONNECTION_SPECTATING;
@ -844,8 +844,8 @@ static bool netplay_get_cmd(netplay_t *netplay,
netplay_send_raw_cmd(netplay, connection, NETPLAY_CMD_MODE, payload, sizeof(payload)); netplay_send_raw_cmd(netplay, connection, NETPLAY_CMD_MODE, payload, sizeof(payload));
/* And expect their data */ /* And expect their data */
netplay->foo_read_ptr[player] = NEXT_PTR(netplay->self_ptr); netplay->read_ptr[player] = NEXT_PTR(netplay->self_ptr);
netplay->foo_read_frame_count[player] = netplay->self_frame_count + 1; netplay->read_frame_count[player] = netplay->self_frame_count + 1;
break; break;
} }
@ -950,8 +950,8 @@ static bool netplay_get_cmd(netplay_t *netplay,
{ {
netplay->connected_players |= (1<<player); netplay->connected_players |= (1<<player);
netplay->foo_read_ptr[player] = netplay->server_ptr; netplay->read_ptr[player] = netplay->server_ptr;
netplay->foo_read_frame_count[player] = netplay->server_frame_count; netplay->read_frame_count[player] = netplay->server_frame_count;
} }
else else
{ {
@ -1091,7 +1091,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
} }
frame = ntohl(frame); frame = ntohl(frame);
if (frame != netplay->foo_read_frame_count[connection->player]) if (frame != netplay->read_frame_count[connection->player])
{ {
RARCH_ERR("CMD_LOAD_SAVESTATE loading a state out of order!\n"); RARCH_ERR("CMD_LOAD_SAVESTATE loading a state out of order!\n");
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
@ -1120,7 +1120,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
netplay->decompression_backend->set_in(netplay->decompression_stream, netplay->decompression_backend->set_in(netplay->decompression_stream,
netplay->zbuffer, cmd_size - 2*sizeof(uint32_t)); netplay->zbuffer, cmd_size - 2*sizeof(uint32_t));
netplay->decompression_backend->set_out(netplay->decompression_stream, netplay->decompression_backend->set_out(netplay->decompression_stream,
(uint8_t*)netplay->buffer[netplay->foo_read_ptr[connection->player]].state, (uint8_t*)netplay->buffer[netplay->read_ptr[connection->player]].state,
netplay->state_size); netplay->state_size);
netplay->decompression_backend->trans(netplay->decompression_stream, netplay->decompression_backend->trans(netplay->decompression_stream,
true, &rd, &wn, NULL); true, &rd, &wn, NULL);
@ -1133,14 +1133,14 @@ static bool netplay_get_cmd(netplay_t *netplay,
* load into. If we refer directly to read_ptr, then we'll end * load into. If we refer directly to read_ptr, then we'll end
* up never reading the input for read_frame_count itself, which * up never reading the input for read_frame_count itself, which
* will make the other side unhappy. */ * will make the other side unhappy. */
netplay->self_ptr = PREV_PTR(netplay->foo_read_ptr[connection->player]); netplay->self_ptr = PREV_PTR(netplay->read_ptr[connection->player]);
netplay->self_frame_count = frame - 1; netplay->self_frame_count = frame - 1;
} }
/* And force rewind to it */ /* And force rewind to it */
netplay->force_rewind = true; netplay->force_rewind = true;
netplay->savestate_request_outstanding = false; netplay->savestate_request_outstanding = false;
netplay->other_ptr = netplay->foo_read_ptr[connection->player]; netplay->other_ptr = netplay->read_ptr[connection->player];
netplay->other_frame_count = frame; netplay->other_frame_count = frame;
break; break;
} }
@ -2137,10 +2137,10 @@ void netplay_load_savestate(netplay_t *netplay,
for (player = 0; player < MAX_USERS; player++) for (player = 0; player < MAX_USERS; player++)
{ {
if (!(netplay->connected_players & (1<<player))) continue; if (!(netplay->connected_players & (1<<player))) continue;
if (netplay->foo_read_frame_count[player] < netplay->self_frame_count) if (netplay->read_frame_count[player] < netplay->self_frame_count)
{ {
netplay->foo_read_ptr[player] = netplay->self_ptr; netplay->read_ptr[player] = netplay->self_ptr;
netplay->foo_read_frame_count[player] = netplay->self_frame_count; netplay->read_frame_count[player] = netplay->self_frame_count;
} }
} }
if (netplay->server_frame_count < netplay->self_frame_count) if (netplay->server_frame_count < netplay->self_frame_count)

4
network/netplay/netplay_common.c
View File

@ -385,7 +385,7 @@ bool netplay_handshake_pre_sync(netplay_t *netplay, struct netplay_connection *c
/* FIXME: Assuming server is player 0 */ /* FIXME: Assuming server is player 0 */
netplay->self_frame_count = netplay->other_frame_count = netplay->self_frame_count = netplay->other_frame_count =
netplay->unread_frame_count = netplay->server_frame_count = netplay->unread_frame_count = netplay->server_frame_count =
netplay->foo_read_frame_count[0] = new_frame_count; netplay->read_frame_count[0] = new_frame_count;
for (i = 0; i < netplay->buffer_size; i++) for (i = 0; i < netplay->buffer_size; i++)
{ {
struct delta_frame *ptr = &netplay->buffer[i]; struct delta_frame *ptr = &netplay->buffer[i];
@ -398,7 +398,7 @@ bool netplay_handshake_pre_sync(netplay_t *netplay, struct netplay_connection *c
ptr->frame = new_frame_count; ptr->frame = new_frame_count;
ptr->have_local = true; ptr->have_local = true;
netplay->other_ptr = netplay->unread_ptr = netplay->server_ptr = netplay->other_ptr = netplay->unread_ptr = netplay->server_ptr =
netplay->foo_read_ptr[0] = i; netplay->read_ptr[0] = i;
} }
} }

4
network/netplay/netplay_private.h
View File

@ -319,8 +319,8 @@ struct netplay
uint32_t unread_frame_count; uint32_t unread_frame_count;
/* Pointer to the next frame to read from each player */ /* Pointer to the next frame to read from each player */
size_t foo_read_ptr[MAX_USERS]; size_t read_ptr[MAX_USERS];
uint32_t foo_read_frame_count[MAX_USERS]; uint32_t read_frame_count[MAX_USERS];
/* Pointer to the next frame to read from the server (as it might not be a /* Pointer to the next frame to read from the server (as it might not be a
* player but still synchronizes) */ * player but still synchronizes) */