Index Card object

Hi all,
I just had access to the beta and I like what I'm seeing so far, congrats! It's very fast and responsive. I can see it working very well as battlemap replacement.

Personally, I almost always play games that don't use any map/battlemat, but that instead can benefit greatly by having a shared "table", where the players can see (and manipulate) the same kind of objects they'd use in a face to face game.

For example, say, tokens and/or poker chips. And those are easily handled using tokens, so thumbs up!

What's missing(*) to be actually useable, from my (admittedly, probably very niche) point of view, is a couple of objects to use as "text holders" that can then be moved around, stacked and so on.

Basically, what I suggest (and I *think* should be easy to implement) is an "index card" object. A rectangular object (resizeable, ideally) that can be moved around, with a "title" line at the top (bolded) and a "content" area where the text lives.

This would be quite enough to play Fiasco, for example, or Remember Tomorrow, Danger Patrol and many others.

More featureful variants of the object would obviously be even more useful, but they could be left to future developments.

Thanks for your excellent work!

(*) And if it's already there and I missed it, sorry!

The handouts system partially covers this already but being able to move them around the 'tabletop' would definitely improve the the functionality.

Yep, some games for example use the position of the cards (like Microscope) to show the timeline progression. It'd be cool :)

Personally, I almost always play games that don't use any map/battlemat, but that instead can benefit greatly by having a shared "table", where the players can see (and manipulate) the same kind of objects they'd use in a face to face game.

Same here! This is also the reason I'd like to see some version of on-table dice, for situations where dice aren't just number generators, but also act as resources to be shared and manipulated. Anyway, on to notecards:

What's missing(*) to be actually useable, from my (admittedly, probably very niche) point of view, is a couple of objects to use as "text holders" that can then be moved around, stacked and so on.

I've been asking for the same thing since early in the beta, so if it's a niche request, there's at least two of us now! Anyway, since the big drawing update (which happened just before the open beta, I think), I've been using rectangle drawing + multiple text objects + object grouping as notecards.

Basically, I set up a template card that I can copy from (in your case, base + Title + content) and group the text+drawing (select objects, right click, advanced, group). Then I just copy and paste, use alt+mouse click to select the individual text objects so that I can change them to whatever text they need to be, and I'm basically ready to go.



Here's an example from my Danger Patrol table. I selected one of the cards in that picture so that you can see what objects make it up.

I don't know if that'll satisfy your needs, but I think that it's the best Roll20 offers at the moment.

Your mockup is very cool!

Also, you're right, let me second the "dice as smart tokens" notion: they would be IMMENSELY useful for a number of games (most of what I'm likely to play, I'd say).

They could simply be "special tokens" with a "roll this" button, changing their number/image accordingly.

Being then able to move/manipulate them would allow many games to be played VERY handily, for example:

* Dogs in the Vineyard (many dice get rolled and then kept in front of each player, who moves them forward when they want to play them).

* Marvel Heroic Roleplaying, and most of the Cortex Plus games in general: the pool building is much easier for all players involved if players can see the dice move.

* Danger Patrol (as you say), where dice are put on the cards.

...and so on, you get my point :)

Thanks, glad you liked the mockup. That was made way back at the start of the closed beta; it's been updated slightly since then.

Those are some good examples of games that would benefit from on-table dice; I hadn't considered Dogs in the Vineyard (never played it, unfortunately). There's been some discussion on that topic in particular here. It sounds like you've got some ideas that could add to that discussion.

You can create an index cars by using shift-drag with the draw tool to draw a rectangle, then using the drawing select tool to select it and choosing a narrow outline, appropriate colour, and an opaque fill. This is then an object that can be moved around using the drawing select tool. You can write on it by using the text tool and then grouping the rectangle and text together, which you do by choosing the drawing select tool, holding down shift while you click on each of the text fields you want to link to the card, then the rectangle, then letting up the shift key and holding down the option/ALT key while you click on one of the objects, letting up the key, clicking "advanced" on the pop-up menu, and then clicking on "group". Then you can edit the text on the card by clicking on any of the attached text fields with the "text" tool. To add another text field you first create it, then shift-click it and then the card with the drawing select tool, then option/ALT-clicking it and choosing "advanced->group" as before.

Ah, interesting! As I mentioned in my OP, it may be that the functionality is already there and I'm not seeing it :)

I'll try that!

Ok, I gave it a shot. I can see this working, cool!

It's a bit awkward, but yeah, I can see it working, especially if a game facilitator (no GM in Fiasco) prepares the cards beforehand and people can then simply fill them in (can the other players edit the text, btw?).

Cool, cool. Not very discoverable, but cool :)

A "library" of these arbitrary objects (just like for the tokens) would be even better, but I can see it being a low-priority goal.

Putting poker chips, die faces, card backs and faces, and pre-grouped "index cards" into the library of built-in art objects is probably an easy way to get out of having to write certain functionalities into the code.