Cómo calculamos Elo en nuestro juego de cartas

Equilibrar las calificaciones de los jugadores en un juego de cartas competitivo no es fácil — y hemos estado iterando en un sistema Elo personalizado que se adapta a Sedma, juego inspirado en Semice con métricas de rendimiento únicas.

🎯 ¿Qué hay de nuevo en nuestro sistema Elo?

✅ Dinámica K-factor El factor K controla cómo se ajustan las calificaciones rápidas. Nuestro juego adapta K basado en su calificación actual:

• ■ 1200 Elo: K = 40 (nuevos jugadores se ajustan más rápido)
• 1200–1800 Elo: K = 32 (ajuste normal)
• 1800–2200 Elo: K = 24 (más estable)
• √2200 Elo: K = 16 (muy estable)

Licencias basadas en el rendimiento Su actualización Elo no es sólo ganar / perder:

• +0.05 por ronda ganada por puntos 16 (max +0.15)
• +0.1 por ronda ganada por puntos 24 (max +0.2)
• +0.03 por ronda ganado con 4 y último (max +0.09)

✅ Mal movimiento penal Cada mala jugada aplica un malus pequeño (–0.02), tapado en el total –0.3.

¿Si pierdes pero jugaste bien? Sus bonos todavía se aplican — pero en la fuerza 10%.

---

¿Por qué este enfoque?

Queremos que Elo refleje cómo usted gana (o pierde), no sólo el resultado. Un fuerte rendimiento en una pérdida todavía debe contar para algo. Del mismo modo, gana imprudentemente con muchos malos movimientos no debería inflar las calificaciones.

---

public static void CalculateNewRatings(
ref int ratingA,
ref int ratingB,
bool playerAWon,
int badMovesA,
int badMovesB,
int wonBy16A,
int wonBy16B,
int wonBy24A,
int wonBy24B,
int wonBy4AndLastA,
int wonBy4AndLastB
)
{
    // K determines how sensitive the Elo rating is to each match outcome.
    // Higher K means faster rating changes (good for new players),
    // lower K means more stable ratings (good for experienced players).
    int kA = GetKFactor(ratingA);
    int kB = GetKFactor(ratingB);

    // Bonus and malus coefficients
    const float BonusPer16 = 0.05f;
    const float BonusPer24 = 0.1f;
    const float BonusPer4AndLast = 0.03f;
    const float MalusPerBadMove = 0.02f;

    // Caps
    const float MaxBonus16 = 0.15f;
    const float MaxBonus24 = 0.2f;
    const float MaxBonus4AndLast = 0.09f;
    const float MaxMalus = 0.3f;

    float baseScoreA = playerAWon ? 1f : 0f;
    float baseScoreB = 1f - baseScoreA;

    // Bonus for player A (full if won, 1/10 if lost)
    float multiplierA = playerAWon ? 1f : 0.1f;
    float bonusA =
        Mathf.Min(wonBy16A * BonusPer16, MaxBonus16) +
        Mathf.Min(wonBy24A * BonusPer24, MaxBonus24) +
        Mathf.Min(wonBy4AndLastA * BonusPer4AndLast, MaxBonus4AndLast);
    bonusA *= multiplierA;

    // Bonus for player B (full if won, 1/10 if lost)
    float multiplierB = playerAWon ? 0.1f : 1f;
    float bonusB =
        Mathf.Min(wonBy16B * BonusPer16, MaxBonus16) +
        Mathf.Min(wonBy24B * BonusPer24, MaxBonus24) +
        Mathf.Min(wonBy4AndLastB * BonusPer4AndLast, MaxBonus4AndLast);
    bonusB *= multiplierB;

    float malusA = Mathf.Min(badMovesA * MalusPerBadMove, MaxMalus);
    float malusB = Mathf.Min(badMovesB * MalusPerBadMove, MaxMalus);

    float adjustedScoreA = Mathf.Clamp(baseScoreA + bonusA - malusA, 0f, 1f);
    float adjustedScoreB = Mathf.Clamp(baseScoreB + bonusB - malusB, 0f, 1f);

    double expectedA = 1.0 / (1.0 + Math.Pow(10, (ratingB - ratingA) / 400.0));
    double expectedB = 1.0 / (1.0 + Math.Pow(10, (ratingA - ratingB) / 400.0));

    //Debug.Log($"[ELO CALCULATION]");
    //Debug.Log($"Player A: baseScore={baseScoreA}, bonus={bonusA}, malus={malusA}, adjustedScore={adjustedScoreA}, expected={expectedA}");
    //Debug.Log($"Player B: baseScore={baseScoreB}, bonus={bonusB}, malus={malusB}, adjustedScore={adjustedScoreB}, expected={expectedB}");
    //Debug.Log($"Old Ratings - A: {ratingA}, B: {ratingB}");


    ratingA = (int)Math.Round(ratingA + kA * (adjustedScoreA - expectedA));
    ratingB = (int)Math.Round(ratingB + kB * (adjustedScoreB - expectedB));

    //Debug.Log($"New Ratings - A: {ratingA}, B: {ratingB}");
}

private static int GetKFactor(int rating)
{
    if (rating < 1200) return 40;       // Fast adaptation for new players
    if (rating < 1800) return 32;       // Balanced default for most players
    if (rating < 2200) return 24;       // More stable for advanced players
    return 16;                          // Very stable for top-ranked
}

¿Qué sigue?

¡Este sistema es experimental! Estamos afinando activamente los coeficientes y podemos ajustar:

• Cuánta bonificaciones/malusos pesan
• Cuando los valores K cambian
• Cómo manejar los partidos o sorteos del equipo

¡Queremos tus comentarios! ¿Esta calificación se siente justa? ¿Te dejó un partido pensando que el cambio de calificación no estaba justificado? 👉 Comentarios a continuación o llegar a cabo — tu entrada nos ayuda a refinar el sistema!

---