Packet packet;

     write_bytes(&packet, (u8 *)bancho.username.toUtf8(), bancho.username.lengthUtf8());

     write_bytes(&packet, (u8 *)bancho.pw_md5.hash, 32);

     write_bytes(&packet, (u8 *)OSU_VERSION, strlen(OSU_VERSION));

     // UTC offset

     time_t now = time(NULL);

     auto local_time = localtime(&now);

     int utc_offset = difftime(mktime(local_time), mktime(gmt)) / 3600;

     if(utc_offset < 0) {

         utc_offset *= -1;

     }

     // Don't dox the user's city

     char osu_path[PATH_MAX] = {0};

 #ifdef _WIN32

     write_bytes(&packet, (u8 *)bancho.client_hashes.toUtf8(), bancho.client_hashes.lengthUtf8());

     // Allow PMs from strangers

     return packet;

 }

     // This is a blocking call, but we *do* want this to block when quitting the game.

     if(bancho.is_online()) {

         Packet packet;

         CURL *curl = curl_easy_init();

         auto version_header = UString::format("x-mcosu-ver: %s", bancho.neosu_version.toUtf8());

     last_packet_tms = time(NULL);

     CURL *curl = curl_easy_init();

     if(!curl) {

         debugLog("Failed to initialize cURL, online functionality disabled.\n");

             free(login.memory);

             pthread_mutex_lock(&outgoing_mutex);

         } else if(should_ping && outgoing.pos == 0) {

             // Polling gets slower over time, but resets when we receive new data

             if(seconds_between_pings < 30.0) {

             // DEBUG: If we're not sending the right amount of bytes, bancho.py just

             // chugs along! To try to detect it faster, we'll send two packets per request.

             send_bancho_packet(curl, out);

             free(out.memory);

     // We're not sending it immediately, instead we just add it to the pile of

     // packets to send

     write_bytes(&outgoing, packet.memory, packet.pos);

     pthread_mutex_unlock(&outgoing_mutex);

 }

 void Room::pack(Packet *packet) {

     write_string(packet, name.toUtf8());

     write_string(packet, password.toUtf8());

     write_string(packet, map_name.toUtf8());

     write_string(packet, map_md5.toUtf8());

     for(int i = 0; i < 16; i++) {

     }

     for(int i = 0; i < 16; i++) {

     }

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

         if(slots[s].has_player()) {

         }

     }

     if(freemods) {

         for(int i = 0; i < 16; i++) {

         }

     }

 }

 bool Room::is_host() { return host_id == bancho.user_id; }

 void write_bytes(Packet *packet, u8 *bytes, size_t n) {

     if(packet->pos + n > packet->size) {

         if(!packet->memory) return;

     }

     packet->pos += n;

 }

 void write_uleb128(Packet *packet, u32 num) {

     if(num == 0) {

         u8 zero = 0;

         return;

     }

         if(num != 0) {

             next |= 0x80;

         }

     }

 }

 void write_string(Packet *packet, const char *str) {

     if(!str || str[0] == '\0') {

         u8 zero = 0;

         return;

     }

     u8 empty_check = 11;

     u32 len = strlen(str);

     write_uleb128(packet, len);

     write_bytes(packet, (u8 *)str, len);

 }

     size_t pos = 0;

     u8 *extra = nullptr;

     u32 extra_int = 0;  // lazy

 };

 struct Slot {

 }

 void write_bytes(Packet *packet, u8 *bytes, size_t n);

 void write_uleb128(Packet *packet, u32 num);

 void write_string(Packet *packet, const char *str);

 template <typename T>

 void write(Packet *packet, T t) {

     if(packet->pos + sizeof(T) > packet->size) {

         if(!packet->memory) return;

     }

 void Beatmap::unloadMusic() {

     if(m_osu->getInstanceID() < 2) {

         engine->getResourceManager()->destroyResource(m_music);

     }

 }

 void Beatmap::unloadObjects() {

             write_string(&packet, (char *)bancho.username.toUtf8());

             write_string(&packet, (char *)m_input_box->getText().toUtf8());

             write_string(&packet, (char *)m_selected_channel->name.toUtf8());

             send_packet(packet);

             // Server doesn't echo the message back

     const double startTime = engine->getTimeReal();

     Packet db;

     u32 nb_collections = collections.size();

     for(auto collection : collections) {

         write_string(&db, collection->name.c_str());

         u32 nb_deleted = collection->deleted_maps.size();

         for(auto map : collection->deleted_maps) {

             write_string(&db, map.hash);

         }

         u32 nb_neosu = collection->neosu_maps.size();

         for(auto map : collection->neosu_maps) {

             write_string(&db, map.hash);

         }

             m_toCleanup.swap(m_db->m_databaseBeatmaps);

             m_db->m_databaseBeatmaps.clear();

             m_db->loadDB(&db, m_bNeedRawLoad);

             m_bNeedRawLoad = true;

         m_bAsyncReady = true;

     }

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

         delete m_scoreSortingMethods[i].comparator;

     }

 }

 void Database::update() {

 void Database::saveStars() {

     debugLog("Osu: Saving stars ...\n");

     i64 numStarsCacheEntries = 0;

     for(DatabaseBeatmap *beatmap : m_databaseBeatmaps) {

     // write

     Packet cache;

     write_string(&cache, "00000000000000000000000000000000");

     for(DatabaseBeatmap *beatmap : m_databaseBeatmaps) {

         for(DatabaseBeatmap *diff2 : beatmap->getDifficulties()) {

             write<i32>(&cache, diff2->getMinBPM());

             write<i32>(&cache, diff2->getMaxBPM());

             write<i32>(&cache, diff2->getMostCommonBPM());

     }

     free(cache.memory);

 }

 void Database::loadScores() {

     // write header

     Packet db;

     // write scores for each beatmap

     for(auto &beatmap : m_scores) {

         if(numNonLegacyScores == 0) continue;

         write_string(&db, beatmap.first.hash);  // beatmap md5 hash

         for(auto &score : beatmap.second) {

             if(score.isLegacyScore) continue;

             u8 gamemode = 0;

             if(score.version > 20190103 && score.isImportedLegacyScore) gamemode = hackIsImportedLegacyScoreFlag;

             // default

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

             // custom

             if(score.version > 20180722) {

             }

             if(score.version >= 20240412) {

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

             }

 void Lobby::joinRoom(u32 id, UString password) {

     Packet packet;

     packet.id = JOIN_ROOM;

     write_string(&packet, password.toUtf8());

     send_packet(packet);

 }

 MainMenu::~MainMenu() {

     SAFE_DELETE(m_updateAvailableButton);

     anim->deleteExistingAnimation(&m_fUpdateButtonAnim);

     } else {

         if(music->isFinished()) {

             selectRandomBeatmap();

             m_pauseButton->setPaused(false);

             // NOTE: We set this every frame, because music loading isn't instant

             Packet packet;

             packet.id = MATCH_CHANGE_MODS;

             send_packet(packet);

             m_osu->m_room->updateLayout(m_osu->getScreenSize());

     Packet packet;

     packet.id = CHANGE_ACTION;

     write_string(&packet, fancy_text);

     write_string(&packet, map_md5.hash);

     send_packet(packet);

 }

     Packet packet;

     packet.id = CHANGE_ACTION;

     write_string(&packet, last_status.toUtf8());

     write_string(&packet, map_md5.hash);

     send_packet(packet);

     // Servers like akatsuki send different leaderboards based on what mods

     Packet packet;

     packet.id = UPDATE_MATCH_SCORE;

     u8 slot_id = 0;

     for(u8 i = 0; i < 16; i++) {

             break;

         }

     }

     send_packet(packet);

     last_packet_tms = time(NULL);

             debugLog("Sending mod change to server.\n");

             Packet packet;

             packet.id = MATCH_CHANGE_MODS;

             send_packet(packet);

             m_osu->m_room->on_room_updated(bancho.room);

     if(user_action == UA_TRANSFER_HOST) {

         Packet packet;

         packet.id = TRANSFER_HOST;

         send_packet(packet);

     } else if(user_action == KICK) {

         Packet packet;

         packet.id = MATCH_LOCK;

         send_packet(packet);  // kick by locking the slot

         send_packet(packet);  // unlock the slot

     } else if(user_action == START_CHAT) {

     } else if(user_action == UA_ADD_FRIEND) {

         Packet packet;

         packet.id = FRIEND_ADD;

         send_packet(packet);

         friends.push_back(m_user_id);

     } else if(user_action == UA_REMOVE_FRIEND) {

         Packet packet;

         packet.id = FRIEND_REMOVE;

         send_packet(packet);

         auto it = std::find(friends.begin(), friends.end(), m_user_id);

 ConsoleBox *Engine::m_consoleBox = NULL;

 Engine::Engine(Environment *environment, const char *args) {

     engine = this;

     m_environment = environment;

     env = environment;

     if(m_bBlackout || (m_app != NULL && !m_app->onShutdown())) return;

     m_bBlackout = true;

     m_environment->shutdown();

 }

 bool SoundEngine::initializeOutputDevice(OUTPUT_DEVICE device) {

     debugLog("SoundEngine: initializeOutputDevice( %s ) ...\n", device.name.toUtf8());

     if(device.driver == OutputDriver::NONE || (device.driver == OutputDriver::BASS && device.id == 0)) {

         m_bReady = true;

     return true;

 }

     if(m_currentOutputDevice.driver == OutputDriver::BASS) {

         BASS_Free();

 #ifdef _WIN32

         BASS_ASIO_Free();

     } else if(m_currentOutputDevice.driver == OutputDriver::BASS_WASAPI) {

         BASS_WASAPI_Free();

     }

 void SoundEngine::update() {}

 class SoundEngine {

    public:

     SoundEngine();

     void restart();

     void update();