Pre and Post Processing Options

Pre-Processing Options

These operations are done before other operations, ie before both Rail and Movement options

Note that the order of operation is always as they are listed here, regardless in which order you specify them. If you want a different order or run a single operation multiple times, you need to run the tool multiple times, or use multiple lines in a action.txt preset file.

All operations support filtering options to apply to certain types only.

Change BPM

-b<bpm> or --bpm=<bpm>

Rescales the position of everything to match the new BPM without affecting the timing. If a pattern was 1 second long before, it will be 1 second long afterwards, no matter what the BPM was or changed to.
Note that everything will still be rounded 1/192 to ensure the editor can work correctly. Avoid changing BPM of sections multiple times as errors from this may add up.

This is useful if you have a song that switches BPM somewhere, so you can map each section at the correct BPM and then paste them together.

Delete Everything Not Matching Filter

--delete-others, use with Filtering options

Instead of ignoring everything not matching the filter, like this tool does by default, this option will instead delete those.

Connect Single Notes Into Rails

--connect-singles=<max_interval>

This will covert all single notes of the same type that are no more than max_interval part from each other into a single rail with nodes where the notes were.

This is the inverse of the --rails-to-singles post-processing option, which turns rail nodes into single notes.

If you want to keep the single notes, you can combine this with --rails-to-singles=1 where the =1 makes it keep the rail

Merge Rails

--merge-rails or --merge-rails=<max_interval>

By default (without giving max_interval), this merges rails of the same type when the end of the last rail is "very close" (both in time and X/Y) to the start of the next rail. If you give it a max_interval, the XY-distance is ignored and rails are merged if they are no more than that interval from each other.

Single notes will be placed where the start of each rail was.

This is the inverse of the --split-rails post-processing option, which splits rails at single notes.

Change Note Type

-n <note_type> or --change-notes <note_type> or multiple types: --change-notes <note_type1> <note_type2> ...

Changes all notes to the given type, see the glossary for the note type names this tools uses.

When you specify multiple types, it cycles through them over and over, allowing you to make rainbows. Ie -n left single right single will result in left single right single left single right single ....
Note that this cycle happens independently for each input color, so if you have 3 left handed notes followed by three right handed notes, it would result in left single right - left single right instead of left single right - single left single which 6 notes of the same color would produce.

Swap Hands

--swap-hands (not affected by filter)

Swaps notes of left and right hand. Note that this does not mirror the notes, add --scale=-1,1,1 if you want that.

Change Wall Type

-w <wall_type> or --change-walls <wall_type> or multiple types: --change-walls <wall_type1> <wall_type2> ...

Changes all walls to the given type, see the glossary for the wall type names this tools uses.

When you specify multiple types, it cycles through them over and over, allowing you to make repeating patterns. Ie -n wall_left center wall_right center will result in wall_left center wall_right center wall_left center wall_right center ....

Spawn Object

--spawn <type> and optionally --spawn-location=x,y,t (defaults to 0,0,0)

Creates a note/wall of the given type. See Game Objects for available note/wall types.
You can only create a single object per call, if you need multiple objects you have to run multiple commands (ie multiple lines in a preset file), or use stacking.

Note: You can start with empty data and use this to create a deterministic input.

---

Post-Processing Options

These operations are done after other operations, ie after both Rail and Movement options

Note that the order of operation is always as they are listed here, regardless in which order you specify them. If you want a different order or run a single operation multiple times, you need to run the tool multiple times, or use multiple lines in a action.txt preset file.

Create parallel patterns

--parallels=<distance>

This will create parallel patterns from the input. When the distance is negative, creates crossovers. A distance of 0 simply duplicates.

Left and right hand are copied and moved over by the distance and specials are split into two notes/rails.

Note that if your input contains multiple notes at the same time (which you may want to therefore avoid), the following priority is used for the output:

• Original note from the input (lowest priority, gets overwritten by everything else)
• Parallel note from the other hand
• Split single-handed special
• Split two-handed special (highest priority, overwrites everything else)

In practice, this means if your input has notes for both hands in the same time (even if one is a rail head), those will get overwritten by the parallel of the other hand, so they effectively appear to swap places (plus some offset).

Split Rails

--split-rails

This will find single notes along rails and split the rail at those positions. The single notes will become both end point and start points of the split rails, so you may want to ensure they are placed right on the rail.

This is the inverse of the --merge-rails pre-processing option.

Convert Rails Into Single Notes

--rails-to-singles or --rails-to-singles=<keep_rail>

When keep_rail is not given or 0, this will replace rails with single notes at every rail node. When keep_rail is 1, the rail will not be deleted.

Snap Single Notes to Rails

--snap-singles-to-rail

Does exactly what it sounds like.

Keep Selection Alignment

--keep-alignment

Usually this tool will realign the selection such that it starts at the first element. This is handy in some situations (such as when mirroring in time or negative time offset), but "wierd" in others, as you may need to change the editor location where you paste something back in.

For this reason when you add --keep-alignment, the start will not be realigned.

Note that this may result in pasting stuff way ahead of the position you paste, so use at your own risk.