Exercício – aplicar propriedades da lista

Concluído(a)

Digamos que você é desenvolvedor de uma empresa de jogos. Foi solicitado que você crie um código inicial para ser usado em um jogo de cartas. Sua primeira tarefa é criar um baralho e uma função que tire uma carta do baralho de cada vez.

Criar um baralho

Um baralho tem 52 cartas, mas, para facilitar a leitura da impressão do console, vamos reduzir o baralho para cinco cartas. Você pode criar uma série numérica inserindo dois pontos (..), cercados por espaços, entre o primeiro e o último número da lista.

1. No console, crie um novo projeto executando dotnet new:

   dotnet new console --language F# -o Cards
   cd Cards
   

2. Para criar uma lista que contém os cartões, no arquivo Program.fs , adicione o seguinte código:

   let cards = [ 0 .. 5 ]
   

   Esse código cria uma lista de números de 0 a 5.

Tirar cartas do baralho

Agora que você criou o baralho, pode desenvolver um método para tirar cartas dele. Para isso, você pode usar as propriedades internas Head e Tail.

1. Em seguida, crie uma função drawCard():

   let drawCard (list:int list) = 
       printfn "%i" list.Head
       list.Tail 
   

   Usando a propriedade Head, você lê o primeiro item da lista e, retornando Tail, você simula o ato de tirar uma carta do topo da lista e retornar as cartas restantes ao baralho.

2. Para experimentar sua implementação, adicione o seguinte código ao método main():

   let result = cards |> drawCard |> drawCard // 0 1
   

3. Execute o projeto chamando dotnet run:

   Agora, você deve ver 0 e 1 impressos no console.

Parabéns! Você implementou um baralho do qual pode retirar cartas.

Tirar as cartões para uma mão

Tirar cartas do baralho é um ótimo começo, mas jogos de cartas normalmente precisam de dois ou mais jogadores para retirar essas cartas. Como você sabe, a coleção de cartas desenhadas de cada jogador é chamada de mão. Em seguida, você precisa implementar o código para que cada carta retirada seja adicionada a uma mão.

1. No código em que você declarou a lista cards, adicione o seguinte código:

   let hand = []
   

2. Depois, modifique o método drawCard() para aceitar uma tupla, que consiste em duas listas, uma representando o baralho e a outra a mão:

   let drawCard (tuple: int list * int list) = 
       let deck = fst tuple
       let draw = snd tuple
       let firstCard = deck.Head
       printfn "%i" firstCard
   
       let hand = 
           draw
           |> List.append [firstCard]
   
       (deck.Tail, hand)
   

   A função fst() é usada para acessar a primeira propriedade da tupla (isto é, o baralho). A função snd é usada para acessar a mão. Você também modificou o tipo de retorno, de modo que ele retorna uma tupla, que consiste no baralho e na sua mão (deck.Tail, hand), mas com a carta firstCard adicionada.

3. Modifique o código no método principal para tirar cartas para a mão:

   let d, h = (cards, hand) |> drawCard |> drawCard
   
   printfn "Deck: %A Hand: %A" d h // Deck: [2; 3; 4; 5] Hand: [1; 0]
   

4. Execute o projeto chamando dotnet run:

   dotnet run
   

   Você deverá ver o seguinte resultado no console:

   Deck: [2; 3; 4; 5] Hand: [1; 0]
   

Parabéns! Você conseguiu simular a presença de um jogador, hand, a cada vez que você retira uma carta.