mattmazzola

// Create players
const initialRating = 1000
const numPlayers = 10
const playerTiers = 5
const playerRatingRange = 6000 - initialRating
const playerSegmentSize = Math.floor(numPlayers / playerTiers)
const playerIncrementAmount = Math.floor(playerRatingRange / playerTiers)

const playerGeneration = {
    total: numPlayers,

mattmazzola

const symmetricRatingSystem = createRatingSystem()

const playerKFactor = 32
const questionKFactor = 4
const asymmetricKFactorFn: KFactorFunctionWithPlayers = (rating, playerIndex) => {
    let kFactor = playerIndex === 0
        ? playerKFactor
        : questionKFactor

    if (rating > 6000) {

mattmazzola

export type KFactorOption =
    | KFactorFunctionWithPlayers
    | KFactorFunction
    | number

export function createRatingSystem(kFactor: KFactorOption = 32, exponentDenominator: number = 400, exponentBase: number = 10): RatingSystem {

    let resolvedKFactor: KFactorFunctionWithPlayers

    if (typeof kFactor === 'number') {

mattmazzola

    const {
        playerAProbability,
        playerBProbability,
        nextPlayerARating,
        playerARatingDiff,
        nextPlayerBRating,
        playerBRatingDiff
    } = rating.getNextRatings(playerARating, playerBRating, actualScore)

mattmazzola

function createNextRatingsFn(
    getExpectedPlayerProbabilities: ExpectedProbabilitiesFn,
    getNextARating: NextRatingFn,
    getNextBRating: NextRatingFn
): NextRatingsFn {
    const nextRatingsFn = (playerARating: number, playerBRating: number, playerAScore: number) => {
        const [expectedPlayerAProbability, expectedPlayerBProbability] = getExpectedPlayerProbabilities(playerARating, playerBRating)
        const aProbability = playerAScore
        const bProbability = 1 - playerAScore

mattmazzola

import createRatingSystem from '@sc2/rating'

// Defaults to K 32, Scale 400, Base 10
const ratingSystem = createRatingSystem()

// get two players
const playerA = {
    id: 'playerA',
    rating: 1000,
}

mattmazzola

export function createRatingSystem(kFactor = 32, exponentDenominator = 400, exponentBase = 10): RatingSystem {
    // Standard Elo implementation with symmetric kfactor functions for each player
    // This would be a true zero-sum game where A(-x) = B(+x)
    const getPlayerProbabilities = createPlayerProbabilitiesFn(exponentBase, exponentDenominator)
    const getNextRating = createNextRatingFn(kFactor)

    return {
        getPlayerProbabilities,
        getNextRating
    }

mattmazzola

type NextRatingFn = (rating: number, actualPoints: number, expectedPoints: number) => [nextRating: number, ratingChange: number]
type KFactorFunction = (rating: number) => number

function createNextRatingFn(kFactor: number | KFactorFunction): NextRatingFn {
    const kFactorFn: KFactorFunction = typeof kFactor === 'number'
        ? () => kFactor
        : kFactor

    return (rating: number, actualPoints: number, expectedPoints: number): [number, number] => {
        const change = Math.round(kFactorFn(rating) * (actualPoints - expectedPoints))

mattmazzola

type ExpectedProbabilitiesFn = (playerARating: number, playerBRating: number) =>
    [
        playerAProbability: number,
        playerBProbability: number,
        ratingADifference: number,
        ratingBDifference: number
    ]

function createPlayerProbabilitiesFn(exponentBase: number, exponentDenominator: number): ExpectedProbabilitiesFn {
    const expectedPlayerProbabilityFn = createBaseExpectedPlayerProbabilityFn(exponentBase, exponentDenominator)

mattmazzola

function createBaseExpectedPlayerProbabilityFn(exponentBase: number, exponentDenominator: number) {
    return (ratingDifference: number): number => {
        const exponent = ratingDifference / exponentDenominator

        return 1 / (1 + Math.pow(exponentBase, exponent))
    }
}