void KinectV2Classifier::eventSetPredicting(ofxControlButtonEventArgs & evt) {
if (evt.value) {
toRecord = false;
toPredict = true;
capturing = false;
clock.stop();
startCountdown();
}
else if (!evt.value && !recording) {
clock.stop();
}
}
void Watchdog::startCountdownIfNeeded()
{
if (!m_isStopped)
return; // Already started.
if (!isArmed())
return; // Not executing JS script. No need to start.
if (isEnabled()) {
m_elapsedTime = std::chrono::microseconds::zero();
m_startTime = currentCPUTime();
startCountdown(m_limit);
}
}
InputEventSelectionDialog::InputEventSelectionDialog(QWidget* parent)
: QDialog(parent)
, ui(new Ui::InputEventSelectionDialog)
{
ui->setupUi(this);
ui->countdownlabel->setText(m_countingText.arg(COUNTDOWN_SECS));
m_countdownTimer = new QTimer(this);
connect(m_countdownTimer, SIGNAL(timeout()), this, SLOT(updateCountdown()));
setWindowFlags(Qt::Window | Qt::WindowCloseButtonHint);
setFixedSize(size());
// workaround to avoid direct thread ui access
connect(this, SIGNAL(startCountdown(QString)), this, SLOT(handleStartCountdown(QString)));
connect(this, SIGNAL(cancelCountdown()), this, SLOT(handleCancelCountdown()));
}
bool Watchdog::didFire(ExecState* exec)
{
if (m_didFire)
return true;
if (!m_timerDidFire)
return false;
m_timerDidFire = false;
stopCountdown();
auto currentTime = currentCPUTime();
auto deltaTime = currentTime - m_startTime;
auto totalElapsedTime = m_elapsedTime + deltaTime;
if (totalElapsedTime > m_limit) {
// Case 1: the allowed CPU time has elapsed.
// If m_callback is not set, then we terminate by default.
// Else, we let m_callback decide if we should terminate or not.
bool needsTermination = !m_callback
|| m_callback(exec, m_callbackData1, m_callbackData2);
if (needsTermination) {
m_didFire = true;
return true;
}
// The m_callback may have set a new limit. So, we may need to restart
// the countdown.
startCountdownIfNeeded();
} else {
// Case 2: the allowed CPU time has NOT elapsed.
// Tell the timer to alarm us again when it thinks we've reached the
// end of the allowed time.
auto remainingTime = m_limit - totalElapsedTime;
m_elapsedTime = totalElapsedTime;
m_startTime = currentTime;
startCountdown(remainingTime);
}
return false;
}
void InputEventSelectionDialog::onInputEvent(const BINDINGTARGET& target, uint32 value)
{
auto setSelection =
[this](CInputBindingManager::BINDINGTYPE bindingType, const auto& target) {
m_selectedTarget = target;
m_bindingType = bindingType;
m_state = STATE::SELECTED;
auto targetDescription = m_inputManager->GetTargetDescription(target);
startCountdown(QString::fromStdString(targetDescription));
};
auto resetSelection =
[this]() {
m_selectedTarget = BINDINGTARGET();
m_state = STATE::WAITING;
m_bindingType = CInputBindingManager::BINDING_UNBOUND;
cancelCountdown();
};
auto setSelectionSimulatedAxis =
[this](const auto& target) {
m_selectedTargetSimulatedAxis = target;
m_state = STATE::SIMULATEDAXIS_SELECTED;
auto targetDescription = m_inputManager->GetTargetDescription(target);
startCountdown(QString::fromStdString(targetDescription));
};
auto resetSelectionSimulatedAxis =
[this]() {
m_selectedTargetSimulatedAxis = BINDINGTARGET();
m_state = STATE::SIMULATEDAXIS_WAITING;
cancelCountdown();
};
switch(m_state)
{
case STATE::WAITING:
//Check if we've pressed something
if(PS2::CControllerInfo::IsAxis(m_button))
{
switch(target.keyType)
{
case BINDINGTARGET::KEYTYPE::BUTTON:
if(value != 0)
{
setSelection(CInputBindingManager::BINDING_SIMULATEDAXIS, target);
}
break;
case BINDINGTARGET::KEYTYPE::AXIS:
if(!IsAxisIdle(value))
{
setSelection(CInputBindingManager::BINDING_SIMPLE, target);
}
break;
}
}
else
{
switch(target.keyType)
{
case BINDINGTARGET::KEYTYPE::BUTTON:
if(value != 0)
{
setSelection(CInputBindingManager::BINDING_SIMPLE, target);
}
break;
case BINDINGTARGET::KEYTYPE::AXIS:
if(!IsAxisIdle(value))
{
setSelection(CInputBindingManager::BINDING_SIMPLE, target);
}
break;
case BINDINGTARGET::KEYTYPE::POVHAT:
if(value < BINDINGTARGET::POVHAT_MAX)
{
m_bindingValue = value;
setSelection(CInputBindingManager::BINDING_POVHAT, target);
}
}
}
break;
case STATE::SELECTED:
if(target != m_selectedTarget) break;
switch(target.keyType)
{
case BINDINGTARGET::KEYTYPE::BUTTON:
if(value == 0)
{
resetSelection();
}
break;
case BINDINGTARGET::KEYTYPE::AXIS:
if(IsAxisIdle(value))
{
resetSelection();
}
break;
case BINDINGTARGET::KEYTYPE::POVHAT:
if(m_bindingValue != value)
{
resetSelection();
}
}
break;
case STATE::SIMULATEDAXIS_WAITING:
if((target.keyType == BINDINGTARGET::KEYTYPE::BUTTON) && (value != 0))
{
setSelectionSimulatedAxis(target);
}
break;
case STATE::SIMULATEDAXIS_SELECTED:
if(target != m_selectedTargetSimulatedAxis) break;
if(value == 0)
{
resetSelectionSimulatedAxis();
}
break;
}
}
bool SynchronizationProtocol::notifyEventAsynchronous(Event* event)
{
if (event->type != EVENT_TYPE_MESSAGE)
return true;
NetworkString data = event->data();
if (data.size() < 10)
{
Log::warn("SynchronizationProtocol", "Received a message too short.");
return true;
}
uint8_t talk_id = data.gui8();
uint32_t token = data.gui32(1);
uint32_t request = data.gui8(5);
uint32_t sequence = data.gui32(6);
std::vector<STKPeer*> peers = NetworkManager::getInstance()->getPeers();
assert(peers.size() > 0);
if (m_listener->isServer())
{
if (talk_id > peers.size())
{
Log::warn("SynchronizationProtocol", "The ID isn't known.");
return true;
}
}
uint8_t peer_id = 0;
for (unsigned int i = 0; i < peers.size(); i++)
{
if (peers[i]->isSamePeer(*event->peer))
{
peer_id = i;
}
}
if (peers[peer_id]->getClientServerToken() != token)
{
Log::warn("SynchronizationProtocol", "Bad token from peer %d", talk_id);
return true;
}
if (request)
{
NetworkString response;
response.ai8(data.gui8(talk_id)).ai32(token).ai8(0).ai32(sequence);
m_listener->sendMessage(this, peers[peer_id], response, false);
Log::verbose("SynchronizationProtocol", "Answering sequence %u", sequence);
if (data.size() == 14 && !m_listener->isServer()) // countdown time in the message
{
uint32_t time_to_start = data.gui32(10);
Log::debug("SynchronizationProtocol", "Request to start game in %d.", time_to_start);
if (!m_countdown_activated)
startCountdown(time_to_start);
else
m_countdown = (double)(time_to_start/1000.0);
}
else
Log::verbose("SynchronizationProtocol", "No countdown for now.");
}
else // response
{
if (sequence >= m_pings[peer_id].size())
{
Log::warn("SynchronizationProtocol", "The sequence# %u isn't known.", sequence);
return true;
}
double current_time = StkTime::getRealTime();
m_total_diff[peer_id] += current_time - m_pings[peer_id][sequence];
Log::verbose("SynchronizationProtocol", "InstantPing is %u",
(unsigned int)((current_time - m_pings[peer_id][sequence])*1000));
m_successed_pings[peer_id]++;
m_average_ping[peer_id] = (int)((m_total_diff[peer_id]/m_successed_pings[peer_id])*1000.0);
Log::debug("SynchronizationProtocol", "Ping is %u", m_average_ping[peer_id]);
}
return true;
}
void loop() {
// Though counter-intuitive, game creation cannot be in setup because of varying arduino boot times and boot gibberish
if (!gameCreated) {
drawGUI();
while(!waitUntil(JOYSTICK_BUTTON_PIN, false));
if (!startNetwork()) {
tft.fillScreen(ST7735_BLACK); // we must clear all conflicting messages from screen
tft.setCursor(0,0);
dualPrint("Network connection failed!");
dualPrint("Please ensure:");
dualPrint("1) both arduinos are connected");
dualPrint("2) both parties pressed the joystick");
dualPrint("If both are true, consult someone who");
dualPrint("looks like he knows what he's talking about");
dualPrint("Reset both Arduinos to try again");
while(1);
}
/* Extensibility Goal:
* Enable colour selection here, time permissible
*/
gameCreated = true;
}
if (!gameStarted) {
setSpawns(&player1, &player2);
setColour(&player1, &player2);
tft.fillScreen(ST7735_BLACK);
startCountdown();
gameStarted = true;
}
winner = gameOver(&player1.currentPosition, &player2.currentPosition);
if (winner) {
tft.setCursor(0, 80);
String message;
switch (winner) {
case -1:
message = "YOU SUPER TIE";
break;
case 1:
message = "YOU SUPER WIN";
player1.score++;
break;
case 2:
message = "YOU SUPER LOSE";
player2.score++;
break;
}
tft.println(message);
tft.println("SCORES:");
tft.print("You: ");
tft.print(player1.score);
tft.print(" | Him: ");
tft.println(player2.score);
tft.println("Again? <Press Joystick>");
waitUntil(JOYSTICK_BUTTON_PIN, LOW);
memset(&wallPositions, 0, 2560); // 2560 is a magic number because size_ts were acting unexpectedly
gameStarted = false;
tft.fillScreen(ST7735_BLACK);
} else {
// add a wall ad draw car at current position
addWallPosition(player1.currentPosition);
addWallPosition(player2.currentPosition);
tft.fillRect(player1.currentPosition.x, player1.currentPosition.y, 2, 2, player1.colour);
tft.fillRect(player2.currentPosition.x, player2.currentPosition.y, 2, 2, player2.colour);
movement_t newDirection = getJoystickInput();
if (validInput(newDirection, player1.direction)) player1.direction = newDirection;
sendDeltas(&player1.direction);
receiveDeltas(&player2.direction);
player1.currentPosition.x += player1.direction.x;
player1.currentPosition.y += player1.direction.y;
player2.currentPosition.x += player2.direction.x;
player2.currentPosition.y += player2.direction.y;
delay(75); // this is how we control the game speed
/* Extensibility Goal:
* Find a more efficient and reliable way of controlling game speed.
* Implement it, and allow it to be customized
*/
}
}
