overlord_event_system/behaviors/

arena.rs

//! Arena rating-change math (code-dispatched by the matchmaking display and
//! fight-result paths).
//!
//! Asymmetric point exchange: the opponent's KIND is decided by the honest
//! power ratio `opponent_power / player_power` at the moment of the fight —
//! below the prey threshold it's «добыча» (small reward), above the stretch
//! threshold «дерзость» (big reward), otherwise «ровня». Wins pay by kind
//! plus a capped win-streak bonus; losses also cost by kind (losing to a
//! stretch is nearly free, losing to prey is expensive) and cost NOTHING
//! below the newcomer-protection rating — the ladder cushions its floor
//! without capping the top (whales keep dominating by design).

use configs::fighting::ArenaSettings;

/// Matchup inputs for the rating math. `player_win_streak` is the streak
/// BEFORE the fight being scored (so the Nth consecutive win pays
/// `base + min((N-1)·step, max)`).
pub struct RatingChangeCtx<'a> {
    pub player_power: i64,
    pub player_rating: i64,
    pub player_win_streak: i64,
    pub opponent_power: i64,
    pub settings: &'a ArenaSettings,
}

/// Opponent kind by honest power ratio (see module docs).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OpponentKind {
    Prey,
    Peer,
    Stretch,
}

pub fn opponent_kind(
    player_power: i64,
    opponent_power: i64,
    settings: &ArenaSettings,
) -> OpponentKind {
    if player_power <= 0 {
        return OpponentKind::Peer;
    }
    let ratio = opponent_power as f64 / player_power as f64;
    if ratio < settings.rating_prey_power_ratio {
        OpponentKind::Prey
    } else if ratio > settings.rating_stretch_power_ratio {
        OpponentKind::Stretch
    } else {
        OpponentKind::Peer
    }
}

/// Rating gained on an arena win: kind base + capped win-streak bonus.
pub fn win_rating_increase(ctx: &RatingChangeCtx) -> i64 {
    let s = ctx.settings;
    let base = match opponent_kind(ctx.player_power, ctx.opponent_power, s) {
        OpponentKind::Prey => s.win_points_prey,
        OpponentKind::Peer => s.win_points_peer,
        OpponentKind::Stretch => s.win_points_stretch,
    };
    let streak_bonus = (ctx.player_win_streak.max(0) * s.win_streak_bonus_step)
        .min(s.win_streak_bonus_max)
        .max(0);
    base + streak_bonus
}

/// Rating change on an arena loss: kind-based cost (losing to a stronger
/// opponent costs less), or 0 under the newcomer-protection rating (the
/// ladder's no-point-loss floor).
pub fn lose_rating_decrease(ctx: &RatingChangeCtx) -> i64 {
    let s = ctx.settings;
    if ctx.player_rating < s.lose_protection_rating {
        return 0;
    }
    let cost = match opponent_kind(ctx.player_power, ctx.opponent_power, s) {
        OpponentKind::Prey => s.lose_points_prey,
        OpponentKind::Peer => s.lose_points_peer,
        OpponentKind::Stretch => s.lose_points_stretch,
    };
    -cost.max(0)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn settings() -> ArenaSettings {
        // Only the rating fields matter here; build via serde defaults from a
        // minimal JSON so the test doesn't hand-construct unrelated fields.
        serde_json::from_value(serde_json::json!({
            "base_rating": 1000,
            "matches_history_size": 10,
            "leaderboard_size": 100,
            "arena_tickets_currency_id": "0199958f-61b0-72f3-97ba-16dff38a93d0",
            "matchmaking_character_rating_delta": 100,
            "pvp_cooldown_secs": 60,
            "win_reward_bundle_id": "019f2358-e971-7d1f-827d-f722bea66b8c",
            "lose_reward_bundle_id": "019f2358-e971-7d1f-827d-f722bea66b8c",
            "arena_ticket_buy_currency_id": "0194d64e-2162-76d3-8449-3e850f6e39e9",
            "arena_ticket_price": {"currency_id": "0194d64e-2162-76d3-8449-3e850f6e39e9", "amount": 20},
            "arena_matches_ttl_days": 30,
            "rematch_max_rating_increase": 10,
            "rematch_max_rating_decrease": 10
        }))
        .expect("arena settings from defaults")
    }

    fn ctx(
        s: &ArenaSettings,
        power: i64,
        opp: i64,
        rating: i64,
        streak: i64,
    ) -> RatingChangeCtx<'_> {
        RatingChangeCtx {
            player_power: power,
            player_rating: rating,
            player_win_streak: streak,
            opponent_power: opp,
            settings: s,
        }
    }

    #[test]
    fn asymmetric_points_by_power_kind() {
        let s = settings();
        // prey (0.7×) pays the small base, peer (1.0×) the middle, stretch (1.3×) the big one.
        assert_eq!(
            win_rating_increase(&ctx(&s, 1000, 700, 1500, 0)),
            s.win_points_prey
        );
        assert_eq!(
            win_rating_increase(&ctx(&s, 1000, 1000, 1500, 0)),
            s.win_points_peer
        );
        assert_eq!(
            win_rating_increase(&ctx(&s, 1000, 1300, 1500, 0)),
            s.win_points_stretch
        );
    }

    #[test]
    fn win_streak_bonus_is_capped() {
        let s = settings();
        let base = s.win_points_peer;
        assert_eq!(win_rating_increase(&ctx(&s, 1000, 1000, 1500, 1)), base + 1);
        assert_eq!(
            win_rating_increase(&ctx(&s, 1000, 1000, 1500, 50)),
            base + s.win_streak_bonus_max
        );
    }

    #[test]
    fn loss_is_free_under_protection_rating() {
        let s = settings();
        assert_eq!(
            lose_rating_decrease(&ctx(&s, 1000, 1000, s.lose_protection_rating - 1, 0)),
            0
        );
        assert_eq!(
            lose_rating_decrease(&ctx(&s, 1000, 1000, s.lose_protection_rating, 0)),
            -s.lose_points_peer
        );
    }

    #[test]
    fn asymmetric_loss_by_power_kind() {
        let s = settings();
        // Losing to prey (0.7×) costs the most, to a peer the middle,
        // to a stretch (1.3×) the least.
        assert_eq!(
            lose_rating_decrease(&ctx(&s, 1000, 700, 1500, 0)),
            -s.lose_points_prey
        );
        assert_eq!(
            lose_rating_decrease(&ctx(&s, 1000, 1000, 1500, 0)),
            -s.lose_points_peer
        );
        assert_eq!(
            lose_rating_decrease(&ctx(&s, 1000, 1300, 1500, 0)),
            -s.lose_points_stretch
        );
        assert!(s.lose_points_prey > s.lose_points_peer);
        assert!(s.lose_points_peer > s.lose_points_stretch);
    }

    #[test]
    fn zero_power_player_defaults_to_peer() {
        let s = settings();
        assert_eq!(opponent_kind(0, 500, &s), OpponentKind::Peer);
    }
}