Øvelse – anvend listeegenskaber

Lad os sige, at du er udvikler i en afslappet spilvirksomhed. Du er blevet bedt om at skrive en startkode, der skal bruges til et kortspil. Din første opgave er at oprette et sæt kort og derefter oprette en funktion, der kan tegne kort fra bunken, én ad gangen.

Opret et sæt kort

Et kortsæt har 52 kort, men for at gøre det nemmere at læse konsoludskriften, så lad os reducere kortene til fem kort. Du kan oprette en talserie ved at indsætte to prikker (..), omgivet af mellemrum, mellem det første og det sidste tal på listen.

1. Opret et nyt projekt i konsollen ved at køre dotnet new:

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

2. Hvis du vil oprette en liste, der indeholder kortene, skal du tilføje følgende kode i filen Program.fs:

   let cards = [ 0 .. 5 ]
   

   Denne kode opretter en liste over tal fra 0 til 5.

Tegn kort fra dækket

Nu, hvor du har oprettet dit sæt, kan du oprette en metode til at tegne kort ud fra det. Det gør du ved at bruge de indbyggede egenskaber Head og Tail.

1. Opret derefter en funktion drawCard():

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

   Når du bruger egenskaben Head, læser du det første element på listen, og ved at returnere Tailsimulerer du, at du tager et kort øverst på listen og returnerer de resterende kort i oversigten.

2. Hvis du vil afprøve implementeringen, skal du føje følgende kode til metoden main():

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

3. Kør projektet ved at kalde dotnet run:

   Nu kan du se, at 0 og 1 udskrives i konsollen.

Tillykke! Du har implementeret et sæt, som du kan tegne kort fra.

Tegn kort til en hånd

Evnen til at trække kort fra bunken er en god start, men kortspil normalt brug for to eller flere spillere til at hente disse kort. Som du ved, kaldes hver spillers samling af tegnekort en hånd. Derefter skal du implementere kode for at få hvert kort, der er tegnet, føjet til en hånd.

1. Tilføj følgende kode i den kode, hvor du erklærede listen cards:

   let hand = []
   

2. Rediger derefter metoden drawCard() for at acceptere en tupel, der består af to lister, hvoraf den ene repræsenterer dækket, og den anden repræsenterer hånden:

   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)
   

   Funktionen fst() bruges til at få adgang til den første egenskab i tupelen (dvs. dit dæk). Funktionen snd bruges til at få adgang til hånden. Du har også ændret returtypen, så den returnerer en tupel, der består af dækket, og din hånd (deck.Tail, hand), men med det tilføjede kort firstCard.

3. Rediger koden i hovedmetoden for at trække kort til hånden:

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

4. Kør projektet ved at kalde dotnet run:

   dotnet run
   

   Du kan se følgende output trykt i konsollen:

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

Tillykke! Du har formået at simulere at have en spiller, hand, for hver gang du tegner et kort.