mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-03 19:20:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed simulation for >2 players

Browse Source
This commit is contained in:
Gregor Richards 2016-12-12 17:23:21 -05:00
parent 262d77546b
commit 2130fd81a5
3 changed files with 49 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
network/netplay/netplay.c
View File

@ -1318,45 +1318,56 @@ static int poll_input(netplay_t *netplay, bool block)
* *
* "Simulate" input by assuming it hasn't changed since the last read input. * "Simulate" input by assuming it hasn't changed since the last read input.
*/ */
void netplay_simulate_input(netplay_t *netplay, uint32_t sim_ptr, bool resim) void netplay_simulate_input(netplay_t *netplay, size_t sim_ptr, bool resim)
{ {
size_t prev = PREV_PTR(netplay->unread_ptr); uint32_t player;
struct delta_frame *pframe = &netplay->buffer[prev], size_t prev;
*simframe = &netplay->buffer[sim_ptr]; struct delta_frame *simframe, *pframe;
if (resim)
simframe = &netplay->buffer[sim_ptr];
for (player = 0; player < MAX_USERS; player++)
{ {
/* In resimulation mode, we only copy the buttons. The reason for this if (!(netplay->connected_players & (1<<player))) continue;
* is nonobvious: if (simframe->have_real[player]) continue;
*
* If we resimulated nothing, then the /duration/ with which any input prev = PREV_PTR(netplay->read_ptr[player]);
* was pressed would be approximately correct, since the original pframe = &netplay->buffer[prev];
* simulation came in as the input came in, but the /number of times/
* the input was pressed would be wrong, as there would be an if (resim)
* advancing wavefront of real data overtaking the simulated data {
* (which is really just real data offset by some frames). /* In resimulation mode, we only copy the buttons. The reason for this
* * is nonobvious:
* That's acceptable for arrows in most situations, since the amount *
* you move is tied to the duration, but unacceptable for buttons, * If we resimulated nothing, then the /duration/ with which any input
* which will seem to jerkily be pressed numerous times with those * was pressed would be approximately correct, since the original
* wavefronts. * simulation came in as the input came in, but the /number of times/
*/ * the input was pressed would be wrong, as there would be an
const uint32_t keep = (1U<<RETRO_DEVICE_ID_JOYPAD_UP) | * advancing wavefront of real data overtaking the simulated data
(1U<<RETRO_DEVICE_ID_JOYPAD_DOWN) | * (which is really just real data offset by some frames).
(1U<<RETRO_DEVICE_ID_JOYPAD_LEFT) | *
(1U<<RETRO_DEVICE_ID_JOYPAD_RIGHT); * That's acceptable for arrows in most situations, since the amount
uint32_t sim_state = simframe->simulated_input_state[0][0] & keep; * you move is tied to the duration, but unacceptable for buttons,
sim_state |= pframe->real_input_state[0][0] & ~keep; * which will seem to jerkily be pressed numerous times with those
simframe->simulated_input_state[0][0] = sim_state; * wavefronts.
} */
else const uint32_t keep = (1U<<RETRO_DEVICE_ID_JOYPAD_UP) |
{ (1U<<RETRO_DEVICE_ID_JOYPAD_DOWN) |
memcpy(simframe->simulated_input_state, (1U<<RETRO_DEVICE_ID_JOYPAD_LEFT) |
pframe->real_input_state, (1U<<RETRO_DEVICE_ID_JOYPAD_RIGHT);
sizeof(pframe->real_input_state)); uint32_t sim_state = simframe->simulated_input_state[player][0] & keep;
sim_state |= pframe->real_input_state[player][0] & ~keep;
simframe->simulated_input_state[player][0] = sim_state;
}
else
{
memcpy(simframe->simulated_input_state[player],
pframe->real_input_state[player],
WORDS_PER_INPUT * sizeof(uint32_t));
}
} }
} }
/** /**
* netplay_poll: * netplay_poll:
* @netplay : pointer to netplay object * @netplay : pointer to netplay object
@ -1392,8 +1403,7 @@ static bool netplay_poll(void)
} }
/* Simulate the input if we don't have real input */ /* Simulate the input if we don't have real input */
if (!netplay_data->buffer[netplay_data->self_ptr].have_real) netplay_simulate_input(netplay_data, netplay_data->self_ptr, false);
netplay_simulate_input(netplay_data, netplay_data->self_ptr, false);
/* Consider stalling */ /* Consider stalling */
switch (netplay_data->stall) switch (netplay_data->stall)

5
network/netplay/netplay_net.c
View File

@ -318,9 +318,8 @@ void netplay_sync_post_frame(netplay_t *netplay)
if (netplay->replay_frame_count < netplay->unread_frame_count) if (netplay->replay_frame_count < netplay->unread_frame_count)
netplay_handle_frame_hash(netplay, ptr); netplay_handle_frame_hash(netplay, ptr);
/* Simulate this frame's input */ /* Re-simulate this frame's input */
if (netplay->replay_frame_count >= netplay->unread_frame_count) netplay_simulate_input(netplay, netplay->replay_ptr, true);
netplay_simulate_input(netplay, netplay->replay_ptr, true);
autosave_lock(); autosave_lock();
core_run(); core_run();

2
network/netplay/netplay_private.h
View File

@ -482,7 +482,7 @@ bool netplay_init_serialization(netplay_t *netplay);
/* Force serialization to be ready by fast-forwarding the core */ /* Force serialization to be ready by fast-forwarding the core */
bool netplay_wait_and_init_serialization(netplay_t *netplay); bool netplay_wait_and_init_serialization(netplay_t *netplay);
void netplay_simulate_input(netplay_t *netplay, uint32_t sim_ptr, bool resim); void netplay_simulate_input(netplay_t *netplay, size_t sim_ptr, bool resim);
void netplay_log_connection(const struct sockaddr_storage *their_addr, void netplay_log_connection(const struct sockaddr_storage *their_addr,
unsigned slot, const char *nick); unsigned slot, const char *nick);