JUMP 2-4 players 6+ blinks Move the jumpers around the board and jump on your oponents until you're the last one standing. Setup: Assemble the blinks in any way you like. Each player choses a controlling blink and long-press it until it displays his color. Play: Click once your controlling blink to have your jumper move in the direction of the white arrow. If there was an other jumper there, it got destroyed, congratulation. Optional extra rule: At any time, double-click your controller blink to bunker your jumper. If anyone jumps your jumper while bunkered it will be destroyed instead of you. Bunkering lasts 3 seconds, and can only be done once every 30 seconds. Your jumper cannot move while bunkered. Reset: Triple-click a controlling blink to spawn a jumper again. Trilple-click any other blink to remove the jumper there.
If I understand this correctly, a player uses one blink to control action that occurs on the rest of the blinks, so the single blink is like a gamepad while the others are the “screen.” Correct? I’ve wondered if this sort of thing was possible, but I couldn’t figure out how the communication would happen efficiently. Does the game work alright? (I can’t load it up at the moment!)
Yes it works as you described. The orders from the “gamepad” blinks are broadcasted in parallel with a debounce: when a blink receive a “jump order blue” for instance at time T, it will broadcast the order between T and T+EMIT_DURATION, and ignore any similar order received between T and T+DEBOUNCE_DURATION. Feel free to check the code.
FWIIW, Hexxagon does a similar thing but using datagrams instead of face values. Every single blink in the cluster is aware of things happening anywhere else in it.
Yeah, and it makes sense to me in that context. I think of Hexxagon as a more traditional “board game” format (I understand the original Hexxagon was a computer game, but still built on a board game concept). Players take turns, there’s no need for quick reactions, etc, so it doesn’t hurt anything to have a lot of redundant information across the board (I assume this is effectively what happens w/ Hexxagon?)
What I’m trying to wrap my head around in this Jump game is how the game handles quicker decisions, or what happens when more than one player sends a signal from their control blink at the same time?
Maybe it works out; I’m still in the early stages of wrapping my mind around how these things “think” anyway. And currently I’ve leant out my dev kit to my brother in another state, so I can’t load it up to try!
Although maybe I’m missing something – the custom blinklib allows blinks to set up a virtual map of their cluster, correct? Does this then allow a message from any given blink to be targeted/sent to a specific other blink, rather than just sending the message out across the whole board?
Apologies to the OP if this is sending this thread off on a tangent
Yes. Every Blink in Hexxagon had the full map of Blinks in the game.
But back to the game at hand, face values propagation, specially with just a few Blinks, is fast enough for this kind of thing. Although it is always possible to break things if you are not careful.
I did not look too deep into the code yet nor tried to play it (I will), but it looks the main method for handling issues like that is debouncing. I guess you can still break it if you manage to send conflicting signals for the same player from 2 different Blinks.
Well, you are asking the right questions, if that helps.
The Custom Blinklib itself does not do that (it adds only a few things on top of the original Blinklib), but it makes doing this kind of things easier by adding guaranteed delivery datagrams, so you can send a datagram and can be sure it will be received by connected Blinks eventually.
The thing that allows the mapping is actually my Blinks Broadcast library. It does not support directly addressing a Blink (it could be added if needed) but you do not need to. You can add the Blink “address” to the payload and then only handle packets that are addressed to you (all other blinks will also receive it, but simply ignore the packet).
Awesome, thanks for the additional insight!
So, I tried the game. Seems to work fine except that there should be an indication of which blink is the controller one for a player (I misread the rules and thought the controller blink was the actual colored Blink and that I need to click whatever was the colored Blink to move it. When I realized the problem, I did not remember what was the controlling blink again and had to click Blinks in the general area where it was to figure it out.
When you have a lot of Blinks, the latency of value propagation actually gets very noticeable (I played with 67 Blink).
I’m sure this wasn’t intentional, but I like the sound of “Blink” as both singular and plural