Some Quick And Dirty Boards for a Tabletop Game Idea

"maybe" -- but ultimately the issue is going to be drawing an "area" on the (in-game) floor where something happened.

USUALLY this is done either by:

(a) counting squares from the "center" of the effect (b) paper/plastic templates held over the "center" of the effect

Which would require that the slave MCU to have a programmable address (and then there's the problem of address conflicts), and on top of that, there'd need to be a way to convey which slave was at which position of the "game board", so that the effects would be done correctly.

Yep -- Think of the playing surface as a *VERY* low-resolution display screen: there's only a resolution of 1 pixel / inch (and for testing, I'm working with a "display" that's all of 8x8 pixels.). The standard playing surface is effectively a large sheet of graph paper, with a

Here's an example of the 3d-printed tileset. The room here is comprised of nine (9) individual 3d-printed tiles (All are 2x2 playing spaces, even though the walls eat half the space, to keep the real-world dimensions "correct") :

Yep, the framerate (and brightness) should be fine; at least for this initial testing size. I mean, let's face it, this is already 64 LED packages with "just" an 8x8 grid; "testing" with 16x16 (256 LEDs) or

Sure, I could do that (maybe). But I *really* want to avoid making "special cases" for myself at this point (or, frankly, at any point). As it stands, if there were a feature that breaks the "standard tile" for some reason (e.g. a chasm, or collapsed floor, or ... whatever), it's not going to have any effect on any other LED in the given row/column.

Maybe someday I'll figure it out (or scrap this approach as subpar, and revise the whole thing ...)

Close enough :). The issue is, now I'm tossing an MCU onto each tile, to try making them "smarter", and adding complexity to the "master" board to accommodate selecting which row/column is active.

It's certainly an option; but on the other hand, "dumb LEDs" where a MCU can just act as a CPU and push out "turn on 4,2" with a BJT and a shift register.

Ah, so "sorta" like the idea behind the WS2812 driver chips, but using a selector switch (for example) to enable the data to "Row N"

Yeah, *MOST* of them are quite likely "floor style, variant X" (e.g. a "dungeon" set may have 4 "open floor" variants -- "empty" [just four flagstones], "some rubble" in a space, or perhaps something like "trap door" or "collapsed floor"). Then there's also the "border" pieces with walls (and doors, etc).

"Sort of" but at the present time, I'm not planning anything quite so complex as to know what the floor features are.

Yep, or a little hole in the space where a player piece would be standing. PROBABLY a hole, since painting the tiles wouldn't become problematic (I mean, let's face it, 3D-Printers are entirely uniform colors, and while that's perfectly fine for a testing phase ... )

No. Taking that little room shown in the picture there, maybe the players set off some kind of trap from the door in the "north" wall that sprayed fire at them when they tried opening it.

So this is the grid, with the "W" representing the spaces with walls, "D" being the doors, and the "0" being the tiles a character might be on.

W W D D W W W 0 0 0 0 W D 0 0 0 0 D D 0 0 0 0 D W 0 0 0 0 W W 0 0 0 0 W W W W W W W

Here, we've switched "on" the fire effect ('1's)

W W D D W W W 0 1 1 0 W D 0 1 1 0 D D 1 1 1 1 D W 0 0 0 0 W W 0 0 0 0 W W W W W W W

So, any character that happened to be standing in the "1" spaces would get hurt.

For now, they're gonna be really simple (just solid red). Eventually, probably replace the shift-registers with proper LED drivers, that can help do brightness control, etc (so I can mix the RGB channels and get a more "fire" looking color orange, or "electric blue", and so on)

good enough, but I don't have a CRT to hand. I've done it small-scale with protoboard and 64 (white) LEDs, and it came out well enough. Plan for the week is to drop by the hardware store and pick up one of those

Yeah, but the thing you're not accounting for is that a "Ruined Floor" piece isn't the "standard(tm)" nominal 2" square -- rather, it'll have a missing corner (or more) so that there's a visual hole in the floor. So I'd need a special PCB for that piece (or any similar piece that "breaks through" the plane of the floor.

With the current multiplexed approach, those "odd" tiles don't cause any trouble (other than an extra ring of non-effect that's suboptimal, but I can live with that, since it's less engineering

FOR NOW, it's 4x4 tiles (64 LEDs), because that fits really well into two bytes, and I can keep it all in my head. EVENTUALLY I want to accommodate 8x8 tiles (256 LEDs) ...

Yep

Yep, figurines or even just tokens stolen from other games (e.g. "Trouble" or "Monopoly", etc). Anything that the players can remember as "them" or "that Goblin I'm fighting" ...

The "Effects" are pretty static in general terms (e.g. that flame-jet trap is ALWAYS that shape when on the grid. If it's 45 degrees to the grid, then it'd just look like this: 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 1 1 1 0 0 0 0 0 0

Other effects might approximate a circle:

Or just a line.

After that, it's just defining the color (e.g. an explosion would be some kind of orange color; or a broken vial of acid might be green, etc.) Ultimately; it really is just "shape and color".

Although your (possibly snipped) idea about "other effects" is certainly interesting (torches on the walls sounds pretty neat, tbh).

Nuh uh. CRT is a scanning electron gun in a vacuum tube (and wicked heavy).

But yes, I should have at least one or two old monitors that'll still accept VGA inputs, if that's what you meant?

No, it's printed that way. Normally a "full tile" is 2x2 playable spaces, i.e.

S S S S

But a ruin / chasm / etc tile may only be

S S OR S S - - - S

(with the "-" indicating the missing space). The "broken" edge then (i.e. touching the "-") will be printed up to look like the stone floor cracked, or if it's an abandoned wooden structure, you'll have a bit of floor joist sticking out, etc.

Ultimately, that "edge" part of the feature doesn't accommodate the shape of my LED board; and even if I did make a custom board for those features, the current design puts the connector dead-center on the LED carrier. Moving those connection points around is potentially possible, but I'd rather get the general idea into a "working" state before changing too many other things.

Right now, a single board is basically $2 assembled (4x LEDs packages,

Even adding "just" an ATTiny 202 is upping each slave board's price by

Correct :) The "enhanced visuals" are just simple things to show an area-of-effect thing happening, instead of paper or plastic templates over top of the game board (or counting squares)

Maybe for a version two :)

Less that I don't want it there, and more that (as currently designed), it doesn't physically fit those "damaged" tiles. They're made to snap together, so they have approximately a 0.100" thick "base" that the PCB slips up into. So I'd either

(a) need a differently shaped PCB to accommodate the odd shapes (and also move where the connections are on them) OR (b) cut away the edges of those tiles, to let the "Standard" PCB stick out as you're suggesting.

Simplest solution -> those tiles don't get a PCB :)

Tiny202 is (as far as I know) the simplest / cheapest option that has necessary hardware (UART).

Yeah, but the immediate concern is "does it even work in the absolute simplest method I can devise" (which is 8x8 multiplexing). If you can't even see the indicators well through (holes in) the tiles, well, it's a bit dead in the water

Probably could. Or a v1.5 that has something silly like an ATTiny4/5/9/10 handling the "torch" effect on the wall. Realistically, adding a "VCC" and "GND" wouldn't be too difficult. In fact, I'm seeing better approaches for handling the grids as it is, so ...

It's the "standard" of the tileset STLs I bought ;) (but yes, this isn't necessarily "universal")

I am. But the tile still has an "edge" that's built up. You can't get around that.

Drillbit :)

Nah, hole and worst case, a bit of acrylic as a lightguide for the SMT part. Things don't need to be extremely bright, just enough to "see" the indication.

So, way back in the 70s it was just done on graph paper; then (IIRC) in the 80s, the game company brought out the idea of the (semi-collectable) miniatures. Since then, the standard "game board" has been based on that 1" square graph (and well, basically _EVERY_ tabletop game of this nature has taken the same approach ... unless it went off into lala land and uses hexagons)

As with any "cool idea", there are oh probably about half a dozen different companies that'll sell you you the 3d printer files to make their own take on what the printable tilesets should look like (and how they should connect, etc.). But they still have to follow the idea that the board is divided up into 1" squares.

I'm printing them, but I don't know enough about the STL or generated gcode to actually stick the holes in there (and I'm certainly not a

Correct, more or less. There are some things where they're oversized, to accommodate player interaction, but those are somewhat the exception.

Perhaps, I'll have to see. Don't forget that, "as printed", the objects are effectively "unpainted models". So, it's not like they're not getting a bit of cleanup / paint / etc. manual intervention anyway. One more step of "drill a hole" isn't exactly onerous.

You seem to not grok the concept that this whole endeavour is a "prototype". Or do you ship off for 10,000 injection-molded parts before you've held a proof in your hands?

Eventually I do want to be able to do that, but it was painful enough getting the layouts crammed into something that offers 180 degree symmetry.

Good news, with multiplexing, the tiles literally don't care what orientation they're in.

Yep. Bad choice of words -- "Proof of Concept" is probably a lot more accurate here.

I know the multiplexing code will (generally) work thanks to a bit of protoboard, LEDs and resistors, but for all I know, I've oversized the snap-in (LED-Carrier) PCB's by 0.010" (~0.25mm), or likewise gotten the spacing wrong on these "testing carriers" (I spaced them at ~2.050" /

That's kinda the downside of 3-d printing, the three samples I took the measurements off of were done a couple of months ago, and in the intervening time the printer's been re-adjusted / calibrated because I noticed it was starting to drift (circles were ... well, oval) . But was it drifting when those samples were printed ...? (I don't think so, but Murphy will see to it that the new "dimensionally accurate" game tiles are now perfectly accurate, meaning I run into problems).

And then there's the problem that maybe I get it perfect for *my* printer, but someone else who likes the idea's printer is off (unless I become the production-house here, and ... ouch ;)).

This is where I'd imagine "mess with the model" would step in; since yes, having the printer do the work is loads easier. But first I want to make sure the idea is generally sound (as in "oh, yes, with a 2.5mm hole in the middle of the space, the holes don't take away from the look of the spaces, AND there's enough indicator-light to make the effect visible").

May well be the case that the hole needs to be too big, and the whole thing is a nonstarter; which is what I NEED to figure out before I commit to anything more complex (expensive).

Sure, and when I've finished my proofs, THEN I can go order a ton of things / mess with the gcode/stl files (possibly ... there might be other challenges there).

Suffice to say, I've only gotten essentially "minimum order qty" worth of the PCBs to play with / verify reality (and manufacturing tolerances) match my expectations, and have enough tiles to prove moving to "production" is viable (at least PCB-side).

Granted, I did order way more LEDs / resistors than are necessary for the proof; but when AREN'T you going to find a use for those :)

Somewhat, but remember that ultimately the (to be designed) base is only providing a grid of 4x4 sockets (with only 180 degree symmetry at this immediate moment). In turn, each socket controls four spaces (i.e. SOCKET {0,0} contains SPACES {{0,0},{0,1},{1,0},{1,1}}; likewise socket {3,3} contains SPACES {{6,6},{6,7},{7,6},{7,7}).

With the assumptions that

(1) The LED isn't dead / soldered the wrong way about AND (2) I didn't mess up the rotational symmetry on the connector AND (3) any requisite jumpers between the various modules aren't crossed

It is physically impossible to have the effect show up where it's not expected.

The only "real" problem becomes if an effect crosses a boundary (e.g. a wall) ... but you have that anyway with paper templates, so it's not a problem I'm really going to worry about :)

Although, having slept on it (and the littles THANKFULLY taking a nap today, hahahah), coming back with a fresh pot of coffee (no donuts though :( ) I can POTENTIALLY do the "tiles with a micro onboard" in a dead simple way with some resistors and (multichannel) multiplexers / shift registers / etc. to minimize pins burned for addressing.

(a) Mux[0] (or BYTE & 0x1F) is the tile's address (0 = upper left corner of the plate, 15 = lower right corner) (b) Mux[1] (or BYTE & 0xC0) is the tile's rotation (0, 90, 180, or 270 degrees). Basically an offset for "where" in the ringbuffer of LED data it's starting.

Really depends on how many control pins either approach needs, but this pretty much completely solves the problem I had with using those "Smart" LEDs in the first place, since getting the 1-wire control signal to be location- and rotation-agnostic was breaking my brain.

Four channels would be easy enough, I think:

ch1 = tiles 0-31 ({0,0} to {3,7} ch2 = tiles 32-63 ({0,8} to {3,15}) ch3 = tiles 64-91 ({4,0} to {7,7}) ch4 = tiles 92-127 ({4,8} to {7,15})

Each channel is further subdivided into "A" and "B" grids ("A" being equivalent of {0,0} to {3,3} in that channel). Since we're using four discrete serial busses, each CHANNEL will only ever think it is a solitary 4x4 (or 4x8) grouping of tiles.

"A" and "B" just need to be differentiated by a DIP switch that either leaves the 5th bit alone (addresses 16-31), or drags it to ground (addresses 0-15). Addresses "0" or "16" mark the upper-left tile; "15" or "31" the lower-right.

Although the full size would absolutely dominate a normal dining room table (remember, each coordinate there represents a 2" by 2" tile piece, so as laid out up there, you're talking a 32x32" playing surface ... bit big for a standard 36" wide table ;) -- but one could use channels 1,3 (or just the first halves of 2,4) to have something that fits).

Board-to-board connections between the tile and the base plate are still a thorn, since offsetting this by 90 degrees means the connector(s) cannot be centered ... but maybe a shrouded 2xN connector for the main set of connections (address, rotation, RS485), and have three other 2x2 pin headers to offer stability. I dunno...

(yay! more rabbit holes before I know if it's even plausible!)

Yep. Proving the general idea works is my main concern at this juncture, downsides and all. As I mentioned, using the other LED options (e.g. "smart" LEDs, or tens of MCUs, etc) wasn't initially making sense for a "tile-able" design. But as I mentioned further down yesterday, it all clicked :)

There's that too -- but they're "just" driven by rubber timing belts (so they do wear out, just like the belts in our cars) ... or the belt slipped a tooth or whatever else causes the things to lose a bit of dimensional accuracy over the course of 5 years ;)

Yep, but then we've gotten into "special" PCBs -- which may well be unavoidable, but for now it's acceptable loss. More LEDs would also probably help, but there's only so small that we can go there.

Yes, which is why I ran with this multiplex-able design -- it still allows for static driving of the LED --> just hook up 5 volts to the anode and pick a cathode to illuminate.

Yeah, that's the problem, there aren't any good edge-contact options that wouldn't need a few dozen iterations of "does this stick out far enough to allow connectivity; but not TOO far that the tile spacing is all wonky?"

And then you REALLY run into problems of "where is 0,0" and "what's my rotation" and "where's the end of a row".

Yep. There are only like a dozen different shapes (and half of them are the difference between a "cone" being laid out in line with the grid, or

Yep, that's essentially the plan -- i.e. a tile's address is defined by where it's plugged in. Not 100% sure which variant approach (as far as pullups / downs / etc.) will work out "best" in terms of me not pulling my hair out :)

Eh? By the time I got to this idea here; I was already seeing the way out of using multiplexing --- IF AND ONLY IF

(a) multiplexing "16 tiles" (8x8 spaces) looks okay, or if not (b) driving the LED hard on looks okay

If neither of those work out, then the idea's entirely a nonstarter from the getgo.

I mean the baseplate plan operates in that manner today -- the XY axis is inherent to the base, and has nothing to do with the tiles themselves. So popping out any one tile doesn't affect the others.

Yep.

That'd be fun too, and would potentially help visibility-wise.

That's the easy aproach.

But adds the issue of knocking them over :)

ULTIMATELY, the main concern is the outline of the effect (everything "inside" that outline gets hit with it) -- and the nice thing with the LED things here is that you can just move it +/- 1 square to check without lifting a figure.

Happens all the time -- Remember, the "standard" approach is a cardboard (or vinyl) mat with erasable markers creating the rooms, etc. Or even just "Theatre of the Mind".

These plastic tile-sets would more be "set-piece" things -- you plop it down on the table for a "climactic scene" (e.g. The battle between the Nazgûl and the hobbits / Aragorn on Weathertop); and when the scene is over, it goes away.

What does this help prove? Multiplexing everything from a single controller is only ever going to be for this proof-of-concept (64 LEDs).

I'm quite confident the concept will pan out, and warrant moving to a more complex design. There are already enough avenues for mistakes that minimizing the potential problems in the circuitry made sense for a "first real world test".

Pieces have various sizes (22mm diameter base is the standard "Medium Creature" though). But they're still easy enough to tip over.

No, not all at once anyway. The board gets re-drawn pretty constantly throughout a 2 or 3 hour game session (or not at all, because "... beware one of us always tells the truth and the other always lies..." starts the players on a 3 hour discussion of "so how do we figure out the liar?" )

Except I don't care what it "might" look like at 32x32 spaces, since the project is never going to illuminate 32x32 spaces from a single MCU. That's why I'm not understanding why you're saying to test as if I was...

Yeah, but multiplexing / charlieplexing four LEDs (well, 12 because RGB, but details) is going to be as bright as (if not brighter than) the 4x4 tile proof-of-concept that I'm going to build as soon as my stuff arrives from the PCB house.

Can, if the pieces are close enough together (or usually what happens is someone tries to catch it, and hits other things)

It's not too many, maybe a dozen or two at the absolute most (least that I've seen -- it's nowhere near as insane as those military style ones that are setup on pingpong tables)

Nothing. :)

(although you going off on your own merry way is a really good way to get in trouble)

If you're familiar with the Lord of the Rings movies, think the scenes in Fellowship where Gimli keeps going on about going through Moria ;)

Sure, but I can easily do that on this grid of 64 tiles, without pretending to be looking at an 8x8 corner of a 32x32 grid.

Yes, there is one "player" who acts as the narrator / rules adjudicator, but otherwise all other players are working as a (mostly) cohesive unit to complete the "story".

And I've done LEDs on a protoboard before (and changed how bright they get, etc). Only real downside there is that they're no-name ebay options (well, on top of being thru-hole, and thus too big for the application anyway).

I did, of course, test the specific Cree LEDs I settled on with a bit of home-etched PCB to run different LEDs underneath a tile (albeit these breakouts were only 1" squares to fit under a single space)

This original lot of tiles (etc.) is proving that

(a) I got my PCB dimensions right to snap into the plastic tile AND (b) I got the features located on the PCB properly to accommodate a central ~2mm hole AND (c) The chosen LEDs are sufficiently bright on a 4x4 grid (or mocked-up 8x8 or 12x12 grid) when shining through that 2mm hole

Or well, it will when they arrive hopefully today :)

Yep. :)

Chunk of steel (or aluminum) will work perfectly well there. Bit of thermal paste to stick 'em to the test plate and you're good to go.

Update there -> 0.010" too big in all dimensions, so it's a little too tight of an interference fit (nothing a bit of sandpaper won't fix on this test batch...

Heh, the 3d printer disagrees :)