originalutkin / board_game Goto Github PK

specs:

• cardA - attack: 1 health: 5

• cardB - attack: 2 health: 4

• cardC - attack: 3 health: 3

• cardD - attack: 4 health: 2

• choose different picture for card face

• use the same picture on card back

• when click on card, move it to the center of the screen from player's hand

• show "choose your cards" message

• add some background
• add 2 textures of card
• add static card to the scene

Each player can put their cards just to specific part of the battlefield (just half part of the whole battlefield belongs to the each player)

Define basic card class that will be used in the game

• define list of cards programmatically (in array)
• cards in collection will be rendered on "collection panel"

make https://github.com/dotnet/format tool work in pre-commit

• define list of player's cards programmatically (in array)
• cards in player's selection will be rendered on "selection panel"

• make these cards playable, the same way as cards of the first player
• for now, make the second player's cards visible - orient their faces to the camera
• keep data structure in GameLogic package, similarly to GamePreparation.cs

Depends on number of cards change player hand position. Now it's possible that cards won't be visible because of offset

Highlight the position where card could be put on the battlefield

My suggestion is to use https://wiki.js.org/ . It can be run with docker-compose and it can be configured to use local repository as a storage

• show card selection screen for 1st player
• when 1st player chooses all cards and clicks "next", show card selection screen for 2nd player
• when 1st player chooses all cards and clicks "next", load main game scene

For now, card's behavior is the same either on battlefield or hand: it could be moved wherever it is possible. In #57 states were implemented for cards however Received state contains only logs for now. This behaviour should be adjusted and implementation is needed there.

Criteria: All method from IState pattern are implemented (or at least defined how it should be implemented) and card isn't movable once it is placed on table.

Cards in the hand should be moved after card is drown from the pile.

Make card as playable object: card could attack the other card. Once card attacked the other one, health attribute of cards should be recalculated

In case player has finished his turn cards (on table and in hand) shouldn't react on click (or at least there is no possibility to play/move it during other player's turn )

In #51 cards could be moved on scene using the cursor. However there is no logic that is responsible for accept card by game board and holding it. Now we need to adjust this logic and make cards playable: once card is dropped on table, we need to recognise how to

• shift other cards on table if some are there
• once card is placed on table, player isn't able to move it
• decide which spot will be obtained once card is dropped on table

After we have agreed upon on new project architecture in #51 and #52 and implemented it, scene is responsible for game preparation was broken by those kind of changes.

• Since Mouse events could (or even should) be different in those scenes, we need to introduce new card script in game preparation in order to decouple it from card that is used in game itself. The code in those classes could repeat for now.

• Make game preparation scene usable again

• when player selection is max (let's say 5), "next" button is enabled. Otherwise it is disabled
• when "next" button is clicked, next scene should be loaded

Each player could do just a one action: put card on the table, beat the other card or just end current turn

Draw player hand on game with card placeholders

get the idea of:

• how scene is structured
• how assets are structured
• how objects and events are linked together

Original idea was to separate game logic code from Unity-specific code. However at this point it brings more difficulties rather than benefits.

Chosen card cannot attack attack other cards on the same part of the battlefield (e.g. allies cards couldn't be attacked)

In case card is hidden by other card in hand, change hidden card position in way to make it visible

• when player clicks on the card in player's selection, card moves to collection

• when player clicks on the card in collection, card moves to player selection
• limit player selection size (let's say, 5 cards in total)