feat(mod): ranked threshold and comp threshold can be modified

Author: Golbolco

data/constants.js

@@ -468,6 +468,7 @@ module.exports = {
     editAnySetup: true,
     createPoll: true,
     manageCompetitive: true,
+    adjustMinGames: true,
     awardTrophy: true,
     deleteStrategy: true,
     seeModPanel: true,

db/schemas.js

@@ -733,6 +733,7 @@ var schemas = {
     dateCompleted: { type: String }, // YYYY-MM-DD (inclusive)
     remainingOpenDays: { type: Number, required: true },
     remainingReviewDays: { type: Number, required: true },
+    minimumPoints: { type: Number, default: 150 },
   }),
   CompetitiveGameCompletion: new mongoose.Schema({
     userId: { type: String },

modules/redis.js

@@ -1471,6 +1471,20 @@ async function getDeletedVanityUrlUserId(vanityUrl) {
   return await client.getAsync(key);
 }
 
+async function getMinimumGamesForRanked() {
+  const key = "setting:minimumGamesForRanked";
+  const value = await client.getAsync(key);
+  if (value === null) {
+    return constants.minimumGamesForRanked;
+  }
+  return parseInt(value, 10);
+}
+
+async function setMinimumGamesForRanked(value) {
+  const key = "setting:minimumGamesForRanked";
+  await client.setAsync(key, value);
+}
+
 module.exports = {
   client,
   getUserDbId,
@@ -1547,4 +1561,6 @@ module.exports = {
   rateLimit,
   cacheDeletedVanityUrl,
   getDeletedVanityUrlUserId,
+  getMinimumGamesForRanked,
+  setMinimumGamesForRanked,
 };

react_main/src/pages/Policy/Moderation/CompetitiveManagement.jsx

@@ -19,8 +19,11 @@ import Setup from "components/Setup";
 
 import { COMMAND_COLOR } from "./commands";
 
+const DEFAULT_MINIMUM_POINTS = 150;
+
 export default function CompetitiveManagement() {
   const [seasonData, setSeasonData] = useState(null);
+  const [roundSettings, setRoundSettings] = useState({});
   const [loading, setLoading] = useState(false);
   const [saving, setSaving] = useState(false);
   const [addSetupDialogOpen, setAddSetupDialogOpen] = useState(false);
@@ -53,6 +56,7 @@ export default function CompetitiveManagement() {
             return;
           }
           setSeasonData(response.data);
+          setRoundSettings(response.data.roundSettings || {});
           setLoading(false);
         } else {
           errorAlert("Invalid season data received.");
@@ -100,20 +104,42 @@ export default function CompetitiveManagement() {
     }
   };
 
+  const handleMinimumPointsChange = (roundNumber, value) => {
+    const numValue = parseInt(value, 10);
+    setRoundSettings((prev) => ({
+      ...prev,
+      [roundNumber]: {
+        ...prev[roundNumber],
+        minimumPoints: isNaN(numValue) ? DEFAULT_MINIMUM_POINTS : numValue,
+      },
+    }));
+  };
+
   const handleSave = () => {
     if (!seasonData) return;
 
     setSaving(true);
-    axios
-      .post("/api/competitive/updateSetupOrder", {
-        setupOrder: seasonData.setupOrder,
-      })
+
+    const setupOrderPromise = axios.post("/api/competitive/updateSetupOrder", {
+      setupOrder: seasonData.setupOrder,
+    });
+
+    const roundSettingsPromise = axios.post(
+      "/api/competitive/updateRoundSettings",
+      {
+        roundSettings: roundSettings,
+      }
+    );
+
+    Promise.all([setupOrderPromise, roundSettingsPromise])
       .then(() => {
-        siteInfo.showAlert("Setup order updated successfully.", "success");
+        siteInfo.showAlert("Changes saved successfully.", "success");
         setSaving(false);
       })
       .catch((error) => {
-        errorAlert("Failed to update setup order.");
+        errorAlert(
+          error.response?.data || "Failed to save changes."
+        );
         setSaving(false);
       });
   };
@@ -151,6 +177,7 @@ export default function CompetitiveManagement() {
               response.data.setupOrder
             ) {
               setSeasonData(response.data);
+              setRoundSettings(response.data.roundSettings || {});
               setAddSetupDialogOpen(false);
               setSetupIdToAdd("");
               setAddingSetup(false);
@@ -239,6 +266,23 @@ export default function CompetitiveManagement() {
                           <i className="fas fa-plus" />
                         </IconButton>
                       </Stack>
+                      <TextField
+                        label="Minimum Points"
+                        type="number"
+                        size="small"
+                        value={
+                          roundSettings[roundIndex + 1]?.minimumPoints ??
+                          DEFAULT_MINIMUM_POINTS
+                        }
+                        onChange={(e) =>
+                          handleMinimumPointsChange(
+                            roundIndex + 1,
+                            e.target.value
+                          )
+                        }
+                        inputProps={{ min: 0 }}
+                        sx={{ mb: 1, maxWidth: 200 }}
+                      />
                       <Stack direction="column" spacing={1}>
                         {roundSetups && roundSetups.length > 0 ? (
                           roundSetups.map((setupNumber, setupIndex) => {

react_main/src/pages/Policy/Moderation/commands.js

@@ -914,6 +914,29 @@ export function useModCommands(argValues, commandRan, setResults) {
           .catch(errorAlert);
       },
     },
+    "Adjust Minimum Games Threshold": {
+      perm: "adjustMinGames",
+      category: "Site Management",
+      args: [
+        {
+          label: "Minimum Games for Ranked",
+          name: "value",
+          type: "number",
+        },
+      ],
+      run: function () {
+        axios
+          .post("/api/mod/minGamesThreshold", argValues)
+          .then((res) => {
+            siteInfo.showAlert(
+              `Minimum games for ranked set to ${res.data.minimumGamesForRanked}.`,
+              "success"
+            );
+            commandRan();
+          })
+          .catch(errorAlert);
+      },
+    },
     "Toggle Ranked Setup": {
       perm: "approveRanked",
       category: "Setup Management",

routes/competitive.js

@@ -314,7 +314,7 @@ router.get("/current", async function (req, res) {
       completed: false,
     })
       .sort({ number: -1 })
-      .select("setups setupOrder number")
+      .select("setups setupOrder number numRounds")
       .populate([
         {
           path: "setups",
@@ -341,10 +341,29 @@ router.get("/current", async function (req, res) {
       return;
     }
 
+    // Fetch round settings for all rounds (filter out round 0 if it exists)
+    const rounds = await models.CompetitiveRound.find({
+      season: currentSeason.number,
+      number: { $gt: 0 },
+    })
+      .select("number minimumPoints")
+      .sort({ number: 1 })
+      .lean();
+
+    // Build roundSettings object keyed by round number (1-indexed)
+    const roundSettings = {};
+    for (const round of rounds) {
+      roundSettings[round.number] = {
+        minimumPoints: round.minimumPoints ?? constants.minimumPointsForCompetitive,
+      };
+    }
+
     res.json({
       seasonNumber: currentSeason.number,
       setups: currentSeason.setups,
       setupOrder: currentSeason.setupOrder,
+      numRounds: currentSeason.numRounds,
+      roundSettings: roundSettings,
     });
   } catch (e) {
     logger.error(e);
@@ -561,6 +580,83 @@ router.post("/updateSetupOrder", async function (req, res) {
     res.status(500);
     res.send("Error updating setup order.");
   }
+  
+// Update round settings (minimumPoints) for the current season
+router.post("/updateRoundSettings", async function (req, res) {
+  try {
+    var userId = await routeUtils.verifyLoggedIn(req);
+
+    if (!(await routeUtils.verifyPermission(res, userId, "manageCompetitive")))
+      return;
+
+    const roundSettings = req.body.roundSettings;
+
+    if (!roundSettings || typeof roundSettings !== "object") {
+      res.status(400);
+      res.send("roundSettings must be an object.");
+      return;
+    }
+
+    const currentSeason = await models.CompetitiveSeason.findOne({
+      completed: false,
+    })
+      .sort({ number: -1 })
+      .select("number numRounds")
+      .lean();
+
+    if (!currentSeason) {
+      res.status(404);
+      res.send("No season in progress.");
+      return;
+    }
+
+    // Get existing rounds for this season
+    const existingRounds = await models.CompetitiveRound.find({
+      season: currentSeason.number,
+    })
+      .select("number")
+      .lean();
+    const existingRoundNumbers = new Set(existingRounds.map((r) => r.number));
+
+    // Validate and update each round's settings
+    for (const [roundNumberStr, settings] of Object.entries(roundSettings)) {
+      const roundNumber = Number.parseInt(roundNumberStr);
+
+      if (isNaN(roundNumber) || roundNumber < 1 || roundNumber > currentSeason.numRounds) {
+        res.status(400);
+        res.send(`Invalid round number: ${roundNumberStr}`);
+        return;
+      }
+
+      // Skip rounds that haven't been created yet
+      if (!existingRoundNumbers.has(roundNumber)) {
+        continue;
+      }
+
+      if (settings.minimumPoints !== undefined) {
+        const minPoints = Number.parseInt(settings.minimumPoints);
+        if (isNaN(minPoints) || minPoints < 0) {
+          res.status(400);
+          res.send(`Invalid minimumPoints for round ${roundNumber}: must be a non-negative number.`);
+          return;
+        }
+
+        // Update the round document
+        await models.CompetitiveRound.updateOne(
+          { season: currentSeason.number, number: roundNumber },
+          { $set: { minimumPoints: minPoints } }
+        );
+      }
+    }
+
+    routeUtils.createModAction(userId, "Update Competitive Round Settings", []);
+
+    res.sendStatus(200);
+  } catch (e) {
+    logger.error(e);
+    res.status(500);
+    res.send("Error updating round settings.");
+  }
 });
 
 module.exports = router;

routes/game.js

@@ -9,11 +9,11 @@ const logger = require("../modules/logging")(".");
 const router = express.Router();
 const axios = require("axios");
 
-async function userCanPlayCompetitive(userId) {
+async function userCanPlayCompetitive(userId, minimumPoints = constants.minimumPointsForCompetitive) {
   const user = await redis.getUserInfo(userId);
 
-  if (!user || user.points < constants.minimumPointsForCompetitive) {
-    return `You cannot play competitive games until you've earned ${constants.minimumPointsForCompetitive} fortune.`;
+  if (!user || user.points < minimumPoints) {
+    return `You cannot play competitive games until you've earned ${minimumPoints} fortune.`;
   }
 
   if (!user || user.goldHearts <= 0) {
@@ -252,11 +252,12 @@ router.get("/:id/connect", async function (req, res) {
       // Ranked checks
       if (userId && game.settings.ranked && !isSpectating) {
         const user = await redis.getUserInfo(userId);
+        const minGamesForRanked = await redis.getMinimumGamesForRanked();
 
-        if (!user || user.gamesPlayed < constants.minimumGamesForRanked) {
+        if (!user || user.gamesPlayed < minGamesForRanked) {
           res.status(400);
           res.send(
-            `You cannot play ranked games until you've played ${constants.minimumGamesForRanked} games.`
+            `You cannot play ranked games until you've played ${minGamesForRanked} games.`
           );
           return;
         }
@@ -272,7 +273,9 @@ router.get("/:id/connect", async function (req, res) {
 
       // Competitive checks
       if (userId && game.settings.competitive && !isSpectating) {
-        const failureReason = await userCanPlayCompetitive(userId);
+        const roundInfo = await redis.getCompRoundInfo();
+        const minimumPoints = roundInfo?.round?.minimumPoints ?? constants.minimumPointsForCompetitive;
+        const failureReason = await userCanPlayCompetitive(userId, minimumPoints);
         if (failureReason) {
           res.status(400);
           res.send(failureReason);
@@ -704,10 +707,11 @@ router.post("/host", async function (req, res) {
 
     const user = await redis.getUserInfo(userId);
     if (req.body.ranked) {
-      if (user && user.gamesPlayed < constants.minimumGamesForRanked) {
+      const minGamesForRanked = await redis.getMinimumGamesForRanked();
+      if (user && user.gamesPlayed < minGamesForRanked) {
         res.status(400);
         res.send(
-          `You cannot play ranked games until you've played ${constants.minimumGamesForRanked} games.`
+          `You cannot play ranked games until you've played ${minGamesForRanked} games.`
         );
         return;
       }
@@ -722,7 +726,8 @@ router.post("/host", async function (req, res) {
     }
 
     if (userId && req.body.competitive) {
-      const failureReason = await userCanPlayCompetitive(userId);
+      const minimumPoints = roundInfo?.round?.minimumPoints ?? constants.minimumPointsForCompetitive;
+      const failureReason = await userCanPlayCompetitive(userId, minimumPoints);
       if (failureReason) {
         res.status(400);
         res.send(failureReason);
@@ -1298,4 +1303,4 @@ const settingsChecks = {
   },
 };
 
-module.exports = router;
+module.exports = router;