Rift Logic Reference

Overview

Rift Logic is a small C++-style language for making claims about League of Legends that can be checked against the game's own data. It has three kinds of answer:

• Calculations: damage, healing, stats, cooldowns, projectile travel times, from the formulas the game ships with.
• Simulations: timed fights between champions or team comps, with runes, item passives, heals and shields.
• Arguments: rules that argue for or against a claim like beats(Fizz, Syndra), where the strongest argument wins.

Every result shows its working and lists every assumption the model made. A result is only as good as those assumptions, which is why they're always visible.

Running programs

In the editor, results update as you type (Ctrl/⌘ + Enter re-runs). Click a row in the results to see its working, assumptions and tables. The Inspect tab shows any champion's or item's data, including every named formula you can reach.

From the command line, the same engine runs a file:

node tools/rl.js program.rl           # full working for every result
node tools/rl.js program.rl --brief   # one line per result
echo 'print(Syndra(11).Q.damage);' | node tools/rl.js -

The exit code is 0 when every assert and prove held, and 1 when anything was refuted or errored, so programs can be used as checks.

Imports (command line only): import "../lib.rl"; at the top of a file pulls in another program's functions, rules, variables and data corrections. Paths are relative to the importing file, each file is imported once, and the imported file's own assert/print/prove output is not shown. The reasoning workspace (reasoning/) uses this to share scenario comps and rules between questions.

A first program

ItemSet burst = {Ludens, Sorc};
Champion a = Syndra(11).with(burst, Electrocute);
Champion tank = Garen(11).with(Plated, Kaenic);

assert(a.Q.damage(vs: tank) > 150);          // Proved or Refuted, with the formula
print(a.ap, a.Q.cd, a.combo(Q, E, R, vs: tank));
assert(canKill(a, tank, 5), "Syndra kills Garen in 5 seconds");

Syntax

C++ you'd sketch on a whiteboard. Statements end with ;. Comments are // … and /* … */. Strings use double quotes. There are no pointers, headers, classes or templates.

Types and values

Assignment and parameter passing copy champions, sets and comps. To change the original inside a loop or function, use a reference: for (Champion& c : team) c.target = x;.

Names: champions, items, runes

A capitalised name that isn't a variable is looked up in this order: classes (Mage), summoner spells (Flash, Ignite, …), champions, exact rune names, items, then rune name prefixes. Lower-case names are variables or ability tags (stun, dash).

• Champions are written without spaces or punctuation: KSante, MissFortune, Wukong. Syndra alone is Syndra at defaultLevel with no items; Syndra(11) sets the level.
• Items accept any unique start of the name: Ludens, Rabadon, Sorc, Plated. An ambiguous prefix is an error that lists the matches.
• Runes by name, without spaces: Electrocute, SuddenImpact, AdaptiveForce, HealthScaling.
• Ability slots P Q W E R are used in combo(Q, E, R).
• Globals: defaultLevel (11) and gameMinute (20) can be assigned.

Functions and control flow

double burstOn(Champion c, Champion t) {
    return c.combo(Q, E, vs: t) + c.proc(Ludens, vs: t);
}
bool oneShots(Champion c, Champion t) { return burstOn(c, t) >= t.hp; }

for (Champion c : blue) if (c.is(Mage)) mages++;
for (int i = 0; i < 5; i++) { … }
while (x < 10) { … }             // break and continue work as usual

Functions can be declared anywhere at the top level and called before their declaration. Parameters need types; a function with a return type other than void must return. Programs are stopped after about three million steps, which catches endless loops.

assert, print, prove

Every result lists its assumptions: ranks chosen for you, facts you asserted, item passives not modelled, simulator simplifications.

Champion

Making and changing

Stats

Methods

Fight settings

Ability

Item and ItemSet

Rune

Runes go into with() or a.runes.add(). Shards can be repeated: .with(AdaptiveForce, AdaptiveForce, HealthScaling). Conqueror.description returns the rune's text, which is where its numbers come from. runes() lists every rune. See Modelled runes for which ones change stats and which act in fights.

Summoner spells

Flash, Ghost, Heal, Barrier, Ignite, Exhaust and Cleanse are values of type Summoner. Give a champion two with x.with(Flash, Ignite) or x.summoners = {Flash, Ignite};. A champion without any set is assumed to have whichever one you use (the result says so).

Champion o = Orianna(11).with(Flash, Ignite);
print(o.Flash.cooldown, o.Ignite.damage);           // 300, 300 at level 11
prove canDodge(o, Syndra(11).Q, distance: 800, using: o.Flash);
Combo c = {Flash, Q, W, Ignite};
print(Annie(11).perform(c, vs: Dummy(hp: 3000)).damage);

.cooldown uses summoner spell haste: base × 100 ÷ (100 + haste), from Ionian Boots of Lucidity (10), Crimson Lucidity (20) and Cosmic Insight (18). Numbers that scale with level use the champion's level (x.Ignite.damage) or defaultLevel (Ignite.damage).

• Dodging: using: Flash, using: Ghost, using: Heal (its speed), or combined with abilities: using: {o.W, Flash}. See Physics and dodging.
• Combos: Combo c = {Flash, R, Ignite};. Ignite adds its true damage (5 ticks, one every 1.056 s) and grievous wounds; Exhaust cuts the target's damage by 35% for 3 s; Heal and Barrier heal and shield the user. A summoner the champion didn't take is skipped; one on cooldown is waited for, like abilities.
• Fights: a champion with .summoners set uses Ignite and Exhaust as soon as it fights (Exhaust on the enemy with the most AD + AP), and Heal and Barrier below 30% health. Flash, Ghost and Cleanse don't change fight numbers.

TeamComp and lists

Fight

Combo

A combo is an exact sequence of abilities and auto attacks, run through the fight simulator against one target, so every proc applies: spellblade after abilities, Electrocute on the third separate hit, Luden's, on-hit items, crits, burns, and the target's shields, Zhonya's and healers.

Combo burst = {R, E, Q, AA};               // AA = one auto attack
Combo full = burst + W + Q;                // or Combo(Q, AA) + E, or c.add(W)
ComboResult r = zed.perform(full, vs: lux);
print(r.damage, r.time, r.killed, r.steps);

Each step happens as soon as it can: an ability when it's off cooldown (casts lock the champion for 0.25 s), an auto attack when the attack timer allows. Every step hits; the assumptions list says so.

Rounding. The game shows whole numbers in floating combat text and on the dummy. Whether it rounds or truncates damage numbers is not documented: the wiki only says the health bar rounds up and the C panel rounds armor, MR, AD and AP to the nearest whole number (wiki “Health”). floatingText shows both until measurements settle it; the practice tests allow ±1 per displayed number.

Practice-tool dummy

Dummy(hp:, armor:, mr:) is the Practice Tool target dummy, usable wherever a target Champion is: x.Q.damage(vs: d), x.proc(Item, vs: d), x.perform(combo, vs: d), canKill, timeToKill, fight. All settings are optional.

Dummy d = Dummy();                           // 1000 health, 0 armor, 0 MR
Dummy big = Dummy(hp: 3000, resists: 50);    // 20 × Add 100 Max HP, 5 × Add 10 Resistances
print(big);                                  // Target Dummy (practice tool: 3000 health, 50 armor, 50 magic resist)
auto r = Syndra(11).perform({Q, W, E}, vs: big);
print(r.floatingText);

Measurements from practice-tool sessions go in tests/practice/ (format in its README); tools/practice_to_tests.py turns them into assertions that the regression gate runs.

Built-in functions

Rules and claims

rule dive(Champion x, Champion y) -> beats(x, y) [1] {
    return x.is(Assassin) && x.has(mobile) && !y.has(mobile);
}
rule stunTheDive(Champion x, Champion y) -> !beats(x, y) [2] {
    return x.has(mobile) && y.has(stun);
}
prove beats(Fizz, Syndra);

• A rule is an argument that the claim is true (-> beats(x, y)) or false (-> !beats(x, y)) whenever its body returns true. [n] is its strength, default 1.
• For a claim, every rule with that name and number of arguments is tried. The strongest argument that fires wins. If the strongest for and against are equally strong, the claim is contested. If none fire, no rule applies.
• A body written as return c1 && c2 && c3; is shown condition by condition, with the evidence for each (the tooltip phrase behind a tag, the formula behind a number). Other bodies are shown as a whole.
• Claims can be used inside functions and other rules as booleans: beats(a, b). A claim is true only when it's proved. Sub-proofs are shown nested.
• Rule arguments are the parameter names in the claim, in order: -> counters(y, x) is allowed.

Correcting the data

Tags are read from tooltip text, and a few physics values are missing from the game files. Correct them in your program. Every result that uses a correction lists it under Holds only if you accept.

Corrections apply to that champion everywhere in the program, from the line where they're made.

Physics and dodging

canDodge(defender, ability, distance: d, using: defender.X, reaction: r, preBuff: bool, hitbox: units) checks whether the defender can avoid an ability aimed perfectly at them from d units away.

Where it comes from. Range doesn't always mean the ability travels from the champion to the target. Every ability has a delivery (a.Q.delivery), read from the game files' targeting type and corrected by hand where they mislead (each correction cites its source):

• Arrival time (a.Q.arrival(distance: d)) is measured from the start of the cast, by the delivery's formula above.
• Time to respond = arrival time − the moment it becomes visible − reaction time (default 0, perfect play). It becomes visible when the cast ends (the missile or ground marker appears then; during the cast time the target point can't be seen), unless its data says it shows later (Rumble R: nothing is on the ground until the first rockets land). So Syndra Q gives 0.6 s to respond at any distance.
• Hitbox: the defender's gameplay radius (b.hitbox: 65 for most champions, 80 for large ones, 55 for small ones). Test a grown champion with hitbox: 100.
• Out of reach: beyond the reach above plus the defender's hitbox, the defender is safe standing still.
• Walking: the defender must move half the width (lines), the radius (areas) or the cone's half-width at that distance, plus their hitbox, before it lands. Move speed includes boots and other items, runes and League's soft caps (b.ms). For an area centred on the caster, they walk out of it instead. The line prints the move speed that would be needed.
• Point-and-click abilities can't be walked out of.
• using: an ability that makes the defender untargetable or invulnerable dodges anything if its cast time is shorter than the time to respond. A dash or blink adds its distance (after its cast and travel time), then the defender keeps walking. A move-speed boost (Orianna W, Hecarim E, Singed R, Ghost, Heal, …) starts after its cast: the defender stands still while casting, then walks at the boosted speed (with its decay, ramp or field, and League's soft caps above 415). Perfect play: the defender uses whatever moves it farthest, so a boost whose cast costs more than it gains is skipped and plain walking counts.
• preBuff: true: the move-speed boosts in using: were cast before the ability appeared, so they're already running (fresh) when the time to respond starts, and cost no cast time.
• Several at once: using: {o.W, Flash} tries every combination of the listed abilities and summoner spells (boost casts first, then dashes and blinks, then walking) and uses the best. using: Flash adds a 400-unit blink with no cast time.

setPhysics also takes delivery: "placed" (or any of the above), origin: (units from the remote object to the target), length: (a vector's length), reveal: (seconds into the cast when it becomes visible) and reach:.

How fights are simulated

• Time moves in 0.05-second steps. Within a step everyone acts at once, on the state at the start of the step: first items, summoner spells, heals and shields, then everything else. Damage between the sides (and the healing it causes), deaths, walking, blinks, new crowd control (and the interruptions it causes), stasis and knockbacks take effect at the end of the step. So the order of the champions, and which side is side 1, doesn't change the result: a mirror match ends even, and fight(a, b) is fight(b, a) with the sides swapped (tests/fight_symmetry.rl). Two champions can kill each other in the same step. The line is centred on 0 (side 1's front at −start/2) so mirrored positions are exact.
• Each champion, when free, first uses a heal or shield if an ally needs one (healing ultimates are saved for allies below 40% health), then peels (below), then the first ability in its rotation that is off cooldown and in reach, otherwise an auto attack if the target is in attack range, otherwise it moves. Casting locks the champion for 0.25 seconds. See Crowd control and positions.
• Damage goes through amplifiers, resistances after penetration, Bone Plating and shields, then health. Lifesteal (attacks), omnivamp and Conqueror heal the attacker; grievous wounds cut healing received by 40%.
• Heals go to whoever the healer's policy picks; team heals reach everyone; Moonstone chains 30% to a second ally.
• Zhonya's (below 30% health) puts a champion in 2.5 seconds of stasis; Guardian Angel revives once after 4 seconds.
• Summoner spells (only for champions with .summoners set, or as combo steps): Ignite and Exhaust on first contact, Heal and Barrier below 30% health.
• The fight ends when one side has nobody left, or at the time limit.

Crowd control and positions

Positions

• One line, centred on 0. Side 1's front is at −start/2 and faces +; side 2's front is at +start/2 and faces − (start: default 0). Each champion stands max(0, attack range − 175) behind its front, so ranged champions start at their attack range from where the enemy front will be (formation: false: everyone on the front line).
• Reach (wiki "Range"): basic attacks use edge range (attack range + both gameplay radii); point-and-click abilities centred range; other abilities their reach (.reach) + the target's radius. Placed and lobbed areas hit every enemy within their radius of the target; self-centred areas every enemy within the radius of the caster; lines and cones every enemy within reach (on one line everything is in the path).
• Walking uses the current move speed: (base + flat) × (1 + % bonuses) × (1 − the strongest slow × (1 − slow resist)), then the soft caps (wiki "Movement speed": only the strongest slow counts).
• Dashes and blinks (abilities tagged dash or blink) use the dash range and speed from the game data (dashInfo; 1200 units/s when the data has none). A dash ends touching its target or at its range; its hits land when it arrives. A blink moves at once.
• Knockbacks move the target away from the caster by the data distance over the airborne time (Janna R: to 875 units from her; Gragas R 900; Alistar W 700; Vayne E 475); pulls move it toward the caster. A placed knockback (Gragas R) is aimed away from the caster's team, or toward it for role "engage". Knockbacks whose distance neither source gives (Gragas E, Draven E, Ornn Q) only make the target airborne.

Roles (x.role)

An enemy "dives" ally A when it is within its own attack range (+ 50) of A and A's attack range is longer. Spell shields, Morgana E and cleanses react perfectly: Sivir E and Nocturne W are raised as a hostile ability lands; Morgana E is cast on the ally a hard crowd control is about to land on (if in range); Quicksilver Sash and Mercurial Scimitar cleanse as soon as a cleansable crowd control lands; Mikael's Blessing is used on a crowd-controlled ally.

Crowd control types

Source: wiki "Types of Crowd Control" (summary table). Tenacity (wiki "Tenacity") shortens every type except airborne, suppression and drowsy, to no less than 0.3 s; items, elixirs and the rune shard stack multiplicatively (1 − (1 − a)(1 − b)…). Quicksilver removes everything except airborne (suppression included); Mikael's Blessing removes stuns, roots, silences, polymorphs, forced actions, sleep and slows, not suppression or airborne. Spell shields (Banshee's Veil, Edge of Night, Verdant Barrier, Sivir E, Nocturne W) block one whole ability, crowd control included.

Where the numbers come from

src/cc_export.py reads which crowd control each ability applies from the wiki ability text ({{tip|stun|…}} for {{fd|1}} seconds, knock back 900 units, slowed by 80%) and takes the value from the game data (StunDuration, RootDuration, KnockupDuration, KnockbackDistance, SlowAmount, …) when one exists and agrees with the wiki at every rank; otherwise the wiki's value, and the working says so. Where they disagree the wiki value is used and the game data value is shown (python src/cc_export.py lists them: KSante Q, Rammus Q, Urgot E, Hwei R, Lissandra R, Maokai Q…). Durations that grow with distance travelled (Xerath E 0.75–2.25 s, Braum R) are assumed linear up to the ability's reach; charge-dependent ones (Janna Q, K'Sante W, Sion Q) use the uncharged value, since fights cast at once. Kennen's Mark of the Storm is modelled: every ability hit marks, the third mark stuns 1.25 s (0.5 s if stunned by it within 6 s; game data), Slicing Maelstrom marks each target up to 3 times. Effects the wiki makes conditional on terrain (Vayne E stun, Poppy E stun, Ornn E) are left out, as are effects with no known duration (the assumptions list each one). Braum R: the first target's knock-up grows from 0.6 s with distance, assumed linear up to the ability's reach.

Damage, healing, stats

• Stats at a level: base + growth × (level − 1) × (0.7025 + 0.0175 × (level − 1)), the game's formula.
• Ability formulas are evaluated from the game's calculation trees: per-rank values, stat ratios (total, bonus or base), level curves, sums, products and clamps. Stack-based parts count as 0 stacks (noted).
• Resistances: percent penetration first, then flat (lethality is flat armor penetration); damage × 100 ÷ (100 + resist), or 2 − 100 ÷ (100 − resist) below zero.
• Adaptive runes give AD when bonus AD exceeds AP and AP when AP exceeds bonus AD (1 adaptive = 0.6 AD or 1 AP). The AP compared includes Rabadon's +30%, which then also amplifies adaptive AP. A tie (e.g. no items) goes to the champion's adaptive type from the game files (Zed: AD, Syndra: AP). Adaptive damage is physical or magic by the same test.
• Abilities that apply on-hit effects (the wiki's "Attack effects" list: Katarina's Shunpo, Sinister Steel and Death Lotus, Ezreal Q, Fiora Q, Gangplank Q, Irelia Q, Yasuo Q, Yone Q…) trigger on-hit items at the listed effectiveness (Death Lotus 25/30/35%, Master Yi Q 18.75%, Urgot W 50%…). Channels like Death Lotus are separate hits (15 daggers per target). Ones that also trigger on-attack effects count as basic attacks for Kraken Slayer, Terminus and Hullbreaker stacks. On-hit-only ones stack and consume Kraken's Bring It Down, per the wiki's Kraken Slayer page, but build no Terminus stacks (assumed).
• Critical strikes deal 200% (base; Infinity Edge +30% = 230%). Ashe's crits deal no bonus damage.
• Attack speed is capped at 3.003 (one attack per 0.333 s); Bel'Veth has no cap. Cap exceptions that only last during an ability (Jinx, Kennen, Varus, Sion, Zeri) aren't modelled.
• Move speed = (base + flat) × (1 + % bonuses), then soft caps: above 415 → × 0.8 + 83, above 490 → × 0.5 + 230.
• Item limits from the game's item data: one pair of boots, one Blight item (Void Staff, Cryptbloom, Terminus…), one Hydra, one Spellblade, no two copies of a legendary, and so on. Breaking one is an error.
• Cooldowns: base × 100 ÷ (100 + ability haste). Haste that one ability gives another (Syndra R: Dark Sphere +10 per R rank) is included.
• Heals: formula × (1 + heal & shield power) × (1 + healing received), capped at missing health.

Modelled runes

Values the rune text gives as a range “based on level” are spread evenly from level 1 to 18 unless the wiki gives another curve (Fleet Footwork follows the champion-growth curve). Stacks earned before the fight (Legend runes, Ultimate Hunter, Overgrowth, Dark Harvest souls, Manaflow Band mana) start at 0, as in a fresh practice-tool game; set them with a.stacks(LegendAlacrity, 10). Gathering Storm, Conditioning and Biscuit Delivery follow gameMinute. Every rune's status, source and approximation is in the runes audit (outputs/runes_audit/RUNES.md), and every choice appears in the assumptions.

Modelled item passives

Every item's stats are always included. These items' passives and actives are also modelled in fights and combos, using the values in the game data (the few values the data lacks come from the item text):

These items have nothing a fight can see (movement, vision, mana, cleanses, gold); a build that contains one says so in the assumptions:

Stacks earned before a fight (Heartsteel, Mejai's, Hubris, Yun Tal, Rod of Ages…) start at 0, as when you buy the item in the practice tool; set them with a.stacks(Item, n). Every approximation (for example Energized items recharging only from attacks, because nobody moves) is listed in the assumptions of any result that uses the item.

Ability tags

Tags are read from each ability's tooltip text. mobile means dash or blink; hardcc means any hard crowd control; targeted means point-and-click. The Inspect tab shows the phrase behind every tag.

Data sources

• Riot Data Dragon (patch —): champion stats, ability tooltips, cooldowns, ranges, item names and prices.
• CommunityDragon game files: ability calculation trees, per-rank values, projectile speeds, widths, cast times; item stats and passive values.
• Client rune data: rune descriptions, whose numbers the rune model uses.

The data is rebuilt for a new patch with python src/fetch_static.py, python src/calc_export.py and python src/kb_export.py.

Limits

• A proof holds for the model, not the live game. The assumptions list says exactly where the two can differ.
• Tooltip-derived tags and damage types can be wrong; check the evidence and correct with addTag / removeTag.
• Champion-specific mechanics (Zed's shadows, stored damage, stacking passives, empowered recasts) are only as good as the tooltip formula.
• Fights are one-dimensional: no terrain, walls, flanks or body blocking, and area abilities catch everyone within their radius on the line (2-D spacing would catch fewer). Mana is ignored. Physics checks assume perfect aim and a straight-line dodge.