2 - Tjugoett
Den oslagbara examinationsuppgiften.
Last updated
Den oslagbara examinationsuppgiften.
Last updated
Examinationsuppgift 2 https://github.com/1dv021/examination-2.git
VIKTIGT! Innan du börjar arbeta med examinationsuppgiften är det viktigt att du lägger till examinationsuppgiftens repo till ditt privata repo för examinationsuppgiften.
OBS! OBS! OBS!
Detta är en obligatorisk och examinerande uppgift som du ska lösa helt på egen hand.
Du måste göra regelbundna "commits" och "pushes" av koden till ditt repo för uppgiften för att kursledningen ska kunna följa ditt arbetet med uppgiften.
Du ska kunna förklara samtliga konstruktioner och satser som din lösning av uppgiften innehåller.
I denna examinationsuppgift ska du simulera kortspelet Tjugoett enligt givna regler.
Du kommer att ha stor frihet välja hur du vill lösa uppgiften; vilka konstruktioner att använda. Hur representeras lämpligen en kortlek om 52 kort? Behöver data kapslas in så att "getters" och "setter" behövs? Hur många egendefinierade typer behöver skapas? Är arv lämpligt att använda i något sammanhang? Vilka funktioner och/eller prototypmetoder behövs? Ska metoderna tillhöra prototypobjektet eller inte? Överskuggning?
En vanlig kortlek om 52 kort används. Esset är värt 1 eller 14 poäng (vilket nu som är mest fördelaktigt för den aktuella handen), en kung är värd 13, en dam 12, en knekt 11 och övriga kort sin valör.
I Tjugoett gäller det att komma till, eller så nära som möjligt, summan 21 på två eller flera kort.
Given ger alla spelare ett kort var från draghögen. Given tar inte själv något kort. Spelarna spelar nu mot given en i taget i turordning. När det är en spelares tur begär spelaren ett kort av given. Efter spelarens andra kort kan något av följande inträffa:
Spelaren har fått 21 och vinner direkt.
Spelaren har fem kort på handen, en summa mindre än 21 och vinner direkt.
Spelaren har spruckit, d.v.s. fått en summa större än 21, och förlorar direkt.
Spelaren begär ytterligare kort tills summan är 21, har fem kort på handen,
summan större än 21, eller förklara sig nöjd.
Om en spelare inte vunnit eller förlorat direkt utan istället förklarat sig nöjd är det givens tur att försöka straffa spelaren. Given drar kort från draghögen, ett efter ett, och något av följande kan inträffa:
Given får 21 och vinner.
Given spricker och spelaren vinner.
Given förklarar sig nöjd. Spelaren och given jämför sina händers summor och den som har högst vinner. Om summorna är lika vinner given.
Given fortsätter sedan att spela mot näste spelare på samma sätt. Tar korten i draghögen slut, det understa kortet delas inte ut, tar given det återstående kortet i draghögen samt alla dittills avverka kort, blandar om dem och använder dem som en ny draghög.
Du ska skriva en Javascriptapplikation som simulerar kortspelet Tjugoett enligt givna regler. Inget hasardmoment, d.v.s. ingen satsning av pengar, behöver förekomma. Det ska kunna vara en eller flera spelare (antalet spelare ska bestämmas med hjälp av en konstants värde) utöver given. Ingen interaktion med användare ska finnas utan både spelare och giv drar kort från draghögen enligt en förutbestämd algoritm utformad enligt ditt eget tycke. Exempelvis kan du välja att en spelare är nöjd då summan uppgår till 15 (eller mer konservativt, och hållbarare i längden(?), 8). Giv och spelare ska kunna vara nöjda vid olika summor.
Startpunkten för applikationen ska vara i filen app.js, placerad i roten av Javascript-applikationen. Övriga Javascript-filer ska vara placerade i underkatalogen src.
Din applikation måste använda olika typer av objekt, som måste skapas på minst två olika sätt:
skapande av objekt med en egendefinierad konstruktorfunktion (använd designmönstret "constructor/prototype" vid deklaration av typen).
instansering av objekt av en egendefinierad som använder class-syntax.
Samtliga typer ska vara placerade i olika moduler. Du väljer själv vad typerna ska representera. Kanske skapar du typer för spelbord, draghög, giv, spelare, hand, spelkort, färg, valör, ...?
Undvik om lämpligt att upprepa kod och bryt därför inte mot principen DRY ("don't repeat yourself").
Dokumentera typer och funktioner genom att använda JSDOC-kommentarer (beskrivning ska finnas och dokumentation av parametrar, kastade undatag och returvärden). Använd även radkommentarer innuti funktioner i de fall det är befogat.
Efter varje spelomgång ska resultatet presenteras. Det ska framgå vilka kort spelare och giv dragit, respektive hands summa och vem som vunnit. Nedan hittar du förslag på presentation av resultatet av olika spelomgångar.
Spelaren och given förklarar sig nöjda och given vinner då given har den högsta summan.
Spelaren får 21 och vinner direkt.
Spelaren och given är nöjda och har samma summa på handen varför given vinner.
Spelaren nöjd, given spricker varför spelaren vinner.
Spelaren spricker varför given vinner direkt.
Spelaren drar fem kort och får en summa under 21 och vinner direkt.
Bedömning av examinationsuppgiften görs enligt skalan U/G/VG. För att få VG i slutbetyg krävs VG på denna examinationsuppgift, samt G på examinationsuppgift 1.
Samtliga åtta mål i kursplanen examineras, men framför allt det åttonde och sista målet, "analysera problem för att därefter värdera och välja lämplig design samt konstruera lösning i form av program i programspråket Javascript (8)".
Betygsgraden bestäms utifrån hur väl du kan visa att du tillgodogjort dig kursens samtliga moment och den praktiska tillämpning av dessa. Utökningar av uppgiften kan premieras.
Ett vanligt sätt att representera en kortlek är att använda en array. För att blanda arrayen brukar algoritmen Fisher-Yates Shuffle användas i en eller annan form.
