2012

Eksamensprojekt: Casino
Alexander Kauffmann Vener, s113396
Indledende programmering med Matlab 02631
Abstract
I denne opgave udformes et virtuelt kasino, hvor et bruger fr mulighed for at spille p en rkke forskellige
borde og maskiner, og afprver sine frdigheder og held p et kasino. Spillene som kasinoet er High Low,
Slot Machine, American Roulette. Programmet fungerer i Matlab, og er en eksamens opgave i kurset
indledende programmering - 02631
Indholdsfortegnelse
Abstract ............................................................................................................................................................. 1
Introduktion ....................................................................................................................................................... 2
Design og implementering ................................................................................................................................ 2
Casino scriptet ............................................................................................................................................... 2
Implementering ......................................................................................................................................... 5
High-Low ........................................................................................................................................................ 8
Implementering ......................................................................................................................................... 9
Slot Machine ................................................................................................................................................ 10
Implementering ....................................................................................................................................... 11
American Roulette ....................................................................................................................................... 13
Implementering ....................................................................................................................................... 13
Fejl tjek ........................................................................................................................................................ 15
Errorcheck ................................................................................................................................................ 15
BetFcheck ................................................................................................................................................ 15
Linjecheck ................................................................................................................................................ 16
Diskussion ........................................................................................................................................................ 16
Konklusion ....................................................................................................................................................... 17
Kilder ................................................................................................................................................................ 17


Introduktion
Antallet af online kasinoer er i de seneste r steget eksponentielt, og er get hen og blevet en af de mest
indbringende internet forretninger der findes. Kasinoerne byder alle p et stort udvalg af spil, alt lige fra
bordspil til maskiner, og videospil. Det m derfor ligeledes forventes at kompleksiteten af den bagved
liggende kode at sky hj, men da er sprgsmlet dog om dette er den egentlige sandhed?
Jeg vil i dette projekt forsge at programmere mit eget virtuelle kasino, hvor en bruger trder ind p
kasinoet med en sum virtuelle penge, som han/hun derefter har fri mulighed for at bruge p kasinoets
forskellige borde og maskiner. Kasinoet har derudover til forml at give en brugeren indblik i statistikken
bag et kasino, ved at give brugeren mulighed for at se statistik over sig eget besg og resultatet af sine spil
ved de enkelte borde og maskiner.
I forhold til kurset indledende programmering i matlab, udgr dette projekt mulighed for at afprve den
vrktjskasse med tilhrende vrktjer man har erhvervet sig gennem de sidste 13 uger, og prve hvor
ledes et strre programmerings opgave kan lses i praksis, nr en kundes krav ligeledes skal tages i
betragtning
Design og implementering
I de flgende afsnit vil designet og implementeringen af funktionerne i programmet blive gennemget,
ligesom at selve casino scriptet, vil blive gennemget og forklaret.
Casino scriptet
Det er ud fra opgave beskrivelsen givet, at formlet med casino scriptet er at give brugeren mulighed for at
interagere p kasinoet. Dette indebrer blandt andet at brug starter sit besg p kasinoet gennem dette
script, og dernst navigere videre gennem kasinoets muligheder. Nr brugeren trder ind p kasinoet vil
han/hun som det frste blive prsenteret for et velkomst billede, som blot har til forml at skabe et indtryk
af, at man nu er trdt ind p kasinoet. Ligeledes kommer selve programmenuen op til venstre for dette
billede, hvor gennem brugeren senere har mulighed for at navigere i kasinoet.

Figur 1 p overstende billede, ses den menu, billede, og besked der fremkommer ved start af programmet.
For at spille er det dog ndvendigt at brugeren indstter penge p kontoen, og det ville derfor vre
naturligt at prompte brugeren for dette fr der gives mulighed for at navigere videre i kasinoet, dette kan
dog ligeledes vre til irritation for brugeren sfremt brugeren f.eks. nsker at gennemg spiltyperne fr
videre brug af programmet, alternativet er derfor ikke at prompte brugeren som det frste, hvilket
ligeledes kan resultere i at brugeren mske forsger at spille uden at have sat penge p kontoen. Problemet
lses dog ved at informere brugeren ved opstart om, at det er ndvendigt at indstte penge fr der kan
spilles, herved kan brugeren vente med at indstte penge til brugeren nsker at spille, dette muliggre
ligeledes at nr brugeren har opbrugt sine penge, at der s er mulighed for at indstte penge endnu
indgang og derved forstte besget. Som foranstaltning er det dog ikke muligt at starte spillene fr der er
penge p kontoen, dette vil dog blive beskrevet yderligere i flgende afsnit hvor implementering af scriptet
gennemgs.
Efter indsttelse af penge p kontoen har brugeren som tidligere beskrevet fri mulighed for at benytte de
forskellige funktioner i programmet, og kan via menuen navigere videre. Den anden menu knap spil leder
videre til selve undermenuen spil hvorfra der er mulighed for at vlge blandt spillene High Low, Slot
Machine og American Roulette. Ved at klikke p det nskede spil ledes man endnu engang videre til en
undermenu hvorfra man enten kan starte spillet, se statistik for tidligere spil, eller f hjlp til selve spillet
og reglerne for de nskede inputs, derudover er der selvflgelig mulighed for at bevge sig tilbage til den
foregende menu vedhjlp af menu knappen Back to menu.

Figur 2 P overstende figur ses hvordan der navigeres fra hovedmenuen og videre til High Low spillet
Afhngigt af hvilket spil der vlges i den anden under menu, vil brugeren nr der trykkes p play under
den sidste menu, blive bedt om et eller flere input, det vil i alle tre spil typer inkludere gambleAmount som
er det belb brugeren nsker at medbringe til bordet, eller indstte i maskinen. For SlotMachine vil
brugeren ligeledes blive bedt om at angive BetFactoren, som er det belb brugeren nsker at satse for
hvert spil. I American Roulette vil brugeren som andet input blive bedt om inputtet variablen TypeOfBet,
dvs. vlge hvad brugeren nsker at stte sine penge p, dette kunne f.eks. vre Black eller Even. Ved
indtastning af input vil der blive gjort brug af en rkke forskellige fejl tjek funktioner som tjekker hvor vidt
det angivne input er validt, i tilflde af et ikke validt vil brugeren f besked her om, og vil dernst f
mulighed for at indtaste igen, eller g tilbage og sge hjlp i hjlp menuen.
I hovedmenuen ses ligeledes ud fra figur 1., at det i hovedmenuen er muligt at tjekke sin konto via Account
knappen. Ved et klik p denne menu knap vil brugeren f besked om den tilbage vrende mngde penge
p sin konto. Den flgende menu knap Statistik viser et subplot af fire grafer, af hhv. konto historik, dvs.
mngden af penge p kontoen efter hvert spil, et pie chart over fordelingen af spil, et plot over vundne og
tabte spil i forhold til det totale antal spil, samt et plot over fordelingen af gevinster fra de tre spil. Menu
knappen Statistik vil dog kun fremvise fr nvnte plots sfremt, at brugeren har spillet p kasinoet, da
det vil vre overfldigt at fremvise fire tomme plots, sfremt at der alligevel trykkes p statistik uden at
have spillet vil programmet blot fremvise en besked om, at det ikke er mulig at lave en statistik over
brugerens besg.
Fra hovedmenuen er det ligeledes muligt at f hjlp til sin videre frd p kasinoet, via menu knappen
Help vil brugeren opn en deltaljeret forklaring af kasinoet, samt en liste over fejl som kan forekommen,
dette kunne f.eks. vre en fejl som manglende indbetaling. Sidste menu knap er Exit knappen, denne knap
har til forml at lukke programmet, samt give brugeren en oversigt over resultatet af brugerens besg,
dette gres ved hjlp af de samme fire plots som under menu knappen Statistik i hovedmenuen. Ved
visning af de fire plots vil brugeren samtidig blive spurgt endnu en gang om man er sikker p, at man nsker
at forlade kasinoet, for p denne mde at sikre at brugeren ikke blive lukket ud af kasinoet ved en fejl.

Figur 3 P ovestende figur ses billedet som brugeren prsenteres for, nr der trykkes p exit i hovedmenuen.

Implementering
Programmet er opbygget omkring et while loop, dette loop indeholder alle de forskellige muligheder i
kasinoet, og brugeren vil derfor altid i sidste ende blive frt tilbage til dette loop og den tilhrende menu,
antallet af step fr brugeren bliver frt tilbage til dette loop kan dog variere, som funktion af antallet af
undermenuer.
Fr dette while loop startes der dog med at definere alle de ndvendige variable. I forbindelse med dette,
er taget et mindre velset valg, nemlig at definere en rkke forskellige variable som globale variable, det vil
sige at de kan bruges p tvrs af script og funktioner, uden at skulle figurere som output eller input. Dette
anses normalt for vrende drlig programmerings stil, men grundet begrnsende specifikationer i
funktionernes interface har dette vret en ndvendighed. At dette har vret en ndvendighed skyldes
kravet om de tre plots ved afslutning af programmet. Her nskes brugeren som tidligere beskrevet
prsenteret for hhv. et plot over konto bevgelserne efter hvert spil, fordelingen antallet af spil p de
forskellige borde eller maskiner, samt et plot over tabte og vundne spil i forhold til det totale antal spil.
Problemet opstr i selve formuleringen af opgaven i forhold til scriptets funktion, scriptet kan ved hjlp af
en counter tlle hver gang programmet kalder funktionen, dette er dog ikke det samme som antallet
egentlige spil der bliver spillet, dette skal der derimod anvendes en counter til inde i selve funktionen til at
gre. Men grundet kravene til interfacet er det ikke muligt at have en sdan counter som output variable,
og det derfor ndvendigt at definere den til at vre global. Alternativet til dette ville vre at output
variablen wonAmount fra funktionerne skulle vre en vektor bestende af gevinsterne fra hvert spil, alts
en vektor defineret som flgende inde i funktionerne:
[ ]
()
Counter, vil vre en tller i funktionen, som tller antallet af spil, sledes at wonAmount opdateres efter
hvert spil. Antallet af spil vil i scriptet da vre lig lngden af vektoren som kan bestemmes ved matlab
funktionen length(wonAmount). Dette ville muliggre plottet af fordelingen af spil p de forskellige spil
typer. Ved at definere wonAmount som en vektor bestende af gevinster efter hvert spil, er det ligeledes
muligt at plotte antallet af tabte og vundne spil i forhold til det totale antal spil, dette gres ved at
bestemme antallet af 0er i vektoren, dette kan gres som flgende:
(( ) )
Antallet af 0er vil vre antallet af spil hvor gevinsten har vret lig 0, dvs. alle de spil for brugeren har tabt,
antallet af vundne spil vre differencen mellem antallet af tabte spil og det totale antal spil, dvs. lngden
af vektoren. Det sidste plot over kontohistorikken kan dog kun laves vedhjlp af en variable ligesom
wonAmount, som opdateres ved hjlp counter, men da det ikke er muligt at lave en counter i scriptet som
tller hver gang der spilles et spil i en af funktionerne, er dette ikke muligt at lave et plot over uden at
bruge globale variable.
Ved hjlp af de globale variable og output fra funktioner laves de fire tidligere beskrevne plots, de fire
plots vises dog i sammen vindue, da det ellers kan virke forvirrende hvis fire separate vinduer bnes. Derfor
anvendes subplot til plotte de fire plots i samme vindue .
For at vende tilbage til selve kodens flow, s vil brugeren ved start blive prsenteret for 6 hoved cases, som
indeholder de forskellige dele af programmet. Afhngigt at hvilken case der vlges vil brugeren blive ledt
videre til en undermenu eller blive afkrvet input. Dernst vil enten en funktion blive kaldt, eller en
variable blive opdateret. Ved kald af en funktion vil funktionen efterflgende returnere et output med
opdaterede variable, og brugeren vil da igen have mulighed for at anvende menuen og vlge ny spil eller
funktioner i kasinoet. De 6 hoved cases dkker over flgende indehold, med tilhrende under cases:
1. Case 1: Her har brugeren mulighed for at indstte en virtuel p sin konto. Kontoen vil efterflgende
blive opdateret med det indsatte belb.

2. Case 2: Denne case bestr af yderligere fire cases, som giver brugeren mulighed at vlge hvilken spil
menu der nskes bnet, samt mulighed for at vende tilbage til hovedmenuen.
2.1. Case 1: Ved valg af denne case vil brugeren via den tilhrende menu f mulighed for enten at
starte spillet High Low, se statistik over tidligere High Low spil, f hjlp til spillet eller vende tilbage
til hovedmenuen
2.1.1. Case 1: Ved valg af denne case promptes brugeren frst for inputvariablen gambleAmount,
hvorefter HighLow funktionen kaldes
2.1.2. Case 2: Ved valg af denne case vil brugeren f statistisk information om tidligere spillede
highlow spil
2.1.3. Case 3: Generer en tekst felt med information om spillet High Low, samt regler for input
2.1.4. Case 4: Frer brugeren tilbage til den foregende menu
2.2. Case 2: Ved valg af denne case vil brugeren via den tilhrende menu f mulighed for enten at
starte spillet SlotMachine, se statistik over tidligere spil p maskinen, f hjlp til spillet eller vende
tilbage til hovedmenuen
2.2.1. Case 1: Ved valg af denne case promptes brugeren for to input til funktionen i form af
gambleAmount, samt BetFactor, herefter kaldes SlotMachine funktionen, som starter spillet.
2.2.2. Case 2: Ved valg af denne case vil brugeren f statistisk information om tidligere spil p
maskinen.
2.2.3. Case 3: Generer tekst felt med information om maskinen, og regler vedrrende input til
funktionen.
2.2.4. Case 4: Frer brugeren tilbage til den foregende menu
2.3. Case 3: Ved valg af denne case vil brugeren via den tilhrende menu f mulighed for enten at
starte spillet American Roulette, se statistik over tidligere spil ved bordet, f hjlp til spillet eller
vende tilbage til hovedmenuen
2.3.1. Case 1: Ved valg af denne case vil brugeren frst blive promptet for input variablen
gambleAmount, og dernst for input variablen TypeOfBet, som er en string variable,
bestende af navnet p den nskede spiltype.
2.3.2. Case 2: Viser brugen hvor det tidligere af get ved spil p rouletten.
2.3.3. Case 3:
2.3.4. Case 3: Frer brugeren tilbage til den foregende menu.
2.4. Case 4: Frer brugeren tilbage til hovedmenuen.

3. Case 3: Ved valg af denne case vil brugeren blive informeret om tilbage havende p kontoen

4. Case 4: Brugeren vil i denne case blive prsenteret for statistik over besget, indeholdende plots over
konto historik i et x,y plot, spil fordeling i et pie chart, Resultat fordeling i et bar chart og gevinst
fordeling p de forskellige spil i et bar chart. Denne information vil dog kun vre tilgngelig sfremt
der er spillet p minimum en maskine. Til at lave plottene anvendes matlab built in function til de
forskellige plot typer, dvs. plot, pie, og bar.

5. Case 5: Generer et tekst felt med generel information omkring kasinoet, samt information om mulige
fejl der kan opst under besget p kasinoet

6. Case 6: Den case generer frst samme information som beskrevet i case 4, hvorefter brugeren blive
spurgt om han/hun er sikker p at han/hun vil forlade kasinoet, ved Yes bliver programmet lukket og
et afsked billede bnet, ved svaret No fres brugeren tilbage til hovedmenuen.
Jeg finder personligt overstende program opbygning overskuelig og intuitiv. Overstende kan dog designes
p adskillige andre mder, man kunne forestille sig at man nskede at placere indgangen til spilmenuerne
helt ude i hovedmenuen, og derved spare en undermenu vk.
Koden til den beskrevne opbygning kan ogs delvis visualiseres som flgende.



Figur 4 overstende figur viser en delvis visualisering af programmets opbygning. Programmet startes i
while loop, hvorfra hovedmenuen kres, derfra har brugeren mulig for at vlge en case, som frer
videre, i tilfldet af valg af case 2 fres brugeren videre til et nyt while loop med tilhrende menu. Der
kan fra alle menuer vendes tilbage til den foregende ved at slutte while loopet.

High-Low
Funktionen til High Low spillet er kaldt HL i projektet, alts en forkortelse for High Low, og er skal som flge
af krav fra projekt formuleringen vre opbygget omkring flgende interface:
[ ] ()
Som tillgskrav til interface er det givet at, output variablen noGuesses skal kunne undlades ved kald af
funktionen, det vil sige, at det er et krav fra kunden, at funktionen kun returnere output variablen
wonAmount. Dette kan gres p flgende mde
()
Ved at kalde funktionen p overstende mde undlades output variablen noGuesses, og kun det frste
output wonAmount assignes til variablen wonAmount i scriptet, dette vil resulterer i, at den hukommelse
der fr skulle vre brugt spares, derudover resulterer det dog ogs i, at noGuesses ikke kan anvendes i
scriptet. Samlet set er derfor en opvejning af hvor vidt det er relevant at have noGuesses defineret i
scriptet, sfremt dette ikke er tilfldet kaldes funktion som fr beskrevet, hvis noGuesses derimod nskes
anvendt i scriptet, eksempelvis i forbindelse med plots eller statistik. Det i projekt beskrivelsen givet, at der
opfordres til at give brugeren adgang til yderligere statistiske informationer og plot over besget, og derfor
vlges det i stedet at kalde funktionen som flgende:
[ ] ()
Ved at kalde funktionen som vist ovenfor, assignes de to output variable gambleAmount, og noGuesses til
to variable af samme navn i scriptet, hvorved de kan bruges senere hen. I forhold interfacet er det tidligere
beskrevet i rapporten, hvordan det har vret ndvendigt gre brug af globale variable, flere af disse
variable kan dog undlades at defineres som globale, ved at ndre p hhv. input og output i interfacet. Ved
at tilfje variablen AccountRecord, som er en vektor bestende af det indestende belb p kontoen efter
hvert spil, som bde input og output, vil det vre muligt at lave det nskede plot over konto historikken.
AccountRecord vil i scriptet vre defineret som:
[ ]
Og vil derefter ved kald af funktion efter hvert spil vre defineret i funktionen som flgende:
()
counter vil vre en tller i funktionen som tller antallet af spil, sledes at AccountRecord bliver en
vektor, som tilfjes et element efter hvert spil. AccountRecord skal dog anvendes i alle funktioner, det
derfor ndvendigt at tlleren, counter, starter som vrende lig antallet af elementer i AccountRecord, og
initialiseres derfor som flgende i funktionen:
()
Ved start af spillet i funktionen, som forklares yderligere under implementeringen, vil tlleren vre
defineret som flgende:

Dette ville efter min mening give det mest optimale interface, da man p denne mde kunne undg brugen
af globale variable, og derved en opn en langt mere en elegant kode.
Implementering
I HighLow funktionen gres der brug af en rkke globale variable, deriblandt Account, AccountRecord,
HLcounter, HLWcounter og HLLcounter, hvis forml hhv. er at opdatere belbet til rdighed p kontoen
efter hvert spil, at danne en vektor over kontohistorikken, efter hvert spil, en tller til at tlle antallet af
spil, en tller til at tlle antallet af tabte spil, og en til vundne spil. Disse er alle globale der de alle
anvendes i scriptet i forbindelse med statistik over besget og spillet.
Derudover anvendes variablen guess, som er det tal brugeren gtter p, guess indtastet som en string
variable vedhjlp af inputdlg, og konverteres derefter til et nummer ved hjlp af str2num funktionen.
Derudover er der ligeledes wonAmount som er det vundne belb, noGuesses, som er en vektor over
antallet af gt brugt i de enkelte spil, samt en counter, som tller antallet af gt der bruges til at gtte x i
et enkelt spil. Sidste er variablen inputnum, som anvendes i forbindelse med de flgende while loops.
Inputnum defineres fr while loop til vrende lig 1.
Dernst fres brugeren ind i while loop som krer s lnge inputnum er forskellige fra 0, dette gr at
brugeren kan forstte med at spille nye spil, indtil inputnum bliver defineret som vrende lig 0. Dette er
der allerede mulig ved frste input brugeren promptes for, her skal brugeren tage stilling om han/hun
nsker er klar til at spille, hvis nej s defineres inputnum=0, og output af funktionen returneres samtidig
med at brugeren fres tilbage til menuen.
Hvis brugeren derimod vlger at spille vil der blive promptes for endnu et input i form af det nskede bet,
inputtet fejl tjekkes ved hjlp af funktionen Errorcheck, som beskrives senere i rapporten, og hvis inputtet
er validt genereres tallet x, som er tallet brugeren skal gtte. Dernst fres brugeren ind i et nyt while
loop, som krer s lnge brugeren gt, guess, er forskelligt fra x.
Brugeren promptes herefter for inputtet guess, dvs. det nummer brugeren nsker at gtte, dette input fejl
tjekkes ligeledes. Dernst tjekker funktionen om gttet er lig x, hvis gttet er for enten hjt eller for lavt
anvendes fprintf til at give en besked om hvad brugeren gttet, samt at gttet er for hjt eller for lavt. Da
gttet i dette tilflde ikke er lig x, forsttes while loopet, og brugeren promptes endnu gang for et gt,
sdan forsttes loopet indtil guess=x, nr dette er tilfldet regnes payout og wonAmount, og brugeren
informeres om dette ved hjlp af fprintf, samtidig opdateres at gambleAmount sledes, at brugeren enten
har mulighed for ogs at spille for de penge der lige er vundet eller brugeren har det belb der lige er
blevet tabt mindre at spille for. Dernst fres brugeren tilbage til det foregende while loop, hvor
brugeren via en dialog med programmet skal angive om han/hun nsker at spille endnu engang, hvis dette
er tilfldet er inputnum forsat lig 1, hvorimod hvis brugeren svarer nej, vil inputnum vre lig 0, og while
loopet stoppes og output returneres til scriptet samtidig med at brugeren fres tilbage til menuen. Fr
brugeren indleder den fr beskrevne dialog tjekkes det om gambleAmount >0 hvis dette ikke er tilfldet,
s svarer det til at brugeren ikke har flere penge at spille for, og inputnum = 0, hvorefter while loopet
stoppes og output returneres til scriptet.

Figur 5 Ovenfor ses en visualiseringen af kodens flow i funktionen
Den valgte opbygning og det tilhrende flow, finder jeg intuitivt, og medvirker til at brugeren let kan
navigere og spille i funktionen, ligeledes har brugeren efter hvert spil mulighed for at forlade spillet, og tage
sin gevinst med sig. En ndring til funktionen kunne eventuelt vre at tilfje endnu en begrnsning ved
hjlp af et if som siger at, hvis antallet af gt er strre end 10, s er spillet tabt, da brugeren ved flere gt
end 10 ikke vinder noget. Denne begrnsning ville sikre at brugeren hurtigt kunne komme i gang med et
nyt spil, uden at skulle gennemfre det i forvejen tabte spil, da alt over ti gt er lige gyldigt for resultatet.
Dette giver dog et problem i forhold til antallet af gt der bruges, da det s vil vre uvist hvor mange gt
brugeren ville ende op med at bruge. Dette giver ligeledes et problem i forhold til statistikken, da
gennemsnittet af antallet af gt til at gtte x, vil vre misvisende, og tale for at det er get bedre end det
egentlig er.

Slot Machine
Funktionen til den enarmede tyvekngt, ogs kendt som slot machine, er kaldet SlotMachine i projekt, og
skal som flge af projekt beskrivelsen vre opbygget omkring flgende interface
[ ] ( )
Tillgskravet, som blev beskrevet i forbindelse med High Low funktionen, glder ligeledes for SlotMachine
funktionen, her er det dog i stedet ouput variablen noPulls, som det skal vre muligt at undlade. Dette kan
ligesom i forbindelse med HighLow funktionen gres ved at kalde funktionen som flgende:
( )
Dette har dog ligeledes den konsekvens at output variablen noPulls ikke er defineret i scriptet, og derfor
ikke er tilgngelig i forbindelse med statistik. Derfor vlges det i stedet at kalde funktionen som flgende:
[ ] ( )
Ved at kalde funktionen p denne mde vil det vre muligt at anvende output variablen i scriptet, hvilket
er relevant i forbindelse med den nskede statistik del i programmet. Dette interface er dog langt fra
optimalt, da det, som beskrevet under high low funktionen stter sine begrnsninger, som medfrer at
brugen af globale variable er ndvendig, derfor br interfacet for funktionen ndres p samme mde som
High Low funktionens interface ndres, nemlig ved at tilfje variablen AccountRecord som bde input og
output, interfacet bliver derved som flgende:
[ ] ( )
Fr kald af funktionen vil brugeren dog frst blive promptet for input parameteren gambleAmount, dvs.
den mngde penge brugeren nsker at bringe til bordet. Dernst promptes brugeren for input
parameteren BetFactor. Det er i projektbeskrivelse ikke givet hvor vidt brugeren skal promptes for et ny
BetFactor efter hvert spil, p traditionelle maskiner er dette dog ikke muligt, men da brugeren til en hver
tid kan vlge at slutte spillet, og stoppe funktionen, og dernst kalde funktionen igen, virker det blot som
en overfldig begrnsning. Derfor vil brugeren ved start at et nyt spil blive spurgt hvor vidt det flgende
spil nskes spillet med en ny BetFactor, hvordan dette gres kan lses i afsnit om implementeringen af Slot
Machine funktionen.
Implementering
De to input parametre gambleAmount, og BetFactor, er begge string variable, men konverteres til en
talvrdi ved hjlp af str2num funktionen i matlab. I SlotMachine funktionen gres der ligesom i HighLow
funktionen brug af en rkke forskellige globale variable, deriblandt Account og AccountRecord, som der
gres brug af i alle spil funktionerne. Derudover anvendes ligeledes en tller variable SMcounter som
tller antallet af spil p maskinen, en SMWcounter som tller antallet af vundne spil, og SMLcounter som
tller antallet af tabte spil p maskinen, disse variable er alle globale, og anvendes i forbindelse med
statistik delen i scriptet. Derudover er der variablen x, som er vektor bestende af tre runde random
generede tal mellem 1-10. Den sidste variable er variablen inputnum, der ligesom i highlow funktionen,
styrer while loopet som spillet er bygget op omkring.
Efter at have defineret de variable i funktionen startes while loopet, while loopet srger for at, brugeren
kan forstte med at spille uden at skulle forlade funktionen for at spille igen. Nr while loopet startes vil
brugeren via en dialog med programmet blive spurgt om han/hun er klar til at begynde. Hvis nej, defineres
inputnum=0, og while loopet stoppes, brugeren fres tilbage til menuen, og output returneres til scriptet
fra funktionen. Hvis brugeren derimod svarer ja, generes vektoren x, bestende af de tre talvrdier,
hvorefter der tjekkes for gevinst via en if clause.. Kravet for gevinst er at mindst to elementer i x er lig
hinanden, derfor tjekkes der for gevinst som flgende:
(( ))
I overstende er n tallet som der er to elementer af, det vil sige et tal intervallet 1-10. Det er dog ogs
ndvendigt at tjekke for tre ens, da dette giver et hjt payout, som derudover ogs afhnger af tallet n. Et
eksempel p hvordan dette tjekkes i forhold til if clausen, er som flgende
(( ))

Brugeren vil herefter blive informeret om gevinsten i spillet, og hvor meget der er til rdighed at spille for
p maskinen, dvs. gambleAmount, opdateres med enten tabet eller gevinsten efter spillet. Ligeledes
opdateres wonAmount med enten det vundne eller tabte belb. Hvis gevinsten er strre end 0, dvs. spillet
er vundet, tller SMWcounter +1, ellers tller SMLcounter +1.
Dernst startes en ny dialog med funktionen hvor brugeren skal tage stilling til om han/hun nsker at
starte et nyt spil, sfremt dette ikke er tilfldet defineres inputnum=0, og brugeren fres tilbage til
menuen, og funktionen returnerer output til scriptet. Hvis brugeren derimod nsker at spille igen vil
brugeren blive spurgt om hvor vidt han/hun nsker en ny BetFactor, hvis nej, startes spillet blot forfra med
den tidligere valgte BetFactor, hvis ja, promptes brugeren derimod for en nyt BetFactor, hvorefter et nyt
spil startes med denne BetFactor. Sledes forstter while loopet med at kre indtil brugeren enten vlger
at stoppe, eller ikke har flere penge at spille for, dvs. gambleAmount=0.
Samlet set kan koden visualiseres som flgende:

Figur 6 Ovenfor ses en visualisering af kodens flow gennem funktionen.
Den valgte opbygning og det tilhrende flow, finder jeg intuitivt, og medvirker til at brugeren let kan
navigere og spille i funktionen, ligeledes har brugeren efter hvert spil mulighed for at forlade spillet, og tage
sin gevinst med sig. Jeg har tidligere under designet beskrevet at det er muligt at ndre betFactoren under
hvert spil, det har formentlig ikke vret meningen, at dette skulle vre muligt, men det giver som sagt
brugeren get fleksibilitet til selv at vlge, om han/hun vil satse alt p et trk og have mulighed for at
opn et hjt payut eller splitte det op i flere trk med et mindre muligt payout.

American Roulette
I projekt beskrivelsen er denne funktion kaldt Rouletten, men da jeg i funktionen har inkluderet bde 0 og
00, er den rette betegnelse for spillet American Roulette, da kun denne type roulette indeholder 00, i
modstning til f.eks. European Roulette og French Roulette. Funktionen er i projektet derfor kaldt
AmRoulette, og skal som flge af specifikationerne i projekt beskrivelsen vre opbygget omkring flgende
interface:
( )
I modstning til de to andre spil funktioner, har vi kun et output i denne funktion, og derfor er der heller
intet tillgskrav vedrrende output. Derfor kan funktionen blot kaldes som flgende:
( )
Fr funktionen kaldes promptes brugeren frst for input parameteren gambleAmount, og dernst for
input parameteren TypeOfBet, det er dog givet i specifikationerne at TypeOfBet skal behandles som en
string variabel. Dette gres ved at anvende menu funktionen i matlab, hvorfra brugeren vlger TypeOfBet,
og ud fra den valgte type/case, anvendes en switch, til at definere TypeOfBet som en string med navnet p
den valgte spil type. Hvis brugeren f.eks. vlger at spille p Red, bliver TypeOfBet lig flgende:

For at vende tilbage til interfacet, har AmRoulette funktionen samme problem som de to tidligere
beskrevne funktioner, nemlig at outputtet fra funktionen ikke indeholder tilstrkkelig information til de
pkrvne plots i scriptet. Det lses dog p njagtig samme mde, nemlig ved at tilfje variablen
AccountRecord som bde input og output i funktionen. Ligeledes defineres wonAmount i stedet som
vrende en vektor indeholdende gevinsterne efter hvert spil, som beskrevet under implementeringen af
casino scriptet.
Implementering
Som beskrevet under design har funktionen to input parametre, gambleAmount og TypeOfBet, som begge
er defineret som string variable, gambleAmount konverteres dog til en talvrdi ved hjlp af str2num
funktionen, og inputtet er derfor talvrdi, i modstning til TypeOfBet som forbliver en string variable i
inputtet.
I funktionen anvendes defineres de to variable Account, og AccountRecord endnu en gang som globale
variable, sledes at de kan bruges i scriptet. Derudover defineres hhv. ARcounter, ARWcounter og
ARLcounter som globale variable da disse ligeledes skal bruge i forbindelse med statistik delen. Derudover
anvendes variablen x, som er en random generet talvrdi til hrende de naturlige tal i intervallet 0-37,
forklaringen p, at intervallet ikke stopper ved 36, som er det hjeste tal p rouletten er, at tallet 00
defineres som vrende tallet 37, dvs. sfremt at x =37 vil brugeren f at vide at tallet er 00. Den sidste
variabel er inputnum, som ved start sttes lig 1.
Efter at have defineret de variable startes while loopet, som krer s lnge inputnum er forskellig fra 0, p
denne mde kan brugeren forstte med at spille uden at skulle forlade funktionen. Efter whilet loopet
kommer den switch som srger for at assigne typeofbet til de talvrdier som der er satset p, det gres
f.eks. som flgende hvis TypeOfBet inputtet er lig Even

Sfremt at TypeOfBet=Straight eller Street vil brugeren blive promptet for et input, som for Straight kan
vre alle numre p rouletten. Sfremt brugeren vlger 00, vil funktionen automatisk stte TypeOfBet=37.
Street skal derimod vre et linje nr. i intervallet 1-12, inputtet tjekkes ved hjlp af fejl tjek funktionen
linjetjek. Nr brugeren har angivet det nskede linje nr. og det er blevet tjekket og godkendt, kan tallene
som der satses p, regnes som flgende:
[ ( ) ( ) ( )]
Eksempelvis hvis brugeren vlger linje 1., bliver tallene som flgende
[]
Herefter sprges brugeren om han/hun er klar til at spille, hvis nej, defineres inputnum=0, og while loopet
stoppes, og funktionen returnerer outputtet. Hvis ja, promptes brugeren for et bet, dvs. den mngde
penge der nskes satset. S generes x, hvis x = 37, anvendes funktion disp til at sige at tallet er lig 00, hvis
tallet er forskelligt fra 37 anvendes matlab funktionen fprintf til at skrive hvad tallet er.
En if clause bestemmer dernst om brugeren har vundet, dette gres ved hjlp af matlab funktion
ismember, som tjekker om x er en del af TypeOfBet, hvis dette er tilfldet kan payout bestemmes som
flgende:

()

Ellers er Payout =0. Herefter informeres brugeren om gevinsten, og hvad han/hun har tilbage at spille for. I
dialog med programmet gives brugeren dernst mulighed for at forlade bordet, dvs. inputnum=0, eller at
spille endnu engang, hvis brugeren vlger at spille igen promptes der for ny TypeOfBet, hvorefter spillet
starter igen. Nr brugeren vlger at forlade bordet eller ikke har flere penge at gamble for,dvs
gambleAmount =0, s er inputnum=0, og brugeren fres tilbage til menuen, og funktionen returnerer
output variablen wonAmount til scriptet.
Koden kan visualiseres som flgende:

Figur 7 p overstende figur ses kode flowet i funktionen
Funktionens opbygning er intuitiv, og fungerer efter hensigten, det sikrer en god bruger oplevelse med god
fleksibilitet hvor brugeren til en hver tid har mulighed for at forlade spillet.
Fejl tjek
I de flgende afsnit vil designet af hhv. funktionen Errorcheck, BetFcheck og Linjecheck blive gennemget.
Disse har alle til forml at tjekke for fejl i input i forhold til de forskellige variable.
Errorcheck
Errorcheck funktionen tjekker variabler som gambleAmount og bet, og tager udgangspunkt i en if clause
som siger, at hvis input er mindre end minimumsvrdien, er strre end maksimumsvrdien, eller ikke er
angivet s er output lig 0, for alle andre som overholder fr nvnte vil output vre lig 1. Ved at kombinere
dette med et while loop, vil brugeren blive promptet for et nyt input indtil input er godkendt. Interfacet til
denne funktion er som flgende
( )
BetFcheck
BetFcheck funktionen anvendes til at tjekke om input parameteren BetFactor i forbindelse med
SlotMachine funktionen overholder kravene. Forklaringen p hvorfor dette ikke blot gres ved hjlp af
errorcheck funktion skyldes kravet om at, sfremt betFactor undlades, dvs inputtet er tomt, s skal
BetFactor sttes lig 1, hvilket ikke er muligt uden at ndre Errorcheck funktion. BetFcheck funktionen
bygger p samme if clause som Errorcheck, men undtagelse af hvad der sker hvis isempty(BetFactor)==1,
ved Errorcheck ville dette udgre et ulovligt input, men grundet kravet, skal BetFactor i denne situation
assignes talvrdien 1, derfor tilfjes et elseif statement, som siger at:
(())

rsagen til at der i overstende ogs anvendes str2num funktionen er at, BetFactor er en string variabel.
Interfacet til funktionen er derfor som flgende:
( )
Linjecheck
Den sidste fejltjek funktion af Linjecheck som tjekker inputtet i forbindelse med TypeOfBet=street. Nr
brugeren vlger at spil typen Street, bliver der promptet for en linje nr., dette nr. skal vre et naturligt tal
og ligge i intervallet 1-12. Det vil sige den skal overholde alle de samme begrnsninger som i Errorcheck
funktionen, men skal derudover ogs vre en del af de naturlige tal, dvs. tallet skal vre rundt. Det gres
ved flgende:
(() (()))
Ovenfor tjekkes det om inputtet, er forskellig fra afrundingen af inputtet, hvis dette er tilfldet er tallet
ikke en del af de naturlige tal, og derfor ikke en validt input. Derudover fungere funktionen p samme mde
som Errorcheck ved at blive kombineret med et while loop, sledes at brugeren vil blive promptet for et
input indtil et validt input indtastet. Interfacet for Linjecheck er som flgende:
( )
I princippet kun funktionen uden problemer omskrives til en funktion med kun et input, da antallet af linjer
ikke varierer, men altid vil vre lig 12, og min vil derfor altid vre lig 1, og max lig 12. Men for ge
brugbarheden anvendes det valgte interface, sledes at den f.eks. ogs kan vende i forbindelse med
straight, hvor TypeOfBet ligeledes skal vre et naturligt tal.
Diskussion
Det er lykkedes mig at lave et program som kan simulere et online kasino, dog med en begrnset mngde
funktioner taget virkelige online kasinoer i betragtning. Ikke desto mindre viser mit program, at det er
muligt at programmere et kasino med simpel programmering. Programmet tilbyder dog ogs brugeren en
funktion som er sjldent set p rigtige kasinoer, nemlig en statistik funktion, som giver brugeren et
overblik over resultaterne af de enkelte spil, og kan p baggrund af dette udvlge sin strategi, som f.eks.
kunne vre at undlade at spille p den enarmede tyvekngt da denne giver det laveste payout taget
sandsynligheden for at vinde i betragtning. Koden bag programmet kan dog optimeres p en rkke
punkter, blandt andet i forhold til anvendelsen af globale variable. Ved videre udvikling ville det derfor
vre relevant af undg brugen af dette, hvilket dog krver at funktionsinterfacene udvides som beskrevet
under implementeringen af de forskellige funktioner. Derudover er der flere input som kan udvides med
fejl tjek, hvilket reducerer antallet af fejl i programmet, og derved ger bruger venligheden.
I forbindelse med videre udvikling af programmet er det svrt at komme uden om antallet af nuvrende
funktioner. Kasinoet byder p et begrnset udvalg af spil, og det ville derfor vre oplagt at udvide antallet
af spil. De mest oplagte spil at udvide kasinoet med ville umiddelbart vre hhv. blackjack og poker. Poker
udgr klart den strste udfordring da antallet af parametre og udfald er betydeligt strre end i black jack.
Black Jack er derimod til at programmere uden strre problemer sfremt regler som split undlades, ved at
undlade split afhnger spillet udelukkende af hvem der kommer tttest p at komme op p en 21.
En sidste vsentlig forbedring af programmet ville vre at opdatere interfacet af selve programmet,
sledes at spillene i stedet kre i command window, kres ved hjlp at et GUI, og i det hele taget forbedre
det grafiske interface, da dette p alle mder vil ge brugervenligheden.
Konklusion
Jeg har gennem de sidste 13 uger arbejdet med programmering i matlab, med det forml at blive i stand til
at arbejde i matlabs interface, og bruge dette og dets muligheder for at skrive kode til diverse scripts og
funktioner ved brug af indbyggede funktioner i matlab, og brug af diverse typer af variable, samt blive i
stand til at visualisere data p forskellige mder afhngigt at situationen og formlet med visualiseringen.
At dette er lykkes ses blandt andet ud fra dette projekt. I projektet har jeg brugt de kompetencer jeg har
erhvervet mig i lbet af ret, til at lse et konkrent programmerings problem, hvor samtlige af fr nvnte
kompetencer har vret ndvendige. Resultatet af projektet er blevet et kasino som i alt sin enkelthed viser
hvordan et kasino simpelt kan opbygges, samtidig med at det tilbyder en tilstrkkelig bruger venligt
interface, sledes at enhver bruger vil vre i stand til at bruge kasinoet. Kasinoets koder indeholder flere
muligheder for forbedringer, men ingen som ikke kan lses ud fra den erhvervede vrktjskasse.
Kilder
Skabelonen der er anvendt til bde velkomst billedet, og farvel billedet er fundet via flgende link:
http://www.google.dk/imgres?um=1&hl=da&sa=N&tbo=d&biw=1366&bih=667&tbm=isch&tbnid=9wBwOg
5J84t7-M:&imgrefurl=http://slot-machine-news.com/&docid=g6TgEwgoYmgI9M&imgurl=http://slot-
machine-news.com/wp-
content/uploads/2011/05/casino.jpg&w=300&h=300&ei=9h3BUICQEZDAtAbGjICoBA&zoom=1&iact=rc&du
r=288&sig=114815250815250289594&page=3&tbnh=149&tbnw=141&start=41&ndsp=24&ved=1t:429,r:57
,s:0,i:324&tx=102&ty=49
Billedet er efterflgende redigeret sledes at det udgr hhv. et velkomst billede, og et farvel billede.