Used only during the first loop repetition to set the position/rotation at an absolute value. Usually used in the first beat of a program. This can be helpful as a sort of reset, in case the object does not start out at the desired position by default. For example:
SA:1/2; S:-1/2 | S:1/2
If this were a linear actuator, this would move the unit to the halfway point on the very first beat of the first loop and then shuttle it back and forth over the full range every other beat.
For a linear actuator, values will be clamped to a range of 0 - 1, representing 0% to 100% of the track length. For a rotator, this will typically also be 0 - 1, representing 0° - 360°, but can also take values outside this range, which get mapped to this range. For example, -1/4 gets treated the same as 3/4.
Similar to shift, but this does the relative sliding/rotation immediately at the start of the beat, before shift gets its chance to do more sliding/rotation. For example:
If this unit were a linear actuator, this program would bump it all the way back to its 0 point on the track at the start of each beat and then shift it gradually out to its end over the rest of that beat.
This is the heart and soul of unit programming. It describes a (generally) gradual transition of a unit from its starting position along its track or around its axis by the given amount, expressed as a percent of a full turn. That percent ranges from 0 to 1, but is a relative, not absolute, value. For example:
S:1/2 | S:-1/4
If this were a rotator unit, it would rotate half a turn one way and then, in the next beat, a quarter turn the other way. By the end of the eighth beat (after four loops), it will have cycled back to its starting orientation, ready for the next user-perceived loop.
Over the course of a beat, the unit can shift from one position/rotation to another using one of a variety of easing functions. Below is an illustration of six units all following the same back-and-forth shift program at the same pace, but using different easing functions:
The options, seen above from left to right, include:
The default value is "EIO" (ease in/out), which is most like how real, massy machines move. A car, for example, must take time to get up to speed and time to slow to a halt.
If you want a continuous motion with no speed variation, use "L" (linear), as in this example:
The "EI" (ease in) option feels like a hammer coming down, since it starts at zero speed and stops immediately at its top speed. The "EO" (ease out) option feels more like an explosion, since it starts at top speed and gradually slows down until it reaches zero and stops.
If you want a tick-tick clock-like motion, consider using the "BE" (back edge) or "FE" (front edge) options, as in this example:
To clarify, the front-edge option acts like a linear function for the first 1/4 of the beat, shifting through the full amount of motion, and then remains stationary for the rest of it. The back-edge option keeps the unit stationary for the first 3/4 of the beat and shifts the full amount linearly during the last 1/4 of it. The stationary periods give it that tick-tick feel, which can help cue viewers in to the fact that your program has a well-defined pace. Note also that you can simulate this pattern using a more complicated arrangement like the following:
P:4; R:3; | S:1/12; E:L
In this case, we speed the pace up 4 times and then spend 3 of those beats doing nothing, then rotating 1/12 of a turn in the last of four beats. With this approach you could have finer control over the motion, but it's more verbose than just using "S:1/12; E:BE".
Flavors are like a Swiss army knife, where you choose from a variety of different versions of the same unit appearance to show at any given time. A great example is a club light that can switch among three different colors and even "off". That's four copies of the same 3D model, each with different spotlight configurations.
Each copy of the "same" unit that represents the different flavor of it gets its own copy of the unit script. All have the same name, with only the "Flavor" setting varying. The default flavor will have no value in its "Flavor" setting and all the other ones will have some helpful name like "Red", "Blue", "Yellow".
The "F" attribute lets you choose which flavor to start showing from now on. Its argument is the flavor name to select. For example, "F:Red". To select the default flavor again, use "F:", a blank value. This flavor will continue being used until another "F" attribute is encountered to select a different flavor. Here is an example program:
S:1/4; E:L; F: | S:1/4; E:L; F:Red | S:1/4; E:L; F:Green | S:1/4; E:L; F:Yellow
This unit rotates continuously and goes through its four colors during a full circuit.
You can use your Clockworks machine as a timing system for triggering Reflex scripts like doors, etc., to do their things. This command will send out a "bang" triggering message in the same way a People sensor would. The message name is this attribute's argument. For example, "RMS:StartOfProg1".
In this case, the bang message goes out immediately at the start of this beat. Use the "RME" attribute to have it sent at the end of this beat instead.
You can use your Clockworks machine as a timing system for triggering Reflex scripts like doors, etc., to do their things. This command will send out a "bang" triggering message in the same way a People sensor would. The message name is this attribute's argument. For example, "RMS:EndOfProg1".
In this case, the bang message goes out immediately at the end of this beat. Use the "RMS" attribute to have it sent at the start of this beat instead.
See the Pacing section for a detailed primer. Briefly, the beat pace allows you to temporarily change how fast each beat in your program runs to some value relative to the "master beat". The default is 1. Higher values yield a faster pace and lower numbers yield a slower one. For example, "P:2" means two unit beats per master beat (faster) and "P:1/2" means one unit beat for every two master beats (slower).
This attribute carries forward during one loop of the program until the next "P" attribute is found. When the loop restarts, the pace is restored to 1, unless the first beat in the loop indicates otherwise. For example:
S:1 | S:-1 | P:8; R:8; S:1/8; E:BE | P:1; S:-1
For a linear actuator unit, this would slide it out one full length over one beat, then back over the second, then make it "tick" ("E:BE") its way outward ("S:1/8") in 8 small increments ("R:8") over the third master beat ("P:1/8"), and then finally return back in the fourth beat.
A call to "RP" (run program) when the pace is currently other than 1 does not affect the pace of that program, which starts out with its own default of 1. When that program returns control to this one, the pace will again be what it was before the run-program call.
See the Repetition section for a detailed primer. By default, a beat gets "repeated" only once, but you can tell it to repeat for more than one beat (e.g., "R:2") or to skip the time passage of a beat (i.e., "R:0"). For example:
S:1 | S:-1/7; E:BE; R:7
See the Repetition section for a detailed primer. This overrides the "R" (beat repetitions) attribute during the first loop iteration of a program.
See the Repetition section for a detailed primer. This can appear in the first beat of a program to indicate that it should run a finite number of times instead of forever. For example:
LR:4; S:1/4 | S:-1/4
For a rotator unit, this program will have it wave back and forth 4 times over the course of 8 beats and then stop.
See the Run another program section for a detailed primer. This attribute indicates that this beat should actually be given over to the first beat of some other named program. And when that program is done and returns, this program's next beat will be queued up to go next.
If combined with the "R" (beat repetition) attribute, the program will be run more than one time. For example:
S:1/4 | RP:Prog1; R:4 | S:-1/4
In this example, Prog1 gets run 4 times before we move on to the last beat of this program. If Prog1 has a "LR" (loop repetitions) attribute value of 2, its loop will ultimately run 8 times.
To run an initial program and then kick off another one to run indefinitely, try the "R:F" (beat repetitions = forever) attribute value with the "RP" attribute.