dave/openttd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into jgrpp

Browse Source 
# Conflicts:
#	src/animated_tile.cpp
#	src/cargopacket.h
#	src/cheat_gui.cpp
#	src/company_cmd.cpp
#	src/company_gui.cpp
#	src/date.cpp
#	src/disaster_vehicle.cpp
#	src/dock_gui.cpp
#	src/economy.cpp
#	src/engine.cpp
#	src/error_gui.cpp
#	src/fontcache/spritefontcache.cpp
#	src/game/game_gui.cpp
#	src/game/game_text.cpp
#	src/gfx.cpp
#	src/graph_gui.cpp
#	src/highscore_gui.cpp
#	src/industry_cmd.cpp
#	src/lang/dutch.txt
#	src/lang/english_AU.txt
#	src/lang/english_US.txt
#	src/lang/finnish.txt
#	src/lang/french.txt
#	src/lang/italian.txt
#	src/lang/portuguese.txt
#	src/lang/russian.txt
#	src/lang/turkish.txt
#	src/lang/vietnamese.txt
#	src/main_gui.cpp
#	src/misc_gui.cpp
#	src/network/network_gui.cpp
#	src/network/network_server.cpp
#	src/newgrf.cpp
#	src/newgrf.h
#	src/newgrf_generic.cpp
#	src/news_gui.cpp
#	src/openttd.cpp
#	src/os/unix/unix.cpp
#	src/os/windows/font_win32.cpp
#	src/os/windows/win32.cpp
#	src/rail_gui.cpp
#	src/road_gui.cpp
#	src/saveload/afterload.cpp
#	src/saveload/misc_sl.cpp
#	src/saveload/oldloader_sl.cpp
#	src/saveload/saveload.cpp
#	src/saveload/saveload.h
#	src/script/script_gui.cpp
#	src/settings_table.cpp
#	src/signs_gui.cpp
#	src/smallmap_gui.cpp
#	src/smallmap_gui.h
#	src/spritecache.cpp
#	src/spritecache.h
#	src/spriteloader/grf.cpp
#	src/station_cmd.cpp
#	src/statusbar_gui.cpp
#	src/stdafx.h
#	src/strgen/strgen_base.cpp
#	src/subsidy.cpp
#	src/table/settings/difficulty_settings.ini
#	src/texteff.cpp
#	src/timetable_cmd.cpp
#	src/timetable_gui.cpp
#	src/toolbar_gui.cpp
#	src/town_cmd.cpp
#	src/town_gui.cpp
#	src/townname.cpp
#	src/vehicle.cpp
#	src/waypoint_cmd.cpp
#	src/widgets/dropdown.cpp
#	src/window.cpp
This commit is contained in:
Jonathan G Rennison
2023-05-26 19:36:48 +01:00
parent 7615c831aa 370a8d77a4
commit fd4d4d341d
170 changed files with 1526 additions and 1238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/timer/CMakeLists.txt Normal file
View File

@@ -0,0 +1,6 @@
add_files(
timer_game_tick.cpp
timer_game_tick.h
timer_manager.h
timer.h
)

186
src/timer/timer.h Normal file
View File

@@ -0,0 +1,186 @@
/*
* This file is part of OpenTTD.
* OpenTTD 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, version 2.
* OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file timer.h Definition of Interval and OneShot timers */
#ifndef TIMER_H
#define TIMER_H
#include "timer_manager.h"
/**
* The base where every other type of timer is derived from.
*
* Never use this class directly yourself.
*/
template <typename TTimerType>
class BaseTimer {
public:
using TPeriod = typename TTimerType::TPeriod;
using TElapsed = typename TTimerType::TElapsed;
using TStorage = typename TTimerType::TStorage;
/**
* Create a new timer.
*
* @param period The period of the timer.
*/
NODISCARD BaseTimer(const TPeriod period) :
period(period)
{
TimerManager<TTimerType>::RegisterTimer(*this);
}
/**
* Delete the timer.
*/
virtual ~BaseTimer()
{
TimerManager<TTimerType>::UnregisterTimer(*this);
}
/* Although these variables are public, they are only public to make saveload easier; not for common use. */
TPeriod period; ///< The period of the timer.
TStorage storage = {}; ///< The storage of the timer.
protected:
/**
* Called by the timer manager to notify the timer that the given amount of time has elapsed.
*
* @param delta Depending on the time type, this is either in milliseconds or in ticks.
*/
virtual void Elapsed(TElapsed delta) = 0;
/* To ensure only TimerManager can access Elapsed. */
friend class TimerManager<TTimerType>;
};
/**
* An interval timer will fire every interval, and will continue to fire until it is deleted.
*
* The callback receives how many times the timer has fired since the last time it fired.
* It will always try to fire every interval, but in times of severe stress it might be late.
*
* Each Timer-type needs to implement the Elapsed() method, and call the callback if needed.
*
* Setting the period to zero disables the interval. It can be reenabled at any time by
* calling SetInterval() with a non-zero period.
*/
template <typename TTimerType>
class IntervalTimer : public BaseTimer<TTimerType> {
public:
using TPeriod = typename TTimerType::TPeriod;
using TElapsed = typename TTimerType::TElapsed;
/**
* Create a new interval timer.
*
* @param interval The interval between each callback.
* @param callback The callback to call when the interval has passed.
*/
NODISCARD IntervalTimer(const TPeriod interval, std::function<void(uint)> callback) :
BaseTimer<TTimerType>(interval),
callback(callback)
{
}
/**
* Set a new interval for the timer.
*
* @param interval The interval between each callback.
* @param reset Whether to reset the timer to zero.
*/
void SetInterval(const TPeriod interval, bool reset = true)
{
this->period = interval;
if (reset) this->storage = {};
}
private:
std::function<void(uint)> callback;
void Elapsed(TElapsed count) override;
};
/**
* A timeout timer will fire once after the interval. You can reset it to fire again.
* The timer will never fire before the interval has passed, but in times of severe stress it might be late.
*/
template <typename TTimerType>
class TimeoutTimer : public BaseTimer<TTimerType> {
public:
using TPeriod = typename TTimerType::TPeriod;
using TElapsed = typename TTimerType::TElapsed;
/**
* Create a new timeout timer.
*
* By default the timeout starts aborted; you will have to call Reset() before it starts.
*
* @param timeout The timeout after which the timer will fire.
* @param callback The callback to call when the timeout has passed.
* @param start Whether to start the timer immediately. If false, you can call Reset() to start it.
*/
NODISCARD TimeoutTimer(const TPeriod timeout, std::function<void()> callback, bool start = false) :
BaseTimer<TTimerType>(timeout),
fired(!start),
callback(callback)
{
}
/**
* Reset the timer, so it will fire again after the timeout.
*/
void Reset()
{
this->fired = false;
this->storage = {};
}
/**
* Reset the timer, so it will fire again after the timeout.
*
* @param timeout Set a new timeout for the next trigger.
*/
void Reset(const TPeriod timeout)
{
this->period = timeout;
this->fired = false;
this->storage = {};
}
/**
* Abort the timer so it doesn't fire if it hasn't yet.
*/
void Abort()
{
this->fired = true;
}
/**
* Check whether the timeout occurred.
*
* @return True iff the timeout occurred.
*/
bool HasFired() const
{
return this->fired;
}
/* Although these variables are public, they are only public to make saveload easier; not for common use. */
bool fired; ///< Whether the timeout has occurred.
private:
std::function<void()> callback;
void Elapsed(TElapsed count) override;
};
#endif /* TIMER_H */

64
src/timer/timer_game_tick.cpp Normal file
View File

@@ -0,0 +1,64 @@
/*
* This file is part of OpenTTD.
* OpenTTD 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, version 2.
* OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file timer_game_tick.cpp
* This file implements the timer logic for the tick-based game-timer.
*/
#include "stdafx.h"
#include "timer.h"
#include "timer_game_tick.h"
#include "safeguards.h"
template<>
void IntervalTimer<TimerGameTick>::Elapsed(TimerGameTick::TElapsed delta)
{
if (this->period == 0) return;
this->storage.elapsed += delta;
uint count = 0;
while (this->storage.elapsed >= this->period) {
this->storage.elapsed -= this->period;
count++;
}
if (count > 0) {
this->callback(count);
}
}
template<>
void TimeoutTimer<TimerGameTick>::Elapsed(TimerGameTick::TElapsed delta)
{
if (this->fired) return;
if (this->period == 0) return;
this->storage.elapsed += delta;
if (this->storage.elapsed >= this->period) {
this->callback();
this->fired = true;
}
}
template<>
void TimerManager<TimerGameTick>::Elapsed(TimerGameTick::TElapsed delta)
{
for (auto timer : TimerManager<TimerGameTick>::GetTimers()) {
timer->Elapsed(delta);
}
}
#ifdef WITH_ASSERT
template<>
void TimerManager<TimerGameTick>::Validate(TimerGameTick::TPeriod period)
{
}
#endif /* WITH_ASSERT */

34
src/timer/timer_game_tick.h Normal file
View File

@@ -0,0 +1,34 @@
/*
* This file is part of OpenTTD.
* OpenTTD 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, version 2.
* OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file timer_game_tick.h Definition of the tick-based game-timer */
#ifndef TIMER_GAME_TICK_H
#define TIMER_GAME_TICK_H
#include "gfx_type.h"
#include <chrono>
/** Estimation of how many ticks fit in a single second. */
static const uint TICKS_PER_SECOND = 1000 / 27 /*MILLISECONDS_PER_TICK*/;
/**
* Timer that represents the game-ticks. It will pause when the game is paused.
*
* @note Callbacks are executed in the game-thread.
*/
class TimerGameTick {
public:
using TPeriod = uint;
using TElapsed = uint;
struct TStorage {
uint elapsed;
};
};
#endif /* TIMER_GAME_TICK_H */

104
src/timer/timer_manager.h Normal file
View File

@@ -0,0 +1,104 @@
/*
* This file is part of OpenTTD.
* OpenTTD 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, version 2.
* OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file timer_manager.h Definition of the TimerManager */
/** @note don't include this file; include "timer.h". */
#ifndef TIMER_MANAGER_H
#define TIMER_MANAGER_H
#include "stdafx.h"
#include <set>
template <typename TTimerType>
class BaseTimer;
/**
* The TimerManager manages a single Timer-type.
*
* It allows for automatic registration and unregistration of timers like Interval and OneShot.
*
* Each Timer-type needs to implement the Elapsed() method, and distribute that to the timers if needed.
*/
template <typename TTimerType>
class TimerManager {
public:
using TPeriod = typename TTimerType::TPeriod;
using TElapsed = typename TTimerType::TElapsed;
/* Avoid copying this object; it is a singleton object. */
TimerManager(TimerManager const &) = delete;
TimerManager &operator=(TimerManager const &) = delete;
/**
* Register a timer.
*
* @param timer The timer to register.
*/
static void RegisterTimer(BaseTimer<TTimerType> &timer) {
#ifdef WITH_ASSERT
Validate(timer.period);
#endif /* WITH_ASSERT */
GetTimers().insert(&timer);
}
/**
* Unregister a timer.
*
* @param timer The timer to unregister.
*/
static void UnregisterTimer(BaseTimer<TTimerType> &timer) {
GetTimers().erase(&timer);
}
#ifdef WITH_ASSERT
/**
* Validate that a new period is actually valid.
*
* For most timers this is not an issue, but some want to make sure their
* period is unique, to ensure deterministic game-play.
*
* This is meant purely to protect a developer from making a mistake.
* As such, assert() when validation fails.
*
* @param period The period to validate.
*/
static void Validate(TPeriod period);
#endif /* WITH_ASSERT */
/**
* Called when time for this timer elapsed.
*
* The implementation per type is different, but they all share a similar goal:
* Call the Elapsed() method of all active timers.
*
* @param value The amount of time that has elapsed.
*/
static void Elapsed(TElapsed value);
private:
/**
* Sorter for timers.
*
* It will sort based on the period, smaller first. If the period is the
* same, it will sort based on the pointer value.
*/
struct base_timer_sorter {
bool operator() (BaseTimer<TTimerType> *a, BaseTimer<TTimerType> *b) const {
if (a->period == b->period) return a < b;
return a->period < b->period;
}
};
/** Singleton list, to store all the active timers. */
static std::set<BaseTimer<TTimerType> *, base_timer_sorter> &GetTimers() {
static std::set<BaseTimer<TTimerType> *, base_timer_sorter> timers;
return timers;
}
};
#endif /* TIMER_MANAGER_H */