JJS Skill Builder Branch and Hit Cancel Guide

Once you understand basic custom moves in JJS Skill Builder, the next step is learning how to control move logic. That is where Branch and Hit Cancel become important.

These two systems help your moves react to what actually happens in combat. Instead of always following one fixed path, a move can change outcome depending on whether it hits, misses, or reaches a certain condition.

In this guide, you will learn what Branch and Hit Cancel do, how they work together, and how to use them to build smarter custom moves in JJS Skill Builder. If you are still learning the basics, start with our How to Make Custom Moves and How to Make Variants guides first.

What Branch Does in JJS Skill Builder

A Branch lets your move split into a different path.

Instead of forcing the same result every time, a move can say:

• if one condition is true, continue here
• if not, stay on the normal path
• if the move lands, go to a follow-up
• if the move fails, end early or recover

This is one of the most important logic systems in Skill Builder because it allows one move to have multiple outcomes.

Simple idea

Think of Branch like a fork in the road:

That alternate result can be: another hit, a stronger finisher, a miss recovery, a combo extender, or a variant path.

What Hit Cancel Does in JJS Skill Builder

Hit Cancel is used when a move needs to react to whether a hit happened. The simplest way to think about it is: Hit Cancel checks the hit result and lets the move continue differently depending on whether the target was hit.

This is useful because many good moves should not behave the same on hit and on whiff. For example:

• if the attack lands, continue into a finisher
• if the attack misses, stop the combo
• if the attack connects, trigger a new branch
• if the attack fails, return to recovery

That makes moves feel much more responsive and intentional.

Why These Nodes Matter So Much

Without logic nodes, most moves are just:

That works for simple attacks, but it is limited. With Branch and Hit Cancel, you can build:

• follow-up attacks only on hit
• safer recovery when the move misses
• tap vs hold logic with real conditions
• combo routes that depend on success
• counters and smarter variants later

These systems are what move building from "basic attack creator" into actual custom move logic.

Branch vs Hit Cancel

A lot of beginners confuse these two.

Branch

Branch is the pathing tool. It decides where the move goes next, which timeline path should play, and what alternate route becomes available.

Hit Cancel

Hit Cancel is the condition tool. It helps determine whether the move hit, whether logic should continue differently, and whether a follow-up should activate.

Simple summary

A Simple Example of Move Logic

Without Branch or Hit Cancel

The move always does the same thing.

With Branch and Hit Cancel

This version feels much better because the move reacts to what happened.

How to Use Branch in JJS Skill Builder

Step 1: Build the Normal Move First

Before adding any logic, make sure the base move already works. Start with startup animation, short wait, hitbox, sound, end. Always start simple.

Step 2: Decide Where the Move Should Split

Ask one clear question: at what point should the move have two possible outcomes? Good examples: after the first hit, after a hold window, after a timing check, or before a finisher. That is where your Branch should go.

Step 3: Make the Two Paths Clearly Different

Your branch should not lead to two almost identical results. A good split looks like:

• path A = standard hit ender
• path B = extended combo finisher

The point of Branch is meaningful difference.

Step 4: Keep the Shared Opening Before the Split

Try to keep this structure: shared opening — split point — separate outcomes. This makes the move easier to test and edit later.

How to Use Hit Cancel in JJS Skill Builder

Step 1: Start With a Move That Can Hit or Miss

Hit Cancel matters most when the move outcome depends on contact. A good beginner example is one slash with one forward hitbox.

Step 2: Place the Hit Check After the Hitbox

The move needs to know whether the attack connected. So the hit check should happen after the attack moment, not before it.

Step 3: Decide What Happens on Hit

If the move connects, maybe you want: extra hit, launch, finisher, stronger animation, or combo continuation.

Step 4: Decide What Happens on Miss

If the move misses, maybe you want: early end, recovery animation, no follow-up, or weaker outcome. This is what makes the logic useful.

Step 5: Test Hit and Miss Separately

Do not only test successful hits. Also test: target out of range, bad timing, whiff scenarios, and edge hitbox cases. If the move only works on ideal hits, the logic is not ready.

How Branch and Hit Cancel Work Together

The most common beginner structure looks like this:

Basic Logic Flow

On-Hit Path

On-Miss Path

This is one of the safest and most useful templates for early advanced move design.

A Beginner-Friendly Logic Template

Timeline

Branch A: Hit Success

Branch B: Miss / Fail

Good Uses for Branch

• follow-up finishers
• alternate combo routes
• variant outcomes
• charge-release behavior
• hit-confirm logic
• miss recovery

Good Uses for Hit Cancel

• confirming whether the first attack landed
• deciding whether to allow combo extension
• preventing full follow-up on whiff
• improving move fairness
• building more reactive custom skills

Common Beginner Mistakes

Branch is added too early

If the split happens before the move has enough information, the result often feels random or broken.

Both paths feel the same

A branch should create a meaningful difference. If both paths barely change anything, the logic adds complexity without value.

Hit Cancel is placed in the wrong spot

If you check too early, the move may not know whether the hit actually happened yet.

The move only works on hit

Many builders forget to design the miss path at all. That often makes the move awkward or unfair.

The logic becomes too messy

Trying to add too many branches at once makes debugging much harder. Start with one clean split.

How to Make Logic Feel Better

Use one clear question

Every branch should answer one simple question: did the move hit? Was the move held? Did the player choose the alternate route?

Make the follow-up readable

If the move changes path, the player should be able to feel that clearly through animation, timing, or sound.

Balance risk and reward

A stronger on-hit branch should feel earned. A miss path should usually have less reward or more recovery.

Avoid unnecessary branches

Not every move needs complicated logic.

How This Connects to Other Systems

Branch and Hit Cancel become much stronger when combined with:

• Hitbox for hit confirmation
• Variants for alternate path design
• Velocity for different knockback results
• Animation and Sound IDs for clearer path feedback
• Counters for reaction-based outcomes later

This is why they are such important bridge topics between beginner and advanced builder content.

When You Should Learn This

You should learn Branch and Hit Cancel after you already understand:

• timeline order — see How to Use JJS Skill Builder
• basic hitboxes — see Hitbox guide
• simple custom moves — see How to Make Custom Moves
• move testing

If you skip those basics, this topic becomes much harder than it needs to be.

Helpful Resources

To learn logic faster, use these resources together:

• Jujutsu Shenanigans codes — study move structure ideas and real moveset logic
• Animation & Sound IDs for clearer route changes and path feedback
• Planner (Beta) to map logic before rebuilding it in a full move

FAQ

Conclusion

Branch and Hit Cancel are two of the most useful systems in JJS Skill Builder because they let your custom moves react to real combat outcomes. Start with one simple hit-confirm move, split it into a hit path and a miss path, and keep the logic easy to read. Once that feels natural, you will be ready for more advanced move systems like counters and deeper variants.

If you want ideas before building your own logic-heavy moves, browse our JJS codes, Animation & Sound IDs, and Planner (Beta).