Randomu' Oltenesc

Scor Compozit (calculat in timp real)

Rating-ul se calculeaza din datele raw ale meciului, comparat cu toti participantii prin rank-normalizare. Formula e role-agnostic — tank, support, ADC sau fighter sunt evaluate echitabil. Nu exista bonus/penalizare pentru victorie/infrangere — scopul e masurarea contributiei individuale pentru echilibrarea echipelor.

Formula

Composite = 0.70×Impact + 0.15×Supravietuire + 0.15×Eficienta

Se aplica o functie de stretch (exponent 0.35) pentru a mari diferentele intre jucatori:

Rating = 1.0 + 9.0 × stretch(Composite) + Bonusuri

Rank-normalizare

Fiecare metrica se compara cu toti participantii meciului prin ranking (cel mai bun = 1.0, cel mai slab = 0.0). In meciuri mici (2-4 jucatori) se aplica damping care trage scorurile catre 0.5 pentru a evita extremele. Asta inseamna ca un meci de 3v3 nu va produce rating-uri la fel de polarizate ca un 5v5.

Bonusuri & Penalizari

Se aplica dupa calculul compozit. Unele sunt scalate cu numarul de jucatori (meciuri mici = penalizari mai blande).

Ce NU afecteaza ratingul

• Victoria/Infrangerea — nu exista bonus de win/loss. Rating-ul masoara contributia individuala, nu rezultatul meciului. Asta previne feedback loop-ul unde jucatorii cu rating mare ajung in echipe mai bune, castiga, si primesc rating si mai mare.

De ce e fair pentru orice rol?

• Tank — primeste credit prin Tank Share (Impact), bonus "The Frontline", si Survival redus la 15% ca sa nu fie penalizat pentru deaths inevitabile din engage
• Support — primeste credit prin Support Score (healing + CC), protejat de penalizarile "Passenger" si "Gold Sink" daca are healing/CC ridicat
• ADC/Mage — primeste credit prin Damage Share si Damage/Gold efficiency
• Fighter/Bruiser — beneficiaza de mix: damage share, tank share, si KP ridicat

Rating overall

Tabul Last 10 Games foloseste ultimele 10 meciuri. Tabul Overall foloseste ultimele maximum 100 de meciuri per player, cu minimum 10 meciuri pentru eligibilitate.

Codul sursa

// ── Rank-normalizare ──
function rankNormalize(values) {
  const n = values.length;
  if (n <= 1) return values.map(() => 0.5);
  const indexed = values.map((v, i) => ({ v, i }));
  indexed.sort((a, b) => b.v - a.v);
  const scores = new Array(n);
  // damping: N=2 → 0.4, N=3 → 0.6, N=5 → 0.8, N>=8 → ~1.0
  const damping = Math.min(1, 1 - 2 / (n + 1));
  for (let rank = 0; rank < n; rank++) {
    const raw = 1 - (rank / (n - 1));
    scores[indexed[rank].i] = 0.5 + (raw - 0.5) * damping;
  }
  return scores;
}

// ── Stretch + Rating ──
function stretchFromCenter(value, exp) {
  if (value < 0.5) return 0.5 - Math.pow((0.5 - value) / 0.5, exp) * 0.5;
  return 0.5 + Math.pow((value - 0.5) / 0.5, exp) * 0.5;
}

function compositeToRating(composite, bonusAdj) {
  const stretched = stretchFromCenter(Math.max(0, Math.min(1, composite)), 0.35);
  return Math.max(1.0, Math.min(10.0, Math.round((1.0 + 9.0 * stretched + bonusAdj) * 100) / 100));
}

// ── Raw metrics per participant ──
const raw = participants.map(p => ({
  kp:              Math.min(1, (p.kills + p.assists) / teamKills),
  damage_share:    p.damage / teamDamage,
  tank_share:      (p.damage_taken + p.self_mitigated) / teamTakenMit,
  support_metric:  p.healing + p.cc_score * 100,
  ka_share:        (p.kills + p.assists) / teamKA,
  kda:             (p.kills + p.assists) / (p.deaths + 1),
  damage_per_gold: p.damage / p.gold,
  cc_per_gold:     p.cc_score / p.gold,
}));

// ── Rank-normalize all metrics ──
const rSupport     = rankNormalize(raw.map(r => r.support_metric));
const rKda         = rankNormalize(raw.map(r => r.kda));
const rDmgPerGold  = rankNormalize(raw.map(r => r.damage_per_gold));
const rCcPerGold   = rankNormalize(raw.map(r => r.cc_per_gold));
const rDamage      = rankNormalize(raw.map(r => r.damage));
const rGold        = rankNormalize(raw.map(r => r.gold));
const rDeaths      = rankNormalize(raw.map(r => -r.deaths));
const rKp          = rankNormalize(raw.map(r => r.kp));
const rHealing     = rankNormalize(raw.map(r => r.support_metric));
const rDamageTaken = rankNormalize(raw.map(r => r.damage_taken + r.self_mitigated));

// ═══ 1. IMPACT (60%) ═══
const rolePerf = Math.min(1, Math.max(
  r.damage_share * 5,   // Damage dealer
  r.tank_share * 5,     // Tank
  rSupport[i]           // Support (rank-normalized)
));
const impact = 0.40 * r.kp + 0.35 * rolePerf + 0.25 * r.ka_share;

// ═══ 2. SURVIVAL (15%) ═══
const survival = rKda[i];

// ═══ 3. EFFICIENCY (15%) ═══
const efficiency = Math.max(rDmgPerGold[i], rCcPerGold[i]);

// ═══ Composite ═══
let composite = 0.70 * impact + 0.15 * survival + 0.15 * efficiency;

// ═══ Bonusuri & Penalizari ═══
const bScale = Math.min(1, (n - 1) / 9);
const isHealer = rHealing[i] >= 0.75;  // top 2 support

if (rank1Damage && rank1KP) bonus += 0.60;                         // The Carry
if (fewestDeaths && r.kp > 0.50) bonus += 0.40;                    // Smart Player
if (mostTakenMitigated && r.kp > 0.40) bonus += 0.40;              // The Frontline
if (r.kp < 0.70 && bottomDamage && lowestKP && !protected) bonus -= 1.50;
if (topGold && r.damage_share < 0.35 && !protected) bonus -= 0.70;
if (mostDeaths && r.kp < 0.80 && weakDamage && !protected) bonus -= 0.50;

// ═══ Final Rating (1-10) ═══
rating = compositeToRating(composite, bonus);