This repository has been archived on 2024-06-03. You can view files and clone it, but cannot push or open issues or pull requests.
shared-libraries/ScStwLibraries/sources/scstwrace.cpp

913 lines
28 KiB
C++
Raw Normal View History

/****************************************************************************
2020-06-07 14:43:47 +02:00
** 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"
2020-10-09 15:18:56 +02:00
ScStwRace::ScStwRace(QObject* parent) : ScStwRace(nullptr, parent)
{
}
ScStwRace::ScStwRace(ScStwSettings *settings, QObject *parent) : QObject(parent)
{
this->state = IDLE;
2020-10-03 17:45:54 +02:00
this->competitionMode = false;
2020-10-09 15:18:56 +02:00
this->autoRefreshTimerText = 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);
2020-10-02 19:53:07 +02:00
connect(this, &ScStwRace::currentStartDelayChanged, this, &ScStwRace::detailsChanged);
connect(this, &ScStwRace::timersChanged, this, &ScStwRace::detailsChanged);
2020-10-03 11:10:15 +02:00
connect(this, &ScStwRace::stateChanged, this, &ScStwRace::detailsChanged);
2020-10-02 19:53:07 +02:00
// init settings
2020-10-09 15:18:56 +02:00
this->setSettings(settings);
}
// --------------------------
// --- Main Functionality ---
// --------------------------
2020-10-02 15:23:30 +02:00
ScStw::StatusCode ScStwRace::start(bool asyncronous) {
if(this->state == WAITING) {
2020-10-03 11:10:15 +02:00
if(this->getIsReadyForNextState()) {
this->startWaitLoop->exit(LoopManualExit);
return ScStw::Success;
}
else {
return ScStw::TimersNotReadyError;
}
}
else if(this->state != IDLE) {
return ScStw::CurrentStateNotVaildForOperationError;
}
2020-10-03 17:45:54 +02:00
this->refreshCompetitionMode();
2020-10-03 11:10:15 +02:00
if(!this->getIsReadyForNextState())
return ScStw::TimersNotReadyError;
this->setState(PREPAIRING);
2020-04-19 13:09:24 +02:00
if(asyncronous) {
QTimer::singleShot(1, [=](){this->playSoundsAndStartTimers();});
2020-04-19 13:09:24 +02:00
}
else
this->playSoundsAndStartTimers();
2020-04-19 22:39:33 +02:00
return ScStw::Success;
}
2020-10-02 15:23:30 +02:00
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();
2020-10-02 15:23:30 +02:00
ScStw::StatusCode returnCode = ScStw::Success;
foreach(ScStwTimer *speedTimer, this->timers){
if(!speedTimer->stop(timeOfStop) && speedTimer->getState() != ScStwTimer::DISABLED){
2020-04-19 22:39:33 +02:00
returnCode = ScStw::InternalErrorTimerOperationFailed;
}
}
2020-04-19 22:39:33 +02:00
if(returnCode == ScStw::Success) {
this->setState(STOPPED);
}
return returnCode;
}
2020-10-02 15:23:30 +02:00
ScStw::StatusCode ScStwRace::reset() {
if(this->state != STOPPED && this->state != INCIDENT) {
return ScStw::CurrentStateNotVaildForOperationError;
}
qDebug() << "[INFO][RACE] resetting race";
if(this->competitionMode) {
for(int i = 0; i < this->timers.length(); i++)
this->setTimerDisabled(i, false);
}
2020-10-02 15:23:30 +02:00
ScStw::StatusCode returnCode = ScStw::Success;
2020-10-06 13:58:42 +02:00
foreach(ScStwTimer *timer, this->timers){
if(!timer->reset() && timer->getState() != ScStwTimer::DISABLED && timer->getState() != ScStwTimer::IDLE) {
2020-04-19 22:39:33 +02:00
returnCode = ScStw::InternalErrorTimerOperationFailed;
}
}
if(returnCode == ScStw::Success)
this->setState(IDLE);
2020-10-02 17:05:52 +02:00
this->soundPlayer->cancel();
return returnCode;
}
2020-10-02 15:23:30 +02:00
ScStw::StatusCode ScStwRace::cancel() {
if(this->state != PREPAIRING && this->state != WAITING && this->state != STARTING && this->state != RUNNING)
return ScStw::CurrentStateNotVaildForOperationError;
2020-04-19 22:39:33 +02:00
qDebug() << "[INFO][RACE] cancelling race";
2020-10-02 15:23:30 +02:00
ScStw::StatusCode returnCode = ScStw::Success;
2020-04-19 22:39:33 +02:00
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);
2020-10-03 11:10:15 +02:00
this->soundPlayer->cancel();
this->startDelayTimer->stop();
2020-10-02 17:05:52 +02:00
emit this->currentStartDelayChanged();
2020-04-19 22:39:33 +02:00
return returnCode;
}
ScStw::StatusCode ScStwRace::setTimerDisabled(int timerId, bool disabled) {
2020-10-06 13:58:42 +02:00
if(timerId < 0 || timerId - 1 > this->timers.length())
return ScStw::ItemNotFoundError;
return this->setTimerDisabled(this->timers[timerId], disabled);
}
ScStw::StatusCode ScStwRace::setTimerDisabled(ScStwTimer* timer, bool disabled) {
qDebug() << "[INFO][RACE] Setting timer "<< timer->getLetter() << " to disabled: " << disabled << " this state: " << this->state;
if(this->state != IDLE && this->state != WAITING)
return ScStw::CurrentStateNotVaildForOperationError;
2020-10-06 13:58:42 +02:00
if(!this->timers.contains(timer))
return ScStw::ItemNotFoundError;
2020-10-06 13:58:42 +02:00
int enabledTimerCount = 0;
foreach(ScStwTimer *timer, this->timers) {
if(timer->getState() != ScStwTimer::DISABLED)
enabledTimerCount ++;
}
if(disabled && enabledTimerCount <= 1)
return ScStw::LastTimerCannotBeDisabledError;
qDebug() << "[INFO][RACE] Setting timer "<< timer->getLetter() << " to disabled: " << disabled;
timer->setDisabled(disabled);
emit this->timersChanged();
return ScStw::Success;
2020-10-06 13:58:42 +02:00
}
2020-10-04 01:47:50 +02:00
void ScStwRace::handleTimerReadyStateChange(ScStwTimer::ReadyState readyState) {
if(!this->competitionMode || this->state == IDLE || this->state == STOPPED || this->state == INCIDENT )
return;
qDebug() << "Some ready state changed: " << readyState;
2020-10-04 01:47:50 +02:00
// cancel as a technical incident if extensions are disconnected or run low on battery
if(readyState == ScStwTimer::ExtensionIsNotConnected || readyState == ScStwTimer::ExtensionBatteryIsCritical) {
2020-10-04 01:47:50 +02:00
this->technicalIncident();
return;
}
// only continue if the current state is waiting
if(this->state == WAITING) {
this->startWaitLoop->exit(ScStwRace::LoopReadyStateChangeExit);
emit this->timersChanged();
}
}
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
2020-10-03 17:45:54 +02:00
if(this->competitionMode && this->getSoundEnabledSetting(ScStwSoundPlayer::Ready)) {
qDebug() << "[RACE][INFO] Now waiting for climbers";
// get delay
int minimumReadyDelay = 1000;
2020-10-03 17:45:54 +02:00
if(this->getSoundDelaySetting(ScStwSoundPlayer::Ready) > 1000)
minimumReadyDelay = this->getSoundDelaySetting(ScStwSoundPlayer::Ready);
this->startDelayTimer->setInterval(minimumReadyDelay);
2020-10-02 17:05:52 +02:00
// 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 {
2020-10-03 11:10:15 +02:00
if(!this->getIsReadyForNextState()) {
this->startDelayTimer->stop();
timerTriggered = false;
}
else if(this->startDelayTimer->isActive()) {
timerTriggered = true;
}
else {
this->startDelayTimer->stop();
2020-12-28 16:17:38 +01:00
this->startDelayTimer->setInterval(minimumReadyDelay);
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;
}
2020-10-02 17:05:52 +02:00
//qDebug() << "At end of loop: remaining time: " << this->startDelayTimer->remainingTime() << " timer triggered: " << timerTriggered << " ready for next state: " << this->isReadyForNextState();
2020-10-03 11:10:15 +02:00
} 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;
2020-10-02 17:05:52 +02:00
}
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;
2020-10-03 11:10:15 +02:00
} 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;
2020-10-02 17:05:52 +02:00
}
}
// 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();
2020-10-02 17:05:52 +02:00
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) {
2020-10-03 17:45:54 +02:00
ScStwSoundPlayer::StartSound sound = this->getSoundForState(this->state);
2020-10-03 17:45:54 +02:00
if(this->getSoundEnabledSetting(sound)) {
if(sound != ScStwSoundPlayer::Start && this->getSoundDelaySetting(sound) > 0) {
// perform the delay before the start
// get delay
2020-10-03 17:45:54 +02:00
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) {
2020-04-19 13:09:24 +02:00
qDebug() << "[INFO][RACE] state changed: " << newState;
this->state = newState;
emit this->stateChanged(newState);
if(this->state == IDLE) {
2020-10-03 17:45:54 +02:00
this->refreshCompetitionMode();
}
}
}
void ScStwRace::handleTimerStateChange(ScStwTimer::TimerState newState) {
if(
newState == ScStwTimer::WON ||
newState == ScStwTimer::LOST ||
newState == ScStwTimer::WILDCARD ||
newState == ScStwTimer::FAILED ||
this->state == INCIDENT
)
return;
qDebug() << "[INFO][MAIN] handling timer state change";
// check if the race is over
bool raceIsOver = true;
int incidentCount = 0;
foreach(ScStwTimer * timer, this->timers){
2020-10-04 16:04:22 +02:00
if(timer->getState() < ScStwTimer::WAITING){
// if the timer is not in stoped state
raceIsOver = false;
}
else if(timer->getState() == ScStwTimer::WAITING)
this->handleTimerStop();
2020-10-04 16:04:22 +02:00
else if (timer->getState() == ScStwTimer::FAILING)
2020-04-19 22:39:33 +02:00
this->handleFalseStart();
else if (timer->getState() == ScStwTimer::INCIDENT)
incidentCount ++;
}
if(incidentCount == this->timers.length()) {
this->setState(INCIDENT);
this->soundPlayer->play(ScStwSoundPlayer::FalseStart, this->getSoundVolume());
}
else if(raceIsOver)
this->setState(STOPPED);
}
2020-10-04 16:04:22 +02:00
void ScStwRace::handleTimerStop() {
if(this->state != RUNNING)
return;
2020-10-04 17:25:30 +02:00
qDebug() << "[INFO][RACE] Got a TIMER STOP";
2020-10-04 16:04:22 +02:00
// find out which timer has won
double lowestStoppedTime = -1;
// iterate through all timers and find the lowest time that was stopped
foreach(ScStwTimer * timer, this->timers) {
2020-10-06 13:58:42 +02:00
qDebug() << "Current stopped time is: " << timer->getCurrentTime();
if(!timer->isRunning() && !timer->isDisabled() && (timer->getCurrentTime() <= lowestStoppedTime || lowestStoppedTime < 0)) {
2020-10-04 16:04:22 +02:00
// this is the timer with the lowest stopped time
lowestStoppedTime = timer->getCurrentTime();
}
}
2020-10-06 13:58:42 +02:00
qDebug() << "LOWEST Stop time is: " << lowestStoppedTime;
2020-10-04 16:04:22 +02:00
// append the timer(s) with the lowest stopped time to the winner list
foreach(ScStwTimer * timer, this->timers) {
if(timer->getCurrentTime() <= lowestStoppedTime)
2020-10-04 16:04:22 +02:00
// this is the timer with the lowest stopped time
timer->setResult(ScStwTimer::WON);
else
2020-10-04 16:04:22 +02:00
timer->setResult(ScStwTimer::LOST);
}
}
void ScStwRace::handleFalseStart() {
if(this->state != STARTING && this->state != RUNNING && this->state != STOPPED)
return;
qDebug() << "[INFO][RACE] Got a FALSE START";
// set lowest to a value that is impossible to reach (start tone is only 3100ms long)
double lowestReactionTime = -4000;
2020-10-04 16:04:22 +02:00
// iterate through all timers and find the lowest reactiontime that was stopped
foreach(ScStwTimer *timer, this->timers) {
if(
timer->getState() >= ScStwTimer::FAILING &&
timer->getState() <= ScStwTimer::FAILED &&
2020-10-06 13:58:42 +02:00
!timer->isDisabled() &&
2020-10-04 16:04:22 +02:00
(
timer->getReactionTime() < lowestReactionTime ||
lowestReactionTime == -4000
)
) {
lowestReactionTime = timer->getReactionTime();
}
}
if(lowestReactionTime == -4000)
// no timer has failed
return;
qDebug() << "LOWEST reaction time is: " << lowestReactionTime;
2020-10-04 16:04:22 +02:00
// find out which timer(s) have lost and which get a wildcard
foreach(ScStwTimer * timer, this->timers) {
qDebug() << "THIS TIMERS reaction time is: " << timer->getReactionTime();
2020-10-04 16:04:22 +02:00
if(
timer->getState() >= ScStwTimer::FAILING &&
timer->getState() <= ScStwTimer::FAILED &&
2020-10-06 13:58:42 +02:00
!timer->isDisabled() &&
timer->getReactionTime() <= lowestReactionTime
2020-10-04 16:04:22 +02:00
) {
// this is the timer with the lowest stopped time
timer->setResult(ScStwTimer::FAILED);
qDebug() << "FOUND BAD TIMER";
2020-10-04 16:04:22 +02:00
}
else {
timer->setResult(ScStwTimer::WILDCARD);
}
}
if(this->state != STOPPED) {
this->setState(STOPPED);
this->soundPlayer->cancel();
this->soundPlayer->play(ScStwSoundPlayer::FalseStart, this->getSoundVolume());
}
}
void ScStwRace::technicalIncident() {
bool raceIsRunning = this->state == RUNNING;
qDebug() << "[ERROR][RACE] Got a technical incident, state is: " << this->state;
if(!raceIsRunning) {
this->startWaitLoop->exit(LoopCancelExit);
if(this->state == STARTING) {
this->soundPlayer->cancel();
this->soundPlayer->play(ScStwSoundPlayer::FalseStart, this->getSoundVolume());
}
this->setState(INCIDENT);
}
foreach(ScStwTimer *timer, this->timers){
if(raceIsRunning && timer->getReadyState() == ScStwTimer::ExtensionBatteryIsCritical)
continue;
else if(timer->getReadyState() == ScStwTimer::ExtensionIsNotConnected || timer->getReadyState() == ScStwTimer::ExtensionBatteryIsCritical)
timer->technicalIncident();
else if(!raceIsRunning)
timer->setState(ScStwTimer::CANCELLED);
}
2020-10-04 16:04:22 +02:00
}
// ------------------------
// --- helper functions ---
// ------------------------
2020-10-03 11:10:15 +02:00
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::ExtensionBatteryIsCritical) {
this->technicalIncident();
qDebug() << "[ERROR][RACE] Could not start due to not-ready timers";
return false;
}
}
break;
case WAITING: {
foreach (ScStwTimer *timer, this->timers) {
2020-10-06 13:58:42 +02:00
if(timer->getReadyState() != ScStwTimer::IsReady && timer->getReadyState() != ScStwTimer::IsDisabled)
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) {
2020-10-06 13:58:42 +02:00
qDebug() << "Handling timer wants to be disabled";
if(this->competitionMode)
return;
if(this->state == IDLE) {
2020-10-06 13:58:42 +02:00
qDebug() << "Handling timer wants to be disabled: " << wantsToBeDisabled;
this->setTimerDisabled(timer, wantsToBeDisabled);
}
}
2020-10-03 17:45:54 +02:00
void ScStwRace::refreshCompetitionMode() {
if(this->state != IDLE)
return;
2020-10-09 15:18:56 +02:00
bool currentCompetitionMode = false;
if(this->settings != nullptr)
currentCompetitionMode = this->settings->readSetting(ScStwSettings::CompetitionModeSetting).toBool();
2020-10-03 17:45:54 +02:00
if(this->competitionMode != currentCompetitionMode) {
qDebug() << "[INFO][RACE] Setting competition mode to " << currentCompetitionMode;
this->competitionMode = currentCompetitionMode;
2020-10-06 13:58:42 +02:00
}
2020-10-03 17:45:54 +02:00
2020-10-06 13:58:42 +02:00
if(this->competitionMode) {
foreach (ScStwTimer *timer, this->timers) {
timer->setDisabled(false);
2020-10-03 17:45:54 +02:00
}
2020-10-06 13:58:42 +02:00
}
else {
foreach(ScStwTimer* timer, this->timers) {
if(
(timer->getWantsToBeDisabled() && timer->getState() != ScStwTimer::DISABLED) ||
(!timer->getWantsToBeDisabled() && timer->getState() == ScStwTimer::DISABLED)
)
this->handleTimerWantsToBeDisabledChange(timer, timer->getWantsToBeDisabled());
2020-10-03 17:45:54 +02:00
}
}
}
QVariantMap ScStwRace::getCurrentStartDelay() {
QVariantMap currentStartDelay = {
{"total", -1.0},
{"progress", -1.0}
};
switch (this->state) {
case WAITING:
2020-10-03 17:45:54 +02:00
if(!this->getSoundEnabledSetting(ScStwSoundPlayer::Ready))
return currentStartDelay;
2020-10-03 12:45:44 +02:00
if(!this->getIsReadyForNextState()) {
// indicate that we are waiting for climbers and the progress shall be zero
2020-10-03 12:45:44 +02:00
currentStartDelay["progress"] = 0;
return currentStartDelay;
}
break;
case PREPAIRING: {
2020-10-03 17:45:54 +02:00
if(!this->getSoundEnabledSetting(ScStwSoundPlayer::AtYourMarks))
return currentStartDelay;
break;
2020-10-02 17:05:52 +02:00
}
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);
2020-10-04 16:04:22 +02:00
connect(timer, &ScStwTimer::stateChanged, this, &ScStwRace::handleTimerStateChange);
connect(timer, &ScStwTimer::stateChanged, this, &ScStwRace::timersChanged);
2020-10-02 19:53:07 +02:00
connect(timer, &ScStwTimer::wantsToBeDisabledChanged, this, &ScStwRace::handleTimerWantsToBeDisabledChange);
connect(timer, &ScStwTimer::reactionTimeChanged, this, &ScStwRace::timersChanged);
2020-10-02 19:53:07 +02:00
connect(timer, &ScStwTimer::readyStateChanged, this, &ScStwRace::handleTimerReadyStateChange);
2020-10-02 19:56:08 +02:00
connect(timer, &ScStwTimer::readyStateChanged, this, &ScStwRace::isReadyForNextStateChanged);
if(this->competitionMode && timer->getState() == ScStwTimer::DISABLED)
timer->setDisabled(false);
2020-10-06 13:58:42 +02:00
else if(!this->competitionMode)
this->handleTimerWantsToBeDisabledChange(timer, timer->getWantsToBeDisabled());
return true;
}
2020-10-03 17:45:54 +02:00
ScStwRace::RaceState ScStwRace::getState() {
return this->state;
}
2020-10-03 17:45:54 +02:00
QList<ScStwTimer*> ScStwRace::getTimers() {
return this->timers;
}
2020-10-03 17:45:54 +02:00
double ScStwRace::getSoundVolume() {
2020-10-09 15:18:56 +02:00
if(this->settings == nullptr)
return 1;
2020-10-03 17:45:54 +02:00
return this->settings->readSetting(ScStwSettings::SoundVolumeSetting).toDouble();
}
2020-10-03 17:45:54 +02:00
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);
}
2020-10-03 17:45:54 +02:00
}
2020-10-03 17:45:54 +02:00
bool ScStwRace::getSoundEnabledSetting(ScStwSoundPlayer::StartSound sound) {
ScStwSettings::BaseStationSetting soundEnabledSetting;
switch (sound) {
case ScStwSoundPlayer::AtYourMarks:
soundEnabledSetting = ScStwSettings::AtYourMarksSoundEnableSetting;
break;
2020-10-03 17:45:54 +02:00
case ScStwSoundPlayer::Ready:
soundEnabledSetting = ScStwSettings::ReadySoundEnableSetting;
break;
case ScStwSoundPlayer::Start:
return true;
break;
default:
return false;
}
2020-10-09 15:18:56 +02:00
if(this->settings == nullptr)
return false;
2020-10-03 17:45:54 +02:00
return this->settings->readSetting(soundEnabledSetting).toBool();
}
2020-10-03 17:45:54 +02:00
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;
}
2020-10-09 15:18:56 +02:00
if(this->settings == nullptr)
return -1;
2020-10-03 17:45:54 +02:00
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());
2020-06-13 12:38:24 +02:00
tmpTimer.insert("letter", timer->getLetter());
2020-10-02 19:53:07 +02:00
tmpTimer.insert("readyState", timer->getReadyState());
2020-10-03 18:32:39 +02:00
tmpTimer.insert("text", timer->getText());
tmpTimers.append(tmpTimer);
}
return tmpTimers;
}
2020-10-02 19:53:07 +02:00
QVariantMap ScStwRace::getDetails() {
QVariantMap tmpDetails;
2020-10-03 11:10:15 +02:00
tmpDetails.insert("state", this->getState());
2020-10-02 19:53:07 +02:00
tmpDetails.insert("competitionMode", this->competitionMode);
2020-10-03 17:45:54 +02:00
tmpDetails.insert("readySoundEnabled", this->getSoundEnabledSetting(ScStwSoundPlayer::Ready));
2020-10-03 11:10:15 +02:00
tmpDetails.insert("currentStartDelay", this->getCurrentStartDelay());
tmpDetails.insert("timers", this->getTimerDetailList());
2020-10-02 19:53:07 +02:00
if(this->state == WAITING)
2020-10-03 11:10:15 +02:00
tmpDetails.insert("isReadyForNextState", this->getIsReadyForNextState());
else
tmpDetails.insert("isReadyForNextState", true);
2020-10-02 19:53:07 +02:00
return tmpDetails;
}
bool ScStwRace::isStarting() {
return this->state == PREPAIRING || this->state == WAITING || this->state == STARTING;
}
bool ScStwRace::getCompetitionMode() {
return this->competitionMode;
}
bool ScStwRace::getReadySoundEnabled() {
2020-10-03 17:45:54 +02:00
return this->getSoundEnabledSetting(ScStwSoundPlayer::Ready);
}
2020-10-09 15:18:56 +02:00
ScStwSettings* ScStwRace::getSettings() {
return this->settings;
}
void ScStwRace::setSettings(ScStwSettings* settings) {
if(settings == this->settings)
return;
this->settings = settings;
this->refreshCompetitionMode();
emit this->settingsChanged();
}
bool ScStwRace::getAutoRefreshTimerText() {
return this->autoRefreshTimerText;
}
void ScStwRace::setAutoRefreshTimerText(bool autoRefresh) {
if(autoRefresh == this->autoRefreshTimerText)
return;
this->autoRefreshTimerText = autoRefresh;
if(this->autoRefreshTimerText) {
this->timerTextRefreshTimer = new QTimer(this);
this->timerTextRefreshTimer->setInterval(1);
this->timerTextRefreshTimer->connect(
this->timerTextRefreshTimer,
&QTimer::timeout,
[=]{
// refresh timer text
if(this->getState() == ScStwRace::RUNNING) {
emit this->timersChanged();
}
// refresh next start action delay progress
if(this->getState() == ScStwRace::WAITING || this->getState() == ScStwRace::PREPAIRING) {
emit this->currentStartDelayChanged();
}
}
);
this->timerTextRefreshTimer->start();
}
else if(this->timerTextRefreshTimer != nullptr) {
this->timerTextRefreshTimer->deleteLater();
}
emit this->autoRefreshTimerTextChanged();
}