Implement Editor command system

CMakeLists.txt

@@ -17,7 +17,7 @@ set(CMAKE_THREAD_LIBS_INIT "-lpthread")
       set(THREADS_PREFER_PTHREAD_FLAG ON)
 
 include_directories(${CMAKE_SOURCE_DIR}/include)
-file(GLOB_RECURSE SOURCES "src/main.cpp")
+file(GLOB_RECURSE SOURCES "src/main.cpp" "include/*.h")
 add_executable(project-kyoku ${SOURCES})
 
 SET(CMAKE_INSTALL_PREFIX /)

include/core/editorcallback.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "core/systemevent.h"
+#include <string>
+
+namespace kku
+{
+
+class EditorCallback
+{
+public:
+    virtual ~EditorCallback() = default;
+
+    struct Metadata
+    {
+        const std::string group_title;
+        const std::string title;
+    };
+
+    virtual bool isEnabled() const = 0;
+    virtual void run() const = 0;
+
+    virtual Metadata getMetadata() const = 0;
+};
+
+}

include/core/functional.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <functional>
+
+namespace kku
+{
+
+using lambda = std::function<void(void)>;
+using predicate = std::function<bool(void)>;
+
+}

include/core/timeline.h

@@ -140,6 +140,11 @@ public:
         return _timeline.begin();
     }
 
+    inline Iterator end() const noexcept
+    {
+        return _timeline.end();
+    }
+
 private:
     std::set<TNote*, NotePtrComparator> _timeline;
     microsec _current_offset;

src/application/include/application/editorstate.h

@@ -3,14 +3,12 @@
 #include "application/state.h"
 #include "core/corefactory.h"
 #include "core/music.h"
+#include "core/functional.h"
 
 class BPMCalculator;
 class Group;
 
-namespace kku
-{
-class Editor;
-}
+namespace kku { class Editor; }
 
 class EditorState : public GUIState
 {
@@ -18,7 +16,7 @@ public:
 
     struct Callbacks
     {
-        std::function<void(void)> onLeaveEditorState;
+        kku::lambda onLeaveEditorState;
     };
 
     explicit EditorState(const std::shared_ptr<kku::CoreFactory>& core_factory, std::unique_ptr<kku::Editor>&& editor, Callbacks&& callbacks);

src/application/include/application/gamestate.h

@@ -4,6 +4,7 @@
 #include "core/music.h"
 #include "core/game.h"
 #include "core/corefactory.h"
+#include "core/functional.h"
 
 class Group;
 
@@ -13,7 +14,7 @@ public:
 
     struct Callbacks
     {
-        std::function<void(void)> onLeaveGame;
+        kku::lambda onLeaveGame;
     };
 
 
@@ -31,7 +32,7 @@ private:
     std::shared_ptr<kku::Music> _music;
     std::shared_ptr<kku::Game> _game;
 
-    std::function<void(void)> _onEnterGameCallback;
-    std::function<void(void)> _onLeaveGameCallback;
+    kku::lambda _onEnterGameCallback;
+    kku::lambda _onLeaveGameCallback;
 };
 

src/application/include/application/mainmenu.h

@@ -2,6 +2,7 @@
 
 #include "application/state.h"
 #include "core/corefactory.h"
+#include "core/functional.h"
 
 class Group;
 
@@ -11,8 +12,8 @@ public:
 
     struct Callbacks
     {
-        std::function<void(void)> onAppendGameState;
-        std::function<void(void)> onAppendEditorState;
+        kku::lambda onAppendGameState;
+        kku::lambda onAppendEditorState;
     };
 
     explicit MainMenu(const std::shared_ptr<kku::CoreFactory>& factory, Callbacks&& callbacks);

src/application/include/application/state.h

@@ -2,7 +2,6 @@
 
 #include <stack>
 #include <memory>
-#include <functional>
 
 #include "core/systemevent.h"
 #include "core/vector.h"

src/application/src/widgets/button.h

@@ -3,8 +3,6 @@
 #include "widget.h"
 #include "core/corefactory.h"
 
-#include <functional>
-
 class Button : public Widget
 {
 public:

src/application/src/widgets/pushbutton.cpp

@@ -43,7 +43,7 @@ void PushButton::input(const kku::SystemEvent& event)
     }
 }
 
-void PushButton::setCallback(std::function<void(void)> callback)
+void PushButton::setCallback(kku::lambda callback)
 {
     _on_click_callback = callback;
 }

src/application/src/widgets/pushbutton.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "button.h"
+#include "core/functional.h"
 
 class PushButton : public Button
 {
@@ -8,7 +9,7 @@ public:
     explicit PushButton(const std::string& text, const std::shared_ptr<kku::CoreFactory>& factory, unsigned int font_size = 12);
     virtual void input(const kku::SystemEvent& event) override final;
 
-    void setCallback(std::function<void(void)> callback);
+    void setCallback(kku::lambda callback);
     void setColors(kku::Color&& idle_color, kku::Color&& pressed_color);
 
 private:
@@ -16,6 +17,6 @@ private:
     kku::Color _color_pressed;
 
     bool _pressed;
-    std::function<void(void)> _on_click_callback;
+    kku::lambda _on_click_callback;
 };
 

src/application/src/widgets/window.cpp

@@ -1,5 +1,4 @@
 #include "window.h"
-#include "pushbutton.h"
 
 Window::Window(const std::shared_ptr<kku::CoreFactory>& factory, const std::string& title) :
     _core_factory(factory),
@@ -109,7 +108,7 @@ bool Window::isUnderMouse(const kku::Point& position) const
     return _is_visible && _window_content->contains(position);
 }
 
-void Window::addBarButton(const std::string &text, std::function<void(void)> callback)
+void Window::addBarButton(const std::string &text, kku::lambda callback)
 {
     const auto area = _window_content->getRect();
 

src/application/src/widgets/window.h

@@ -1,13 +1,12 @@
 #pragma once
 
 #include "widget.h"
+#include "pushbutton.h"
 #include "core/corefactory.h"
 #include "core/rectangle.h"
 #include "core/vector.h"
 #include "core/text.h"
 
-#include <functional>
-
 class Window : public Widget
 {
 public:
@@ -25,7 +24,7 @@ public:
     virtual void setPosition(const kku::Point& position) override;
     virtual kku::Point getPosition() const override;
 
-    void addBarButton(const std::string& text, std::function<void(void)> callback);
+    void addBarButton(const std::string& text, kku::lambda callback);
 
 protected:
     std::shared_ptr<kku::Rectangle> _bar;

src/modes/classicmode/classicfactory.cpp

@@ -17,7 +17,7 @@ std::unique_ptr<kku::Game> classic::getGame(const std::shared_ptr<kku::CoreFacto
     const auto factory = std::make_shared<ClassicGraphicsFactory>(core_factory);
     const auto timeline = std::make_shared<kku::Timeline<ClassicNote>>();
     const auto selection_manager = std::make_shared<SelectionManager>();
-    const auto graphics_manager = std::make_shared<ClassicSceneGraphicsManager>(timeline, factory, visibility_offset);
+    const auto graphics_manager = std::make_shared<ClassicSceneGraphicsManager<ClassicNote>>(timeline, factory, visibility_offset);
 
     return std::make_unique<ClassicGame>(timeline, graphics_manager);
 }
@@ -28,9 +28,9 @@ std::unique_ptr<kku::Editor> classic::getEditor(const std::shared_ptr<kku::CoreF
     const kku::microsec visibility_offset = 1648648;
 
     const auto factory = std::make_shared<ClassicGraphicsFactory>(core_factory);
-    const auto timeline = std::make_shared<kku::Timeline<ClassicNote>>();
+    const auto timeline = std::make_shared<kku::Timeline<ClassicMockNote>>();
     const auto selection_manager = std::make_shared<SelectionManager>();
-    const auto graphics_manager = std::make_shared<ClassicSceneGraphicsManager>(timeline, factory, visibility_offset);
+    const auto graphics_manager = std::make_shared<ClassicSceneGraphicsManager<ClassicMockNote>>(timeline, factory, visibility_offset);
 
     return std::make_unique<ClassicEditor>(timeline, graphics_manager, selection_manager);
 }

src/modes/classicmode/editor/callbacks/callbacksimple.cpp

@@ -0,0 +1,22 @@
+#include "callbacksimple.h"
+
+CallbackSimple::CallbackSimple(Init&& init, Metadata&& metadata) :
+    _run(std::move(init.run)),
+    _is_enabled(std::move(init.is_enabled)),
+    _metadata(std::move(metadata))
+{}
+
+bool CallbackSimple::isEnabled() const
+{
+    return _is_enabled();
+}
+
+void CallbackSimple::run() const
+{
+    _run();
+}
+
+auto CallbackSimple::getMetadata() const -> EditorCallback::Metadata
+{
+    return _metadata;
+}

src/modes/classicmode/editor/callbacks/callbacksimple.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "core/editorcallback.h"
+#include "core/functional.h"
+
+class CallbackSimple : public kku::EditorCallback
+{
+public:
+
+    struct Init
+    {
+        kku::lambda run;
+        kku::predicate is_enabled;
+    };
+
+    explicit CallbackSimple(Init&& init, Metadata&& metadata);
+
+    virtual bool isEnabled() const override;
+    virtual void run() const override;
+
+    virtual Metadata getMetadata() const override;
+
+private:
+    const kku::lambda _run;
+    const kku::predicate _is_enabled;
+    const Metadata _metadata;
+};

src/modes/classicmode/editor/classiceditor.cpp

@@ -9,7 +9,9 @@
 #include "graphics/animations/classicdyinganimationscenario.h"
 //
 
-ClassicEditor::ClassicEditor(const std::shared_ptr<kku::Timeline<ClassicNote>>& timeline,
+#include "callbacks/callbacksimple.h"
+
+ClassicEditor::ClassicEditor(const std::shared_ptr<kku::Timeline<ClassicMockNote>>& timeline,
                              const std::shared_ptr<ClassicGraphicsManager>& graphics_manager,
                              const std::shared_ptr<SelectionManager>& selection_manager) :
     _timeline(timeline),
@@ -29,7 +31,7 @@ ClassicEditor::ClassicEditor(const std::shared_ptr<kku::Timeline<ClassicNote>>&
     kku::microsec bpm_end = starting_beat_offset + (interval * amount_of_beats);
 
     std::vector<kku::microsec> input_intervals = {note_input_offset / 3, note_input_offset / 3 * 2, note_input_offset};
-    std::set<ClassicNote*, kku::NotePtrComparator> notes;
+    std::set<ClassicMockNote*, kku::NotePtrComparator> notes;
     input_intervals.shrink_to_fit();
 
     bpm_iterator += tempo_interval;

src/modes/classicmode/editor/classiceditor.h

@@ -5,7 +5,7 @@
 #include "core/editor.h"
 #include "core/timeline.h"
 
-#include "classicmode/classicnote.h"
+#include "classicmocknote.h"
 #include "classicmode/classicactions.h"
 
 class ClassicGraphicsManager;
@@ -14,7 +14,7 @@ class SelectionManager;
 class ClassicEditor : public kku::Editor
 {
 public:
-    explicit ClassicEditor(const std::shared_ptr<kku::Timeline<ClassicNote>>& timeline,
+    explicit ClassicEditor(const std::shared_ptr<kku::Timeline<ClassicMockNote>>& timeline,
                            const std::shared_ptr<ClassicGraphicsManager>& graphics_manager,
                            const std::shared_ptr<SelectionManager>& selection_manager);
 
@@ -28,7 +28,7 @@ public:
 private:
     inline kku::microsec adjustOffset(kku::microsec offset) const noexcept;
 
-    const std::shared_ptr<kku::Timeline<ClassicNote>> _timeline;
+    const std::shared_ptr<kku::Timeline<ClassicMockNote>> _timeline;
     const std::shared_ptr<ClassicGraphicsManager> _graphics_manager;
     const std::shared_ptr<SelectionManager> _selection_manager;
 

src/modes/classicmode/editor/classicmocknote.cpp

@@ -89,22 +89,6 @@ void ClassicMockNote::update(const kku::microsec& music_offset)
                 element.animations[_state]->update(music_offset);
 }
 
-void ClassicMockNote::display(const ClassicGraphicsManager * const manager) const
-{
-    manager->display(_elements);
-}
-
-void ClassicMockNote::setGraphics(ClassicGraphicsManager * const manager, kku::TimeRange&& range)
-{
-    manager->setGraphics(_elements, std::move(range));
-}
-
-void ClassicMockNote::removeGraphics(ClassicGraphicsManager * const manager)
-{
-    manager->removeGraphics(_elements);
-}
-
-
 std::vector<MockElement>& ClassicMockNote::getElements()
 {
     return _elements;

src/modes/classicmode/editor/classicmocknote.h

@@ -17,10 +17,6 @@ public:
     virtual void update(const kku::microsec &music_offset) override;
     virtual void input(kku::GameEvent&& input) override;
 
-    virtual void display(const ClassicGraphicsManager * const manager) const override;
-    virtual void setGraphics(ClassicGraphicsManager * const manager, kku::TimeRange&& range) override;
-    virtual void removeGraphics(ClassicGraphicsManager * const manager) override;
-
     std::vector<MockElement>& getElements();
 
 private:

src/modes/classicmode/game/classicarrownote.cpp

@@ -94,21 +94,6 @@ void ClassicArrowNote::update(const kku::microsec& music_offset)
                 element.animations[_state]->update(music_offset);
 }
 
-void ClassicArrowNote::display(const ClassicGraphicsManager * const manager) const
-{
-    manager->display(_elements);
-}
-
-void ClassicArrowNote::setGraphics(ClassicGraphicsManager * const manager, kku::TimeRange&& range)
-{
-    manager->setGraphics(_elements, std::move(range));
-}
-
-void ClassicArrowNote::removeGraphics(ClassicGraphicsManager * const manager)
-{
-    manager->removeGraphics(_elements);
-}
-
 bool ClassicArrowNote::allElementsPressed() const
 {
     return std::all_of(_elements.begin(), _elements.end(),
@@ -131,3 +116,8 @@ bool ClassicArrowNote::isHold() const
 {
     return _is_hold;
 }
+
+std::vector<ArrowElement>& ClassicArrowNote::getElements()
+{
+    return _elements;
+}

src/modes/classicmode/game/classicarrownote.h

@@ -24,14 +24,12 @@ public:
     virtual void update(const kku::microsec &music_offset) override;
     virtual void input(kku::GameEvent&& input) override;
 
-    virtual void display(const ClassicGraphicsManager * const manager) const override;
-    virtual void setGraphics(ClassicGraphicsManager * const manager, kku::TimeRange&& range) override;
-    virtual void removeGraphics(ClassicGraphicsManager * const manager) override;
-
     bool allElementsPressed() const;
     bool isPressedAs(kku::SystemEvent::Key::Code key) const;
     inline bool isHold() const;
 
+    std::vector<ArrowElement>& getElements();
+
 private:
     const kku::PrecisionEvaluator<Grade> _evaluator;
     const std::shared_ptr<HoldManager> _hold_manager;

src/modes/classicmode/graphics/classicgraphicsmanager.h

@@ -1,13 +1,9 @@
 #pragma once
 
 #include "core/time.h"
-#include "classicmode/classicactions.h"
+#include "core/gameevent.h"
 
 #include <memory>
-#include <vector>
-
-struct ArrowElement;
-struct MockElement;
 
 class ClassicGraphicsManager : public std::enable_shared_from_this<ClassicGraphicsManager>
 {
@@ -18,15 +14,6 @@ public:
     {}
 
     virtual void input(kku::GameEvent&& input) = 0;
-
-    virtual void display(const std::vector<ArrowElement>& elements) const = 0;
-    virtual void setGraphics(std::vector<ArrowElement>& elements, kku::TimeRange&& range) = 0;
-    virtual void removeGraphics(std::vector<ArrowElement>& elements) = 0;
-
-    virtual void display(const std::vector<MockElement>& elements) const = 0;
-    virtual void setGraphics(std::vector<MockElement>& elements, kku::TimeRange&& range) = 0;
-    virtual void removeGraphics(std::vector<MockElement>& elements) = 0;
-
     virtual void display() const = 0;
     virtual void update(const kku::microsec& offset) = 0;
 

src/modes/classicmode/graphics/classicscenegraphicsmanager.cpp

@@ -1,248 +0,0 @@
-#include "classicscenegraphicsmanager.h"
-
-#include "editor/mockelement.h"
-#include "game/arrowelement.h"
-
-#include "graphics/animations/classicflyinganimationscenario.h"
-#include "graphics/animations/classicdyinganimationscenario.h"
-
-ClassicSceneGraphicsManager::ClassicSceneGraphicsManager(const std::shared_ptr<kku::Timeline<ClassicNote>>& timeline,
-                                                         const std::shared_ptr<ClassicGraphicsFactory>& factory,
-                                                         const kku::microsec& visibility_offset) :
-    ClassicGraphicsManager(visibility_offset),
-    _sprite_container({Type::UP, Type::DOWN,
-                      Type::LEFT, Type::RIGHT},
-                      factory),
-    _factory(factory),
-    _timeline(timeline)
-{
-    _timeline->expire(_first);
-    _timeline->expire(_last);
-}
-
-void ClassicSceneGraphicsManager::input(kku::GameEvent&& input)
-{
-    if (nothingToDraw())
-        return;
-
-    for (auto it = _first; it != _last; ++it)
-    {
-        (*it)->input(std::move(input));
-    }
-}
-
-void ClassicSceneGraphicsManager::display() const
-{
-    if (nothingToDraw())
-        return;
-
-    for (auto it = _first; it != _last; ++it)
-    {
-        (*it)->display(this);
-    }
-}
-
-void ClassicSceneGraphicsManager::update(const kku::microsec &offset)
-{
-    fetchLastNote(offset);
-    fetchFirstNote(offset);
-
-    updateVisibleNotes(offset);
-}
-
-void ClassicSceneGraphicsManager::display(const std::vector<ArrowElement>& elements) const
-{
-    for (std::size_t i = 0; i < elements.size(); ++i)
-    {
-        const auto& sprite = elements[i].sprite;
-
-        if (i >= 1)
-        {
-            //const auto& neighbor_sprite = elements[i - 1].sprite;
-
-            //const auto c1 = neighbor_sprite->trailPosition();
-            //const auto c2 = sprite->trailPosition();
-
-            //_render_target->draw(makeLine(c1, c2));
-        }
-
-        sprite->display();
-    }
-}
-
-void ClassicSceneGraphicsManager::setGraphics(std::vector<ArrowElement>& elements, kku::TimeRange &&range)
-{
-    for (auto& element : elements)
-    {
-        element.sprite = _sprite_container.getSprite(element.type);
-        element.sprite->setPosition(element.position);
-        element.sprite->setTrailPosition(kku::Point( 0.f, 9.f ));
-
-        element.animations[ClassicNote::State::NONE] = nullptr;
-        element.animations[ClassicNote::State::FLYING] = std::make_shared<ClassicFlyingAnimationScenario>();
-        element.animations[ClassicNote::State::DYING] = std::make_shared<ClassicDyingAnimationScenario>();
-        element.animations[ClassicNote::State::DEAD] = nullptr;
-
-        element.animations[ClassicNote::State::FLYING]->launch(element.sprite, range.begin, range.end);
-    }
-}
-
-void ClassicSceneGraphicsManager::removeGraphics(std::vector<ArrowElement>& elements)
-{
-    for (auto& element : elements)
-    {
-        _sprite_container.resetSprite(element.sprite, element.type);
-        element.sprite = nullptr;
-
-        element.animations[ClassicNote::State::NONE] = nullptr;
-        element.animations[ClassicNote::State::FLYING] = nullptr;
-        element.animations[ClassicNote::State::DYING] = nullptr;
-        element.animations[ClassicNote::State::DEAD] = nullptr;
-    }
-}
-
-void ClassicSceneGraphicsManager::display(const std::vector<MockElement>& elements) const
-{
-    for (std::size_t i = 0; i < elements.size(); ++i)
-    {
-        const auto& sprite = elements[i].sprite;
-
-        if (i >= 1)
-        {
-            //const auto& neighbor_sprite = elements[i - 1].sprite;
-
-            //const auto c1 = neighbor_sprite->trailPosition();
-            //const auto c2 = sprite->trailPosition();
-
-            //_render_target->draw(makeLine(c1, c2));
-        }
-
-        sprite->display();
-    }
-}
-
-void ClassicSceneGraphicsManager::setGraphics(std::vector<MockElement>& elements, kku::TimeRange &&range)
-{
-    for (auto& element : elements)
-    {
-        element.sprite = _sprite_container.getSprite(element.type);
-        element.sprite->setPosition(element.position);
-        element.sprite->setTrailPosition(kku::Point( 0.f, 9.f ));
-
-        element.selection = _factory->createSelection();
-        element.selection->adjustTo(element.sprite);
-
-        element.animations[ClassicNote::State::NONE] = nullptr;
-        element.animations[ClassicNote::State::FLYING] = std::make_shared<ClassicFlyingAnimationScenario>();
-        element.animations[ClassicNote::State::DYING] = std::make_shared<ClassicDyingAnimationScenario>();
-        element.animations[ClassicNote::State::DEAD] = nullptr;
-        element.animations[ClassicNote::State::FLYING]->launch(element.sprite, range.begin, range.end);
-    }
-}
-
-void ClassicSceneGraphicsManager::removeGraphics(std::vector<MockElement>& elements)
-{
-    for (auto& element : elements)
-    {
-        _sprite_container.resetSprite(element.sprite, element.type);
-        element.sprite = nullptr;
-
-        element.animations[ClassicNote::State::NONE] = nullptr;
-        element.animations[ClassicNote::State::FLYING] = nullptr;
-        element.animations[ClassicNote::State::DYING] = nullptr;
-        element.animations[ClassicNote::State::DEAD] = nullptr;
-    }
-}
-
-/*sf::VertexArray ClassicSceneGraphicsSFML::makeLine(const kku::Point& c1, const kku::Point& c2) const
-{
-    sf::VertexArray line(sf::LinesStrip, 2);
-    line[0].color = sf::Color::Yellow;
-    line[0].position = {c1.x + 10, c1.y};
-    line[1].color = sf::Color::Blue;
-    line[1].position = {c2.x + 10, c2.y};
-
-    return line;
-}*/
-
-void ClassicSceneGraphicsManager::updateVisibleNotes(const kku::microsec &offset)
-{
-    for (auto it = _first; it != _last; ++it)
-        (*it)->update(offset);
-}
-
-void ClassicSceneGraphicsManager::fetchFirstNote(const kku::microsec& offset)
-{
-    if (nothingToDraw())
-        return;
-
-    if (offset < (*_first)->getPerfectOffset())
-    {
-        Iterator note_iterator = _first;
-        while (note_iterator != _timeline->begin() && isVisiblyClose(note_iterator, offset))
-        {
-            --note_iterator;
-        }
-
-        _first = note_iterator;
-
-        auto note = *_first;
-        if (note->getState() != ClassicNote::State::FLYING
-        &&  note->getState() != ClassicNote::State::DYING
-        &&  offset <= note->getPerfectOffset())
-        {
-            note->setState(ClassicNote::State::FLYING);
-            note->setGraphics(this, kku::TimeRange{note->getPerfectOffset() - _visibility_offset, note->getPerfectOffset()});
-        }
-    }
-    else
-    {
-        Iterator note_iterator = _first;
-        while (note_iterator != _last)
-        {
-            auto note = *note_iterator;
-            if (note->getState() == ClassicNote::State::DEAD)
-            {
-               // note->removeGraphics(this);
-                ++_first;
-            }
-
-            ++note_iterator;
-        }
-    }
-}
-
-void ClassicSceneGraphicsManager::fetchLastNote(const kku::microsec& offset)
-{
-    Iterator note_iterator = _timeline->getTopNote();
-    while (!_timeline->isExpired(note_iterator) && isVisiblyClose(note_iterator, offset))
-    {
-        if (nothingToDraw())
-            _first = note_iterator;
-
-        auto note = *note_iterator;
-
-        if (note->getState() != ClassicNote::State::FLYING
-        &&  note->getState() != ClassicNote::State::DYING
-        &&  offset <= note->getPerfectOffset())
-        {
-            note->setState(ClassicNote::State::FLYING);
-            note->setGraphics(this, kku::TimeRange{note->getPerfectOffset() - _visibility_offset, note->getPerfectOffset()});
-        }
-
-        ++note_iterator;
-    }
-
-    _last = note_iterator;
-}
-
-bool ClassicSceneGraphicsManager::nothingToDraw() const noexcept
-{
-    return _timeline->isExpired(_first)
-        || _timeline->isExpired(_last);
-}
-
-bool ClassicSceneGraphicsManager::isVisiblyClose(const Iterator& iterator, const kku::microsec& music_offset) const noexcept
-{
-    return ((*iterator)->getPerfectOffset() - _visibility_offset) <= music_offset;
-}

src/modes/classicmode/graphics/classicscenegraphicsmanager.h

@@ -6,43 +6,254 @@
 #include "core/timeline.h"
 #include "core/spritecontainer.h"
 
-class ClassicSprite;
+#include "editor/mockelement.h"
+#include "game/arrowelement.h"
 
+#include "graphics/animations/classicflyinganimationscenario.h"
+#include "graphics/animations/classicdyinganimationscenario.h"
+
+template <class TNote, class = std::enable_if_t<std::is_base_of<kku::Note, TNote>::value>>
 class ClassicSceneGraphicsManager : public ClassicGraphicsManager
 {
 public:
-    explicit ClassicSceneGraphicsManager(const std::shared_ptr<kku::Timeline<ClassicNote>>& timeline,
+    explicit ClassicSceneGraphicsManager(const std::shared_ptr<kku::Timeline<TNote>>& timeline,
                                          const std::shared_ptr<ClassicGraphicsFactory>& factory,
-                                         const kku::microsec& visibility_offset);
+                                         const kku::microsec& visibility_offset) :
+        ClassicGraphicsManager(visibility_offset),
+        _sprite_container({Type::UP, Type::DOWN,
+                          Type::LEFT, Type::RIGHT},
+                          factory),
+        _factory(factory),
+        _timeline(timeline)
+    {
+        _timeline->expire(_first);
+        _timeline->expire(_last);
+    }
 
-    virtual void input(kku::GameEvent&& input) override;
+    virtual void input(kku::GameEvent&& input) override
+    {
+        if (nothingToDraw())
+            return;
 
-    virtual void display() const override;
-    virtual void update(const kku::microsec& offset) override;
+        for (auto it = _first; it != _last; ++it)
+        {
+            (*it)->input(std::move(input));
+        }
+    }
 
-    virtual void display(const std::vector<ArrowElement>& elements) const override;
-    virtual void setGraphics(std::vector<ArrowElement>& elements, kku::TimeRange&& range) override;
-    virtual void removeGraphics(std::vector<ArrowElement>& elements) override;
+    virtual void display() const override
+    {
+        if (nothingToDraw())
+            return;
 
-    virtual void display(const std::vector<MockElement>& elements) const override;
-    virtual void setGraphics(std::vector<MockElement>& elements, kku::TimeRange&& range) override;
-    virtual void removeGraphics(std::vector<MockElement>& elements) override;
+        for (auto it = _first; it != _last; ++it)
+        {
+            display((*it)->getElements());
+        }
+    }
+
+    virtual void update(const kku::microsec& offset) override
+    {
+        fetchLastNote(offset);
+        fetchFirstNote(offset);
+
+        updateVisibleNotes(offset);
+    }
+
+    virtual void display(const std::vector<ArrowElement>& elements) const
+    {
+        for (std::size_t i = 0; i < elements.size(); ++i)
+        {
+            const auto& sprite = elements[i].sprite;
+
+            if (i >= 1)
+            {
+                //const auto& neighbor_sprite = elements[i - 1].sprite;
+
+                //const auto c1 = neighbor_sprite->trailPosition();
+                //const auto c2 = sprite->trailPosition();
+
+                //_render_target->draw(makeLine(c1, c2));
+            }
+
+            sprite->display();
+        }
+    }
+
+    virtual void setGraphics(std::vector<ArrowElement>& elements, kku::TimeRange&& range)
+    {
+        for (auto& element : elements)
+        {
+            element.sprite = _sprite_container.getSprite(element.type);
+            element.sprite->setPosition(element.position);
+            element.sprite->setTrailPosition(kku::Point( 0.f, 9.f ));
+
+            element.animations[ClassicNote::State::NONE] = nullptr;
+            element.animations[ClassicNote::State::FLYING] = std::make_shared<ClassicFlyingAnimationScenario>();
+            element.animations[ClassicNote::State::DYING] = std::make_shared<ClassicDyingAnimationScenario>();
+            element.animations[ClassicNote::State::DEAD] = nullptr;
+
+            element.animations[ClassicNote::State::FLYING]->launch(element.sprite, range.begin, range.end);
+        }
+    }
+
+    virtual void removeGraphics(std::vector<ArrowElement>& elements)
+    {
+        for (auto& element : elements)
+        {
+            _sprite_container.resetSprite(element.sprite, element.type);
+            element.sprite = nullptr;
+
+            element.animations[ClassicNote::State::NONE] = nullptr;
+            element.animations[ClassicNote::State::FLYING] = nullptr;
+            element.animations[ClassicNote::State::DYING] = nullptr;
+            element.animations[ClassicNote::State::DEAD] = nullptr;
+        }
+    }
+
+    virtual void display(const std::vector<MockElement>& elements) const
+    {
+        for (std::size_t i = 0; i < elements.size(); ++i)
+        {
+            const auto& sprite = elements[i].sprite;
+
+            if (i >= 1)
+            {
+                //const auto& neighbor_sprite = elements[i - 1].sprite;
+
+                //const auto c1 = neighbor_sprite->trailPosition();
+                //const auto c2 = sprite->trailPosition();
+
+                //_render_target->draw(makeLine(c1, c2));
+            }
+
+            sprite->display();
+        }
+    }
+
+    virtual void setGraphics(std::vector<MockElement>& elements, kku::TimeRange&& range)
+    {
+        for (auto& element : elements)
+        {
+            element.sprite = _sprite_container.getSprite(element.type);
+            element.sprite->setPosition(element.position);
+            element.sprite->setTrailPosition(kku::Point( 0.f, 9.f ));
+
+            element.selection = _factory->createSelection();
+            element.selection->adjustTo(element.sprite);
+
+            element.animations[ClassicNote::State::NONE] = nullptr;
+            element.animations[ClassicNote::State::FLYING] = std::make_shared<ClassicFlyingAnimationScenario>();
+            element.animations[ClassicNote::State::DYING] = std::make_shared<ClassicDyingAnimationScenario>();
+            element.animations[ClassicNote::State::DEAD] = nullptr;
+            element.animations[ClassicNote::State::FLYING]->launch(element.sprite, range.begin, range.end);
+        }
+    }
+
+    virtual void removeGraphics(std::vector<MockElement>& elements)
+    {
+        for (auto& element : elements)
+        {
+            _sprite_container.resetSprite(element.sprite, element.type);
+            element.sprite = nullptr;
+
+            element.animations[ClassicNote::State::NONE] = nullptr;
+            element.animations[ClassicNote::State::FLYING] = nullptr;
+            element.animations[ClassicNote::State::DYING] = nullptr;
+            element.animations[ClassicNote::State::DEAD] = nullptr;
+        }
+    }
 
 protected:
     kku::SpriteContainer<Type, ClassicGraphicsFactory, ClassicSprite> _sprite_container;
     const std::shared_ptr<const ClassicGraphicsFactory> _factory;
-    using Iterator = kku::Timeline<ClassicNote>::Iterator;
+
+    typedef typename std::set<TNote*>::const_iterator Iterator;
 
     Iterator _first;
     Iterator _last;
 
-    const std::shared_ptr<kku::Timeline<ClassicNote>> _timeline;
+    const std::shared_ptr<kku::Timeline<TNote>> _timeline;
 
-    inline bool nothingToDraw() const noexcept;
-    inline bool isVisiblyClose(const Iterator& iterator, const kku::microsec& music_offset) const noexcept;
-    //inline sf::VertexArray makeLine(const kku::Point& c1, const kku::Point& c2) const;
+    inline bool nothingToDraw() const noexcept
+    {
+        return _timeline->isExpired(_first)
+            || _timeline->isExpired(_last);
+    }
 
-    void fetchFirstNote(const kku::microsec& offset);
-    void fetchLastNote(const kku::microsec& offset);
-    void updateVisibleNotes(const kku::microsec& offset);
+    inline bool isVisiblyClose(const Iterator& iterator, const kku::microsec& music_offset) const noexcept
+    {
+        return ((*iterator)->getPerfectOffset() - _visibility_offset) <= music_offset;
+    }
+
+    void fetchFirstNote(const kku::microsec& offset)
+    {
+        if (nothingToDraw())
+            return;
+
+        if (offset < (*_first)->getPerfectOffset())
+        {
+            Iterator note_iterator = _first;
+            while (note_iterator != _timeline->begin() && isVisiblyClose(note_iterator, offset))
+            {
+                --note_iterator;
+            }
+
+            _first = note_iterator;
+
+            auto note = *_first;
+            if (note->getState() != ClassicNote::State::FLYING
+            &&  note->getState() != ClassicNote::State::DYING
+            &&  offset <= note->getPerfectOffset())
+            {
+                note->setState(ClassicNote::State::FLYING);
+                setGraphics(note, kku::TimeRange{note->getPerfectOffset() - _visibility_offset, note->getPerfectOffset()});
+            }
+        }
+        else
+        {
+            Iterator note_iterator = _first;
+            while (note_iterator != _last)
+            {
+                auto note = *note_iterator;
+                if (note->getState() == ClassicNote::State::DEAD)
+                {
+                   // note->removeGraphics(this);
+                    ++_first;
+                }
+
+                ++note_iterator;
+            }
+        }
+    }
+
+    void fetchLastNote(const kku::microsec& offset)
+    {
+        Iterator note_iterator = _timeline->getTopNote();
+        while (!_timeline->isExpired(note_iterator) && isVisiblyClose(note_iterator, offset))
+        {
+            if (nothingToDraw())
+                _first = note_iterator;
+
+            auto note = *note_iterator;
+
+            if (note->getState() != ClassicNote::State::FLYING
+            &&  note->getState() != ClassicNote::State::DYING
+            &&  offset <= note->getPerfectOffset())
+            {
+                note->setState(ClassicNote::State::FLYING);
+                note->setGraphics(this, kku::TimeRange{note->getPerfectOffset() - _visibility_offset, note->getPerfectOffset()});
+            }
+
+            ++note_iterator;
+        }
+
+        _last = note_iterator;
+    }
+
+    void updateVisibleNotes(const kku::microsec& offset)
+    {
+        for (auto it = _first; it != _last; ++it)
+            (*it)->update(offset);
+    }
 };

src/modes/classicmode/include/classicmode/classicnote.h

@@ -27,10 +27,6 @@ public:
 
     virtual void input(kku::GameEvent&& input) override = 0;
 
-    virtual void display(const ClassicGraphicsManager * const manager) const = 0;
-    virtual void setGraphics(ClassicGraphicsManager * const manager, kku::TimeRange&& range) = 0;
-    virtual void removeGraphics(ClassicGraphicsManager * const manager) = 0;
-
     void setState(State state) noexcept;
     State getState() const noexcept;