https://steamproxy.net/sharedfiles/filedetails/?id=240391722&tscn=1632130396

https://steamproxy.net/sharedfiles/filedetails/?id=245673429

Hello 2021, hello anyone who may come across this article! It's been almost 8 years since the creation of two of my Wiremod write-ups, and things are much different than they were when I spent much of my free time in sandbox titles like gmod. I've not abandoned the platform, just make pit stops every so often since there really aren't many platforms out there as expansive as this, being a Source driven title that is.

Long story short, before I had gotten to finishing this guide, I had started working a job through high school and had a lot more interest in things I was missing out on in life instead of spending those couple extra hours every day tinkering with this game and others like it. I'm 23 now, and i'm always finding new things to peak my interest and learn about. My Wiremod days would proceed to fully functional prop engines, E2 scripts for controlling different aspects of prop vehicles such as torque-driving transmissions to suspension and gripping modifiers. The base "analog" style of gates has always been the fruits of my labors in the early days, and still is the most memorable experience I've had in the creation of contraptions. Nothing beats spamming a non-dedicated server on some dudes ♥♥♥♥♥♥ PC with a build containing over 200 logic gates and then having the audacity to keep everything shown just to show how maniacal you can be to avoid using E2 (at the time lol)

The rest of the content I provide in here is a mostly-complete awaited Part 3 to the write-ups, where I go over a lot of specifics of individual gates in the mod. A lot of this information was sourced from the wikis, and backed up with in-game descriptions of the inputs/outputs, as well as uses and application to some extent. Again, this was meant to cover EVERY gate, it seems I stopped at Vectors, which wasn't something I used much in gates but did dig into with expression 2, so to those who want that information, I would highly recommend using the official wikis as a backbone. It should give you the tools to work with (x,y,z) information for uses in vector thrusters and (forgive me it's been a minute) the x,y screens that can display pixels based on what information you feed it, dig?

I don't have plans on finishing this guide, honestly I just found out I left it as a draft as of writing this at 2 in the morning during a late night :) Please provide feedback about anything that's incorrect or missing that's been covered in the already existing categories, as I don't plan on adding any missing sections unless it was a heavy oversight from the beginning. I think I've explained enough already, I left most of the guide in it's original state that I left it in as a draft after a few skims of what I wrote down. I hope this helps those out there taking the steps after making doors and goofy thruster cars get going into more complex builds that they can use to strengthen their skills about basic arithmetic, how binary 0's and 1's are used in the activation of embedded objects in the game, and hopefully encourage some of you out there to spread that information with your friends! At the end of the day, these guides were made for people I couldn't fit in my time back then to coach on these principles, but that never stopped me from still going one-on-one with those who asked.

Thank you if you read through any of that, and if not, hey; this game is ancient and I'm proud of everyone that still runs their mind up on sandbox to inspire their engineering or programming mindsets, you all started somewhere, ♥♥♥♥, I'm not gonna judge if it was in Garry's Mod too. I love you all, sorry if I suck at reading comments.

- froggcore (A Twig)

Hello Steam Community!

It's been quite a while since the posting of my first tutorial, and even so with my second. Life has prospered me to take another important route in the mean time with work and everything else bundled up on top of that. Time for the explanation of the guide...

In this guide, I'm going to go through each folder in the gates section of Wiremod, and explain each gate. Each gate will be described briefly, descriptively or in high detail concerning it's usefulness to me on a regular basis whenever I create devices with gates. I will mark the less used gates in red, the moderately used in yellow, and the most useful in green. The green will get the most explanation, and if anyone wants me to go over a specific gate I will be more than glad to modify the list with that gate and explain how it works in more detail.

Each gate explained in detail will be given a quick example of how it is used, for example, how a timer works, why I myself use them, and an example of how a timer comes in handy in my contraptions. Let's start with the Table of Contents. (Gates)

I apologize to those who have read my tutorials in the past and are used to the old system of Wiremod. I will modify the old ones shortly with proper directions to find the wire tools since the new update to Wiremod itself. This tutorial will have the updated Wiremod instructions, so you won't be lost. (I prefer it anyways)

Once in-game, you will see the Wire tab and click on it. Once here, near the very top of all the folders is a folder called "Chips,Gates". Open this folder and you're greeted by a similar section that the Control section used to have, click on Gates to activate the Wire Gates table and tool.


On the right, you're welcomed by all your familiar folders, and fortunately this wasn't changed. (It would not make any sense in doing so since it was already organized nicely) I will start from the first folder, to the last folder; here we go:

The Trig folder (standing for Trigonometry) is a folder I seldom have ever used in general, mainly because I don't deal with many ideas of mine that I need to work with circles or triangles. I know people who have and the ideas were very interesting, and many E2s will use trig for different reasons, however I do not, so therefore I will not run down on each gate in this section.

If you know what trigonometry is, and know how to use it, you know what you're doing in this section. It is self-explanatory with Sin, Cos and Tan and all of the others included in the list. Feel free to experiment, but like I said I'm not going to run through it only because if you knew it through your math classes then you have no problem here.

This section is one of my favorite because it allows you to question the variable values flowing through your system and tell it to do something only when certain conditions are valid.

For example, in English it would go as such:

"Sir, the enemy has infiltrated the countryside, what do we do?" - This is an enemy that means no good, so the leader of said nation has no choice other than....
"We defend our homeland!"

Comparison can go like that, if a certain condition is met, then the resulting action is acted out. Here are the gates:

[X] Equal

Inputs: A and B
Outputs: Out

If A is Equal To B, then Output 1

The Equal gate I use often to ask if a value comes into the gate as the exact value I want it to be, and it has to meet that condition only. For example, if I want a system where I want a button to be pressed, and each time it is pressed an imaginary variable increments one number per click, and when the variable increments to the number I want it to, which would be what he Equal gate is told to be equal to, it will output a value of 1 when the condition is met. If I wanted the value to reach 5 and the equal gate's B value was wired to a constant value of 5, then when A = 5, the output will be 1.

[ ] Greater or Equal

Inputs: A and B
Outputs: Out

If A is Greater Than B OR Equal To B, then Output 1

Most of these gates say for themselves how they work. They compare values in regards to the constant value that is first given and the variable value passing by. This one I use sometimes, but only on occasion and it depends on the circumstances where I either use a Greater Than or a Great or Equal. (Which is also Greater Than or Equal To in math terms)

[X] Greater Than

Inputs: A and B
Outputs: Out

If A is Greater Than B, then Output 1

I will usually use a Greater Than gate, since my occurrences with certain values that come from gates such as timers like to not always be exact unless rounded, so I tend to use the Greater Than gate more often. Simply stated, it checks to see if the value flowing in it is greater than the constant value it is initially given.

[ ] Is In Range (Exclusive)

Inputs: Min, Max and Value
Outputs: Out

If the Value is NOT in between the Min and the Max, then Output 1

As useful as they sound, I hardly use them. They will output a value of 1 only if the value that variably enters the chip is NOT in between the Min and Max values. If your Min was 10 and your Max was 20, your chip would only output 1 if the Value coming into the gate was NOT 10, 11, 12, 13..... all the way to 20 or whatever your Max is.

[ ] Is In Range (Inclusive)

Inputs: Min, Max and Value
Outputs: Out

If the Value IS in between the Min and the Max, then Output 1

The opposite of the one before this, this one will ONLY output 1 if the Value IS between the Min and Max. I need no further explanation with this since the other one was explained, and you can put 2 and 2 together and see how this is clearly the opposite.

[ ] Less or Equal

Inputs: A and B
Outputs: Out

If A is Less Than OR if A is Equal To B, then Output 1

Another less frequently used gate but still as useful as all the others. As it says, it checks to see if a value is Less Than or Equal To the Value it is comparing to.

[X] Less Than

Inputs: A and B
Outputs: Out

If A is Less Than B, then Output 1

Used only more than the one above because of it's simplicity. It's your decision if you want to include the Equal To argument into your device, but it can alter the behavior slightly and it might be distasteful so be cautious of how you're designing your systems. Like it says, it checks to see if a value is Less Than the compared constant value.

[ ] Not Equal

Inputs: A and B
Outputs: Out

If A does Not Equal B, then Output 1

Simply put, if a value does not equal the compared constant value, then output 1. I never use this gate because I use a gate in the Logic folder section called "Not (Invert)", only since it's more useful in my contraptions that solely involve the values 1 and 0.

I avoid this section because I hate working with Arrays in E2, and because they're simpler in E2. I won't run down this because I personally believe that E2 is a lot more beneficial to use than the Array gates. I will explain what an Array does, but not with these gates.

An Array is a table of values that is held in an order from 1 to whatever value you have set to it's max. They are very useful for white-list systems, black-list systems, server lists, and any lists in general for that matter. If I mess around with arrays more, I will make a tutorial for it for gates.

- lmao so juvenile

All of your math related needs, for the most part, can be found here!

[X] Absolute

Inputs: A
Outputs: Out

If A is Positive, output Positive Version
If A is Negative, output Positive Version

|A| = Out

I am not going to run through most of these gates in detail even if I use them often. If you know what they do in the math world, you know how to use them here.

The Absolute gate takes ANY value it brings in, and always outputs a positive version of the value, known as the Absolute Value.

[X] Add

Inputs: A, B, C, D, E, F, G and H
Outputs: Out

A + B = Out
A + B + C + D + E + F + H + H = Out

Very useful gate that simply adds two or more values together. It can add up to a total of 8 different values in total, and you can create a system that adds together multiple add gates if you run out of space if need be.

[ ] And/All

Inputs: A and B
Outputs: Out

If A and B are NOT 0, then A + B = Out
If A OR B are 0, Out = 0

I have never used this gate, but I have looked for ways to use it. It is a strange gate that will only add values together if the values being added are NOT 0.

[ ] Average

Inputs: A, B, C, D, E, F, G and H
Outputs: Out

A + B + C + D + E + F + G + H / (NUMBER OF VALUES WIRED) = Out

Useful in the real world, but I have not needed to use it. It takes the average of the values inside by taking the sum of each input and dividing it by the amount of total inputs that are wired to another value.

[ ] Ceiling (Round up)

Inputs: A
Outputs: Out

Rounds Input value when the tenth digit is 0.50 or higher, bringing it to the next whole number.

Used seldom, it depends on what types of numbers you're trying to round and what for what reason. Timers are best rounded down, so you would use a Floor gate, but personally I use the Ceiling less often than all other gates. The Round gate does a good enough job of rounding values to a whole number that is usable in comparisons, but like mentioned, a Floor (Round down) gate will be more accurate for a circuit with a timer inside of it.

[X] Clamp

Inputs: A, Min and Max
Outputs: Out

Outputs the Minimum and Maximum approach values of A, and CANNOT exceed the Minimum or Maximum under any circumstances

Never using this gate before I had to see how it functioned, and I might use this very soon. It has a functionality to have a Minimum and Maximum value, which I set to 1 and 5. The A value is a variable value that flows through this gate and is expected to change. For example, if I had a timer attached to a toggled button to run when it's on, and a clamp with a Min of 1 and a Max of 5, with A attached to the timer, when the timer starts, the output of the Clamp would increase with the timer, UNTIL, the timer reaches 5. It will stop following the timer when it reaches 5. Basically, the Clamp will only output the largest or smallest value reached by the input of A. This can be very helpful in creating more efficient timing in all sorts of things, I would give this one a try honestly.

[ ] Delta

Inputs: A
Outputs: Out

Compares the change in the value between one point and another per server tick

Very nice in the math world, little usage in Wiremod. You can use this to create a turret that aims better, so that it checks the change in velocity or bearing from point A to point B, but that takes a lot of know-how to create something sophisticated of that level. All it does is output the change of a value from one point in time to a next.

[ ] Delta (Rectified)

Inputs: A
Outputs: Out

Compares the change in the value between one point and another per server tick without exceeding 180 or -180 (Good for angles)

Never messed with this gate in particular, only because it has a modulo inclusion that deals with remainders and with angles in certain regards. Experiment with this one at your own disclosure, but I don't have much to say about it. If you want to prevent your values from ever going above or below 180 and -180, for working with circles and angles, this is your choice for a delta gate.

[ ] Divide

Inputs: A and B
Outputs: Out

A / B = Out

Used occasionally but very useful. I use it once to convert a number down many times to create a 6 digit clock with 7 segment display. You can also use this in cooperation with an Add gate to make your own Average circuit. The possibilities with these math gates lies on your mental capacity. Figure numbers in your head and have the need to make numbers work the way you want them to work, and you might eventually find a need for this gate.

[ ] Exp

Inputs: A
Outputs: Out

Gives the exponential of A

This is a gate that doesn't modify anything, but tells you what the exponent of a number is. (if it has one) These are best used for clarity when using Exponential Power gates, which I will get to shortly. If you know how exponential powers works, you can get a hang of this

[ ] Exponential Powers

Inputs: A and B
Outputs: Out

Gives A to the exponential power of B

Exponents are a mathematical tool for simplifying excessively large or excessively small numbers. Most commonly in the real world are exponents used for scientific notation in making the reading of incredibly small numbers more simple, such as 0.00000000000032 would then be converted over to 3.2 x 10 to the 13th power. For your needs in Garry's Mod, you might not need to do that, but you can use this for increasing the value of a number beyond the simple capabilities of a Multiply gate.

[X] Floor (Round down)

Inputs: A
Outputs: Out

Floors the value it is given so that it makes the value the smaller whole number if the decimal is 0.49 or smaller

Simply put, it will round the decimal down to the smaller whole number as long as the decimal is 0.49 or smaller. Best used with timers, so that the whole number increases realistically with it's expanded counterpart.

[ ] Identity (No change)

Inputs: A
Outputs: Out

Gives the exact same value as A

Not a lot of use for this unless you are OCD and like a simplified circuit where everything is connected to a gate one way or another. This will give you the EXACT VALUE you wire it to, every time, no modifications to it at all. If you wire it to the output of a button, it will always be whatever the button outputs, instead being transferred to the Identity gate. It literally carries over the exact identity of the input.

[X] Increment

Inputs: A, Clk and Reset
Outputs: Out

Adds A to itself each time Clk is activated with a value greater than or equal to 1
The value built up can be reset to 0 if the Reset input is wired to something which outputs 1

The increment gate is very useful for counting a value every time something triggers it. If you want to count up each time someone joins the server you're playing on, that's possible with the increment gate. Every time Clk is triggered with a value of 1 or anything greater than 1, it will add whatever A is to the gate each time. If A was 1 and you wired a button to the Clk input, then each time you click the button it would "tally" up each time you clicked it. How you want to use these is your call, and they are very handy.

[X] Increment/Decrement

Inputs: A, Increment, Decrement, Reset
Outputs: Out

Adds A to itself if the Increment input is greater than or equal to 1, and Subtracts A from itself if the Decrement input is greater than or equal to 1

Like the gate above, this one is very helpful and can either tally up or tally down. Remember, A does NOT have to be 1. You can tally up 5 units at a time each time, or 20, or 500, or 20,000! It's your choice how much you want to increase each time you send a value of 1 to the Increment or Decrement input.

[ ] Inverse

Inputs: A
Outputs: Out

1 / A = Out

Mathematically speaking, if you had a whole number of 4, and you wanted the inverse, you would then have 1/4. 1/4 is the inverse of 4/1, you flip it.

[ ] Log

Inputs: A
Outputs: Out

Gives you the logarithm of A to the base of Euler's Number "e"

Preserved for those who know what they're doing, it will output the logarithm of A. I have not used this with anything yet, but it's there at your disposal so if you find it useful and have had ideas, let it out and experiment!

[ ] Log 10

Inputs: A
Outputs: Out

Gives you the logarithm of A to the base of 10 instead of e

Same as above, just with the base of 10 instead of e.

[ ] Modulo

Inputs: A and B
Outputs: Out

Gives you the remaining value after A is divided by B

Never used it, and I doubt I will find a reason to use it. Use it if you want to, all it does is give you the remainder of a division equation.

[X] Multiply

Inputs: A, B, C, D, E, F, G and H
Outputs: Out

A x B = Out
A x B x C x D x E x F x G x H = Out

As simple as it is, it is one of my favorite gates for it's simplicity in my circuits. I can create toggles, manipulate values and create proper acceleration for a vehicle, and so many other things with this one gate! I need no more explanation for this, if you can multiply, you have yourself a valuable tool at your disposal right here.

[X] Negate

Inputs: A
Outputs: Out

If A is Positive, then Out is Negative
If A is Negative, then Out is Positive

Whatever A is, it will multiply it by -1 so that it gets the negated value. It depends what you want to use this for, sometimes I may hook it up to a Numpad Input or a button or anything I need a -1 for with a circuit that deals with 0 and 1 already. Very handy, it will save you from needing to make a multiply gate and an extra constant value of -1.

[ ] Pi

Inputs: None
Outputs: Pi

No explanation. Directly gives you the value of 3.14 infinitely repeating to the true value of Pi without having to Google the most decimals you need.

[ ] Percent

Inputs: Value and Max
Outputs: Out

Gives you the divided value of Value and Max and multiplies it by 100.

100 x (Value / Max) = Out

Very simple, can be done with other gates but this takes away the need for 2 gates and makes it one. Never used it but there is potential for it.

[X] Random

Inputs: A and B
Outputs: Out

Randomly gives you a number between A and B in a non-simplified form

Unless I need a random vector, I will use this for RTD situations, or for other circuits I need random numbers spitting out, such as randomized spawn-points on death or for a slot machine I made a long time ago. Taking a random number between A and B and outputs it as a raw number with decimals, you can do anything with it.

[X] Round

Inputs: A
Outputs: Out

Rounds A to the lower whole number if it is 0.49 or lower, and rounds A to the higher whole number if it is 0.5 or higher

This is the most used round gate between Ceiling, Floor and Round. Because Floor will always round to the lower number even if the decimal is 0.99, and Ceiling will always round up if the decimal is 0.01, Round is useful for everyday usage for rounding numbers.

[ ] Sign (-1,0,1)

Inputs: A
Outputs: Out

Gives you -1 if A is less than 0
Gives you 0 if A is equal to 0
Gives you 1 if A is greater than 0

A very different gate that I've only used a few times. It's a form of selection gate that will output -1, 0 or 1 dependent on 3 different conditions. You can use this for selecting, multiply a number differently, or anything you might find the need for it.

[ ] Square Root

Inputs: A
Outputs: Out

Gives you the square root of A

Simple as it says, it gives you the square root of the number you want a square root of. Unless you plan on writing out trigonometrical equations, you might not find a use for this. Surprisingly there is no cubed root gate, or a gate that lets you create the root you want.

[X] Subtract

Inputs: A, B, C, D, E, F, G and H
Outputs: Out

A - B = Out
A - B - C - D - E - F - G - H = Out

Very useful like all the other basic arithmetic gates, this one will subtract up to 8 values together and output the remainder.

[X] Accumulator

Inputs: A, Hold and Reset
Outputs: Out

Lets you increase at A units per second and when Hold = 1, it will hold the value it contains and is outputting

This is a very helpful gate for doing thing such as vehicle turbos and accelerating an engine. A can be anything, and if it is 1 it will increase at 1 unit per second. If you make it 5, it will increase at 5 units per second. A can be anything, and use the Reset to make your Accumulator 0 again. The Hold value is helpful for locking the accumulator at a maximum value and keeping it there until the Hold input is no longer 1.

[ ] Delay

Inputs: Clk, Delay, Hold and Reset
Outputs: Out

When Clk is 1 or greater it will run a timer for Delay amount of seconds, and then it will output 1 for Hold amount of seconds

I never use Delays because my contraptions never work out properly, but I could use them. I usually use a mix of an Or gate, a Toggle gate, a Timer and a Greater than and it's my form of a delay. These are okay, and I strongly recommend you use these over my method so you save on gates. Lets say we clicked a button and then Clk was now 1, we want the Delay to run for 3 seconds, hold for 3 seconds, and then stop. You would wire Hold to 3, Delay to 3, and when you click the button, it will run the timer for 3 seconds, and then it will output 1 for ONLY 3 seconds since the Hold value is also 3.

[ ] Derivative

Inputs: A
Outputs: Out

Gives you the rate of change of A per second

Works similarly to how a Delta gate works, except instead of per server tick, this will output per second. Never used it but has potential.

[ ] Monostable Timer

Inputs: Run, Time and Reset
Outputs: Out

This will output 1 for Time seconds if Run is receiving a 1 and will reset if the reset input is 1

I have used this only a couple times not fully getting a grip but reading up on it more makes it have a potential in some of my ideas I've had lately. If you wire a button to the Run, and that button is toggled, and you wire the Time input to a value of 3, this timer will output 1 for 3 seconds. Once it goes over 3 seconds, it will stop outputting 1 and it will now output 0. It will never output 1 again unless reset and started again.

[ ] OS Date

Inputs: None
Outputs: Out

Gives you the current date that your computer reads off to you

Useful once using a decoder to get the proper Days, Months, and Years into individual values. You won't need this unless you want a global clock, same goes for OS Time.

[ ] OS Time

Inputs: None
Outputs: Out

Gives you the current time that your computer reads off o you

Same as above, except current time instead of date. The time is in military time so you will need to convert the hours if you want standard 12 hour time.

[X] Pulser

Inputs: Run, Tick and Reset
Outputs: Out

When Run is 1, this will output 1 every Tick (units per second)

Reset is useless when I use these. I usually have these always running and just switch them on through a Multiply gate. I use them for strobe lights, alarms, white-list systems that pulse through the Target Finder's Next Target input and search for targets that are not being skipped over. If I set the Tick to 0.5, and ran the Pulser, it would pulse every half second. If I made Tick to 2, it would output 1 every 2 seconds, and it would do this loop infinitely as long as Run is receiving a 1.

[ ] Saw Pulse

Inputs: Run SlopeRaiseTime PulseTime SlopeDescendTime GapTime Min Max Reset
Outputs: Out

When Run is 1 this will go from the Min value to the Max value at SlopeRaiseTime in seconds. When there, it will hold the Max value for PulseTime seconds. Afterwards, it will go from Max value to Min Value at SlopeDescendTime in seconds. When there, it will hold the Min value for GapTime and loop the cycle infinitely as long as Run receives a value of 1.

Probably one of the most elaborate gates I have seen. I have never used this gate, and just thinking about it gives possibility. This could potentially be a way of making a security camera that pans left to right, and hold it there for a while, then pan right to left and repeat. The possibilities have a limit, since it's automatic unless you ran variable values through the different time values.

[X] Smoother

Inputs: A Rate
Outputs: Out

This will reach A at Rate units per second

One of my favorite gates, very hand for steering chassis and for smooth opening doors. If you want to get to the number 100, and you want to get there faster than 1 second at a time, you would use either an Accumulator or a Smoother. The advantage of a smoother is that it can ONLY reach A, where as an Accumulator increases infinitely at A per second. The Smoother MUST reach A at so many units per second, which is Rate. We could increase at 10 units per second to reach 100 in 10 seconds by making Rate equal to 10, and A equal to 100 and it would reach 100 progressively at 10 units per second. The output is the progression of it going to the number, and when it reaches that number it stays there until A changes. Changing A is why smooth doors work, changing between 0 and 100 would let it go from 0 to 100 at 10 units per second, and from 100 to 0 at 10 units per second equally.

[ ] Square Pulse

Inputs: Run PulseTime GapTime Min Max Reset
Outputs: Out

When Run is 1 it will output Min for GapTime seconds, and after it will output Max for PulseTime seconds

A simpler version of the Saw Pulse gate, and this one also has potential to be great. It will output Min for so many seconds, then after the time is up, output Max for the said amount of seconds too. There is no transition time so that is where this becomes the simpler version of the Saw Pulse.

[X] Timer

Inputs: Run Reset
Outputs: Out

When Run is 1 it will increase forever at 1 unit per second in decimal form

The simplest gate of the folder. It is literally a timer. It is calibrated for real time and increases at 1 unit per second and can be reset. Without the timer, many things would be very difficult to do.

[X] Addition

Inputs:

w o o p s i e s 🐸