I'm using a sort of a hybrid of Mugen's default juggles and a 3-var worth series of flags in an attempt to conceive a juggle system that encourages using most of the movelist as possible to do juggles. Due to my lack of better wording chances are I may end up confusing you with how I write but at least I'll try.

For almost every attack aside of basic throws and supers (to which I have them not use up juggle points at all) I'd assign a "group" (a var for which the flags would be stored) and an "id" (the flag itself), which could be written as floor(exp(X*ln(2)) + 0.5) (where X is the id in range of 0-9). This equation actually translates to a power of 2 thus in the place of the equation you can just put in 1,2,4,8,16,32 etc., the equation's there just for the sake of easier readablitity

Spoiler: **what the equations translate to:** (click to see content)

floor(exp(0*ln(2)) + 0.5) = 1

floor(exp(1*ln(2)) + 0.5) = 2

floor(exp(2*ln(2)) + 0.5) = 4

floor(exp(3*ln(2)) + 0.5) = 8

floor(exp(4*ln(2)) + 0.5) = 16

floor(exp(5*ln(2)) + 0.5) = 32

floor(exp(6*ln(2)) + 0.5) = 64

floor(exp(7*ln(2)) + 0.5) = 128

floor(exp(8*ln(2)) + 0.5) = 256

floor(exp(9*ln(2)) + 0.5) = 512

Note that a couple of years ago when I tried flags higher than 512 ( say, floor(exp(10*ln(2)) + 0.5) which would translate to 1024 ) things have gotten sort of screwy from what I remember - probably based on the limit of how high the var integer can reach - which is exactly why just in case I'm using around 3 vars to store the flags.

For attacks, the statedefs have juggle points something like this (for flag detection):

juggle = ifelse(var(40) & floor(exp(1*ln(2)) + 0.5) ,1,0)

Which makes it so the particular attack uses up the juggle point only if at the start of it the flag 2 (see above) in var(40) is set (for context, the attack would use up the juggle point *only* if the character has already hit the opponent with said attack before in a combo)

The attacks would also have a state controller like this (for flag setting):

[State Neo-Juggle-System-Flag]

type = VarSet

trigger1 = movehit = [1,2]

trigger1 = numtarget

trigger1 = (target,statetype = A) || (target,statetype = L)

var(40) = var(40) | floor(exp(1*ln(2)) + 0.5)

ignorehitpause = 1

persistent = 0

This would set the flag 2 in var 40 when the attack hits an aerial opponent.

Of course, we should also remember to use a measure in statedef -2 that resets the vars when opponent is not in hitstate, which goes something like this (for flag resets):

[State -2, Neo-Juggle-System-Reset]

type = VarSet

triggerall = var(40)

trigger1 = !numtarget

var(40) = 0

ignorehitpause = 1

[State -2, Neo-Juggle-System-Reset]

type = VarSet

triggerall = var(41)

trigger1 = !numtarget

var(41) = 0

ignorehitpause = 1

[State -2, Neo-Juggle-System-Reset]

type = VarSet

triggerall = var(42)

trigger1 = !numtarget

var(42) = 0

ignorehitpause = 1

Because of the matter of helpers not sharing the (spent) juggle points with their owners, for projectiles I usually go for other means to limit them (like the projectile going invisible after impact and not getting "destroyed" - which would allow the projectile to be thrown again - until the opponent would leave the hitstate). That being said I did code a character (Kaf Ka from *Battle Monsters*) that attacks with the floating orbs that are his constant helpers and I did in fact apply the system to them as well, I just had to adjust some things - especially regarding the juggle flag reset - to make it work.