project-kyoku/src/classicgame/classictimeline.cpp

#include "note.h"
#include "classictimeline.h"
#include <iostream>

ClassicTimeline::ClassicTimeline() :
    _sfml_music_offset(0),
    _previous_frame_offset(0),
    _absolute_offset(0)
{
    // BPM of METEOR is 170.
    // Length is 1:14
    // I calculated that the time between beats is about 1412162 microseconds

    std::string song_filename = "METEOR.flac";

    _music.openFromFile(song_filename);
    _music.setVolume(10);
}

void ClassicTimeline::run(std::vector<Note*>&& notes, const microsec& visibility)
{
    _visibility_offset = visibility;
    _timeline = std::move(notes);

    _top_note = _timeline.begin();
    expire(_first_visible_note);
    expire(_last_visible_note);
    expire(_active_note);

    fetchVisibleNotes();
    _music.play();

    _previous_frame_offset = _offset_interpolator.restart().asMicroseconds();
}

ClassicTimeline::~ClassicTimeline()
{
    clear();
}

void ClassicTimeline::clear()
{
    for (auto& note : _timeline)
        delete note;

    _timeline.clear();
}

void ClassicTimeline::update()
{
    const auto interpolator_timestamp = _offset_interpolator.getElapsedTime().asMicroseconds();
    const auto sfml_new_offset = currentMusicOffset();

    _absolute_offset += (interpolator_timestamp - _previous_frame_offset);
    _previous_frame_offset = interpolator_timestamp;
    if (sfml_new_offset != _sfml_music_offset)
    {
        _absolute_offset = ((_absolute_offset + sfml_new_offset) / 2);
        _sfml_music_offset = sfml_new_offset;
    }

    checkCurrentActiveNote();
    checkForNextActiveNote();
    updateVisibleSprites(_absolute_offset);
}

void ClassicTimeline::checkCurrentActiveNote()
{
    if (isExpired(_active_note))
        return;

    auto note = *_active_note;

    if (!note->isActive())
    {
        expire(_active_note);
        ++_top_note;
    }
}

void ClassicTimeline::checkForNextActiveNote()
{
    if (!isExpired(_active_note))
        return;

    auto top_note = *_top_note;
    if (top_note->isActive())
        _active_note = _top_note;
}

void ClassicTimeline::updateVisibleSprites(const microsec& music_offset)
{
    if (nothingToDraw())
        return;

    std::for_each(_first_visible_note, _last_visible_note,
                  [&music_offset](const auto& note)
                  {
                      note->update(music_offset);
                  });
}

ClassicTimeline::Iterator ClassicTimeline::getActiveNote() noexcept
{
    return _active_note;
}

bool ClassicTimeline::isExpired(const Iterator& iterator) const
{
    return iterator == _timeline.end();
}

void ClassicTimeline::expire(Iterator& iterator)
{
    iterator = _timeline.end();
}

microsec ClassicTimeline::currentMusicOffset() const
{
    return _music.getPlayingOffset().asMicroseconds();
}

bool ClassicTimeline::isVisiblyClose(const Iterator& iterator, const microsec& music_offset) const
{
    return ((*iterator)->offset() - _visibility_offset) <= music_offset;
}

void ClassicTimeline::fetchVisibleNotes()
{
    findLastVisibleNote(_absolute_offset);
    findFirstVisibleNote();
}

void ClassicTimeline::findLastVisibleNote(const microsec &music_offset)
{
    Iterator note_iterator = _top_note;
    while (isVisiblyClose(note_iterator, music_offset))
    {
        if (nothingToDraw())
            _first_visible_note = note_iterator;

        auto note = *note_iterator;

        if (!note->isInGame())
            note->putToGame(music_offset);

        ++note_iterator;
    }

    _last_visible_note = note_iterator;
}

void ClassicTimeline::findFirstVisibleNote()
{
    if (nothingToDraw())
        return;

    auto note_iterator = _first_visible_note;
    while (note_iterator != _last_visible_note)
    {
        auto note = *note_iterator;
        if (note->shouldRemove())
            ++_first_visible_note;

        ++note_iterator;
    }
}

bool ClassicTimeline::nothingToDraw() const noexcept
{
    return isExpired(_first_visible_note);
}

void ClassicTimeline::drawVisibleNotes() const
{
    if (nothingToDraw())
        return;

    std::for_each(_first_visible_note, _last_visible_note,
                  [](const auto& note)
                  {
                      note->draw();
                  });
}