INSANE!

What INSANE! is

The original Little Fighter 2 has four computer levels: Easy, Normal, Difficult and CRAZY!. Its computer player is a set of rules written for the original fighters, keyed by their ids. Put it in a mod (One Piece GrandWorld, Naruto: The Setting Dawn, KT-LF2, Sx2…) and it has no idea what the new moves are, so it mostly punches, kicks and throws the odd D+A at random.

INSANE! is a fifth level, selected right after CRAZY! on the character selection screen (and in Tournament and Battle mode). It contains no line about Luffy or Naruto: everything it knows about a fighter comes from playing each of that fighter's moves itself, in a private copy of the match, before the match begins. That is why it can use the moves of mods nobody has ever written an AI for.

How it learns and fights

All of it lives in one Lua file. There is no training step and no GPU: all of its "knowledge" is recomputed from the mod's data when a match starts, in exactly the same way on every machine.

1. Learning the moves. For each fighter, the AI builds a small private copy of the match (just the fighter and a dummy) and presses every key combination: D+A and D+J in each direction, D+J+A, the punches, the running, jumping and dashing attacks, and the keys pressed during a move (chains, including counters out of the guard). It records where and when each move hits, how hard, what it costs in MP, when the fighter is free again, and where the things the move spawns (projectiles, clones, fields) fly.
2. Predicting. Every frame of the match it works out which enemy attack is about to reach it (including projectiles in flight), how long the opponent stays stunned or down, whether the opponent is blinking (invulnerable), and after how many frames each of its own moves would land if started now.
3. Choosing a move. Each move is scored: damage, the chance of being guarded, the risk that the opponent hits back before the move lands, MP cost, how long the fighter is left open afterwards. Slow moves (Luffy's 585-damage special takes 44 frames to come out) are used only when the opponent is locked down long enough. A move not yet used in the match gets a small bonus, so spectators see the whole kit.
4. Defence and positioning. Guard or sidestep what is coming, never guard a blow that would break the guard, stand just outside the opponent's arms so it has to walk into the AI's own blow, avoid the danger zones of its quick strong moves, walk around obstacles, run when far away, jump in or dash in when an air move would land.
5. Stances and charging. Held moves (Blackbeard's dark field, the chakra charge in Naruto) are kept as long as they serve and left in time; MP is charged when the opponent is far away or lying down.
6. Knocked down. When sent flying, the AI flips back up early only if the landing spot is safe; if the opponent is waiting there, it lets the fall finish (a lying fighter cannot be hit), gets up during the invulnerability blink, and uses that blink to strike first.
7. Knowing the opponent. The opponent's data says what it can do; how it plays says what it will do. During the match the AI counts what its opponent does: the blows it guards against the blows that land, how often it attacks when someone is within its reach, whether it flips up out of every fall, how much it jumps. A guard-happy opponent makes guard-breaking moves and grabs worth more and ordinary blows worth less; a passive one is walked up to instead of baited; one that always flips up is met where its roll ends. Everything is counted from the match state alone, so network games stay in sync.
8. Weapons, teleports and a partner. A knife, stick, stone or drink lying nearby is walked onto and picked up when nothing presses; the AI plays its moves again with the weapon in hand, so it knows what the fighter does with it (swing, throw, drink) and uses it like any other move — a knife is thrown at the opponent, a drink is kept for when HP or MP run low. Moves that teleport to the enemy are aimed from where the fighter lands, not from where it stands. Two against one, the second fighter goes round to the other side so the enemy cannot guard both.
9. Forms of a mod's own making. Many mods build a stronger form on an invisible item: Luffy's Gear Second in One Piece GrandWorld is a defend move that lays down an item nobody sees and picks it up at once, and with that item in hand every key does something else — faster runs, harder blows, a drain on MP every frame. The AI finds such moves because the item ends up in its fighter's hand, plays the form's keys in the copy too (its attacks, jumps, runs and what they chain into), measures what it burns and how fast it runs, and weighs it against the fighter's ordinary kit. A form worth it is entered when the opponent is held or far enough away, fought in with its own moves and runs, and, when its MP is about to run out, let end away from the enemy's arms. Sanji's Diable Jambe and a Rasengan formed in the hand work the same way; a form reached from inside another form (Zoro's Asura) is not learned yet.
10. Untouchable forms, healing, flight. Mods keep bodies far above or below the visible layer — a thousand pixels and more — for interactions of their own, and a frame whose bodies are all out there is out of reach of every blow except those aimed at the same layer. Drake's T-rex and Magellan's Venom Demon in One Piece GrandWorld are built that way: invulnerable while MP lasts. The AI reckons, for each opponent, which of its own frames that opponent's blows (and what it throws) can still reach; a form whose resting and moving frames none of them reaches is worth entering for that alone, and in it the fighter walks straight up and strikes instead of minding the opponent's reach — its own run or creeping walk steered onto the opponent's line and stopped with the form's own key. A move that restores HP (Marco's phoenix, state 1700) is measured in the copy with HP missing, and used when much of the HP lost can still come back and nothing can reach the fighter meanwhile. The roll out of a run is learned with what its frames lead to (Marco takes off as a phoenix with jump and strikes from the flight), and a flight that steers in depth is flown onto the opponent's line.
11. Respecting the get-up. A fallen opponent cannot be hit until it is up again, and after it rises it is invulnerable for a moment while it can already strike. Until the AI's quickest blow could land as that moment ends, it waits outside the opponent's arms instead of beside it — farther away, and longer, when its own HP is low.
12. Approaching beside the line of fire. A free opponent with a long blow — a beam, a sweep, a special struck out of the guard — covers the whole line between the two fighters, and a melee fighter walking straight along it steps into that blow at every pace. The AI now approaches such an opponent beside the line, offset in depth by the blow's width, and steps onto the line only as its own blows come into reach.
13. Trapped opponents. Some mods hold an opponent with an object (Yamato's wood prison in Naruto: The Setting Dawn). The AI knows a held opponent is harmless and, when the trap lets blows through, hittable: it walks up and strikes — or, when its MP is short of a strong move and the hold has time to spare, charges MP first, while the trap keeps the opponent harmless, and lands the strong move before the hold ends. A trap is never set again on an opponent already held: cast on and on from afar, it only held the opponent on, and the two fighters stood there for the rest of the match.
14. Out of the wake-up blows. A fallen opponent gets up invulnerable for a moment and can strike at once — in some mods with a blow that reaches half the stage (Yamato's wood spike). Standing beside it is a blow taken for nothing, and so is standing anywhere its quick moves reach. The AI now works out where those moves strike (and how far in depth, with the step the opponent can take once it is up) and is out of that zone by the time the opponent is on its feet, by the quicker way: a few steps in depth off its line, or back out of reach, as on a stage too shallow for the first; off the line it may wait at its own range rather than far away. Which side of the line has room is judged from the opponent's line, so on a stage only a few steps deep it does not turn back and forth (version 28: before, Rock Lee walked to and fro on a fallen Neji's line on Hot Springs until Neji got up, or waited just off it, to be inside the zone again as Neji rose). It does not charge MP, drink or pick up a weapon inside the zone, and a charge stance beside a fallen opponent is left early enough to get out.
15. Weighing the counter along the way. Before a move, the AI already asked whether the opponent's quickest answer would land first; it asked that from where the fighter stood. A rush or a jump-in carries the fighter into blows that did not reach its starting spot, and a punch the opponent starts as the rush sets off lands first there. The question is now asked along the move's own path, frame by frame, and out of the air for a jump-in. An opponent in a charge stance is known to be free the moment it can leave the stance, with the MP the charge brings in meanwhile; a trade (both blows landing together) is struck first only when the AI's blow is clearly the heavier.
16. Weighing the risk, and learning it in the match. Version 23 did not start a blow that the opponent's quicker answer could beat on its way — as if the opponent always fired at the worst moment. A fighter that has to rush in (Rock Lee against Neji, whose quick beam covers the whole line) then rushed half as often and lost its share of the fight while walking about: standing off is no answer to long arms either. Version 24 weighs such a blow instead: what it brings if the answer does not come, against the answer's damage times how often this opponent has answered so far — counted in the match itself, from the AI's own rushes that were struck before they landed, starting hopeful. Against an opponent that punishes, the AI soon stops rushing; against one that does not, it keeps going. Like everything else, the count is taken from the match state alone.
17. Out of the way with a move of its own. When something is coming that no step in depth, jump or step back gets the fighter out of, version 25 looks through the fighter's own moves for one whose path no blow on its way meets: a teleport, a rush, a leap. Kuma in One Piece GrandWorld vanishes as he jumps (defend pressed in the jump — keys a mod's jump takes are now learned as moves too) and comes down behind the enemy, untouchable on the way. Such a move is taken against a blow the guard cannot hold, against a heavy one when MP is left for a strong move afterwards, or when it strikes back on the way; otherwise the AI guards in time rather than start a move that cannot come out before the blow lands. A teleport is reckoned to land where the game puts it: in front of the enemy, or behind it when the move turns the fighter round first.
18. Steady on its feet. In LF2 a direction key turns the fighter and walks it, so every turn round is a step. Version 25 forgot that at the edges it keeps: it stepped back from an enemy much too close, turned round to face it — a step back in — and stepped back again, frame after frame; the same at the edge of an enemy's quick blows and of a fallen enemy's wake-up blows, and between two ways out of them. The faster the fighter walks the worse it was (a Naruto of Naruto 2.4 walks 17 pixels a frame), and the less MP, the more of a match goes on walking — players saw it most at low MP and took it for the AI torn between a weapon on the ground and its opponent. Version 26 steps back until turning round again leaves room, waits at those edges instead of stepping in and out, keeps a way out once chosen, and turns round at most once every few frames while walking. In 70 games of Naruto 2.4, turns within three frames of the previous one fell from 116 to under 3 in every thousand frames.
19. Beside the line of a wave. Neji's air palm in Naruto 2.4 is a wind sent along the ground at 55 pixels a frame, across the stage, and it cannot be guarded. The approach beside the line of a long blow (version 22) looked only at a move's first frames, so from afar the line seemed safe; it also stopped while Neji charged chakra or was short of MP, which he charges back in moments; and a run was steered back onto the line right after a palm was dodged. Version 26 reckons such a wave all the way out, keeps beside its line whenever the opponent will be free and able to pay for it by the time the fighter gets there, and steps or steers onto the line only once no wave flies along it. Gaara, who lost to Neji 16 games in 20, now wins 17 in 20; the single palm hits him a tenth as often.

A mod's own AI scripts (ai/*.as, as Dragon Ball Super's or Sauce's "lf2-AI VS and Stage Challenge") play its fighters at CRAZY! and below; INSANE! and XOI play at their own levels whatever scripts the mod has (up to version 40 a fighter with a script of its own kept it at those levels too, which in Sauce's pack made the levels named INSANE! and XOI that AI).

What INSANE! is aware of — and where it stands

A summary of what the computer player perceives, what it can do with it, and what is still to come. Each line names the version that brought it; the page's version badge above is read from the game build itself.

How smart is it now? Against the mods' own computer players at CRAZY! it wins most fights (table below); against the original fighters, which CRAZY! already knows by heart, it is only somewhat ahead; a human who keeps changing habits is still the hardest opponent, because every habit it learns takes some seconds of play to show.

Version history

• …The history is read from the game build (insane-version.json); it is in smart_ai.lua as well.

XOI — INSANE! with tuned numbers and a memory of training

INSANE! starts every match knowing what each move can do, from playing it in a copy of the game — but not how it fares against one particular opponent: a combo that lands on a still dummy may be cut short by Neji's quick palm nearly every time, while a modest-looking special lands four times in five. XOI, the level after INSANE!, plays as INSANE! does, with two things INSANE! has not: the numbers its judgement rests on tuned by play, and notes of training.

1. Training. A bench job plays many games — 100 to 200 — of every pair of the mod's fighters, both played by INSANE!, and writes down, for each fighter against each opponent and each move it chose: how often it landed, how often the fighter was hit before it did, the damage dealt and taken while it ran (its follow-ups included) and what the AI expected of it; and how often the opponent struck first a move started at a risk. On Windows, xoi-hoc.bat spreads the pairs over every processor of the machine and packs the notes into a copy of the mod's file (xoi/notes.txt, beside its data folder), ready for the relay.
2. Playing. At XOI a move's score is weighed by how much of what was expected of it, against this opponent, it brought — against how much the fighter's moves brought on the whole. A move seldom tried stays near the average (its record counts over a few starts' worth of the average), and the weight stays between 0.5 and 1.6: the notes tilt choices rather than make them. The opponent's answers to a risky rush are expected from what training saw, and the match goes on counting them.
3. The situation, too (version 27). Training also writes down each move's record by the situation it was started in — what the opponent was doing (on its feet facing the fighter or turned away, busy in a move, in the air, guarding, hurt or held), how far off it was (near, middle, far) and whether the fighter's own HP had run low — and, for every spot the fighter stood on with both fighters free (by distance, depth and side), the damage dealt and taken in the 45 frames after. At XOI each side of the situation changes a move's weight by a small part only (three quarters to four thirds, all three together seven tenths to seven fifths), and only as far as the starts seen there bear it out; a step onto a spot training found clearly worse is not taken, one onto a clearly better spot within a few steps is — clearly meaning by more than either may be off.
4. In step. The notes are part of the mod's file, which every machine in a network room has, so what XOI decides still depends only on the match and that file: rooms and replays stay in sync. A mod without notes plays XOI with its tuned numbers only; the match line shows (XOI v27, N matchups), or no notes. Notes trained before version 27 have no situations or spots: XOI then weighs moves as before.

First measurement, Naruto: The Setting Dawn: 8 pairs of fighters, 100 training games each (800 games), then XOI against INSANE! on the same pairs with random seeds training never used, each fighter of each pair played by XOI in 10 games a seed: with version 25, 82–77 and 94–62 (176–139 with 5 draws, 55.9%); with the play of version 24 before it, 171–146 with 3 draws. Together 347–285 over 640 games (54.9%, ±3.9% at 95%), XOI's blows struck first less often (1,497 against 1,823). A second round on the same pairs — XOI against XOI on the notes, 100 games a pair more, or simply 100 more games of INSANE! — did not add to the first measurably: 172–148 and 169–146 on the same games, against 176–139: the notes only weigh which move is chosen, and that is soon learned. The notes were made against INSANE!'s own play, and a human plays differently: that is why XOI is a level of its own and INSANE! is not changed by them.

The situations, measured (version 27): 100 training games on each of 8 pairs of Naruto 2.4 and of KT-LF2, then XOI with the situations and spots against XOI with the moves' weights alone, each fighter of each pair played by each in 10 games: 75–80 and 83–73, 158–153 together — as strong, not stronger. A first, bolder version (situations added up in full, weights from 0.4 to 1.8) lost 63–93 on Naruto: a move's record split three ways rests on few starts, and much of what it shows is chance. What a situation adds is kept small for that reason; it is a memory to grow with more training rather than a gain yet.

Benchmark results

INSANE! against CRAZY! (the mod's own computer player), 40 one-on-one games per mod over 10 different fighter pairs, 9000 frames per game at most, with a fixed random seed so anyone can reproduce the exact result.

Version 27 figures with --seed 12345 (version 26 gave 38–1 with a draw, 40–0, 29–11 and 36–4, version 25 40–0, 39–1, 31–9 and 38–2, version 24 35–4 with a draw, 35–4 with a draw, 30–10 and 37–3, version 23 34–5 with a draw, 37–3, 30–10 and 35–5, version 22 36–3 with a draw, 39–1, 29–11 and 38–2, version 20 35–5, 35–5, 28–12 and 30–10 on the same games; the LuaJIT desktop build and the Lua 5.2 web build give the same result frame for frame). Another seed (777) gives 38–2, 40–0, 32–8 and 37–3 for version 26 (38–2, 36–4, 30–10 and 38–2 for version 25; 34–6, 40–0, 33–7 and 38–2 for version 24; 37–2 with a draw, 39–1, 33–7 and 39–1 for version 23): against CRAZY! versions 22 to 26 are about equal, single pairs swinging by a game or two either way. The differences show against a strong opponent, head to head over the same ten pairs of each mod, three seeds, 240 games: version 23 against version 22 137–88 with 15 draws (Naruto 62–56, One Piece 75–32), taking fewer than half the hits from a just-risen opponent (90 against 211) and a fifth less damage; version 24 against version 23 120–107 with 13 draws (Naruto 59–61, One Piece 61–46), landing a fifth more blows; version 25 against version 24 115–112 with 13 draws (Naruto 56–63, One Piece 59–49). With each fighter of each pair played by each version (8 pairs, 10 games each way), version 25 beats version 24 87–70 and 86–73 in Naruto, where Sasuke's teleport now lands where the game puts it, and plays One Piece about even (67–72, 21 draws), cut short less often in both. Version 26 against version 25 the same way: 94–66 and 86–71 in Naruto, 83–62 (15 draws) and 75–71 (14 draws) in One Piece — 338–270 over the four, hit less often in each (86–71 and 83–62 were measured just before a last small change to the walk to a weapon; on Naruto's first seed it moved 93–66 to 94–66); Gaara against Neji, both played by one version, wins 17 games in 20 with version 26 and 4 with version 25. Version 27 against version 26 the same way: 82–74 and 89–65 in Naruto, 77–68 (15 draws) and 75–69 (16 draws) in One Piece, 76–79 in KT-LF2 and 76–79 in Sx2 — 475–434 over the six, ahead where the new reckoning has something to work on (untouchable forms, traps, grabs, charging) and level elsewhere; Naruto, Kakashi, Kankuro, Jiraiya and Kisame against Neji, both played by one version, win 10 games in 50 with version 27 and 4 with version 26. In the matchup that version 24 was made for, Rock Lee against Neji in Naruto, 20,000 games between versions 24 and 23 end 10,928–9,047 with 25 draws (54.7%, ±0.6%): version 24's Lee wins 38.9% against version 23's Neji, where version 23's own Lee won 28.2%, and its Neji is as strong as version 23's. (Until 1 November 2026 the two players of a head-to-head match on the bench shared one context — how they read the fighters' moves — which skewed matches between versions that read moves differently; the figures above are measured with separate ones.) "HP left" is the average over all 40 games, lost games counting as 0. In KT-LF2 the original computer player already knows the original fighters' moves, so the two are close; in mods with new fighters it barely knows how to use them.

Source code and building on it

The whole project is MIT-licensed (the original game and the mods are not covered). The AI is a single Lua 5.2 file that runs identically on the web, Windows, Linux, macOS and Android. Read it, change it, send a pull request.

Good places to start

• smart.levels: the reaction time of each level; a new level is one more line.
• attack_score: the formula that scores a blow. To make the AI bolder or more careful, change it here.
• danger_at, preferred_range: how the AI chooses where to stand.
• approach_attack: jumping in and dashing in; stance_exit: held stances.
• watch, guard_rate, pressure, flips_up: the opponent model, counted once a frame; add a habit there and use it in attack_score or the positioning.
• weapon_to_take, over_weapon, armed_analysis, view_of: which weapon is worth picking up, and the fighter's moves re-learned with each kind of weapon in hand.
• mode_entries, mode_drain, enter_mode, mode.worth: a form of the fighter's own making (an item of its own in hand), what its keys do, what it burns, and whether it is worth entering; the "enter mode" and "mode run" blocks of smart.control enter it and move in it.
• wake_zone, wake_escape: where a fallen opponent's wake-up blows strike and the quicker way out; counter_along, enemy_reach with a path: the opponent's quickest answer where a move takes the fighter; stance_leave: how soon an opponent can leave a charge or a field; answer_chance, worth_the_risk: how often this opponent has struck a risky blow of ours first, and whether a blow is worth that risk.
• Not done yet: a form reached from inside another form (Zoro's Asura) and forms that are a stance rather than an item; healing, buff and summon moves that deal no damage have no score yet (they are used only when they also charge MP or heal); 2-on-2 play is limited to choosing the enemy and the side to attack from — there is no shared plan between partners; habits are learned within a match only.

# Run the bench on your machine (see tools/ai-bench/README.md): 40 games of INSANE! against CRAZY! in the One Piece mod
openlf2 --pack onepiece.zip --mod tools/ai-bench --seed 12345 --input-trace ""
# Two computer players against each other: brains = {"smart", "smart@ai_alt"} in config.lua, ai_alt.lua being
# another version of smart_ai.lua — or your own player, started from tools/ai-bench/ai_template.lua
# audit = true adds, per brain, blows started, landed and interrupted, hits taken from a just-risen opponent or at a wall,
# trades, and what the fighter was doing when hit: the numbers a change is judged by, next to the score

Anyone can write a computer player of their own in the template's shape (a Lua module with prepare and control) and run it against INSANE! or any other player with the bench; an open arena where such players are submitted and ranked is the natural next step, and this is its ground floor.

Every decision depends only on the state of the match — the AI draws no random numbers of its own — so recordings and network games always replay exactly. After changing the AI, run replaytest in the bench to make sure that still holds.

About this build

LF2 Online is the OpenLF2 build maintained by Xôi: the web page, the relay server for network rooms with its library of mods, the Vietnamese player guide, and the INSANE! computer player. INSANE! was Xôi's problem statement; Xôi tested it mod by mod and gave feedback over many versions, and the programming was done together with Claude (Anthropic). OpenLF2 itself is the open-source project of the OpenLF2 community.

Sauce shared his lf2-AI VS and Stage Challenge openly: a computer player for the ten original fighters, written for LF2's AI script engine (ai\<id>.as). OpenLF2 runs those scripts as they are (from package 56), so INSANE! and XOI could fight a player made by someone else — the measure quoted in the history above — and v35 learned several of its habits, worked out in a form that holds for every mod: grabbing a dizzy opponent and punching before the throw, rolling out of a run or the landing crouch, holding a direction to steer a move or a ball onto the opponent's line, and following a knock-up into the air. Thank you, Sauce.