m_bWasSeekFrame = true;

             } else {

                 m_music->setPositionMS_fast(m_selectedDifficulty2->getPreviewTime() < 0

                 m_bWasSeekFrame = true;

             }

         // all remaining clicks which have not been consumed by any hitobjects can safely be deleted

         if(m_clicks.size() > 0) {

             // nightmare mod: extra clicks = sliderbreak

             if((osu->getModNightmare() || osu_mod_jigsaw1.getBool()) && !m_bIsInSkippableSection && !m_bInBreak &&

     CHANGELOG latest;

     latest.title =

         UString::format("%.2f (%s, %s)", convar->getConVarByName("osu_version")->getFloat(), __DATE__, __TIME__);

     changelogs.push_back(latest);

     CHANGELOG v35_08;

     v35_08.title = "35.08 (2024-06-28)";

     v35_08.changes.push_back("- Added ability to import .osk and .osz files (drop them onto the neosu window)");

     v35_08.changes.push_back("- Added skin folder");

     v35_08.changes.push_back("- Now publishing 32-bit releases (for PCs running Windows 7)");

     v35_08.changes.push_back("- Fixed songs failing to restart");

         const Vector2 osuCoords = m_beatmap->pixels2OsuCoords(m_beatmap->osuCoords2Pixels(m_vRawPos));

         m_fHitAnimation = 0.001f;  // quickfix for 1 frame missing images

         anim->moveQuadOut(&m_fHitAnimation, 1.0f, GameRules::getFadeOutTime(m_beatmap), true);

         m_db->loadStars();

         // load database

         std::string osuDbFilePath = osu_folder.getString().toUtf8();

         osuDbFilePath.append("osu!.db");

         Packet db = load_db(osuDbFilePath);

             m_bDidScoresChangeForSave = true;

             m_bDidScoresChangeForStats = true;

             break;

         }

     }

     m_importTimer->start();

     bool should_read_peppy_database = db->size > 0;

     if(should_read_peppy_database) {

         // read header

         auto playerName = read_stdstring(db);

         m_iNumBeatmapsToLoad = read<u32>(db);

         if(m_iVersion < 20170222) {

             debugLog("Database: Version is quite old, below 20170222 ...\n");

             should_read_peppy_database = false;

         } else if(!osu_database_ignore_version_warnings.getBool()) {

             if(m_iVersion < 20190207) {  // xexxar angles star recalc

             }

         }

         // hard cap upper db version

         if(m_iVersion > osu_database_version.getInt() && !osu_database_ignore_version.getBool()) {

             osu->getNotificationOverlay()->addNotification(

             should_read_peppy_database = false;

         }

     }

             if(m_iVersion < 20191107)  // see https://osu.ppy.sh/home/changelog/stable40/20191107.2

             {

                 // also see https://github.com/ppy/osu-wiki/commit/b90f312e06b4f86e509b397565f1fe014bb15943

                 /*unsigned int size = */ read<u32>(db);  // size in bytes of the beatmap entry

             }

             double sliderMultiplier = read<f64>(db);

             unsigned int numOsuStandardStarRatings = read<u32>(db);

             float numOsuStandardStars = 0.0f;

             for(int s = 0; s < numOsuStandardStarRatings; s++) {

                 read<u8>(db);  // ObjType

                 unsigned int mods = read<u32>(db);

                 read<u8>(db);  // ObjType

                 double starRating = read<f64>(db);

                 if(mods == 0) numOsuStandardStars = starRating;

             }

             unsigned int numTaikoStarRatings = read<u32>(db);

             for(int s = 0; s < numTaikoStarRatings; s++) {

                 read<u8>(db);  // ObjType

                 read<u32>(db);

             }

             unsigned int numCtbStarRatings = read<u32>(db);

             for(int s = 0; s < numCtbStarRatings; s++) {

                 read<u8>(db);  // ObjType

                 read<u32>(db);

             }

             unsigned int numManiaStarRatings = read<u32>(db);

             for(int s = 0; s < numManiaStarRatings; s++) {

                 read<u8>(db);  // ObjType

                 read<u32>(db);

             duration = duration >= 0 ? duration : 0;      // sanity clamp

             int previewTime = read<u32>(db);

             unsigned int numTimingPoints = read<u32>(db);

             zarray<TIMINGPOINT> timingPoints(numTimingPoints);

             read_bytes(db, (u8 *)timingPoints.data(), sizeof(TIMINGPOINT) * numTimingPoints);

             int beatmapSetID = read<i32>(db);  // same here

             /*unsigned int threadID = */ read<u32>(db);

             /*unsigned char taikoGrade = */ read<u8>(db);

             /*unsigned char ctbGrade = */ read<u8>(db);

             /*unsigned char maniaGrade = */ read<u8>(db);

             short localOffset = read<u16>(db);

             float stackLeniency = read<f32>(db);

             unsigned char mode = read<u8>(db);

             auto songSource = read_stdstring(db);

             auto songTags = read_stdstring(db);

             trim(&songSource);

             trim(&songTags);

             short onlineOffset = read<u16>(db);

             skip_string(db);  // song title font

             trim(&path);

             /*long long lastOnlineCheck = */ read<u64>(db);

             /*bool ignoreBeatmapSounds = */ read<u8>(db);

             /*bool ignoreBeatmapSkin = */ read<u8>(db);

             /*bool visualOverride = */ read<u8>(db);

             /*int lastEditTime = */ read<u32>(db);

             /*unsigned char maniaScrollSpeed = */ read<u8>(db);

             if(env->getOS() == Environment::OS::LINUX || env->getOS() == Environment::OS::MACOS) {

                 for(int c = 0; c < path.length(); c++) {

                     if(path[c] == '\\') {

             fullFilePath.append(osuFileName);

             // skip invalid/corrupt entries

             if(artistName.length() < 1 && songTitle.length() < 1 && creatorName.length() < 1 &&

                difficultyName.length() < 1 && md5hash.hash[0] == 0)

                 continue;

                 s.diffs2->push_back(diff2);

                 beatmapSets.push_back(s);

             }

         }

         // build beatmap sets

             mapset_path.append(std::to_string(set_id));

             mapset_path.append("/");

             for(u16 j = 0; j < nb_diffs; j++) {

                 std::string osu_filename = read_stdstring(&neosu_maps);

                 }

                 diffs->push_back(diff);

             }

             if(diffs->empty()) {

         m_neosu_maps_loaded = true;

     }

     m_importTimer->update();

     // signal that we are done

     m_fLoadingProgress = 1.0f;

                             sc.server = read_stdstring(&db);

                         }

                         sc.experimentalModsConVars = read_stdstring(&db);

                         if(gamemode == 0x0 || (dbVersion > 20210103 && sc.version > 20190103)) {

                 write_string(&db, score.server.c_str());

             }

             write_string(&db, score.experimentalModsConVars.c_str());

         }

     }

             g->pushTransform();

             {

                 g->rotate(90);

                 g->setColor(0xff777777);

                 g->setAlpha(1.0f - m_fExperimentalAnimation * m_fExperimentalAnimation);

                 g->drawString(experimentalFont, experimentalText);

             {

                 g->rotate(90);

                 g->translate((int)(rectHeight + max(0.0f, experimentalModsAnimationTranslation +

                              (int)(osu->getScreenHeight() / 2 - rectWidth / 2));

                 g->drawRect(0, 0, rectWidth, rectHeight);

             }

     }

 }

 ModSelection ModSelector::getModSelection() {

     ModSelection selection;

     // Reset buttons and sliders to clean state

     resetMods();

     // Override sliders

     for(int i = 0; i < m_overrideSliders.size(); i++) {

         if(m_overrideSliders[i].lock != NULL) {

         }

     }

 }

 void ModSelector::enableModsFromFlags(u32 flags) {

     hitResultScaleSlider->setKeyDelta(0.01f);

     addCheckbox("Draw Numbers", convar->getConVarByName("osu_draw_numbers"));

     addCheckbox("Draw Approach Circles", convar->getConVarByName("osu_draw_approach_circles"));

     addSpacer();

     addCheckbox("Ignore Beatmap Sample Volume",

                 "Ignore beatmap timingpoint effect volumes.\nQuiet hitsounds can destroy accuracy and concentration, "

 // release configuration

 ConVar auto_update("auto_update", true, FCVAR_DEFAULT);

 #ifdef _DEBUG

 ConVar osu_debug("osu_debug", true, FCVAR_DEFAULT);

 ConVar restart_sound_engine_before_playing("restart_sound_engine_before_playing", false, FCVAR_DEFAULT,

                                            "jank fix for users who experience sound issues after playing for a while");

 ConVar instafade("instafade", false, FCVAR_DEFAULT, "don't draw hitcircle fadeout animations");

 ConVar sort_skins_by_name("sort_skins_by_name", true, FCVAR_DEFAULT, "set to false to use old behavior");

 ConVar use_https("use_https", true, FCVAR_DEFAULT);

 // If catboy.best doesn't work for you, here are some alternatives:

 // - https://api.osu.direct/d/

 // - https://api.nerinyan.moe/d/

 // - https://osu.gatari.pw/d/

 // - https://osu.sayobot.cn/osu.php?s=

         if(newValue.length() < 1) return;

     }

     std::string neosuSkinFolder = MCENGINE_DATA_DIR "skins/";

     neosuSkinFolder.append(newValue.toUtf8());

     neosuSkinFolder.append("/");

     if(env->directoryExists(neosuSkinFolder)) {

     } else {

         UString ppySkinFolder = m_osu_folder_ref->getString();

         ppySkinFolder.append(m_osu_folder_sub_skins_ref->getString());

         ppySkinFolder.append(newValue);

         ppySkinFolder.append("/");

         std::string sf = ppySkinFolder.toUtf8();

     }

     // initial load

 #include <string.h>

 #include "Beatmap.h"

 #include "ConVar.h"

 #include "Engine.h"

 #include "SkinImage.h"

 #include "SoundEngine.h"

 #include "VolumeOverlay.h"

 using namespace std;

 ConVar osu_ignore_beatmap_combo_colors("osu_ignore_beatmap_combo_colors", false, FCVAR_DEFAULT);

 ConVar osu_ignore_beatmap_sample_volume("osu_ignore_beatmap_sample_volume", false, FCVAR_DEFAULT);

 Image *Skin::m_missingTexture = NULL;

 ConVar *Skin::m_osu_skin_async = &osu_skin_async;

 ConVar *Skin::m_osu_skin_ref = NULL;

 ConVar *Skin::m_osu_mod_fposu_ref = NULL;

     auto skin_name = env->getFileNameFromFilePath(filepath);

     debugLog("Extracting %s...\n", skin_name.c_str());

     auto skin_root = std::string(MCENGINE_DATA_DIR "skins/");

     skin_root.append(skin_name);

     if(m_missingTexture == NULL) m_missingTexture = engine->getResourceManager()->getImage("MISSING_TEXTURE");

     // vars

     m_hitCircle = m_missingTexture;

     m_approachCircle = m_missingTexture;

     m_spinnerBonus = NULL;

     m_spinnerSpinSound = NULL;

     m_combobreak = NULL;

     m_failsound = NULL;

     m_applause = NULL;

     // skin ini

     randomizeFilePath();

     m_sSkinIniFilePath = m_sFilePath;

     m_sSkinIniFilePath.append("skin.ini");

     bool parseSkinIni1Status = true;

     bool parseSkinIni2Status = true;

     if(!parseSkinINI(m_sSkinIniFilePath)) {

         parseSkinIni1Status = false;

         parseSkinIni2Status = parseSkinINI(m_sSkinIniFilePath);

     }

     checkLoadSound(&m_spinnerBonus, "spinnerbonus", "OSU_SKIN_SPINNERBONUS_SND", true, true);

     checkLoadSound(&m_spinnerSpinSound, "spinnerspin", "OSU_SKIN_SPINNERSPIN_SND", false, true, true);

     // others

     checkLoadSound(&m_combobreak, "combobreak", "OSU_SKIN_COMBOBREAK_SND", true, true);

     checkLoadSound(&m_failsound, "failsound", "OSU_SKIN_FAILSOUND_SND");

 void Skin::setBeatmapComboColors(std::vector<Color> colors) { m_beatmapComboColors = colors; }

     if(m_iSampleVolume <= 0) {

         return;

     }

         pan *= osu_sound_panning_multiplier.getFloat();

     }

     int actualSampleSet = m_iSampleSet;

     if(osu_skin_force_hitsound_sample_set.getInt() > 0) actualSampleSet = osu_skin_force_hitsound_sample_set.getInt();

     // NOTE: only the default skin is loaded with a resource name (it must never be unloaded by other instances), and it

     // is NOT added to the resources vector

     defaultFilePath1.append(skinElementName);

     defaultFilePath1.append("@2x.");

     defaultFilePath1.append(fileExtension);

     defaultFilePath2.append(skinElementName);

     defaultFilePath2.append(".");

     defaultFilePath2.append(fileExtension);

             std::string path = base_path;

             path.append(fn);

             if(env->fileExists(path)) {

                 if(osu_skin_async.getBool()) {

             }

         }

         return (Sound *)NULL;

     };

     // load default skin

     if(fallback_to_default) {

         std::string defaultResourceName = resourceName;

         defaultResourceName.append("_DEFAULT");

         *addressOfPointer = try_load_sound(defaultpath, skinElementName, defaultResourceName, loop);

 class Skin {

    public:

     static ConVar *m_osu_skin_async;

     static ConVar *m_osu_skin_hd;

     void setSampleVolume(float volume, bool force = false);

     void resetSampleVolume();

     void playSliderTickSound(float pan = 0.0f);

     void playSliderSlideSound(float pan = 0.0f);

     void playSpinnerSpinSound();

     Sound *m_spinnerBonus;

     Sound *m_spinnerSpinSound;

     // Plays when sending a message in chat

     Sound *m_messageSent = NULL;

     filepath2.append(skinElementName);

     filepath2.append(".png");

     defaultFilePath1.append(skinElementName);

     defaultFilePath1.append("@2x.png");

     defaultFilePath2.append(skinElementName);

     defaultFilePath2.append(".png");

 ConVar osu_slider_reverse_arrow_animated("osu_slider_reverse_arrow_animated", true, FCVAR_DEFAULT,

                                          "pulse animation on reverse arrows");

 ConVar osu_slider_reverse_arrow_alpha_multiplier("osu_slider_reverse_arrow_alpha_multiplier", 1.0f, FCVAR_DEFAULT);

 ConVar *Slider::m_osu_playfield_mirror_horizontal_ref = NULL;

 ConVar *Slider::m_osu_playfield_mirror_vertical_ref = NULL;

     }

     // slider body fade animation, draw start/end circle hit animation

        !osu->getModHD()) {

         std::vector<Vector2> emptyVector;

         std::vector<Vector2> alwaysPoints;

                                  1.0f - m_fEndSliderBodyFadeAnimation, getTime());

     }

        m_fStartHitAnimation != 1.0f && !osu->getModHD()) {

         float alpha = 1.0f - m_fStartHitAnimation;

         g->popTransform();

     }

         float alpha = 1.0f - m_fEndHitAnimation;

         float scale = m_fEndHitAnimation;

             const Vector2 osuCoords = m_beatmap->pixels2OsuCoords(m_beatmap->osuCoords2Pixels(m_vCurPointRaw));

             m_beatmap->getSkin()->playHitCircleSound(m_iCurRepeatCounterForHitSounds < m_hitSounds.size()

                                                          ? m_hitSounds[m_iCurRepeatCounterForHitSounds]

                                                          : m_iSampleType,

             if(!startOrEnd) {

                 m_fStartHitAnimation = 0.001f;  // quickfix for 1 frame missing images

         m_beatmap->getSkin()->playHitCircleSound(m_iCurRepeatCounterForHitSounds < m_hitSounds.size()

                                                      ? m_hitSounds[m_iCurRepeatCounterForHitSounds]

                                                      : m_iSampleType,

         float animation_multiplier = osu->getSpeedMultiplier() / osu->getAnimationSpeedMultiplier();

         float tick_pulse_time = GameRules::osu_slider_followcircle_tick_pulse_time.getFloat() * animation_multiplier;

     // having a copy of the vector in here is actually completely unnecessary

     m_beatmaps = std::vector<DatabaseBeatmap *>(m_db->getDatabaseBeatmaps());

     // initialize all collection (grouped) buttons

     {

         const Vector2 osuCoords = m_beatmap->pixels2OsuCoords(m_beatmap->osuCoords2Pixels(m_vRawPos));

     }

     // add it, and we are finished

 class LiveScore {

    public:

     enum class HIT {

         // score