Rule sets — write how your squad fights

Your squad fights on its own, and it fights on your rules.

A rule set is an ordered list of rules of the form who to watch, when to act, what to do. Your squad members read them top to bottom, every two or three seconds of a fight, and do the first thing that applies. That is the whole system, and it is the same one Final Fantasy XII shipped as gambits — except these are your own characters, wearing their own gear, casting the spells they have actually learned.

`` !squad rules add My Medic party hp<40 cure ``

Any ally below 40% HP → cast the biggest Cure that member can afford.

Not "Cure III". The biggest one it can afford, worked out fresh every time it looks: Cure at level 5, Cure IV at 41, and whatever it can pay for when its MP is low. Write the rule once and it grows with the character.

If you never want to write one

Fourteen sets ship with the server. They cost nothing, they are always there, and you can put one to work in one line:

`` !squad rules use whm medic !squad rules use pld vanguard !squad rules presets ``

The first four are the profiles !squad behavior sets, so a squad you never configure is already running one — defensive — and !squad behavior aggressive in a macro is just a shorter way of assigning that set to everybody.

The Chain Crew pair is worth a paragraph. Normally your squad skillchains opportunistically — whenever two TP bars happen to line up. Give one member chain opener and the rest chain closer and it stops being luck: the opener waits for a chain to start, the closers wait for somebody to start one, and every chain is deliberate. The cost is members standing around on a full TP bar. Give exactly one of them the opener — a squad of closers is a squad of people waiting for a bus that is not coming.

Writing your own

Start from something that works, or start empty:

`` !squad rules copy medic My Medic copies a shipped set into one you can edit !squad rules new My Medic or start with nothing ``

Then add rules. Each is who / when / what:

`` !squad rules add My Medic party hp<40 cure !squad rules add My Medic party status:sleep cure1 !squad rules add My Medic party nostatus:protect protectra retry:60 !squad rules add My Medic enemy nostatus:dia dia !squad rules posture My Medic swing never !squad rules use whm My Medic ``

Order is priority. An earlier rule beats a later one, so emergencies go at the top and "when there is nothing better to do" goes at the bottom. move reorders and del removes:

`` !squad rules show My Medic the whole set, numbered !squad rules move My Medic 4 to 1 that one first from now on !squad rules del My Medic 6 ``

What a rule may say

Two conditions join with and or or. retry:60 waits a minute between uses of that one rule. !squad rules vocab lists every word the server accepts — that list is the truth, and it is generated from the same table the server validates against, so it cannot drift.

Some things are deliberately not rules, because the engine decides them before it reads any:

`` !squad rules posture My Medic swing never | always | role !squad rules posture My Medic tp off don't spend TP on weapon skills !squad rules posture My Medic hold on never engage on its own !squad rules posture My Medic stance still stand and cast instead of chasing ``

A window, if you would rather click

/gambits opens the editor: your characters down the left, the rule table in the middle, a dropdown per column, drag-free reorder buttons, and a Save that only sends what actually changed. It ships in the launcher's Default addon set.

It is a renderer. Every single thing it does is a !squad rules line it could have typed, which is why turning it off loses you nothing but the convenience — and why a bug in it cannot corrupt anything, because the server re-checks every rule regardless of which way it arrived.

Rules a member cannot act on yet are greyed rather than hidden, with the reason: not learned, wrong job, not high enough level. They start working on their own the moment that character levels into them.

Share codes

A rule set is text. Say it, paste it into Discord, write it on a napkin:

`` !squad rules export My Medic ``

That prints a code. Anyone on any DriftwoodXI character types:

`` !squad rules import dwg1At2AQEGfwANUG9ja2V0IEhlYWxlcgYQVQQIISUERIIQWMQIISlQQJUeCUqSBLjwylUQLkeA63Y ``

That one is real — try it. It is a six-rule backup healer called Pocket Healer: emergency cures, a wake-up Cure for anyone slept, top-up cures, Protect and Shell kept on the party, and Regen kept on you. It works on any member with a cure — a white mage, a red mage, a paladin, a scholar.

A long set comes back as two lines and both are needed; the export tells you so. A code carries the name it was shared under, and !squad rules import <code> Some Other Name overrides it.

A code is a claim, never a permission. Every rule in one is checked against the same list your own typed rules are checked against, on the server, on the way in. There is nothing a code can install that you could not have typed yourself — no imported set can do something the system does not already allow, and a code with a character mistyped is refused rather than quietly meaning something else.

Things that will look wrong and are not

Buffs only go up in a fight. Rules are read during combat and at no other time. Nobody will Protect you while you stand in the field deciding where to go.

Weapon skills are not rules and cannot be. The engine spends a full TP bar before it reads a single rule, so "don't use weapon skills" is posture … tp off and nothing else. Which weapon skill, and when, is posture … tpwhen and tpuse.

`party` means the first match, not the worst-off one. A rule scanning your party takes the first member that passes, in a fixed order — which is why an emergency cure rule wants to sit above an ordinary one rather than beside it.

`timer:30` and `retry:30` are not the same thing. A timer's clock runs whenever the rule is looked at; a retry's runs only when the rule actually fired. For "not more often than every 30 seconds", you almost always want retry.

A rule naming a spell nobody has learned is fine. It is reported, not refused — sets store intent, and your squad levels while it is out. !squad rules report <member> lists exactly what is live and what is waiting.

The small print

• 24 rules per set, 16 sets per account, 2 conditions per rule. The shipped sets are exempt from the first one — several of them are compositions that hand each job only the part that applies to it, which is how one set can be right for a warrior and a white mage at once. Copying one flattens it for a particular member, and if that comes to more than 24 rules the copy is refused and tells you which rules did not fit.
• Rule sets belong to the account, not the character. Write one on any character and every character you own can run it.
• A set can be assigned per job: !squad rules use Yakapo My Medic when whm gives that character the set only while it is a white mage.
• Rules live between summon and dismiss. Edit a set and anybody currently running it picks the change up immediately — you do not need to re-call them.
• `!squad rules` on its own says what each member out is running right now. !squad rules help is the whole grammar with worked examples.

What is still rough

The vocabulary is a whitelist, and it is deliberately smaller than the engine's. Several of the engine's own conditions do nothing, do the wrong thing, or crash the server outright when given a bad argument — those are not in the list and never will be. Others are one particular job's private logic and want a proper job preset to hang them on: geomancer indi-spells, scholar storms, red mage enspells, rune fencer runes. They are audited, they work, and they are waiting on a set worth putting them in.

Bard songs, summoner and puppetmaster pets and most of ninja are still untuned generally, which the squad post already said and this does not change.

If a rule does something other than what it says, that is a bug and worth reporting — with the set, which !squad rules export turns into a single line.