New Game: Blink "Chess"

This is something I have been working on and I just finished implementing the game “engine” (for lack of a better term) while I do not have an actual game yet.

The actual rules are only tentative and incomplete at this time but I will mention what I have in the hope that other people might chime in with suggestions:

The general mechanic is that it would be a 2 player game (at least at first) with a fixed number of pieces. As there is no “board” per-se for Blink games (well, Hexxagon technically makes a board out of the Blinks themselves) the “pieces in fixed starting positions” from chess is replaced by “pieces join the game one by one” at each player’s turn.

Each Blink would have a role (like in Crownfall) with multiple Blinks in the same role being possible. Each role would, as expected, have different properties (more on this below).

Either during the setup phase (where pieces are being added one by one) or after it finishes (all pieces are in), players would be able to start moving pieces around.

As In chess, each piece can move only in a specific way (to be determined) but probably related to how they can be moved from one place in the cluster of Blinks to another place in the same cluster.

Also as in chess, the main objective would be to capture a specific piece (a king?). How that would happen is still up for discussion but an obvious way would be if it was surrounded by pieces for the other player (depending on how this would play out with other movement rules, of course).

Some generic rules common to several Blink games would apply here: There can be only one cluster (so moving a piece can not break it in 2). Pieces can only be moved if they can easily be removed and inserted in another position (this probably excludes moving pieces in the middle of the cluster although I THINK this could be relaxed depending on how pieces move), pieces must be touching at least one other piece to be in game (with some specific logic to sort up the first move where there would be a single piece, maybe just having an initial cluster with one piece from each player).

And, in case it is not clear yet, a move means physically moving pieces around the cluster following the specific movement rules.

The cool thing about what I intend to do (and I am not sure I can do everything I want due to space constraints) is that it will feel and play like a normal table top game with discrete pieces (think, dominoes) but other than animations I intend to add game hints (for example, when a piece is removed, the cluster will indicate where that same piece that was removed can be reconnected to it), cluster validation (for detecting invalid states and end game condition) which is something that can only be done with Blinks.

This is how far I went with this so far. Any suggestions about ANYTHING (specially game mechanics/rules) would be greatly appreciated.


Hey @BGA I think what you’re trying to do is something very similar to one of my FAVOURITE two game players and actually exist!


Is a turn based placement, it actually uses hexagonal pieces with bug trailed draws, and need a minimum of 11 “pieces” per player (without expansions) and there are 2 additional pieces as expansion, doing a maximum of 13 per player.

Is based on the “capture the queen” concept, and also not divide the “cluster” (instruction says it must be only one “hive”)

Of course a Blink implementation can be something really good!

Check out the rules, I think you can get some cool ideas with this game =)

1 Like

Thanks for the tip! I checked it and except for the fact that I did not even consider using insects as pieces ( :slight_smile: ), it seems to be exactly the type of game I had in mind (and I thought I had an original idea…).

I specially liked the way the beetle moves and started thinking of ways to actually do that with blinks in a way that would work without breaking game state.

Maybe I should just call it Blinks Hive and do something that is as close as possible (considering the use of Blinks) to the original design (which most likely mean fully implementing exactly that game but with added Blinks-only features).

What do you think?

Thanks again.

It can be an easy game to implement.

I’m imagining this key features:

  • Asign roles to every blink at the beginning
  • Turn detection (with some colours)
  • Legal move validation (that can be really hard to do)
  • Surround the queen and send a Win/Lose game state to all blinks.

But of course with a simple code, some colours mappings and game states, and auto asign the roles at the beginning of the player turn is just ok and you can play with that!

The basics can be easily coded in just one hour!

If you do it, that game will be permanently in one of my blinks!

Also if you don’t do it, I will do it, as when I first thinked on blinks games, I thinked on porting this game =D

Yep. generally speaking it should not be difficult to implement (I already have a lot of the logic for a generic game like this implemented) but there are definitely tricky problems to solve (determining valid moves is probably the more interesting one and preventing state breaking is another as pieces are removed from the cluster and reconnected during a move).

I guess I will implement Hive as is to use as a base then change it to whatever works best with Blinks.

Fun Fact: The dimensions and weight of Blinks were inspired by the feeling of a hive tile in the hand. The self aligning magnets were because I found it frustrating to keep the pieces nicely aligned.


So then a Hive port to Blinks should be a must!

Deja Vue all over again. I mentioned Hive within the first five minutes of meeting Jon. Then I mentioned Go as an example of emergent strategy and then Jon revealed the etymology of the company name, Move38. Jon is always ten steps ahead of me. :smile:

1 Like

@AEthyr So then you’re on move 28?


Oh, man – I got a dev kit SPECIFICALLY because I wanted a Blinks implementation of Hive!! Has anyone made any progress on this? I’ve got some ideas, but I’m still at the “hello world” stage of learning to program, so I’d love to see a competent coder’s version of it, even if it’s not fully ready to roll (so to speak).

I mostly have some prototype code that implements several pieces of game mechanics (like detecting pieces being connect/disconnected during the move phase to validate moves). But I did not work much on it since I learn what I was proposing was an existing game. :stuck_out_tongue: I will eventually get back to it at some point.

Actually because in Hive you don’t “die” you just need colors for the tiles and maybe some animations and some interaction for the win state, sure is not very difficult to do.

The negative point is half of the tiles are black, half are white, and that can be tricky to do! If you have some idea on how to do it tell us, I want to hear your opinion on that! :grinning:

Well, it can be trivial if you rely on humans to enforce all the rules. I actually prefer to make the Blinks themselves do that as it is a better display of what is possible with them (otherwise they are just static game pieces).

For example, I want to enforce valid moves. Even better, whenever the user removes a piece from the board I want to:

1 - Indicate if the piece removed could be removed (for example, removing a piece when it is not your turn).
2 - Display valid positions for the piece to be moved to.
3 - Detect it was connected to a valid place and, if it was not, indicate that.
4 - automatically enforce turns.

And so on…

All of those are pretty interesting problems top solve when you are programming for Blinks.

1 Like

For distinguishing between players, I think either:
a) Player 0 gets a circling white light, over top of each color. Player 1 gets a circling dark spot (a la Darkball).
b) Player 0 gets 1 circling light, 1 gets two lights, and so on. This is if you want to make the game with the potential of more than 2 players. I can see this working for up to 4 sets of pieces.

I think a set of 9 would be a good starter kit (1 Queen, 2 spiders, 3 grasshoppers, 3 ants); this is very close to the original setup, allows someone with 3 sets of Blinks to play, and eliminates the difficulty of programming the beetle (since it moves on top of the hive, I’ve been racking my brain thinking of a way to track it – I think it will be the most difficult piece. Even the Ladybug at least comes down at the end of its turn).

My thinking about movement was: click to see legal moves, click to cancel, move-then-click to actually move. Your turn ends when you click the moved piece.

I actually have this mechanics working already. You just disconnect the beetle piece and click the piece you want to move it on top of. The piece know where it is and where the beetle was so it know if the beetle can be there or not). If another beetle is moved on top of that one, you still click the bottom piece (and it will remember there are 2 beetles on top of it). To remove a beetle you just double click that piece.

None of this is necessary, you can detect when a piece is disconnected or reconnected. Any piece being disconnected is the one the player wants to move (and the other pieces validate if that piece can be moved or not and notify the user about this in case it is invalid).

1 Like

In fact, the trickiest thing to handle are not the moves, but a group of connected blinks that have entrances that are exactly one blink in size. Something like this:

The reason this is a problem is because you need to know the actual coordinates of the 2 Blinks so you can determine that (in this example), the ant can not move to the middle of that cluster.

Thankfully, a standard Hive game has 22 pieces and I need only 2 bytes to represent their coordinates (I can even use a single byte with bitmasks, but it is not owrth it storage wise), so I only need 22*2 = 44 bytes to store the entire “game map” so what I will do is make all the blinks know the entire board and suddenly what would be a network communication problem becomes a much easier hexagonal grid problem (than can be computed locally on every Blink).

Making sure all Blinks know about the position of all other Blinks is still a network communication problem, but one I already solved for Hexxagon).


I can’t be more happy knowing you are programing for blinks. You’re going to bring a lot of happiness to my blinks :upside_down_face:

Actually I’ve just thinked on one of the “B&W” pieces problem. You can even do the same you did for Hexxagon, light your pieces and fade down the pieces of the other player, that way you don’t need to mark each player piece to know the owner of each piece.


I am so glad to see an actual coder working on this!!! I am not much past “hello world” in any language, so while I can look at & more-or-less grok already written code, I have not put much time into learning.

One of the cool things about Blinks is that the API is pretty simple. You can come up with fun games even if you don’t know much about programming. In the end, creating a fun game is all that matters. :slight_smile:


I started committing some code here in case someone wants to follow the development. There is not much useful there yet.