This is of course due to godotengine/godot#16854, as their rect_global_position doesn't seem to take into account rotation. The solution would be to figure out how to apply the parent's rotation to their rect_global_position to receive the correct value to check against the mouse cursor. No clue how to calculate this however.

Only the board should zoom in however, not the hand and piles

Tasks to add to the ScriptingEngine:

• Rotate Card
• Flip Card
• Move Card to CardContainer
• Move Card to Board
• Spawn Card
• Move Card from CardContainer to Container
• Move Card from CardContainer to Board
• Shuffle CardContainer
• Mod Card Tokens
• Attach card to other card
• Tutor a card by name
• Tutor a card by properties
• Request int input for player
• Modify card property/label

This way will allow them to be dragged together.

Some sort of glowing particles etc.

Some glow, some particles, stuff like that

On very rare occasions, the player's mouse will move at a speed an angle where it will enter a card on the board exactly on top of one of its ManipulationButtons. If the mouse exits at the same speed without passing over a non-button part of the card, the on_button_mouse_exited() will finish its yield after on_Card_mouse_exited() which will thus never clear the card's focus until a card is focused again.

Very rare situation, with very easy solution, which is caused by the workarounds I implemented against godotengine/godot#16854.

For a permanent fix, I do not see an easy solution. 2 options

1. Moving the buttons further in the card rect (which would look ugly) so that the mouse always has a chance to move over the $Control rect before exiting.
2. Checking if the mouse cursor is still inside the card after exiting the button. This would take quite a calculations to achieve, especially with the viewport shenanigans in relation to mouse position.

Given the low impact, I'm leaving as is. If it becomes too bothersome, I'll revisit.

Saw that prismata does this. Should make keeping card text up to date easier.

The idea is that some method will read its card's scripting definition, and will translate it into human-readable card-text

Some abilities require the player specifying targets. When those activate, it would be good to have some arrow being dragged by the mouse to select the target. Alternatively make the mouse a targeting reticle on first click, to signify you're selecting targets.

Should also activate while the card is being dragged

Due to #52 , often I drop the card in the wrong place. It would be beneficial that when a card is being dragged, it highlights the container it would drop onto when released. This would also prevent issues when trying to attach a card.

An area where cards will go when discarded by dragging them there

Add a discard fuction which can trigger on a 'del' keypress while a card is focused

Some basic or typical triggers for effects in card games.

• card_rotated
• card_flipped
• card_viewed
• card_moved_to_board
• card_moved_to_hand
• card_moved_to_pile
• card_token_modified
• card_attached
• card_unattached
• card_targeted

Currently all the scripts in the ScriptingEngine are only final effects. We do not have the concept of costs. I need to implement a deinition so that the ScriptingEngine stops executing scripts in the pipeline, if one of more scripts marked as cost cannot be implemented.

This would require us implementing a way to "dry-run" effects to see if they would be able to execute.

As a demo, use this function to discard a random card

When an optional task is encountered, the game should inquire to the player with a pop-up if they want to activate it

Once a card object has been moved to the play area, the player should be able to turn it 90 degrees sideways though some function.

By default that function should be assigned to double-clicking the card.

Provide code in the library to change the orientation further (e.g. 180 degrees) or add more orientation options with other shortcuts/calls

Something similar to tokens I think. It's not possible to click on attachment buttons to do the cards above them

Currently the scripts trigger on player activation (double-click to be exact), but a lot of card effects are also reactive. E.g. "When this card is drawn, discard a card", or "When a card is destroyed, draw a card".

I have to figure out a way to trigger card scripts based on signals defined in their code. This needs to work in parallel with the state-based limit, as a script might require a signal and a specific state.

One way to do this, is to make various common actions trigger signals. I can think of a few generic ones

• Card Drawn(source pile)
• Card Discarded(source container)
• Card Rotated
• Card Flipped

etc.

Those signals would be caught by a central point (the board? cfc? some new signal coordinator node? not sure yet) and then will call some sort of parser, to see if there's any other cards who are listening for those signals.

I think I should go through a central coordinator node as I don't think it makes sense to connect each card to each other card just in case.

In a lot of games, tokens themselves might add extra effects or execute things depending on a trigger

I need to have a way where a token can include scripts that will initiate the ScriptingEngine

I like this game very much. Is this a game framework similar to the slay the spire?

The existing focus for hand won't work as you cannot push other card around. I'm thinking it has to be another viewport which is displayed as a pop-up with the card in it.

This wouldn't affect the cards mechanically like #16, but rather it would simply serve as some sort of visual representation for the player.

This link would be stored in the card object however and available to be exploited by developers if needed.

https://docs.godotengine.org/en/stable/getting_started/step_by_step/scripting_continued.html#groups

Since it's there, I think it makes sense to use it.

Also, when dragged outside of the hand area, they should be shrunk as they follow the cursor.

Similar to how the slay the spire hand looks. The dev should be able to easily switch showing the hand straight, or oval depending on their game needs

It should be possible by displacing each new card in the pile by a pixel or two and having the container itself be transparent but on top of the card stack, like a glass pane

Now that piles don't have their own graphic, the buttons are not as obvious when they're hovering. Might be better to have them slide like tokens?

Currently I'm using a warp_mouse() workaround to avoid the card teleporting when first grabbing onto it to move around, I warp the mouse to the card location (which effectively moves it to the card's local Vector2(0,0)).

This has two issues:

• It sometimes confuses the player who finds their mouse cursor warped.
• You're still getting a cross-cursor on the top-left of the card, which I often confuse as a targeting reticle. However the truth is that cards find the container to drop into based on their Area2D colisions. So if you try to target the deck using the top right part of the card (where the cross mouse cursor will be while dragging), the card ends up inside the hand, because its Area2D collides with both deck and hand. and hand has a lower node index than the deck and so the automation prioritizes it for a move_to() target.

I think the best solution would be if the mouse cursor was hidden, then it's intuitively more natural to understand where you want to drop the card. I did try with MOUSE_MODE_HIDDEN, but I could not combine it with MOUSE_MODE_CONFINED which is way more imporant (as unclicking the mouse outside the game can break dragging and automation which relies in mouse inputs).

Maybe a solution like suggested here: https://godotengine.org/qa/60675/make-cursor-hidden-in-mouse_mode_confined could work, to temporary replace the mouse cursor with a transparent sprite?

If the mouse cannot be made invisible, another solution would be to keep the dragged card always on the same relative spot on the mouse cursor as in the moment it was picked up. This would mean offsetting the card global placement when dragged to match the local placement of the cursor inside the card. You might still get some jitter/teleportation when picking up a card from a position next to the board edge, (especiually in the hand), but it shouldn't be too bad.

When you grab a card from the hand, if you move to a screen edge the card gets stuck to the mouse and you're unable to release the card into the board. When this happens, sometimes you can pick up a second card and the second card will release normally on the board.

Because many games allow cards with the same name in different sets, using the set should be a way to differentiate.

Technically I could go full geek and just make each dictionary key a UUID or something, but I've used OCTGN which does this method, and it's a PITA to work with.

To improve on #53 I should probably figure out a workaround to make Pile have higher priority for card drops, than Hand, when a card's Area2D collides with both, as it's the natural way people expect (to target the hand, they usually move the card to the middle position).

I cannot move the Hand node higher in the node hierarchy, as that would cause the card-draw animation to show the card be picked from the bottom of the pile. This is because I first change parents, then execute the animations, so the relative z_index of the two CardContainer nodes matters.

I am thinking just have the CardDrop logic prioritize cfc.piles over cfc.hands

Instead of a draw card button, the user should need to simply click on the deck button.

Optimally, it should have some sort of algorithmic graphic where it grows "thicker" the more card there are in it

Currently the existing board has been defined using the Godot visual editor. These of course means that positions and dimentions are hardcoded and don't work well without stretching when changing resolution.

I would like a way for each game to specify the board setup using gdscript.

I'm envisioning something like a game.gd. There the player would specify for each CardContainer its anchor and its size relative to the viewport. They would also specify card_size there as well

When pressing the hover buttons if the mouse click is held for too long (more than just a quick tap) instead of the hover button performing its action the card is dragged instead. This makes it very difficult to actually use the hover buttons.

An idea I got from reddit. A button which appears only when the mouse hovers over that area of a card would be convenient way to do basic things like discard the card. It would also serve as a template to add move varied interactions with cards based on buttons

This seems to happen because I don't instantly clear out the old object, to give time to tween the viewport to alpha, if there's nothing else in focus. Because of this, when I switch two cards fast, there's a millisecond where both duplicate card objects exist under the camera, and you see the old one as the camera focuses on the new one.