736 lines
22 KiB
C++
736 lines
22 KiB
C++
/****************************************************************************
|
|
** ScStw Libraries
|
|
** Copyright (C) 2020 Itsblue development
|
|
**
|
|
** This program is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation, either version 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** This program is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
****************************************************************************/
|
|
|
|
#include "../headers/scstwrace.h"
|
|
|
|
ScStwRace::ScStwRace(ScStwSettings *settings, QObject *parent) : QObject(parent)
|
|
{
|
|
this->state = IDLE;
|
|
this->competitionMode = false;
|
|
|
|
// configure the loop that waits for the sound effect to finish
|
|
this->soundPlayer = new ScStwSoundPlayer();
|
|
|
|
// configure timer that handles the delay between the start commands
|
|
this->startDelayTimer = new QTimer(this);
|
|
startDelayTimer->setSingleShot(true);
|
|
this->startWaitLoop = new QEventLoop(this);
|
|
|
|
connect(this->startDelayTimer, &QTimer::timeout, this->startWaitLoop, &QEventLoop::quit);
|
|
|
|
connect(this, &ScStwRace::currentStartDelayChanged, this, &ScStwRace::detailsChanged);
|
|
connect(this, &ScStwRace::timersChanged, this, &ScStwRace::detailsChanged);
|
|
connect(this, &ScStwRace::stateChanged, this, &ScStwRace::detailsChanged);
|
|
|
|
// init settings
|
|
this->settings = settings;
|
|
this->refreshCompetitionMode();
|
|
}
|
|
|
|
// --------------------------
|
|
// --- Main Functionality ---
|
|
// --------------------------
|
|
|
|
ScStw::StatusCode ScStwRace::start(bool asyncronous) {
|
|
if(this->state == WAITING) {
|
|
if(this->getIsReadyForNextState()) {
|
|
this->startWaitLoop->exit(LoopManualExit);
|
|
return ScStw::Success;
|
|
}
|
|
else {
|
|
return ScStw::TimersNotReadyError;
|
|
}
|
|
}
|
|
else if(this->state != IDLE) {
|
|
return ScStw::CurrentStateNotVaildForOperationError;
|
|
}
|
|
|
|
this->refreshCompetitionMode();
|
|
|
|
if(!this->getIsReadyForNextState())
|
|
return ScStw::TimersNotReadyError;
|
|
|
|
this->setState(PREPAIRING);
|
|
|
|
if(asyncronous) {
|
|
QTimer::singleShot(1, [=](){this->playSoundsAndStartTimers();});
|
|
}
|
|
else
|
|
this->playSoundsAndStartTimers();
|
|
|
|
return ScStw::Success;
|
|
}
|
|
|
|
ScStw::StatusCode ScStwRace::stop() {
|
|
if(this->state != RUNNING && this->state != STARTING) {
|
|
return ScStw::CurrentStateNotVaildForOperationError;
|
|
}
|
|
|
|
if(this->competitionMode)
|
|
return this->cancel();
|
|
|
|
qDebug() << "[INFO][RACE] stopping race";
|
|
|
|
double timeOfStop = QDateTime::currentMSecsSinceEpoch();
|
|
|
|
ScStw::StatusCode returnCode = ScStw::Success;
|
|
|
|
foreach(ScStwTimer *speedTimer, this->timers){
|
|
if(!speedTimer->stop(timeOfStop) && speedTimer->getState() != ScStwTimer::DISABLED){
|
|
returnCode = ScStw::InternalErrorTimerOperationFailed;
|
|
}
|
|
}
|
|
|
|
if(returnCode == ScStw::Success) {
|
|
this->setState(STOPPED);
|
|
}
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
void ScStwRace::handleTimerStop() {
|
|
if(this->state == RUNNING) {
|
|
// find out which timer has won
|
|
double lowestStoppedTime = -1;
|
|
QList<ScStwTimer *> timersWhichHaveWonIds;
|
|
|
|
// iterate through all timers and find the lowest time taht was stopped
|
|
foreach(ScStwTimer * timer, this->timers) {
|
|
if(timer->getCurrentTime() > 0 && (timer->getCurrentTime() <= lowestStoppedTime || lowestStoppedTime < 0)) {
|
|
// this is the timer with the lowest stopped time
|
|
lowestStoppedTime = timer->getCurrentTime();
|
|
}
|
|
}
|
|
|
|
// append the timer(s) with the lowest stopped time to the winner list
|
|
foreach(ScStwTimer * timer, this->timers) {
|
|
if(timer->getCurrentTime() > 0
|
|
&& (timer->getCurrentTime() <= lowestStoppedTime || lowestStoppedTime < 0)
|
|
&& timer->getState() != ScStwTimer::RUNNING
|
|
) {
|
|
// this is the timer with the lowest stopped time
|
|
timersWhichHaveWonIds.append(timer);
|
|
}
|
|
}
|
|
|
|
// update the states of all timers
|
|
foreach(ScStwTimer * timer, this->timers) {
|
|
if(timer->getState() == ScStwTimer::RUNNING)
|
|
continue;
|
|
|
|
if(timersWhichHaveWonIds.contains(timer)) {
|
|
timer->setResult(ScStwTimer::WON);
|
|
}
|
|
else {
|
|
timer->setResult(ScStwTimer::LOST);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ScStw::StatusCode ScStwRace::reset() {
|
|
if(this->state != STOPPED && this->state != INCIDENT) {
|
|
return ScStw::CurrentStateNotVaildForOperationError;
|
|
}
|
|
|
|
qDebug() << "[INFO][RACE] resetting race";
|
|
|
|
ScStw::StatusCode returnCode = ScStw::Success;
|
|
|
|
foreach(ScStwTimer *speedTimer, this->timers){
|
|
if(!speedTimer->reset() && speedTimer->getState() != ScStwTimer::DISABLED && speedTimer->getState() != ScStwTimer::IDLE) {
|
|
returnCode = ScStw::InternalErrorTimerOperationFailed;
|
|
}
|
|
}
|
|
|
|
if(returnCode == ScStw::Success)
|
|
this->setState(IDLE);
|
|
|
|
this->soundPlayer->cancel();
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
ScStw::StatusCode ScStwRace::cancel() {
|
|
if(this->state != PREPAIRING && this->state != WAITING && this->state != STARTING && this->state != RUNNING)
|
|
return ScStw::CurrentStateNotVaildForOperationError;
|
|
|
|
qDebug() << "[INFO][RACE] cancelling race";
|
|
|
|
ScStw::StatusCode returnCode = ScStw::Success;
|
|
|
|
foreach(ScStwTimer *timer, this->timers){
|
|
if(!timer->cancel() && timer->getState() != ScStwTimer::DISABLED)
|
|
returnCode = ScStw::InternalErrorTimerOperationFailed;
|
|
}
|
|
|
|
if(returnCode != ScStw::Success)
|
|
return returnCode;
|
|
|
|
this->setState(STOPPED);
|
|
|
|
this->startWaitLoop->exit(LoopCancelExit);
|
|
this->soundPlayer->cancel();
|
|
this->startDelayTimer->stop();
|
|
|
|
emit this->currentStartDelayChanged();
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
void ScStwRace::technicalIncident() {
|
|
foreach(ScStwTimer *timer, this->timers){
|
|
timer->cancel();
|
|
}
|
|
|
|
this->soundPlayer->cancel();
|
|
this->setState(INCIDENT);
|
|
}
|
|
|
|
int ScStwRace::handleFalseStart() {
|
|
if(this->getState() != STARTING && this->getState() != RUNNING)
|
|
return ScStw::CurrentStateNotVaildForOperationError;
|
|
|
|
int returnCode = ScStw::Success;
|
|
// cancel all running timers
|
|
foreach(ScStwTimer *timer, this->timers) {
|
|
if(!timer->cancel() && timer->getState() != ScStwTimer::DISABLED && timer->getState() != ScStwTimer::FAILED)
|
|
returnCode = ScStw::InternalErrorTimerOperationFailed;
|
|
}
|
|
|
|
this->setState(STOPPED);
|
|
this->soundPlayer->cancel();
|
|
this->soundPlayer->play(ScStwSoundPlayer::FalseStart, this->getSoundVolume());
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
bool ScStwRace::playSoundsAndStartTimers() {
|
|
if(this->state != PREPAIRING)
|
|
return true;
|
|
|
|
// The check if all timers are ready has already happened at this point
|
|
ScStwSoundPlayer::PlayResult res = this->doDelayAndSoundOfCurrentStartState();
|
|
|
|
if(res == ScStwSoundPlayer::Error) {
|
|
qDebug() << "[ERROR][RACE] error playing at your marks sound";
|
|
this->technicalIncident();
|
|
return false;
|
|
}
|
|
else if(res == ScStwSoundPlayer::Cancelled) {
|
|
return false;
|
|
}
|
|
|
|
// check if the start was cancelled
|
|
if(!this->isStarting())
|
|
return false;
|
|
|
|
this->setState(WAITING);
|
|
|
|
// do climber readiness tests
|
|
|
|
// if the automatic ready tone is enabled, wait for the climbers to become ready
|
|
if(this->competitionMode && this->getSoundEnabledSetting(ScStwSoundPlayer::Ready)) {
|
|
|
|
qDebug() << "[RACE][INFO] Now waiting for climbers";
|
|
|
|
// get delay
|
|
int minimumReadyDelay = 1000;
|
|
if(this->getSoundDelaySetting(ScStwSoundPlayer::Ready) > 1000)
|
|
minimumReadyDelay = this->getSoundDelaySetting(ScStwSoundPlayer::Ready);
|
|
|
|
this->startDelayTimer->setInterval(minimumReadyDelay);
|
|
|
|
// wait for all climbers to be ready for the ReadyActionDelay, but at least one second continuosly
|
|
// the climber ready wait loop will also quit, if the climber steps of the pad
|
|
// -> wait for both climbers to stand on the pad for at least one second
|
|
|
|
bool timerTriggered = true;
|
|
do {
|
|
|
|
if(!this->getIsReadyForNextState()) {
|
|
this->startDelayTimer->stop();
|
|
timerTriggered = false;
|
|
}
|
|
else if(this->startDelayTimer->isActive()) {
|
|
timerTriggered = true;
|
|
}
|
|
else {
|
|
this->startDelayTimer->stop();
|
|
this->startDelayTimer->start();
|
|
timerTriggered = true;
|
|
}
|
|
|
|
emit this->currentStartDelayChanged();
|
|
|
|
int loopExitCode = this->startWaitLoop->exec();
|
|
|
|
switch (loopExitCode) {
|
|
case LoopAutomaticExit:
|
|
break;
|
|
case LoopManualExit:
|
|
// prevent manual stop
|
|
timerTriggered = false;
|
|
break;
|
|
case LoopCancelExit:
|
|
return false;
|
|
}
|
|
|
|
//qDebug() << "At end of loop: remaining time: " << this->startDelayTimer->remainingTime() << " timer triggered: " << timerTriggered << " ready for next state: " << this->isReadyForNextState();
|
|
|
|
} while(this->startDelayTimer->remainingTime() > 0 || !timerTriggered || !this->getIsReadyForNextState());
|
|
|
|
qDebug() << "[DEBUG][RACE] Wait finished, starting now!";
|
|
|
|
// play ready tone
|
|
ScStwSoundPlayer::PlayResult res = this->soundPlayer->play(ScStwSoundPlayer::Ready, this->getSoundVolume());
|
|
|
|
if(res == ScStwSoundPlayer::Error) {
|
|
qDebug() << "[ERROR][RACE] error playing ready sound";
|
|
this->technicalIncident();
|
|
return false;
|
|
}
|
|
else if(res == ScStwSoundPlayer::Cancelled) {
|
|
return false;
|
|
}
|
|
}
|
|
else if(this->competitionMode) {
|
|
// wait for climbers and manual start
|
|
int loopExitCode;
|
|
do {
|
|
loopExitCode = this->startWaitLoop->exec();
|
|
|
|
if(loopExitCode == LoopCancelExit)
|
|
return false;
|
|
|
|
} while(loopExitCode != LoopManualExit || !this->getIsReadyForNextState());
|
|
}
|
|
else {
|
|
ScStwSoundPlayer::PlayResult res = this->doDelayAndSoundOfCurrentStartState();
|
|
|
|
if(res == ScStwSoundPlayer::Error) {
|
|
qDebug() << "[ERROR][RACE] error playing ready sound";
|
|
this->technicalIncident();
|
|
return false;
|
|
}
|
|
else if(res == ScStwSoundPlayer::Cancelled) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// enter starting state
|
|
this->setState(STARTING);
|
|
|
|
// play start tone
|
|
double timeOfSoundPlaybackStart;
|
|
res = this->doDelayAndSoundOfCurrentStartState(&timeOfSoundPlaybackStart);
|
|
|
|
if(res == ScStwSoundPlayer::Error) {
|
|
qDebug() << "[ERROR][RACE] error playing at your marks sound";
|
|
this->technicalIncident();
|
|
return false;
|
|
}
|
|
else if(res == ScStwSoundPlayer::Cancelled) {
|
|
return false;
|
|
}
|
|
|
|
// perform start
|
|
|
|
// start all timers
|
|
bool startOk = true;
|
|
foreach(ScStwTimer *timer, this->timers){
|
|
if(!timer->start(timeOfSoundPlaybackStart + 3100) && timer->getState() != ScStwTimer::DISABLED){
|
|
startOk = false;
|
|
}
|
|
}
|
|
if(!startOk) {
|
|
qDebug() << "[ERROR][RACE] error staring all timers";
|
|
this->technicalIncident();
|
|
return false;
|
|
}
|
|
|
|
if(this->soundPlayer->waitForSoundFinish() == ScStwSoundPlayer::Error) {
|
|
qDebug() << "[ERROR][RACE] start sound wait error";
|
|
this->technicalIncident();
|
|
return false;
|
|
}
|
|
|
|
// check if a false start occured
|
|
if(!this->isStarting())
|
|
return false;
|
|
|
|
this->setState(RUNNING);
|
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
ScStwSoundPlayer::PlayResult ScStwRace::doDelayAndSoundOfCurrentStartState(double *timeOfSoundPlaybackStart) {
|
|
ScStwSoundPlayer::StartSound sound = this->getSoundForState(this->state);
|
|
|
|
if(this->getSoundEnabledSetting(sound)) {
|
|
if(sound != ScStwSoundPlayer::Start && this->getSoundDelaySetting(sound) > 0) {
|
|
// perform the delay before the start
|
|
|
|
// get delay
|
|
int thisSoundDelay = this->getSoundDelaySetting(sound);
|
|
|
|
// perform next action
|
|
if(thisSoundDelay > 0) {
|
|
this->startDelayTimer->setInterval(thisSoundDelay);
|
|
this->startDelayTimer->start();
|
|
|
|
emit this->currentStartDelayChanged();
|
|
|
|
if(this->startWaitLoop->exec() == LoopCancelExit)
|
|
return ScStwSoundPlayer::Cancelled;
|
|
}
|
|
}
|
|
|
|
if(!this->isStarting())
|
|
return ScStwSoundPlayer::Error;
|
|
|
|
|
|
return this->soundPlayer->play(sound, this->getSoundVolume(), timeOfSoundPlaybackStart);
|
|
}
|
|
|
|
return ScStwSoundPlayer::Success;
|
|
}
|
|
|
|
void ScStwRace::setState(RaceState newState) {
|
|
if(newState != this->state) {
|
|
qDebug() << "[INFO][RACE] state changed: " << newState;
|
|
this->state = newState;
|
|
emit this->stateChanged(newState);
|
|
|
|
if(this->state == IDLE) {
|
|
this->refreshCompetitionMode();
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScStwRace::refreshTimerStates() {
|
|
qDebug() << "[INFO][MAIN] refreshing timer states";
|
|
|
|
// check if the race is over
|
|
bool raceIsOver = true;
|
|
|
|
foreach(ScStwTimer * timer, this->timers){
|
|
if(timer->getState() < ScStwTimer::WON && timer->getState() != ScStwTimer::WAITING){
|
|
// if the timer is not in stoped state
|
|
raceIsOver = false;
|
|
break;
|
|
}
|
|
else if(timer->getState() == ScStwTimer::WAITING) {
|
|
this->handleTimerStop();
|
|
}
|
|
else if (timer->getState() == ScStwTimer::FAILED) {
|
|
this->handleFalseStart();
|
|
}
|
|
}
|
|
|
|
if(raceIsOver)
|
|
this->setState(STOPPED);
|
|
}
|
|
|
|
// ------------------------
|
|
// --- helper functions ---
|
|
// ------------------------
|
|
|
|
bool ScStwRace::getIsReadyForNextState() {
|
|
if(!this->competitionMode) {
|
|
return true;
|
|
}
|
|
|
|
switch (this->state) {
|
|
case IDLE: {
|
|
foreach (ScStwTimer *timer, this->timers) {
|
|
if(timer->getState() == ScStwTimer::DISABLED)
|
|
continue;
|
|
|
|
if(timer->getReadyState() == ScStwTimer::ExtensionIsNotConnected || timer->getReadyState() == ScStwTimer::ExtensionBatteryNotFine) {
|
|
|
|
timer->technicalIncident();
|
|
|
|
foreach (ScStwTimer *subTimer, this->timers) {
|
|
if(timer != subTimer && (timer->getReadyState() == ScStwTimer::ExtensionIsNotConnected || timer->getReadyState() == ScStwTimer::ExtensionBatteryNotFine))
|
|
subTimer->technicalIncident();
|
|
else if(timer != subTimer)
|
|
subTimer->setState(ScStwTimer::CANCELLED);
|
|
}
|
|
|
|
this->technicalIncident();
|
|
|
|
qDebug() << "[ERROR][RACE] Could not start due to not-ready timers";
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
break;
|
|
case WAITING: {
|
|
foreach (ScStwTimer *timer, this->timers) {
|
|
if(timer->getReadyState() != ScStwTimer::IsReady)
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;;
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
/**
|
|
* @brief ScStwRace::handleTimerEnable function to enable timers at the right moment to prevent them from bricking the state machine
|
|
* @param {ScStwExtensionControlledTimer*} timer timer to be enabled
|
|
*/
|
|
void ScStwRace::handleTimerWantsToBeDisabledChange(ScStwTimer* timer, bool wantsToBeDisabled) {
|
|
if(this->competitionMode)
|
|
return;
|
|
|
|
if(this->state == IDLE) {
|
|
timer->setDisabled(wantsToBeDisabled);
|
|
}
|
|
}
|
|
|
|
void ScStwRace::refreshCompetitionMode() {
|
|
if(this->state != IDLE)
|
|
return;
|
|
|
|
bool currentCompetitionMode = this->settings->readSetting(ScStwSettings::CompetitionModeSetting).toBool();
|
|
|
|
if(this->competitionMode != currentCompetitionMode) {
|
|
|
|
qDebug() << "[INFO][RACE] Setting competition mode to " << currentCompetitionMode;
|
|
|
|
this->competitionMode = currentCompetitionMode;
|
|
|
|
if(this->competitionMode) {
|
|
foreach (ScStwTimer *timer, this->timers) {
|
|
timer->setDisabled(false);
|
|
}
|
|
}
|
|
else {
|
|
foreach(ScStwTimer* timer, this->timers) {
|
|
if(timer->getWantsToBeDisabled() && timer->getState() != ScStwTimer::DISABLED)
|
|
this->handleTimerWantsToBeDisabledChange(timer, timer->getWantsToBeDisabled());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
QVariantMap ScStwRace::getCurrentStartDelay() {
|
|
|
|
QVariantMap currentStartDelay = {
|
|
{"total", -1.0},
|
|
{"progress", -1.0}
|
|
};
|
|
|
|
switch (this->state) {
|
|
|
|
case WAITING:
|
|
if(!this->getSoundEnabledSetting(ScStwSoundPlayer::Ready))
|
|
return currentStartDelay;
|
|
if(!this->getIsReadyForNextState()) {
|
|
// indicate that we are waiting for climbers and the progress shall be zero
|
|
currentStartDelay["progress"] = 0;
|
|
return currentStartDelay;
|
|
}
|
|
break;
|
|
case PREPAIRING: {
|
|
if(!this->getSoundEnabledSetting(ScStwSoundPlayer::AtYourMarks))
|
|
return currentStartDelay;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return currentStartDelay;
|
|
break;
|
|
|
|
}
|
|
|
|
// get the total delay and the delay progress of the next action timer
|
|
double remaining = this->startDelayTimer->remainingTime();
|
|
|
|
if(remaining < 0)
|
|
return currentStartDelay;
|
|
|
|
currentStartDelay["total"] = this->startDelayTimer->interval();
|
|
currentStartDelay["progress"] = 1 - (remaining / currentStartDelay["total"].toDouble());
|
|
|
|
if(currentStartDelay["progress"].toDouble() < 0)
|
|
currentStartDelay["progress"] = 0;
|
|
|
|
|
|
return currentStartDelay;
|
|
}
|
|
|
|
bool ScStwRace::addTimer(ScStwTimer *timer) {
|
|
if(this->state != IDLE)
|
|
return false;
|
|
|
|
foreach(ScStwTimer *existingTimer, this->timers) {
|
|
if(existingTimer == timer)
|
|
return true;
|
|
}
|
|
|
|
this->timers.append(timer);
|
|
|
|
connect(timer, &ScStwTimer::stateChanged, this, &ScStwRace::refreshTimerStates);
|
|
connect(timer, &ScStwTimer::stateChanged, this, &ScStwRace::timersChanged);
|
|
connect(timer, &ScStwTimer::wantsToBeDisabledChanged, this, &ScStwRace::handleTimerWantsToBeDisabledChange);
|
|
connect(timer, &ScStwTimer::reactionTimeChanged, this, &ScStwRace::timersChanged);
|
|
connect(timer, &ScStwTimer::readyStateChanged, this->startWaitLoop, &QEventLoop::quit);
|
|
connect(timer, &ScStwTimer::readyStateChanged, this, &ScStwRace::handleTimerReadyStateChange);
|
|
|
|
connect(timer, &ScStwTimer::readyStateChanged, this, &ScStwRace::isReadyForNextStateChanged);
|
|
|
|
if(this->competitionMode && timer->getState() == ScStwTimer::DISABLED)
|
|
timer->setDisabled(false);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
ScStwRace::RaceState ScStwRace::getState() {
|
|
return this->state;
|
|
}
|
|
|
|
QList<ScStwTimer*> ScStwRace::getTimers() {
|
|
return this->timers;
|
|
}
|
|
|
|
double ScStwRace::getSoundVolume() {
|
|
return this->settings->readSetting(ScStwSettings::SoundVolumeSetting).toDouble();
|
|
}
|
|
|
|
ScStwSoundPlayer::StartSound ScStwRace::getSoundForState(ScStwRace::RaceState state) {
|
|
switch (state) {
|
|
case PREPAIRING:
|
|
return ScStwSoundPlayer::AtYourMarks;
|
|
break;
|
|
case WAITING:
|
|
return ScStwSoundPlayer::Ready;
|
|
break;
|
|
case STARTING:
|
|
return ScStwSoundPlayer::Start;
|
|
break;
|
|
default:
|
|
return ScStwSoundPlayer::StartSound(-1);
|
|
}
|
|
}
|
|
|
|
bool ScStwRace::getSoundEnabledSetting(ScStwSoundPlayer::StartSound sound) {
|
|
ScStwSettings::BaseStationSetting soundEnabledSetting;
|
|
switch (sound) {
|
|
case ScStwSoundPlayer::AtYourMarks:
|
|
soundEnabledSetting = ScStwSettings::AtYourMarksSoundEnableSetting;
|
|
break;
|
|
case ScStwSoundPlayer::Ready:
|
|
soundEnabledSetting = ScStwSettings::ReadySoundEnableSetting;
|
|
break;
|
|
case ScStwSoundPlayer::Start:
|
|
return true;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return this->settings->readSetting(soundEnabledSetting).toBool();
|
|
}
|
|
|
|
int ScStwRace::getSoundDelaySetting(ScStwSoundPlayer::StartSound sound) {
|
|
ScStwSettings::BaseStationSetting soundDelaySetting;
|
|
switch (sound) {
|
|
case ScStwSoundPlayer::AtYourMarks:
|
|
soundDelaySetting = ScStwSettings::AtYourMarksSoundDelaySetting;
|
|
break;
|
|
case ScStwSoundPlayer::Ready:
|
|
soundDelaySetting = ScStwSettings::ReadySoundDelaySetting;
|
|
break;
|
|
case ScStwSoundPlayer::Start:
|
|
return 0;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
return this->settings->readSetting(soundDelaySetting).toInt();
|
|
}
|
|
|
|
QVariantList ScStwRace::getTimerDetailList() {
|
|
QVariantList tmpTimers;
|
|
|
|
foreach(ScStwTimer * timer, this->timers){
|
|
QVariantMap tmpTimer;
|
|
tmpTimer.insert("id", this->timers.indexOf(timer));
|
|
tmpTimer.insert("state", timer->getState());
|
|
tmpTimer.insert("currentTime", timer->getCurrentTime());
|
|
tmpTimer.insert("reactionTime", timer->getReactionTime());
|
|
tmpTimer.insert("letter", timer->getLetter());
|
|
tmpTimer.insert("readyState", timer->getReadyState());
|
|
tmpTimers.append(tmpTimer);
|
|
}
|
|
|
|
return tmpTimers;
|
|
}
|
|
|
|
QVariantMap ScStwRace::getDetails() {
|
|
QVariantMap tmpDetails;
|
|
|
|
tmpDetails.insert("state", this->getState());
|
|
tmpDetails.insert("competitionMode", this->competitionMode);
|
|
tmpDetails.insert("readySoundEnabled", this->getSoundEnabledSetting(ScStwSoundPlayer::Ready));
|
|
tmpDetails.insert("currentStartDelay", this->getCurrentStartDelay());
|
|
tmpDetails.insert("timers", this->getTimerDetailList());
|
|
|
|
if(this->state == WAITING)
|
|
tmpDetails.insert("isReadyForNextState", this->getIsReadyForNextState());
|
|
else
|
|
tmpDetails.insert("isReadyForNextState", true);
|
|
|
|
return tmpDetails;
|
|
}
|
|
|
|
bool ScStwRace::isStarting() {
|
|
return this->state == PREPAIRING || this->state == WAITING || this->state == STARTING;
|
|
}
|
|
|
|
void ScStwRace::handleTimerReadyStateChange(ScStwTimer::ReadyState readyState) {
|
|
Q_UNUSED(readyState)
|
|
|
|
// only continue if the current state is waiting
|
|
if(this->state == WAITING)
|
|
emit this->timersChanged();
|
|
}
|
|
|
|
bool ScStwRace::getCompetitionMode() {
|
|
return this->competitionMode;
|
|
}
|
|
|
|
bool ScStwRace::getReadySoundEnabled() {
|
|
return this->getSoundEnabledSetting(ScStwSoundPlayer::Ready);
|
|
}
|