@quenty/elo 1.1.0 → 2.0.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.0.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/elo@1.1.0...@quenty/elo@2.0.0) (2023-10-15)
+
+**Note:** Version bump only for package @quenty/elo
+
+
+
+
+
 # 1.1.0 (2022-03-10)
 
 

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2014-2021 Quenty
+Copyright (c) 2014-2023 James Onnen (Quenty)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/elo",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Elo rating utility library.",
   "keywords": [
     "Roblox",
@@ -28,5 +28,10 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "0797de955876b050fb24875de0423453e268b2ce"
+  "devDependencies": {
+    "@quenty/blend": "^7.0.0",
+    "@quenty/loader": "^7.0.0",
+    "@quenty/maid": "^2.6.0"
+  },
+  "gitHead": "c0034bed881fc1445e04366dd0b0abb49bc42e88"
 }

package/src/Shared/EloMatchResult.lua

@@ -0,0 +1,15 @@
+--[=[
+	@class EloMatchResult
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+return table.freeze(setmetatable({
+	PLAYER_ONE_WIN = 1;
+	DRAW = 0.5;
+	PLAYER_TWO_WIN = 0;
+}, {
+	__index = function()
+		error("Bad index onto EloMatchResult")
+	end;
+}))

package/src/Shared/EloMatchResultUtils.lua

@@ -0,0 +1,31 @@
+--[=[
+	@class EloMatchResultUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local EloMatchResult = require("EloMatchResult")
+
+local EloMatchResultUtils = {}
+
+function EloMatchResultUtils.isEloMatchResult(matchResult)
+	return matchResult == EloMatchResult.PLAYER_ONE_WIN
+		or matchResult == EloMatchResult.PLAYER_TWO_WIN
+		or matchResult == EloMatchResult.DRAW
+end
+
+function EloMatchResultUtils.isEloMatchResultList(eloMatchResultList)
+	if type(eloMatchResultList) ~= "table" then
+		return false
+	end
+
+	for _, eloMatchResult in pairs(eloMatchResultList) do
+		if not EloMatchResultUtils.isEloMatchResult(eloMatchResult) then
+			return false
+		end
+	end
+
+	return true
+end
+
+return EloMatchResultUtils

package/src/Shared/EloUtils.lua

@@ -5,34 +5,29 @@
 	```lua
 	local config = EloUtils.createConfig()
 
-	local playerRating = 1400
-	local opponentRating = 1800
+	local playerOneRating = 1400
+	local playerTwoRating = 1800
 
 	-- Update rating!
-	playerRating, opponentRating = EloUtils.getNewScores(
+	playerOneRating, playerTwoRating = EloUtils.getNewElo(
 		config,
-		playerRating,
-		opponentRating,
+		playerOneRating,
+		playerTwoRating,
 		{
-			EloUtils.Scores.WIN;
+			EloMatchResult.PLAYER_ONE_WIN;
 		})
 
 	-- New rankings!
-	print(playerRating, opponentRating)
+	print(playerOneRating, playerTwoRating)
 	```
 ]=]
 
-local EloUtils = {}
+local require = require(script.Parent.loader).load(script)
+
+local EloMatchResult = require("EloMatchResult")
+local EloMatchResultUtils = require("EloMatchResultUtils")
 
-EloUtils.Scores = setmetatable({
-	WIN = 1;
-	DRAW = 0.5;
-	LOSS = 0;
-}, {
-	__index = function()
-		error("Bad index onto EloUtils.Scores")
-	end;
-})
+local EloUtils = {}
 
 --[=[
 	@interface EloConfig
@@ -40,6 +35,7 @@ EloUtils.Scores = setmetatable({
 	.kfactor number | function
 	.initial number
 	.ratingFloor number
+	.groupMultipleResultAsOne boolean
 	@within EloUtils
 ]=]
 
@@ -56,6 +52,7 @@ function EloUtils.createConfig(config)
 		kfactor = config.kfactor or EloUtils.standardKFactorFormula;
 		initial = config.initial or 1400;
 		ratingFloor = config.ratingFloor or 100;
+		groupMultipleResultAsOne = false;
 	}
 end
 
@@ -73,38 +70,60 @@ end
 	Gets the new score for the player and opponent after a series of matches.
 
 	@param config EloConfig
-	@param playerRating number
-	@param opponentRating number
-	@param matchScores { number } -- 0 for loss, 1 for win, 0.5 for draw.
-	@return number -- playerRating
-	@return number -- opponentRating
+	@param playerOneRating number
+	@param playerTwoRating number
+	@param eloMatchResultList { EloMatchResult }
+	@return number -- playerOneRating
+	@return number -- playerTwoRating
 ]=]
-function EloUtils.getNewScores(config, playerRating, opponentRating, matchScores)
+function EloUtils.getNewElo(config, playerOneRating, playerTwoRating, eloMatchResultList)
 	assert(EloUtils.isEloConfig(config), "Bad config")
-	assert(type(playerRating) == "number", "Bad playerRating")
-	assert(type(opponentRating) == "number", "Bad opponentRating")
-	assert(type(matchScores) == "table", "Bad matchScores")
+	assert(type(playerOneRating) == "number", "Bad playerOneRating")
+	assert(type(playerTwoRating) == "number", "Bad playerTwoRating")
+	assert(EloMatchResultUtils.isEloMatchResultList(eloMatchResultList), "Bad eloMatchResultList")
 
-	return EloUtils.getNewScore(config, playerRating, opponentRating, matchScores),
-		EloUtils.getNewScore(config, opponentRating, playerRating, EloUtils.fromOpponentPerspective(matchScores))
+	local newPlayerOneRating = EloUtils.getNewPlayerOneScore(config, playerOneRating, playerTwoRating, eloMatchResultList)
+	local newPlayerTwoRating = EloUtils.getNewPlayerOneScore(config, playerTwoRating, playerOneRating, EloUtils.fromOpponentPerspective(eloMatchResultList))
+	return newPlayerOneRating, newPlayerTwoRating
 end
 
+--[=[
+	Gets the change in elo for the given players and the results
+
+	@param config EloConfig
+	@param playerOneRating number
+	@param playerTwoRating number
+	@param eloMatchResultList { EloMatchResult }
+	@return number -- playerOneRating
+	@return number -- playerTwoRating
+]=]
+function EloUtils.getEloChange(config, playerOneRating, playerTwoRating, eloMatchResultList)
+	assert(EloUtils.isEloConfig(config), "Bad config")
+	assert(type(playerOneRating) == "number", "Bad playerOneRating")
+	assert(type(playerTwoRating) == "number", "Bad playerTwoRating")
+	assert(EloMatchResultUtils.isEloMatchResultList(eloMatchResultList), "Bad eloMatchResultList")
+
+	local newPlayerOneRating, newPlayerTwoRating = EloUtils.getNewElo(config, playerOneRating, playerTwoRating, eloMatchResultList)
+	local playerOneChange = newPlayerOneRating - playerOneRating
+	local playerTwoChange = newPlayerTwoRating - playerTwoRating
+	return playerOneChange, playerTwoChange
+end
 
 --[=[
 	Gets the new score for the player after a series of matches.
 
 	@param config EloConfig
-	@param playerRating number
-	@param opponentRating number
-	@param matchScores { number } -- 0 for loss, 1 for win, 0.5 for draw.
+	@param playerOneRating number
+	@param playerTwoRating number
+	@param eloMatchResultList { EloMatchResult }
 ]=]
-function EloUtils.getNewScore(config, playerRating, opponentRating, matchScores)
+function EloUtils.getNewPlayerOneScore(config, playerOneRating, playerTwoRating, eloMatchResultList)
 	assert(EloUtils.isEloConfig(config), "Bad config")
-	assert(type(playerRating) == "number", "Bad playerRating")
-	assert(type(opponentRating) == "number", "Bad opponentRating")
-	assert(type(matchScores) == "table", "Bad matchScores")
+	assert(type(playerOneRating) == "number", "Bad playerOneRating")
+	assert(type(playerTwoRating) == "number", "Bad playerTwoRating")
+	assert(EloMatchResultUtils.isEloMatchResultList(eloMatchResultList), "Bad eloMatchResultList")
 
-	return math.max(config.ratingFloor, playerRating + EloUtils.getScoreAdjustment(config, playerRating, opponentRating, matchScores))
+	return math.max(config.ratingFloor, playerOneRating + EloUtils.getPlayerOneScoreAdjustment(config, playerOneRating, playerTwoRating, eloMatchResultList))
 end
 
 --[=[
@@ -115,16 +134,16 @@ end
 	:::
 
 	@param config EloConfig
-	@param playerRating number
-	@param opponentRating number
+	@param playerOneRating number
+	@param playerTwoRating number
 	@return number
 ]=]
-function EloUtils.getExpected(config, playerRating, opponentRating)
+function EloUtils.getPlayerOneExpected(config, playerOneRating, playerTwoRating)
 	assert(EloUtils.isEloConfig(config), "Bad config")
-	assert(type(playerRating) == "number", "Bad playerRating")
-	assert(type(opponentRating) == "number", "Bad opponentRating")
+	assert(type(playerOneRating) == "number", "Bad playerOneRating")
+	assert(type(playerTwoRating) == "number", "Bad playerTwoRating")
 
-	local diff = opponentRating - playerRating
+	local diff = playerTwoRating - playerOneRating
 	return 1 / (1 + 10 ^ (diff / config.factor))
 end
 
@@ -132,46 +151,97 @@ end
 	Gets the score adjustment for a given player's base.
 
 	@param config EloConfig
-	@param playerRating number
-	@param opponentRating number
-	@param matchScores { number } -- 0 for loss, 1 for win, 0.5 for draw.
+	@param playerOneRating number
+	@param playerTwoRating number
+	@param eloMatchResultList { EloMatchResult }
 	@return number
 ]=]
-function EloUtils.getScoreAdjustment(config, playerRating, opponentRating, matchScores)
+function EloUtils.getPlayerOneScoreAdjustment(config, playerOneRating, playerTwoRating, eloMatchResultList)
 	assert(EloUtils.isEloConfig(config), "Bad config")
-	assert(type(playerRating) == "number", "Bad playerRating")
-	assert(type(opponentRating) == "number", "Bad opponentRating")
-	assert(type(matchScores) == "table", "Bad matchScores")
+	assert(type(playerOneRating) == "number", "Bad playerOneRating")
+	assert(type(playerTwoRating) == "number", "Bad playerTwoRating")
+	assert(EloMatchResultUtils.isEloMatchResultList(eloMatchResultList), "Bad eloMatchResultList")
 
 	local adjustment = 0
-	local expected = EloUtils.getExpected(config, playerRating, opponentRating)
+	local expected = EloUtils.getPlayerOneExpected(config, playerOneRating, playerTwoRating)
+
+	if config.groupMultipleResultAsOne then
+		local wins = EloUtils.countPlayerOneWins(eloMatchResultList)
+		local losses = EloUtils.countPlayerTwoWins(eloMatchResultList)
+		local score = wins > losses and 1 or 0
+		local multiplier = 1
 
-	for _, score in pairs(matchScores) do
-		adjustment = adjustment + (score - expected)
+		if wins > losses then
+			multiplier = wins
+		else
+			multiplier = losses
+		end
+
+		adjustment = multiplier*(score - expected)
+	else
+		for _, score in pairs(eloMatchResultList) do
+			adjustment = adjustment + (score - expected)
+		end
 	end
 
-	local kfactor = EloUtils.extractKFactor(config, playerRating)
+	local kfactor = EloUtils.extractKFactor(config, playerOneRating)
 	return kfactor*adjustment
 end
 
 --[=[
 	Flips the scores for the opponent
 
-	@param matchScores { number } -- 0 for loss, 1 for win, 0.5 for draw.
+	@param eloMatchResultList { EloMatchResult }
 	@return { number }
 ]=]
-function EloUtils.fromOpponentPerspective(matchScores)
-	assert(type(matchScores) == "table", "Bad matchScores")
+function EloUtils.fromOpponentPerspective(eloMatchResultList)
+	assert(EloMatchResultUtils.isEloMatchResultList(eloMatchResultList), "Bad eloMatchResultList")
 
 	local newScores = {}
 
-	for index, score in pairs(matchScores) do
+	for index, score in pairs(eloMatchResultList) do
 		newScores[index] = 1 - score
 	end
 
 	return newScores
 end
 
+--[=[
+	Counts the number of wins for player one
+
+	@param eloMatchResultList { EloMatchResult }
+	@return { number }
+]=]
+function EloUtils.countPlayerOneWins(eloMatchResultList)
+	assert(EloMatchResultUtils.isEloMatchResultList(eloMatchResultList), "Bad eloMatchResultList")
+
+	local count = 0
+	for _, score in pairs(eloMatchResultList) do
+		if score == EloMatchResult.PLAYER_ONE_WIN then
+			count = count + 1
+		end
+	end
+	return count
+end
+
+--[=[
+	Counts the number of wins for player two
+
+	@param eloMatchResultList { EloMatchResult }
+	@return { number }
+]=]
+function EloUtils.countPlayerTwoWins(eloMatchResultList)
+	assert(EloMatchResultUtils.isEloMatchResultList(eloMatchResultList), "Bad eloMatchResultList")
+
+	local count = 0
+	for _, score in pairs(eloMatchResultList) do
+		if score == EloMatchResult.PLAYER_TWO_WIN then
+			count = count + 1
+		end
+	end
+	return count
+end
+
 --[=[
 	Standard kfactor formula for use in the elo config.
 

package/src/Shared/EloUtils.spec.lua

@@ -6,7 +6,7 @@
 local EloUtils = require(script.Parent.EloUtils)
 
 return function()
-	describe("EloUtils.getNewScores", function()
+	describe("EloUtils.getNewElo", function()
 		local config = EloUtils.createConfig()
 
 		local playerRating = 1400
@@ -17,12 +17,12 @@ return function()
 		local newPlayerDrawRating, newOpponentDrawRating
 
 		it("should change on win", function()
-			newPlayerWinRating, newOpponentWinRating = EloUtils.getNewScores(
+			newPlayerWinRating, newOpponentWinRating = EloUtils.getNewElo(
 				config,
 				playerRating,
 				opponentRating,
 				{
-					EloUtils.Scores.WIN;
+					EloUtils.MatchResult.PLAYER_ONE_WIN;
 				})
 
 			expect(newPlayerWinRating > playerRating).to.equal(true)
@@ -30,12 +30,12 @@ return function()
 		end)
 
 		it("should change on a loss", function()
-			newPlayerLossRating, newOpponentLossRating = EloUtils.getNewScores(
+			newPlayerLossRating, newOpponentLossRating = EloUtils.getNewElo(
 				config,
 				playerRating,
 				opponentRating,
 				{
-					EloUtils.Scores.LOSS;
+					EloUtils.MatchResult.PLAYER_TWO_WIN;
 				})
 
 			expect(newPlayerLossRating < playerRating).to.equal(true)
@@ -43,12 +43,12 @@ return function()
 		end)
 
 		it("should change on a draw", function()
-			newPlayerDrawRating, newOpponentDrawRating = EloUtils.getNewScores(
+			newPlayerDrawRating, newOpponentDrawRating = EloUtils.getNewElo(
 				config,
 				playerRating,
 				opponentRating,
 				{
-					EloUtils.Scores.DRAW;
+					EloUtils.MatchResult.DRAW;
 				})
 
 			expect(newPlayerDrawRating > playerRating).to.equal(true)

package/src/Shared/EloUtils.story.lua

@@ -0,0 +1,358 @@
+--[[
+	@class EloUtils.story
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).load(script)
+
+local Maid = require("Maid")
+local Blend = require("Blend")
+local EloUtils = require("EloUtils")
+
+local function TextLabel(props)
+	return Blend.New "TextLabel" {
+		Size = props.Size;
+		TextXAlignment = props.TextXAlignment;
+		TextYAlignment = props.TextYAlignment;
+		BackgroundTransparency = 1;
+		Font = Enum.Font.FredokaOne;
+		AnchorPoint = props.AnchorPoint;
+		Position = props.Position;
+		TextColor3 = props.TextColor3;
+		TextSize = props.TextSize or 20;
+		Text = props.Text;
+		RichText = props.RichText;
+	};
+end
+
+local function MatchResultCard(props)
+	return Blend.New "Frame" {
+		Name = "MatchResultCard";
+		Size = UDim2.new(0, 140, 0, 0);
+		AutomaticSize = Enum.AutomaticSize.Y;
+		BackgroundTransparency = 1;
+
+		TextLabel {
+			Name = "PlayerLabel";
+			Size = UDim2.new(1, 0, 0, 30);
+			TextXAlignment = Enum.TextXAlignment.Center;
+			BackgroundTransparency = 1;
+			TextSize = 25;
+			TextColor3 = Blend.Computed(props.Change, function(change)
+				if change > 0 then
+					return Color3.fromRGB(61, 83, 60)
+				else
+					return Color3.fromRGB(103, 39, 39)
+				end
+			end);
+			Text = Blend.Computed(props.OldElo, props.NewElo, props.IsWinner, function(oldElo, newElo, winner)
+				if winner then
+					return string.format("%d → %d", oldElo, newElo)
+				else
+					return string.format("%d → %d", oldElo, newElo)
+				end
+			end);
+		};
+
+		Blend.New "Frame" {
+			Name = "Elo change";
+			BackgroundColor3 = Blend.Computed(props.Change, function(change)
+				if change > 0 then
+					return Color3.fromRGB(61, 83, 60)
+				else
+					return Color3.fromRGB(103, 39, 39)
+				end
+			end);
+			Size = UDim2.new(0, 60, 0, 30);
+
+			Blend.New "UICorner" {
+				CornerRadius = UDim.new(0.5, 0);
+			};
+
+			TextLabel {
+				Size = UDim2.new(1, 0, 0, 30);
+				BackgroundTransparency = 1;
+				TextColor3 = Blend.Computed(props.Change, function(change)
+					if change > 0 then
+						return Color3.fromRGB(221, 255, 223)
+					else
+						return Color3.fromRGB(255, 219, 219)
+					end
+				end);
+				Text = Blend.Computed(props.Change, function(change)
+					if change > 0 then
+						return string.format("+%d", change)
+					else
+						return string.format("%d", change)
+					end
+				end);
+			};
+		};
+
+		Blend.New "UIListLayout" {
+			FillDirection = Enum.FillDirection.Vertical;
+			HorizontalAlignment = Enum.HorizontalAlignment.Center;
+			Padding = UDim.new(0, 5);
+		};
+	}
+end
+
+local function PlayerScoreChange(props)
+	local playerOneWin = EloUtils.countPlayerOneWins(props.MatchResults) > EloUtils.countPlayerTwoWins(props.MatchResults)
+
+	return Blend.New "Frame" {
+		Name = "PlayerScoreChange";
+		Size = UDim2.new(0, 0, 0, 0);
+		AutomaticSize = Enum.AutomaticSize.XY;
+		BackgroundColor3 = Color3.new(0.9, 0.9, 0.9);
+		BackgroundTransparency = 0;
+
+		Blend.New "UIPadding" {
+			PaddingTop = UDim.new(0, 10);
+			PaddingBottom = UDim.new(0, 10);
+			PaddingLeft = UDim.new(0, 10);
+			PaddingRight = UDim.new(0, 10);
+		};
+
+		Blend.New "UICorner" {
+			CornerRadius = UDim.new(0, 10);
+		};
+
+		Blend.New "UIGradient" {
+			Color = Blend.Computed(playerOneWin, function(winner)
+				if winner then
+					return ColorSequence.new(Color3.fromRGB(208, 255, 194), Color3.fromRGB(255, 197, 197))
+				else
+					return ColorSequence.new(Color3.fromRGB(255, 197, 197), Color3.fromRGB(208, 255, 194))
+				end
+			end)
+		};
+
+		Blend.New "UIListLayout" {
+			FillDirection = Enum.FillDirection.Horizontal;
+			VerticalAlignment = Enum.VerticalAlignment.Center;
+			Padding = UDim.new(0, 5);
+		};
+
+		MatchResultCard({
+			IsWinner = playerOneWin;
+			NewElo = props.PlayerOne.New;
+			OldElo = props.PlayerOne.Old;
+			Change = props.PlayerOne.New - props.PlayerOne.Old;
+		});
+
+		Blend.New "Frame" {
+			Name = "MatchResults";
+			Size = UDim2.new(0, 90, 0, 40);
+			BackgroundColor3 = Color3.fromRGB(185, 185, 185);
+
+			Blend.New "UICorner" {
+				CornerRadius = UDim.new(0.5, 0);
+			};
+
+			TextLabel {
+				RichText = true;
+				Size = UDim2.new(1, 0, 0, 30);
+				TextColor3 = Color3.fromRGB(24, 24, 24);
+				AnchorPoint = Vector2.new(0.5, 0.5);
+				Position = UDim2.fromScale(0.5, 0.5);
+				BackgroundTransparency = 1;
+				Text = Blend.Computed(props.MatchResults, function(matchScores)
+					local playerOneWins = EloUtils.countPlayerOneWins(matchScores)
+					local playerTwoWins = EloUtils.countPlayerTwoWins(matchScores)
+
+					if playerOneWins > playerTwoWins then
+						return string.format("<font color='#355024'><stroke color='#9dd59a'>%d</stroke></font> - %d", playerOneWins, playerTwoWins)
+					else
+						return string.format("%d - <font color='#355024'><stroke color='#9dd59a'>%d</stroke></font>", playerOneWins, playerTwoWins)
+					end
+				end);
+				TextSize = 20;
+			};
+		};
+
+		MatchResultCard({
+			IsWinner = not playerOneWin;
+			NewElo = props.PlayerTwo.New;
+			OldElo = props.PlayerTwo.Old;
+			Change = props.PlayerTwo.New - props.PlayerTwo.Old;
+		});
+	}
+end
+
+local function EloGroup(props)
+	return Blend.New "Frame" {
+		Name = "EloGroup";
+		AutomaticSize = Enum.AutomaticSize.XY;
+		BackgroundTransparency = 1;
+
+		Blend.New "Frame" {
+			BackgroundColor3 = Color3.new(0.1, 0.1, 0.1);
+			AutomaticSize = Enum.AutomaticSize.XY;
+
+			Blend.New "UICorner" {
+				CornerRadius = UDim.new(0, 15);
+			};
+
+			Blend.New "UIStroke" {
+				Color = Color3.fromRGB(69, 170, 156);
+				Thickness = 3;
+			};
+
+			Blend.New "UIListLayout" {
+				FillDirection = Enum.FillDirection.Vertical;
+				HorizontalAlignment = Enum.HorizontalAlignment.Center;
+				Padding = UDim.new(0, 5);
+			};
+
+			Blend.New "Frame" {
+				Name = "Children";
+				AutomaticSize = Enum.AutomaticSize.XY;
+				BackgroundTransparency = 1;
+
+				Blend.New "UIListLayout" {
+					FillDirection = Enum.FillDirection.Vertical;
+					HorizontalAlignment = Enum.HorizontalAlignment.Center;
+					Padding = UDim.new(0, 5);
+				};
+
+				props.Items;
+			};
+
+
+			Blend.New "UIPadding" {
+				PaddingTop = UDim.new(0, 25);
+				PaddingBottom = UDim.new(0, 10);
+				PaddingLeft = UDim.new(0, 10);
+				PaddingRight = UDim.new(0, 10);
+			};
+		};
+
+		Blend.New "UIPadding" {
+			PaddingTop = UDim.new(0, 30);
+		};
+
+		Blend.New "Frame" {
+			Name = "Header";
+			Size = UDim2.new(0, 200, 0, 30);
+			AnchorPoint = Vector2.new(0.5, 0.5);
+			Position = UDim2.fromScale(0.5, 0);
+			BackgroundColor3 = Color3.new(0.1, 0.1, 0.1);
+
+			Blend.New "UIStroke" {
+				Color = Color3.fromRGB(69, 170, 156);
+				Thickness = 3;
+			};
+
+			Blend.New "UICorner" {
+				CornerRadius = UDim.new(0.5, 0);
+			};
+
+			TextLabel({
+				TextColor3 = Color3.new(1, 1, 1);
+				Text = props.HeaderText;
+				Size = UDim2.fromScale(1, 1);
+			})
+		};
+	}
+end
+
+return function(target)
+	local maid = Maid.new()
+
+	local options = {}
+	local config = EloUtils.createConfig()
+
+
+	for playerOneElo=800, 2400, 200 do
+		for playerTwoEloDiff=-400, 400, 100 do
+			local groupOptions = {}
+			local playerTwoElo = playerOneElo + playerTwoEloDiff
+
+			local matchResultTypes = {
+				string.format("%d wins vs %d", playerOneElo, playerTwoElo);
+
+				{
+					results = { EloUtils.MatchResult.PLAYER_ONE_WIN }
+				};
+				{
+					results = { EloUtils.MatchResult.PLAYER_ONE_WIN, EloUtils.MatchResult.PLAYER_ONE_WIN, EloUtils.MatchResult.PLAYER_TWO_WIN }
+				};
+				{
+					results = { EloUtils.MatchResult.PLAYER_ONE_WIN, EloUtils.MatchResult.PLAYER_ONE_WIN }
+				};
+
+				string.format("%d loses vs %d", playerOneElo, playerTwoElo);
+
+				{
+					results = { EloUtils.MatchResult.PLAYER_TWO_WIN }
+				};
+				{
+					results = { EloUtils.MatchResult.PLAYER_TWO_WIN, EloUtils.MatchResult.PLAYER_TWO_WIN, EloUtils.MatchResult.PLAYER_ONE_WIN }
+				};
+				{
+					results = { EloUtils.MatchResult.PLAYER_TWO_WIN, EloUtils.MatchResult.PLAYER_TWO_WIN }
+				};
+			}
+
+			for _, matchResultType in pairs(matchResultTypes) do
+				if type(matchResultType) == "string" then
+					table.insert(groupOptions, TextLabel({
+						TextColor3 = Color3.new(1, 1, 1);
+						Text = matchResultType;
+						Size = UDim2.new(0, 100, 0, 30);
+					}))
+
+					continue
+				end
+
+				local matchResults = matchResultType.results
+
+				local scoreA, scoreB = EloUtils.getNewElo(config, playerOneElo, playerTwoElo, matchResults)
+				table.insert(groupOptions, PlayerScoreChange({
+					MatchResults = matchResults;
+					PlayerOne = {
+						Old = playerOneElo;
+						New = scoreA;
+					};
+					PlayerTwo = {
+						Old = playerTwoElo;
+						New = scoreB;
+					};
+				}))
+			end
+
+			table.insert(options, EloGroup {
+				HeaderText = string.format("%d vs %d", playerOneElo, playerTwoElo);
+				Items = groupOptions;
+			})
+		end
+	end
+
+	maid:GiveTask(Blend.mount(target, {
+		Blend.New "ScrollingFrame" {
+			Size = UDim2.new(1, 0, 1, 0);
+			BackgroundTransparency = 1;
+			CanvasSize = UDim2.new(0, 0, 0, 0);
+			AutomaticCanvasSize = Enum.AutomaticSize.Y;
+
+			Blend.New "UIPadding" {
+				PaddingTop = UDim.new(0, 10);
+				PaddingBottom = UDim.new(0, 10);
+				PaddingLeft = UDim.new(0, 10);
+				PaddingRight = UDim.new(0, 10);
+			};
+
+			Blend.New "UIListLayout" {
+				FillDirection = Enum.FillDirection.Vertical;
+				HorizontalAlignment = Enum.HorizontalAlignment.Center;
+				Padding = UDim.new(0, 10);
+			};
+
+			options;
+		}
+	}))
+
+	return function()
+		maid:DoCleaning()
+	end
+end