Playrade

Rules

Expected performance formula

During a live match, your Cricketer points increase or decrease based on what happens ball-by-ball, compared to an “Expected Favorable Run” set at the start of each over.

Valuation rules

Core idea

  • Performance is evaluated ball-by-ball during an over; buy/sell is paused while the over is running.
  • At the start of the over, we take a snapshot of valuations and compute expected runs (constant for the full over).
  • Each ball updates payouts; ball payouts are summed at over end and applied to update each player’s Cricketer points holdings.
Important: “Actual runs” means runs off the bat only (extras are excluded). This keeps the performance signal clean.

Expected favorable run

Expected favorable run is calculated at the start of the over (using valuations at over start) and stays constant for the whole over.

For batsman point holders

Expected favorable run is the minimum bat-runs a batsman should score against the bowler so that you earn more points.

For bowler point holders

Expected favorable run is the maximum bat-runs a bowler can concede against a batsman so that you earn more points.

Expected run per ball (constant within the over)
ExpectedRun =
((HoldingValuation + OpponentCurrentValuation) / 2) / 100 * 6
HoldingValuation = valuation of Cricketer points you hold (your average buy valuation).
OpponentCurrentValuation = opponent cricketer’s current valuation (snapshot at over start).

Quick example

HoldingValuation = 61.25, OpponentValuation = 78.75
ExpectedRun = 4.20
This expected value applies to all legal balls in the over.
If a batsman is dismissed/retired and a new batsman comes in mid-over, expected runs are recalculated using the same over-start valuation snapshot for the new batsman vs the bowler (and vice versa).

Who is included in the payout pool for a ball

For any delivery, we only consider players who hold points in the involved Cricketers.

  • all_users means: all players holding points of the relevant batsman and/or bowler for that delivery.
  • Strike rotation changes which batsman is the striker for the next ball, so “batsman pool” follows the striker where applicable.
  • Only bowler-attributed wickets use the wicket rule below; other dismissals are treated as normal deliveries and then the batsman changes.

Wager per ball

  • For legal balls, a player’s wager for a Cricketer on a ball is: wager = holding / 6.
  • If a batsman faces fewer than 6 balls in the over, we still use holding/6 for the balls they actually face.
  • Illegal deliveries (wide/no-ball) do not count as balls, but they can affect the next wager for bowler holders via a penalty mechanism.

Normal delivery (legal ball)

Uses actual bat-runs, expected run, each player’s wager (holding/6), and per-ball give-away points (FPB).

Step 1 — compute raw result (per player)
# actual: bat-runs on the ball (no extras)
# pred: ExpectedRun for that matchup
# wager: player’s wager for that ball
# sign: +1 for batsman holders, -1 for bowler holders

gap = sign * (actual - pred)
f_i = gap / 6.0
raw = wager * (1 + f_i)
Step 2 — scale so the pool is conserved
total_wager = sum(wager over all included users)
total_raw   = sum(raw over all included users)

factor = (total_wager + FPB) / total_raw  if total_raw != 0  else 1.0
payout = raw * factor
FPB = give-away points per ball (configured in the Give-away Distribution page).
Payouts are computed per ball per player, then summed across the over and applied to update holdings at over end.

Bowler wicket delivery (legal ball)

If the wicket is credited to the bowler, batsman holders lose their wager for that ball (their payout becomes 0), and the “pot” is redistributed among bowler holders.

Wicket pot + distribution
# pot = (sum of all batsman wagers for that ball) + FPB
# bowler_wager = player’s wager for bowler points
# total_wager_bowl = sum of bowler wagers across all bowler holders

batsman_payout = 0

bowler_payout_from_pot = pot * (bowler_wager / total_wager_bowl)

# Final earning for bowler holders includes returning their own wager
bowler_final_earning = bowler_payout_from_pot + bowler_wager
Why “+ bowler_wager”? The pot contains batsman wagers + FPB. Returning bowler_wager ensures bowler holders don’t lose their own stake on a successful wicket ball.
If there are no bowler holders, the pot is added back to the remaining innings give-away pool (FPB for remaining balls of the over stays unchanged).

Wide / No-ball (illegal delivery)

Wides and no-balls do not count as balls, but they apply a penalty to bowler holders that rewards striker batsman holders.

Penalty fractions

  • Wide: FRAC = 0.10
  • No-ball: FRAC = 0.30

Key rules

  • Bowler holders get no payout on that illegal delivery.
  • Batsman holders’ earnings are only payout (no “+ wager”).
  • The remaining bowler wager carries forward as the bowler wager for the next delivery.
Penalty deduction + redistribution
# wager_bowl: bowler-holder wager for this (illegal) delivery
portion   = FRAC * wager_bowl
remaining = wager_bowl - portion

# pot = sum(portion) across all bowler holders for this illegal delivery

# Distribute pot to striker batsman holders
payout_bat = pot * (bat_wager / total_wager_bats)

# Earnings (updated rule)
bat_final_earning = payout_bat
bowler_final_earning = 0

# Carry forward
next_bowler_wager = remaining
If there are no batsman holders (total_wager_bats = 0), the pot is added to the remaining innings give-away pool. FPB for remaining balls of the over remains unchanged.

Conservation rules (auditable invariants)

The system is designed so every ball is “accounted for” and can be audited.

Normal delivery invariant

After scaling, the total payout across all included users equals: 

Sum(payouts) = total_wager + FPB

Bowler wicket invariant

The pot is redistributed to bowler holders and each bowler holder also receives back their own wager: 

Sum(bowler_final_earning) = pot + total_wager_bowl

Wide / No-ball invariant

Bowler holders lose a portion (penalty) and it is redistributed to striker holders: 

Sum(bat_final_earning) = pot
Sum(bowler_final_earning) = 0

Remaining bowler wager is carried forward to the next delivery.

Important notes

  • Expected runs and valuations used during the over are based on the over-start snapshot.
  • “Actual runs” are off the bat only; extras are excluded from the normal-delivery formula.
  • Only bowler-attributed wickets trigger the wicket redistribution rule.
  • All calculations are rounded to 2 decimals for display; internal math should use Decimal.
Give-away points (FPB) are defined in: Give-away distribution.