project-kyoku/modes/classicmode/editor/classiceditor.cpp

#include "classiceditor.h"

ClassicEditor::ClassicEditor(std::shared_ptr<ClassicGraphicsManager>&& manager) :
    _graphics_manager(manager),
    _selected_type(Type::UP),
    _current_time(0),
    _scroll_step(500000)
{
    _context.graphics_manager = _graphics_manager;

    int basic_offset = 500000 * 6;

    std::set<MockClassicNote*, NotePtrCompt> _set = {};

    NoteInitializer init;
    init.context = &_context;
    init.intervals = {};
    init.perfect_offset = basic_offset + (500000 * 20);

    ElementInitializer elem_init;
    elem_init.type = _selected_type;
    elem_init.coordinates = Coordinates{ 700 - (5 * 120), 550 };
    elem_init.falling_curve_interpolation = {};

    MockArrowNoteInitializer mock_init;
    mock_init.elements = {elem_init};
    mock_init.initializer = init;
    _set.insert(new MockClassicNote(std::move(mock_init)));

    _timeline.setNotes(_set, 1648648);
}

microsec ClassicEditor::adjustOffset(microsec offset) const noexcept
{
    microsec  left = -1;
    microsec right = -1;

    std::set<microsec>::iterator i;

    for (i = _ticks.begin(); i != _ticks.end(); ++i)
    {
        if (*i >= offset)
        {
            right = *i;
            break;
        }
    }

    for (; i != _ticks.end(); --i)
    {
        if (*i <= offset)
        {
            left = *i;
            break;
        }
    }

    if (right == -1)
        offset = left;
    else if (left == -1)
        offset = right;
    else
    {
        const microsec right_distance = right - offset;
        const microsec left_distance = offset - left;

        offset = (right_distance > left_distance)
               ? left_distance
               : right_distance;
    }


    return offset;
}

void ClassicEditor::input(PlayerInput&& inputdata)
{
    _current_time = inputdata.timestamp;
    const auto& event = inputdata.event;

    switch (event.type)
    {

    default:
        break;

    case sf::Event::MouseButtonPressed:
    {
        const auto note = _timeline.getNoteBy(_current_time);
        if (_timeline.isExpired(note) && !_ticks.empty())
        {
            NoteInitializer init;
            init.context = &_context;
            init.intervals = {};
            init.perfect_offset = adjustOffset(_current_time);

            ElementInitializer elem_init;
            elem_init.type = _selected_type;
            elem_init.coordinates = Coordinates{ event.mouseButton.x, event.mouseButton.y };
            elem_init.falling_curve_interpolation = {};

            MockArrowNoteInitializer mock_init;
            mock_init.elements = {elem_init};
            mock_init.initializer = init;

            _timeline.insertNote(new MockClassicNote(std::move(mock_init)));
        }
        break;
    }

    }
}

void ClassicEditor::update(UpdateData&& updatedata)
{
    _timeline.update(updatedata.timestamp);
    _timeline.fetchVisibleNotes();
}

void ClassicEditor::draw() const
{
    const auto& graphics_manager = _graphics_manager;
    auto notes = _timeline.getVisibleNotes();

    std::for_each(notes.first, notes.second,
                  [graphics_manager](const auto& note)
                  {
                      note->draw();
                  });
}

void ClassicEditor::recalculate(const microsec& timestamp)
{
    _timeline.recalculate(timestamp);
}

void ClassicEditor::selectNoteType(Type type) noexcept
{
    _selected_type = type;
}