Binary Encoded RGB Gaming Beacon in Minecraft

G’day ladies and gents cubic meter here i recently discovered that you can make multi-colored beacons well i always knew that placing some colored glass above a beacon would change the color of the beam but what i didn’t know was that you could combine different glass colors to make slightly different variations of a

Color this inspired me to create this very compact color shifting beacon however you might notice that the color shifting on it is not very smooth the problem is i don’t quite understand how the color mixing works with the beacons so i went and had a look at an

Existing design which was able to make the smooth transition between all the colors this particular design is one made by peter farr if we unravel the entire block conveyor of this design what we get is a sequence that looks like this and what immediately strikes me is that this sequence for changing

Between the colors looks to me like binary counting so let’s do something interesting and build a binary encoded beacon now to start with i don’t just want a single beacon beam i want to make the beam thick so of course this means that we need to make considerations throughout our entire design process

Or a thick beam the basic idea is that we can start with a simple sequence like red green and blue we can then split up the layers of this sequence into five different layers each can be assigned one of the three colors then we can simply select one of the three colors

For each slice ah bugger it turns out this is just one of the instances where java redstone can actually be a problem what we are seeing is quasi connectivity meaning if we try to power only this slice it will also power the slice below it but where does

Quasi connectivity even come from well back in the day before pistons were even added the only component that would respond to direct redstone inputs was the iron door and as you can see with an iron door i can power the bottom but also the top but here’s the funny

Story when notch went to introduce the piston into the game for the first time it copied the code for the iron door into the piston so if i power this lever you can see both the door and the piston power but if i power this lever the iron door immediately opens however

The piston doesn’t extend at first but observe now what happens when i send this piston a block update the piston now thinks it’s being powered by this block here and that is because the piston has some code in it from the iron door telling it that if this space

Above the piston as some power source around it that it should be extending but of course in the example of using this lever the red glass indicates where all the block updates are sent you can clearly see that none of the block updates is sent to the position where

The piston is meaning the piston doesn’t know it’s being powered by this lever until we send it a block update from another source so why is it that the door responds properly or the piston doesn’t well the door is a multi-block structure and this top section is receiving the block update

And in fact we could mimic the same situation by pulling the piston upwards so if i now power this lever send the piston a block update and then unpower the lever when the piston head receives the block update it will actually send the signal to the piston base telling it to retract

And in that sense you can actually see the behavior of the piston matching that of the door that is quasi connectivity in a nutshell pistons are confused and think they are iron doors but unfortunately this does not help the case of trying to select an individual

Color from our column so i guess we may as well give up and build this on bedrock edition instead but hold on because java edition still has some tools left at our disposal to actually make this possible check out what happens if i put a button on the side of this piston

And hit the button as you just saw only this color extended that my friends was a zero tick something that is definitely not possible in bedrock edition a zero tick occurs whenever a redstone component is powered and then immediately in the next game tick unpowered in this particular example

When i hit the button the piston will immediately power then schedule the button to be broken so in the next game tick the button is already broken and the piston realizes it doesn’t have power and then receives a zero tick pulse and with sticky pistons in particular this zero ticking behavior makes the

Sticky piston extend instantaneously if you watch the block you see the block moves instantly if we go back to pedophile’s design and start the clock what you’ll notice is that he actually uses zero ticks to move the next sequence in front of the beacon because if we use regular pistons like so

The blocks take free game ticks to move and in that time the beacon realizes it doesn’t actually have any color above it and then we’ll flash briefly into the default white color so zero tick sticky pistons are also a solution for getting that extremely smooth color transition

In our encoded beacon design we can replicate a zero tick like so what i’m going to do is place down some regular pistons then i’ll have observers like this the observers will be watching some rails like so and over here we’ll have a reset system which is just two pistons

Like this with our rails alternating like this we can now individually target a layer and have that layer and get zero ticked in front of our beacons like so the reason we are able to do this is due to sub tick mechanics another tool only available in the java

Edition of the game i’ve explained many times how this rail will reverse the update order that it’s powered so when we power from this side this line observers will fire first meaning we have this block being powered and this block being powered before this piston will then start extending meaning

Power is simultaneously sent to these pistons and removed giving us our zero tick and the beautiful thing about a zero tech is that it doesn’t allow quasi connectivity so we’re able to individually target a layer and then above that we even get the instantaneous transition of the

Color of the beacon beam by copying the setup all throughout the layers and then rotating it around our thick beacon beam we now have a setup that can individually target a color on each of our five layers i can make this layer green this layer blue this layer red and so on

So what we essentially have here is a 15-bit binary input to choose a color for each layer but now we run into another problem let’s say for example i want to start with the beam being completely red but then i want to keep one of the layers red as

I start transitioning to green well then in order to start transitioning to green i need to undo the layers with red then add in the layers a green and red and within that transition you can see that the beam briefly turns white however we want a smooth and continuous transition between colors if

We start with a sequence that’s like red red we want to be able to send it any sequence and have it transition to that sequence seamlessly meaning that if we send it the red green sequence we want it to change this to green remove this red and then realize that

This is already red and do nothing what we need is a memory system which can keep track of what colors are already active and if a new sequence coming in tries to trigger that color it will ignore it however if there is an active color that is not included in the next

Sequence we want to remove that color it turns out that a bit of java mechanics can help us out remember our other two components that can receive quasi connectivity here we have a dropper if we wanted to power the red glass on the bottom layer

All we need to do is trigger that bit and what we do is we quasi-power the dropper and then send a block update through this rail what ends up happening is that our dropper will go into the triggered true state if i continue to send signals to the red

Glass on the bottom layer the state of our dropper is not going to change that is to say our dropper remembers that the red glass is currently being triggered on the bottom layer if i add another dropper corresponding the green color on the first layer now we have a separate input for the

Green if i trigger this input it will power this dropper for the green while also sending a block update through these rails so if i go ahead and trigger this because the block update is sent to both of these droppers the dropper for the red realizes it’s no

Longer powered then toggles off however the dropper corresponding to the green is toggled into the triggered state the result is that we now see the green turned on and if i continuously send messages to the green it will simply ignore them because it already knows that the green is activated and doesn’t

Need to be triggered but if instead i want to toggle the red on like so the green has been retracted and the red has been put in its place this means we now have an effective memory cell for seamlessly transferring between different colors stacking together the memory gives us our 15 individual inputs

Corresponding to the colors on each layer and using the memory we can instantly transition between each color the how the logic works is that if i power any of these inputs it will power the dropper for that slice however it will receive any input that gets powered and then redistribute that signal

To send a block update to every single one of the droppers so if a dropper is in the powered state when it receives the update it means that that color will be turned on if any dropper receives the update on not being powered it will switch that

Color off so if i send any other signal it will turn off any of the droppers that are not being powered by that same signal and turn on any of the droppers that are being powered by that signal and by simply sending a block update to every single dropper without powering anything

Gives us a full reset so we now have 15 bits each one corresponding to a color being activated on a specific layer and for each layer we will be transitioning from one color to another one way to transition through all of our encoded sequences is to store everything in a

Read-only memory cell here we have the entire sequence of our transition from red to green to blue and back to red all encoded in a unary slice of a read-only memory of course when we start with red we want to have an observer on every slice corresponding to red

So we have a red on the very bottom and three blocks above that another red three blocks above that another red and so on until we have every single layer filled with red so if i go ahead and send the sequence for red from the read-only memory to our beacon

You can see the beacon immediately turns red if i send green like right here our entire beacon will turn green so we’ve gone from a 15-bit sequence and then compress that down into 48 different color combinations so even though we have 15 bits going into our beacon which gives about 33 000

Different combinations the vast majority of those combinations will produce similar colors so in reality we only need to worry about these 48 color combinations that means we can compress the 15 bits with 33 000 combinations into only six bits with 64 different combinations so i can now line up the 48 different combinations

Into a string of six bit numbers starting at zero our beacon will turn red if we skip to color number 16 a beacon will turn green if we skip again all the way to color number 32 in the sequence a beacon will turn completely blue now that we’ve got all of our color

Combinations lined up in binary from 0 to 48 we can implement something like this clever little binary counter invented by crane and this absolutely blew my mind because it’s so ridiculously simple and compact and it counts in binary looking up the binary counter to our beacon we can now automatically cycle

Through the entire color transition sequence automatically as you can see a beacon is now gradually turning green if i tick warp we can see our beam transitioning through all 48 of our color combinations this approach to a binary encoded beacon in order to get the color transitions

Is obviously a lot less compact and less reliable than the feed tape method however we do in fact get the advantage of the system being expandable which is what allowed us to get our thick beam and we can instantly transition to any color that we want without having to go through every other

Color to get to it but this feels extremely inefficient we’ve got this beacon which is capable of cycling through 48 colors however the feed tape system which is way simpler to build and way more compact is able to cycle through 96 colors and simply adding more color combinations to

This rom feels like a very inefficient way of doing it simply because if we want to get 96 or even more combinations we’ll need to add every single one of these combinations to our rom making it not just 48 blocks long but 96 blocks long and that would be an insane

Amount of build effort so what if we could be smarter about this and use the advantages of our encoded beacon design to go with a sequence of colors with even more combinations and then cycle through these combinations in a way that does not require every single combination to be hard-coded in a memory

Unit well if we look closely at the pattern of our color transitions we can start at something like the purple glass here if we focus on the value of the red in binary we can see that it goes from zero to one in the red color the next transition

It doesn’t go to two it goes to one plus two equals to three this is how you count in binary by the way so if we continue counting we have one activated we also have four activated meaning we add one and four together and we get five continuing this trend we can see

All of these combinations are going to be even numbers like 2 4 6 and 8. every single one of these even numbers is going to have the number one added to it all the way up until this point here what that means is that our red color is counting in binary

Every single odd number so it’s going 1 3 5 7 9 all the way to 31. now look at what happens when our red gets to 31. we then remove the one then drops down to 30 and starts counting down to 28 26 24 all the way down to two

And then to zero there is actually a logical pattern to the way in which we transition through all of the colors this gives us a handy way to possibly bypass the need to have a massive memory unit for every single color combination we could instead make some sort of

Analog circuit that can count through all the binary combinations of the colors and what i ended up with was a massive modification to crane’s counter which would count in the specific way that i wanted but just imagine that these five bits here correspond to the five layers of our column

That need the different colors of glass we have our bottom right here and the top of the column right here let’s say we start with a color at a value of zero so what that will correspond to is that we have another color which completely fills the column

Then the next color is going to be zero in that particular instance as we count we start by adding one then we add two to make three we add four to make five and so on for every single one of the odd numbers until we finally reach

Our 31. the entire machine has now flipped states and so if we trigger it again we remove the one digit and we’ll now start counting down in even numbers this is basically an analog circuit mimicking the pattern on this glass and by introducing an analog circuit to our binary encoded beacon

We can go from this setup with the massive rom that scales with the amount of color combinations to this absolute monstrosity with 176 different color combinations and those are only the combinations that you can do in a linear sequence we have 11 colors where any particular color can be

Combined with another color in 16 different combinations this gives us 16 multiplied by 11 factorial different color combinations which is roughly 640 million different color combinations however at the moment this sequence is only set up to cycle through from black to red to orange to yellow to

Green the blue the cyan to a darker blue then to darker purple then to magenta then to white then the white goes back to black and keep in mind we will have 16 transitional colors between each one of these so with 11 colors in total we end up with 176 different combinations running

Through this sequence in order to gain access to these 640 million different combinations we would need to bypass this sequence and allow combinations such as black fading into orange or red fading into green things like that currently all the beacon does is transition through all the spectrum

Colors but of course it is capable of doing this using a thick beacon beam zero ticking the blocks for that smoother transition between colors as well as being fully resettable at any stage in the entire sequence so now if we start the sequence again we will see it will start back at black

There we go there we have it the barn ring coated rgb gaming beacon this is a pretty fun creative project learning to work with butter and curd redstone this might not have many uses in survival although we have already considered using a beacon like this in wavetech’s new main storage

Not only because it will be cool to have an rgb gaming beacon but because you can encode specific signals to be displayed through the beacon to indicate various things about the storage which could be a really cool application of this technology anyway thank you very much for watching

And i will see you next time