Create boardgame-card-stack

[jkomoros]

This will be the class that handles positioning of cards.

Different positioning styles:

• Stack (e.g. for decks, with clean and messy versions)
• Grid (e.g. for memory cards, could have one row or multiple)
• Hand (e.g. for a player's hand. Cards can be arrayed radially, and squash together. Hovering reveals a card and makes it stick out a bit).

Originally captured in #209

[jkomoros]

• [x] Hand has a mark, unmark that game view calls before and after databind takes note of their unique IDs and where they are and then animates
• [x] #card margin should be set in collection, not boardgame-card
• [x] jsdoc documentation
• [x] Implement stack layout
• [x] get rid of multiplying shadows in stack
• [x] implement hand layout
• [x] hand layout shouldn't skip spacer cards
• [ ] On hover, card in hand layout should push out other cards animated-wise
• [ ] the amount of overlap allowed in .hand layout should be to allow container to be 100% (might be as easy as setting container width to 100%; also, this might already be happening)
• [x] If Stack is provided, instantiate our own components for the cards via a template inside of slot (this is actually really hard, because the data-stamping needs to have known that they'll get an item property, and that has to be a template in order to trigger databinding...) actually what we'd do is have it just find the first dom-repeat inside of itself and then plug the items to be the Stack.Components (this, combined with boardgame-card allowing an item that automatically expands, would be very poweful)
• [x] implement radial hand layout (set transform-origin way below the card (at radius?) and then rotate the ones at an amount based on what their index is and how far away from center index)
• [x] fan layout should use cosin or something to set translation amount correctly
• [x] fan layout should build on top of the messy rotation, not overriding it
• [x] Fan layout should also translate x according to something like cosine or something
• [ ] fan layout should figure out how much translation to do based on how high the container is sized to be
• [x] The messy index should be perturbed by something stable but unique, like the id of the element, so that the first element in all messy stacks isn't rotated the exact same way
• [x] implement faux cards in stack layout for large decks (or decks where we only want to render one card), e.g. with a faux-length property
• [x] cards in collections should be vertically centered
• [ ] things like how much overlap to allow in spread should be set based on size of cards
• [ ] hovering over a card in fan or spread layouts should have it transform it animate rising up an em or so
• [x] shadow on hover is clipped by container which looks odd
• [x] faux cards technically arent' styled right; it should be their LOGICAL depth in stack, not their actual depth in their parent, because if there are non-faux cards then their index in their parent is wrong (the solution may be to have one pass that iterates across all cards and sets classes on them about e.g. how much to rotate, what type of skew to have, as opposed to using nth-of-type selectors.)
• [ ] grid layout should have a row-length property to wrap
• [ ] Test that the slotted selectors I'm using for messy works in the polyfill
• [ ] BUG: if the card doesn't flip but doesn change rotation, the FIRST time it happens when going from unrotated to rotated it just jumps. There's something about basicRotation not being set or something. Happens when going from not rotated to rotated, but only the first time (if it oscillated back then it's fine)
• [x] Animate between different layout properties (FLIP?)
• [x] Use in monroe, other games

[jkomoros]

Should these be three different elements or one?

If it's one the different layouts will get confusing, but it will also be possible to animate between them by setting the display type

[jkomoros]

Sometimes a deck will actually have all cards instantiated, and sometimes it will only have fake cards to show that the deck has many items. (like a draw deck in monroe). Need a way to configure that

[jkomoros]

The collection should take a stack and optionally print out all of the elements themselves (but how would you pass the element to use for front of card?)

collection takes the stack, each card takes the expanded component