Algodoo Marble Racing Components

(Insert some intro about Components) [THIS IS A WORK IN PROGRESS]

Main Page: Algodoo Marble Racing Wiki

## **Alternators**

   May also be known as T-Flip Flop. The way it works is that it sends a marble to one direction, and by doing that tips to the other side. The next marble then gets sent to the other side, tipping the alternator back to it's original state. The idea is that it alternates where it sends the marble, hence the name. Commonly used with the organizer.

**How to make:**

* This can be pretty challenging to make and there's no one-size-fits-all answer, so I recommend not relying on the text and checking out the video link below.
* Make a T shape from boxes and add an axle to the center-bottom part.
* Add 2 boxes below it to make sure it tips just enough and not too much.
* This might take some trial and error to make but other than that, it's not that hard. Make sure to set the friction and restitution to 0 so it doesn't bounce and the marble can flow smoothly. Lowering the mass (not too low!) can help too.
* Tutorial video from Algorox: https://www.youtube.com/watch?v=8VEAxKl4278

## **Axles**

Axles are used to loosely attach objects to other objects or to the background. Unlike using fixates, objects attached with an axle can still spin and move. Axles can also be set to be motors and brakes, the former allows objects to be spun and the latter does quite the opposite, more specifically try and prevent objects to be spun.

**How to make:**

* You don't exactly make these, you just need to add them. Click on the axle on the bottom left side (or press the shortcut tool "H") and click on the object you want to attach. Make sure the object you want to attach it to is behind it.

## **Bowls**

   Bowls are one of the simplest and most common components you can have in a marble race. It gives marbles who are falling behind a chance to catch up with the ones that are ahead. It's relatively simple to make too.

**How to make:**

* Make a box as big as you want the bowl to be.
* Cut out a circle from it, a good way to do this is by making a circle and utilizing the subtract tool.
* Cut out the top half of the remains of the box until it reaches the far edges of the circle you cut out.

* Tutorial video from Rome Hanna: https://www.youtube.com/watch?v=ajhzafjS2J0

## **Box**

Boxes... well they are the basic track of a marble race. Literally just make a box and tilt it to get a track. Alternatively, you can add a sideways velocity script to it (see
velocity pad). To be honest, there's not much else to say here... So keep on reading!'

## **Circle**

Circles are probably the most important thing. Without them, there would be nothing to race!

This concludes this topic

## **Conveyors**

Also known as conveyers (looked it up and even though it seems misspelled, is somehow acceptable). Conveyors are a series of spinners that move marbles by hitting it with a spinner and passing it to the next one, continuously until the marble reaches the end of it. The most common shapes used for conveyors are ovals, rectangles, triangles and squares.

**How to make:**

* Look down below on how to make spinners and just add them one after the other! Make sure to select them all and tick "No self collision" (or heteroCollide in script menu) to make sure the spinners don't hit each other.

## **Fixates**

    Fixates are pretty much an alternative to gluing objects to other objects or to the background. Honestly speaking, I can't think of a difference. Just think fixates fix objects to other objects or to the background.

**How to make:**

* You don't exactly make these, you just need to add them. Click on the fixate on the bottom left side (or press the shortcut tool "F") and click on the object you want to attach. Make sure the object you want to attach it to is behind it.

## **Float Pads**

Not to be confused with **gravity pads**. It changes marbles' densities to a lower value when touched, making them float. These pads often come in pairs: one to make the marbles float and one to reverse the effects of the float pad.

    **How to make:**

* **For the float pad itself:** Make a box and add this script in its onCollide box:
```
(e)=>{
     e.other.density = 0.001
}
```
What this does is lessens the marbles' densities, making them float. You can change **0.001** in the code to a different value to change the marble's float speed, with lesser meaning faster.

* **For the float cancellation pad:** Make a box and add this script in its onCollide box:
```
(e)=>{
     e.other.density = 2
}
```
What this does is changes the marbles' densities back to its original value. 2 is the density for all objects by default, but if your marble uses a density value other than 2, then replace the **2** to be that value instead.

* **How is the float pad different from the gravity pad?:** For the most part, the two can be used interchangeably, but they do have their own uses.
	+ The float pad makes marbles float in a constant speed but the gravity pad accelerates.
	+ The float pad keeps the marbles floating upwards whenever possible, while marbles under the effect of the gravity pad can bounce.
	+ The float pad can only be used going upwards but the gravity pad can be altered to move marbles in a specific direction.
	+ Although they serve almost the same purpose, they have their own uses: a gravity pad might be better in a reverse plinko situation, while a float pad might be better if you just need the marbles to fly straight upwards.

## **Fork**

A fork in marble racing probably has nothing to do with the utensil. A fork is a very broad term that can be made in many ways. A marble will fall straight on an object - as long as it makes the marble either go left or right with no certainty, it's considered a fork. You might think that this is pretty much an alternator or the other way around, but the basic idea is that you know which
way a marble will go on an alternator (depending on which way it's tipped) so you can make sure that marbles are spread out evenly, and with forks, you have absolutely no idea which way the marble will go.

## **Gears**

Gear are surprisingly important when it comes to marble racing. They can move marbles, program multiple things at once and much more! As well as have spikes on the outside, It can also have spikes on the inside. I have no clue why that would be useful but it just is,

## **Gravity Pads**

Not to be confused with **float pads**. A less common component, but a very useful one. Gravity pads can turn the marbles' gravity in all directions: left, right, upwards, diagonal - you name it! However, the most common one is the upwards one, and is the one demonstrated in the *how to make* below.

    **How to make:**
Go to script menu, and in the onCollide of the pad, type:

```
(e)=>{
    e.other.postStep = (e)=>{
        vel = vel + [0, 0.32]
    }
}
```

This is the basic code for an upside down gravity pad. For modification, just change the numbers in the code. For a more detailed tutorial, check out Algorox's video here: https://www.youtube.com/watch?v=ED\_wDVSZB-g

## **Marble**

Circle (without circle cake or borders) + Tracer (Fade Time = 0.15 and Size = 2 \* Circle Radius) = Marble!

LOL, as easy as that!

## **Organizers**

Organizers are commonly used to regulate the flow of marbles - an example being before an alternator. It makes sure the next component doesn't get overwhelmed with marbles. There are 2 common ways organizers are made:

#### **1. Gear organizer**

The way this functions is that marbles occupy the holes in the inner circle if it's vacant, and will be able to go around to the bottom where they get to continue on with the track.

**How to make:**

* First, you want to make the inside circle. Make a circle and make it as big as you'd like, but generally you should stick to a moderate size. Punch out holes where the marbles should slide in by placing marbles on the circle **with half of it sticking out**, and using the subtract tool. Most of the time, people tend to make 2 or 4 holes, but make as many as you deem appropriate.

* Now, add guides on the side so that the marbles don't fall off. Make two circles: One being *radius of your inner circle + 3 times the radius of your marbles* and the other being *radius of your inner circle + the radius of your marbles.* (Example: If your inner circle's radius is 2m and your marbles' radii are 0.5m, the 2 circles you should make are 3.5m and 2.5m.) Subtract the smaller circle from the larger one. You should be left with a ring. With that ring, cut out the top and the bottom so your marbles can slide in and out. Place the ring in a way that the inner circle is in the middle of it.

* Don't forget to add an axle to the inside circle - don't make it spin too fast that marbles fail to exit the hole. Don't forget to glue the guide too, but **don't** glue the inner circle or else it wouldn't spin. For best results, try setting the friction to 0.

* Tutorial from Algorox: https://www.youtube.com/watch?v=3wnD7Rk\_xx0

## **Opening Gate/Controller**

Opening Gates are what make sure that marbles start off fairly. there are several types of Opening gates, including but not limited to: Circle Spinner, Teleporter, Square Spinner, Circle Spinner w/ guide, Timer and more! They use the controller section of the drop down menu to do this. Going to controller, we can use the Destroy Key to destroy the starter. Do this by clicking on the Destroy Key space then hitting the key that you want to set the Destroy Key as. You can also set multiple destroy keys, and they will need to be pressed simultaneously for functions to work.

## **Pump**

Pumps are objects that move side to side, utilizing two walls.

**How to make:** I'm not explaining this so just watch this: https://www.youtube.com/watch?v=VsUTp6xYKVw

## **Snake**

A snake is a long, curly tube that resembles, you guessed it, a snake. The way it works is relatively simple: a marble enters it and slithers down it. The way you make it though is a little on the complicated side.

**How to make:** I'm too lazy to tell you

## **Spinners**

Another common component, spinners spin... hence the name. They can serve varied purposes, such as flinging marbles in a certain direction or to keep marbles in bounds within the track. Note that the term "spinners" are not limited to ones that have four arms or "crosses". They can have a varied number of arms or even varied shape, too.

**How to make:**

* Since spinners can come in many shapes and sizes, there's no one-size-fits-all answer to how to make it. Although, the general idea is that you should add an axle (see Axle) to the middle of the shape to make it spin.

* Tutorial video from Algorox: https://www.youtube.com/watch?v=Gw3JuecinMM

## **Spring**

The Spring tool attaches objects to the background or to each other with a spring.

**Note:** That spring must bee attached to at least one geometry. To obtain it. press S.

**How it use for marble race:**

It used for Holding object. Unlike the fixate. It make the block standing still but still moving when the marble touch. It really helpful for legs that design to make the marble go pass through the obstacle.

-...what? (a different person here, idk what this is supposed to mean)

-Springs are good at, well, being springs. They don't have any collision and must be connected to at least one geometry,. When a spring is created, it tries to hold it's length (it can be rotated all you want, it does not care). In the settings, you can adjust 3 unique settings:

-spring constant: how hard it will try to hold it's length

-damping: how much "energy" it loses (how fast it will enter a resting position once it reaches optimal length) -sort of like friction, but a spring.

-target length: how long it will attempt to be (starts as however long it is when created, but can be adjusted)

## **Teleporters**

Teleporters... teleport things. The position of a marble is determined by its variable called pos. By modifying this, we can teleport marbles!

```
(e)=>{
    e.other.pos = [x, y]
}
```

If this code is in onLaserHit, the code will not work because of the nature of scripting w/ lasers. The correct code is below:

```
(e)=>{
    e.geom.pos = [x, y]
}
```
(insert part about moving ends to teleporters here)

- another way to create teleporters, which is especially useful if you want moving teleport "exits" is to teleport to a variable, as you can put position data into a variable. The simplest method I know to do so is to first create your teleport "exit" and enter the script menu. In postStep, put the following:

```
(e)=>{
    scene.my.[variable name] = pos
}
```
--i recommend to be sure your teleport exit is fixed to something, and remove its collision, but you do not have to.
-You then create any teleport entrances. They are required to have collision, but I recommend fixing them to something as well, to prevent them from falling and teleporting anything and everything (yes, even the floor and any walls and whatnot) to the exit. In the entrance, enter the script menu and under onCollide, put the following:

```
(e)=>{
    e.other.pos = scene.my.[variable name]
}
```
This code will cause anything that touches the entrance teleporter to get sent to the exit teleporter. Some information:

-There can be multiple entrances per teleporter, but only 1 exit.

-water cannot be teleported.

## **Thrusters**

Thrusters are boosters the can Apply a force to its applied object. It can be turned any direction the object is and the thruster will use its force to push that object in that specific direction. You can change the force of the thruster to affect the movement of the object. You can also set the option to make the thruster only move one position no matter if the object turns. And you can set an activation key to a thruster to turn it on and off.

## **Tracers**

Tracers are used to give the marble a trail, hence the name. Usually they are the same size as the marble, have a 0.1 - 0.2 second trail, and are the same color as the marble. However, sometimes several tracers are attached to a marble for a triangular effect, or to clearly show a dark marble on a dark background, or a light marble on a light background. The code to add a tracer to a marble is "scene.addPen" (see Scripting components [to be added]).

## **Trampoline**

Again another common component. The way it works is that it will bounce the marble - simple as that. It can help any marble racer beginner improve their skills.

**How to make:**

* It's easy, add a box and change the Restitution under the materials tab to a higher number (A good number is around 1.5 - 2.5, depending on how high you need to bounce the marble and how big your marbles are).
* **Note:** Don't make it too high or your marbles might glitch!

* Tutorial video from Algorox: https://www.youtube.com/watch?v=h55kH9uol5Q

## **Water**

Water is literally water in the physics simulator. You would think "how do you even apply water into marble races?" but you'd be surprised on how it can spice up your race. You just need to get creative ;).

**How to make:**

* Water can be added in manually by spawning in a box or a circle and *liquefying* it. Once you do, the object you liquefied will turn into water molecules.
* **Note: Don't** overdo the water! Water can lag your PC horribly on Algodoo, so refrain from using it too much!