static int
parse_dts(struct ckb_softc *sc)
{
phandle_t node;
pcell_t dts_value;
pcell_t *keymap;
int len, ret;
const char *keymap_prop = NULL;
if ((node = ofw_bus_get_node(sc->dev)) == -1)
return (ENXIO);
if ((len = OF_getproplen(node, "google,key-rows")) <= 0)
return (ENXIO);
OF_getencprop(node, "google,key-rows", &dts_value, len);
sc->rows = dts_value;
if ((len = OF_getproplen(node, "google,key-columns")) <= 0)
return (ENXIO);
OF_getencprop(node, "google,key-columns", &dts_value, len);
sc->cols = dts_value;
if ((len = OF_getproplen(node, "freebsd,intr-gpio")) <= 0)
return (ENXIO);
OF_getencprop(node, "freebsd,intr-gpio", &dts_value, len);
sc->gpio = dts_value;
if (OF_hasprop(node, "freebsd,keymap")) {
keymap_prop = "freebsd,keymap";
device_printf(sc->dev, "using FreeBSD-specific keymap from FDT\n");
} else if (OF_hasprop(node, "linux,keymap")) {
keymap_prop = "linux,keymap";
device_printf(sc->dev, "using Linux keymap from FDT\n");
} else {
device_printf(sc->dev, "using built-in keymap\n");
}
if (keymap_prop != NULL) {
if ((ret = read_keymap(node, keymap_prop, &keymap, &len))) {
device_printf(sc->dev,
"failed to read keymap from FDT: %d\n", ret);
return (ret);
}
ret = parse_keymap(sc, keymap, len);
free(keymap, M_DEVBUF);
if (ret) {
return (ret);
}
} else {
if ((ret = parse_keymap(sc, default_keymap, KEYMAP_LEN))) {
return (ret);
}
}
if ((sc->rows == 0) || (sc->cols == 0) || (sc->gpio == 0))
return (ENXIO);
return (0);
}
void load_keyboard_settings()
{
// Load the default keymap
std::istringstream sin;
sin.str(default_keymap_txt());
parse_keymap(sin, default_keymap);
// Load the player's actual keymap
std::ifstream fin;
fin.open(FILENAMES["keymap"].c_str());
if (!fin) { // It doesn't exist
std::ofstream fout;
fout.open(FILENAMES["keymap"].c_str());
fout << default_keymap_txt();
fout.close();
fin.open(FILENAMES["keymap"].c_str());
}
if (!fin) { // Still can't open it--probably bad permissions
debugmsg(std::string("Can't open " + FILENAMES["keymap"] + " This may be a permissions issue.").c_str());
keymap = default_keymap;
return;
} else {
parse_keymap(fin, keymap, true);
}
// Check for new defaults, and automatically bind them if possible
std::map<char, action_id>::iterator d_it;
for (d_it = default_keymap.begin(); d_it != default_keymap.end(); ++d_it) {
bool found = false;
if (unbound_keymap.find(d_it->second) != unbound_keymap.end()) {
break;
}
std::map<char, action_id>::iterator k_it;
for (k_it = keymap.begin(); k_it != keymap.end(); ++k_it) {
if (d_it->second == k_it->second) {
found = true;
break;
}
}
if (!found && !keymap.count(d_it->first)) {
keymap[d_it->first] = d_it->second;
}
}
}
/* Called by the time manager task in vbl_macintosh.c */
boolean input_controller(
void)
{
if (input_task_active)
{
if((heartbeat_count-dynamic_world->tick_count) < MAXIMUM_TIME_DIFFERENCE)
{
if (game_is_networked) // input from network
{
; // all handled elsewhere now. (in network.c)
}
else if (replay.game_is_being_replayed) // input from recorded game file
{
static short phase= 0; /* When this gets to 0, update the world */
/* Minimum replay speed is a pause. */
if(replay.replay_speed != MINIMUM_REPLAY_SPEED)
{
if (replay.replay_speed > 0 || (--phase<=0))
{
short flag_count= MAX(replay.replay_speed, 1);
if (!pull_flags_from_recording(flag_count)) // oops. silly me.
{
if (replay.have_read_last_chunk)
{
assert(get_game_state()==_game_in_progress || get_game_state()==_switch_demo);
set_game_state(_switch_demo);
}
}
else
{
/* Increment the heartbeat.. */
heartbeat_count+= flag_count;
}
/* Reset the phase-> doesn't matter if the replay speed is positive */
/* +1 so that replay_speed 0 is different from replay_speed 1 */
phase= -(replay.replay_speed) + 1;
}
}
}
else // then getting input from the keyboard/mouse
{
long action_flags= parse_keymap();
process_action_flags(local_player_index, &action_flags, 1);
heartbeat_count++; // ba-doom
}
} else {
// dprintf("Out of phase.. (%d);g", heartbeat_count - dynamic_world->tick_count);
}
}
return TRUE; // tells the time manager library to reschedule this task
}
void load_keyboard_settings( std::map<char, action_id> &keymap,
std::string &keymap_file_loaded_from,
std::set<action_id> &unbound_keymap )
{
const auto parser = [&]( std::istream & fin ) {
parse_keymap( fin, keymap, unbound_keymap );
};
if( read_from_file_optional( FILENAMES["keymap"], parser ) ) {
keymap_file_loaded_from = FILENAMES["keymap"];
} else if( read_from_file_optional( FILENAMES["legacy_keymap"], parser ) ) {
keymap_file_loaded_from = FILENAMES["legacy_keymap"];
}
}
void load_keyboard_settings(std::map<char, action_id> &keymap, std::string &keymap_file_loaded_from, std::set<action_id> &unbound_keymap)
{
// Load the player's actual keymap
std::ifstream fin;
fin.open(FILENAMES["keymap"].c_str());
if (!fin.is_open()) { // It doesn't exist
// Try it at the legacy location.
fin.open(FILENAMES["legacy_keymap"].c_str());
if (fin.is_open()) {
keymap_file_loaded_from = FILENAMES["legacy_keymap"];
}
} else {
keymap_file_loaded_from = FILENAMES["keymap"];
}
if (!fin.is_open()) { // Still can't open it--probably bad permissions
return;
}
parse_keymap(fin, keymap, unbound_keymap);
}
static bool
spoke_tick()
{
logContextNMT("processing spoke_tick %d", sNetworkTicker);
sNetworkTicker++;
if(sConnected)
{
int32 theSilentTicksBeforeNetDeath = (sOutgoingFlags.getReadTick() >= sSmallestRealGameTick) ? sSpokePreferences.mInGameTicksBeforeNetDeath : sSpokePreferences.mPregameTicksBeforeNetDeath;
if(sNetworkTicker - sLastNetworkTickHeard > theSilentTicksBeforeNetDeath)
{
logTraceNMT("giving up on hub; disconnecting");
spoke_became_disconnected();
return true;
}
}
bool shouldSend = false;
// Negative timing adjustment means we need to provide extra ticks because we're late.
// We let this cover the normal timing adjustment = 0 case too.
if(sOutstandingTimingAdjustment <= 0)
{
int theNumberOfFlagsToProvide = -sOutstandingTimingAdjustment + 1;
logDumpNMT("want to provide %d flags", theNumberOfFlagsToProvide);
while(theNumberOfFlagsToProvide > 0)
{
// If we're not connected, write only to our local game's queue.
// If we are connected,
// if we're actually in the game, write to both local game and outbound flags queues
// else (if pregame), write only to the outbound flags queue.
WritableTickBasedActionQueue& theTargetQueue =
sConnected ?
((sOutgoingFlags.getWriteTick() >= sSmallestRealGameTick) ?
static_cast<WritableTickBasedActionQueue&>(sLocallyGeneratedFlags)
: static_cast<WritableTickBasedActionQueue&>(sOutgoingFlags))
: *(sNetworkPlayers[sLocalPlayerIndex].mQueue);
if(theTargetQueue.availableCapacity() <= 0)
break;
logDumpNMT("enqueueing flags for tick %d", theTargetQueue.getWriteTick());
theTargetQueue.enqueue(parse_keymap());
shouldSend = true;
theNumberOfFlagsToProvide--;
}
// Prevent creeping timing adjustment during "lulls"; OTOH remember to
// finish next time if we made progress but couldn't complete our obligation.
if(theNumberOfFlagsToProvide != -sOutstandingTimingAdjustment + 1)
sOutstandingTimingAdjustment = -theNumberOfFlagsToProvide;
}
// Positive timing adjustment means we should delay sending for a while,
// so we just throw away this local tick.
else
{
logDumpNMT("ignoring this tick for timing adjustment");
sOutstandingTimingAdjustment--;
}
logDumpNMT("sOutstandingTimingAdjustment is now %d", sOutstandingTimingAdjustment);
if(sOutgoingLossyByteStreamDescriptors.getCountOfElements() > 0)
shouldSend = true;
// If we're connected and (we generated new data or if it's been long enough since we last sent), send.
if(sConnected)
{
if (sHeardFromHub) {
if(shouldSend || (sNetworkTicker - sLastNetworkTickSent) >= sSpokePreferences.mRecoverySendPeriod)
send_packet();
} else {
if (!(sNetworkTicker % 30))
send_identification_packet();
}
}
else
{
int32 theLocalPlayerWriteTick = getNetworkPlayer(sLocalPlayerIndex).mQueue->getWriteTick();
// Since we're not connected, we won't be enqueueing flags for the other players in the packet handler.
// So, we do it here to keep the game moving.
for(size_t i = 0; i < sNetworkPlayers.size(); i++)
{
if(i == sLocalPlayerIndex)
{
// move our flags from sent queue to player queue
while (sSmallestUnconfirmedTick < sUnconfirmedFlags.getWriteTick())
{
sNetworkPlayers[i].mQueue->enqueue(sUnconfirmedFlags.peek(sSmallestUnconfirmedTick++));
}
continue;
}
NetworkPlayer_spoke& thePlayer = sNetworkPlayers[i];
if(!thePlayer.mZombie)
{
while(thePlayer.mQueue->getWriteTick() < theLocalPlayerWriteTick)
{
logDumpNMT("enqueueing NET_DEAD_ACTION_FLAG for player %d tick %d", i, thePlayer.mQueue->getWriteTick());
thePlayer.mQueue->enqueue(static_cast<action_flags_t>(NET_DEAD_ACTION_FLAG));
}
}
}
}
check_send_packet_to_hub();
// We want to run again.
return true;
}