Autofire.cc

Go to the documentation of this file.

#include "Autofire.hh"
#include "MSXMotherBoard.hh"
#include "Scheduler.hh"
#include "StateChange.hh"
#include "StateChangeDistributor.hh"
#include <algorithm>
#include <cassert>
 
namespace openmsx {
 
static std::string_view nameForId(Autofire::ID id)
{
        switch (id) {
                case Autofire::RENSHATURBO: return "renshaturbo";
                default: return "unknown-autofire";
        }
}
 
class AutofireStateChange final : public StateChange
{
public:
        AutofireStateChange() = default; // for serialize
        AutofireStateChange(EmuTime::param time_, Autofire::ID id_, int value_)
                : StateChange(time_)
                , id(id_), value(value_) {}
        [[nodiscard]] auto getId() const { return id; }
        [[nodiscard]] int getValue() const { return value; }
        template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)
        {
                ar.template serializeBase<StateChange>(*this);
                // for backwards compatibility serialize 'id' as 'name'
                std::string name = Archive::IS_LOADER ? "" : std::string(nameForId(id));
                ar.serialize("name",    name,
                             "value",   value);
                if constexpr (Archive::IS_LOADER) {
                        id = (name == nameForId(Autofire::RENSHATURBO))
                           ? Autofire::RENSHATURBO
                           : Autofire::UNKNOWN;
                }
        }
 
private:
        Autofire::ID id;
        int value;
};
REGISTER_POLYMORPHIC_CLASS(StateChange, AutofireStateChange, "AutofireStateChange");
 
 
Autofire::Autofire(MSXMotherBoard& motherBoard,
                   unsigned newMinInts, unsigned newMaxInts, ID id_)
        : scheduler(motherBoard.getScheduler())
        , stateChangeDistributor(motherBoard.getStateChangeDistributor())
        , min_ints(std::max(newMinInts, 1u))
        , max_ints(std::max(newMaxInts, min_ints + 1))
        , speedSetting(motherBoard.getCommandController(), nameForId(id_),
                "controls the speed of this autofire circuit", 0, 0, 100)
        , clock(scheduler.getCurrentTime())
        , id(id_)
{
        setClock(speedSetting.getInt());
 
        stateChangeDistributor.registerListener(*this);
        speedSetting.attach(*this);
}
 
Autofire::~Autofire()
{
        speedSetting.detach(*this);
        stateChangeDistributor.unregisterListener(*this);
}
 
void Autofire::setSpeed(EmuTime::param time)
{
        stateChangeDistributor.distributeNew<AutofireStateChange>(
                time, id, speedSetting.getInt());
}
 
void Autofire::setClock(int speed)
{
        if (speed) {
                clock.setFreq(
                    (2 * 50 * 60) / (max_ints - (speed * (max_ints - min_ints)) / 100));
        } else {
                clock.setPeriod(EmuDuration::zero()); // special value: disabled
        }
}
 
void Autofire::update(const Setting& setting) noexcept
{
        (void)setting;
        assert(&setting == &speedSetting);
        setSpeed(scheduler.getCurrentTime());
}
 
void Autofire::signalStateChange(const StateChange& event)
{
        const auto* as = dynamic_cast<const AutofireStateChange*>(&event);
        if (!as) return;
        if (as->getId() != id) return;
 
        setClock(as->getValue());
}
 
void Autofire::stopReplay(EmuTime::param time) noexcept
{
        setSpeed(time); // re-sync with current value of the setting
}
 
bool Autofire::getSignal(EmuTime::param time)
{
        return (clock.getPeriod() == EmuDuration::zero())
                ? false // special value: disabled
                : (clock.getTicksTill(time) & 1);
}
 
template<typename Archive>
void Autofire::serialize(Archive& ar, unsigned /*version*/)
{
        ar.serialize("clock", clock);
}
INSTANTIATE_SERIALIZE_METHODS(Autofire)
 
} // namespace openmsx