Assembly Mode

Predictability is all very well in its place, but sometimes you want an element of chance in your creations. That's where the randomizer comes in.

It takes the signal you pass in and sends it from a random output port. So you could use it to randomly turn lights on and off in a night time cityscape, for example.

Here's a fun wee demo. Stamp a bunch of different shapes into your scene. Don't forget to make them separate sculptures or this won't work at all!

Place a timer and a randomizer. On the timer, connect timer finished (pulse) to reset timer. This will cause the timer to loop (which is a handy thing to remember).

Now also connect timer finished (pulse) to randomize on the randomizer (yep, you can have pretty much as many wires in and out of ports as you like).

This will send a signal each time the (looping, remember) timer finishes, which tells the randomizer to randomize, sending a signal down a random output port.

So what are we doing with these signals? Firstly, bump up the no. ports slider to correspond with the number of shapes you put in your scene.

Now connect each of those outputs to the input of the visible toggle on a shape. Hit start time. The shapes randomly appear and disappear as they get the signals.

Counts up or down to a given value when it gets a signal and sends a signal when it's done, so it's great for setting conditions in logic chains based on a count.

It works sensibly with other gadgets like the number displayer and the calculator, so you could make your own countdowns or scores if you're so inclined.

Let's use one to trigger a sound effect after a player has walked into a trigger zone a few times. Stamp a counter, trigger zone, any sound effect and a puppet into the scene.

Connect detected on the trigger zone to increase count on the counter. This means the counter will be counting each time the trigger zone detects something.

Connect counter full on the counter to the power port on the sound effect, so that it'll activate the sound effect when it's reached its target value. Speaking of which...

Tweak the counter and nudge the target value up to, say, 5. Enter test mode, possess the puppet, and run into the trigger zone 5 times.

AND is one of the fundamental building blocks of logic. The AND gate combines signals to give you the condition "only do this thing if ALL of these things are true".

It has a variable number of inputs and will only send a signal when ALL of the inputs are on or true.

Here's a practical example. Place an AND gate, a controller sensor and a shape into your scene. Tweak the controller sensor and make it remote controllable.

Connect the outputs of and to the input ports of the AND gate. Tweak the shape and connect the gate's result output to the input of the visible toggle on the shape.

Hit start time and press and at the same time. The shape becomes visible. It won't if you only press one of them - it needs both inputs to be true.

OR is one of the fundamental building blocks of logic. The OR gate combines signals to give you the condition "do this thing if ANY of these things are true".

It has a variable number of input ports and will send a signal when one, more, or all of the inputs are on or true.

Place 2 trigger zones, a light, a puppet and an OR gate. Make the zones overlap a bit. Connect detected on each of the trigger zones to the inputs of the OR gate.

Connect the result output on the OR gate to the power port on the light. Go to test mode and possess the puppet. Run in and out of each zone and the overlap.

The light will come on whether you are in one trigger zone, the other, or both at the same time. OR just needs any of the inputs to be true.

XOR is one of the fundamental building blocks of logic. The XOR gate combines signals to give you the condition "do this thing if ONLY ONE of these things are true".

It has a variable number of inputs and will send a signal when one, and only one, of the inputs are on or true.

Place a light, controller sensor, trigger zone, puppet and XOR gate. Connect detected on the trigger zone to one of the XOR inputs. Tweak the controller sensor.

Make it remote controllable and connect the output to the other XOR input. Connect the result output on the XOR to the power port on the light.

Head into test mode and possess the puppet. Run into the trigger zone and the light comes on. Press outside the trigger zone and the light comes on.

But if you press while in the trigger zone, the light will go off, because both inputs are true, and XOR demands one, and only one, be true.

NOT is one of the fundamental building blocks of logic. The NOT gate inverts a signal, giving you the condition "if this thing is true, make it false" and vice versa.

It has only one input port and one output port. If the input is true the output will be false. If the input is false, the output will be true.

Place a shape and tweak it to make it grabbable. Snap a grab sensor onto it. Get a NOT gate. Wire the grabbed output on the grab sensor to the input of the NOT gate.

Then connect the output of the NOT gate to the power port on the light. Head into test mode. Notice that the light is on to start with.

The NOT gate turns the "false" signal from the grab sensor into a "true" one. Now grab the shape. The light goes off because the "true" signal becomes "false".

This has a bunch of "slots" (you can choose how many) each with an input and an output port, and you can send it a signal to cycle forwards or backwards through the slots.

You could use it to give your player a list of options to choose between - a menu, a selection of characters, buttons to press in a puzzle and so on.

You could also use it - along with other logic of course - to choose which event should happen where there's more than one to choose from.

Traffic lights are the perfect demo for this gadget. Stamp 3 shapes (remembering to make each one a new sculpture), a timer and a selector.

Tweak each shape to make them glow (about 30% is fine) and use tint color to make them red, amber and green. Also whack the tint amount up to 200%.

Tweak the selector and bump up the no. ports to 3. Connect the output of port A to the glow input of the red shape, B to amber's and C to green's.

Tweak the timer. Connect timer finished (pulse) to reset timer. This will make it loop. Then connect timer finished (pulse) to move to next output on the selector.

This will make the selector send a signal from the next port in the sequence. Use start time and watch the lights cycle from red to green.

An exclusive gate can be open or closed. When it's open, it works like a node and lets a signal pass through from its input to its output. When it's closed it just outputs 0.

It's useful for blocking specific bits of logic while other logic is running. Think of a puppet with animations, states, lines to speak and so on.

These could be triggered by various things in your scene. You don't want any of those actions clashing, e.g. making your puppet wave hello and punch at the same time.

A selector is also good for this sort of thing (and also cheaper in thermometer terms, so use those where you can) but an exclusive gate has some bonus features.

You can have as many as you want, assigning one to each state or action or what-have-you. You don't have to route wires through a single point.

And most importantly, they have tweaks which allow for priority and queuing of signals, and what to do in the event of a tie (two signals with the same priority).

This all works "magically" using naming, i.e. all exclusive gates with the same name use the priorities to collaborate and let only one signal through at a time.

The following example entails a fair bit of wiring for something so simple, so you may wish to snap all the gadgets onto a microchip to make it more tidy and clear.

Grab yourself 2 exclusive gates, two timers, two lights and a controller sensor. Tweak the controller sensor and make it remote controllable.

Connect the output to one gate input and the output to the other. Tweak the gates and set their reset mode to manual, so that we can control when it gets reset.

On each timer, connect timer finished (pulse) to reset timer to make them loop, and connect each timer output to the power port on a light.

Connect gate output on one exclusive gate to start timer on one timer. Do the same with the other gate and timer. This will start the timers when the gates open.

Finally, connect BOTH timer finished (pulse) to BOTH close gate inputs. This means that both gates will get reset each time a timer finishes.

To test this out it's best to bring up the options menu and select play mode. Press to make one light go on and immediately press to try to get the other one on.

You can't do it until the timer runs out, because while one gate is open and letting the signal through the other is closed and blocking it.

If you want to play with signals in a bit more depth, this here is a veritable multi-tool of signal manipulation and you can do some seriously advanced stuff with it.

Change the range of a signal - useful when an output is too large to drive the thing you're sending it to, e.g. the velocity output from a movement sensor to drive a light.

You can also smooth it, so it reaches a value over time instead of instantly. You can manipulate edges, the point where a signal goes on or off.

All this control has endless applications, so do experiment. Control the brightness of lights, and make them fade in and out rather than just switching on or off.

Use them in sound, to stop things cutting in and out suddenly. In animation, to avoid jittery movement. And in gameplay, to make sure events trigger exactly when you want.

Let's do a super simple example. Stamp a shape you can easily jump a puppet onto. Snap an impact sensor and a signal manipulator onto it.

Connect touching on the impact sensor to the input of Input/Output on the signal manipulator. Touching the shape will send a signal to the signal manipulator.

Tweak the signal manipulator. Nudge the output smoothing sliders up to 2 seconds each. These give us a gradual fade in and fade out of the signal.

Tweak the shape, nudging glow up to 50%. Connect Input/Output on the signal manipulator to the input of the glow slider. The manipulated signal will activate glow.

Put a puppet into the scene, enter test mode, and jump on and off the shape. Notice the glow gradually fades up and down rather than going straight on and off.

Acts just like a timer in the real world - set how long you want it to run for and it'll send a signal when it's done. So you can use it to set conditions based on timing.

Good if you want to give a player a set amount of time to complete a task in. Also has uses in altering signals, like a simpler, more linear signal manipulator.

Here's an example using the timer to delay an event. Stamp a shape and snap a grab sensor onto it. Tweak the shape and make sure imp interaction is set to grab.

Nudge the glow slider up to about 40%. Stamp a timer into the scene and connect its timer finished (signal) output to the glow slider input port.

Finally, connect the grabbed output on the grab sensor to the start timer input. Enter test mode and grab the shape. It'll glow 5 seconds after you let go.

The main purpose of this is to do math on signals to change them in some way. Takes two signals as operands, performs an operation on them and outputs the result.

You could use <, > and = to detect signals of specific values. Or to make gradual fades and smoothing in a simpler way than the signal manipulator.

Stamp a light, a slider and a calculator. Tweak the calculator and set the operation to > (greater than). Connect the result output to the power port of the light.

Connect the value output on the value slider to the operand 1 input on the calculator and set the operand 2 slider to 0.5.

Move the slider up and down. The light won't come on until you get the value above 0.5.

Want to do calculations with more than two numbers? Well with this baby you can input up to 10 values. Just keep adding those wires and it'll keep creating ports for you.

You can't do anything too fancy-schmancy, mind you. Operations are necessarily limited to add, subtract, multiply, divide, minimum and maximum.

If that's all you want to do, then this will save you from adding more gadgets than you need to your scene. Let's check it out.

Stamp 10 value sliders, a wide calculator and a number displayer. Connect the value output from one value slider to the operand 1 input on the wide calculator.

Then connect the value output from another value slider to the operand 2 input. And so on. Notice that, as you add each wire, another input port appears.

Repeat until you've connected all the value sliders. Next, connect the result output from the wide calculator to the number/range input on the number displayer. Tweak the wide calculator so you can see the operations and choose one. Then just start playing with the value sliders. This is more fun than it should be.

At its most basic this is just a pass-through. In other words, a signal goes in one end and comes out the other unaltered. So you could just use it for tidy wiring.

Another simple and effective use is for naming inputs and outputs, for your own memory aids, or for anyone who might work with your creations.

Further to this you can also give them a color, so that you can set up clever schemes like "all the nodes for enemy activity are red".

If you have a system of complex logic, wire a node into an input or output port and name it aptly. So nobody needs to try and figure it out, they just use the port.

If you add one to a microchip, you have the option of making it a permanent port on the 'chip, effectively giving you the power to make your own gadgets.

Let's make a simple one. Get a microchip and open it. Place a node on the left side and a node on the right side. They'll become input and output ports automatically.

Place a calculator between the two nodes. Tweak it, select greater than, and set operand 2 to 0.5. Connect the output of the input node to operand 1 on the calculator.

Connect the result output to the input of the output node. Close the microchip. Notice it has input and output ports now, just like any other gadget.

Stamp in a value slider and connect it to the input port. Then add a light and connect it to the output port. Drag the slider and the light goes on when the value gets above 0.5.

We've made ourselves a gadget which will only pass a signal through if the value is above 0.5. This is just a very simple demo - think what you could do with complex logic.

Splits the signals from fat wires into their separate values. A fat wire looks like different colored wires twisted together, and its signal carries multiple values.

A wire from hit position on the laser scope has values for x, y and z, for the co-ordinates of the hit. Tint color on a sculpture carries values for red, green and blue.

Plug a fat wire into the splitter and you'll see the outputs appear for each of those values in the tweak menu, so you can wire those up to other stuff separately.

A good use for this is to split the outputs from and into up/down and left/right. You can join them back up again if you need to using the combiner.

Let's see it in action. Place a tag and a splitter. Connect scene space transform on the tag to splitter input on the splitter. The splitter now has three output ports.

These are the now-separated values for position, orientation and scale. Position is also a fat wire value, so let's break it down again. Place another splitter.

Connect position on the first splitter to splitter input on the second. Now we've got three number values to do with as we see fit. Curious to see the numbers?

Add three number displayers. Connect the number value outputs of the splitter to the number/range inputs of the number displayers.

Tweak their decimal places all the way up and hit start time to see the numbers.

As mentioned, the combiner is used to rejoin fat wires you've split using the splitter. But you can also use it to join up single value wires and make your own fat wires.

You could use this to do stuff like a potions puzzle, where your player would mix different colored liquids in a container to get the right color.

But it also allows you to do some rather wild things. Build a color from the output of a trigger zone. Make sounds from the outputs of a bunch of lights.

There are a number of fat wire types you can choose from in the combiner. Select one and the appropriate inputs will appear to plug your outputs in and make your fat wire.

Note also the splitter outputs the type of fat wire from its fat wire type output. Plug that into the equivalent input on a combiner and it will select the correct type for you.

Here's a really cute example - a color-changing shape. Stamp a shape and tweak it. Whack tint amount up to 200%. Add a combiner and 3 signal generators.

Tweak the combiner and set it to color. This will give you R, G and B (red, green, blue) inputs. Connect the combiner output to the input of tint color on the shape.

Change the wire blend (controls how wires going into a tweak affect the value of it) to overwrite, so that the combiner output determines the colors.

The signal generators will be used to cycle through colors, by giving us values for red, green and blue. Connect each of their output nodes to one of the R, G, and B input nodes.

If you hit start time now, the shape would just turn white, so we need to give each of the signal generators an offset so that they're not just generating the same value.

Tweak them and set phase offset to a different value on each, say 30, 60, 90. Now hit start time and watch the shape do a pretty rainbow thing.

Initializes and defines any variables you want to use in your dreams. Use it with the variable modifier for stuff like hits taken, items collected, enemies killed and so on.

The really clever bit is the option to make them persist in dream, meaning your player can leave one scene in your dream with (say) 10 gems, and enter the next with 10 gems.

To use persist in dream, you need to have a variable gadget (for each variable) with the same name and settings in each scene which uses that variable in the dream.

If you have a lot of different variables, think about saving them all together in one scene and saving it as an element that you can then add to all your scenes.

Be careful when naming your variables. Give them wordy and specific names to avoid accidental conflicts. "Cellar Door Is Open" is better than "door open", for example.

Let's count and display the number of jumps a puppet does. Place a variable and name it "jumps". Place a puppet, scope in to it, open its microchip, then open controller logic.

Put a variable modifier on the 'chip and tweak it. Enter "jumps" in the variable name field, set the operation type to add, and make the operation value 1.

Tweak the puppet interface and connect the jumped output to the power port on the variable modifier. Now it will add 1 to the "jumps" variable when the puppet jumps.

It'd be nice to see this working, right? Close all those 'chips and scope out of the puppet. Add a number displayer and another variable modifier to the scene.

Tweak the variable modifier. Enter "jumps" in the variable name field. Set operation type to get. Connect variable value to the number/range input on the text displayer.

Nip into test mode, possess the puppet, and do some jumping!

Makes changes to any variables you've set up. Say you have a variable called "gems", something your player can collect in your dream.

Use the modifier to increase the player's gems when they collect them; decrease them when they spend them; or to take them all away when they die.

Let's count and display the number of jumps a puppet does. Place a variable and name it "jumps". Place a puppet, scope in to it, open its microchip, then open controller logic.

Put a variable modifier on the 'chip and tweak it. Enter "jumps" in the variable name field, set the operation type to add, and make the operation value 1.

Tweak the puppet interface and connect the jumped output to the power port on the variable modifier. Now it will add 1 to the "jumps" variable when the puppet jumps.

It'd be nice to see this working, right? Close all those 'chips and scope out of the puppet. Add a number displayer and another variable modifier to the scene.

Tweak the variable modifier. Enter "jumps" in the variable name field. Set operation type to get. Connect variable value to the number/range input on the text displayer.

Nip into test mode, possess the puppet, and do some jumping!