* [Node.JS LTS](https://nodejs.org/en/)

 * [Yarn](https://yarnpkg.com/)

 * [Rust](https://doc.rust-lang.org/cargo/getting-started/installation.html) (for calculating pp)

 * On Windows, [Visual Studio 2013/2015/2017/2019 with C++ Option](https://docs.microsoft.com/en-us/visualstudio/install/install-visual-studio?view=vs-2022)

 # Installation (basic)

 * [Create a new osu! API application](https://osu.ppy.sh/home/account/edit#new-oauth-application), then add the client ID and secret to `osu_v2api_client_id` and `osu_v2api_client_secret` in `config.json`.

 That's it! You should be able to run the website with `yarn start`.

 # Installation (osu!)

 * [Create a new Discord application](https://discord.com/developers/applications) and add the bot id and token to `config.json`

 * Invite the bot to your Discord server ([invite generator](https://discordapi.com/permissions.html))

 import db from './database.js';

 import {get_user_ranks} from './glicko.js';

 import Config from './util/config.js';

 async function reply(user, lobby, message) {

     }

   }

   const fancy_elo = rank_info.elo == '???' ? '???' : Math.round(rank_info.elo);

 }

 async function start_command(msg, match, lobby) {

 }

 async function about_command(msg, match, lobby) {

   if (lobby) {

   } else {

   }

 }

     "discord_linked_account_role_id": "909777665223966750",

     "HOST_WEBSITE": true,

     "IS_PRODUCTION": false,

     "ENABLE_SENTRY": false,

 import db from './database.js';

 import {sync_discord_info} from './discord_updates.js';

 import Config from './util/config.js';

 const client = new Client({intents: [Intents.FLAGS.GUILDS]});

       const res = db.prepare(`SELECT * FROM user WHERE discord_user_id = ?`).get(target.id);

       if (res) {

       } else {

         await interaction.reply({

           content: 'That user hasn\'t linked their osu! account yet.',

     components: [

       new MessageActionRow().addComponents([

         new MessageButton({

           label: 'Verify using osu!web',

           style: 'LINK',

         }),

 import db from './database.js';

 import Config from './util/config.js';

 import {get_user_by_id} from './user.js';

 const RANK_DIVISIONS = [

     const new_rank_text = get_rank_text(ratio);

     if (old_rank_text != new_rank_text) {

     }

   }

               <img class="h-8" src="/images/mode-osu.png" />

             </button>

             <div id="rulesets-dropdown" class="absolute hidden z-10 mt-4 -ml-12 bg-zinc-700 rounded-md">

                 <img class="h-8" src="/images/mode-osu.png" />

                 <span class="px-2 leading-7">osu!</span>

               </button>

                 <img class="h-8" src="/images/mode-taiko.png" />

                 <span class="px-2 leading-7">osu!taiko</span>

               </button>

                 <img class="h-8" src="/images/mode-catch.png" />

                 <span class="px-2 leading-7">osu!catch</span>

               </button>

                 <img class="h-8" src="/images/mode-mania.png" />

                 <span class="px-2 leading-7">osu!mania</span>

               </button>

             </div>

           </div>

           <a class="login-btn p-2 opacity-75 hover:opacity-100" href="/osu_login">

             <img class="h-8 rounded-full" src="/images/login.png" />

           </a>

       </div>

     </template>

   </body>

 </html>

 }

 function update_header_highlights() {

   const header_links = document.querySelectorAll('header a');

 function update_header_profile() {

   const a = document.querySelector('.login-btn');

     a.querySelector('img').src = `https://s.ppy.sh/a/${logged_user_id}`;

   } else {

     a.querySelector('img').src = `/images/login.png`;

   }

 }

 // Returns the color of a given star rating, matching osu!web's color scheme.

 function stars_to_color(sr) {

   if (sr <= 0.1) {

 document.querySelectorAll('.choose-ruleset').forEach((btn) => {

   btn.addEventListener('click', function(event) {

     event.preventDefault();

   });

 });

 function click_listener(evt) {

   // Intercept clicks that don't lead to an external domain

   if (this.host == location.host && this.target != '_blank') {

     evt.preventDefault();

       window.history.pushState({}, '', `/reopen-lobby/${lobby.match_id}`);

       route(`/reopen-lobby/${lobby.match_id}`);

     } else {

       document.location = '/osu_login';

     }

   });

     evt.stopPropagation();

     if (!token) {

       document.location = '/osu_login';

       return;

     }

   const template = document.querySelector('#lobbies-template').content.cloneNode(true);

   document.querySelector('main').appendChild(document.querySelector('#loading-template').content.cloneNode(true));

   document.querySelector('main .loading-placeholder').remove();

   if (json.open.length == 0) {

       window.history.pushState({}, '', '/create-lobby/');

       route('/create-lobby/');

     } else {

       document.location = '/osu_login';

     }

   });

   return twemoji.parse(emoji);

 }

   document.title = 'Leaderboard - o!RL';

   const template = document.querySelector('#leaderboard-template').content.cloneNode(true);

   document.querySelector('main').appendChild(document.querySelector('#loading-template').content.cloneNode(true));

   document.querySelector('main .loading-placeholder').remove();

   const lboard = template.querySelector('.leaderboard tbody');

   }

   const pagi_div = template.querySelector('.pagination');

   document.querySelector('main').appendChild(template);

 }

     'The One': 'the-one',

   };

   const template = document.querySelector('#user-template').content.cloneNode(true);

   template.querySelector('.heading-left img').src = `https://s.ppy.sh/a/${json.user_id}`;

   template.querySelector('.heading-right h1').innerHTML = get_country_flag_html(json.country_code) + ' ' + json.username;

   template.querySelector('.heading-right h1').classList.add(division_to_class[user_info.text]);

   template.querySelector('.heading-right .subheading').href = `https://osu.ppy.sh/users/${json.user_id}`;

   const blocks = template.querySelectorAll('.user-focus-block');

   if (user_info.is_ranked) {

   document.querySelector('main').appendChild(template);

   document.querySelector('main').appendChild(document.querySelector('#loading-template').content.cloneNode(true));

   document.querySelector('main .loading-placeholder').remove();

   const tbody = document.querySelector('.match-history tbody');

   }

   const pagi_div = document.querySelector('.pagination');

 }

   console.info('Loading ' + new_url);

   update_header_highlights();

   update_header_profile();

   let m;

   if (m = new_url.match(/\/create-lobby\//)) {

         document.querySelector('.lobby-creation-success').hidden = false;

         last_match_id = json_res.lobby.tournament_id;

       } catch (err) {

         document.querySelector('.lobby-creation-error .error-msg').innerText = err.message;

         document.querySelector('.lobby-creation-spinner').hidden = true;

           window.history.pushState({}, '', `/reopen-lobby/${last_match_id}`);

           route(`/reopen-lobby/${last_match_id}`);

         } else {

           document.location = '/osu_login';

         }

       });

       evt.stopPropagation();

       const lobby_settings = {

         title: document.querySelector('input[name="title"]').value,

         map_selection_algo: document.querySelector('main input[name="map-selection-type"]:checked').value,

         map_pool: document.querySelector('main input[name="map-pool"]:checked').value,

         document.querySelector('.lobby-creation-success').hidden = false;

         last_match_id = json_res.lobby.tournament_id;

       } catch (err) {

         document.querySelector('.lobby-creation-error .error-msg').innerText = err.message;

         document.querySelector('.lobby-creation-spinner').hidden = true;

   } else if (m = new_url.match(/\/lobbies\//)) {

     document.querySelector('main').innerHTML = '';

     await render_lobbies();

     document.querySelector('main').innerHTML = '';

     const user_id = m[1];

     document.querySelector('main').innerHTML = '';

     await render_user(user_id, page_num);

     const user_id = m[1];

     document.querySelector('main').innerHTML = '';

     await render_user(user_id, 1);

   } else {

     const main = document.querySelector('main');

     if (main.innerHTML.indexOf('{{ error }}') != -1) {

       main.innerHTML = 'Page not found.';

     }

   }

 // Load pages and hijack browser browsing

 route(location.pathname);

   }

 }

 export function random_from(arr) {

   return arr[Math.floor((Math.random() * arr.length))];

 }

 export const render_error = async (req, error, code, data = {}) => {

   data.error = error;

   return await Mustache.render(base, data);

 };

 import express from 'express';

 import fs from 'fs';

 import fetch from 'node-fetch';

 import morgan from 'morgan';

 import Sentry from '@sentry/node';

 import crypto from 'crypto';

 import bancho from './bancho.js';

 import db from './database.js';

 import {get_user_ranks} from './glicko.js';

 import {get_user_by_id} from './user.js';

 import Config from './util/config.js';

 import {register_routes as register_api_routes} from './website_api.js';

 async function listen() {

   const app = express();

   app.use(morgan(':status :method :url :response-time ms (:remote-addr)'));

   app.enable('trust proxy');

   app.set('trust proxy', () => true);

   await register_api_routes(app);

   // Convenience redirect so we only have to generate the oauth URL here.

   app.get('/osu_login', (req, http_res) => {

     }

   });

   app.get('/auth', async (req, http_res) => {

     let res;

     if (!req.query.code) {

       http_res.status(403).send(await render_error(req, 'No auth code provided.', 403));

       return;

             client_secret: Config.osu_v2api_client_secret,

             code: req.query.code,

             grant_type: 'authorization_code',

           }),

           headers: {

             'Accept': 'application/json',

       // Initialize the user in the database if needed

       await get_user_by_id(user_profile.id, true);

     } else {

       // Get discord user id from ephemeral token

       const ephemeral_token = req.query.state;

   });

   app.post('/get-invite/:banchoId', async (req, http_res) => {

       http_res.status(403).json({error: 'You need to be authenticated to get an invite.'});

       return;

     }

       return;

     }

     await bancho.privmsg(user.username, `${user.username}, here's your invite: [http://osump://${inviting_lobby.invite_id}/ ${inviting_lobby.name}]`);

     http_res.status(200).json({success: true});

   });

   // Dirty hack to handle Discord embeds nicely

     if (req.get('User-Agent').indexOf('Discordbot') != -1) {

       const user = await get_user_by_id(req.params.userId, false);

       if (!user) {

       return;

     }

   });

   if (Config.ENABLE_SENTRY) {

   }

   app.listen(3001, () => {

   });

 }

 function validate_lobby_settings(settings) {

   if (!['random', 'pp', 'elo'].includes(settings.map_selection_algo)) {

     throw new Error('Invalid map selection');

   }

 }

   if (ruleset == 'osu') {

     return 0;

   } else if (ruleset == 'taiko') {

 }

   const PLAYERS_PER_PAGE = 20;

   const total_players = db.prepare(

       `SELECT COUNT(*) AS nb FROM rating WHERE sig < ? AND mode = ?`,

   ).get(Config.ranked_sig_cutoff, mode);

   };

 }

   const total_scores = db.prepare(

       `SELECT COUNT(*) AS nb FROM score WHERE mode = ? AND user_id = ?`,

   ).get(mode, user_id);

 }

 async function register_routes(app) {

     try {

       http_res.set('Cache-control', 'public, max-age=60');

       http_res.json(data);

     } catch (err) {

     }

   });

     try {

       const data = await get_user_matches(

           parseInt(req.params.userId, 10),

           parseInt(req.params.pageNum, 10),

       );

       http_res.set('Cache-control', 'public, max-age=60');

     }

   });

     const lobbies = {

       open: [],

   });

   app.post('/api/create-lobby/', express.json(), async (req, http_res) => {

       http_res.status(403).json({error: 'You need to be authenticated to create a lobby.'});

       return;

     }

     for (const lobby of bancho.joined_lobbies) {

         http_res.status(401).json({error: 'You already have a lobby open.'});

         return;

       }

         return;

       }

     } else {

       validate_lobby_settings(req.body);

       lobby_data.ruleset = req.body.ruleset;

       lobby_data.pp_closeness = 50;

     }

     if (!user) {

       // User has never played in a ranked lobby.

       // But we still can create a lobby for them :)

       };

     }

     lobby_data.creator = user.username;

     let lobby = null;

     if (req.body.match_id) {

       try {

         console.info(`Creating lobby for ${lobby_data.creator}...`);

         lobby = await bancho.make(Config.IS_PRODUCTION ? `New o!RL lobby` : `test lobby`);

       } catch (err) {

         http_res.status(400).json({error: 'Could not create the lobby', details: err.message});

         return;

       return;

     }

     http_res.status(200).json({

       success: true,

       lobby: {

       },

     });

   });

 }