SquareGameLiberationFront/jujube
1
0
Fork 0
mirror of synced 2025-02-02 12:27:20 +01:00
Code Releases Activity

Divide Resources into shared and screen-specific

Browse Source
This commit is contained in:
Stepland 2020-05-01 00:18:30 +02:00
parent 917e44dac0
commit 3de0d50975
46 changed files with 630 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
TODO.md
View File

@ -2,6 +2,7 @@
## Misc
## Gameplay Screen
- Precise Input handling, the dirty way
## Results Screen

21
meson.build
View File

@ -30,23 +30,26 @@ sources = [
'src/Data/Note.hpp',
'src/Data/Preferences.hpp',
'src/Data/Preferences.cpp',
'src/Data/Score.hpp',
'src/Data/Song.hpp',
'src/Data/Song.cpp',
'src/Drawables/BlackFrame.hpp',
'src/Drawables/BlackFrame.cpp',
'src/Drawables/ButtonHighlight.hpp',
'src/Drawables/ButtonHighlight.cpp',
'src/Drawables/DensityGraph.hpp',
'src/Drawables/DensityGraph.cpp',
'src/Input/Buttons.hpp',
'src/Input/Buttons.cpp',
'src/Input/KeyMapping.hpp',
'src/Input/KeyMapping.cpp',
'src/Input/MappableKeys.hpp',
'src/Input/MappableKeys.cpp',
'src/Input/Events.hpp',
'src/Input/Events.cpp',
'src/Resources/TextureCache.cpp',
'src/Resources/TextureCache.hpp',
'src/Resources/Marker.cpp',
'src/Resources/Marker.hpp',
'src/Resources/SharedResources.hpp',
'src/Resources/SharedResources.cpp',
# 'src/Resources/CoverAtlas.hpp',
# 'src/Resources/CoverAtlas.cpp',
# 'src/Screens/Gameplay.hpp',
@ -62,8 +65,6 @@ sources = [
'src/Screens/MusicSelect/Panels/Panel.cpp',
'src/Screens/MusicSelect/Panels/SubpagePanel.hpp',
'src/Screens/MusicSelect/Panels/SubpagePanel.cpp',
'src/Screens/MusicSelect/DensityGraph.hpp',
'src/Screens/MusicSelect/DensityGraph.cpp',
'src/Screens/MusicSelect/MusicPreview.hpp',
'src/Screens/MusicSelect/MusicPreview.cpp',
'src/Screens/MusicSelect/MusicSelect.hpp',
@ -72,10 +73,16 @@ sources = [
'src/Screens/MusicSelect/PanelLayout.cpp',
'src/Screens/MusicSelect/Ribbon.hpp',
'src/Screens/MusicSelect/Ribbon.cpp',
'src/Screens/MusicSelect/SharedResources.hpp',
'src/Screens/MusicSelect/SharedResources.cpp',
'src/Screens/MusicSelect/Resources.hpp',
'src/Screens/MusicSelect/Resources.cpp',
'src/Screens/MusicSelect/SongInfo.hpp',
'src/Screens/MusicSelect/SongInfo.cpp',
'src/Screens/Gameplay/Gameplay.hpp',
'src/Screens/Gameplay/Gameplay.cpp',
'src/Screens/Gameplay/PreciseMusic.hpp',
'src/Screens/Gameplay/PreciseMusic.cpp',
'src/Screens/Gameplay/Silence.hpp',
'src/Screens/Gameplay/Silence.cpp',
# 'src/Screens/Result.hpp',
'src/Toolkit/AffineTransform.hpp',
'src/Toolkit/Cache.hpp',

22
src/Data/Chart.cpp
View File

@ -11,21 +11,21 @@ namespace Data {
auto [_, chart] = *it;
level = chart.level;
resolution = static_cast<std::size_t>(chart.resolution);
Toolkit::AffineTransform<float> memon_timing_to_1000Hz(
Toolkit::AffineTransform<float> memon_timing_to_seconds(
0.f, static_cast<float>(chart.resolution),
-memon.offset*1000.f, (-memon.offset+60.f/memon.BPM)*1000.f
-memon.offset, (-memon.offset+60.f/memon.BPM)
);
Toolkit::AffineTransform<float> memon_timing_to_300Hz_proportional(
Toolkit::AffineTransform<float> memon_timing_to_seconds_proportional(
0.f, static_cast<float>(chart.resolution),
0.f, (60.f/memon.BPM)*300.f
0.f, (60.f/memon.BPM)*1000.f
);
for (auto &&note : chart.notes) {
auto timing = static_cast<long>(memon_timing_to_1000Hz.transform(note.get_timing()));
auto timing = sf::seconds(memon_timing_to_seconds.transform(note.get_timing()));
auto position = static_cast<Input::Button>(note.get_pos());
std::size_t length = 0;
sf::Time length = sf::Time::Zero;
auto tail = Input::Button::B1;
if (note.get_length() != 0) {
length = static_cast<std::size_t>(memon_timing_to_300Hz_proportional.transform(note.get_length()));
length = sf::seconds(memon_timing_to_seconds_proportional.transform(note.get_length()));
tail = convert_memon_tail(position, note.get_tail_pos());
}
notes.insert({timing, position, length, tail});
@ -74,4 +74,12 @@ namespace Data {
}
return *tail;
}
sf::Time Chart::get_duration_based_on_notes() const {
if (notes.rbegin() == notes.rend()) {
return sf::Time::Zero;
} else {
return notes.rbegin()->timing;
}
}
}

2
src/Data/Chart.hpp
View File

@ -4,6 +4,7 @@
#include <set>
#include <memon/memon.hpp>
#include <SFML/System/Time.hpp>
#include "../Input/Buttons.hpp"
#include "Note.hpp"
@ -14,6 +15,7 @@ namespace Data {
int level;
std::set<Note> notes;
std::size_t resolution;
sf::Time get_duration_based_on_notes() const;
};
Input::Button convert_memon_tail(Input::Button note, unsigned int tail_position);
}

10
src/Data/Note.hpp
View File

@ -1,14 +1,16 @@
#pragma once
#include <SFML/System/Time.hpp>
#include "../Input/Buttons.hpp"
namespace Data {
struct Note {
// Timing is stored as ticks on a 1000Hz clock starting at the begging of the audio
long int timing;
// offset since the begging of the audio
sf::Time timing;
Input::Button position;
// zero length means it's a standard note
std::size_t length;
// zero means it's a normal note
sf::Time duration;
Input::Button tail;
bool operator==(const Note &rhs) const {

2
src/Data/Score.hpp
View File

@ -5,4 +5,4 @@ namespace Data {
public:
Score();
};
};
}

20
src/Screens/MusicSelect/DensityGraph.cpp → src/Drawables/DensityGraph.cpp
View File

@ -5,9 +5,9 @@
#include <SFML/Audio.hpp>
#include "../../Toolkit/AffineTransform.hpp"
#include "../Toolkit/AffineTransform.hpp"
namespace MusicSelect {
namespace Drawables {
DensityGraph::DensityGraph(const std::array<unsigned int, 115>& t_densities) :
m_densities(t_densities),
@ -53,7 +53,7 @@ namespace MusicSelect {
throw std::invalid_argument("Song "+song.title+" has no "+difficulty+" chart");
}
if (c->notes.empty()) {
return compute_density_graph_from_chart(*c, 0, 0);
return compute_density_graph_from_chart(*c, sf::Time::Zero, sf::Time::Zero);
}
if (not song.audio.has_value()) {
return compute_density_graph_from_chart(*c, c->notes.begin()->timing, c->notes.rbegin()->timing);
@ -64,22 +64,22 @@ namespace MusicSelect {
}
return compute_density_graph_from_chart(
*c,
std::min(0L, c->notes.begin()->timing),
std::max(c->notes.rbegin()->timing, static_cast<long>(m.getDuration().asMilliseconds()*3/10))
sf::microseconds(std::min(0LL, c->notes.begin()->timing.asMicroseconds())),
sf::microseconds(std::max(c->notes.rbegin()->timing.asMicroseconds(), m.getDuration().asMicroseconds()))
);
}
DensityGraph compute_density_graph_from_chart(const Data::Chart& chart, long start, long end) {
DensityGraph compute_density_graph_from_chart(const Data::Chart& chart, sf::Time start, sf::Time end) {
std::array<unsigned int, 115> d{};
if (start != end) {
Toolkit::AffineTransform<float> ticks_to_column{
static_cast<float>(start),
static_cast<float>(end),
start.asSeconds(),
end.asSeconds(),
0.f,
115.f
};
for (auto &&note : chart.notes) {
auto index = static_cast<unsigned int>(ticks_to_column.transform(static_cast<float>(note.timing)));
auto index = static_cast<unsigned int>(ticks_to_column.transform(note.timing.asSeconds()));
d.at(index) += 1;
}
std::replace_if(
@ -95,7 +95,7 @@ namespace MusicSelect {
namespace Toolkit {
template<>
void set_origin_normalized(MusicSelect::DensityGraph& s, float x, float y) {
void set_origin_normalized(Drawables::DensityGraph& s, float x, float y) {
s.setOrigin(x*574.f, y*39.f);
}
}

14
src/Screens/MusicSelect/DensityGraph.hpp → src/Drawables/DensityGraph.hpp
View File

@ -5,12 +5,12 @@
#include <SFML/Graphics.hpp>
#include "../../Data/Chart.hpp"
#include "../../Data/Song.hpp"
#include "../../Toolkit/Cache.hpp"
#include "../../Toolkit/NormalizedOrigin.hpp"
#include "../Data/Chart.hpp"
#include "../Data/Song.hpp"
#include "../Toolkit/Cache.hpp"
#include "../Toolkit/NormalizedOrigin.hpp"
namespace MusicSelect {
namespace Drawables {
class DensityGraph : public sf::Drawable, public sf::Transformable {
public:
explicit DensityGraph(const std::array<unsigned int, 115>& t_densities);
@ -22,7 +22,7 @@ namespace MusicSelect {
DensityGraph compute_density_graph_from_struct(const Data::SongDifficulty& sd);
DensityGraph compute_density_graph_from_song_difficulty(const Data::Song& song, const std::string& difficulty);
DensityGraph compute_density_graph_from_chart(const Data::Chart& chart, long start, long end);
DensityGraph compute_density_graph_from_chart(const Data::Chart& chart, sf::Time start, sf::Time end);
using DensityGraphCache = Toolkit::Cache<Data::SongDifficulty, DensityGraph, &compute_density_graph_from_struct>;
}
@ -40,5 +40,5 @@ namespace std {
namespace Toolkit {
template<>
void set_origin_normalized(MusicSelect::DensityGraph& s, float x, float y);
void set_origin_normalized(Drawables::DensityGraph& s, float x, float y);
}

10
src/Input/MappableKeys.cpp → src/Input/Events.cpp
View File

@ -1,19 +1,19 @@
#include "MappableKeys.hpp"
#include "Events.hpp"
namespace Input {
MappableKeyToString mappable_button_to_string;
EventToString mappable_button_to_string;
std::string to_string(const MappableKey& mk) {
std::string to_string(const Event& mk) {
return std::visit(mappable_button_to_string, mk);
}
std::regex mappable_button_regex("(.+?)::(.+)");
std::regex joystick_button_regex("(\\d+)_(\\d+)");
MappableKey from_string(const std::string& s) {
Event from_string(const std::string& s) {
std::smatch matches;
if (not std::regex_match(s, matches, mappable_button_regex)) {
throw std::runtime_error("Unknown MappableKey : "+s);
throw std::runtime_error("Unknown Event : "+s);
}
auto device = matches[1].str();
auto button = matches[2].str();

9
src/Input/MappableKeys.hpp → src/Input/Events.hpp
View File

@ -33,7 +33,7 @@ namespace std {
}
namespace Input {
using MappableKey = std::variant<sf::Keyboard::Key, JoystickButton>;
using Event = std::variant<sf::Keyboard::Key, JoystickButton>;
const std::unordered_map<sf::Keyboard::Key, std::string> keyboard_to_string{
{
@ -249,8 +249,7 @@ namespace Input {
}
};
struct MappableKeyToString {
public:
struct EventToString {
std::string operator() (const sf::Keyboard::Key& k) {
return "Keyboard::"+keyboard_to_string.at(k);
};
@ -259,6 +258,6 @@ namespace Input {
};
};
std::string to_string(const MappableKey& mk);
MappableKey from_string(const std::string& s);
std::string to_string(const Event& mk);
Event from_string(const std::string& s);
}

12
src/Input/KeyMapping.cpp
View File

@ -24,21 +24,21 @@ namespace Input {
}
}
KeyMapping::KeyMapping(std::unordered_map<Button, MappableKey> button_to_key) : m_button_to_key(button_to_key) {
KeyMapping::KeyMapping(std::unordered_map<Button, Event> button_to_key) : m_button_to_key(button_to_key) {
for (auto &&[button, key] : m_button_to_key) {
m_key_to_button[key] = button;
}
assert((m_button_to_key.size() == m_key_to_button.size()));
}
KeyMapping::KeyMapping(std::unordered_map<MappableKey, Button> key_to_button) : m_key_to_button(key_to_button) {
KeyMapping::KeyMapping(std::unordered_map<Event, Button> key_to_button) : m_key_to_button(key_to_button) {
for (auto &&[key, button] : m_key_to_button) {
m_button_to_key[button] = key;
}
assert((m_button_to_key.size() == m_key_to_button.size()));
}
void KeyMapping::set_button_to_key(const Button& button, const MappableKey& key) {
void KeyMapping::set_button_to_key(const Button& button, const Event& key) {
if (m_key_to_button.find(key) != m_key_to_button.end()) {
m_button_to_key.erase(m_key_to_button[key]);
m_key_to_button.erase(key);
@ -47,7 +47,7 @@ namespace Input {
m_key_to_button[key] = button;
}
std::optional<Button> KeyMapping::key_to_button(const MappableKey& key) {
std::optional<Button> KeyMapping::key_to_button(const Event& key) {
if (m_key_to_button.find(key) == m_key_to_button.end()) {
return {};
} else {
@ -55,7 +55,7 @@ namespace Input {
}
}
std::optional<MappableKey> KeyMapping::button_to_key(const Button& button) {
std::optional<Event> KeyMapping::button_to_key(const Button& button) {
if (m_button_to_key.find(button) == m_button_to_key.end()) {
return {};
} else {
@ -70,7 +70,7 @@ namespace Input {
}
void from_json(const nlohmann::json& j, KeyMapping& km) {
std::unordered_map<Button, MappableKey> map;
std::unordered_map<Button, Event> map;
for (std::size_t i = 0; i < 16; i++) {
map[*index_to_button(i)] = from_string(j.at("B"+std::to_string(i+1)));
}

16
src/Input/KeyMapping.hpp
View File

@ -9,7 +9,7 @@
#include <SFML/Window.hpp>
#include "Buttons.hpp"
#include "MappableKeys.hpp"
#include "Events.hpp"
namespace Data {
struct Preferences;
@ -19,14 +19,14 @@ namespace Input {
class KeyMapping {
public:
KeyMapping();
explicit KeyMapping(std::unordered_map<Button, MappableKey> button_to_key);
explicit KeyMapping(std::unordered_map<MappableKey, Button> button_to_key);
void set_button_to_key(const Button& button, const MappableKey& key);
std::optional<Button> key_to_button(const MappableKey& key);
std::optional<MappableKey> button_to_key(const Button& button);
explicit KeyMapping(std::unordered_map<Button, Event> button_to_key);
explicit KeyMapping(std::unordered_map<Event, Button> button_to_key);
void set_button_to_key(const Button& button, const Event& key);
std::optional<Button> key_to_button(const Event& key);
std::optional<Event> button_to_key(const Button& button);
private:
std::unordered_map<MappableKey, Button> m_key_to_button;
std::unordered_map<Button, MappableKey> m_button_to_key;
std::unordered_map<Event, Button> m_key_to_button;
std::unordered_map<Button, Event> m_button_to_key;
friend struct Data::Preferences;
friend void to_json(nlohmann::json& j, const KeyMapping& km);

9
src/Main.cpp
View File

@ -6,9 +6,11 @@
#include "Data/Song.hpp"
#include "Data/Preferences.hpp"
#include "Resources/Marker.hpp"
#include "Resources/SharedResources.hpp"
// #include "Data/Chart.hpp"
// #include "Data/Score.hpp"
#include "Screens/MusicSelect/Resources.hpp"
#include "Screens/MusicSelect/MusicSelect.hpp"
// #include "Screens/Gameplay.hpp"
// #include "Screens/Result.hpp"
@ -19,9 +21,10 @@ int main(int, char const **) {
const std::string jujube_path = whereami::executable_dir();
Data::Preferences preferences{jujube_path};
Data::SongList song_list{jujube_path};
MusicSelect::SharedResources music_select_resources{preferences};
if (music_select_resources.markers.find(preferences.options.marker) == music_select_resources.markers.end()) {
preferences.options.marker = music_select_resources.markers.begin()->first;
Resources::SharedResources shared_resources{preferences};
MusicSelect::ScreenResources music_select_resources{shared_resources};
if (shared_resources.markers.find(preferences.options.marker) == shared_resources.markers.end()) {
preferences.options.marker = shared_resources.markers.begin()->first;
}
MusicSelect::Screen music_select{song_list, music_select_resources};

33
src/Screens/MusicSelect/SharedResources.cpp → src/Resources/SharedResources.cpp
View File

@ -2,12 +2,9 @@
#include <iostream>
#include "../../Toolkit/HSL.hpp"
#include "../Toolkit/HSL.hpp"
#include "Options/OptionPage.hpp"
#include "Panels/Panel.hpp"
namespace MusicSelect {
namespace Resources {
FallbackFont::FallbackFont(const ghc::filesystem::path& jujube_path) :
light(),
@ -36,32 +33,6 @@ namespace MusicSelect {
std::cout << "Loaded MusicSelect::SharedResources" << std::endl;
}
std::string SharedResources::get_last_selected_difficulty() {
return get_selected_difficulty().value_or("BSC");
}
std::optional<std::string> SharedResources::get_selected_difficulty() {
if (not selected_panel.has_value()) {
return {};
}
auto chart_selection = selected_panel->obj.get_selected_difficulty();
if (not chart_selection.has_value()) {
return {};
}
return chart_selection->difficulty;
}
std::optional<std::reference_wrapper<const Data::Song>> MusicSelect::SharedResources::get_selected_song() {
if (not selected_panel.has_value()) {
return {};
}
auto chart_selection = selected_panel->obj.get_selected_difficulty();
if (not chart_selection.has_value()) {
return {};
}
return chart_selection->song;
}
sf::Color SharedResources::get_chart_color(const std::string& chart) {
if (chart == "BSC") {
return BSC_color;

37
src/Screens/MusicSelect/SharedResources.hpp → src/Resources/SharedResources.hpp
View File

@ -9,20 +9,16 @@
#include <SFML/Graphics/Font.hpp>
#include <SFML/System.hpp>
#include "../../Data/Preferences.hpp"
#include "../../Data/Song.hpp"
#include "../../Drawables/ButtonHighlight.hpp"
#include "../../Resources/Marker.hpp"
#include "../../Resources/TextureCache.hpp"
#include "../Data/Preferences.hpp"
#include "../Data/Song.hpp"
#include "../Drawables/ButtonHighlight.hpp"
#include "../Drawables/DensityGraph.hpp"
#include "../Resources/Marker.hpp"
#include "../Resources/TextureCache.hpp"
#include "DensityGraph.hpp"
#include "MusicPreview.hpp"
namespace Resources {
namespace MusicSelect {
class SelectablePanel;
class MarkerPanel;
class OptionPage;
template<class Object>
struct Timed {
@ -40,7 +36,7 @@ namespace MusicSelect {
sf::Font black;
};
// Holds everything that needs to be shared by all levels of the class hierarchy
// Holds everything that needs to be shared between screens and down the class hierarchy
struct SharedResources : public Data::HoldsPreferences {
SharedResources(Data::Preferences& p);
@ -48,32 +44,21 @@ namespace MusicSelect {
FallbackFont fallback_font;
MusicSelect::DensityGraphCache density_graphs;
std::optional<Timed<SelectablePanel>> selected_panel;
std::string get_last_selected_difficulty();
std::optional<std::string> get_selected_difficulty();
std::optional<std::reference_wrapper<const Data::Song>> get_selected_song();
Drawables::DensityGraphCache density_graphs;
sf::Color BSC_color = sf::Color{34,216,92};
sf::Color ADV_color = sf::Color{252,212,32};
sf::Color EXT_color = sf::Color{234,46,32};
sf::Color get_chart_color(const std::string& chart);
MusicPreview music_preview;
std::vector<std::reference_wrapper<OptionPage>> options_state;
Resources::Markers markers;
std::optional<Timed<MarkerPanel>> selected_marker;
Drawables::ButtonHighlight button_highlight;
};
// Proxy for HoldsPreferences
struct HoldsSharedResources : public Data::HoldsPreferences {
HoldsSharedResources(SharedResources& t_resources) : Data::HoldsPreferences(t_resources.preferences), resources(t_resources) {};
protected:
SharedResources& resources;
HoldsSharedResources(SharedResources& t_resources) : Data::HoldsPreferences(t_resources.preferences), shared(t_resources) {};
SharedResources& shared;
};
}

58
src/Screens/Gameplay/Gameplay.cpp
View File

@ -1,5 +1,9 @@
#include "Gameplay.hpp"
#include <chrono>
#include <optional>
#include <thread>
#include <imgui/imgui.h>
#include <imgui-sfml/imgui-SFML.h>
@ -8,16 +12,22 @@ namespace Gameplay {
song_selection(t_song_selection),
chart(*t_song_selection.song.get_chart(t_song_selection.difficulty))
{
notes_left = chart.notes;
std::variant<PreciseMusic, Silence> music;
auto music_path = song_selection.song.full_audio_path();
if (music_path) {
music.emplace<PreciseMusic>(music_path->string());
} else {
music.emplace<Silence>(chart.get_duration_based_on_notes());
}
getPlayingOffset = std::visit(GetPlayingOffsetVisitor{}, music);
getStatus = std::visit(GetStatusVisitor{}, music);
}
Data::Score Screen::play_chart(sf::RenderWindow& window) {
window.setFramerateLimit(60);
ImGui::SFML::Init(window);
sf::Clock imguiClock;
sf::Music song;
if (song_selection.song.full_audio_path())
std::thread render_thread(&Screen::render, this, std::ref(window));
while ((not song_finished) and window.isOpen()) {
auto playing_offset = getPlayingOffset();
sf::Event event;
while (window.pollEvent(event)) {
ImGui::SFML::ProcessEvent(event);
@ -32,13 +42,20 @@ namespace Gameplay {
case sf::Event::Resized:
// update the view to the new size of the window
window.setView(sf::View({0, 0, static_cast<float>(event.size.width), static_cast<float>(event.size.height)}));
// resources.preferences.screen.height = event.size.height;
// resources.preferences.screen.width = event.size.width;
break;
default:
break;
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
void Screen::render(sf::RenderWindow& window) {
window.setFramerateLimit(60);
ImGui::SFML::Init(window);
sf::Clock imguiClock;
while ((not song_finished) and window.isOpen()) {
ImGui::SFML::Update(window, imguiClock.restart());
window.clear(sf::Color(7, 23, 53));
draw_debug();
@ -47,4 +64,29 @@ namespace Gameplay {
}
ImGui::SFML::Shutdown();
}
void Screen::handle_raw_event(const Input::Event& event, const sf::Time& playing_offset) {
}
void Screen::handle_button(const Input::Button& button, const sf::Time& playing_offset) {
// TODO : Button Highlight
// Is the music even playing ?
if (getStatus() == sf::SoundSource::Playing) {
for (auto &&note : notes_left) {
// is the note visible ?
if (note.timing > playing_offset + sf::seconds(16.f/30.f)) {
break;
}
// is it even the right button ?
if (note.position != button) {
continue;
}
notes_passed.emplace(note, note.timing-playing_offset);
notes_left.erase(note);
break;
}
}
}
}

45
src/Screens/Gameplay/Gameplay.hpp
View File

@ -1,11 +1,19 @@
#pragma once
#include <atomic>
#include <SFML/Graphics.hpp>
#include "../../Data/Chart.hpp"
#include "../../Data/Note.hpp"
#include "../../Data/Song.hpp"
#include "../../Data/Score.hpp"
#include "../../Input/Buttons.hpp"
#include "../../Input/Events.hpp"
#include "../../Toolkit/Debuggable.hpp"
#include "PreciseMusic.hpp"
#include "Silence.hpp"
#include "GradedNote.hpp"
namespace Gameplay {
class Screen : public Toolkit::Debuggable {
@ -13,10 +21,39 @@ namespace Gameplay {
explicit Screen(const Data::SongDifficulty& song_selection);
Data::Score play_chart(sf::RenderWindow& window);
private:
void render(sf::RenderWindow& window);
std::function<sf::Time(void)> getPlayingOffset;
std::function<sf::SoundSource::Status(void)> getStatus;
void handle_raw_event(const Input::Event& event, const sf::Time& playing_offset);
void handle_button(const Input::Button& button, const sf::Time& playing_offset);
const Data::SongDifficulty& song_selection;
const Data::Chart chart;
Data::Score score;
bool song_finished = false;
};
};
std::set<GradedNote> notes_passed;
std::set<Data::Note> notes_left;
std::atomic<bool> song_finished = false;
};
struct GetPlayingOffsetVisitor {
std::function<sf::Time(void)> operator() (const PreciseMusic& pm) {
return [&pm](){return pm.getPrecisePlayingOffset();};
}
std::function<sf::Time(void)> operator() (const Silence& s) {
return [&s](){return s.getPlayingOffset();};
}
};
struct GetStatusVisitor {
std::function<sf::SoundSource::Status(void)> operator() (const PreciseMusic& pm) {
return [&pm](){return pm.getStatus();};
}
std::function<sf::SoundSource::Status(void)> operator() (const Silence& s) {
return [&s](){return s.getStatus();};
}
};
}

25
src/Screens/Gameplay/GradedNote.cpp Normal file
View File

@ -0,0 +1,25 @@
#include "GradedNote.hpp"
namespace Gameplay {
Judgement delta_to_judgement(const sf::Time& delta) {
auto delta_abs = delta;
if (delta_abs < sf::Time::Zero) {
delta_abs = -delta_abs;
}
// Numbers from http://544332133981.hatenablog.com/entry/bemani-rank_4
// which themselves are apparently from jubeat analyser's code.
// Here they are divided by 2 because we are checking against an absolute
// offset from the target time position
if (delta_abs < sf::milliseconds(21)) {
return Judgement::Perfect;
} else if (delta_abs < sf::milliseconds(46)) {
return Judgement::Great;
} else if (delta_abs < sf::milliseconds(83)) {
return Judgement::Good;
} else if (delta_abs < sf::milliseconds(250)) {
return Judgement::Poor;
} else {
return Judgement::Miss;
}
}
}

23
src/Screens/Gameplay/GradedNote.hpp Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include <SFML/System/Time.hpp>
#include "../../Data/Note.hpp"
namespace Gameplay {
enum class Judgement {
Perfect,
Great,
Good,
Poor,
Miss
};
Judgement delta_to_judgement(const sf::Time& delta);
struct GradedNote : Data::Note {
GradedNote(const Data::Note& n, const sf::Time& t) : Note::Note(n), delta(t), judgement(delta_to_judgement(t)) {};
sf::Time delta;
Judgement judgement;
};
}

57
src/Screens/Gameplay/PreciseMusic.cpp Normal file
View File

@ -0,0 +1,57 @@
#include "PreciseMusic.hpp"
#include <chrono>
namespace Gameplay {
PreciseMusic::PreciseMusic() : Music::Music() {
}
PreciseMusic::PreciseMusic(std::string path) {
if (not this->openFromFile(path)) {
throw std::invalid_argument("Could not open "+path);
}
position_update_watchdog = std::thread{&PreciseMusic::position_update_watchdog_main, this};
}
void PreciseMusic::position_update_watchdog_main() {
sf::Time next_music_position = sf::Time::Zero;
while (not should_stop_watchdog) {
if (this->getStatus() == sf::Music::Playing) {
next_music_position = this->getPlayingOffset();
if (next_music_position != last_music_position) {
lag = lag_measurement.getElapsedTime()/2.f;
should_correct = true;
break;
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
PreciseMusic::~PreciseMusic() {
should_stop_watchdog = true;
position_update_watchdog.join();
}
sf::Time PreciseMusic::getPrecisePlayingOffset() const {
if (should_correct) {
return last_music_position+last_position_update.getElapsedTime()-lag;
} else {
return this->getPlayingOffset();
}
}
bool PreciseMusic::onGetData(sf::SoundStream::Chunk& data) {
if (first_onGetData_call) {
first_onGetData_call = false;
lag_measurement.restart();
}
bool continue_playback = sf::Music::onGetData(data);
if (continue_playback) {
last_music_position = getPlayingOffset();
last_position_update.restart();
}
return continue_playback;
}
}

31
src/Screens/Gameplay/PreciseMusic.hpp Normal file
View File

@ -0,0 +1,31 @@
#pragma once
#include <thread>
#include <atomic>
#include <SFML/Audio.hpp>
#include <SFML/System/Time.hpp>
namespace Gameplay {
struct PreciseMusic : sf::Music {
PreciseMusic();
explicit PreciseMusic(std::string path);
~PreciseMusic();
std::thread position_update_watchdog;
void position_update_watchdog_main();
std::atomic<bool> should_stop_watchdog = false;
sf::Time getPrecisePlayingOffset() const;
bool first_onGetData_call = true;
sf::Clock lag_measurement;
std::atomic<sf::Time> lag = sf::Time::Zero;
std::atomic<bool> should_correct = false;
std::atomic<sf::Time> last_music_position = sf::Time::Zero;
sf::Clock last_position_update;
protected:
bool onGetData(sf::SoundStream::Chunk& data) override;
};
}

67
src/Screens/Gameplay/Silence.cpp Normal file
View File

@ -0,0 +1,67 @@
#include "Silence.hpp"
namespace Gameplay {
Silence::Silence(const sf::Time& duration) :
m_duration(duration),
m_status(sf::Music::Stopped)
{
}
void Silence::play() {
if (m_status != sf::SoundSource::Paused) {
m_position = sf::Time::Zero;
}
m_clock.restart();
}
void Silence::pause() {
if (m_status == sf::SoundSource::Playing) {
m_position += m_clock.getElapsedTime();
if (m_position > m_duration) {
stop();
} else {
m_status = sf::Music::Paused;
}
}
}
void Silence::stop() {
m_status = sf::Music::Stopped;
m_position = sf::Time::Zero;
}
unsigned int getChannelCount() {
return 2;
}
unsigned int getSampleRate() {
return 48000;
}
sf::SoundSource::Status Silence::getStatus() const {
return m_status;
}
void Silence::setPlayingOffset(sf::Time timeOffset) {
if (timeOffset > m_duration) {
stop();
} else {
m_position = timeOffset;
}
}
sf::Time Silence::getPlayingOffset() const {
if (m_status == sf::SoundSource::Playing) {
m_position += m_clock.restart();
if (m_position > m_duration) {
m_status = sf::Music::Stopped;
m_position = sf::Time::Zero;
}
}
return m_position;
}
sf::Time Silence::getDuration() const {
return m_duration;
}
}

34
src/Screens/Gameplay/Silence.hpp Normal file
View File

@ -0,0 +1,34 @@
#pragma once
#include <SFML/Audio/Music.hpp>
#include <SFML/System/Time.hpp>
#include <SFML/System/Clock.hpp>
namespace Gameplay {
// noop class for use when the chart has no associated music file
class Silence : public sf::Music {
public:
Silence(const sf::Time& duration);
void play();
void pause();
void stop();
unsigned int getChannelCount() const;
unsigned int getSampleRate() const;
sf::SoundSource::Status getStatus() const;
void setPlayingOffset(sf::Time timeOffset);
sf::Time getPlayingOffset() const;
void setLoop(bool /*loop*/) {};
bool getLoop() const {return false;};
bool openFromFile(const std::string& /*filename*/) {return false;};
bool openFromMemory(const void* /*data*/, std::size_t /*sizeInBytes*/) {return false;};
bool openFromStream(sf::InputStream& /*stream*/) {return false;};
sf::Time getDuration() const;
TimeSpan getLoopPoints() const {return TimeSpan{};};
void setLoopPoints(TimeSpan /*timePoints*/) {};
private:
const sf::Time m_duration;
mutable sf::SoundSource::Status m_status;
mutable sf::Time m_position;
mutable sf::Clock m_clock;
};
}

14
src/Screens/MusicSelect/Drawables/ControlPanels.cpp
View File

@ -57,7 +57,7 @@ namespace MusicSelect {
sf::Text label{
"OPTIONS",
resources.fallback_font.black,
shared.fallback_font.black,
static_cast<unsigned int>(0.2f*get_panel_size())
};
label.setFillColor(sf::Color::White);
@ -72,17 +72,17 @@ namespace MusicSelect {
sf::CircleShape circle{get_panel_size()*0.4f};
circle.setFillColor(sf::Color::Black);
circle.setOutlineThickness(0.02f*get_panel_size());
circle.setOutlineColor(resources.BSC_color);
circle.setOutlineColor(shared.BSC_color);
Toolkit::set_origin_normalized(circle, 0.5f, 0.5f);
circle.setPosition(get_panel_size()*0.5f, get_panel_size()*0.5f);
target.draw(circle, states);
sf::Text label{
"START",
resources.fallback_font.black,
shared.fallback_font.black,
static_cast<unsigned int>(0.2f*get_panel_size())
};
label.setFillColor(resources.BSC_color);
label.setFillColor(shared.BSC_color);
Toolkit::set_local_origin_normalized(label, 0.5f, 0.5f);
label.setPosition(get_panel_size()*0.5f, get_panel_size()*0.5f);
target.draw(label, states);
@ -93,17 +93,17 @@ namespace MusicSelect {
sf::CircleShape circle{get_panel_size()*0.4f};
circle.setFillColor(sf::Color::Black);
circle.setOutlineThickness(0.02f*get_panel_size());
circle.setOutlineColor(resources.EXT_color);
circle.setOutlineColor(shared.EXT_color);
Toolkit::set_origin_normalized(circle, 0.5f, 0.5f);
circle.setPosition(get_panel_size()*0.5f, get_panel_size()*0.5f);
target.draw(circle, states);
sf::Text label{
"BACK",
resources.fallback_font.black,
shared.fallback_font.black,
static_cast<unsigned int>(0.2f*get_panel_size())
};
label.setFillColor(resources.EXT_color);
label.setFillColor(shared.EXT_color);
Toolkit::set_local_origin_normalized(label, 0.5f, 0.5f);
label.setPosition(get_panel_size()*0.5f, get_panel_size()*0.5f);
target.draw(label, states);

22
src/Screens/MusicSelect/Drawables/ControlPanels.hpp
View File

@ -2,40 +2,40 @@
#include <SFML/Graphics.hpp>
#include "../SharedResources.hpp"
#include "../Resources.hpp"
namespace MusicSelect {
class LeftButton final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class LeftButton final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
using HoldsSharedResources::HoldsSharedResources;
using HoldsResources::HoldsResources;
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};
class RightButton final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class RightButton final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
using HoldsSharedResources::HoldsSharedResources;
using HoldsResources::HoldsResources;
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};
class OptionsButton final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class OptionsButton final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
using HoldsSharedResources::HoldsSharedResources;
using HoldsResources::HoldsResources;
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};
class StartButton final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class StartButton final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
using HoldsSharedResources::HoldsSharedResources;
using HoldsResources::HoldsResources;
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};
class BackButton final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class BackButton final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
using HoldsSharedResources::HoldsSharedResources;
using HoldsResources::HoldsResources;
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
};

3
src/Screens/MusicSelect/MusicPreview.hpp
View File

@ -11,6 +11,8 @@
namespace fs = ghc::filesystem;
// In this file define stuff to try to handle creating sf::Music objects
// and starting their playback asynchronously while trying to keep some thread-safety
namespace MusicSelect {
struct MusicLoop {
MusicLoop(fs::path music_path, std::optional<sf::Music::TimeSpan> t_loop);
@ -18,7 +20,6 @@ namespace MusicSelect {
sf::Music::TimeSpan loop;
Toolkit::AffineTransform<float> fade_out = {0.f, 1.f, 0.f, 1.f}; // placeholder value
};
class MusicPreview {
public:
MusicPreview() = default;

31
src/Screens/MusicSelect/MusicSelect.cpp
View File

@ -13,15 +13,15 @@
#include "Panels/Panel.hpp"
#include "PanelLayout.hpp"
MusicSelect::Screen::Screen(const Data::SongList& t_song_list, SharedResources& t_resources) :
HoldsSharedResources(t_resources),
MusicSelect::Screen::Screen(const Data::SongList& t_song_list, ScreenResources& t_resources) :
HoldsResources(t_resources),
song_list(t_song_list),
ribbon(PanelLayout::title_sort(t_song_list, t_resources), t_resources),
song_info(t_resources),
main_option_page(t_resources),
options_button(t_resources),
start_button(t_resources),
black_frame(t_resources.preferences)
black_frame(t_resources.shared.preferences)
{
panel_filter.setFillColor(sf::Color(0,0,0,200));
std::cout << "loaded MusicSelect::Screen" << std::endl;
@ -32,7 +32,7 @@ std::optional<Data::SongDifficulty> MusicSelect::Screen::select_chart(sf::Render
ImGui::SFML::Init(window);
sf::Clock imguiClock;
ribbon.setPosition(get_ribbon_x(), get_ribbon_y());
resources.button_highlight.setPosition(get_ribbon_x(), get_ribbon_y());
shared.button_highlight.setPosition(get_ribbon_x(), get_ribbon_y());
panel_filter.setSize(sf::Vector2f{window.getSize()});
options_button.setPosition(get_ribbon_x()+2.f*get_panel_step(), get_ribbon_y()+3.f*get_panel_step());
start_button.setPosition(get_ribbon_x()+3.f*get_panel_step(), get_ribbon_y()+3.f*get_panel_step());
@ -53,10 +53,10 @@ std::optional<Data::SongDifficulty> MusicSelect::Screen::select_chart(sf::Render
case sf::Event::Resized:
// update the view to the new size of the window
window.setView(sf::View({0, 0, static_cast<float>(event.size.width), static_cast<float>(event.size.height)}));
resources.preferences.screen.height = event.size.height;
resources.preferences.screen.width = event.size.width;
shared.preferences.screen.height = event.size.height;
shared.preferences.screen.width = event.size.width;
ribbon.setPosition(get_ribbon_x(), get_ribbon_y());
resources.button_highlight.setPosition(get_ribbon_x(), get_ribbon_y());
shared.button_highlight.setPosition(get_ribbon_x(), get_ribbon_y());
panel_filter.setSize(sf::Vector2f{window.getSize()});
if (not resources.options_state.empty()) {
resources.options_state.back().get().update();
@ -77,15 +77,15 @@ std::optional<Data::SongDifficulty> MusicSelect::Screen::select_chart(sf::Render
if (not resources.options_state.empty()) {
window.draw(panel_filter);
window.draw(resources.options_state.back());
if (resources.options_state.back().get().should_exit()) {
resources.options_state.back().get().exit();
if (resources.options_state.back().get().should_exit()) {
resources.options_state.pop_back();
if (not resources.options_state.empty()) {
resources.options_state.back().get().update();
}
}
}
window.draw(resources.button_highlight);
window.draw(shared.button_highlight);
window.draw(black_frame);
ribbon.draw_debug();
draw_debug();
@ -107,20 +107,19 @@ void MusicSelect::Screen::draw_debug() {
if (ImGui::CollapsingHeader("Preferences")) {
if (ImGui::TreeNode("screen")) {
ImGui::TextUnformatted("width : "); ImGui::SameLine();
ImGui::Text("%s", std::to_string(resources.preferences.screen.width).c_str());
ImGui::Text("%s", std::to_string(preferences.screen.width).c_str());
ImGui::TextUnformatted("height : "); ImGui::SameLine();
ImGui::Text("%s", std::to_string(resources.preferences.screen.height).c_str());
ImGui::Text("%s", std::to_string(preferences.screen.height).c_str());
ImGui::TextUnformatted("fullscreen : "); ImGui::SameLine();
ImGui::Text("%s", resources.preferences.screen.fullscreen ? "true" : "false");
ImGui::Text("%s", preferences.screen.fullscreen ? "true" : "false");
ImGui::TreePop();
}
if (ImGui::TreeNode("layout")) {
ImGui::TreePop();
}
if (ImGui::TreeNode("options")) {
ImGui::TextUnformatted("marker : "); ImGui::SameLine();
ImGui::Text("%s", resources.preferences.options.marker.c_str());
ImGui::Text("%s", preferences.options.marker.c_str());
ImGui::TreePop();
}
}
@ -157,7 +156,7 @@ void MusicSelect::Screen::handle_key_press(const sf::Event::KeyEvent& key_event)
if (output_used) {
return;
}
auto button = resources.preferences.key_mapping.key_to_button(key_event.code);
auto button = shared.preferences.key_mapping.key_to_button(key_event.code);
if (button) {
press_button(*button);
} else {
@ -203,7 +202,7 @@ void MusicSelect::Screen::handle_mouse_click(const sf::Event::MouseButtonEvent&
}
void MusicSelect::Screen::press_button(const Input::Button& button) {
resources.button_highlight.button_pressed(button);
shared.button_highlight.button_pressed(button);
auto button_index = Input::button_to_index(button);
if (button_index < 14) {
ribbon.click_on(button);

9
src/Screens/MusicSelect/MusicSelect.hpp
View File

@ -15,7 +15,7 @@
#include "../../Toolkit/Debuggable.hpp"
#include "Ribbon.hpp"
#include "SongInfo.hpp"
#include "SharedResources.hpp"
#include "Resources.hpp"
#include "Options/OptionPage.hpp"
#include "Drawables/ControlPanels.hpp"
@ -24,12 +24,9 @@ namespace MusicSelect {
class SongPanel;
// The music select screen is created only once
// it loads a cache of available songs in the song_list attribute
class Screen : public Toolkit::Debuggable, public HoldsSharedResources {
class Screen : public Toolkit::Debuggable, public HoldsResources {
public:
Screen(
const Data::SongList& t_song_list,
SharedResources& t_resources
);
Screen(const Data::SongList& t_song_list, ScreenResources& t_resources);
std::optional<Data::SongDifficulty> select_chart(sf::RenderWindow& window);
void draw_debug() override;
private:

30
src/Screens/MusicSelect/Options/InputRemap.cpp
View File

@ -10,12 +10,12 @@
namespace MusicSelect {
PressHere::PressHere(SharedResources& t_resources) :
HoldsSharedResources(t_resources),
PressHere::PressHere(ScreenResources& t_resources) :
HoldsResources(t_resources),
color_anim(0.0f, 1.0f, 1.0f, 0.1f),
size_anim(0.0f, 1.0f, 1.0f, 0.7f)
{
message.setFont(resources.fallback_font.black);
message.setFont(shared.fallback_font.black);
message.setString("PRESS\nHERE!");
message.setFillColor(sf::Color::White);
message.setCharacterSize(static_cast<unsigned int>(0.2f*get_panel_size()));
@ -46,8 +46,8 @@ namespace MusicSelect {
target.draw(message, states);
}
AlreadyMapped::AlreadyMapped(SharedResources& t_resources) : HoldsSharedResources(t_resources) {
background.setFillColor(resources.BSC_color);
AlreadyMapped::AlreadyMapped(ScreenResources& t_resources) : HoldsResources(t_resources) {
background.setFillColor(shared.BSC_color);
}
void AlreadyMapped::update() {
@ -60,17 +60,17 @@ namespace MusicSelect {
}
MappingPreview::MappingPreview(
SharedResources& t_resources,
const std::unordered_map<Input::MappableKey, Input::Button>& t_key_to_button
ScreenResources& t_resources,
const std::unordered_map<Input::Event, Input::Button>& t_key_to_button
) :
HoldsSharedResources(t_resources),
HoldsResources(t_resources),
key_to_button(t_key_to_button)
{
square.setFillColor(sf::Color::Transparent);
square.setOutlineThickness(1.f);
square.setOutlineColor(sf::Color::White);
key_label.setFillColor(sf::Color::White);
key_label.setFont(resources.fallback_font.medium);
key_label.setFont(shared.fallback_font.medium);
}
void MappingPreview::draw(sf::RenderTarget& target, sf::RenderStates states) const {
@ -103,20 +103,20 @@ namespace MusicSelect {
}
}
InputRemap::InputRemap(SharedResources& t_resources) :
InputRemap::InputRemap(ScreenResources& t_resources) :
OptionPage(t_resources),
press_here_panel(t_resources),
already_mapped_panel(t_resources),
mapping_preview(t_resources, m_key_to_button)
{
confirm_text_top.setString("Are you sure about this setting ?");
confirm_text_top.setFillColor(resources.EXT_color);
confirm_text_top.setFont(resources.fallback_font.black);
confirm_text_top.setFillColor(shared.EXT_color);
confirm_text_top.setFont(shared.fallback_font.black);
confirm_text_bottom.setString("Press any key to cancel");
confirm_text_bottom.setFillColor(resources.EXT_color);
confirm_text_bottom.setFont(resources.fallback_font.black);
confirm_text_bottom.setFillColor(shared.EXT_color);
confirm_text_bottom.setFont(shared.fallback_font.black);
big_number.setFillColor(sf::Color::Black);
big_number.setFont(resources.fallback_font.black);
big_number.setFont(shared.fallback_font.black);
}
bool InputRemap::handle_raw_input(const sf::Event::KeyEvent& event) {

22
src/Screens/MusicSelect/Options/InputRemap.hpp
View File

@ -6,16 +6,16 @@
#include <SFML/System.hpp>
#include <SFML/Graphics.hpp>
#include "../../../Input/MappableKeys.hpp"
#include "../../../Input/Events.hpp"
#include "../../../Toolkit/AffineTransform.hpp"
#include "../SharedResources.hpp"
#include "../Resources.hpp"
#include "OptionPage.hpp"
namespace MusicSelect {
class PressHere final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class PressHere final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
PressHere(SharedResources& t_resources);
PressHere(ScreenResources& t_resources);
void update();
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
@ -26,28 +26,28 @@ namespace MusicSelect {
Toolkit::AffineTransform<float> size_anim;
};
class AlreadyMapped final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class AlreadyMapped final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
AlreadyMapped(SharedResources& t_resources);
AlreadyMapped(ScreenResources& t_resources);
void update();
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
sf::RectangleShape background;
};
class MappingPreview final : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class MappingPreview final : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
MappingPreview(SharedResources& t_resources, const std::unordered_map<Input::MappableKey, Input::Button>& t_key_to_button);
MappingPreview(ScreenResources& t_resources, const std::unordered_map<Input::Event, Input::Button>& t_key_to_button);
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
const std::unordered_map<Input::MappableKey, Input::Button>& key_to_button;
const std::unordered_map<Input::Event, Input::Button>& key_to_button;
mutable sf::RectangleShape square;
mutable sf::Text key_label;
};
class InputRemap final : public OptionPage {
public:
InputRemap(SharedResources& t_resources);
InputRemap(ScreenResources& t_resources);
bool handle_raw_input(const sf::Event::KeyEvent& event) override;
const std::string name = "Mapping";
bool should_exit() override;
@ -61,7 +61,7 @@ namespace MusicSelect {
mutable sf::Text confirm_text_top;
mutable sf::Text confirm_text_bottom;
mutable sf::Text big_number;
std::unordered_map<Input::MappableKey, Input::Button> m_key_to_button;
std::unordered_map<Input::Event, Input::Button> m_key_to_button;
mutable PressHere press_here_panel;
mutable AlreadyMapped already_mapped_panel;
mutable MappingPreview mapping_preview;

18
src/Screens/MusicSelect/Options/OptionPage.cpp
View File

@ -15,7 +15,7 @@ namespace MusicSelect {
this->setPosition(get_ribbon_x(), get_ribbon_y());
}
RibbonPage::RibbonPage(const PanelLayout& layout, SharedResources& t_resources) :
RibbonPage::RibbonPage(const PanelLayout& layout, ScreenResources& t_resources) :
OptionPage(t_resources),
m_ribbon(layout, t_resources),
back_button(t_resources)
@ -36,7 +36,7 @@ namespace MusicSelect {
}
void RibbonPage::button_click(const Input::Button& button) {
resources.button_highlight.button_pressed(button);
shared.button_highlight.button_pressed(button);
auto button_index = Input::button_to_index(button);
if (button_index < 12) {
m_ribbon.click_on(button);
@ -61,12 +61,12 @@ namespace MusicSelect {
target.draw(back_button, states);
}
MainOptionPage::MainOptionPage(SharedResources& t_resources) :
MainOptionPage::MainOptionPage(ScreenResources& t_resources) :
RibbonPage(MainOptionPage::create_layout(t_resources), t_resources)
{
}
PanelLayout MainOptionPage::create_layout(SharedResources& t_resources) {
PanelLayout MainOptionPage::create_layout(ScreenResources& t_resources) {
std::vector<std::shared_ptr<Panel>> subpages;
auto marker_select = std::make_shared<MarkerSelect>(t_resources);
subpages.emplace_back(std::make_shared<SubpagePanel>(t_resources, std::move(marker_select), "markers"));
@ -75,19 +75,19 @@ namespace MusicSelect {
return PanelLayout{subpages, t_resources};
}
InputOptionPage::InputOptionPage(SharedResources& t_resources) :
InputOptionPage::InputOptionPage(ScreenResources& t_resources) :
RibbonPage(InputOptionPage::create_layout(t_resources), t_resources)
{
}
PanelLayout InputOptionPage::create_layout(SharedResources& t_resources) {
PanelLayout InputOptionPage::create_layout(ScreenResources& t_resources) {
std::vector<std::shared_ptr<Panel>> subpages;
auto input_remap = std::make_shared<InputRemap>(t_resources);
subpages.emplace_back(std::make_shared<SubpagePanel>(t_resources, std::move(input_remap), "remap\nbuttons"));
return PanelLayout{subpages, t_resources};
}
MarkerSelect::MarkerSelect(SharedResources& t_resources) :
MarkerSelect::MarkerSelect(ScreenResources& t_resources) :
RibbonPage(MarkerSelect::create_layout(t_resources), t_resources)
{
}
@ -96,9 +96,9 @@ namespace MusicSelect {
resources.selected_marker.reset();
}
PanelLayout MarkerSelect::create_layout(SharedResources& t_resources) {
PanelLayout MarkerSelect::create_layout(ScreenResources& t_resources) {
std::vector<std::shared_ptr<Panel>> markers;
for (const auto &[name, marker] : t_resources.markers) {
for (const auto &[name, marker] : t_resources.shared.markers) {
markers.emplace_back(std::make_shared<MarkerPanel>(t_resources, marker));
}
return PanelLayout{markers, t_resources};

20
src/Screens/MusicSelect/Options/OptionPage.hpp
View File

@ -6,16 +6,16 @@
#include "../../../Input/Buttons.hpp"
#include "../Drawables/ControlPanels.hpp"
#include "../Ribbon.hpp"
#include "../SharedResources.hpp"
#include "../Resources.hpp"
namespace MusicSelect {
class PanelLayout;
class OptionPage : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class OptionPage : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
OptionPage(SharedResources& t_resources) : HoldsSharedResources(t_resources) {update();};
OptionPage(ScreenResources& t_resources) : HoldsResources(t_resources) {update();};
// Returns true if input was used
virtual bool handle_raw_input(const sf::Event::KeyEvent& event) = 0;
virtual ~OptionPage() = default;
@ -27,7 +27,7 @@ namespace MusicSelect {
class RibbonPage : public OptionPage {
public:
RibbonPage(const PanelLayout& layout, SharedResources& t_resources);
RibbonPage(const PanelLayout& layout, ScreenResources& t_resources);
bool handle_raw_input(const sf::Event::KeyEvent& event) override;
void button_click(const Input::Button& button);
private:
@ -38,26 +38,26 @@ namespace MusicSelect {
class MainOptionPage final : public RibbonPage {
public:
MainOptionPage(SharedResources& t_resources);
MainOptionPage(ScreenResources& t_resources);
const std::string name = "Options";
private:
static PanelLayout create_layout(SharedResources& t_resources);
static PanelLayout create_layout(ScreenResources& t_resources);
};
class InputOptionPage final : public RibbonPage {
public:
InputOptionPage(SharedResources& t_resources);
InputOptionPage(ScreenResources& t_resources);
const std::string name = "Input";
private:
static PanelLayout create_layout(SharedResources& t_resources);
static PanelLayout create_layout(ScreenResources& t_resources);
};
class MarkerSelect final : public RibbonPage {
public:
MarkerSelect(SharedResources& t_resources);
MarkerSelect(ScreenResources& t_resources);
~MarkerSelect();
const std::string name = "Marker Select";
private:
static PanelLayout create_layout(SharedResources& t_resources);
static PanelLayout create_layout(ScreenResources& t_resources);
};
}

10
src/Screens/MusicSelect/PanelLayout.cpp
View File

@ -5,7 +5,7 @@
namespace MusicSelect {
PanelLayout::PanelLayout(
const std::map<std::string,std::vector<std::shared_ptr<Panel>>>& categories,
SharedResources& t_resources
ScreenResources& t_resources
) {
for (auto &&[category, panels] : categories) {
if (not panels.empty()) {
@ -31,7 +31,7 @@ namespace MusicSelect {
PanelLayout::PanelLayout(
const std::vector<std::shared_ptr<Panel>>& panels,
SharedResources& t_resources
ScreenResources& t_resources
) {
std::vector<std::shared_ptr<Panel>> current_column;
for (auto& panel : panels) {
@ -50,7 +50,7 @@ namespace MusicSelect {
fill_layout(t_resources);
}
PanelLayout PanelLayout::red_empty_layout(SharedResources& t_resources) {
PanelLayout PanelLayout::red_empty_layout(ScreenResources& t_resources) {
std::vector<std::shared_ptr<Panel>> panels;
for (size_t i = 0; i < 3*4; i++) {
panels.emplace_back(std::make_shared<ColoredMessagePanel>(t_resources, sf::Color::Red, "- EMPTY -"));
@ -58,7 +58,7 @@ namespace MusicSelect {
return PanelLayout{panels, t_resources};
}
PanelLayout PanelLayout::title_sort(const Data::SongList& song_list, SharedResources& t_resources) {
PanelLayout PanelLayout::title_sort(const Data::SongList& song_list, ScreenResources& t_resources) {
std::vector<std::shared_ptr<const Data::Song>> songs;
for (auto &&song : song_list.songs) {
songs.push_back(song);
@ -90,7 +90,7 @@ namespace MusicSelect {
return PanelLayout{categories, t_resources};
}
void PanelLayout::fill_layout(SharedResources& t_resources) {
void PanelLayout::fill_layout(ScreenResources& t_resources) {
while (size() < 4) {
push_back({
std::make_shared<EmptyPanel>(t_resources),

12
src/Screens/MusicSelect/PanelLayout.hpp
View File

@ -5,7 +5,7 @@
#include <vector>
#include "../../Data/Song.hpp"
#include "SharedResources.hpp"
#include "Resources.hpp"
namespace MusicSelect {
@ -14,14 +14,14 @@ namespace MusicSelect {
class PanelLayout : public std::vector<std::array<std::shared_ptr<Panel>,3>> {
public:
// Takes of map of category name and associated Panels, useful for all the sorted layouts
explicit PanelLayout(const std::map<std::string,std::vector<std::shared_ptr<Panel>>>& categories, SharedResources& t_resources);
explicit PanelLayout(const std::map<std::string,std::vector<std::shared_ptr<Panel>>>& categories, ScreenResources& t_resources);
// Arranges all the panels in the vector in columns of three
explicit PanelLayout(const std::vector<std::shared_ptr<Panel>>& panels, SharedResources& t_resources);
explicit PanelLayout(const std::vector<std::shared_ptr<Panel>>& panels, ScreenResources& t_resources);
// Stepmania-like empty layout with big red panels that say EMPTY
static PanelLayout red_empty_layout(SharedResources& t_resources);
static PanelLayout red_empty_layout(ScreenResources& t_resources);
// Standard title sort with categories for each letter
static PanelLayout title_sort(const Data::SongList& song_list, SharedResources& t_resources);
static PanelLayout title_sort(const Data::SongList& song_list, ScreenResources& t_resources);
private:
void fill_layout(SharedResources& t_resources);
void fill_layout(ScreenResources& t_resources);
};
}

6
src/Screens/MusicSelect/Panels/MarkerPanel.cpp
View File

@ -3,11 +3,11 @@
#include <cmath>
namespace MusicSelect {
MarkerPanel::MarkerPanel(SharedResources& t_resources, const Resources::Marker& marker) :
MarkerPanel::MarkerPanel(ScreenResources& t_resources, const Resources::Marker& marker) :
Panel(t_resources),
m_marker(marker)
{
if (resources.preferences.options.marker == m_marker.m_metadata.name) {
if (shared.preferences.options.marker == m_marker.m_metadata.name) {
select();
}
}
@ -40,7 +40,7 @@ namespace MusicSelect {
resources.selected_marker->obj.unselect();
}
resources.selected_marker.emplace(*this);
resources.preferences.options.marker = m_marker.m_metadata.name;
preferences.options.marker = m_marker.m_metadata.name;
this->selected = true;
}

2
src/Screens/MusicSelect/Panels/MarkerPanel.hpp
View File

@ -10,7 +10,7 @@
namespace MusicSelect {
class MarkerPanel final : public Panel {
public:
MarkerPanel(SharedResources& t_resources, const Resources::Marker& marker);
MarkerPanel(ScreenResources& t_resources, const Resources::Marker& marker);
void click(Ribbon&, const Input::Button&) override;
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;

18
src/Screens/MusicSelect/Panels/Panel.cpp
View File

@ -7,10 +7,10 @@
#include "../../../Toolkit/HSL.hpp"
#include "../../../Toolkit/NormalizedOrigin.hpp"
#include "../Ribbon.hpp"
#include "../SharedResources.hpp"
#include "../Resources.hpp"
namespace MusicSelect {
Panel::Panel(SharedResources& t_resources) : HoldsSharedResources(t_resources) {
Panel::Panel(ScreenResources& t_resources) : HoldsResources(t_resources) {
}
@ -42,7 +42,7 @@ namespace MusicSelect {
sf::Text category_label{
"category",
resources.fallback_font.medium,
shared.fallback_font.medium,
static_cast<unsigned int>(get_size()*0.1f)
};
category_label.setFillColor(sf::Color::White);
@ -51,7 +51,7 @@ namespace MusicSelect {
sf::Text label_text{
m_label,
resources.fallback_font.black,
shared.fallback_font.black,
static_cast<unsigned int>(get_size()*0.7f)
};
label_text.setFillColor(sf::Color::White);
@ -111,7 +111,7 @@ namespace MusicSelect {
// We should gray out the panel if the currently selected difficulty doesn't exist for this song
bool should_be_grayed_out = m_song->chart_levels.find(last_selected_chart) == m_song->chart_levels.end();
if (m_song->cover) {
auto loaded_texture = resources.covers.async_get(m_song->folder/m_song->cover.value());
auto loaded_texture = shared.covers.async_get(m_song->folder/m_song->cover.value());
if (loaded_texture) {
sf::Sprite cover{*(loaded_texture->texture)};
auto alpha = static_cast<std::uint8_t>(
@ -134,7 +134,7 @@ namespace MusicSelect {
chart_dif_badge.setFillColor(sf::Color(128,128,128));
} else {
chart_dif_badge.setFillColor(
resources.get_chart_color(last_selected_chart)
shared.get_chart_color(last_selected_chart)
);
}
target.draw(chart_dif_badge, states);
@ -142,7 +142,7 @@ namespace MusicSelect {
auto dif = m_song->chart_levels.at(last_selected_chart);
sf::Text dif_label{
std::to_string(dif),
resources.fallback_font.black,
shared.fallback_font.black,
static_cast<unsigned int>(get_size()*0.15f)
};
dif_label.setFillColor(sf::Color::White);
@ -151,7 +151,7 @@ namespace MusicSelect {
target.draw(dif_label, states);
}
sf::Text song_title;
song_title.setFont(resources.fallback_font.medium);
song_title.setFont(shared.fallback_font.medium);
song_title.setString(sf::String::fromUtf8(m_song->title.begin(), m_song->title.end()));
song_title.setCharacterSize(static_cast<unsigned int>(0.06875f*get_size()));
song_title.setFillColor(sf::Color::White);
@ -181,7 +181,7 @@ namespace MusicSelect {
target.draw(frame, states);
sf::Text message;
message.setFont(resources.fallback_font.medium);
message.setFont(shared.fallback_font.medium);
message.setString(sf::String::fromUtf8(m_message.begin(), m_message.end()));
message.setCharacterSize(static_cast<unsigned int>(0.1f*get_size()));
message.setFillColor(m_color);

15
src/Screens/MusicSelect/Panels/Panel.hpp
View File

@ -9,8 +9,7 @@
#include "../../../Input/Buttons.hpp"
#include "../../../Data/Song.hpp"
#include "../../../Toolkit/AffineTransform.hpp"
#include "../DensityGraph.hpp"
#include "../SharedResources.hpp"
#include "../Resources.hpp"
namespace MusicSelect {
@ -18,9 +17,9 @@ namespace MusicSelect {
// A Panel holds anything that can go under a button on the moving part
// of the music select screen, be it nothing, a category indicator, or a song
class Panel : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class Panel : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
explicit Panel(SharedResources& t_resources);
explicit Panel(ScreenResources& t_resources);
// What happens when you click on the panel
virtual void click(Ribbon& ribbon, const Input::Button& button) = 0;
virtual ~Panel() = default;
@ -38,7 +37,7 @@ namespace MusicSelect {
class ColoredMessagePanel final : public Panel {
public:
ColoredMessagePanel(SharedResources& t_resources, const sf::Color& color, const std::string& message) : Panel(t_resources), m_color(color), m_message(message) {};
ColoredMessagePanel(ScreenResources& t_resources, const sf::Color& color, const std::string& message) : Panel(t_resources), m_color(color), m_message(message) {};
void click(Ribbon&, const Input::Button&) override {return;};
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
@ -48,7 +47,7 @@ namespace MusicSelect {
class ColorPanel final : public Panel {
public:
ColorPanel(SharedResources& t_resources, const sf::Color& t_color) : Panel(t_resources), m_color(t_color) {};
ColorPanel(ScreenResources& t_resources, const sf::Color& t_color) : Panel(t_resources), m_color(t_color) {};
void click(Ribbon&, const Input::Button&) override {return;};
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
@ -57,7 +56,7 @@ namespace MusicSelect {
class CategoryPanel final : public Panel {
public:
CategoryPanel(SharedResources& t_resources, const std::string& t_label) : Panel(t_resources), m_label(t_label) {};
CategoryPanel(ScreenResources& t_resources, const std::string& t_label) : Panel(t_resources), m_label(t_label) {};
void click(Ribbon& ribbon, const Input::Button& button) override;
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
@ -74,7 +73,7 @@ namespace MusicSelect {
class SongPanel final : public SelectablePanel {
public:
explicit SongPanel(SharedResources& t_resources, const std::shared_ptr<const Data::Song>& t_song) : SelectablePanel(t_resources), m_song(t_song) {};
explicit SongPanel(ScreenResources& t_resources, const std::shared_ptr<const Data::Song>& t_song) : SelectablePanel(t_resources), m_song(t_song) {};
void click(Ribbon& ribbon, const Input::Button& button) override;
void unselect() override;
std::optional<Data::SongDifficulty> get_selected_difficulty() const override;

2
src/Screens/MusicSelect/Panels/SubpagePanel.cpp
View File

@ -19,7 +19,7 @@ namespace MusicSelect {
target.draw(frame, states);
sf::Text message;
message.setFont(resources.fallback_font.medium);
message.setFont(shared.fallback_font.medium);
message.setString(sf::String::fromUtf8(m_name.begin(), m_name.end()));
message.setCharacterSize(static_cast<unsigned int>(0.1f*get_size()));
message.setFillColor(sf::Color::White);

2
src/Screens/MusicSelect/Panels/SubpagePanel.hpp
View File

@ -13,7 +13,7 @@ namespace MusicSelect {
class SubpagePanel final : public Panel {
public:
SubpagePanel(
SharedResources& t_resources,
ScreenResources& t_resources,
std::shared_ptr<OptionPage> subpage,
const std::string& name
) :

31
src/Screens/MusicSelect/Resources.cpp Normal file
View File

@ -0,0 +1,31 @@
#include "Resources.hpp"
#include "Panels/Panel.hpp"
namespace MusicSelect {
std::string ScreenResources::get_last_selected_difficulty() {
return get_selected_difficulty().value_or("BSC");
}
std::optional<std::string> ScreenResources::get_selected_difficulty() {
if (not selected_panel.has_value()) {
return {};
}
auto chart_selection = selected_panel->obj.get_selected_difficulty();
if (not chart_selection.has_value()) {
return {};
}
return chart_selection->difficulty;
}
std::optional<std::reference_wrapper<const Data::Song>> ScreenResources::get_selected_song() {
if (not selected_panel.has_value()) {
return {};
}
auto chart_selection = selected_panel->obj.get_selected_difficulty();
if (not chart_selection.has_value()) {
return {};
}
return chart_selection->song;
}
}

32
src/Screens/MusicSelect/Resources.hpp Normal file
View File

@ -0,0 +1,32 @@
#pragma once
#include "../../Resources/SharedResources.hpp"
#include "MusicPreview.hpp"
namespace MusicSelect {
class SelectablePanel;
class MarkerPanel;
class OptionPage;
struct ScreenResources : Resources::HoldsSharedResources {
ScreenResources(Resources::SharedResources& r) : Resources::HoldsSharedResources(r) {}
std::optional<Resources::Timed<SelectablePanel>> selected_panel;
std::string get_last_selected_difficulty();
std::optional<std::string> get_selected_difficulty();
std::optional<std::reference_wrapper<const Data::Song>> get_selected_song();
MusicPreview music_preview;
std::vector<std::reference_wrapper<OptionPage>> options_state;
std::optional<Resources::Timed<MarkerPanel>> selected_marker;
};
// Proxy for HoldsPreferences
struct HoldsResources : Resources::HoldsSharedResources {
HoldsResources(ScreenResources& t_resources) : Resources::HoldsSharedResources(t_resources.shared), resources(t_resources) {};
ScreenResources& resources;
};
}

4
src/Screens/MusicSelect/Ribbon.cpp
View File

@ -65,8 +65,8 @@ namespace MusicSelect {
return clock.getElapsedTime() / m_time_factor > sf::milliseconds(300);
}
Ribbon::Ribbon(PanelLayout layout, SharedResources& t_resources) :
HoldsSharedResources(t_resources),
Ribbon::Ribbon(PanelLayout layout, ScreenResources& t_resources) :
HoldsResources(t_resources),
m_layout(layout),
left_button(t_resources),
right_button(t_resources)

6
src/Screens/MusicSelect/Ribbon.hpp
View File

@ -11,7 +11,7 @@
#include "../../Toolkit/AffineTransform.hpp"
#include "../../Toolkit/Debuggable.hpp"
#include "../../Toolkit/EasingFunctions.hpp"
#include "SharedResources.hpp"
#include "Resources.hpp"
#include "PanelLayout.hpp"
#include "Drawables/ControlPanels.hpp"
@ -39,9 +39,9 @@ namespace MusicSelect {
// A Ribbon is a visual representation of a PanelLayout,
// You can scroll it using the left and right buttons
class Ribbon : public sf::Drawable, public sf::Transformable, public HoldsSharedResources, public Toolkit::Debuggable {
class Ribbon : public sf::Drawable, public sf::Transformable, public HoldsResources, public Toolkit::Debuggable {
public:
Ribbon(PanelLayout layout, SharedResources& t_resources);
Ribbon(PanelLayout layout, ScreenResources& t_resources);
std::shared_ptr<Panel>& get_panel_under_button(const Input::Button& button);
void click_on(const Input::Button& button);
void move_right();

28
src/Screens/MusicSelect/SongInfo.cpp
View File

@ -12,8 +12,8 @@
namespace MusicSelect {
BigCover::BigCover(SharedResources& t_resources) :
HoldsSharedResources(t_resources)
BigCover::BigCover(ScreenResources& t_resources) :
HoldsResources(t_resources)
{
m_cover_fallback.setFillColor(sf::Color::Transparent);
m_cover_fallback.setOutlineThickness(1.f);
@ -36,7 +36,7 @@ namespace MusicSelect {
if (not cover_path.has_value()) {
return;
}
auto cover_texture = resources.covers.async_get(*cover_path);
auto cover_texture = shared.covers.async_get(*cover_path);
if (not cover_texture.has_value()) {
return;
}
@ -52,8 +52,8 @@ namespace MusicSelect {
target.draw(cover, states);
}
SongInfo::SongInfo(SharedResources& t_resources) :
HoldsSharedResources(t_resources),
SongInfo::SongInfo(ScreenResources& t_resources) :
HoldsResources(t_resources),
m_big_cover(resources)
{}
@ -81,7 +81,7 @@ namespace MusicSelect {
if (not song_title.empty()) {
sf::Text song_title_label{
sf::String::fromUtf8(song_title.begin(), song_title.end()),
resources.fallback_font.medium,
shared.fallback_font.medium,
static_cast<unsigned int>(
0.026315789f*get_screen_width()
)
@ -101,7 +101,7 @@ namespace MusicSelect {
if (not song_artist.empty()) {
sf::Text song_artist_label{
sf::String::fromUtf8(song_artist.begin(), song_artist.end()),
resources.fallback_font.medium,
shared.fallback_font.medium,
static_cast<unsigned int>(
0.02f*get_screen_width()
)
@ -132,7 +132,7 @@ namespace MusicSelect {
}
sf::Text level_label{
"LEVEL",
resources.fallback_font.light,
shared.fallback_font.light,
static_cast<unsigned int>(12.f/768.f*get_screen_width())
};
Toolkit::set_origin_normalized(level_label, 0.5f, 0.f);
@ -142,7 +142,7 @@ namespace MusicSelect {
sf::Text level_number_label{
std::to_string(selected_chart->song.chart_levels.at(selected_chart->difficulty)),
resources.fallback_font.black,
shared.fallback_font.black,
static_cast<unsigned int>(130.f/768.f*get_screen_width())
};
Toolkit::set_origin_normalized(level_number_label, 0.5f, 0.f);
@ -161,12 +161,12 @@ namespace MusicSelect {
sf::Text chart_label{
sf::String::fromUtf8(full_difficulty.begin(), full_difficulty.end()),
resources.fallback_font.medium,
shared.fallback_font.medium,
static_cast<unsigned int>(20.f/768.f*get_screen_width())
};
Toolkit::set_origin_normalized_no_position(chart_label, 0.5f, 0.f);
chart_label.setPosition(get_big_level_x(), get_big_level_y()+(145.f/768.f*get_screen_width()));
chart_label.setFillColor(resources.get_chart_color(selected_chart->difficulty));
chart_label.setFillColor(shared.get_chart_color(selected_chart->difficulty));
target.draw(chart_label, states);
}
@ -187,7 +187,7 @@ namespace MusicSelect {
for (auto &&[difficulty, level] : selected_chart->song.chart_levels) {
sf::CircleShape dif_badge{dif_badge_radius};
Toolkit::set_origin_normalized(dif_badge, 0.5f, 0.5f);
dif_badge.setFillColor(resources.get_chart_color(difficulty));
dif_badge.setFillColor(shared.get_chart_color(difficulty));
dif_badge.setPosition(dif_badge_x+dif_index*dif_badge_step, dif_badge_y);
target.draw(dif_badge, states);
if (difficulty == selected_chart->difficulty) {
@ -229,8 +229,8 @@ namespace MusicSelect {
if (not selected_difficulty.has_value()) {
return;
}
resources.density_graphs.load(*selected_difficulty);
auto densities = resources.density_graphs.get(*selected_difficulty);
shared.density_graphs.load(*selected_difficulty);
auto densities = shared.density_graphs.get(*selected_difficulty);
if (not densities.has_value()) {
return;
}

10
src/Screens/MusicSelect/SongInfo.hpp
View File

@ -5,13 +5,13 @@
#include "../../Toolkit/AffineTransform.hpp"
#include "SharedResources.hpp"
#include "Resources.hpp"
namespace MusicSelect {
class BigCover : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class BigCover : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
BigCover(SharedResources& t_resources);
BigCover(ScreenResources& t_resources);
float get_size() const {return preferences.layout.big_cover_size*get_screen_width();};
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
@ -20,9 +20,9 @@ namespace MusicSelect {
};
// Displays the song info on the top part of the screen
class SongInfo : public sf::Drawable, public sf::Transformable, public HoldsSharedResources {
class SongInfo : public sf::Drawable, public sf::Transformable, public HoldsResources {
public:
SongInfo(SharedResources& t_resources);
SongInfo(ScreenResources& t_resources);
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
void draw_song_title(sf::RenderTarget& target, sf::RenderStates states) const;