Kunstig Intelligens til Brætspillet Taiji - Danmarks Tekniske Universitet

Kunstig Intelligens til Brætspillet 

Taiji 

Morten Rask 

Kongens Lyngby 2009 

IMM-MSC-2009-66

Technical University of Denmark 

Informatics and Mathematical Modelling 

Building 321, DK-2800 Kongens Lyngby, Denmark 

Phone +45 45253351, Fax +45 45882673 

reception@imm.dtu.dk 

www.imm.dtu.dk

Summary 

This project concerns the development of several artificial intelligences to the 

board game Taiji. Taiji is a fully observable abstract strategic game where two 

opponents each will try to score the most points by forming a larger figure on 

the board than the opponent’s figure. 

Taiji is a relatively new game released in the year 2007 and therefore there 

has not yet been developed an effective artificial intelligence (AI) for the game. 

The game’s designer, Néstor Romeral Andrés, has developed a simple AI for the 

game, but it requires great computing power at the high difficulty levels without 

even necessarily defeating a human opponent. 

The project aims to develop an effective AI to Taiji. In the first phase is implemented 

a classical AI-based search in a Minimax game tree. This involves, 

among other, construction of an appropriate heuristics for the game. The next 

stage is to examine further opportunities for improvement and development of 

more advanced AI’er. This includes, inter alia, an upgrade from game tree to 

game graph. Game tree gives as the name indicates only the opportunity to 

follow structure of the path, while the game graph allows move across structure 

of the path and thus is considerably more comprehensive. 

The project also includes an analysis of the game’s complexity and a score 

of winning strategies for different board sizes. 

The physical implementation of the game and the artificial intelligences have 

been made in Java.

Resumé 

Dette projekt omhandler udviklingen af flere kunstige intelligenser til brætspillet 

Taiji. Taiji er et fuldt observerbart abstrakt strategisk spil, hvor to modstander 

hver især forsøger at score flest point ved at danne en større figur p˚a brættet 

end modstanderens figur. 

Taiji er et forholdsvis nyt spil udgivet i ˚ar 2007 og derfor er der endnu ikke 

blevet udviklet en effektiv Artificial intelligence (AI) til spillet. Spillets designer, 

Néstor Romeral Andrés, har udviklet en simpel AI til spillet, men den kræver 

stor computerkraft p˚a de høje sværhedsgrader uden nødvendigvis at besejre en 

menneskelig modstander. 

M˚alet med projektet er at udvikle en effektiv AI til Taiji. I første fase implementeres 

en klassisk AI baseret p˚a minimax søgning i et spiltræ. Dette involvere 

blandt andet konstruktion af en passende heuristik for spillet. I næste fase undersøges 

yderligere muligheder for forbedringer og udvikling af mere avancerede 

AI’er. Dette inkludere blandt andet en opgradering fra spiltræ til spilgraf. Spiltræ 

giver som navnet angiver kun mulighed for at følge stistruktur, mens spilgraf 

giver mulighed for g˚a p˚a tværs af stistruktur og dermed er væsentligt mere omfattende. 

Projektet indeholder ogs˚a en analyse af spillets kompleksitet og en vurdering 

af vinderstrategier for forskellige brætstørrelser. 

Den fysiske Implementeringen af spillet og de kunstige intelligenser er blevet 

foretaget i Java.

Forord 

Dette speciale er udarbejdet ved Institut for Informatik og Matematisk Modellering, 

Danmarks Tekniske Universitet, som en del af kravene til færdiggørelsen 

af kandidatuddannelsen. 

Dette speciale omhandler kunstig intelligens i brætspillet Taiji og en analyse 

af spillet. 

Dette projekt blev lavet i perioden fra den 6. april 2009 til den 5. oktober 

2009 under vejledning af Thomas Bolander. 

Jeg vil gerne takke Thomas Bolander for hjælp og vejledning gennem hele 

forløbet, og David Christian Askirk for feedback p˚a rapporten. Rapporten kunne 

ikke være udført uden bogen ”Artificial Intelligence - A Modern Approach”af 

Stuart J. Russel og Peter Norvig. Og sidst, men ikke mindst et tak til Néstor 

Romeral Andrés for at have bragt brætspillet Taiji til verden. 

Lyngby, oktober 2009 

Morten Rask 

s031736

Indhold 

Summary i 

Resumé iii 

Forord v 

1 Taiji 1 

1.1 Spillets regler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

1.2 Néstors AI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 

1.3 Generele egenskaber for Taiji . . . . . . . . . . . . . . . . . . . . 4 

1.4 Spillets kompleksitet . . . . . . . . . . . . . . . . . . . . . . . . . 14 

2 Design og brugervenlighed 21 

2.1 Vurdering af Néstors Interface . . . . . . . . . . . . . . . . . . . . 21 

2.2 Design af eget Interface . . . . . . . . . . . . . . . . . . . . . . . 26 

3 Kunstig Intelligens 31 

3.1 Programmet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 

3.2 Generelle datastrukturer og metoder . . . . . . . . . . . . . . . . 35 

3.3 Heuristik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 

4 Minimax 39 

4.1 Beskrivelse af Minimax med brede-først søgning . . . . . . . . . . 40 

4.2 Beskrivelse af Minimax med dybde-først søgning . . . . . . . . . 41 

4.3 Spilgraf for 3x3 Taiji spil: . . . . . . . . . . . . . . . . . . . . . . 42 

5 Optimering af Minimax 51 

5.1 Spilgraf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 

5.2 Rotationer og spejlinger . . . . . . . . . . . . . . . . . . . . . . . 53

viii INDHOLD 

5.3 Hash funktioner . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 

5.4 Alpha-beta pruning . . . . . . . . . . . . . . . . . . . . . . . . . . 60 

6 Begrænsning af antallet af undersøgte træk 71 

6.1 Local Area . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 

6.2 Growth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 

7 Test og sammenligning af de implementerede AI’er 77 

7.1 Test af Néstor’s AI . . . . . . . . . . . . . . . . . . . . . . . . . . 77 

7.2 Test af AlphaBeta AI (udviklet af Morten Rask) . . . . . . . . . 81 

7.3 Test af LocalArea AI (designet og udviklet af Morten Rask) . . . 85 

7.4 Test af Growth AI (designet og udviklet af Morten Rask) . . . . 87 

7.5 Sammenligning af AI’erne . . . . . . . . . . . . . . . . . . . . . . 90 

8 Konklusion 91 

A Kildekode 95 

A.1 AITaijiAlphaBeta.java . . . . . . . . . . . . . . . . . . . . . . . . 95 

A.2 AITaijiGrowth.java . . . . . . . . . . . . . . . . . . . . . . . . . . 106 

A.3 AITaijiLocalAreaAB.java . . . . . . . . . . . . . . . . . . . . . . 130 

A.4 AITaijiMinimax.java . . . . . . . . . . . . . . . . . . . . . . . . . 142 

A.5 Board.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 

A.6 FigureMap.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 

A.7 Node.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 

A.8 TaijiDriver.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 

A.9 TaijiFrame.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 

A.10 TaijiHash.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 

A.11 TaijiListeners.java . . . . . . . . . . . . . . . . . . . . . . . . . . 176 

A.12 TaijiMenu.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 

A.13 TaijiModel.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 

A.14 TaijiPanels.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 

A.15 TaijiPrint.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 

A.16 TaijiSettings.java . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 

A.17 Tree.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 

B Kildeliste 231 

B.1 Hjemmesider: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 

B.2 Bøger: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

Kapitel 1 

Taiji 

Taiji er kinesisk og kan oversættes til Den Store Absolut. Taiji opfattes som det 

størst tænkelige princip, der indeholder yin og yang, hvor af alt udspringer. Yin 

og yang, lyset og mørket, modstandere, der ikke kan eksister uden hinanden. 

Deraf udspringer ideen i spillet Taiji. For hver brik du lægger, lægger du b˚ade 

en lys og en mørk side, den ene vil hjælpe dig og den anden vil kunne hjælpe 

din modstander. Taiji er designet af Néstor Romeral Andrés og udgivet af Blue 

Panther Games i 2007. Her under ses Taiji-brættet p˚a ni gange ni felter og en 

Taiji-brik:

2 Taiji 

Figur 1.1: Standard Taiji bræt p˚a 9x9 felter og en Taiji-brik. 

1.0.1 Kildemateriale for Taiji 

Da Taiji er et forholdsvis nyt spil, har det eneste tilgængelige kildemateriale 

omkring Taiji, været de officielle regler til spillet. Det er heller ikke lykkedes at 

finde et ældre spil, der i sin natur ligger s˚a tæt opad Taiji, at materiale om et 

s˚adan spil har kunne anvendes direkte p˚a Taiji eller som inspiration til skabelsen 

af en effektiv AI for spillet Taiji. 

Dette betyder at konklusioner draget omkring spillet Taiji er baseret p˚a mine 

egne undersøgelser og ideer, medmindre andet er angivet.

1.1 Spillets regler 3 

1.1 Spillets regler 

Taiji spilles af to spiller p˚a en plade af ni gange ni felter. Spillerne skiftes til at 

lægge en brik p˚a brættet. N˚ar en brik bliver lagt p˚a brættet er den endeligt lagt, 

der bliver hverken fjernet eller flyttet brikker undervejs i spillet. Brikkerne har 

en størrelse der svare til to felter p˚a spillepladen. Disse brikker har alle en lys 

og en mørk ende og er ens for begge spillere. Selvom de to spillere spiller med 

samme brikker, spiller den ene som hvid og den anden som sort. Det gælder 

for begge spillere om at bygge de to største figurer i sin farve. En figur best˚ar 

af sammenhængende felter i én farve. To felter skal ligge opad hinanden enten 

lodret eller vandret for at kunne siges at hænge sammen, diagonalt tæller ikke. 

Scoren tælles op for hver spiller ved at tælle antallet af felter, der indg˚ar i spillerens 

to største figurer. Den spiller der har den højeste score, n˚ar der ikke kan 

lægges flere brikker, har vundet. Et eksempel p˚a et afsluttet spil kan se s˚aledes 

ud: 

Figur 1.2: Afsluttet spil med score. 

I dette tilfælde er det sort som vinder med 17 point mod hvids 15 point.


1.1.1 Forskelle mellem de officielle regler og mine 

Ifølge de officielle regler skal brætstørrelsen være minimum ni gange ni, kvadratisk 

og side længden skal være p˚a et ulige tal. Jeg ser derimod p˚a alle 

brætstørrelser, med lige sider, rektangulære og mindre end ni gange ni. 

De officielle regler siger ogs˚a at et spil, hvor scoren ender lige, tæller som en 

sejr til sort. Som udgangspunkt i denne opgave ser jeg p˚a et lige resultat som 

et uafgjort resultat. Det vil undervejs blive set p˚a hvilke forskelle dette har for 

spillet. 

1.2 Néstors AI 

Néstor skaberen af Taiji har selv lavet en AI til spillet med fire sværhedsgrader. 

Néstor har dog ikke oplyst hvordan disse AI er lavet og der vides derfor 

hvordan de faktisk fungerer. P˚a den højeste sværhedsgrad bruger AI’en godt og 

vel 30 sekunder p˚a at beregne sit træk. Beregningstiden bliver dog lavere som 

spillet nærmere sig sin afslutning, og de mulige træk bliver færre. Selvom programmet 

bruger forholdsvis megen computerkraft - deraf den forholdsvis lange 

beregningstid - er det muligt for en rutineret Taiji-spiller at sl˚a af den kunstige 

intelligens og s˚a endda rimeligt overbevisende. Efter selv at have arbejdet 

med spillet gennem længere tid lykkedes det mig at sl˚a Néstors AI p˚a højeste 

sværhedsgrad med scoren 19-8. 

1.3 Generele egenskaber for Taiji 

Der er et begrænset antal træk i ét Taiji-spil. Dette skyldes, at der hverken fjernes 

eller flyttes brikker undervejs i spillet og det er derfor begrænset hvor mange 

træk, der kan fortages i et spil. Antallet af brikker, der kan lægges bestemmes 

fra start af brætstørrelsen, men som spillet skrider frem vil dette antal oftest 

falde yderligere, da spillerne kun kan lægge deres brikker som dækker to felter, 

s˚a nogle de fri felter p˚a brættet bliver uanvendelige.

1.3 Generele egenskaber for Taiji 5 

1.3.1 Maksimum antal træk 

Da der hverken fjernes eller flyttes brikker undervejs i spillet, er spillets længde 

udelukkende styret af hvor mange brikker det er muligt at lægge p˚a brættet. 

Hver brik fylder to fletter og spillepladen er normalt er p˚a 9 gange 9 felter. 

Dette betyder at det maksimale antal brikker der ville kunne lægges og dermed 

det maksimale antal træk, vil være brættets størrelse divideret med brikkernes 

størrelse. I tilfælde af decimaltal vil der naturligvis skulle rundes ned, da det 

ikke er tilladt at lægge halve eller p˚a anden m˚ade delte brikker. For en standardspilleplade 

betyder dette at spillet vil strække sig over maksimalt 40 træk. 

Alts˚a ni gange ni divideret med to og rundet ned ((9·9)/2 = 81/2 = 40, 5 ∼ 40). 

Brætlængde x Brætbredde / 2 ≥ antallet af træk 

Som spillet skrider frem kan det maksimale antal tilbageværende træk falde. 

Selvfølgelig vil antallet af træk blive reduceret med en for hver brik der bliver 

lagt. Derudover vil nogle træk tage pladsen for mere end en brik. Dette sker n˚ar 

brikker placeres s˚aledes, at de efterlader tomme omr˚ader der ikke er store nok 

til at en brik kan placeres i dem. Ud fra dette er det muligt undervejs i spillet 

at beregne et opdateret og derved mere præcist upper-bound for antallet af 

tilbageværende træk. Denne nye beregning tager udgangspunkt i den foreg˚aende 

beregning og tilføjer en reducering af antal af træk baseret p˚a antal af brikker 

p˚a brættet og antal af tomme omr˚ader, hvor det ikke længere er muligt at lægge 

brikker. Da brikkerne er p˚a et gange to felter, vil et frit omr˚ade der ikke længere 

kan spilles p˚a altid kun være p˚a et enkelt flet. 

( Brætlængde x Brætbredde / 2) - antallet af træk - ( enkeltst˚aende frie felter 

/ 2 ) ≤ tilbageværende træk 

eks: 

(4 x 4 / 2) - 3 - (1 / 2) = 4,5 

Figur 1.3: 4x4 Taiji-plade med 3 brikker.


Alts˚a kan der maksimalt fortages yderligere 4 træk. 

1.3.2 Minimum antal træk 

Den mindste forekomst af Taiji, hvor mængden af træk kan reduceres undervejs, 

er 3x2. Her er det muligt at reducere antallet af træk fra 3 til 2. Dette sker ved 

at brikkerne lægges s˚aledes at der opst˚ar to indelukkede tomme felter: 

Figur 1.4: 3x2 Taiji-plade afsluttet med minimum antal brikker. 

Der bruges her en brik per indelukket tomt felt. 

For 4x2 felter er det kun muligt at lave to tomme indelukkede felter: 

Figur 1.5: To 4x2 Taiji-plader afsluttet med minimum antal brikker. 

I dette tilfæde er det dog ikke muligt at skabe et tomt felt per brik, men der 

bruges stadig minimum en brik per tomt indelukket felt. 

For 3x3 felter: 

Figur 1.6: En 3x3 Taiji-plade afsluttet med minimum antal brikker.


Resultatet er her et tomt felt per brik. 

For 4x3 felter: 

Figur 1.7: To 4x3 Taiji-plader afsluttet med minimum antal brikker. 

Resultatet er igen et tomt felt per brik. 

For at bevise at det ikke er muligt at danne et tomt felt per brik, ses der p˚a det 

mest repræsentative eksempel p˚a et bræt, hvor der skal absolut mindst til for 

at danne et indelukket tomt felt, nemlig et bræt der kun har et felt p˚a den ene 

led: 

Figur 1.8: En vilk˚arligt lang og en høj Taiji-plade med minimum antal brikker. 

Her er det tydeligt at der skal en brik til for at danne et nyt indelukket tomt 

felt. Hvis det forsøges med færre brikker, vil hulerne blive s˚a store, at der kan 

placeres brikker i dem. Det er simpelthen ikke muligt at danne tomme felter 

med mindre en brik per tomt felt. 

Derfor bliver det minimale antal træk følgende: 

Brætlængde x Brætbredde / (2 + 1) ≤ = antallet af træk 

Et standard spil, hvor brætstørrelsen er p˚a ni gange ni felter, vil derfor ikke 

være slut før minimum 27 brikker er blevet lagt p˚a brættet. 

For 9x9 felter er det muligt at lave dette eksempel p˚a et bræt med det minimale 

antal træk for denne størrelse:


Figur 1.9: Et standard Taiji-bræt afsluttet med minimum antal brikker. 

Ud fra disse antagelser er det muligt at beregne det minimale antal træk for standardbrætstørrelsen 

9x9. Det kan ses som værende blot gentagelser af mønstret 

fra brættet p˚a 2x3 felter:


Figur 1.10: Standard Taiji-brættet opdelt i stykker p˚a 3x2. 

Med denne metode er det muligt at beregne det minimale antal træk, s˚a længe 

3 g˚ar op i enten højden eller bredden af brættet. Det er dog ikke et krav, at 3 

skal g˚a op i højden eller bredden, for at det er muligt at opn˚a et tomt felt per 

brik. Men da et tomt felt og en brik optager 3 felter, er det et krav at 3 g˚ar op 

i det samlede antal felter, før dette er muligt. 

X · Y = Z · 3 ⇔ 

X · Y 

3 

= Z ⇔ X 

3 

= Z 

Y 

3 skal g˚a op i X før X/3 kan blive et helt tal. Er dette ikke tilfældet skal 3 g˚a op 

i Y for at kunne matche X antal tredjedele p˚a den anden side, da 3 er et primtal 

og brøken derfor ikke kan reduceres yderligere. 

Det er alts˚a kun muligt at opn˚a det minimale antal træk, hvis 3 g˚ar op i enten 

højden eller bredden. Dette vil ogs˚a kunne ses i formlen i form af decimaltal. 

I disse tilfælde vil formlen for det minimale antal træk ikke give et helt tal, men 

det er ikke helt enkelt om dette resultat s˚a skal rundes op eller ned. Her er nogle 

eksempler: 

1x5: Formlen giver her 1,67, mens det er ikke muligt at afslutte spillet med 

mindre end to brikker. 

4x4: Her giver formlen 5,3, hvilket normalt ville være et tal der rundes ned, men 

det er ikke muligt at afslutte et spil af denne størrelse med mindre end 6 brikker.


Der er dog en række special tilfælde, hvor det med en brik er muligt at danne 

to enkeltst˚aende tomme felter, et p˚a hver side af brikken. Disse er bræt p˚a 1 

gange 3 · X + 1 og selvfølgelig ogs˚a 3 · X + 1 gange 1. 

Det første eksempel her p˚a er 4x1. Her vil en brik, der placeret i midten af dette 

bræt, resultere i to uanvendelige tomme felter: 

Figur 1.11: 4x1 Taiji-bræt afsluttet med minimum antal brikker. 

Resultatet af formlen bliver 1,33, men det er muligt at afslutte spillet med en 

enkelt brik. 

For et større tilfælde som f.eks. 13 gange 1: 

Figur 1.12: 13x1 Taiji-bræt afsluttet med minimum antal brikker. 

Resultatet af formlen bliver her 4,33, men igen er det muligt at afslutte spillet 

med kun 4 brikker. 

Det er en mulighed at runde resultaterne op og se p˚a disse tilfælde som undtagelser 

p˚a formlen, men da formelen skal bruges som et lower-bound estimat, 

vil det være en udmærket løsning altid at runde resultatet ned, da det ikke vil 

være et problem at nogle brætstørrelser ikke vil kunne n˚a deres beregnede minimum 

for antallet af træk. Det ville være langt mere problematisk, hvis nogle 

brætstørrelser kunne afsluttes før forventet. 

1.3.3 Maksimum antal point 

Teoretisk set vil det størst mulige antal point n˚as ved at forbinde alle brikker af 

en farve i en eller to figurer. Antallet vil svare til halvdelen af brættets størrelse, 

da den anden halvdel selvfølgelig vil g˚a til modstanderens farve. Her skal antallet 

naturligvis ogs˚a rundes ned til et helt tal. I praksis viser dette sig ogs˚a at være 

tilfældet. Dette forekommer især ved sm˚a plader. Ved det ekstreme tilfælde af


den minimale størrelse p˚a to gange to felter, ville begge spiller altid n˚a topscoren 

p˚a to points uanset hvordan de bære sig ad, enten i form af to figurer p˚a hvert 

et felt eller en figur p˚a to felter. 

Figur 1.13: Mulige afslutninger for et Taiji-bræt p˚a 2x2. 

Dette gør ogs˚a denne minimale brætstørrelse højst uinteressant at arbejde med. 

Men uanset størrelsen vil det altid være muligt at sammensætte et spil der giver 

den maksimale score for en eller begge spillere. Dette er muligt ved at fylde et 

bræt ud s˚aledes, at alle felter for hver farve er del af en af de to største figurer 

for farven. Det er selvfølgelig ogs˚a nødvendigt, at brikkerne ligger s˚a de ikke 

skaber uanvendelige tomme felter. Det kan f.eks. gøres s˚aledes: 

Figur 1.14: Eksempel p˚a maksimal score for begge spiller. 

Det kræver lidt mere variation at opn˚a den højeste score for begge spiller, n˚ar 

brættets sider er ulige, men dette kan ogs˚a opn˚as:


Figur 1.15: Eksempel p˚a maksimal score for begge spiller p˚a en standardplade. 

Disse og lignende mønstre kan altid anvendes til at lave den maksimale score, 

hvis begge spiller g˚ar efter det. Det kan f.eks. gøres ud fra denne form: 

Figur 1.16: Formel for creation af bræt med max point med minimum en lige 

side.


Figur 1.17: Formel for creation af bræt med max point med ulige sider. 

1.3.4 Sammenfatning af de generelle træk 

Det er muligt fra spillets start at beregne et minimum og maksimum for hvor 

mange træk spillet vil strække sig over. Minimum vil være en hjælpende faktor 

i at bedømme spillets kompleksitet. Det samme gælder maksimum, men det vil 

f.eks. ogs˚a kunne anvendes til at bedømme hvorn˚ar det bliver muligt at beregne 

en fuldstændig løsning, efter et spil er g˚aet i gang. 

Det viste sig at scoren for de to spillere kunne blive s˚a høj, som det overhovedet 

kunne forventes, nemlig højden gange bredden divideret med to, da hver brik 

fylder to felter og tilføjer b˚ade et sort og et hvidt felt. Hvor mængden af træk 

forholdsvist nemt kan beregnes undervejs i et spil, er det en langt mere krævende 

opgave at beregne scorens muligheder inde i spillet, da denne afhænger af alle 

brikkerne og deres placeringer, ikke kun antallet af brikker og antallet af uanvendelige 

felter p˚a brættet. Det ville ellers give mulighed for at stoppe spillet, 

n˚ar f.eks. den ene spillers mulige maksimum bliver overg˚aet af den anden spillers 

nuværende score. Disse værdi kunne ogs˚a bruges af en kunstig intelligens, 

ved at forsøge at holde sin mulige maksimum score s˚a høj som mulig og øge sin 

minimums score, samtidig med at reducere modstanderens mulige maksimum 

score og holde den minimums scoren nede.


1.4 Spillets kompleksitet 

Standard størrelsen for et spil Taiji er p˚a ni gange ni felter. Dette lyder m˚aske 

ikke til at være s˚a stort, men sammenlignes det f.eks. med skak er det et felt 

mere p˚a hver led og selvom antallet af træk er begrænset i Taiji, s˚a er der færre 

restriktioner p˚a hvilke træk, der kan foretages. Forsker har estimeret antal af 

lovlige spilstadier i skak til at være 10 43 . 1 

1.4.1 Upper-bound estimat for antal af spilstadier 

Et forholdsvist simpelt upper-bound estimat kan laves ved at se p˚a antallet af 

mulige spilstadier, hvis restriktionerne af brikker fjernes, s˚aledes at der er ni 

gange ni felt som hvert kan p˚atage sig værdierne sort, hvid og tomt uafhængigt 

af hinanden. I s˚a fald bliver antal af mulige spilstadier antallet af værdier per 

felt opløftet i antallet af felter. 

3 81 = 4, 43 · 10 38 

Brikker giver vise restriktioner og derved reduceres dette tal. Restriktionen at 

der skal være minimum et hvidt felt opad hvert sort felt og minimum et sort 

felt opad alle hvide felter, er meget svær at indføre. 

En anden restriktion, der ogs˚a kommer af brikkernes udformning, er at der 

for alle spilstadier skal være lige mange sorte og hvide felter. Denne er ogs˚a, i 

modsætning til forrige restriktion, uafhængig af brættets form, om brættet er 9 

gange 9 eller 81 gange 1 er ligegyldigt. 

P˚a et bræt med et enkelt felt, hvor der normalt vil være tre kombinationsmuligheder, 

vil den eneste mulighed med lige mange hvide og sorte felter, være 

et tomt bræt. For et bræt med to felter, hvor der normalt vil være ni kombinationsmuligheder, 

vil der være tre gyldige kombinationer, et tomt bræt, to 

brætter med et sort og et hvidt felt. 

Herunder ses en tabel over antallet af kombinationsmuligheder for op til 6 felter 

og antallet af kombinations muligheder med og uden restriktionen, at der skal 

være lige mange sorte og hvide felter: 

1 64! 

Tallet kommer af estimatet 

32!·8! 2 ·2! 6 ≈ 1043 som er givet af Claude E. Shannon i ”Programming 

a Computer for Playing Chess”, Phil. Mag. 41 (1950) 256-275).

1.4 Spillets kompleksitet 15 

Antal felter Kombinationer Efter Restriktionen Procentdel 

1 3 1 33,3% 

2 9 3 33,3% 

3 27 7 25,9% 

4 81 19 23,5% 

5 243 49 20,2% 

6 729 137 18,8% 

Tabellen viser at procentdelen af gyldige kombinationsmuligheder falder som 

antallet af felter stiger. Derfor kan antallet af spilstadier i alle tilfælde roligt reduceres 

med en tredjedel. Ligeledes kan antallet af spilstadier for standardbrættet 

p˚a ni gange ni felter roligt reduceres til en 20% . Derved kan upper-bound 

estimatet reduceres fra 4,43 · 10 38 til 10 38 . 

1.4.2 Lower-bound estimat for antal af spil forløb 

I dette afsnit estimeres der et lower-bound for antal spil forløb, eller kombinationsmuligheder 

for trækkene gennem et spil. 

I Taiji er der med et bræt p˚a ni gange ni felter maksimalt 40 træk, da dette er 

det maksimale antal brikker, der kan lægges. Der er ni gange ni felter at gøre 

godt med p˚a brættet og hver brik fylder to felter. 

9 · 9 

2 

= 40, 5 

Og det er naturligvis ikke muligt at lægge en halv brik. Der vil ikke altid være 

40 træk, da det er muligt at lægge brikkerne s˚aledes at de efterlader fri felter 

hvor det ikke er muligt at f˚a plads til en brik. Dette forekommer n˚ar et enkelt 

tomt felt omkredses af brikker og evt. brættets kanter. 

Figuren her under illustrerer de mulige træk:


Figur 1.18: Alle trækmuligheder for et standardbræt. Hver streg repræsentere 

en brik og de to m˚ader, som brikken kan vende p˚a. 

Der er ni gange ni felter. Hver sort streg illustrere to mulige træk, nemlig de træk 

som kan laves p˚a de to felter stregen indg˚ar i. En sort-hvid brik lagt vandret, 

hvis stregen er vandret, og lodret, hvis stregen er lodret og samme brik med 

samme placering blot vendt 180 grader. 

I dette tilfælde er der i alt 144 sorte streger (8x9 vandrette og 9x8 lodrette), med 

andre ord er der 288 mulige træk. Til sammenligning er der i skak 20 muligheder 

for første træk (otte bønder med to mulige træk hver og to springer med hver 

to mulige træk). 

N˚ar der lægges en brik p˚a brættet udelukkes der maksimalt 14 mulige træk, da 

en brik p˚a to felter højst vil overlappe 7 streger: 

Figur 1.19: Repræsentation af det største antal træk en brik kan udelukke. 

Det minimale antal mulige træk, der kan udelukkes vil, være 2. Dette vil kun 

ske i tilfælde hvor alle felter omkring brikken er optaget:


Figur 1.20: Repræsentation af det mindeste antal træk en brik kan udelukke. 

Et lower-bound resultat kan udregnes ved at tage de 288 mulige træk og gange 

dem sammen med de efterfølgende træk, hvor antallet af mulige træk hver gang 

reduceres med de maksimale 14 træk per tur: 

eller mere præcist: 

288 

14 

≈ 20, 57 

20, 57! · 14 20,57 ≈ 5, 208 · 10 42 

288·274·260·246·232·218·204·190·176·162·148·134·120·106·92·78·64·50·36·22·8 

≈ 1, 035 · 10 43 

Dette minimum vil dog være et godt stykke under det reelle antal mulige trækkombinationer. 

Dette lower-bound estimat resulterer f.eks. i at der kun er i alt 

21 træk, hvor det tidligere er blevet vist at der minimum vil blive foretaget 27 

træk i et spil Taiji p˚a et bræt med ni gange ni felter. 

Udover at lower-bound estimat har færre træk end et rigtigt spil, reducere det 

ogs˚a antallet af mulige træk med de maksimale 14 træk per tur. At reducere 

antallet af muligheder med 14 er kun muligt, n˚ar en brik kan lægges uden at 

have nogen restriktioner omkring sig. Dette forventes med et bræt p˚a ni gange 

ni felter højst at kunne gøres 11 gange, som det ses i eksemplet herunder:


Figur 1.21: Denne figur viser en af m˚aderne de 11 brikker kan lægges, hvor de 

hver især reducerer antal af mulige træk mest. 

Efter at de 11 brikker er blevet lagt, er det ikke længere muligt at finde en 

placering hvor en brik kan reducere antallet af mulige træk med mere end 12. 

Og der kan ikke foretages mange træk før det bliver mindre end 12. 

1.4.3 Estimat af antallet af mulige trækkombinationer i et 

gennemsnits spil: 

For at lave et estimat p˚a gennemsnits antallet af mulige trækkombinationer i 

et standard spil, bør b˚ade antallet af træk og antallet af reducerede muligheder 

per træk ligge s˚a tæt p˚a gennemsnittet som muligt. 

Gennemsnits antallet af træk kan forventes at ligge lige mellem det maksimale 

og det minimale antal af træk! 

27 + 40 

2 

= 33, 5 

Og reduceringen af træk per træk kan ogs˚a forventes at ligge lige mellem det 

maksimale og minimale. 

14 + 2 

2 

= 8 

288 

= 36 

8 

Med en reducering af 8 per træk bliver der i alt 36 træk. Hvilket er et stykke 

fra de gennemsnitlige 33,5 træk. Alternativ kan der reduceres med 9 muligheder 

per træk, hvilket resultere i 32 træk. Estimatet af træk bliver med en reducering 

p˚a 8 følgende: 

36! · 8 36 = 1, 207x10 72


Estimatet af træk bliver med en reducering p˚a 9 følgende: 

32! · 9 32 = 9, 035x10 65 

Et mere præcist estimat vil være at starte med et en høj reducering og sænke 

den under vejs s˚a den ender ved minimum efter omkring en 33-34 træk. 

1.4.4 Sammenfatning af spillets kompleksitet 

Selvom Taiji’s regler er meget simple og hurtige at sætte sig ind i, sammenlignet 

med f.eks. skak, er Taiji meget tæt p˚a kompleksitets niveauet for skak, f.eks. 

n˚ar det kommer til antallet af mulige brættilstande, hvor de ikke er langt fra 

hinanden. Taiji kan ogs˚a meget hurtigt overg˚a skak ved blot at øge dimensionerne 

p˚a Taiji-brættet. Ifølge de officielle regler er den næste godkendte brætstørrelse 

11 gange 11, da side længderne ifølge dem skal være ulige. Hvor ubber-bound 

estimatet for 9 gange 9 l˚a omkring 10 38 vil det for 11 gange 11 ligge omkring 

10 57 2 , hvilket er langt over det estimerede 10 43 for skak. Skak vil dog via sine 

muligheder for 

Muligheden for at estimere antallet af tilbageværende træk en en vigtigt faktor 

for at optimere performance uden tab af kvalitet, da antal tilbageværende træk 

kan bruges til at estimere hvor meget regnekraft der skal til for at regne et 

bestemt antal generationer ned i spiltræet. Jo færre antal træk der er tilbage, 

jo færre mulige træk vil der være tilbage, og jo længere vil det være muligt 

at regne ned i spiltræet indenfor en rimelig tid. Det gør det samtidig muligt 

beregne grundigst p˚a de sidste træk i spillet uden at ødelægge performance, og 

de sidste træk er ofte afgørende for at vinde spillet. 

2 3 11·11 reduceret med 80%

20 Taiji

Kapitel 2 

Design og brugervenlighed 

Da der skal arbejdes meget med programmet gennem forløbet, er det vigtigt 

at det har en god brugerflade som er hurtig, brugbar og nem at anvende. Dog 

behøver ikke nødvendigvis nem at tilegne sig, da det ville blive anvendt rigeligt 

s˚a en hurtig og smidig anvendelse for en erfaren bruger er vigtigere, end at 

brugerfladen er let at g˚a i gang med som ny bruger. 

2.1 Vurdering af Néstors Interface 

Inden jeg designer og udvikler min egen brugerflade vil jeg kigge p˚a hvordan 

Néstor Romeral Andrés har lavet sin og gøre mig nogle erfaringer ud fra den. 

2.1.1 At starte et spil: 

For at starte et spil ˚abnes menupunktet ”Game”og ”1-Player”vælges.

22 Design og brugervenlighed 

Figur 2.1: Néstor’s brugerflade n˚ar ”Game”er ˚aben. 

Her bliver brugeren s˚a mødt med en menu, hvor man kan vælge sin farve og en 

modstander, i form af de fire sværhedsgrader for Néstor’s egen AI.

2.1 Vurdering af Néstors Interface 23 

Figur 2.2: Opsætningen for starte et nyt spil. 

Dette fungerer godt, men jeg ser ingen grund til at undlade at have et spil klar til 

start n˚ar programmet ˚abnes. Et spil mod en sort AI p˚a et af de lave niveauer vil 

være at foretrække, da en s˚adan ikke vil lave nogen beregningen før spilleren selv 

lægger den først brik, og fordi de lave niveauer af AI svarer forholdsvis hurtigt 

efter spilleren har foretaget sit træk. Det kan tænkes at Néstor Romeral Andrés 

har undladt dette med vilje for at lede brugeren op i Game menuen og derved 

gøre brugen opmærksom p˚a at der ogs˚a er en ”2-Player-funktion, der spilles over 

nettet, hvilket kan være mere spændende for brugeren. Hvorfor der dog ikke er 

en 2-Player funktion, for to spillere ved samme computer kan man dog undre 

sig over. Der er selvfølgelig den mulighed, at det er et ønske fra Néstor Romeral 

Andrés’ side om at f˚a brugeren til at anskaffe sig den fysiske version af spillet. 

2.1.2 Placering af brikker: 

N˚ar spillet er i gang, placeres en brik ved at bevæge musen hen over brættet 

indtil man har den rette placering. Brikken kan hele tiden ses p˚a brættet og har 

en hvid markering rundt om sig, der gør det tydeligt at skelne den fra andre 

brikker p˚a brættet. Det kan dog være lidt besværligt at f˚a placeret brikken 

korrekt. Brikken vendes lodret eller vandret efter om musen lige er passeret 

gennem en vandret eller lodret væg mellem felterne, hvilket ikke altid virker lige


naturligt. Skal brikken vendes s˚a hvid og sort skifter plads, er det nødvendigt 

at bruge højre musetast, hvilket formentligt kræver et kig i ”Help”og menuen 

”Controls”for at gennemskue. N˚ar brikken først er placeret kræver det kun et 

enkelt klik p˚a venstre musetast at lægge brikken. Dette kan dog give anledning 

til frustration, da der ikke skal meget til at komme til at lægge en brik ved en 

fejl, og spilles der samtidigt mod højeste niveau AI, kan man sidde og ærgre sig 

over fejl trækket i et halv til et helt minut før det bliver éns tur igen. 

2.1.3 Information p˚a displayet: 

Displayet viser to væsentlige ting, hvilken farve spilleren selv har i form af et 

felt i den farve i nederste højre hjørne og s˚a fortæller en kort tekst om det er 

spillerens tur eller om AI’en er ved at beregne sit træk og hvor langt den er n˚aet 

ved hjælp af en lille bar ved siden af. 

Der vises ingen score undervejs i spillet, men n˚ar spillet afsluttes viser et popop 

vindue den endelige stilling og vinderen, derudover vises størrelse p˚a de to 

største figurer for hver spiller i form af et tal placeret p˚a selve figurerne.

2.1 Vurdering af Néstors Interface 25 

Figur 2.3: Eksempel p˚a afsluttet spil med score vist p˚a figurerne. 

2.1.4 Det overordnede indtryk: 

Néstor Romeral Andrés’ brugerflade er p˚a alle omr˚ader god, n˚ar det gælder om 

at lærer spillet at kende. Brikkernes form og hvor de kan lægges vises fint, n˚ar 

musen bevæges hen over brættet. N˚ar spillet er afsluttet vises scoren p˚a figurerne, 

s˚a det er nemt at se og forst˚a, hvor den endelige resultat kommer fra. Den 

placerer ogs˚a to plus’er p˚a den brik som AI senest har placeret, hvilket gør det 

nye træk lettere at finde, hvilket ofte er nødvendigt for de høje sværhedsgrader, 

da spilleren ofte har mistet interessen inden AI bliver færdig med at beregne sit 

træk. 

Fra et lærings synspunkt er Néstor’s interface glimrende, men n˚ar det kommer 

til effektivitet kunne man ønske sig mere. Mulighederne n˚ar spillet derimod først 

er startet er stort set ikke eksisterende, du kan foretage dine træk og vente p˚a 

modstanderens, og evt. starte et nyt spil, hvis du bliver træt af det. Der er ingen


muligheder for at fortryde træk eller g˚a frem og tilbage i spillet. Det ville ogs˚a 

være rart at kunne gemme spillet undervejs, n˚ar de netop bliver s˚a langvarige 

ved den højeste sværhedsgrad. 

2.2 Design af eget Interface 

Min egen brugerflade er designet med henblik p˚a langvarigt brug med test af 

AI’er som hovedform˚al, ikke at lære brugeren spillet hurtigst muligt eller at 

skabe den ultimative spil oplevelse. 

2.2.1 At starte et spil: 

Et spil kan startes op med indstillinger opsat i programmet blot ved at klikke 

p˚a spilbrættet. Enten vil brugeren begynde med at sætte sin brik eller ogs˚a vil 

en AI begynde at beregne sit træk. 

Det er ogs˚a muligt at ændre p˚a indstillingerne gennem menuen, men disse valgmuligheder 

er begrænsede og anvendes hovedsageligt til at vise programmet 

frem. I testsammenhæng vil ændringerne af indstillingerne blive foretaget i selve 

koden. Spillet med disse indstillinger vil s˚a være tilgængeligt med det samme 

programmet ˚abnes og det vil ikke være nødvendigt at skulle igennem menuerne 

for at starte det ønskede spil. 

For at starte et nyt spil op med samme indstillinger kan dette hurtigt gøres i 

menuen. Der vælges blot ”New Game”og ”Same settings”

2.2 Design af eget Interface 27 

Figur 2.4: Min brugerflade n˚ar ”Game”er ˚aben og ”New Game”markeret. 

Vælges ”Change settings”mødes brugeren med denne menu, hvor bruger kan 

vælge at spille menneske mod et menneske p˚a samme computer eller mod en af 

de tre hoved AI’er. 

Figur 2.5: Opsætningen for starte et nyt spil med nye indstillinger.


2.2.2 Placering af brikker: 

Placering af brikker udføres ved at klikke p˚a et frit felt, hvor man ønsker at 

placere sin farves halvdel af brikken, og derefter klikker man p˚a et frit felt ved 

siden af for at placere halvdelen med modstanderens farve. Foretages andet klik 

et sted hvor trækket bliver ugyldigt annulleres det og begge halvdele fjernes 

automatisk igen. Et ugyldigt træk kan ogs˚a bruges til at annullere et træk, som 

man ikke ønskede at lave, hvis man kun har f˚aet placeret den ene halvdel. At 

klikke p˚a samme felt en gang til er en hurtigt m˚ade at annullere et halvt træk 

p˚a. 

Denne m˚ade at udføre trækkene p˚a er yderst hurtigt og nem at anvende, n˚ar 

man først er blev vandt til den. Og det at et enkelt fejlagtigt klik ikke afgør et 

træks skæbne er ofte yderst velkomment. 

2.2.3 Information p˚a displayet: 

P˚a displayet vises flere informationer forholdsvist diskret. Under brættet er der 

et felt med et tal. Tallet viser hvor mange træk, der er blevet foretaget. Desuden 

fortæller baggrundsfarven her om det er hvid eller sorts tur, da den har en 

mørkere nuance ved sort spillers træk end n˚ar der er hvid der st˚ar for tur. 

P˚a venstre side af brættet st˚ar et hvidt tal. Dette tal viser det nuværende antal 

point for den hvide spiller, mens det sorte tal p˚a højre side viser antal af point 

for den sorte. Hvid er placeret i venstre side, da vi læser fra venstre mod højre 

og det er hvid der under de officielle regler starter.

2.2 Design af eget Interface 29 

Figur 2.6: Eksempel p˚a afsluttet spil med score vist p˚a figurerne. 

2.2.4 Andre funktioner: 

Der er i bunden af vinduet to knapper, hvor brugeren kan g˚a frem og tilbage 

i spillet blandt de træk der er blevet foretaget. G˚ar brugeren tilbage i spillet 

og ændrer et træk, fjernes de forrige træk fremad selvfølgelig da disse højst 

sandsynligt ikke længere er korrekte. Disse knapper giver mulighed for bedre at 

analysere spillets gang og kan ogs˚a benyttes efter det har n˚aet sin ende. 

Under menupunktet ”Game”er der ogs˚a mulighed for at gemme spillet. Det 

er kun brættet og dets historie der gemmes, alts˚a den nyeste bræt og alle de 

foreg˚aende som har ledt op til det. Indstillingerne for hvem, der spiller hvad 

gemmes ikke. Hentes spillet vil de spillere der var sat til at spille inden spillet 

blev hentet stadig være gældende. Dette er ikke s˚a heldigt set fra et normalt spils 

synsvinkel, da dette giver brugeren mulighed for at snyde ved f.eks. at bytte om 

p˚a farverne for de to spiller. Men fra et testsynspunkt er dette ganske udmærket, 

da der kan undersøges hvordan forskellige AI’er takler den samme situation. 

Bemærk ogs˚a at vinduet er større, det er for at det skal være muligt at anvende 

større brætstørrelser, uden at brikkerne bliver alt for sm˚a. 

Det skal ogs˚a nævnes at AI’erne først begynder deres beregning, n˚ar brugeren 

klikker en gang p˚a brættet efter placeringen af sin egen brik. Dette er lidt


upraktisk, n˚ar der spilles mellem et menneske og en AI. N˚ar det er to AI’er 

der sættes op mod hinanden, bliver det dog nemmere at følge med i spillet, da 

brugeren selv kan bestemme, hvor hurtigt spillet skrider frem. Ønskes flere træk 

taget hurtigst muligt, er det blot at klikke det ønskede antal gange, og s˚a fortsætter 

AI’erne op til dette antal træk. Dette sker selvom beregningen af første 

træk ikke er blevet gjort færdig inden bruger er færdig med sine klik.

Kapitel 3 

3.1 Programmet 

Kunstig Intelligens 

Herunder er en kort oversigt over programmet og dets opbygning.

32 Kunstig Intelligens 

3.1.1 TaijiDriver: 

Figur 3.1: Oversigtsdiagram for programmet. 

TaijiDriver er main-metoden, der konstruerer TaijiFrame og viser den. 

3.1.2 TaijiFrame: 

TaijiFrame er rammen, som indeholder de dele, der bliver vist p˚a skærmen. Det 

er ogs˚a her dimensionerne for brættet ligger gemt. 

3.1.3 TaijiListeners: 

TaijiListeners h˚andtere opfangelsen af museklik indenfor vinduet.

3.1 Programmet 33 

3.1.4 TaijiMenu 

TaijiMenu h˚andterer dropdown menuen for menupunktet ”Game”. 

3.1.5 TaijiSettings: 

TaijiSettings indeholder menuen for ”Change settings”ved start af nyt spil, hvor 

det er muligt at ændre opsætning for hvilken AI brugeren spiller mod. 

3.1.6 TaijiPanels: 

TaijiPanels tegner selve brættet og omr˚aderne omkring, der f.eks. viser den 

nuværende score. 

3.1.7 TaijiModel: 

Hvor TaijiFrame st˚ar for at styre brugerfladen, at tegne brættet, vise menuerne 

og h˚andtere brugerens kommunikation med programmet, tager TaijiModel sig 

af selve spillet. TaijiModel h˚andterer brættet, hvilke træk, der foretages p˚a det, 

og kalder de forskellige kunstige intelligenser. 

3.1.8 TaijiHash: 

TaijiHash indeholder hashfunktionerne, som de forskellige AI’er har adgang til 

gennem TaijiModel. 

3.1.9 TaijiPrint: 

TaijiPrint inderholder flere forskellige funktioner til effektivt ud skrive forskellig 

data, der kan være relevant n˚ar forskellige dele af de kunstige intelligenser testes.


3.1.10 FigureMap: 

FigureMap bruges til at kortlægge de største figurer for begge farver s˚aledes at 

det bliver muligt at beregne scoren for hver spiller. Andre funktioner, der bruges 

til at konvertere almindelige taijibræt til figurbræt, som fortæller hvilke felter, 

der hænger sammen, findes ogs˚a her. 

3.1.11 Board: 

Board indeholder selve brættet og spilhistorien op til det nyeste træk og derudover 

funktioner, der har at gøre med h˚andtering af brættet. 

3.1.12 Node: 

Node indeholder datastrukturen for Nodes, som anvendes i alle AI’erne. 

3.1.13 Tree: 

Tree indeholder datastrukturen for et spiltræ. Denne benyttes dog kun i den 

først prototype AI, AITaijiMinimax. 

3.1.14 AITaijiMinimax: 

AITaijiMinimax er prototypen lavet for at komme i gang med at lave kunstig 

intelligens til Taiji, effektivitets niveauet for denne AI er langt under de senere 

AI’er. Den benytter sig som den eneste af en bredde-først minimax søgning. 

3.1.15 AITaijiALphaBeta: 

En kunstig intelligense, der anvender minimax algorithmen med alpha beta pruning 

til at søge ned i spilgrafen for at finde et træk.

3.2 Generelle datastrukturer og metoder 35 

3.1.16 AITaijiPureAlphaBeta: 

Fungere som AITaijiAlphaBeta uden at tage højde for rotationer og spejlinger. 

Denne AI er lavet til test form˚al, hvor dens resultat kan holdes op imod resultater 

for AlphaBeta AI’en. 

3.1.17 AITaijiMinimax2: 

Fungere som end dybde først minimax søgning, ved at deaktivere alpha beta 

pruningen i AlphaBeta AI’en. Denne AI anvendes ligeledes til test form˚al, hvor 

den holdes op mod resultaterne fra AlphaBeta AI’en. 

Da AITaijiPureAlphaBeta og AITaijiMinimax2 begge blot er versioner af AI- 

TaijiAlpha, med henholdvis alpha beta pruning og h˚andteringen af rotationerne 

og spejlinger deaktiveret. Er disse to ikke taget med i kildekoden. 

3.1.18 AITaijiLocalArea 

Denne kunstige intelligens benytter sig af samme metoder som AlphaBeta AI’en, 

men begrænser sig selv til et lille søgeomr˚ade omkring det seneste træk. 

3.1.19 AITaijiGrowth 

Growth AI’en benytter sig af en dybde-først minimax søgning. Men i stedet for 

at lade alle de mulige træk prøves af, lader den træk mulighederne vokser ud 

fra de største figurer p˚a brættet. 

3.2 Generelle datastrukturer og metoder 

I dette afsnit beskrives nogle af de vigtigste datastrukturer og metoder, som g˚ar 

igen gennem mange af de kunstige intelligenser.


3.2.1 Nodes: 

Noderne bruges til at holde styr p˚a informationerne om hvert enkelt spilstadie. 

I en node gemmes spilbrættet med alle brikkerne. Der gemmes ingen information 

om grænserne for de enkelte brikker, der gemmes blot hvor der er sorte, 

hvide og frie felter. Det betyder at der ikke er nogen bestemt struktur gemt i 

brættet om hvordan, spillet n˚aede dette punkt. Denne anonymitet er en fordel, 

da det er mere end en rute til hver eneste brætsituation i spillet, og brættets 

fortid derfor ikke m˚a være bundet til en bestemt forgænger. I noden kaldes det 

to-dimensionelle array hvor brættilstanden gemmes for nodeBoard. 

P˚a trods af brættets p˚akrævede anonymitet er koordinatorerne til det træk, der 

skabte Noden, gemt i fire variabler. wc, wr, bc, br, kolonnen for det hvide felt, 

rækken for det hvide felt, kolonnen for det sorte felt og rækken for det sorte felt 

for brikken, der blev lagt for at komme til dette stadie. Disse koordinatorer er 

et levn fra de første versioner, hvor der ikke blev taget højde for at flere forgænger 

kunne lede til samme spilsituation. I de nyere versionerne bliver de dog 

stadig brugt til at gemme det træk, som den kunstige intelligens finder frem til 

skal foretages. I Noden er der ogs˚a en variabel tilegnet at gemme værdien som 

heuristikken finder n˚ar Noden evalueres. Denne variabel hedder a. 

Dybden gemmes ogs˚a i Noden, under navnet d. Dybden er ligesom scoren uafhængig 

af hvilken rute, der er blevet taget for at n˚a Noden, da der skal være 

blevet lagt lige mange brikker før to brætsituationer kan være ens. 

Til slut holder to arraylister af variable længde styr p˚a hvilke forgængere og 

efterkommere Noden har. Den kaldes par for parents og den anden kaldes blot 

children. 

3.2.2 Skabelsen af efterkommere: 

Det vil i langt de fleste af de kunstige intelligenser før eller siden være nødvendigt 

at skabe alle efterkommere til en given node. Da denne proces i disse tilfælde er 

den samme, vil den blive beskrevet her. I de tilfælde hvor skabelsen af efterkommer 

foreg˚ar p˚a anden vis vil det være beskrevet i afsnittet om den p˚agældende 

AI. 

For at skabe alle efterkommerne til en Node, er det nødvendigt at foretage alle 

de træk som den p˚agældende spilleplade tillader. Dette gøres ved at gennemg˚a 

brættet fra enden til anden og lægge brikker alle de steder det er muligt. Det 

nemmeste er først at gennemg˚a brættet med vandrette brikker og hver gang der 

findes en vandret plads til en brik oprettes to Noder, en for hver led brikken 

kan vender p˚a, sort-hvid og hvid-sort. Der samme gøres derefter for alle mulighederne 

for at lægge en brik lodret. Checkes der for b˚ade lodrette og vandrette 

samtidigt opst˚ar der en masse specialtilfælde omkring to af kanterne af brættet,

3.3 Heuristik 37 

og der m˚a checkes separat for lodrette pladser langs højre side og det samme 

gælder de vandrette pladser langs bunden. 

3.3 Heuristik 

En heuristik bruges til at vurdere spillets tilstand. Heuristikken skal alts˚a kunne 

levere en værdi, som giver et indblik i hvor godt eller skidt det st˚ar til for de to 

spiller. I Taiji vil det være naturligt at anvende differencen mellem de to spilleres 

score, som heuristik. 

I tilfælde, hvor det er muligt at undersøge alle trækkombinationer til ende, er 

denne heuristik perfekt. 

3.3.1 Mulige forbedringer af heuristikken: 

Er det ikke muligt at beregne en fuldstændig løsningen, vil en heuristik, der 

tager højde for mere end blot den nuværende score, være mere anvendelig. Den 

nuværende score vil ikke nødvendigvis sige meget om hvad fremtiden vil bringe. 

F.eks er en fugl i h˚anden bedre en ti p˚a taget. Et endeligt spilstadie med et 

points forspring inden for den mulige søgedybde, vil selvfølgelig være bedre end 

en et stadie, hvor spilleren er foran med flere points, men hvor søgedybden er 

n˚aet og spilleren derfor ikke ved hvad trækkene efter vil bringe. (Søgedybden er 

hvor mange generationer man har besluttet at g˚a ned i spiltræet). Er heuristikken 

kun baseret p˚a scoren vil de 10 fugle p˚a taget blive opfattet som den bedste 

muglighed. Dette løsses ved at vinderstadier f˚ar tildelt værdien uendelig, uanset 

hvor stor eller lille forskellen i scoren s˚a er. Dette kan selvfølgelig resultere i at 

AI’en vælger en løsning, hvor den vinder med en mindre point forskel end hvad 

der var mulighed for. Dette har dog først en betydning, hvis point forskellen 

lægges til en samlet score som strækker sig over flere spil. Er dette tilfældet kan 

heuristikken modificeres til at sætte værdien for vinderstadier til uendeligt plus 

differencen i scoren mellem de to spiller, s˚a det bedste af vinderstadierne indenfor 

søgedybden kan vælges. Dette kan selvfølgelig kun gøres fordi ”uendeligt”i 

praksis blot er en værdi som er højere end noget der kan opn˚as i selve spillet. 

Det er ogs˚a muligt at forbedre heuristikken i tilfælde hvor et endeligt stadie ikke 

n˚as indenfor søgedybden. Den ene spiller kan f.eks. have en højere score, men 

være blevet lukket af for at udvide sine to største figurer yderligere, mens den 

anden kan være lidt bagud p˚a point, men have gode muligheder for at udvide 

sine største figurer og dermed komme foran. I dette tilfælde kan heuristikken 

udvides til ogs˚a at tage højde for hvor mange muligheder, der umiddelbart er for


at udvide de større figurer i spillet. Det store spørgsm˚al er her hvordan vægtningen 

skal ligge mellem scoren og mulighederne for udvidelse. Her kunne det 

være en mulighed at anvende et neuraltnetværk eller simuleret nedkøling til at 

finpudse vægtningen basseret p˚a resultater og erfaringer gennem mange spil. 

Det største problem med en heuristik, der kun tager højde for selve scoren, 

opst˚ar n˚ar den kunstige intelligens ikke har mulighed for at søge hele træet 

igennem, og der er blevet lavet to store figurer for begge spillere, som det ikke 

længere er muligt at udvide p˚a. Da det er de to største figurer der tæller 

p˚a scoren, er alle andre figurer ligegyldige indtil en indhenter den næststørste 

figur. Dette betyder at den kunstige intelligens famler i blinde indtil en figur 

som minimum overg˚ar den næststørste figurs størrelse. Har begge spiller f.eks. 

to figurer p˚a 8 point, som ikke længere kan udvides, og ellers kun figurer med 

størrelsen 2 eller mindre, vil det være nødvendigt at bringe en af disse figurer 

op p˚a størrelsen 9 før det overhovedet kan ses p˚a heuristikken. Dette ville i de 

fleste tilfælde kræve flere træk end den kunstige intelligens kan regne frem p˚a 

et større bræt. Dette vil simpelthen resultere i at alle træk vil f˚a tildelt samme 

værdi og derfor vil den kunstige intelligens vælge et fuldstændigt tilfældigt træk. 

Løsningen er selvfølgelig at ændre heuristikken s˚a den ikke kun ser p˚a de største 

figurer. Som nævnt tidligere kunne heuristikken ogs˚a se p˚a antallet af mulige 

udvidelser p˚a de største figurer. Men i stedet for at se p˚a muligheder omkring de 

to største figurer, s˚a sættes op til at se p˚a mulighederne omkring de to største 

figurer der endnu har muligheder for udvidelse. Den endelige udfordring lander 

igen p˚a vægtningen. Hvorn˚ar g˚ar den mindre figur med gode muligheder for 

udvidelse hen og bliver mere fordelagtigt at spille p˚a end den store figur som er 

begyndt at løbe tør for udvidelses muligheder. 

3.3.2 Konklusion p˚a heuristik: 

I den nuværende løsning anvendes den simple heuristikken, der kun ser p˚a selve 

spillets score til de forskellige AI’er. Men som det er blevet beskrevet er der en 

lang række steder hvor denne heuristik ikke er optimal. Dette gælder n˚ar det 

ikke er en praktisk mulighed at afdække hele spiltræet, hvilket er tilfældet ved 

et hvert spilbræt, der er støre end 4x4. Det forventes derfor at en forbedring af 

heuristikken, vil give en yderst mærkbar forbedring p˚a AI’ernes præstation.

Kapitel 4 

Minimax 

Minimax 1 er en velkendt algoritme, der ofte anvendes til brætspil. Minimax 

tager udgangspunkt i at begge spiller altid vil forsøge at maksimere sit eget 

udbytte og minimere modstanderens. 

Minimax fungerer ved at generere et træ med alle mulige træk gennem hele 

spillet. De afsluttende spilstadier (bladene p˚a træet) bliver s˚a givet en heuristisk 

værdi, som fortæller om dette stadie er vundet, tabt eller uafgjort. I Taijis 

tilfælde ogs˚a hvor meget, der er blevet vundet eller tabt med, da det er muligt 

at vinde med forskellige antal points. Disse værdier bliver ført videre op gennem 

træet. Dette sker ved at generationerne af forældre skiftevis p˚atager sig 

den højeste af børnenes værdier eller den laveste, alt efter hvilken spiller generationen 

repræsenterer. Her igennem opn˚as det at spillerne altid vil vælg det 

træk med det minimale maksimum for sin modstander og derved det maksimale 

minimum for sig selv. Deraf navnet Minimax. Med andre ord vælger spilleren 

den vej hvor modstanderens bedst mulige udbytte er det ringeste. 

Da hele træet søges igennem under alle omstændigheder, er det b˚ade muligt at 

lave en Minimax algoritme, hvor der anvendes en dybde-først fremgangsm˚ade, 

og en hvor der anvendes en bredde-først fremgangsm˚ade. 

Fordelen ved en bredde-først søgning, er at den er mere overskuelige at have 

med at gøre. Derimod er mulighederne for videreudvikling bedre for dybde- 

1 Minimax-algoritmen st˚ar beskrevet i kapitel 6, afsnit 2 i ”Articial Intelligence - A Modern 

Approach”.

40 Minimax 

først søgningen, da denne er nødvendig for at kunne lave Alpha-Beta pruning 

(se afsnit om dette). I brede-først søgningen evalueres størstedelen af slutstadierne 

først n˚ar søgningen samlet har n˚aet bunden af træstrukturen, og s˚a er det 

for sent at begynde at skære grene af som ikke behøves søges igennem. 

4.1 Beskrivelse af Minimax med brede-først søgning 

Da bredde-først versionen af Minimax er blev skrevet som en øvelse og ikke 

skulle anvendes til videreudvikling, er den kun blevet skrevet til at kunne spille 

sort. 

Bredde-først versionen fungere ved først at skabe hele træet, ved at sætte det 

nuværende spilstadie som roden og s˚a lade hver generation vokse ud fra den 

forrige. Undervejs bliver der holdt styr p˚a generationerne, ved at hver Node i 

den nye generation gemmes i et af to arrays. Et array for ulige generationer og et 

for lige. Det lige array tømmes, n˚ar en nye lige generation p˚abegyndes og tilsvarende 

tømmes det ulige n˚ar en nye ulige generation startes. Det gøres, fordi det 

er nødvendigt at holde styr p˚a medlemmerne af de to nyeste generationer n˚ar 

alting foreg˚ar per generation, i stedet for at fokusere p˚a en enkelt Node og dens 

efterkommer eller forgænger. De endelige stadier, ogs˚a kaldet bladene, gemmes 

ogs˚a i et array, da bladene ikke kun vil være at finde i den sidste generation. 

N˚ar træet er skabt p˚abegyndes beregning af værdierne op gennem træet. 

Beregningen startes i den endelige generation. Alle Noderne af denne generation 

evalueres og f˚ar tildelt en værdi. Nodernes forgænger tilføjes til det ulige eller 

det lige array afhængigt af generationen. For næste generation p˚atager nodernes 

sig alle den højeste værdi af sine børn, n˚ar generationen er lige. Hvis generationen 

er ulige p˚atager noderne sig den laveste værdi af sine børn. Herudover 

evalueres alle bladene af denne generation som befinder sig i arrayet for bladene, 

og tilføjes til det ulige eller det lige array efter generation. Alle forgængerne 

tilføjes igen til enten det ulige eller det lige array, efter at arrayet er blevet tømt 

for den gamle generation. S˚aledes fortsættes der indtil værdierne n˚ar roden og 

det bedste træk kan vælges. 

4.1.1 Pseudo-kode for Minimax med brede-først søgning: 

Funktion : Minimax ( s t a d i e ) , r e t u r n e r e r et træk 

Input : s t a d i e , s p i l l e t s nuværende s t a d i e . 

rod = s t a d i e 

BeregnTræ ( SkabTræ ( rod ) )

4.2 Beskrivelse af Minimax med dybde-først søgning 41 

RETURN rodens barn med den mindste værdi 

4.2 Beskrivelse af Minimax med dybde-først søgning 

I dybde-først søgningen, søger den først en gren til bunds og n˚ar den n˚ar bunden, 

g˚ar den blot et skridt tilbage for at tage et nyt skridt fremad. 

4.2.1 Pseudo-kode for Minimax med dybde-først søgning: 

Funktion : Minimax ( s p i l l e r , s t a d i e ) , r e t u r n e r e et træk 

Input : s p i l l e r , s p i l l e r n e som s t˚a r f o r tur . 

s t a d i e , s p i l l e t s nuværende s t a d i e . 

IF s p i l l e r = hvid THEN v = Max( s t a d i e ) 

ELSE v = Min( s t a d i e ) 

RETURN Trækket med værdien v 

Funktion : Max( S ) , r e t u r n e r e en værdi f o r s t a d i e t 

Input : S , det a k t u e l l e s t a d i e i s p i l l e t . 

IF S er et e n d e l i g t s t a d i e 

THEN v = e v a l u e r i n g a f S RETURN v 

v = −i n f 

FOR a l l e efterkommere a f S ( s ) 

m = Min( s ) 

IF v < m THEN v = m 

RETURN v 

Funktion : Min(S ) , r e t u r n e r e en værdi f o r s t a d i e t 




v = i n f 


m = Max( s ) 

IF v > m THEN v = m 

RETURN v

42 Minimax 

4.3 Spilgraf for 3x3 Taiji spil: 

Forskellen mellem et spiltræ og en spilgraf, er at det i spilgrafen er muligt at 

flere foreg˚aende stadier kan ende i samme stadie. 

Herunder ses spilgrafen for Taiji p˚a en 3 gange 3 spilplade. Alle rotationer og 

spejlinger af et spilbræt, anses for at være et spilstadie. Var dette ikke tilfældet 

skulle grafen være betydeligt større, f.eks. ville der i stedet for 4 mulige starttræk 

være 18.

4.3 Spilgraf for 3x3 Taiji spil: 43 

Figur 4.1: Spilgrafen for Taiji p˚a et 3x3 bræt.

44 Minimax 

Herunder ses spilgrafen efter de endelige spilstadier har f˚aet tildelt deres værdier. 

Spilgrafen er blevet vendt om for at illustrere hvordan værdierne først 

bliver tildelt de endelige stadier og derefter bliver givet videre op gennem træet. 

(Positiv score er til hvids fordel, negativ er til sorts.)


Figur 4.2: Spilgrafen for Taiji p˚a et 3x3 bræt med score p˚a slutstadierne. Positive 

værdier er til hvids fordel, negative er til sorts.

46 Minimax 

Herunder ses spilgrafen n˚ar værdierne er blevet sendt op gennem træet efter 

minimax-princippet. Dette er grafen som den vil se ud, hvis det er den hvide 

spiller der har det første træk, ergo er det blevet kørt Max() p˚a roden.


Figur 4.3: Spilgrafen for Taiji p˚a et 3x3 efter Minimax genkørsel med Max som 

starter.

48 Minimax 

Som det kan ses ender spilgrafen i et nul ved roden. Dette betyder at der ikke 

er nogen vinderstrategi, som kan lede til en sikker sejr. Dette betyder dog ogs˚a, 

at det er muligt at f˚a et uafgjort resultat uanset hvad modstanderen gør. S˚a 

længe begge parter spiller optimalt vil spillet ende uafgjort. Der vil først være 

en sejrherre, n˚ar den ene part beg˚ar en fejl som vil lede til modstanderens sejr. 

Det kan ogs˚a ses at det første træk ingen betydning har for resultatet, da alle 

anden generations spilstadierne har værdien nul. Spilles der mod en modstander 

der beg˚ar fejl er nogle af disse træk dog bedre end andre. Dette kan f.eks. 

bedømmes p˚a hvor stor en andel af de efterfølgende stadier der føre til en sejr. 

Jo større andel af træk, der føre til en sejr, jo større sandsynlighed for at en forhastet 

modstander vil komme til at vælge et af disse. Placeres den sorte halvdel 

af brikken i et hjørne, er der 6 efter følgende stadier der leder til en sejr ud af 

de i alt 15 forskellige muligheder. 

Herunder er en tabel over de fire mulige starttræk og hvor mange af modstanderens 

træk, der efterfølgende vil lede til sejr for den første spiller: 

Placering Træk, der leder til sejr Samlet antal træk Procentdel 

Sort i hjørnet 6 15 40% 

Hvid i hjørnet 3 15 20% 

Sort i midten 0 6 0% 

Hvid i midten 3 6 50% 

Tages der ikke højde for spejlinger og rotationer ser tabellen s˚aledes ud: 

Placering Træk, der leder til sejr Samlet antal træk Procentdel 

Sort i hjørnet 7 16 43,75% 

Hvid i hjørnet 3 16 18,75% 

Sort i midten 0 12 0,00% 

Hvid i midten 6 12 50,00% 

Ud fra dette kan det ses, at sandsynligheden for at modstanderen laver en fejl, 

der leder den første spiller til sejr, er størst ved at placere spillerens egen halvdel 

af brikken i midten. Det kan ogs˚a forventes, at jo større antallet af mulige træk 

er, jo større er sandsynligheden for at der laves en fejl. Er dette sandt, kan det 

være bedre at placere den sorte halvdel af brikken i et hjørne, da dette øger 

antallet af mulige træk p˚a bekostning af en relativt lille nedgang i procentdelen 

af træk der vil lede til sejr. 

Det kan ogs˚a ses, at det at placere den sorte halvdel af brikken i midten udelukker 

muligheden for sejr, medmindre modstanderen laver fejl længere inde i 

spillet, hvor det vil være nemmere at overskue konsekvenserne af et træk og 

derved er mindre sandsynligt at der laves en fejl. Det er m˚aske endda tilfældet 

at sejren slet ikke er mulig efter dette træk. For at undersøge dette er her 

spilgrafen for trækket med sort i midten:


Figur 4.4: Spilgrafen for Taiji p˚a et 3x3 med fokus p˚a første træk med sort i 

midten.

50 Minimax 

Det kan ses at alle de endelige stadier, som kan opn˚as fra dette træk, enten 

ender i uafgjort eller i en sejr til sort. 

Gennemg˚as alle endelige stadier kan det ogs˚a ses, at intet stadie med sort i 

midten g˚ar til den hvide spiller. Dette gælder selvfølgelige ogs˚a den anden vej 

rundt, intet stadie med hvid i midten g˚ar til den sorte spillers sejr. 

Her af kan det konkluderes at den spiller, der først placeres sin farve i midten, 

vil være sikret minimum et uafgjort resultat. 

Desuden kan det ses at et hvert slutstadie med et frit felt i midten ender uafgjort. 

Med andre ord er midten nødvendig for at vinde spillet, n˚ar brættet er p˚a 3 gange 

3 felter.

Kapitel 5 

5.1 Spilgraf 

Optimering af Minimax 

En kraftig reducering kan opn˚as ved at skifte fra et spiltræ til en spilgraf. Forskellen 

mellem et spil træ og en spilgraf er, at hvor et spiltræs grene aldrig vil g˚a 

sammen igen, er dette en mulighed for en spilgraf. I praksis er dette muligheden 

for at samme brættilstand kan n˚as ad mere end en vej.

52 Optimering af Minimax 

Figur 5.1: Eksempel p˚a et lille spiltræ. 

Figur 5.2: Eksempel p˚a en lille spilgraf for samme brættilstande.

5.2 Rotationer og spejlinger 53 

5.2 Rotationer og spejlinger 

At undg˚a rotationer og spejlinger er en af de mest besparende faktorer i Taiji, 

især ved det helt første træk. Rotationer og spejlinger g˚ar i sin enkelthed ud 

p˚a at to brættilstande anses for at være samme tilstand, hvis den ene er en 

rotation eller spejling af den anden. Hvis to brættilstande er ens, behøves de 

efterfølgende beregninger kun laves en gang. Jo flere brættilstande, der kan siges 

at være de samme, jo færre beregninger skal der til. 

Figur 5.3: Eksempel p˚a tre 4x4 brættilstande, der kan betragtes som værende 

ens. 

I praksis kommer reduceringen kraftigst til syne ved første træk, da de efterfølgende 

reducering bliver færre, fordi den første brik der sættes kommer 

til at danne et anker for efterfølgende rotationer og spejlinger. Herunder ses 

antal af brættilstande før reduceringen og efter reducering pga. rotationer og 

spejlinger:


Figur 5.4: Alle trækmuligheder for et standardbræt. Hver streg repræsentere 

en brik og de to m˚ader, som brikken kan vende p˚a. 

Figur 5.5: Alle træk muligheder for først træk p˚a et standardbræt efter reducering 

pga. rotationer og spejlinger. 

Første forgrening i spilgrafen reduceres her til omkring en 1/8. Langt de fleste 

reduceringer sker i form af denne reducering og alle de brættilstande der aldrig 

kommer til at eksistere fordi deres forgænger blev fjernet her. Der opst˚ar dog 

yderligere reduktioner ned gennem spilgrafen efter den store reducering, n˚ar der 

undervejs dannes ny symmetri.

5.3 Hash funktioner 55 

Figur 5.6: Eksempel p˚a reducering af brættilstande pga. rotationer og spejlinger 

længere nede i spilgrafen. 

Som tommelfingerregel er reduceringen p˚a en faktor 8, fire rotationer af brættet 

og fire rotationer af det spejlvendte bræt. Dette gælder dog kun kvadratiske 

brætstørrelser, for rektangulære brætstørrelser er det ikke muligt at lave 90 

graders rotationer og reduceringen bliver derfor halveret til en faktor 4. 

5.3 Hash funktioner 

Efter at have sparet store dele af spiltræet væk ved at lade det være en graf i 

stedet, hvor hvor flere vej kan lede til samme stadie, er det blevet nødvendigt 

ved hvert enkelt spilstadie at checke om dette spilstadie allerede eksisterer. For 

at gøre dette m˚a spilstadiet sammenlignes med alle andre spilstadier, der indtil 

videre er blevet dannet i aktuelle spil, inden stadiet bliver oprettet i systemet


som et unikt stadie, eller om det blot skal bruges til at tilføje ny information til 

et allerede eksisterende stadie. 

Denne søgning efter ens stadier kan, hvis den bare udføres blindt, potentielt øge 

tidsfaktoren s˚a meget at det ikke kan betale sig at g˚a fra spiltræ til spilgraf. 

Søgningen skal udføres for hvert stadie i spillet, og da der er tusinder af stadier, 

skal der for tusindvis af stadier søges igennem netop tusindvis af stadier. Dette 

vil selvfølgelig være et større problem i slutningen af et spil end i starten, hvor 

der endnu ikke er s˚a mange stadier at søge igennem. Desuden kan et matchende 

stadie findes tidligt i søgning, som s˚a kan afsluttes der. I gennemsnit kan det forventes 

at et stadie findes halvvejs inde i søgningen, men dette gælder selvfølgelig 

kun i tilfælde hvor der er et matchende stadie. Er der ikke et matchende stadie, 

vil det være nødvendigt at søge alle stadierne igennem for at konstatere at der 

ikke er et. 

Dette vil give d˚arlig svartid, hvis der søges blindt fra enden til anden. Men 

søgningen kan optimeres ved at begrænse den til et mindre omr˚ade hvori det 

kan afgøres at stadiet enten eksisterer eller ikke eksisterer. 

Det er her hashtabeller kommer ind i billedet. Hashtabeller 1 bruges til at gøre 

søgninger hurtigere, ikke kun i spiltræer men i alle former data. Det gøres ved at 

opdele data i grupper, s˚aledes at det kun er nødvendigt at søge en enkelt gruppe 

igennem for at konstatere om dataene eksistere eller ej. For at bestemme hvor 

i hashtabellen et stykke data skal placeres, er det nødvendigt at en hashfunktion 

beregner en hashværdi for det stykke data der skal gemmes. Hashværdien 

fungerer lidt ligesom et postnummer og bestemmer hvor i hashtabellen dataene 

skal gemmes, og derved ogs˚a hvor de kan findes og findes hurtigt igen. For at 

dette skal fungere, er det nødvendigt at hashværdierne overholder nogle regler. 

Flere stykker data m˚a godt f˚a tildelt samme hashværdi, dette betyder blot at de 

havner i samme gruppe. Derimod m˚a to ens stykker data ikke kunne f˚a forskellige 

hashværdier, da system s˚a ikke længere vil være p˚alideligt. Det vil fejlagtigt 

give svaret at der ikke findes flere forekomster af et givne stykker data, selvom 

dette ikke er korrekt. 

Da der for hvert træk lægges en brik, og da der p˚a intet tidspunkt hverken 

fjernes eller flyttes brikker, vil to ens stadie kun kunne opst˚a i samme generation, 

da to ens stadier altid vil have samme antal brikker. Af denne grund kan 

dybden p˚a træet anvendes som en hash værdi. 

Ulempen ved at bruge dybden er at de forskellige generationer meget hurtigt 

kan komme til at indeholde rigtigt mange spilstadier. Især de midterste generationer 

i spillet, hvor der er mange stadier i den tidligere generation at komme 

fra, og der stadig er mange fri muligheder for placering af nye brikker. 

Der er dog flere fordele ved at benytte dybden som en hashværdi. Den er nem 

at komme til, det er blot at holde styr p˚a turen eller tælle antallet af brikker, 

1 Der kan findes mere information om hash-tabeller og -funktioner i ”Introduction to Algo- 

rithms”, kapitel 11.


hvilket igen blot kan gøres ved at tælle antallet af enten sort eller hvide felter. 

I denne implementering er dybden endda gemt i hver eneste Node, s˚a den er 

hurtigere og lettere tilgængelige end som s˚a, da en hashfunktion faktisk slet ikke 

er nødvendig. Udover tilgængeligheden vil fordelingen af spilstadierne ogs˚a være 

ganske udmærket. P˚a trods af at der vil værre færre stadier gemt i de først generationer, 

vil spilstadierne være godt fordelt ud over de forskellige generationerne. 

Scoren er ogs˚a en mulig hash værdi, da scoren selvfølgelig altid ville være den 

samme for ens stadier. Differencen i scoren vil dog i et spil mellem jævnbyrdige 

modstander ofte ligge tæt omkring værdien 0, hvilket vil betyde at store dele af 

stadierne vil havne i samme grupper. Derfor vil de oftest forekommende tilfælde 

kræve de største søgninger. Dette er selvfølgelig ikke hensigtsmæssigt. Ved at 

anvende de to score i stedet for blot difference mellem dem, kan der skabes mere 

variation i hashværdierne. Dette kan f.eks. gøres ved at anvende hashfunktionen: 

hashværdi = hvids score + (sorts score · (max score + 1)) 

Med denne hashfunktion vil kun de spilstadier, der har præcis samme score per 

spiller, f˚a samme hashværdi. For mange spilstadier vil scorerne ligge omkring 

de samme værdier, men slet ikke i s˚a høj grad, som n˚ar kun differencen anvendes. 

Selve hashtabellen er blevet lavet som et to-dimensionelt array. Spilstadierne 

bliver inddelt i denne tabel efter to hashværdier som bestemmer i henholdsvis 

hvilken række og hvilken kolonne det enkelt spilstadie placeres. Den ene af disse 

værdier er dybden. Omkostningerne i form af regnekraft for at fremskaffe den 

er stort set ikke eksisterende, samtidigt med at den gør et glimmerende stykke 

arbejde, n˚ar det kommer til at fordele stadierne ud nogenlunde ligeligt. Den 

anden værdi bliver overladt til en mere traditionel hashfunktion. 

I første omgang fik hashfunktionen baseret p˚a scoren opgaven at fordele stadierne, 

og blev nanvgivet hashFunction. Kombinationen af hashFunction og dybden 

fungere rimeligt godt p˚a sm˚a brætter, hvor det er muligt at regne hele spiltræet 

igennem. Denne kombinationen har dog, uanset hvilken størrelse et bræt har, 

den ulempe at generationen og scoren ofte følges ad, jo længere inde i spillet, 

jo højere score. Men de største problemer opst˚ar p˚a store brætter, hvor det 

kun er muligt at søge f˚a generationer frem. For de første par træk i spillet vil 

scoren altid være den samme. For første træk vil der blive lagt en brik, hvilket 

altid vil give et point til sort og et point til hvid, og da det er er de to største 

figurer der tæller, vil andet træk resultere i scoren to-to uanset hvordan den 

anden brik placeres. Først ved spillets tredje træk fremkommer nogen form for 

variation nemlig stillingerne to-to, to-tre, tre-to og tre-tre. Resultatet er alts˚a 

at hashFunction lige s˚a vel kunne have være undladt for de først to træk og kun 

opdeler spilstadierne i yderligere fire grupper for det tredje.


Det er derfor hensigtsmæssigt at finde en nye hashfunktion til at erstatte hash- 

Function. Dette alternativ kun baseres p˚a brikkernes placering p˚a bræt, da den 

enkelte briks placering er s˚a godt som uafhængig af dybden. Problemet er bare 

at en hashfunktion skal give samme hashværdi uanset om spilstadiets bræt er 

blevet spejlvendt, roteret eller en kombination af disse for at fungere. For at 

komme uden om dette problem, kan et bræt med værdi bruges til finde en hashværdi. 

Et s˚adant værdibræt skal have samme dimensioner som selve spilbrættet 

og skal forblive det samme uanset hvordan det vendes og drejes. Hvert felt skal 

have en værdi, som s˚a kan tages i anvendelse, hvis en brik lægges oven p˚a det, 

og derved f˚a indflydelse p˚a den endelige hashværdi. 

I dette tilfælde er værdibrættet konstrueret s˚aledes; det midterste felt har værdien 

1, der kan være tale om flere felter, hvis antallet af kolonner eller rækker af 

lige generationer. Værdierne for fletterne lodret og vandret ud fra midten stiger 

med 1 hver gang de kommer et felt længere fra midten. Disse felter kan ses 

som to akser. De resterende felter f˚ar deres værdi ud fra disse. Er et felt ud for 

værdien 2 p˚a den lodret akse og ud for værdien 3 p˚a den vandret, bliver feltet 

tildelt værdien 6 (2 x 3). 

Et eksempel p˚a dette kan se s˚aledes ud: 

12 9 6 3 3 6 9 12 

8 6 4 2 2 4 6 8 

4 3 2 1 1 2 3 4 

8 6 4 2 2 4 6 8 

12 9 6 3 3 6 9 12 

Den oprindelige ide var at lægge alle værdierne sammen for alle de felter hvor 

der l˚a en hvid halvdel, og trække summen fra af værdierne for alle de felter hvor 

der l˚a en sort halvdel. Det kan dog hurtigt observeres at dette ikke er en optimal 

fremgangsm˚ade, da en vandret brik vil tilføje den samme værdi s˚a længe den 

bevæger sig langs en række indtil den n˚ar midten. Det samme gælder en lodret 

briks bevægelse i en kolonne. 

Eksembel for midterste række: 2 - 1 = 1, 3 - 2 = 1, 4 - 3 = 1. 

Dette kan løses ved i stedet for at fratrække de sorte værdier, halveret værdien 

og s˚a lægge den til, for fortsat at bibeholde en vigtig afvigelse mellem de 

to farver. Til sidst benyttes modulus til at reducere resultatet til en passende 

størrelse. Denne hashfunktion er navngivet hashFunction2. 

Til slut forsøges med en tredje funktion som kombinerer hashFunction og hashFunction2. 

Denne funktion lægger blot hashværdierne fra de to funktionerne 

samme og anvender igen modulus til at holde værdien inde for rammerne. Den 

funktion har f˚aet navnet hashFunction3.


5.3.1 Test af hashfunktioner 

Køretiderne er efter at den menneskelige spiller har foretaget første træk, da 

nogle af de kunstige intelligenser sætter en brik i midten uden at tænke sig om, 

hvis de har første træk, og derfor ikke kan bruges til sammenligning. Gældende 

træk er alts˚a andet træk i spillet, dette er blevet taget ti gange for hver størrelse 

af hver af kunstig intelligens og gennemsnittet af disse ti er hvad der ses i tabellen 

her under: 

4x4 Kun dybde hashFunction hashFunction2 hashFunction3 

AlphaBeta 5,040 1,127 1,555 1,178 

LocalArea 2,997 1,398 1,333 1,348 

Growth 0,183 0,144 0,092 0,096 

For et spillebræt p˚a fire gange fire ses det at de kunstige intelligenser kører 

betydeligt hurtigere n˚ar de tre hash funktioner anvendes sammen med dybden 

end n˚ar dybden anvendes alene. Der er ikke blevet lavet forsøg uden dybden som 

hash værdi, da denne er dybere integreret i koden og derfor ikke lige s˚a nem 

at fjerne i test henseende som de andre hashfunktioner. Overraskende er det 

hashFunction, som kun er baseret p˚a scoren, der klare sig bedst for AlphaBeta 

p˚a et fire gange fire bræt. Det kunne forventes at dette skyldes beregningstiden 

for værdigrafs metoden i hashFunction2 var større end den score baserede 

metode i hashFunction, men var dette tilfældet ville hashFunction3’s resultat 

være d˚arligere en b˚ade hashFunction og hashFunction2, da denne anvender begge 

metoder, hvilket ikke er tilfældet. HashFunction3 klarer sig stort set lige s˚a 

godt som hashFunction, hvilket m˚a betyde at problemet ligger i hashFunction2. 

HashFunction2 anvender som sagt værdigrafs metoden alene og heri opst˚ar problemet, 

da der ikke er meget variation i værdierne i en værdigraf af den størrelse: 

4 2 2 4 

2 1 1 2 

2 1 1 2 

4 2 2 4 

Mange spilstadier vil derfor f˚a samme hash-værdi og der vil s˚aledes være flere 

stadier, der skal søges igennem per søgning. 

9x9 Kun dybde hashFunction hashFunction2 hashFunction3 

AlphaBeta 62,56 41,34 4,22 3,95 

LocalArea 2,997 1,398 1,333 1,348 

Growth 20,12 1,82 1,34 0,82 

Den oprindelige frygt for at en hashfunktion baseret p˚a score ville give meget 

lille variation i starten af spillet, viser sig her begrundet. HashFunction klarer 

sig næsten lige s˚a d˚arligt som dybden anvendt alene. Mens hashFunction2 og 3


klarer sig hele ti gange bedre end hashFunction. Der er unægtelig forskel p˚a om 

den menneskelige spiller skal vente fire sekunder p˚a at modstanderen foretager 

sit ryk eller om det tager næsten et helt minut. 

LocalArea og Growth vil der blive set nærmere p˚a senere, men generelt er resultatet 

det samme for disse to. 

5.3.2 Konklusion p˚a hashfunktioner: 

Testen viser som forventet at hashFunction2 giver en betydeligt hurtigere beregning 

end ved brug af den oprindelige hashFunction, n˚ar det kommer til den 

almindelige minimax algoritme med aplha beta pruning p˚a en stor plade, hvor 

det ikke er muligt at søg ret langt ned i spiltræet. Testen viser ogs˚a at selvom 

den kombinere hashfunktion hashFunction3 ikke altid er hurtigst, kommer den 

altid nær den bedste tid, da den kombinere de to tidligere versioners styrker. Det 

kan ogs˚a ses at denne kombination ikke har de store tidsomkostninger, selvom 

den laver b˚ade beregningen fra hashFunction og fra hashFunction2. 

Dette peger ogs˚a imod at selve beregningerne for hash-værdier ikke er den tunge 

del af svartiden. F.eks. er der en meget lille forskel i beregningstiden mellem 

hashFunction og hashFunction3 for AlphaBeta AI’en p˚a en fire gange fire plade, 

hvor hashFunction2 klare sig mindre godt og derfor ikke burde spille ind p˚a hashFunction3s 

resultat i forhold til hashFunction. Men der opst˚ar alts˚a ikke den 

stor forskel mellem hashFunction og hashFunction3, selvom hashFunction3 laver 

to beregninger, hvor hashFunction laver en. Den lille forskel i beregningstiden 

mellem hashFunction og hashFunction3, kan dog ogs˚a skyldes at hashværdien 

for hashFunction3 er det bedre og derfor giver hurtigere søgetider, og at dette 

derfor opvejer den ekstra regnetid per hashværdi. 

Alt i alt vil hashFunction3 være det bedste generelle valg. Den klare sig altid 

bedst eller næstbedst i testene, og i de tilfælde hvor den kun er næstbedst ligger 

den meget tæt op ad den bedste. Det at den tager egenskaberne fra begge de 

forrige funktioner betyder at den aldrig vil klare sig specielt meget d˚arligere end 

den bedste af disse to i et hvilket som helst tilfælde. 

5.4 Alpha-beta pruning 

Alpha-beta pruning 2 er en teknik, der kan anvendes til at se bort fra store dele 

af et spiltræ. 

2 Alpha-beta pruning er beskrevet i kapitel 6, afsnit 3 i ”Articial Intelligence - A Modern 

Approach”.

5.4 Alpha-beta pruning 61 

Alpha-beta pruning kan anvendes sammen med minimax algorithmen til at begrænse 

mængden af grene, der er skal søges i gennem i spiltræet. Ved hjælp af 

alpha beta pruning er det muligt at afgøre om det er værd at fortsætte søgningen 

ned af en gren, eller om det allerede kan ses at et bedre resultat kan opn˚as anden 

steds. Dette gøres ved at de henholdsvis bedste værdier for max og min gemmes 

som alpha og beat-værdier. N˚ar en søgning n˚ar enden af en gren, er det muligt 

at sammenligne værdien af denne med alpha eller beta-værdien, og afgøre om 

der er grund til at fortsætte søgningen eller ej. Disse afbrydelser kan forsætte 

længere op gennem træet, men minimum et blad skal være besøgt før en gren 

kan klippes fra i søgningen. 

Alpha anvendes til at gemme den hidtil bedste løsning for Max p˚a vejen til det 

p˚agældende stadie, mens beta anvendes ligeledes for min. Hvis Max-funktionen 

et sted inde i søgningen modtager en værdi fra et af børnene, som er større end 

eller lige s˚a stor som beta-værdien for Min en generation over den nuværende 

Max, s˚a afbryder Max sin igangværende søgning og returnere den fundne værdi 

til den igangværende Min-funktion generationen højere oppe. Max afbryder 

her fordi, det lige er blevet bekræftet, at denne gren kun er p˚a niveau med 

eller d˚arligere end overst˚aende Min-funktions hidtil bedste løsning, og det at 

forstsætte søgningen vil kun vise hvor meget d˚arligere grenen er. Hvilket er irrelevant, 

da Min-funktionen under alle omstændigheder aldrig vil vælge denne 

gren, n˚ar der allerede er fundet en bedre mulighed. 

5.4.1 Pseudo-kode for Minimax med Alpha-Beta pruning: 

Funktion : AI−AlphaBeta ( s p i l l e r , s t a d i e ) , r e t u r n e r e et træk 

Input : s p i l l e r , s p i l l e r n e som s t˚a r f o r tur . 

s t a d i e , s p i l l e t s nuværende s t a d i e . 

IF s p i l l e r = hvid THEN Max( s t a d i e , −i n f , i n f ) 

ELSE Min( s t a d i e , −i n f , i n f ) 

Funktion : Max(S , a , ß ) , r e t u r n e r e en værdi f o r s t a d i e t 


a , den a k t u e l l e Alpha værdi . 

ß , den a k t u e l l e Beta værdi . 



v = −i n f 


m = Min( s , a , ß )


IF v < m THEN v = m 

IF v = ß THEN RETURN v 

IF a < v THEN a = v 

RETURN v 

Funktion : Min(S , a , ß ) , r e t u r n e r e en værdi f o r s t a d i e t 


a , den a k t u e l l e Alpha værdi . 

ß , den a k t u e l l e Beta værdi . 



v = i n f 


m = Max( s , a , ß ) 

IF v > m THEN v = m 

IF v = a THEN RETURN v 

IF ß > v THEN ß = v 

RETURN v 

5.4.2 Gennemgang af et eksempel p˚a Alpha-Beta pruning: 

Da det kan være svært umiddelbart at overskue præcist hvordan Alpha-Beta 

pruning fungere er her en grundig gennemgang af et eksempel p˚a Alpha-Beta 

pruning.


Figur 5.7: Eksempel p˚a et spiltræ. 

For at starte søgningen køres Max() p˚a noden rod-noden A, med alpha-værdien 

-8 og beta-værdien 8. Havde det været den modsatte spiller der startede, skulle 

søgningen i stedet startes med Min(). 

Start Max(A,−∞,∞): 

Da søge dybden ikke er n˚aet og A ikke er et endeligt stadie, sættes værdien for 

A sættes til −∞ og der køres Min() p˚a As børn. 

Min(B,−∞,∞): 

Da søge dybden ikke er n˚aet og B ikke er et endeligt stadie, sættes værdien for 

B sættes til ∞ og der køres Max() p˚a Bs børn. 

Max(D,−∞,∞): 

Da søge dybden ikke er n˚aet og D ikke er et endeligt stadie, sættes værdien for 

D sættes til −∞ og der køres Min() p˚a Ds børn. 

Min(H,−∞,∞): 

Da søge dybden er n˚aet, evalueres H og f˚ar i dette tilfælde værdien 5. Værdien 

returneres. 

Max(D,−∞,∞): 

Modtager værdien 5 fra H. 

Værdien for D sættes til at være den højeste værdi af de to værdier, den nuværende 

værdi for D (−∞) eller værdien for H (5). Værdien for D sættes til 5. 

Der checkes om værdien for D (5) er større end/lig med Beta (∞). Hvilket ikke


er tilfældet. 

Alpha sættes til at være den største værdi af Alpha (−∞) og værdien for D (5). 

Alpha = 5. 

Max(D) forsætter med det næste barn. Kører Min(I,5,8). 

Min(I,5,∞): 

Da søgedybden er n˚aet, evalueres I og f˚ar i dette tilfælde værdien 2. Værdien 

returneres. 

Max(D,−∞,∞): 

Modtager værdien 2 fra I. 

Værdien for D sættes til at være den højeste af de to værdier, den nuværende 

værdi for D (5) eller værdien for H (2). Værdien for D forbliver 5. 

Der checkes om værdien for D (5) er større end/lig med Beta (∞). Hvilket ikke 


Alpha sættes til at være den største værdi af Alpha (5) og værdien for D (5). 

Alpha = 5. 

Da D ikke har flere børn returneres værdien (5). 

Figur 5.8: Spiltræet efter at Max(D,−∞,∞) er blevet kørt. 

Min(B,−∞,∞): 

Modtager værdien 5 fra D. 

Værdien for B sættes til at være den mindeste af de to værdier, den nuværende 

værdi for B (∞) eller værdien for D (5). Værdien for B sættes til 5.


Der checkes om værdien for B (5) er mindre end Alpha (−∞). Hvilket ikke er 

tilfældet. 

Beta sættes til at være den mindste værdi af Beta (∞) og værdien for B (5). 

Beta = 5. 

Min(B) forsætter med det næste barn. Kører Max(E,−∞,5). 

Max(E,−∞,5): 

Da søge dybden ikke er n˚aet og E ikke er et endeligt stadie, sættes værdien for 

E sættes til −∞ og der køres Min() p˚a Ds børn. 

Min(J,−∞,5): 

Da søge dybden er n˚aet, evalueres J og f˚ar i dette tilfælde værdien 6. Værdien 

returneres. 

Max(E,−∞,5): 

Modtager værdien 6 fra J. 

Værdien for E sættes til at være den højeste af de to værdier, den nuværende 

værdi for E (−∞) eller værdien for J (6). Værdien for E sættes til 6. 

Der checkes om værdien for E (6) er større end/lig med Beta (5). Hvilket er 


Søgningen afbrydes og værdien for E (6) returneres. 

Min(B,−∞,∞): 

Modtager værdien 6 fra E. 

Værdien for B sættes til at være den mindeste af de to værdier, den nuværende 

værdi for B (5) eller værdien for E (6). Værdien for B forbliver 5. 

Der checkes om værdien for B (5) er mindre end/lig med Alpha (−∞). Hvilket 

ikke er tilfældet. 

Beta sættes til at være den mindste værdi af Beta (5) og værdien for B (5). 

Beta forbliver 5. 

Da B ikke har flere børn returneres værdien 5. 

Max(A,−∞,∞): 

Modtager værdien 5 fra B. 

Værdien for A sættes til at være den højeste af de to værdier, den nuværende 

værdi for A (−∞) eller værdien fra B (5). Værdien for A sættes til 5. 

Der checkes om værdien for A (5) er større end/lig med Beta (∞). Hvilket ikke 


Alpha sættes til at være den største værdi af Alpha (−∞) og værdien for A (5). 

Alpha = 5. 

Max(A) forsætter med det næste barn. Kører Min(C,5,∞).


Figur 5.9: Spiltræet, hvor Min(C,5,∞) kaldes. 

Min(C,5,−∞): 

Da søge dybden ikke er n˚aet og C ikke er et endeligt stadie, sættes værdien for 

C sættes til 8 og der køres Max() p˚a Cs børn. 

Max(F,5,∞): Da F er et endeligt stadie, evalueres F og f˚ar i dette tilfælde 

værdien 3. Værdien returneres. 

Min(C,5,∞): Modtager værdien 3 fra F. 

Værdien for C sættes til at være den mindeste af de to værdier, den nuværende 

værdi for C (∞) eller værdien fra F (3). Værdien for C sættes til 3. 

Der checkes om værdien for C (3) er mindre end/lig med Alpha (5). Hvilket er 


Søgningen afbrydes og værdien for C (3) returneres. 

Max(A,−∞,∞): 

Modtager værdien 3 fra C. 

Værdien for A sættes til at være den højeste af de to værdier, den nuværende 

værdi for A (5) eller værdien fra C (3). Værdien for A forbliver 5. 

Der checkes om værdien for A (5) er større end/lig med Beta (∞). Hvilket ikke 


Alpha sættes til at være den største værdi af Alpha (5) og værdien for A (5). 

Alpha forbliver 5. 

Da A ikke har flere børn er søgning slut. 

Resultatet er at B er det bedste træk, da dette træk har den højeste minimums 

værdi p˚a 5.


Figur 5.10: Det færdige spiltræet. De gr˚a noder er ikke blevet undersøgt. Den 

tykke, sorte vej markere de endelige valg for Max og Min. 

5.4.3 Alpha-Beta pruning p˚a spilgraf: 

I et spiltræ er det relativt nemt at afslutte en undersøgelsen af en brættilstand, 

n˚ar visse kriterier er opfyldt og s˚a g˚a videre uden at bekymre sig mere om den. 

Det samme er dog ikke tilfældet for en spilgraf. I en spilgraf er det nemlig muligt 

at komme tilbage til denne brættilstand, der tidligere er blevet besøgt, som kan 

være blevet søgt helt igennem eller afbrudt undervejs af AlphaBeta pruning’en. 

N˚ar en s˚adan brættilstand mødes igen er det nødvendigvis ikke under samme 

kriterier som forrige gang. Alpha og beta-værdierne, som afgør om undersøgelsen 

af brættilstanden skal afsluttes før tid, kan have ændret sig i mellemtiden og den 

værdi, som er gemt i brættilstanden fra forrige møde, kan være blevet forældet. 

Fortages søgningen p˚a ny under de nye kriterier for at undg˚a at værdi ikke 

længere er tidsvarende, forsvinder hele ideen med at benytte en spilgraf, nemlig 

at den samme brættilstand ikke søges igennem flere gange. Anvendes den gemt 

værdi derimod uden at undersøge brættilstanden igen, risikeres der at det endelige 

resultat bliver forkert. 

Løsningen er at finde en m˚ade at vurdere hvorn˚ar en ny undersøgelse er nødvendig 

og hvorn˚ar den gemte værdi kan anvendes uden videre. 

For finde ud af om en ny undersøgelse af brættilstanden er nødvendig, er det


vigtigt at være opmærksom p˚a præcis hvilken information der er gemt i værdien 

for brættilstanden. Uanset hvilke kriterier undersøgelsen af brættilstanden tidligere 

er blevet foretaget med, vil værdien være et minimum for hvor godt enten 

Min eller Max vil klare sig for denne brættilstand. Om det er Min eller Max 

afhænger af brættilstandens generation. Er generationen over brættilstanden en 

Min-generation er brættilstanden selv af en Max-generation og omvendt. 

Værdien gemt i brættilstanden kommer alts˚a ikke til at blive bedre end den allerede 

er set fra Max eller Min’s syn generationen over brættilstanden. S˚a hvis Min 

generationen over arbejder med en beta-værdi, der er lige s˚a stor eller større end 

den gemte værdi, behøver den ikke lave en nye undersøgelse af brættilstanden, 

da der allerede findes en lige s˚a god eller bedre løsning. Er det ikke tilfældet, 

bliver den nødt til at starte en ny undersøgelse af brættilstanden med de nye 

alpha og beta værdier, da det ikke kan garanteres at værdien for brættilstanden 

ikke reelt er højere end hvad den forrige undersøgelse var kommet frem til, da 

den blev afsluttet. 

Er det Max, der er i gang generationen før brættilstanden, skal der i stedet 

checkes om alpha-værdien er mindre end eller lige s˚a stor som den gemte værdi. 

Er den mindre end eller lige s˚a stor er der ingen grund til at undersøge brættilstanden 

igen. 

Normalt checker Min- eller Max-funktionen om et træk resultere i en brættilstand 

der allerede eksisterer, hvis den gør det tilføjer den brættilstand som et 

barn og tilføjer sig selv som forældre p˚a brættilstanden, og s˚a gøres der ellers 

ikke mere ved den. Men med alpha beta-pruning inde i billedet, stopper den 

ikke længere. Ligesom hvis den ikke havde konstateret at der allerede fandtes 

en s˚adan brættilstand, kører den enten Max eller Min p˚a tilstanden, dog med 

den lille forskel, at udover at sende alpha og beta værdierne med, sender den en 

værdi der indikere om brættilstand fandtes i forvejen eller ej. 

Det første Min eller Max gør, i tilfælde af at brættilstanden allerede eksisterede, 

er at sammenligne henholdsvis alpha og beta med brættilstandens gemte værdi. 

Er værdien for Min’s vedkommende mindre end eller lig med alpha eller for 

Max’s vedkommende større end lig med beta, stoppes processen der og værdien 

gemt i brættilstanden returneres. Er det ikke tilfældet fortsætter Min og Max 

p˚a sædvanligvis. 

5.4.4 Fordele og ulemper: 

Sammenlignet med en almindelige Minimax algoritme har Alpha-Beta versionen 

ingen ulemper, da den altid vil kom frem til samme løsning, bare hurtigere. Den 

eneste forskel der kan komme til syne er, at der kan være mindre variation i 

Alpha-Beta versionens træk. Dette skyldes at den kunstige intelligens er sat


til at vælge et tilfældigt træk, n˚ar der er mere end et træk med den bedste 

værdi. Her er det muligt at Alpha-Beta pruningen har frasorteret grene, som 

hvis de havde været søgt til bunds, havde vist sig at være lige s˚a gode som 

den fundne løsning men aldrig bedre. I det tilfælde ville mængden af lige gode 

træk, som den kunstige intelligens havde at vælge imellem, været mindre end 

med en almindelige Minimax AI. Var dette dog en prioritet, kunne Alpha-Beta 

versionen hurtigt modificeres til ogs˚a at finde alle de bedste løsninger og stadig 

være hurtigere end den almindelige Minimax AI. Dette kunne opn˚as blot ved at 

ændre parametrene til ikke at stoppe en søgning ved en kun lige s˚a god løsning, 

men først at stoppe n˚ar den viser sig decideret at være d˚arligere end den hidtil 

bedst fundne. Det er dog svært at finde et scenarie, hvor det vil være s˚a vigtigt 

at være sikker p˚a at alle lige gode løsninger kommer med, at det er den ekstra 

regnetid værd. 

Desuden er der problemerne som er beskrevet i afsnit omkring heuristik. 

5.4.5 Mulige forbedringer: 

Jo tidligere en god løsning findes, jo flere d˚arlige løsning kan s˚a udelukkes inden 

der søges til bunds. Derfor kan kørslestiden af en Minimax AI som anvender 

Alpha-Beta pruning forbedres ved at der sørges for, at de grene som forventes 

at have en god løsning søges igennem først, s˚aledes at der formentligt vil være et 

godt udgangspunkt for at stoppe de d˚arligere løsninger p˚a et tidligere tidspunkt.

70 Optimering af Minimax

Kapitel 6 

Begrænsning af antallet af 

undersøgte træk 

6.1 Local Area 

Ideen med Local Area AI’en et at fokusere søgningen omkring et lille omr˚ade, 

der s˚a til gengæld søges helt til bunds. Omr˚adet lægges omkring modstanderens 

seneste træk, med mindre det er Local Area AI’en der starter. I s˚a fald ligger 

den bare en brik p˚a midten af brættet. Denne AI vil formentligt spille mere 

defensivt end offensivt, da den fokusere p˚a modstanderens træk som udgangspunkt. 

I praksis er det blot Minimax algoritmen med Alpha-Beta pruning, der 

sættes til at spille p˚a en lille plade midt i den store plade. Heuristikken vurdere 

dog spillet p˚a hele pladen og ikke kun det lokale omr˚ade. Dette betyder at 

figurer, der ligger op ad det lokale omr˚ade, f˚ar den indflydelse de skal have p˚a 

scoren som AI’en vælger sit træk ud fra. Local Area AI’en kører med et lokalt 

omr˚ade p˚a 4x4, da dette er den største plade, hvor p˚a Minimax algoritmen med 

Alpha-Beta pruning kan finde den fuldstændige løsning. 

Hvis modstanderen lægger sin brik tæt p˚a kanten af brættet flytter AI’en det 

lokale omr˚ade længere ind mod midten for fortsat at udnytte hele regnearealet.

72 Begrænsning af antallet af undersøgte træk 

Figur 6.1: Eksempel p˚a søge areal rundt om seneste brik. 

6.1.1 Fordele og ulemper: 

Fordelen ved denne AI er at den vil fungere ved en hver brætstørrelse, s˚a længe 

brættet bare er mindst fire gange fire. 


Det er muligt at denne AI kan forbedres ved at søgearealet udvides p˚a bekostning 

af søgedybden. 

6.2 Growth 

Growth AI’en bygger p˚a, at det kun er de to største figurer for hver spiller, der 

er relevante for spillet og at disse kun er relevante s˚a længe der er mulighed for 

at udvide dem. Dermed er alt andet end de to største figurer, der stadig har

6.2 Growth 73 

mulighed for udvidelse, irrelevant og ikke værd at bruge tid p˚a at undersøge. 

Forskellen p˚a denne kunstige intelligens og den sædvanlige Minimax algoritme 

er, at hvor den almindelige AI lader en mulig efterkommer opst˚a, lader Growth 

AI’en kun efterkommer opst˚a som ligger op ad de to største figurer med mulighed 

for udvidelse. Disse efterkommer vil gøre en af to ting, enten vil de udvide 

AI’ens egen figurer eller ogs˚a vil de fratage modstanderen nogle af mulighederne 

for udvidelse p˚a sine største figurer. Denne AI kaldes netop Growth, fordi efterkommerne 

s˚a at sige vokser ud fra de største figurer, hvor der er mulighed for det. 

Figur 6.2: Eksempel p˚a hvor Growth forsøger at lægge brikker. Hver rød streg 

repræsenterer en brik og den samme brik vendt 180 grader.

74 Begrænsning af antallet af undersøgte træk 

Figur 6.3: Hvor Growth forsøger sig med at lægge brikker efter den nye brik er 

blevet lagt som forsøg. 

6.2.1 Fordele: 

Der vil blive set mere p˚a det i testafsnittet, men i praksis ser Growth ud til 

at spille lige op med den almindelige Alpha-Beta Minimax algoritmen b˚ade p˚a 

resultat og afviklingstid, n˚ar de spiller med samme søgedybde. Dette betyder at 

hvis det lykkes ogs˚a at implementere Alpha-Beta pruning p˚a Growth AI’en, vil 

denne formentligt f˚a muligheden for at regne en generation dybder end Minimax 

algortimen med Alpha-Beta pruning. Om ikke anden s˚a i hvert fald øge 

søgedybden tidligere i spillet. 

6.2.2 Ulemper: 

Der vil opst˚a tilfælde, hvor det bedre kan betale sig at lægge en brik lidt væk fra 

de største figurer og lade modstanderen forbinde figurerne. Dette vil dog aldrig 

ske med denne AI, da der kun ses p˚a mulighederne lige opad de størstefigurer. 

Med den nuværende heuristik lider denne kunstige intelligens ogs˚a under at 

famle i blinde, n˚ar de største figurer ikke længere har muligheden for udvidelser,

6.2 Growth 75 

og de næststørste figurer har lang vej igen for n˚a op p˚a de største. Det ser dog 

ikke ud som om den famler helt s˚a meget i blinde, da den altid placerer brikkerne 

op ad de næststørste figurer med mulighed for udvidelse. Men om de brikker 

den lægger op ad disse figurer hjælper sig selv eller modstanderen, er den stadig 

komplet blind over for. 

Et trejde problem 


Som det første er der at f˚a implementeringen af Alpha-Beta pruning til at fungere. 

P˚a nuværende tidspunkt er aplha-beta pruningen sl˚aet fra, da den ikke 

fungerer korrekt. Derudover er der muligheden for at forbedre heuristikken, s˚a 

den ikke længere famler i blinde n˚ar søgedybden ikke dækker over problemet 

med store afsluttede figurer. Som alternativ til forbedring af heuristikken, kunne 

skabelsen af efterkommer ændres s˚aledes, at den kun lægger brikker, s˚a de 

udvider egne figurer eller tager muligheder fra modstanderens, hvor den nu afprøver 

f.eks. at lægge den sorte ende af en brik op mod sin egen hvide figur 

eller lægge en sort ende op mod modstanderens sorte figur. Dette vil dog reducere 

mængden af træk, som bliver undersøgt med en faktor to p˚a godt og ondt. 

Afviklingstiden vil falde, og dette vil give mulighed for dybere søgninger, men 

sandsynligheden for at en bedre løsning ikke bliver undersøgt vil ogs˚a stige.

76 Begrænsning af antallet af undersøgte træk

Kapitel 7 

Test og sammenligning af de 

implementerede AI’er 

I dette afsnit vil de forskellige kunstige intelligenser blive test og sammenlignet. 

Udover de komplementerende AI’er vil Taiji designeren Néstor Romeral Andrés’ 

egen AI ogs˚a indg˚a i testen, s˚a det er muligt at sammenligne resultaterne. De 

forskellige AI’er vil blive afprøvet mod en menneskelige modstander, mod hinanden 

s˚a vidt muligt og der vil blive taget tid p˚a hvor hurtigt beregningerne 

bliver udført. 

7.1 Test af Néstor’s AI 

Néstor’s egen AI spiller kun med standard brætstørrelsen p˚a ni gange ni felter 

og vil derfor kun blive testet for denne størrelse. Néstor’s AI har fire sværdheds 

grader, hvor 1 er den letteste og 4 er den sværeste, 4 kræver ogs˚a længst tid 

til at beregne sit træk. De fire sværhedsgrader g˚ar ogs˚a under navne Basic (1), 

Intermediate (2), Expert (3) og Master (4).

78 Test og sammenligning af de implementerede AI’er 

7.1.1 Kørselstider for Néstor’s AI: 

Her under ses gennemsnits kørsels tiderne for Néstor’s AI taget over de første 

10 træk: 

Basic Intermediate Expert Master 

9x9 ca. 1 sek ca. 3 sek ca 15 sek ca. 50 sek 

De to mest krævende sværhedsgrader Expert og Master bliver dog mærkbart 

hurtigere n˚ar spillet nærmere sig enden, f.eks bruger Master omkring 25 sekunder 

n˚ar der er cirka 15 træk tilbage og ca. 10 sekunder n˚ar der er cirka 8 træk 

tilbage. 

Beregningstiderne for de to letteste sværhedsgrader er helt i orden. Intermediate 

er lige i overkanten, da en menneskelig modstander vil n˚a at blive en smule 

ut˚almodig inden computeren foretager sit træk. Master er derimod helt uacceptabel 

med beregningstider der tager op i mod et minut. Et spil Taiji forventes 

at vare omkring 20 minutter mellem to menneskelige spiller 1 , hvor der bruges 

længere tid p˚a at fysisk lægge brikkerne og der formentligt snakkes lidt, og der 

bliver tænkt lidt længere over trækkene end mod en computer, hvor ens ære 

ikke st˚ar p˚a spil p˚a samme m˚ade. Et spil Taiji kan indeholde op til 40 træk 

og minimum 27, AI’en kommer til at st˚a for halvdelen af disse. Dette betyder 

at AI’en alene kommer til at st˚a for rundt regnet et kvartes betænkningstid i 

løbet af et enkelt spil. Til sammenligning kan et spil mod Intermediate sagtens 

afsluttes p˚a 3 minutter til den menneskelige spillers fordel. 

7.1.2 Test af Néstor’s AI mod menneskelig modstander: 

Her bliver Néstor’s AI stillet overfor en erfaren menneskelig modstander, hvilket 

jeg efterh˚anden godt kan tillade mig at kalde mig selv. Basic er ikke taget med 

i testen, da dennes eneste fordel er dens lave beregningstid, hvor Intermediate 

er storset lige s˚a hurtig, men er betydeligt smartere. 

Intermediate (sort) mod erfaren menneskelig spiller (hvid): 

1 Tal fra boardgamegeek.com

7.1 Test af Néstor’s AI 79 

9x9 Hvid score Sort score stilling for AI 

18 17 Tabt 

19 16 Tabt 

14 9 Tabt 

30 12 Tabt 

19 14 Tabt 

I alt 100 68 0% 

Intermediate (hvid) mod erfaren menneskelig spiller (sort): 


15 29 Tabt 

9 22 Tabt 

12 20 Tabt 

10 15 Tabt 

10 24 Tabt 

I alt 56 110 0% 

Intermediate vinder alts˚a ingen af sine 10 spil, hverken som sort eller hvid spiller. 

Gennemsnitligt taber den med 8,6 point og det nærmeste den kommer uafgjort 

er en forskel p˚a 3 point. 

Expert (sort) mod erfaren menneskelig spiller (hvid): 


22 11 Tabt 

25 11 Tabt 

19 16 Tabt 

26 9 Tabt 

19 12 Tabt 

I alt 111 59 0% 

Expert (hvid) mod erfaren menneskelig spiller (sort): 


14 19 Tabt 

13 24 Tabt 

12 24 Tabt 

14 29 Tabt 

16 32 Tabt 

I alt 69 128 0% 

Expert vinder heller ikke nogen af sine 10 spil. Gennemsnitligt taber den med 

11,1 point, men til gengæld kommer den tæt p˚a at afslutte et enkelt spil med


uafgjort med kun et points forskel. 

Master (sort) mod erfaren menneskelig spiller (hvid): 


22 14 Tabt 

12 11 Tabt 

17 14 Tabt 

19 8 Tabt 

24 12 Tabt 

I alt 94 59 0% 

Master (hvid) mod erfaren menneskelig spiller (sort): 


9 17 Tabt 

11 19 Tabt 

15 29 Tabt 

11 18 Tabt 

12 17 Tabt 

I alt 58 100 0% 

Master taber ogs˚a alle sine 10 spil p˚a trods af sine lange beregningstider. Den 

taber dog gennemsnitligt med point 7,7 points, hvilket har været det laveste 

indtil videre. Samtidigt kommer den i et enkelt tilfælde lige s˚a tæt p˚a uafgjort 

som Expert med et enkelt points forskel. 

7.1.3 Sammenfatning af resultatet for Néstor’s AI: 

Néstor’s AI beregner hurtigt et træk ved de to laveste sværhedsgrader, men 

sætter nærmeste brikkerne tilfældigt ved den laveste sværhedsgrad og yder ikke 

den store modstand p˚a Intermediate. 

Expert sværhedsgraden bruger typisk en 15 sekunder p˚a at beregne sit træk, 

hvilket er fem gange s˚a meget som Intermediate, p˚a trods af dette klarede den 

sig gennemsnitligt ikke meget bedre en denne, dog kom den i et enkelt tilfælde 

tættere p˚a et uafgjort resultat. 

Master kan bruge næsten et helt minut p˚a at beregne sit træk, p˚a trods af dette 

opn˚aede den kun nederlag overfor den erfarende menneskelige spiller. Den klarere 

sig dog bedre end de alle de lavere sværhedsgrader, s˚a længe der ses bort 

fra beregningstiden. 

Det kunne forventes at Masters lange beregningstider ogs˚a har givet den menneskelige 

spiller længere tid til at overveje sit næste træk, og at dette har været

7.2 Test af AlphaBeta AI (udviklet af Morten Rask) 81 

med til at danne resultatet med en kun let fremgang fra forrige niveau. I praksis 

har de lange beregningstid dog betydet at jeg som testperson er g˚aet helt væk 

fra spillet og lavet noget andet indimellem i de lange ventetider. 

7.2 Test af AlphaBeta AI (udviklet af Morten 

Rask) 

AlphaBeta bruger en minimax søgning med alpha beta pruning. Den eneste forskel 

mellem den almindelige minimax AI og AlphaBeta versionen er beregningstiden. 

Var det ikke for det tilfældige valg mellem lige gode træk ville AlphaBeta 

og minimax AI’en altid vælge samme træk. 

7.2.1 Kørselstider for AlphaBeta AI’en: 

For en fuld søgningen gennem spilgrafen for en fire gange fire plade, har de 

længste beregningstider altid været for det første træk, hvor der selvfølgelig er 

mest at regne igennem. Disse søgninger har taget lidt under 6 sekunder. Starter 

den anden spiller skal AlphaBeta AI’en beregne et træk mindre, beregningstiden 

her svinger mellem 1,7 og 3,3 sekunder afhængigt af hvilket træk modstanderen 

foretager. Alle beregningstider herefter er ubetydeligt sm˚a. 

P˚a en ni gange ni plade, hvor dybden bliver begrænset, har de længste beregningstider 

gennem fem spil været p˚a lige under fire sekunder langt de fleste tider 

har dog ligget under to sekunder. 

7.2.2 Test af AlphaBeta AI med fuld søgning 

AlphaBeta AI’en kan højst kører p˚a en fire gange fire plade, hvis søgningen skal 

g˚a helt til bunds i spilgrafen. Forventningerne er at det ikke vil være muligt 

at opn˚a et bedre resultat end uafgjort mod AlphaBeta AI’en p˚a den størrelse 

plade. Lykkedes det at besejre denne AI vil det enten betyde at der er en vinderstrategi 

for brætstørrelsen fire gange fire, eller at der er en fejl i AI’en. 

AI’en beregninger siger at der ikke er nogen vinderstrategier, da AI’en selv efter 

en fuld søgning giver alle de mulige start træk enten værdien 0, ufgjort, eller 

-1, tabt. Ergo vil AI’en altid kunne f˚a uafgjort uanset hvordan modstanderen 

spiller. -1-værdierne p˚a først træk betyder ogs˚a, at der er start træk, som altid 

vil lede til et nederlag, mod en modstander der ikke beg˚ar fejl.


Da AI’en ikke mener, der er nogle vinderstrategier, vil et nederlag for AI’en 

betyde at den ikke fungere korrekt, dette vil dog hverken bekræft eller udelukke 

om der er en vinderstrategi eller ej. 

AlphaBeta (hvid) mod erfaren menneskelig spiller (sort): 


6 6 Uafgjort 

3 3 Uafgjort 

6 6 Uafgjort 

5 5 Uafgjort 

7 7 Uafgjort 

7 7 Uafgjort 

5 5 Uafgjort 

7 6 Vundet 

6 6 Uafgjort 

7 7 Uafgjort 

I alt 59 58 55% 

Gennem ti spil med AlphaBeta spillende som hvid, har den som forventet aldrig 

tabt og derud over vundet et enkelt spil. 

AlphaBeta (sort) mod erfaren menneskelig spiller (hvid): 


4 4 Uafgjort 

2 2 Uafgjort 

6 6 Uafgjort 

2 2 Uafgjort 

5 5 Uafgjort 

7 7 Uafgjort 

7 7 Uafgjort 

7 7 Uafgjort 

6 6 Uafgjort 

6 6 Uafgjort 

I alt 52 52 50% 

Heller ikke n˚ar den menneskelige spiller starter f˚ar AlphaBeta AI’en et d˚arligere 

resultat end uafgjort. 

AI’ens værdier p˚a mulighederne for første træk viste at nogle disse ville føre 

til nederlag mod en modstander som ikke laver fejl. Det er disse to træk og alle 

spejlinger og rotationerne af disse:

7.2 Test af AlphaBeta AI (udviklet af Morten Rask) 83 

Figur 7.1: De to træk der leder til nederlag (for hvid spiller, n˚ar hvid starter). 

Herunder forsøger den menneskelige spiller at vinde eller f˚a uafgjort efter at 

være startet med et af disse to træk. 

AlphaBeta (sort) mod erfaren menneskelig spiller, som starter med nederlags 

træk (hvid): 


4 5 Vundet 

3 5 Vundet 

3 5 Vundet 

5 7 Vundet 

7 8 Vundet 

3 4 Vundet 

4 5 Vundet 

3 5 Vundet 

4 6 Vundet 

3 4 Vundet 

I alt 39 54 100% 

Det kan ses at AI’en vinder alle spillene, n˚a den menneskelige spiller starter 

med et af de to træk, som AI’en har vurderet ender i nederlag. Dette p˚aviser at 

der er starttræk der leder direkte til nederlag mod en øvet modstander. 

Disse test viser ogs˚a at de konklusioner, der blev draget ud fra værdierne for 

de forskellige starttræk, som AlphaBeta AI’en beregnede, har vist sig at holde 

stik gennem alle forsøgene. Der kan udfra dette konkluderes at AlphaBeta AI’en 

fungere korrekt, det vil dog kræve en komplet spilgraf for en fire gange fire plade, 

lavet i h˚anden at bevise dette, hvilket er en meget stor og uoverskuelige opgave, 

da der er godt og vel 30000 brættilstande for et spil p˚a fire gange fire og det er 

uden rotationer og spejlinger, hvor antallet for brætstørrelsen tre gange tre var 

p˚a lidt over 100.


7.2.3 Test af AlphaBeta AI mod menneskelig modstander: 

Her bliver AlphaBeta AI’en sat op imod en erfaren menneskelig modstander. 

AlphaBeta (sort) mod erfaren menneskelig spiller (hvid): 


17 18 Vundet 

10 11 Vundet 

20 12 Tabt 

24 14 Tabt 

17 18 Vundet 

I alt 88 73 60% 

AlphaBeta (hvid) mod erfaren menneskelig spiller (sort): 


15 18 Tabt 

16 15 Vundet 

20 22 Tabt 

16 20 Tabt 

14 14 Uafgjort 

I alt 81 89 30% 

Samlet set har AlphaBeta vundet 4 spil, tabt 5 og et endte i uafgjort. Dette 

giver en vindings procent p˚a 45% . N˚ar det kommer til ren score har den gennemsnitligt 

tabt med 2,3 point. Dens sejre har alle været snævre, mens nogle af 

dens nederlag har være af større karakter. 

Den menneskelige spiller har aldrig brugt mere end 5 sekunder p˚a sine træk. 

Dette har været tilstrækkeligt til udelukkende at sejr over Néstor’s AI, dette 

har dog ikke været tilfældet her, hvor kun 55% har været sejre. Menneskelige 

spiller er svære at h˚andtere, n˚ar det kommer til holde præstationen konstant. 

Motivation, mental tilstand, humør og t˚almodighed spiller alle ind p˚a kvaliteten 

af den menneskeliges spillers præstation, for ikke at nævne den konstant stigende 

erfaring med spillet. Det er derfor en god ide at opstille nogle rammer for 

den menneskelige modstand. F.eks. har den menneskelig modstander hidtil ikke 

brugt mere end fem sekunder p˚a at tænke over sit træk. Dette kan bruges som 

en regel til at holde den menneskelige modstander niveau lidt nede. Alternativ 

kun en regel, som at der minimum skal g˚a 15 sekunder før den menneskelige 

spiller foretager et træk, hjælper til at holde niveauet oppe. 

Det høje niveau har ikke været nødvendigt mod Néstor’s AI, men det kunne 

være interessant at prøve det op imod AlphaBeta AI’en for at se om dette giver

7.3 Test af LocalArea AI (designet og udviklet af Morten Rask) 85 

indflydelse p˚a resultatet. 

AlphaBeta (sort) mod erfaren menneskelig spiller min 15 sek (hvid): 


25 13 Tabt 

10 12 Vundet 

15 12 Tabt 

17 12 Tabt 

18 11 Tabt 

I alt 85 60 20% 

AlphaBeta (hvid) mod erfaren menneskelig spiller min 15 sek (sort): 


11 14 Tabt 

14 26 Tabt 

11 21 Tabt 

9 9 Uafgjort 

13 14 Tabt 

I alt 58 84 10% 

Det ekstra betænkningstid, som er blevet p˚atvunget den menneskelige spiller, 

har givet resultat. AlphaBeta AI’ens sejrs procent er g˚aet ned fra 45% til kun 

15% . Dette er uden tvivl et resultat af færre fejl p˚a grund bedre overvejede 

beslutninger fra den menneskelige side. 

7.3 Test af LocalArea AI (designet og udviklet 

af Morten Rask) 

LocalArea AI’en benytter en minimax søgning med alpha beta pruning til at 

søge et omr˚ade p˚a fire gange fire helt til bunds, uanset brættets størrelse. Dette 

omr˚ade placeres omkring modstanderens sidst lagte brik, er der ingen frie pladser 

inden for dette omr˚ade flyttets det til et sted hvor der er.


7.3.1 Test af LocalArea AI p˚a en 4x4 plade: 

Denne test er i sig selv ikke s˚a interessant, da resultatet skulle være præcist 

det samme som for AlphaBeta AI’en, da disse fungere ens p˚a en fire gange fire 

plade. Det er dog vigtigt at konstatere at LocalArea AI’en fungere korrekt inden 

den slippes løs p˚a de større brætter, hvor det vil være svært at gennemskue 

forskellen mellem deciderede fejl og generelle problemer med netop den metode. 

Her gør rammerne det tydeligt hvorvidt AI’en fungere, da en lokal fuld dybde 

søgning p˚a fire gange fire anvendt p˚a et fire gange fire bræt, ikke m˚a kunne tabe. 

LocalArea (sort) mod AlphaBeta (hvid): 

4x4 Hvid score Sort score stilling for LocalArea 

6 6 Uafgjort 

2 2 Uafgjort 

6 6 Uafgjort 

5 5 Uafgjort 

6 6 Uafgjort 

5 5 Uafgjort 

6 6 Uafgjort 

8 8 Uafgjort 

4 4 Uafgjort 

5 5 Uafgjort 

I alt 53 53 50% 

LocalArea (hvid) mod AlphaBeta (sort): 

4x4 Hvid score Sort score stilling for LocalArea 

4 4 Uafgjort 

6 6 Uafgjort 

5 5 Uafgjort 

5 5 Uafgjort 

2 2 Uafgjort 

4 4 Uafgjort 

5 5 Uafgjort 

4 4 Uafgjort 

4 4 Uafgjort 

6 6 Uafgjort 

I alt 45 45 50% 

Alle spil endte i uafgjort mellem AlphaBeta og LocalArea, hvilket tyder p˚a 

at LocalArea udfører sin søgning p˚a sit fire gange fire areal korrekt.

7.4 Test af Growth AI (designet og udviklet af Morten Rask) 87 

7.3.2 Test af LocalArea AI p˚a en 9x9 plade: 

P˚a en plade større end fire gange fire tildeler LocalArea trækmulighederne forkert 

værdier, i form af enten ∞ eller −∞ . De mulige træk placeres dog korrekt 

indenfor det p˚agældende fire gange fire omr˚ade. 

Det interessante ved fejlen for LocalArea AI’en er, udover at den virker fint 

for et 4x4 bræt, at der er b˚ade negative og positive ”uendelige”værdier, ofte vil 

der kun være et fortegn, hvis der f.eks. er blevet lavet en fortegnes fejl s˚a en 

værdi, der skulle være meget lille, er s˚a stor at den overtrumfer alt. 

Jeg er overbevidst om at forklaring skal findes i, at undersøgelsen af hvorvidt 

en brættilstand har n˚aet bunden eller ej ikke længere fungerer korrekt, da der 

stadig kan findes lovlige træk uden for arealet som LocalAera koncentrer sig 

om. Derfor ender alle værdier med at blive p˚a det minimum eller maksimum de 

fik tildelt fra start af. De endelige brættilstande bliver ikke vurderet til at være 

endelige brættilstande, men de f˚ar heller ikke nogle børn, da alle pladser inden 

for arealet er optaget. Grund til der b˚ade opst˚ar positive og negative værdi er 

fordi det vil være forskelligt om de endelige brættilstande er af lige eller ulige 

generation, derfor bliver nogle h˚andteret af Min-funktionen og f˚ar værdien ∞, 

mens andre af Max-funktionen og f˚ar −∞. 

En løsning ville være at lave en nye funktion til at vurdere, hvorvidt en brættilstand 

er endelige ud fra det lokal areal i stedet for hele brættet. 

7.4 Test af Growth AI (designet og udviklet af 

Morten Rask) 

7.4.1 Test af Growth AI’en p˚a en 4x4 plade: 

Det er interessant at se hvordan Growth klare sig mod AlphaBeta, da Growth 

netop ser bort fra træk der anses som uinteressante, mens AlphaBeta forsøger 

sig med alle træk. Denne test vil visse om de træk Growth ser bort fra virkeligt 

er uinteressante eller om det lykkedes AlphaBeta at vinde netop p˚a grund af 

disse træk. 

Growth (sort) mod AlphaBeta (hvid):


4x4 Hvid score Sort score stilling for Growth 

4 4 Uafgjort 

6 6 Uafgjort 

5 5 Uafgjort 

4 4 Uafgjort 

7 7 Uafgjort 

4 4 Uafgjort 

4 4 Uafgjort 

4 4 Uafgjort 

5 5 Uafgjort 

5 5 Uafgjort 

I alt 48 48 50% 

Growth (hvid) mod AlphaBeta (sort): 

4x4 Hvid score Sort score stilling for Growth 

4 4 Uafgjort 

4 4 Uafgjort 

6 6 Uafgjort 

4 4 Uafgjort 

4 4 Uafgjort 

6 6 Uafgjort 

5 5 Uafgjort 

4 4 Uafgjort 

4 4 Uafgjort 

4 4 Uafgjort 

I alt 45 45 50% 

Testen viser at Growth p˚a en fire gange fire plade ikke er AlphaBeta underlegen 

p˚a trods af at den undersøger færre træk. 

P˚a en lille plade som fire gange fire er det dog rimeligt begrænset hvor mange 

træk Growth ser bort fra. Jo større pladen bliver jo større bliver forskellen 

mellem antallet af undersøgte træk for Growth og AlphaBeta. Om resultatet vil 

være et andet for større plader er svært at sige, da det ikke er muligt at lave en 

fuld søgning p˚a plader større end fire gange fire. 

7.4.2 Test af Growth AI’en p˚a en 9x9 plade: 

Growth (sort) mod erfaren menneskelig spiller (hvid):

7.4 Test af Growth AI (designet og udviklet af Morten Rask) 89 


11 12 Vundet 

15 12 Tabt 

18 17 Tabt 

14 12 Tabt 


I alt 69 64 30% 

Growth (hvid) mod erfaren menneskelig spiller (sort): 


17 19 Tabt 

14 18 Tabt 


19 12 Vundet 

15 10 Vundet 

I alt 64 82 50% 

Resultatet for Growth mod den erfaren menneskelige modstander, som maximum 

bruger 5 sekunder p˚a hvert træk, er lige s˚a godt som resultatet for Alpha- 

Beta ved samme test med 45% vundende spil. Lige som for AlphaBeta forsøges 

der ogs˚a mod den menneskelige spiller, hvor der bruges minimum 15 sekunder 

per træk. 

Growth (sort) mod erfaren menneskelig spiller min 15 sek(hvid): 


21 16 Tabt 

20 14 Tabt 

13 12 Tabt 

10 13 Vundet 

12 15 vundet 

I alt 76 70 40% 

Growth (hvid) mod erfaren menneskelig spiller min 15 sek(sort): 



11 12 Tabt 

14 15 Tabt 

12 11 Vundet 

11 14 Tabt 

I alt 58 62 30%


7.5 Sammenligning af AI’erne 

Der er foretaget færre spil med Néstor’s AI, da disse spil er langt mere tidskrævende 

end de andre, b˚ade fordi Néstor’s bedste af AI har lange beregningstider 

og fordi Néstor’s AI ikke kan spille direkte mod de andre AI’er eller mod sig 

selv. Det her derfor været nødvendigt manuelt at kopier træk frem og tilbage 

mellem AI’erne i hvert deres vindue. Skal en hvid Néstor AI f.eks spille mod en 

sort AlphaBeta, bliver det til en hvid Néstor AI mod en sort menneskelig spiller 

og en hvid menneskelig spiller mod en sort AlphaBeta, hvor den menneskelig 

spiller blot kopier Néstor AI’ens træk mod AlphaBeta i det andet vindue og 

omvendt. 

Resultatet i parentes er for de Officielle Regler, hvor uafgjort tæller som en 

sejr til sort. 

9x9: 

Hvid spiller Sort spiller antal spil hvid score sort score hvid% (OR) 

Néstor4 Néstor4 5 66 67 50% (40%) 

Néstor4 AlphaBeta 5 73 71 70% (60%) 

Néstor4 Growth 5 57 73 0% (0%) 

AlphaBeta AlphaBeta 10 171 165 65% (50%) 

AlphaBeta Néstor4 5 81 62 80% (80%) 

AlphaBeta Growth 10 147 162 30% (20%) 

Growth Growth 10 157 164 50% (40%) 

Growth Néstor4 5 90 75 90% (80%) 

Growth AlphaBeta 10 182 141 100% (100%) 

Mens AlphaBeta og Néstor4 har en vis tendens til at vinde over hinanden, n˚ar 

de spiller hvid, s˚a sl˚ar Growth dem begge overbevisende uanset hvilken farve 

den spiller som. 

N˚ar det kommer til beregningstiderne p˚a de tre er det mest sigende at lade 

dem kører et helt spil igennem mod sig selv: 

9x9 spil mod sig selv AlphaBeta Growth Néstor4 

tiden (gennemsnit af flere spil) ca. 30 sekunder ca. 1 minut ca. 19 minutter

Kapitel 8 

Konklusion 

Jeg m˚atte konstatere under testen af den AI, som Néstor Romeral Andrés har 

konstrueret til at spille Taiji, at den ikke er særlig anvendelig i praksis. Den er 

for langsom, n˚ar den skal yde sit ypperste for at vinde spillet. Desuden m˚atte 

jeg konkludere, at den ikke p˚a nogen af sine fire niveauer kan vinde over en 

kvalificeret menneskelig modstander. 

Derfor satte jeg for at teste, om det kunne lade sig gøre at n˚a et højere niveau 

med anvendelse af flere metoder indenfor AI. 

Hvis man ikke har ubegrænsede ressourcer som i IBM’s Deep Blue skakcomputerprojekt, 

er det afgørende at kombinere forskellige metoder og kunne benytte 

dem i velovervejet omfang, s˚aledes at man udnytter de tilgængelige computerkræfter 

smart og opn˚ar et anvendeligt resultat. 

I opbygningen af mine AI’er har jeg undersøgt forskellige teorier for kunstige 

intelligencer (AI’er) og gennemprøvet disse. Derefter har jeg kombineret dem 

som gav de bedste resultater og gav mest mening for den foreliggende opgave, at 

spille Taiji. Mit hovedform˚al har netop været at opn˚a en AI som netop opfører 

sig intelligent og samtidig en AI der er tilstrækkelig hurtig til at den kan anvendes 

i praksis. Desuden forlangte jeg at den skulle kunne vinde over en rimelig 

god menneskelig modstander. 

Min Growth AI er b˚ade hurtigt og smart. Growth AI’en kan i spil mod sig

92 Konklusion 

selv n˚a igennem et helt spil p˚a omkring et minut. Den samme opgave tager 

for Néstor Romeral Andrés’ kraftigste AI næsten 20 minutter. Men p˚a trods 

af at Néstor Romeral Andrés’ AI anvender godt 20 gange s˚a lang tid til sine 

beregninger som Growth, lykkedes det kun at vinde et ud 10 spil, og dette var 

ud fra de officielle regler, hvor et uafgjort resultat tæller som en sejr for sort. 

Growth vinder ni ud af ti gange, hvor den sidste en ud af ti endte uafgjort eller 

tabt afhængigt af reglerne. Og dette gjorde den p˚a kun ca. 5% af den tid Néstor 

Romeral Andrés’ AI anvendte. 

Desværre er resultatet ikke lige s˚a overbevisende mod en erfaren menneskelig 

spiller, hvor den vinder en tre-fire gange ud af ti spil, hvilket dog ogs˚a er et 

ganske glimmerende resultat sammenlignes med de andre AI’ers resultater. 

Min overordnede konklusion er derfor, at ved at benytte flere AI-teorier og 

kombinere disse p˚a gennemtænkt og gennemtestet m˚ade, kan man opn˚a væsentlige 

forbedringer vedr. afviklingshastighed uden at sætte ’intelligensen’ over 

styr. Dette er netop bevist med min AI. Derfor mener jeg ogs˚a det er rimeligt 

at konkludere at AI vil kunne anvendes med fordel i flere gennemanalyserede 

situationer. Disse situationer kan netop h˚andteres med AI uden at der behøves 

at anvendes overvældende computerkraft. 

Men ligesom det kan konkluderes at den kunstig intelligens kan bruges med fordel 

p˚a gennemanalyserede situationer, kan det tilsvarende konkluderes at: For 

situationer, hvor der ikke ligger en grundig analyse, der har afdækket alle udfaldsrum 

for en given situation, vil de typer AI som er anvendt i denne opgave 

ikke fungere. I situationer hvor ’spilbrættet’ ikke er kendt vil der være behov for 

andre metoder, der kan simulere en anden type intelligens, den type vi i daglig 

tale kalder intuition. 

8.0.1 Fremtidige udviklingsmuligheder: 

I fremtidsperspektivet for AlphaBeta AI’en er der mulighed at lave yderligere 

forbedringer, disse kun komme p˚a flere fronter, men det bedste resultat ville 

formentligt komme af kombinationer mellem nye tiltag og gamle fungerende 

metoder. 

Et omr˚ade hvor der kan indføres nogle nye tiltag er heuristikken. Nye heuristikker 

kunne laves, som i stedet for blot at se p˚a scoren, kan g˚a ind og se p˚a 

udvidelsesmulighederne for de største figurer eller ser p˚a hvor store de tredje 

største figurer er. Det bedste resultat vil nok ikke komme ved at udskifte den 

nuværende heuristik med en ny, men netop ved at kombinere den nuværende 

heuristik med nye, og finde en passende vægtning mellem dem. 

Vægtningen kunne f.eks. tilpasses ved hjælp af mere avancerede metoder inden 

for AI, som simuleret nedkøling eller neurale netværk. Vægtningen vil med disse 

metoder kunne tilpasses ud fra erfaringer med at spille spillet, og hvordan disse

spil med forskellige vægtninger er endt. 

Ses der p˚a den lidt nærmere fremtid kunne AlphaBeta AI’en forbedres ved 

hjælp af metoden, der bestemmer hvilke træk der undersøges i Growth AI’en. 

Dette skulle ske ved at trækkene, som growth nøjes med at undersøge, skulle 

undersøges først i AlphaBeta AI’en, mens de resterende træk kommer i anden 

række. Det er nemlig ret sandsynligt, at de bedste træk befinder sig indenfor 

de træk growth undersøger. Jo hurtigere AlphaBeta AI’en finder et godt 

træk jo bedre fungerer alpha-beta pruning, da den derved kan stoppe en lang 

række undersøgelser p˚a et tidligere tidspunkt. I praksis vil denne forbedring 

kunne betyde, at AlphaBeta AI’en kommer til at kunne klare en dybere søgning 

ned i spiltræet. Skulle det hermed lykkedes AlphaBeta AI’en at n˚a den samme 

søgedybde, som Growth AI’en leverer, vil AlphaBeta AI’en sandsynligvis g˚a hen 

og blive et bedre valg, fordi Growth AI’ens begrænsede søgning i vise tilfælde 

skader kvaliteten af dens resultat. 

Forbedringer for Growth AI’en kunne best˚a i at lade dens træk g˚a ud fra de 

tre største figurer for hver farve i stedet for blot de to største, som det har 

været hidtil. En forbedring af justeringen af søgedybden kunne ogs˚a hjælpe, da 

nogle træk bliver beregnet s˚a hurtigt, at det formentligt ville være muligt at 

tage en generation mere med i beregningen i disse tilfælde. Dette vil dog kræve 

en grundigere analyse af brættilstanden, da det ikke umiddelbart er til at gennemskue, 

i hvilke tilfælde beregningerne er hurtigt overst˚aet og hvorn˚ar de ikke 

er. 

93

94 Konklusion

Bilag A 

To be added 

A.1 AITaijiAlphaBeta.java 

Kildekode 

1 import java . u t i l . Random ; 

2 import java . u t i l . ArrayList ; 

3 

4 p u b l i c c l a s s AITaijiAlphaBeta { 

5 

6 p u b l i c TaijiModel tModel ; 

7 p u b l i c Node tNode ; 

8 p u b l i c i n t count ; // f o r at t e s t e hvor mange noder der l a v e s . 

9 p u b l i c i n t maxDepth ; 

10 p r i v a t e ArrayList [ ] [ ] nodes ; // i n d e h o l d e r a l l e noderne i 

a r r a y l i s t s e f t e r g e n e r a t i o n og hash v a e r d i . 

11 p r i v a t e i n t maxD; // den maximale dybde f o r t r a e e t . 

12 p r i v a t e i n t maxH ; // den maximale Hash v a e r d i 

13 p r i v a t e Node Root ; // Traeets rod . 

14 p r i v a t e i n t searchD ; // Search depth , muligheden f o r at s a e t t e 

en maximal s o e g e dybde 

15 

16 p u b l i c AITaijiAlphaBeta ( TaijiModel m) { 

17 t h i s . tModel = m; 

18 }

96 Bilag A 

19 

20 // i n i t i a l i s e r e r AlphaBeta 

21 p u b l i c void AlphaBeta ( ) { 

22 tNode = new Node ( ) ; 

23 Root = tNode . createNode ( tModel . currentTurn , tModel ) ; 

24 count = 1 ; 

25 maxD = tModel . maxTurnsLeft ( ) ; 

26 searchD = maxD; 

27 maxH = tModel . tHash . getMaxH3 ( ) ; 

28 nodes = new ArrayList [maxD ] [ maxH+1]; 

29 f o r ( i n t i =0; i = 8 && maxT < 10) 

57 setSearchDepth ( 3 ) ; 

58 i f (maxT > 6 && maxT < 8) 

59 setSearchDepth ( 4 ) ; 

60 i f (maxT

A.1 AITaijiAlphaBeta.java 97 

69 i n t h = tModel . tHash . hashFunction3 ( b ) ; 

70 p [0]= d ; / / d ; 

71 p [1]= h ; 

72 p[2]= −1; 

73 f o r ( i n t i = 0 ; i = searchD | | ! tModel . movesLeftN ( n ) ) { 

85 n . a = tModel . fMap . c a l D i f ( n . nodeBoard , tModel . noCols , 

tModel . noRows ) ; 

86 r e t u r n ( n . a ) ; 

87 } 

88 e l s e { 

89 i f ( ex == 1) { 

90 i f ( n . a >= beta ) 

91 r e t u r n ( n . a ) ; 

92 } 

93 n . a = −tModel . maxScore ; 

94 i n t [ ] [ ] b = n . nodeBoard ; 

95 i n t d = n . d ; 

96 f o r ( i n t c =0; c < tModel . noCols ; c++){ 

97 f o r ( i n t r =0; r < tModel . noRows−1; r++){ 

98 i f ( b [ c ] [ r ] == 2 && b [ c ] [ r +1] == 2 ) { 

99 b [ c ] [ r ] = 1 ; 

100 b [ c ] [ r +1] = 0 ; 

101 i n t [ ] p = new i n t [ 3 ] ; 

102 p = c h e c k B o a r d I n d i v i d u a l i t y ( b , d ) ; 

103 i f ( p [ 2 ] >= 0) { 

104 nodes [ p [ 0 ] ] [ p [ 1 ] ] . get ( p [ 2 ] ) . par . add ( n ) ; 

105 n . c h i l d r e n . add ( nodes [ p [ 0 ] ] [ p [ 1 ] ] . get ( p 

[ 2 ] ) ) ; 

106 i n t v = min ( nodes [ p [ 0 ] ] [ p [ 1 ] ] . get ( p [ 2 ] ) 

, alpha , beta , 1 ) ; 

107 i f ( n . a < v ) 

108 n . a = v ; 

109 i f ( n . a > beta ) { 

110 b [ c ] [ r ] = 2 ; 

111 b [ c ] [ r +1] = 2 ; 

112 r e t u r n ( n . a ) ; 

113 } 

114 i f ( alpha < n . a ) 

115 alpha = n . a ; 

116 

117 } 

118 i f ( p [ 2 ] == −1){ 

119 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ;

98 Bilag A 

120 nodes [ p [ 0 ] ] [ p [ 1 ] ] . add ( n . addChild ( tNode . 

createChildNode ( c , r , c , r +1, n ) ) ) ; 

121 count++; 


, alpha , beta , 0 ) ; 

123 i f ( n . a < v ) 

124 n . a = v ; 

125 i f ( n . a > beta ) { 

126 b [ c ] [ r ] = 2 ; 

127 b [ c ] [ r +1] = 2 ; 

128 r e t u r n ( n . a ) ; 

129 } 

130 i f ( alpha < n . a ) 

131 alpha = n . a ; 

132 

133 } 

134 b [ c ] [ r ] = 0 ; 

135 b [ c ] [ r +1] = 1 ; 


137 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

141 i f ( n . a < v ) 

142 n . a = v ; 

143 i f ( n . a > beta ) { 

144 b [ c ] [ r ] = 2 ; 

145 b [ c ] [ r +1] = 2 ; 

146 r e t u r n ( n . a ) ; 

147 } 

148 i f ( alpha < n . a ) 

149 alpha = n . a ; 

150 } 

151 i f ( p [ 2 ] == −1){ 

152 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 


createChildNode ( c , r +1, c , r , n ) ) ) ; 

154 count++; 


, alpha , beta , 0 ) ; 

156 i f ( n . a < v ) 

157 n . a = v ; 

158 i f ( n . a > beta ) { 

159 b [ c ] [ r ] = 2 ; 

160 b [ c ] [ r +1] = 2 ; 

161 r e t u r n ( n . a ) ; 

162 } 

163 i f ( alpha < n . a ) 

164 alpha = n . a ; 

165 } 

166 

167 b [ c ] [ r ] = 2 ; 

168 b [ c ] [ r +1] = 2 ;


169 } 

170 } 

171 } 

172 

173 f o r ( i n t c =0; c < tModel . noCols −1; c++){ 

174 f o r ( i n t r =0; r < tModel . noRows ; r++){ 

175 i f ( b [ c ] [ r ] == 2 && b [ c +1][ r ] == 2 ) { 

176 b [ c ] [ r ] = 1 ; 

177 b [ c +1][ r ] = 0 ; 

178 i n t [ ] p = new i n t [ 3 ] ; 


180 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

184 i f ( n . a < v ) 

185 n . a = v ; 

186 i f ( n . a > beta ) { 

187 b [ c ] [ r ] = 2 ; 

188 b [ c +1][ r ] = 2 ; 

189 r e t u r n ( n . a ) ; 

190 } 

191 i f ( alpha < n . a ) 

192 alpha = n . a ; 

193 } 

194 i f ( p [ 2 ] == −1){ 

195 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 


createChildNode ( c , r , c +1, r , n ) ) ) ; 

197 count++; 


, alpha , beta , 0 ) ; 

199 i f ( n . a < v ) 

200 n . a = v ; 

201 i f ( n . a > beta ) { 

202 b [ c ] [ r ] = 2 ; 

203 b [ c +1][ r ] = 2 ; 

204 r e t u r n ( n . a ) ; 

205 } 

206 i f ( alpha < n . a ) 

207 alpha = n . a ; 

208 } 

209 b [ c ] [ r ] = 0 ; 

210 b [ c +1][ r ] = 1 ; 


212 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

216 i f ( n . a < v ) 

217 n . a = v ;

100 Bilag A 

218 i f ( n . a > beta ) { 

219 b [ c ] [ r ] = 2 ; 

220 b [ c +1][ r ] = 2 ; 

221 r e t u r n ( n . a ) ; 

222 } 

223 i f ( alpha < n . a ) 

224 alpha = n . a ; 

225 } 

226 i f ( p [ 2 ] == −1){ 

227 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 


createChildNode ( c +1, r , c , r , n ) ) ) ; 

229 count++; 


, alpha , beta , 0 ) ; 

231 i f ( n . a < v ) 

232 n . a = v ; 

233 i f ( n . a > beta ) { 

234 b [ c ] [ r ] = 2 ; 

235 b [ c +1][ r ] = 2 ; 

236 r e t u r n ( n . a ) ; 

237 } 

238 i f ( alpha < n . a ) 

239 alpha = n . a ; 

240 } 

241 b [ c ] [ r ] = 2 ; 

242 b [ c +1][ r ] = 2 ; 

243 } 

244 } 

245 } 

246 r e t u r n ( n . a ) ; 

247 } 

248 } 

249 

250 // Min−f u n k t i o n e n i minimax−soegningen 

251 p r i v a t e i n t min ( Node n , i n t alpha , i n t beta , i n t ex ) { 

252 i f ( n . d >= searchD | | ! tModel . movesLeftN ( n ) ) { 



254 r e t u r n ( n . a ) ; 

255 } 

256 e l s e { 

257 i f ( ex == 1) { 

258 i f ( n . a



271 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 

274 i n t v = max( nodes [ p [ 0 ] ] [ p [ 1 ] ] . get ( p [ 2 ] ) 

, alpha , beta , 1 ) ; 

275 i f ( n . a > v ) 

276 n . a = v ; 

277 i f ( n . a < alpha ) { 

278 b [ c ] [ r ] = 2 ; 

279 b [ c ] [ r +1] = 2 ; 

280 r e t u r n ( n . a ) ; 

281 } 

282 i f ( beta > n . a ) 

283 beta = n . a ; 

284 } 

285 i f ( p [ 2 ] == −1){ 

286 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



288 count++; 


, alpha , beta , 0 ) ; 

290 i f ( n . a > v ) 

291 n . a = v ; 

292 i f ( n . a < alpha ) { 

293 b [ c ] [ r ] = 2 ; 

294 b [ c ] [ r +1] = 2 ; 

295 r e t u r n ( n . a ) ; 

296 } 

297 i f ( beta > n . a ) 

298 beta = n . a ; 

299 } 

300 b [ c ] [ r ] = 0 ; 

301 b [ c ] [ r +1] = 1 ; 

302 


304 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

308 i f ( n . a > v ) 

309 n . a = v ; 

310 i f ( n . a < alpha ) { 

311 b [ c ] [ r ] = 2 ; 

312 b [ c ] [ r +1] = 2 ; 

313 r e t u r n ( n . a ) ; 

314 } 

315 i f ( beta > n . a ) 

316 beta = n . a ; 

317 } 

318 i f ( p [ 2 ] == −1){

102 Bilag A 

319 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



321 count++; 


, alpha , beta , 0 ) ; 

323 i f ( n . a > v ) 

324 n . a = v ; 

325 i f ( n . a < alpha ) { 

326 b [ c ] [ r ] = 2 ; 

327 b [ c ] [ r +1] = 2 ; 

328 r e t u r n ( n . a ) ; 

329 } 

330 i f ( beta > n . a ) 

331 beta = n . a ; 

332 } 

333 b [ c ] [ r ] = 2 ; 

334 b [ c ] [ r +1] = 2 ; 

335 

336 

337 } 

338 } 

339 } 

340 

341 



344 i f ( b [ c ] [ r ] == 2 && b [ c +1][ r ] == 2 ) { 

345 b [ c ] [ r ] = 1 ; 

346 b [ c +1][ r ] = 0 ; 

347 i n t [ ] p = new i n t [ 3 ] ; 


349 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

353 i f ( n . a > v ) 

354 n . a = v ; 

355 i f ( n . a < alpha ) { 

356 b [ c ] [ r ] = 2 ; 

357 b [ c +1][ r ] = 2 ; 

358 r e t u r n ( n . a ) ; 

359 } 

360 i f ( beta > n . a ) 

361 beta = n . a ; 

362 } 

363 i f ( p [ 2 ] == −1){ 

364 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



366 count++; 


, alpha , beta , 0 ) ;


368 i f ( n . a > v ) 

369 n . a = v ; 

370 i f ( n . a < alpha ) { 

371 b [ c ] [ r ] = 2 ; 

372 b [ c +1][ r ] = 2 ; 

373 r e t u r n ( n . a ) ; 

374 } 

375 i f ( beta > n . a ) 

376 beta = n . a ; 

377 } 

378 b [ c ] [ r ] = 0 ; 

379 b [ c +1][ r ] = 1 ; 

380 


382 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

386 i f ( n . a > v ) 

387 n . a = v ; 

388 i f ( n . a < alpha ) { 

389 b [ c ] [ r ] = 2 ; 

390 b [ c +1][ r ] = 2 ; 

391 r e t u r n ( n . a ) ; 

392 } 

393 i f ( beta > n . a ) 

394 beta = n . a ; 

395 } 

396 i f ( p [ 2 ] == −1){ 

397 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



399 count++; 


, alpha , beta , 0 ) ; 

401 i f ( n . a > v ) 

402 n . a = v ; 

403 i f ( n . a < alpha ) { 

404 b [ c ] [ r ] = 2 ; 

405 b [ c +1][ r ] = 2 ; 

406 r e t u r n ( n . a ) ; 

407 } 

408 i f ( beta > n . a ) 

409 beta = n . a ; 

410 } 

411 b [ c ] [ r ] = 2 ; 

412 b [ c +1][ r ] = 2 ; 

413 } 

414 } 

415 } 

416 r e t u r n ( n . a ) ; 

417 } 

418 }

104 Bilag A 

419 

420 

421 

422 

423 

424 

425 // s a e t t e r s c o r e n f o r en node t i l −’ u e n d e l i g ’ 

426 p r i v a t e Node setScoreMin ( Node n ) { 


428 r e t u r n ( n ) ; 

429 } 

430 // s a e t t e r s c o r e n f o r en node t i l ” u e n d e l i g ” 

431 p r i v a t e Node setScoreMax ( Node n ) { 

432 n . a = tModel . maxScore ; 

433 r e t u r n ( n ) ; 

434 } 

435 

436 // u d s k r i v e r v a e r d i e r n e paa f o r a e l d r e n e t i l en Node 

437 p r i v a t e void p r i n t P a r S c o r e ( Node n ) { 

438 System . out . p r i n t (”AB p r i n t P a r S c o r e d=”+n . d+” n . par s c o r e s : 

”) ; 

439 f o r ( i n t i =0; i 1) { 

465 i f ( b ) { 

466 f o r ( i n t i =0; i Root . c h i l d r e n . get ( i ) . a ) {


468 n=Root . c h i l d r e n . get ( i ) ; 

469 } 

470 } 

471 } 

472 i f ( ! b ) { 

473 f o r ( i n t i =0; i

106 Bilag A 

517 n . wr = tModel . noRows−1 − wR; 

518 r e t u r n ( n ) ; 

519 } 

520 i f (mr == 5) { 

521 n . bc = bR ; 

522 n . wc = wR; 

523 n . br = bC ; 

524 n . wr = wC; 

525 r e t u r n ( n ) ; 

526 } 

527 i f (mr == 6) { 

528 n . bc = tModel . noRows−1 − bR ; 

529 n . wc = tModel . noRows−1 − wR; 

530 n . br = bC ; 

531 n . wr = wC; 

532 r e t u r n ( n ) ; 

533 } 

534 i f (mr == 7) { 

535 n . bc = bR ; 

536 n . wc = wR; 

537 n . br = tModel . noCols −1 − bC ; 

538 n . wr = tModel . noCols −1 − wC; 

539 r e t u r n ( n ) ; 

540 } 

541 i f (mr == 8) { 





546 r e t u r n ( n ) ; 

547 } 

548 r e t u r n ( n ) ; 

549 } 

550 

551 

552 } 

A.2 AITaijiGrowth.java 



3 

4 p u b l i c c l a s s AITaijiGrowth { 

5 









13 p r i v a t e Node Root ; // Traeets rod .

A.2 AITaijiGrowth.java 107 



15 

16 p u b l i c AITaijiGrowth ( TaijiModel m) { 


18 } 

19 

20 p u b l i c void Growth ( ) { 



23 count = 1 ; 

24 maxD = tModel . maxTurnsLeft ( ) ; // max dybden s p i l g r a f e n kan 

opnaa f i n d e s 

25 searchD = maxD; // soegedybden s a e t t e s som udgangspunkt t i l 

at gaa h e l t i bund 

26 maxH = tModel . tHash . getMaxH3 ( ) ; //maxH s a e t t e s udfra 

h v i l k e n h a s h funktion der anvendes 


28 f o r ( i n t i =0; i 7 && maxT 6 && maxT

108 Bilag A 

61 } 

62 } 

63 

64 // c h e c k e r om der a l l e r e d e e r e t saadant b r a e t . Returnerer 

c o r d i n a t e r n e f o r den node , h v i s der e r . 

65 p r i v a t e i n t [ ] c h e c k B o a r d I n d i v i d u a l i t y ( i n t [ ] [ ] b , i n t d ) { 

66 i n t [ ] p = new i n t [ 3 ] ; 


68 p [0]= d ; 

69 p [1]= h ; 

70 p[2]= −1; 




84 r e t u r n ( n . a ) ; 

85 } 

86 e l s e { 

87 i f ( ex == 1) { 

88 i f ( n . a >= beta ) 

89 r e t u r n ( n . a ) ; 

90 } 



93 i n t [ ] [ ] fb = new i n t [ tModel . noCols ] [ tModel . noRows ] ; 

94 i n t d = n . d ; 

95 i n t [ ] [ ] [ ] f i g s ; 

96 

97 

98 fb = tModel . fMap . getFigBoard ( n . nodeBoard , tModel . noCols 

, tModel . noRows ) ; 

99 f i g s = tModel . fMap . g e t F i g s ( fb ) ; 

100 

101 i f ( f a l s e ) { // s a e t t e s t i l t r u e f o r at p r i n t e f i g B o a r d 

og h v i l k e f i g u r e , der e r s t o e r s t med f r i e p l a d s e r 

omkring s i g . T i l t e s t brug 

102 System . out . p r i n t l n (” growth f i g s W: ”+ f i g s 

[ 1 ] [ 0 ] [ 0 ] + ” & ”+ f i g s [ 1 ] [ 1 ] [ 0 ] + ” B: ”+ f i g s 

[ 0 ] [ 0 ] [ 0 ] + ” & ”+ f i g s [ 0 ] [ 1 ] [ 0 ] ) ; 

103 printFB ( fb ) ; 

104 } 

105 

106 

107




110 i f ( fb [ c ] [ r ] == f i g s [ 1 ] [ 0 ] [ 0 ] | | fb [ c ] [ r ] == 

f i g s [ 1 ] [ 1 ] [ 0 ] | | fb [ c ] [ r ] == f i g s [ 0 ] [ 0 ] [ 0 ] 

| | fb [ c ] [ r ] == f i g s [ 0 ] [ 1 ] [ 0 ] ) { 

111 // o e s t 

112 i f ( c < tModel . noCols −1){ 

113 i f ( fb [ c +1][ r ] == 0) { 

114 i f ( r < tModel . noRows−1){ 

115 i f ( fb [ c +1][ r +1] == 0) { 

116 i n t [ ] r e ; 

117 b [ c +1][ r ] = 1 ; 

118 b [ c +1][ r +1] = 0 ; 

119 r e = placePieceMax ( b , d , n , 

c +1, r , c +1, r +1, 

alpha , beta ) ; 

120 alpha = r e [ 1 ] ; 

121 beta = r e [ 2 ] ; 

122 i f ( r e [ 0 ] == 1) { 

123 b [ c +1][ r ] = 2 ; 

124 b [ c +1][ r +1] = 2 ; 

125 r e t u r n ( r e [ 3 ] ) ; 

126 } 

127 b [ c +1][ r ] = 0 ; 

128 b [ c +1][ r +1] = 1 ; 


c +1, r +1, c +1, r , 


130 alpha = r e [ 1 ] ; 

131 beta = r e [ 2 ] ; 

132 i f ( r e [ 0 ] == 1) { 

133 b [ c +1][ r ] = 2 ; 

134 b [ c +1][ r +1] = 2 ; 

135 r e t u r n ( r e [ 3 ] ) ; 

136 } 

137 b [ c +1][ r ] = 2 ; 

138 b [ c +1][ r +1] = 2 ; 

139 } 

140 } 

141 i f ( r > 0) { 

142 i f ( fb [ c +1][ r −1] == 0) { 

143 i n t [ ] r e ; 

144 b [ c +1][ r ] = 1 ; 

145 b [ c +1][ r −1] = 0 ; 


c +1, r , c +1, r −1, 


147 alpha = r e [ 1 ] ; 

148 beta = r e [ 2 ] ; 

149 i f ( r e [ 0 ] == 1) { 

150 b [ c +1][ r ] = 2 ; 

151 b [ c +1][ r −1] = 2 ; 

152 r e t u r n ( r e [ 3 ] ) ; 

153 } 

154 b [ c +1][ r ] = 0 ;

110 Bilag A 

155 b [ c +1][ r −1] = 1 ; 


c +1, r −1, c +1, r , 


157 alpha = r e [ 1 ] ; 

158 beta = r e [ 2 ] ; 

159 i f ( r e [ 0 ] == 1) { 

160 b [ c +1][ r ] = 2 ; 

161 b [ c +1][ r −1] = 2 ; 

162 r e t u r n ( r e [ 3 ] ) ; 

163 } 

164 b [ c +1][ r ] = 2 ; 

165 b [ c +1][ r −1] = 2 ; 

166 } 

167 } 


169 i f ( fb [ c +2][ r ] == 0) { 

170 i n t [ ] r e ; 

171 b [ c +1][ r ] = 1 ; 

172 b [ c +2][ r ] = 0 ; 


c +1, r , c +2, r , alpha , 

beta ) ; 

174 alpha = r e [ 1 ] ; 

175 beta = r e [ 2 ] ; 

176 i f ( r e [ 0 ] == 1) { 

177 b [ c +1][ r ] = 2 ; 

178 b [ c +2][ r ] = 2 ; 

179 r e t u r n ( r e [ 3 ] ) ; 

180 } 

181 b [ c +1][ r ] = 0 ; 

182 b [ c +2][ r ] = 1 ; 


c +2, r , c +1, r , alpha , 

beta ) ; 

184 alpha = r e [ 1 ] ; 

185 beta = r e [ 2 ] ; 

186 i f ( r e [ 0 ] == 1) { 

187 b [ c +1][ r ] = 2 ; 

188 b [ c +2][ r ] = 2 ; 

189 r e t u r n ( r e [ 3 ] ) ; 

190 } 

191 b [ c +1][ r ] = 2 ; 

192 b [ c +2][ r ] = 2 ; 

193 } 

194 } 

195 } 

196 } 

197 // v e s t 

198 i f ( c > 0) { 

199 i f ( fb [ c −1][ r ] == 0) { 


201 i f ( fb [ c −1][ r +1] == 0) { 

202 i n t [ ] r e ; 

203 b [ c −1][ r ] = 1 ;


204 b [ c −1][ r +1] = 0 ; 


c −1, r , c −1, r +1, 


206 alpha = r e [ 1 ] ; 

207 beta = r e [ 2 ] ; 

208 i f ( r e [ 0 ] == 1) { 

209 b [ c −1][ r ] = 2 ; 

210 b [ c −1][ r +1] = 2 ; 

211 r e t u r n ( r e [ 3 ] ) ; 

212 } 

213 b [ c −1][ r ] = 0 ; 

214 b [ c −1][ r +1] = 1 ; 


c −1, r +1, c −1, r , 


216 alpha = r e [ 1 ] ; 

217 beta = r e [ 2 ] ; 

218 i f ( r e [ 0 ] == 1) { 

219 b [ c −1][ r ] = 2 ; 

220 b [ c −1][ r +1] = 2 ; 

221 r e t u r n ( r e [ 3 ] ) ; 

222 } 

223 b [ c −1][ r ] = 2 ; 

224 b [ c −1][ r +1] = 2 ; 

225 } 

226 } 

227 i f ( r > 0) { 

228 i f ( fb [ c −1][ r −1] == 0) { 

229 i n t [ ] r e ; 

230 b [ c −1][ r ] = 1 ; 

231 b [ c −1][ r −1] = 0 ; 


c −1, r , c −1, r −1, 


233 alpha = r e [ 1 ] ; 

234 beta = r e [ 2 ] ; 

235 i f ( r e [ 0 ] == 1) { 

236 b [ c −1][ r ] = 2 ; 

237 b [ c −1][ r −1] = 2 ; 

238 r e t u r n ( r e [ 3 ] ) ; 

239 } 

240 b [ c −1][ r ] = 0 ; 

241 b [ c −1][ r −1] = 1 ; 


c −1, r −1, c −1, r , 


243 alpha = r e [ 1 ] ; 

244 beta = r e [ 2 ] ; 

245 i f ( r e [ 0 ] == 1) { 

246 b [ c −1][ r ] = 2 ; 

247 b [ c −1][ r −1] = 2 ; 

248 r e t u r n ( r e [ 3 ] ) ; 

249 } 

250 b [ c −1][ r ] = 2 ;

112 Bilag A 

251 b [ c −1][ r −1] = 2 ; 

252 } 

253 } 

254 i f ( c > 1) { 

255 i f ( fb [ c −2][ r ] == 0) { 

256 i n t [ ] r e ; 

257 b [ c −1][ r ] = 1 ; 

258 b [ c −2][ r ] = 0 ; 


c −1, r , c −2, r , alpha , 

beta ) ; 

260 alpha = r e [ 1 ] ; 

261 beta = r e [ 2 ] ; 

262 i f ( r e [ 0 ] == 1) { 

263 b [ c −1][ r ] = 2 ; 

264 b [ c −2][ r ] = 2 ; 

265 r e t u r n ( r e [ 3 ] ) ; 

266 } 

267 b [ c −1][ r ] = 0 ; 

268 b [ c −2][ r ] = 1 ; 


c −2, r , c −1, r , alpha , 

beta ) ; 

270 alpha = r e [ 1 ] ; 

271 beta = r e [ 2 ] ; 

272 i f ( r e [ 0 ] == 1) { 

273 b [ c −1][ r ] = 2 ; 

274 b [ c −2][ r ] = 2 ; 

275 r e t u r n ( r e [ 3 ] ) ; 

276 } 

277 b [ c −1][ r ] = 2 ; 

278 b [ c −2][ r ] = 2 ; 

279 } 

280 } 

281 } 

282 } 

283 // System . out . p r i n t l n (” Growth count so f a r 

”+count+” d=”+n . d ) ; 

284 // printFB ( fb ) ; 

285 // syd 


287 i f ( fb [ c ] [ r +1] == 0) { 


289 i f ( fb [ c +1][ r +1] == 0) { 

290 i n t [ ] r e ; 

291 b [ c ] [ r +1] = 1 ; 

292 b [ c +1][ r +1] = 0 ; 


c , r +1, c +1, r +1, 


294 alpha = r e [ 1 ] ; 

295 beta = r e [ 2 ] ; 

296 i f ( r e [ 0 ] == 1) { 

297 b [ c ] [ r +1] = 2 ; 

298 b [ c +1][ r +1] = 2 ;


299 r e t u r n ( r e [ 3 ] ) ; 

300 } 

301 b [ c ] [ r +1] = 0 ; 

302 b [ c +1][ r +1] = 1 ; 


c +1, r +1, c , r +1, 


304 alpha = r e [ 1 ] ; 

305 beta = r e [ 2 ] ; 

306 i f ( r e [ 0 ] == 1) { 

307 b [ c ] [ r +1] = 2 ; 

308 b [ c +1][ r +1] = 2 ; 

309 r e t u r n ( r e [ 3 ] ) ; 

310 } 

311 b [ c ] [ r +1] = 2 ; 

312 b [ c +1][ r +1] = 2 ; 

313 } 

314 } 

315 i f ( c > 0) { 

316 i f ( fb [ c −1][ r +1] == 0) { 

317 i n t [ ] r e ; 

318 b [ c ] [ r +1] = 1 ; 

319 b [ c −1][ r +1] = 0 ; 


c , r +1, c −1, r +1, 


321 alpha = r e [ 1 ] ; 

322 beta = r e [ 2 ] ; 

323 i f ( r e [ 0 ] == 1) { 

324 b [ c ] [ r +1] = 2 ; 

325 b [ c −1][ r +1] = 2 ; 

326 r e t u r n ( r e [ 3 ] ) ; 

327 } 

328 b [ c ] [ r +1] = 0 ; 

329 b [ c −1][ r +1] = 1 ; 


c −1, r +1, c , r +1, 


331 alpha = r e [ 1 ] ; 

332 beta = r e [ 2 ] ; 

333 i f ( r e [ 0 ] == 1) { 

334 b [ c ] [ r +1] = 2 ; 

335 b [ c −1][ r +1] = 2 ; 

336 r e t u r n ( r e [ 3 ] ) ; 

337 } 

338 b [ c ] [ r +1] = 2 ; 

339 b [ c −1][ r +1] = 2 ; 

340 } 

341 } 


343 i f ( fb [ c ] [ r +2] == 0) { 

344 i n t [ ] r e ; 

345 b [ c ] [ r +1] = 1 ; 

346 b [ c ] [ r +2] = 0 ;

114 Bilag A 


c , r +1, c , r +2, alpha , 

beta ) ; 

348 alpha = r e [ 1 ] ; 

349 beta = r e [ 2 ] ; 

350 i f ( r e [ 0 ] == 1) { 

351 b [ c ] [ r +1] = 2 ; 

352 b [ c ] [ r +2] = 2 ; 

353 r e t u r n ( r e [ 3 ] ) ; 

354 } 

355 b [ c ] [ r +1] = 0 ; 

356 b [ c ] [ r +2] = 1 ; 


c , r +2, c , r +1, alpha , 

beta ) ; 

358 alpha = r e [ 1 ] ; 

359 beta = r e [ 2 ] ; 

360 i f ( r e [ 0 ] == 1) { 

361 b [ c ] [ r +1] = 2 ; 

362 b [ c ] [ r +2] = 2 ; 

363 r e t u r n ( r e [ 3 ] ) ; 

364 } 

365 b [ c ] [ r +1] = 2 ; 

366 b [ c ] [ r +2] = 2 ; 

367 } 

368 } 

369 } 

370 } 

371 // Nord 

372 i f ( r > 0) { 

373 i f ( fb [ c ] [ r −1] == 0) { 

374 i f ( c > 0) { 

375 i f ( fb [ c −1][ r −1] == 0) { 

376 i n t [ ] r e ; 

377 b [ c ] [ r −1] = 1 ; 

378 b [ c −1][ r −1] = 0 ; 


c , r −1, c −1, r −1, 


380 alpha = r e [ 1 ] ; 

381 beta = r e [ 2 ] ; 

382 i f ( r e [ 0 ] == 1) { 

383 b [ c ] [ r −1] = 2 ; 

384 b [ c −1][ r −1] = 2 ; 

385 r e t u r n ( r e [ 3 ] ) ; 

386 } 

387 b [ c ] [ r −1] = 0 ; 

388 b [ c −1][ r −1] = 1 ; 


c −1, r −1, c , r −1, 


390 alpha = r e [ 1 ] ; 

391 beta = r e [ 2 ] ; 

392 i f ( r e [ 0 ] == 1) { 

393 b [ c ] [ r −1] = 2 ;


394 b [ c −1][ r −1] = 2 ; 

395 r e t u r n ( r e [ 3 ] ) ; 

396 } 

397 b [ c ] [ r −1] = 2 ; 

398 b [ c −1][ r −1] = 2 ; 

399 } 

400 } 


402 i f ( fb [ c +1][ r −1] == 0) { 

403 i n t [ ] r e ; 

404 b [ c ] [ r −1] = 1 ; 

405 b [ c +1][ r −1] = 0 ; 


c , r −1, c +1, r −1, 


407 alpha = r e [ 1 ] ; 

408 beta = r e [ 2 ] ; 

409 i f ( r e [ 0 ] == 1) { 

410 b [ c ] [ r −1] = 2 ; 

411 b [ c +1][ r −1] = 2 ; 

412 r e t u r n ( r e [ 3 ] ) ; 

413 } 

414 b [ c ] [ r −1] = 0 ; 

415 b [ c +1][ r −1] = 1 ; 


c +1, r −1, c , r −1, 


417 alpha = r e [ 1 ] ; 

418 beta = r e [ 2 ] ; 

419 i f ( r e [ 0 ] == 1) { 

420 b [ c ] [ r −1] = 2 ; 

421 b [ c +1][ r −1] = 2 ; 

422 r e t u r n ( r e [ 3 ] ) ; 

423 } 

424 b [ c ] [ r −1] = 2 ; 

425 b [ c +1][ r −1] = 2 ; 

426 } 

427 } 

428 i f ( r > 1) { 

429 i f ( fb [ c ] [ r −2] == 0) { 

430 i n t [ ] r e ; 

431 b [ c ] [ r −1] = 1 ; 

432 b [ c ] [ r −2] = 0 ; 


c , r −1, c , r −2, alpha , 

beta ) ; 

434 alpha = r e [ 1 ] ; 

435 beta = r e [ 2 ] ; 

436 i f ( r e [ 0 ] == 1) { 

437 b [ c ] [ r −1] = 2 ; 

438 b [ c ] [ r −2] = 2 ; 

439 r e t u r n ( r e [ 3 ] ) ; 

440 } 

441 b [ c ] [ r −1] = 0 ; 

442 b [ c ] [ r −2] = 1 ;

116 Bilag A 


c , r −2, c , r −1, alpha , 

beta ) ; 

444 alpha = r e [ 1 ] ; 

445 beta = r e [ 2 ] ; 

446 i f ( r e [ 0 ] == 1) { 

447 b [ c ] [ r −1] = 2 ; 

448 b [ c ] [ r −2] = 2 ; 

449 r e t u r n ( r e [ 3 ] ) ; 

450 } 

451 b [ c ] [ r −1] = 2 ; 

452 b [ c ] [ r −2] = 2 ; 

453 } 

454 } 

455 } 

456 } 

457 } 

458 } 

459 } 

460 r e t u r n ( n . a ) ; 

461 } 

462 } 

463 

464 //Min−f u n k t i o n e n 


466 // System . out . p r i n t l n (” Growth − Min”) ; 




469 r e t u r n ( n . a ) ; 

470 } 

471 e l s e { 

472 i f ( ex == 1) { 

473 i f ( n . a



491 i f ( fb [ c ] [ r ] == f i g s [ 1 ] [ 0 ] [ 0 ] | | fb [ c ] [ r ] == 

f i g s [ 1 ] [ 1 ] [ 0 ] | | fb [ c ] [ r ] == f i g s [ 0 ] [ 0 ] [ 0 ] 

| | fb [ c ] [ r ] == f i g s [ 0 ] [ 1 ] [ 0 ] ) { 

492 // o e s t 


494 i f ( fb [ c +1][ r ] == 0) { 


496 i f ( fb [ c +1][ r +1] == 0) { 

497 i f ( n . a==0) ; 

498 i n t [ ] r e ; 

499 b [ c +1][ r ] = 1 ; 

500 b [ c +1][ r +1] = 0 ; 

501 r e = placePieceMin ( b , d , n , 

c +1, r , c +1, r +1, 


502 alpha = r e [ 1 ] ; 

503 beta = r e [ 2 ] ; 

504 i f ( r e [ 0 ] == 1) { 

505 b [ c +1][ r ] = 2 ; 

506 b [ c +1][ r +1] = 2 ; 

507 r e t u r n ( n . a ) ; 

508 } 

509 b [ c +1][ r ] = 0 ; 

510 b [ c +1][ r +1] = 1 ; 


c +1, r +1, c +1, r , 


512 alpha = r e [ 1 ] ; 

513 beta = r e [ 2 ] ; 

514 i f ( r e [ 0 ] == 1) { 

515 b [ c +1][ r ] = 2 ; 

516 b [ c +1][ r +1] = 2 ; 

517 r e t u r n ( r e [ 3 ] ) ; 

518 } 

519 b [ c +1][ r ] = 2 ; 

520 b [ c +1][ r +1] = 2 ; 

521 } 

522 } 

523 i f ( r > 0) { 

524 i f ( fb [ c +1][ r −1] == 0) { 

525 i n t [ ] r e ; 

526 b [ c +1][ r ] = 1 ; 

527 b [ c +1][ r −1] = 0 ; 


c +1, r , c +1, r −1, 


529 alpha = r e [ 1 ] ; 

530 beta = r e [ 2 ] ; 

531 i f ( r e [ 0 ] == 1) { 

532 b [ c +1][ r ] = 2 ; 

533 b [ c +1][ r −1] = 2 ; 

534 r e t u r n ( r e [ 3 ] ) ; 

535 } 

536 b [ c +1][ r ] = 0 ;

118 Bilag A 

537 b [ c +1][ r −1] = 1 ; 


c +1, r −1, c +1, r , 


539 alpha = r e [ 1 ] ; 

540 beta = r e [ 2 ] ; 

541 i f ( r e [ 0 ] == 1) { 

542 b [ c +1][ r ] = 2 ; 

543 b [ c +1][ r −1] = 2 ; 

544 r e t u r n ( r e [ 3 ] ) ; 

545 } 

546 b [ c +1][ r ] = 2 ; 

547 b [ c +1][ r −1] = 2 ; 

548 } 

549 } 


551 i f ( fb [ c +2][ r ] == 0) { 

552 i n t [ ] r e ; 

553 b [ c +1][ r ] = 1 ; 

554 b [ c +2][ r ] = 0 ; 


c +1, r , c +2, r , alpha , 

beta ) ; 

556 alpha = r e [ 1 ] ; 

557 beta = r e [ 2 ] ; 

558 i f ( r e [ 0 ] == 1) { 

559 b [ c +1][ r ] = 2 ; 

560 b [ c +2][ r ] = 2 ; 

561 r e t u r n ( r e [ 3 ] ) ; 

562 } 

563 b [ c +1][ r ] = 0 ; 

564 b [ c +2][ r ] = 1 ; 


c +2, r , c +1, r , alpha , 

beta ) ; 

566 alpha = r e [ 1 ] ; 

567 beta = r e [ 2 ] ; 

568 i f ( r e [ 0 ] == 1) { 

569 b [ c +1][ r ] = 2 ; 

570 b [ c +2][ r ] = 2 ; 

571 r e t u r n ( r e [ 3 ] ) ; 

572 } 

573 b [ c +1][ r ] = 2 ; 

574 b [ c +2][ r ] = 2 ; 

575 } 

576 } 

577 } 

578 } 

579 // v e s t 

580 i f ( c > 0) { 

581 i f ( fb [ c −1][ r ] == 0) { 


583 i f ( fb [ c −1][ r +1] == 0) { 

584 i n t [ ] r e ; 

585 b [ c −1][ r ] = 1 ;


586 b [ c −1][ r +1] = 0 ; 


c −1, r , c −1, r +1, 


588 alpha = r e [ 1 ] ; 

589 beta = r e [ 2 ] ; 

590 i f ( r e [ 0 ] == 1) { 

591 b [ c −1][ r ] = 2 ; 

592 b [ c −1][ r +1] = 2 ; 

593 r e t u r n ( r e [ 3 ] ) ; 

594 } 

595 b [ c −1][ r ] = 0 ; 

596 b [ c −1][ r +1] = 1 ; 


c −1, r +1, c −1, r , 


598 alpha = r e [ 1 ] ; 

599 beta = r e [ 2 ] ; 

600 i f ( r e [ 0 ] == 1) { 

601 b [ c −1][ r ] = 2 ; 

602 b [ c −1][ r +1] = 2 ; 

603 r e t u r n ( r e [ 3 ] ) ; 

604 } 

605 b [ c −1][ r ] = 2 ; 

606 b [ c −1][ r +1] = 2 ; 

607 } 

608 } 

609 i f ( r > 0) { 

610 i f ( fb [ c −1][ r −1] == 0) { 

611 i n t [ ] r e ; 

612 b [ c −1][ r ] = 1 ; 

613 b [ c −1][ r −1] = 0 ; 


c −1, r , c −1, r −1, 


615 alpha = r e [ 1 ] ; 

616 beta = r e [ 2 ] ; 

617 i f ( r e [ 0 ] == 1) { 

618 b [ c −1][ r ] = 2 ; 

619 b [ c −1][ r −1] = 2 ; 

620 r e t u r n ( r e [ 3 ] ) ; 

621 } 

622 b [ c −1][ r ] = 0 ; 

623 b [ c −1][ r −1] = 1 ; 


c −1, r −1, c −1, r , 


625 alpha = r e [ 1 ] ; 

626 beta = r e [ 2 ] ; 

627 i f ( r e [ 0 ] == 1) { 

628 b [ c −1][ r ] = 2 ; 

629 b [ c −1][ r −1] = 2 ; 

630 r e t u r n ( r e [ 3 ] ) ; 

631 } 

632 b [ c −1][ r ] = 2 ;

120 Bilag A 

633 b [ c −1][ r −1] = 2 ; 

634 } 

635 } 

636 i f ( c > 1) { 

637 i f ( fb [ c −2][ r ] == 0) { 

638 i n t [ ] r e ; 

639 b [ c −1][ r ] = 1 ; 

640 b [ c −2][ r ] = 0 ; 


c −1, r , c −2, r , alpha , 

beta ) ; 

642 alpha = r e [ 1 ] ; 

643 beta = r e [ 2 ] ; 

644 i f ( r e [ 0 ] == 1) { 

645 b [ c −1][ r ] = 2 ; 

646 b [ c −2][ r ] = 2 ; 

647 r e t u r n ( r e [ 3 ] ) ; 

648 } 

649 b [ c −1][ r ] = 0 ; 

650 b [ c −2][ r ] = 1 ; 


c −2, r , c −1, r , alpha , 

beta ) ; 

652 alpha = r e [ 1 ] ; 

653 beta = r e [ 2 ] ; 

654 i f ( r e [ 0 ] == 1) { 

655 b [ c −1][ r ] = 2 ; 

656 b [ c −2][ r ] = 2 ; 

657 r e t u r n ( r e [ 3 ] ) ; 

658 } 

659 b [ c −1][ r ] = 2 ; 

660 b [ c −2][ r ] = 2 ; 

661 } 

662 } 

663 } 

664 } 

665 // syd 


667 i f ( fb [ c ] [ r +1] == 0) { 


669 i f ( fb [ c +1][ r +1] == 0) { 

670 i n t [ ] r e ; 

671 b [ c ] [ r +1] = 1 ; 

672 b [ c +1][ r +1] = 0 ; 


c , r +1, c +1, r +1, 


674 alpha = r e [ 1 ] ; 

675 beta = r e [ 2 ] ; 

676 i f ( r e [ 0 ] == 1) { 

677 b [ c ] [ r +1] = 2 ; 

678 b [ c +1][ r +1] = 2 ; 

679 r e t u r n ( r e [ 3 ] ) ; 

680 } 

681 b [ c ] [ r +1] = 0 ;


682 b [ c +1][ r +1] = 1 ; 


c +1, r +1, c , r +1, 


684 alpha = r e [ 1 ] ; 

685 beta = r e [ 2 ] ; 

686 i f ( r e [ 0 ] == 1) { 

687 b [ c ] [ r +1] = 2 ; 

688 b [ c +1][ r +1] = 2 ; 

689 r e t u r n ( r e [ 3 ] ) ; 

690 } 

691 b [ c ] [ r +1] = 2 ; 

692 b [ c +1][ r +1] = 2 ; 

693 } 

694 } 

695 i f ( c > 0) { 

696 i f ( fb [ c −1][ r +1] == 0) { 

697 i n t [ ] r e ; 

698 b [ c ] [ r +1] = 1 ; 

699 b [ c −1][ r +1] = 0 ; 


c , r +1, c −1, r +1, 


701 alpha = r e [ 1 ] ; 

702 beta = r e [ 2 ] ; 

703 i f ( r e [ 0 ] == 1) { 

704 b [ c ] [ r +1] = 2 ; 

705 b [ c −1][ r +1] = 2 ; 

706 r e t u r n ( r e [ 3 ] ) ; 

707 } 

708 b [ c ] [ r +1] = 0 ; 

709 b [ c −1][ r +1] = 1 ; 


c −1, r +1, c , r +1, 


711 alpha = r e [ 1 ] ; 

712 beta = r e [ 2 ] ; 

713 i f ( r e [ 0 ] == 1) { 

714 b [ c ] [ r +1] = 2 ; 

715 b [ c −1][ r +1] = 2 ; 

716 r e t u r n ( r e [ 3 ] ) ; 

717 } 

718 b [ c ] [ r +1] = 2 ; 

719 b [ c −1][ r +1] = 2 ; 

720 } 

721 } 


723 i f ( fb [ c ] [ r +2] == 0) { 

724 i n t [ ] r e ; 

725 b [ c ] [ r +1] = 1 ; 

726 b [ c ] [ r +2] = 0 ; 


c , r +1, c , r +2, alpha , 

beta ) ; 

728 alpha = r e [ 1 ] ;

122 Bilag A 

729 beta = r e [ 2 ] ; 

730 i f ( r e [ 0 ] == 1) { 

731 b [ c ] [ r +1] = 2 ; 

732 b [ c ] [ r +2] = 2 ; 

733 r e t u r n ( r e [ 3 ] ) ; 

734 } 

735 b [ c ] [ r +1] = 0 ; 

736 b [ c ] [ r +2] = 1 ; 


c , r +2, c , r +1, alpha , 

beta ) ; 

738 alpha = r e [ 1 ] ; 

739 beta = r e [ 2 ] ; 

740 i f ( r e [ 0 ] == 1) { 

741 b [ c ] [ r +1] = 2 ; 

742 b [ c ] [ r +2] = 2 ; 

743 r e t u r n ( r e [ 3 ] ) ; 

744 } 

745 b [ c ] [ r +1] = 2 ; 

746 b [ c ] [ r +2] = 2 ; 

747 } 

748 } 

749 } 

750 } 

751 // Nord 

752 i f ( r > 0) { 

753 i f ( fb [ c ] [ r −1] == 0) { 

754 i f ( c > 0) { 

755 i f ( fb [ c −1][ r −1] == 0) { 

756 i n t [ ] r e ; 

757 b [ c ] [ r −1] = 1 ; 

758 b [ c −1][ r −1] = 0 ; 


c , r −1, c −1, r −1, 


760 alpha = r e [ 1 ] ; 

761 beta = r e [ 2 ] ; 

762 i f ( r e [ 0 ] == 1) { 

763 b [ c ] [ r −1] = 2 ; 

764 b [ c −1][ r −1] = 2 ; 

765 r e t u r n ( r e [ 3 ] ) ; 

766 } 

767 b [ c ] [ r −1] = 0 ; 

768 b [ c −1][ r −1] = 1 ; 


c −1, r −1, c , r −1, 


770 alpha = r e [ 1 ] ; 

771 beta = r e [ 2 ] ; 

772 i f ( r e [ 0 ] == 1) { 

773 b [ c ] [ r −1] = 2 ; 

774 b [ c −1][ r −1] = 2 ; 

775 r e t u r n ( r e [ 3 ] ) ; 

776 } 

777 b [ c ] [ r −1] = 2 ;


778 b [ c −1][ r −1] = 2 ; 

779 } 

780 } 


782 i f ( fb [ c +1][ r −1] == 0) { 

783 i n t [ ] r e ; 

784 b [ c ] [ r −1] = 1 ; 

785 b [ c +1][ r −1] = 0 ; 


c , r −1, c +1, r −1, 


787 alpha = r e [ 1 ] ; 

788 beta = r e [ 2 ] ; 

789 i f ( r e [ 0 ] == 1) { 

790 b [ c ] [ r −1] = 2 ; 

791 b [ c +1][ r −1] = 2 ; 

792 r e t u r n ( r e [ 3 ] ) ; 

793 } 

794 b [ c ] [ r −1] = 0 ; 

795 b [ c +1][ r −1] = 1 ; 


c +1, r −1, c , r −1, 


797 alpha = r e [ 1 ] ; 

798 beta = r e [ 2 ] ; 

799 i f ( r e [ 0 ] == 1) { 

800 b [ c ] [ r −1] = 2 ; 

801 b [ c +1][ r −1] = 2 ; 

802 r e t u r n ( r e [ 3 ] ) ; 

803 } 

804 b [ c ] [ r −1] = 2 ; 

805 b [ c +1][ r −1] = 2 ; 

806 } 

807 } 

808 i f ( r > 1) { 

809 i f ( fb [ c ] [ r −2] == 0) { 

810 i n t [ ] r e ; 

811 b [ c ] [ r −1] = 1 ; 

812 b [ c ] [ r −2] = 0 ; 


c , r −1, c , r −2, alpha , 

beta ) ; 

814 alpha = r e [ 1 ] ; 

815 beta = r e [ 2 ] ; 

816 i f ( r e [ 0 ] == 1) { 

817 b [ c ] [ r −1] = 2 ; 

818 b [ c ] [ r −2] = 2 ; 

819 r e t u r n ( r e [ 3 ] ) ; 

820 } 

821 b [ c ] [ r −1] = 0 ; 

822 b [ c ] [ r −2] = 1 ; 


c , r −2, c , r −1, alpha , 

beta ) ; 

824 alpha = r e [ 1 ] ;

124 Bilag A 

825 beta = r e [ 2 ] ; 

826 i f ( r e [ 0 ] == 1) { 

827 b [ c ] [ r −1] = 2 ; 

828 b [ c ] [ r −2] = 2 ; 

829 r e t u r n ( r e [ 3 ] ) ; 

830 } 

831 b [ c ] [ r −1] = 2 ; 

832 b [ c ] [ r −2] = 2 ; 

833 } 

834 } 

835 } 

836 } 

837 } 

838 } 

839 } 

840 r e t u r n ( n . a ) ; 

841 } 

842 } 

843 

844 

845 // haandtere p l a c e r i n g e n a f b r i k k e r f o r max ( ) , c h e c k e r om de 

a l l e r e d e e k s i s t e r e r , haandtere alpha beta pruning 

846 p r i v a t e i n t [ ] placePieceMax ( i n t [ ] [ ] b , i n t d , Node n , i n t wC, 

i n t wR, i n t bC , i n t bR, i n t alpha , i n t beta ) { 

847 i n t [ ] p = new i n t [ 3 ] ; 


849 i n t [ ] r e = new i n t [ 4 ] ; // r e [0]= 1 break , r e [1]= alpha , r e 

[2]= beta , r e [3]= n . a 

850 

851 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

855 i f ( n . a < v ) 

856 n . a = v ; 

857 i f ( n . a > beta ) { 

858 r e [ 0 ] = 0 ; // 1 = alpha beta pruning 

s l a a e t t i l , 0 = s l a a e t f r a ( 

s l a a e t f r a da den g i v e r 

problemer ) 

859 r e [1]= alpha ; 

860 r e [2]= beta ; 

861 r e [3]= n . a ; 

862 r e t u r n ( r e ) ; 

863 } 

864 i f ( alpha < n . a ) 

865 alpha = n . a ; 

866 

867 } 

868 i f ( p [ 2 ] == −1){ 

869 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 


createChildNode (wC, wR, bC , bR, n ) )


) ; 

871 count++; 


, alpha , beta , 0 ) ; 

873 i f ( n . a < v ) 

874 n . a = v ; 

875 i f ( n . a > beta ) { 

876 r e [ 0 ] = 0 ; // 1 = alpha beta pruning 

s l a a e t t i l , 0 = s l a a e t f r a ( 

s l a a e t f r a da den g i v e r 

problemer ) 

877 r e [1]= alpha ; 

878 r e [2]= beta ; 

879 r e [3]= n . a ; 

880 r e t u r n ( r e ) ; 

881 } 

882 i f ( alpha < n . a ) 

883 alpha = n . a ; 

884 

885 } 

886 r e t u r n ( r e ) ; 

887 } 

888 

889 // haandtere p l a c e r i n g e n a f b r i k k e r f o r min ( ) , c h e c k e r om de 

a l l e r e d e e k s i s t e r e r , haandtere alpha beta pruning 

890 p r i v a t e i n t [ ] placePieceMin ( i n t [ ] [ ] b , i n t d , Node n , i n t wC, 

i n t wR, i n t bC , i n t bR, i n t alpha , i n t beta ) { 

891 i n t [ ] p = new i n t [ 3 ] ; 


893 i n t [ ] r e = new i n t [ 4 ] ; // r e [0]= 1 break , r e [1]= alpha , r e 

[2]= beta , r e [3]= n . a 

894 

895 i f ( p [ 2 ] >= 0) { 


897 n . c h i l d r e n . add ( nodes [ p [ 0 ] ] [ p [ 1 ] ] . get ( p [ 2 ] ) ) ; 

898 i n t v = max( nodes [ p [ 0 ] ] [ p [ 1 ] ] . get ( p [ 2 ] ) , alpha , beta , 1 ) ; 

899 i f ( n . a > v ) 

900 n . a = v ; 

901 i f ( n . a < alpha ) { 

902 r e [ 0 ] = 0 ; // 1 = alpha beta pruning s l a a e t t i l , 0 = 

s l a a e t f r a ( s l a a e t f r a da den g i v e r problemer ) 

903 r e [1]= alpha ; 

904 r e [2]= beta ; 

905 r e [3]= n . a ; 

906 r e t u r n ( r e ) ; 

907 } 

908 i f ( beta > n . a ) 

909 beta = n . a ; 

910 } 

911 i f ( p [ 2 ] == −1){ 

912 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 

913 nodes [ p [ 0 ] ] [ p [ 1 ] ] . add ( n . addChild ( tNode . createChildNode ( 

wC, wR, bC , bR, n ) ) ) ; 

914 count++; 

915 i n t v = max( nodes [ p [ 0 ] ] [ p [ 1 ] ] . get ( p [ 2 ] ) , alpha , beta , 0 ) ;

126 Bilag A 

916 i f ( n . a > v ) 

917 n . a = v ; // 1 = alpha beta pruning s l a a e t t i l , 0 = 

s l a a e t f r a ( s l a a e t f r a da denne g i v e r problemer 

) 

918 i f ( n . a < alpha ) { 

919 r e [ 0 ] = 0 ; 

920 r e [1]= alpha ; 

921 r e [2]= beta ; 

922 r e [3]= n . a ; 

923 r e t u r n ( r e ) ; 

924 } 

925 i f ( beta > n . a ) 

926 beta = n . a ; 

927 } 

928 r e t u r n ( r e ) ; 

929 } 

930 

931 

932 

933 

934 

935 

936 // s a e t t e r s c o r e n f o r en node t i l lower bound 



939 r e t u r n ( n ) ; 

940 } 

941 // s a e t t e r s c o r e n f o r en node t i l e t upper bound 



944 r e t u r n ( n ) ; 

945 } 

946 

947 

948 

949 // u d s k r i v e r f i g B o a r d e t f o r 4x4 e l l e r 9x9 p l a d e r 

950 p r i v a t e void printFB ( i n t [ ] [ ] fb ) { 

951 i f ( tModel . noCols > 8 && tModel . noRows > 8) 

952 printFB9x9 ( fb ) ; 

953 e l s e 

954 printFB4x4 ( fb ) ; 

955 } 

956 

957 // u d s k r i v e r f i g B o a r d e t f o r 4x4 p l a d e r 

958 p r i v a t e void printFB4x4 ( i n t [ ] [ ] fb ) { 

959 System . out . p r i n t l n (” P r i n t FB ”+fb ) ; 

960 System . out . p r i n t l n ( fb [ 0 ] [ 0 ] + ” ”+fb [ 1 ] [ 0 ] + ” ”+fb 

[ 2 ] [ 0 ] + ” ”+fb [ 3 ] [ 0 ] ) ; 


[ 2 ] [ 1 ] + ” ”+fb [ 3 ] [ 1 ] ) ; 


[ 2 ] [ 2 ] + ” ”+fb [ 3 ] [ 2 ] ) ; 


[ 2 ] [ 3 ] + ” ”+fb [ 3 ] [ 3 ] ) ; 

964 System . out . p r i n t l n ( ) ;


965 } 

966 

967 // u d s k r i v e r f i g B o a r d e t f o r 9x9 p l a d e r 

968 p r i v a t e void printFB9x9 ( i n t [ ] [ ] fb ) { 

969 System . out . p r i n t l n (” P r i n t FB ”+fb ) ; 


[ 2 ] [ 0 ] + ” ”+fb [ 3 ] [ 0 ] + ” ”+fb [ 4 ] [ 0 ] + ” ”+fb [ 5 ] [ 0 ] + ” 

”+fb [ 6 ] [ 0 ] + ” ”+fb [ 7 ] [ 0 ] + ” ”+fb [ 8 ] [ 0 ] ) ; 


[ 2 ] [ 1 ] + ” ”+fb [ 3 ] [ 1 ] + ” ”+fb [ 4 ] [ 1 ] + ” ”+fb [ 5 ] [ 1 ] + ” 

”+fb [ 6 ] [ 1 ] + ” ”+fb [ 7 ] [ 1 ] + ” ”+fb [ 8 ] [ 1 ] ) ; 


[ 2 ] [ 2 ] + ” ”+fb [ 3 ] [ 2 ] + ” ”+fb [ 4 ] [ 2 ] + ” ”+fb [ 5 ] [ 2 ] + ” 

”+fb [ 6 ] [ 2 ] + ” ”+fb [ 7 ] [ 2 ] + ” ”+fb [ 8 ] [ 2 ] ) ; 


[ 2 ] [ 3 ] + ” ”+fb [ 3 ] [ 3 ] + ” ”+fb [ 4 ] [ 3 ] + ” ”+fb [ 5 ] [ 3 ] + ” 

”+fb [ 6 ] [ 3 ] + ” ”+fb [ 7 ] [ 3 ] + ” ”+fb [ 8 ] [ 3 ] ) ; 


[ 2 ] [ 4 ] + ” ”+fb [ 3 ] [ 4 ] + ” ”+fb [ 4 ] [ 4 ] + ” ”+fb [ 5 ] [ 4 ] + ” 

”+fb [ 6 ] [ 4 ] + ” ”+fb [ 7 ] [ 4 ] + ” ”+fb [ 8 ] [ 4 ] ) ; 


[ 2 ] [ 5 ] + ” ”+fb [ 3 ] [ 5 ] + ” ”+fb [ 4 ] [ 5 ] + ” ”+fb [ 5 ] [ 5 ] + ” 

”+fb [ 6 ] [ 5 ] + ” ”+fb [ 7 ] [ 5 ] + ” ”+fb [ 8 ] [ 5 ] ) ; 


[ 2 ] [ 6 ] + ” ”+fb [ 3 ] [ 6 ] + ” ”+fb [ 4 ] [ 6 ] + ” ”+fb [ 5 ] [ 6 ] + ” 

”+fb [ 6 ] [ 6 ] + ” ”+fb [ 7 ] [ 6 ] + ” ”+fb [ 8 ] [ 6 ] ) ; 


[ 2 ] [ 7 ] + ” ”+fb [ 3 ] [ 7 ] + ” ”+fb [ 4 ] [ 7 ] + ” ”+fb [ 5 ] [ 7 ] + ” 

”+fb [ 6 ] [ 7 ] + ” ”+fb [ 7 ] [ 7 ] + ” ”+fb [ 8 ] [ 7 ] ) ; 


[ 2 ] [ 8 ] + ” ”+fb [ 3 ] [ 8 ] + ” ”+fb [ 4 ] [ 8 ] + ” ”+fb [ 5 ] [ 8 ] + ” 

”+fb [ 6 ] [ 8 ] + ” ”+fb [ 7 ] [ 8 ] + ” ”+fb [ 8 ] [ 8 ] ) ; 

979 System . out . p r i n t l n ( ) ; 

980 } 

981 

982 // haandtere Growth AI ’ ens k o e r s e l og r e t u r n e r e det fundne 

t r a e k 

983 p u b l i c Node returnMove ( boolean b ) { 

984 i f ( tModel . currentTurn == 1) { 

985 i f ( b == f a l s e ) { 


987 Root = tNode . createNode ( tModel . currentTurn , tModel ) 

; 

988 Root . wc=0; // tModel . noCols / 2 ; // f o r at s a e t t e 

f o e r s t e b r i k i midten i s t e d e t f o r i h j o e r n e t 

989 Root . wr=1; // tModel . noCols / 2 ; // f o r at s a e t t e 


990 Root . bc=Root . wc ; 

991 Root . br=Root . wr−1; 

992 r e t u r n ( Root ) ; 

993 } 

994 i f ( b == t r u e ) { 


996 Root = tNode . createNode ( tModel . currentTurn , tModel ) 

;

128 Bilag A 

997 Root . wc=0; // tModel . noCols / 2 ; // f o r at s a e t t e 


998 Root . wr=0; // tModel . noCols / 2 ; // f o r at s a e t t e 



1000 Root . br=Root . wr+1; 

1001 r e t u r n ( Root ) ; 

1002 } 

1003 } 

1004 Growth ( ) ; 

1005 

1006 i f ( b ) 

1007 min ( Root ,−tModel . maxScore , tModel . maxScore , 0 ) ; 

1008 i f ( ! b ) 

1009 max( Root ,−tModel . maxScore , tModel . maxScore , 0 ) ; 

1010 

1011 Random randomVal = new Random ( ) ; 

1012 Node n ; 

1013 ArrayList move = new ArrayList () ; 

1014 i n t wC,wR, bC , bR, ran ; 

1015 n = Root . c h i l d r e n . get ( 0 ) ; 

1016 // tModel . t P r i n t . printNode ( Root ) ; 

1017 // tModel . t P r i n t . p r i n t C h i l d r e n ( Root ) ; 

1018 // System . out . p r i n t l n (” Growth − r e t u r n move Root . s i z e=”+Root 

. c h i l d r e n . s i z e ( ) ) ; 

1019 i f ( Root . c h i l d r e n . s i z e ( ) > 1) { 

1020 i f ( b ) { 

1021 f o r ( i n t i =0; i Root . c h i l d r e n . get ( i ) . a ) { 


1024 } 

1025 } 

1026 } 

1027 i f ( ! b ) { 

1028 f o r ( i n t i =0; i


1044 wC = n . wc ; 

1045 wR = n . wr ; 

1046 bC = n . bc ; 

1047 bR = n . br ; 

1048 n . nodeBoard [wC ] [ wR]=2; 

1049 n . nodeBoard [ bC ] [ bR]=2; 

1050 // tModel . t P r i n t . printNode ( n ) ; 

1051 

1052 // vender det v a l g t e t r a e k saa det matcher s p i l l e t s 

igangvaerende t r a e k . 

1053 i n t mr = tModel . tBoard . compareBoardsInt ( n . nodeBoard , tModel 

. tBoard . board [ tModel . currentTurn ] ) ; 

1054 System . out . p r i n t l n (” Growth − Return move mr=”+mr) ; 

1055 i f (mr == 1) { 

1056 r e t u r n ( n ) ; 

1057 } 

1058 i f (mr == 2) { 

1059 n . br = tModel . noRows−1 − bR ; 


1061 r e t u r n ( n ) ; 

1062 } 

1063 i f (mr == 3) { 

1064 n . bc = tModel . noCols −1 − bC ; 

1065 n . wc = tModel . noCols −1 − wC; 

1066 r e t u r n ( n ) ; 

1067 } 

1068 i f (mr == 4) { 





1073 r e t u r n ( n ) ; 

1074 } 

1075 i f (mr == 5) { 

1076 n . bc = bR ; 

1077 n . wc = wR; 

1078 n . br = bC ; 

1079 n . wr = wC; 

1080 r e t u r n ( n ) ; 

1081 } 

1082 i f (mr == 6) { 



1085 n . br = bC ; 

1086 n . wr = wC; 

1087 r e t u r n ( n ) ; 

1088 } 

1089 i f (mr == 7) { 

1090 n . bc = bR ; 

1091 n . wc = wR; 



1094 r e t u r n ( n ) ; 

1095 } 

1096 i f (mr == 8) {

130 Bilag A 





1101 r e t u r n ( n ) ; 

1102 } 

1103 r e t u r n ( n ) ; 

1104 } 

1105 

1106 } 

A.3 AITaijiLocalAreaAB.java 



3 

4 p u b l i c c l a s s AITaijiLocalAreaAB { 

5 









13 p r i v a t e Node Root ; // Traeets rod . 



15 p r i v a t e i n t c o l S t a r t , colEnd , rowStart , rowEnd ; 

16 

17 

18 p u b l i c AITaijiLocalAreaAB ( TaijiModel m) { 


20 } 

21 

22 p u b l i c void LocalAreaAB ( ) { 



25 count = 1 ; 

26 maxD = tModel . maxTurnsLeft ( ) ; 

27 searchD = maxD; 

28 maxH = tModel . tHash . getMaxH3 ( ) ; 


30 f o r ( i n t i =0; i

A.3 AITaijiLocalAreaAB.java 131 

39 } 

40 

41 // s a e t t e r c o l S t a r t , colEnd , rowStart og rowEnd s a a l e d e s at der 

kan k o e r e s minimax paa e t 4x4 omraade a f b r a e t t e t . 

42 p r i v a t e void setAround ( i n t [ ] t ) { 

43 i f ( t [ 0 ] < t [ 2 ] ) { 

44 c o l S t a r t = t [ 0 ] − 1 ; 

45 colEnd = t [ 2 ] + 1 ; 

46 } 

47 i f ( t [ 0 ] > t [ 2 ] ) { 

48 c o l S t a r t = t [ 2 ] − 1 ; 

49 colEnd = t [ 0 ] + 1 ; 

50 } 

51 i f ( t [ 0 ] == t [ 2 ] ) { 

52 c o l S t a r t = t [ 0 ] − 1 ; 

53 colEnd = t [ 0 ] + 2 ; // +2 f o r 4x4 , +1 f o r 3x4 

54 } 

55 // f l y t t e r omraadet h v i s f o r r i g e t r a e k l i g g e r opad kanten 

56 i f ( c o l S t a r t < 0) { 

57 i f ( colEnd − c o l S t a r t == 2 && t [0]== t [ 2 ] ) 

58 colEnd = 2 ; // 3x4 

59 e l s e 

60 colEnd = 3 ; // 4x4 

61 c o l S t a r t = 0 ; 

62 } 

63 

64 // f l y t t e r omraadet h v i s f o r r i g e t r a e k l i g g e r opad kanten 

65 i f ( colEnd >= tModel . noCols ) { 

66 i f ( colEnd − c o l S t a r t == 2 && t [0]== t [ 2 ] ) 

67 c o l S t a r t = tModel . noCols −3; // 3x4 

68 e l s e 

69 c o l S t a r t = tModel . noCols −4; // 4x4 

70 colEnd = tModel . noCols −1; 

71 

72 } 

73 

74 i f ( t [ 1 ] < t [ 3 ] ) { 

75 rowStart = t [ 1 ] − 1 ; 

76 rowEnd = t [ 3 ] + 1 ; 

77 } 

78 i f ( t [ 1 ] > t [ 3 ] ) { 

79 rowStart = t [ 3 ] − 1 ; 

80 rowEnd = t [ 1 ] + 1 ; 

81 } 

82 i f ( t [ 1 ] == t [ 3 ] ) { 

83 rowStart = t [ 1 ] − 1 ; 

84 rowEnd = t [ 1 ] + 2 ; // +2 f o r 4x4 , +1 f o r 4x3 

85 } 

86 i f ( rowStart < 0) { 

87 i f ( rowEnd − rowStart == 2 && t [1]== t [ 3 ] ) 

88 rowEnd = 2 ; // 4x3 

89 e l s e 

90 rowEnd = 3 ; // 4x4 

91 rowStart = 0 ; 

92 }

132 Bilag A 

93 i f ( rowEnd >= tModel . noRows ) { 

94 i f ( rowEnd − rowStart == 2 && t [1]== t [ 3 ] ) 

95 rowStart = tModel . noRows−3; // 4x3 

96 e l s e 

97 rowStart = tModel . noRows−4; // 4x4 

98 rowEnd = tModel . noRows−1; 

99 } 

100 } 

101 

102 // s a e t t e r soegedybden 

103 p u b l i c void setSearchDepth ( i n t d ) { 

104 searchD = d ; 

105 } 

106 

107 // c h e c k e r om der a l l e r e d e e r e t saadant b r a e t . Returnerer 

c o r d i n a t e r n e f o r den node , h v i s der e r . 

108 p r i v a t e i n t [ ] c h e c k B o a r d I n d i v i d u a l i t y ( i n t [ ] [ ] b , i n t d ) { 

109 i n t [ ] p = new i n t [ 3 ] ; 


111 p [0]= d ; 

112 p [1]= h ; 

113 p[2]= −1; 




129 r e t u r n ( n . a ) ; 

130 } 

131 e l s e { 

132 i f ( ex == 1) { 

133 i f ( n . a >= beta ) 

134 r e t u r n ( n . a ) ; 

135 } 



138 i n t d = n . d ; 

139 f o r ( i n t c=c o l S t a r t ; c


143 b [ c ] [ r +1] = 0 ; 

144 i n t [ ] p = new i n t [ 3 ] ; 


146 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

150 i f ( n . a < v ) 

151 n . a = v ; 

152 i f ( n . a > beta ) { 

153 b [ c ] [ r ] = 2 ; 

154 b [ c ] [ r +1] = 2 ; 

155 r e t u r n ( n . a ) ; 

156 } 

157 i f ( alpha < n . a ) 

158 alpha = n . a ; 

159 

160 } 

161 i f ( p [ 2 ] == −1){ 

162 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



164 count++; 


, alpha , beta , 0 ) ; 

166 i f ( n . a < v ) 

167 n . a = v ; 

168 i f ( n . a > beta ) { 

169 b [ c ] [ r ] = 2 ; 

170 b [ c ] [ r +1] = 2 ; 

171 r e t u r n ( n . a ) ; 

172 } 

173 i f ( alpha < n . a ) 

174 alpha = n . a ; 

175 

176 } 

177 b [ c ] [ r ] = 0 ; 

178 b [ c ] [ r +1] = 1 ; 


180 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

184 i f ( n . a < v ) 

185 n . a = v ; 

186 i f ( n . a > beta ) { 

187 b [ c ] [ r ] = 2 ; 

188 b [ c ] [ r +1] = 2 ; 

189 r e t u r n ( n . a ) ; 

190 } 

191 i f ( alpha < n . a )

134 Bilag A 

192 alpha = n . a ; 

193 } 

194 i f ( p [ 2 ] == −1){ 

195 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



197 count++; 


, alpha , beta , 0 ) ; 

199 i f ( n . a < v ) 

200 n . a = v ; 

201 i f ( n . a > beta ) { 

202 b [ c ] [ r ] = 2 ; 

203 b [ c ] [ r +1] = 2 ; 

204 r e t u r n ( n . a ) ; 

205 } 

206 i f ( alpha < n . a ) 

207 alpha = n . a ; 

208 } 

209 

210 b [ c ] [ r ] = 2 ; 

211 b [ c ] [ r +1] = 2 ; 

212 } 

213 } 

214 } 

215 

216 f o r ( i n t c=c o l S t a r t ; c beta ) { 

230 b [ c ] [ r ] = 2 ; 

231 b [ c +1][ r ] = 2 ; 

232 r e t u r n ( n . a ) ; 

233 } 

234 i f ( alpha < n . a ) 

235 alpha = n . a ; 

236 } 

237 i f ( p [ 2 ] == −1){ 

238 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



240 count++;



, alpha , beta , 0 ) ; 

242 i f ( n . a < v ) 

243 n . a = v ; 

244 i f ( n . a > beta ) { 

245 b [ c ] [ r ] = 2 ; 

246 b [ c +1][ r ] = 2 ; 

247 r e t u r n ( n . a ) ; 

248 } 

249 i f ( alpha < n . a ) 

250 alpha = n . a ; 

251 } 

252 b [ c ] [ r ] = 0 ; 

253 b [ c +1][ r ] = 1 ; 


255 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

259 i f ( n . a < v ) 

260 n . a = v ; 

261 i f ( n . a > beta ) { 

262 b [ c ] [ r ] = 2 ; 

263 b [ c +1][ r ] = 2 ; 

264 r e t u r n ( n . a ) ; 

265 } 

266 i f ( alpha < n . a ) 

267 alpha = n . a ; 

268 } 

269 i f ( p [ 2 ] == −1){ 

270 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



272 count++; 


, alpha , beta , 0 ) ; 

274 i f ( n . a < v ) 

275 n . a = v ; 

276 i f ( n . a > beta ) { 

277 b [ c ] [ r ] = 2 ; 

278 b [ c +1][ r ] = 2 ; 

279 r e t u r n ( n . a ) ; 

280 } 

281 i f ( alpha < n . a ) 

282 alpha = n . a ; 

283 } 

284 b [ c ] [ r ] = 2 ; 

285 b [ c +1][ r ] = 2 ; 

286 } 

287 } 

288 } 

289 r e t u r n ( n . a ) ; 

290 }

136 Bilag A 

291 } 

292 

293 // Min−funktionen , l a v e t t i l holde s i g inden f o r e t 4x4 a r e a l 

paa b r a e t t e t 





297 r e t u r n ( n . a ) ; 

298 } 

299 e l s e { 



302 i n t d = n . d ; 

303 // boolean Break = f a l s e ; 

304 f o r ( i n t c=c o l S t a r t ; c v ) 

316 n . a = v ; 

317 i f ( n . a < alpha ) { 

318 b [ c ] [ r ] = 2 ; 

319 b [ c ] [ r +1] = 2 ; 

320 r e t u r n ( n . a ) ; 

321 } 

322 i f ( beta > n . a ) 

323 beta = n . a ; 

324 } 

325 i f ( p [ 2 ] == −1){ 

326 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



328 count++; 


, alpha , beta , 0 ) ; 

330 i f ( n . a > v ) 

331 n . a = v ; 

332 i f ( n . a < alpha ) { 

333 b [ c ] [ r ] = 2 ; 

334 b [ c ] [ r +1] = 2 ; 

335 r e t u r n ( n . a ) ; 

336 } 

337 i f ( beta > n . a ) 

338 beta = n . a ; 

339 }


340 b [ c ] [ r ] = 0 ; 

341 b [ c ] [ r +1] = 1 ; 

342 


344 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

348 i f ( n . a > v ) 

349 n . a = v ; 

350 i f ( n . a < alpha ) { 

351 b [ c ] [ r ] = 2 ; 

352 b [ c ] [ r +1] = 2 ; 

353 r e t u r n ( n . a ) ; 

354 } 

355 i f ( beta > n . a ) 

356 beta = n . a ; 

357 } 

358 i f ( p [ 2 ] == −1){ 

359 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



361 count++; 


, alpha , beta , 0 ) ; 

363 i f ( n . a > v ) 

364 n . a = v ; 

365 i f ( n . a < alpha ) { 

366 b [ c ] [ r ] = 2 ; 

367 b [ c ] [ r +1] = 2 ; 

368 r e t u r n ( n . a ) ; 

369 } 

370 i f ( beta > n . a ) 

371 beta = n . a ; 

372 } 

373 b [ c ] [ r ] = 2 ; 

374 b [ c ] [ r +1] = 2 ; 

375 

376 

377 } 

378 } 

379 } 

380 

381 

382 f o r ( i n t c=c o l S t a r t ; c

138 Bilag A 


[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

393 i f ( n . a > v ) 

394 n . a = v ; 

395 i f ( n . a < alpha ) { 

396 b [ c ] [ r ] = 2 ; 

397 b [ c +1][ r ] = 2 ; 

398 r e t u r n ( n . a ) ; 

399 } 

400 i f ( beta > n . a ) 

401 beta = n . a ; 

402 } 

403 i f ( p [ 2 ] == −1){ 

404 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 



406 count++; 


, alpha , beta , 0 ) ; 

408 i f ( n . a > v ) 

409 n . a = v ; 

410 i f ( n . a < alpha ) { 

411 b [ c ] [ r ] = 2 ; 

412 b [ c +1][ r ] = 2 ; 

413 r e t u r n ( n . a ) ; 

414 } 

415 i f ( beta > n . a ) 

416 beta = n . a ; 

417 } 

418 b [ c ] [ r ] = 0 ; 

419 b [ c +1][ r ] = 1 ; 

420 


422 i f ( p [ 2 ] >= 0) { 



[ 2 ] ) ) ; 


, alpha , beta , 1 ) ; 

426 i f ( n . a > v ) 

427 n . a = v ; 

428 i f ( n . a < alpha ) { 

429 b [ c ] [ r ] = 2 ; 

430 b [ c +1][ r ] = 2 ; 

431 r e t u r n ( n . a ) ; 

432 } 

433 i f ( beta > n . a ) 

434 beta = n . a ; 

435 } 

436 i f ( p [ 2 ] == −1){ 

437 p [2]= nodes [ p [ 0 ] ] [ p [ 1 ] ] . s i z e ( ) ; 


createChildNode ( c +1, r , c , r , n ) ) ) ;


439 count++; 


, alpha , beta , 0 ) ; 

441 i f ( n . a > v ) 

442 n . a = v ; 

443 i f ( n . a < alpha ) { 

444 b [ c ] [ r ] = 2 ; 

445 b [ c +1][ r ] = 2 ; 

446 r e t u r n ( n . a ) ; 

447 } 

448 i f ( beta > n . a ) 

449 beta = n . a ; 

450 } 

451 b [ c ] [ r ] = 2 ; 

452 b [ c +1][ r ] = 2 ; 

453 } 

454 } 

455 } 

456 r e t u r n ( n . a ) ; 

457 } 

458 } 

459 

460 

461 

462 

463 // s a e t t e r s c o r e n f o r en node t i l −”u e n d e l i g ” 



466 r e t u r n ( n ) ; 

467 } 

468 // s a e t t e r s c o r e n f o r en node t i l ” u e n d e l i g ” 



471 r e t u r n ( n ) ; 

472 } 

473 

474 

475 

476 p u b l i c Node returnMove ( boolean b ) { 

477 i f ( tModel . currentTurn == 1) { 



480 Root . wc=tModel . noCols / 2 ; 

481 Root . wr=tModel . noCols / 2 ; 


483 Root . br=Root . wr+1; 

484 r e t u r n ( Root ) ; 

485 } 

486 LocalAreaAB ( ) ; 

487 

488 w h i l e ( Root . c h i l d r e n . s i z e ( ) == 0 && tModel . movesLeft ( ) ) { 

489 i f ( b ) 

490 min ( Root ,−tModel . maxScore , tModel . maxScore , 0 ) ; 

491 i f ( ! b ) 

492 max( Root ,−tModel . maxScore , tModel . maxScore , 0 ) ;

140 Bilag A 

493 i f ( Root . c h i l d r e n . s i z e ( ) == 0) { 

494 i n t [ ] s = new i n t [ 4 ] ; 

495 s = tModel . getAMove ( Root ) ; 

496 setAround ( s ) ; 

497 } 

498 // System . out . p r i n t l n (”LA − End o f While ”) ; 

499 } 

500 


502 Node n ; 



505 n = Root . c h i l d r e n . get ( 0 ) ; 

506 // tModel . t P r i n t . printNode ( Root ) ; // u d s k r i v e r roden 

507 // tModel . t P r i n t . p r i n t C h i l d r e n ( Root ) ; // u d s k r i v e r rodens 

boern saa r e s u l t a t e t a f soegningen bedre kan 

u n d e r s o e g e s 

508 System . out . p r i n t l n (”LA − r e t u r n move Root . s i z e=”+Root . 

c h i l d r e n . s i z e ( ) ) ; 

509 i f ( Root . c h i l d r e n . s i z e ( ) > 1) { 

510 i f ( b ) { 

511 f o r ( i n t i =0; i Root . c h i l d r e n . get ( i ) . a ) { 


514 } 

515 } 

516 } 

517 i f ( ! b ) { 

518 f o r ( i n t i =0; i


540 // tModel . t P r i n t . printNode ( n ) ; 

541 

542 // vender det v a l g t e t r a e k saa det matcher s p i l l e t s 

igangvaerende t r a e k . 



544 System . out . p r i n t l n (”LA − Return move mr=”+mr) ; 

545 i f (mr == 1) { 

546 r e t u r n ( n ) ; 

547 } 

548 i f (mr == 2) { 



551 r e t u r n ( n ) ; 

552 } 

553 i f (mr == 3) { 



556 r e t u r n ( n ) ; 

557 } 

558 i f (mr == 4) { 





563 r e t u r n ( n ) ; 

564 } 

565 i f (mr == 5) { 

566 n . bc = bR ; 

567 n . wc = wR; 

568 n . br = bC ; 

569 n . wr = wC; 

570 r e t u r n ( n ) ; 

571 } 

572 i f (mr == 6) { 



575 n . br = bC ; 

576 n . wr = wC; 

577 r e t u r n ( n ) ; 

578 } 

579 i f (mr == 7) { 

580 n . bc = bR ; 

581 n . wc = wR; 



584 r e t u r n ( n ) ; 

585 } 

586 i f (mr == 8) { 





591 r e t u r n ( n ) ; 

592 }

142 Bilag A 

593 r e t u r n ( n ) ; 

594 } 

595 

596 

597 } 

A.4 AITaijiMinimax.java 



3 

4 p u b l i c c l a s s AITaijiMinimax { 



7 p u b l i c Tree tTree ; 


9 p u b l i c i n t maxDepth ; // f o r at kunne s a e t t e en max dybde paa 

soegningen 

10 

11 p u b l i c AITaijiMinimax ( TaijiModel m) { 


13 } 

14 

15 // F r e m s t i l l e r t r a e e t med udgangs punkt i det nuvaerende b r a e t . 

16 p u b l i c void c r e a t e T r e e ( ) 

17 { 


19 Node i n i t = tNode . createNode ( tModel . currentTurn , 

tModel ) ; 

20 count = 1 ; 

21 // i n t b [ ] [ ] = tModel . getOneBoard ( tModel . currentTurn ) ; 

22 //Node t e s t = tNode . createCloneNode ( i n i t ) ; 

23 // System . out . p r i n t l n (” t e s t . par ”+ t e s t . par ) ; 

24 tTree = new Tree ( ) ; 

25 tTree . setRoot ( i n i t ) ; 

26 

27 i n t maxTurns = tModel . maxTurnsLeft ( ) ; 

28 System . out . p r i n t l n (” minimax max t u r n s l e f t ”+maxTurns ) 

; 

29 setMaxDepth ( 1 ) ; 

30 // System . out . p r i n t l n (” i n i t ”) ; 

31 // System . out . p r i n t l n (” ”+ i n i t +” ”+ i n i t . par+” ”+ i n i t . a+” 

”+ i n i t . bc+” ”+ i n i t . br+” ”+ i n i t . wc+” ”+ i n i t . wr+” ”+ 

i n i t . c h i l d r e n +” ”+ i n i t . nodeBoard+” ”+ i n i t . d ) ; 

32 // System . out . p r i n t l n ( i n i t . nodeBoard [ 0 ] [ 0 ] + ” ”+ i n i t . 

nodeBoard [ 1 ] [ 0 ] + ” ”+ i n i t . nodeBoard [ 2 ] [ 0 ] ) ; 





35 

36 // System . out . p r i n t l n (” minimax createChildren ”) ; 

37 c r e a t e C h i l d r e n ( i n i t , 0) ;

A.4 AITaijiMinimax.java 143 

38 // printOddGen ( ) ; 

39 // System . out . p r i n t l n (” ”) ; 

40 c r e a t e C h i l d r e n ( tTree . oddGen . get ( 1 ) , 1) ; 

41 // printEvenGen ( ) ; 

42 // System . out . p r i n t l n (” minimax createLeaves ”) ; 

43 c r e a t e L e a v e s ( ) ; 

44 calcScoreOnLeaves ( ) ; 

45 // p r i n t F i n a l L e a v e s ( ) ; 

46 // System . out . p r i n t l n (” c a l c T r e e ”) ; 

47 // p r i n t L e a v e s ( ) ; 

48 // System . out . p r i n t l n (” minimax calcTree ”) ; 

49 c a l c T r e e ( ) ; 

50 System . out . p r i n t l n (”Number o f nodes c r e a t e d : ”+count ) ; 

51 count =0; 

52 // addLeavesToGen ( 4 ) ; 

53 // calcGen ( 4 ) ; 

54 // printMax ( ) ; 

55 // printOddGen ( ) ; 

56 

57 } 

58 

59 

60 

61 // Laver en node / barn f o r hvert muligt t r a e k f r a f o r a e l d r e noden 

. Laver a l t s a a en g e n e r a t i o n a f boern . 

62 p r i v a t e void c r e a t e C h i l d r e n ( Node p , i n t d ) 

63 { 

64 i n t [ ] [ ] b = p . nodeBoard ; 


66 f o r ( i n t r =0; r < tModel . noRows−1; r++){ 

67 i f ( b [ c ] [ r ] == 2 && b [ c ] [ r +1] == 2 ) { 

68 b [ c ] [ r ] = 1 ; 

69 b [ c ] [ r +1] = 0 ; 

70 i n t i ; 

71 i = c h e c k B o a r d I n d i v i d u a l i t y ( b , d ) ; 

72 // System . out . p r i n t l n (” minimax checkBI i= ”+ i ) ; 

73 i f ( i >= 0) { 

74 i f ( d % 2 == 1) 

75 tTree . evenGen . get ( i ) . par . add ( p ) ; 

76 i f ( d % 2 == 0) 

77 tTree . oddGen . get ( i ) . par . add ( p ) ; 

78 } 

79 i f ( i == −1){ 

80 i f ( d % 2 == 1) { 

81 tTree . evenGen . add ( p . addChild ( tNode . 

createChildNode ( c , r , c , r +1, p ) ) ) ; 

82 count++; 

83 } 

84 i f ( d % 2 == 0) { 

85 tTree . oddGen . add ( p . addChild ( tNode . 


86 count++; 

87 } 

88 } 

89

144 Bilag A 

90 b [ c ] [ r ] = 0 ; 

91 b [ c ] [ r +1] = 1 ; 


93 // System . out . p r i n t l n (” minimax checkBI2 i= ”+ i ) ; 

94 i f ( i >= 0) { 

95 i f ( d % 2 == 1) 


97 i f ( d % 2 == 0) 


99 } 

100 i f ( i == −1){ 

101 i f ( d % 2 == 1) { 


createChildNode ( c , r +1, c , r , p ) ) ) ; 

103 count++; 

104 } 

105 i f ( d % 2 == 0) { 



107 count++; 

108 } 

109 } 

110 b [ c ] [ r ] = 2 ; 

111 b [ c ] [ r +1] = 2 ; 

112 

113 // tTree . addLeave ( p . addChild ( tNode . 




115 } 

116 

117 } 

118 } 



121 i f ( b [ c ] [ r ] == 2 && b [ c +1][ r ] == 2 ) { 

122 b [ c ] [ r ] = 1 ; 

123 b [ c +1][ r ] = 0 ; 

124 i n t i ; 


126 // System . out . p r i n t l n (” minimax checkBoardIndi i 

= ”+ i ) ; 

127 i f ( i >= 0) { 

128 i f ( d % 2 == 1) 


130 i f ( d % 2 == 0) 


132 } 

133 i f ( i == −1){ 

134 i f ( d % 2 == 1) { 


createChildNode ( c , r , c +1, r , p ) ) ) ; 

136 count++; 

137 } 

138 i f ( d % 2 == 0) {




140 count++; 

141 } 

142 } 

143 

144 b [ c ] [ r ] = 0 ; 

145 b [ c +1][ r ] = 1 ; 


147 i f ( i >= 0) { 

148 i f ( d % 2 == 1) 


150 i f ( d % 2 == 0) 


152 } 

153 i f ( i == −1){ 

154 i f ( d % 2 == 1) { 


createChildNode ( c +1, r , c , r , p ) ) ) ; 

156 count++;} 

157 i f ( d % 2 == 0) { 



159 count++; 

160 } 

161 } 

162 b [ c ] [ r ] = 2 ; 

163 b [ c +1][ r ] = 2 ; 





166 } 

167 } 

168 } 

169 } 

170 

171 // Checker om e t b r a e t a l l e r e d e e k s i s t e r e i en node , 

172 // r e t u r n e r e r i f o r p l a c e r i n g paa node med samme b r a e t e l l e r −1, 

h v i s der i k k e f i n d e s en 

173 p r i v a t e i n t c h e c k B o a r d I n d i v i d u a l i t y ( i n t [ ] [ ] b , i n t d ) { 

174 i f ( d % 2 == 1) { 

175 // System . out . p r i n t l n (” minimax checkBI s i z e even ”+tTree . 

evenGen . s i z e ( ) ) ; 

176 f o r ( i n t i = 0 ; i

146 Bilag A 

185 // System . out . p r i n t l n (” minimax checkBI s i z e odd ”+tTree . 

oddGen . s i z e ( ) ) ; 

186 f o r ( i n t i = 0 ; i


231 f o r ( i n t i = 0 ; i < tTree . oddGen . s i z e ( ) ; i ++){ 

232 c r e a t e C h i l d r e n ( tTree . oddGen . get ( i ) , d ) ; 

233 } 

234 oddGenToLeaves ( ) ; 

235 // i f ( d != 1) 

236 tTree . oddGen . c l e a r ( ) ; 

237 } 

238 i f ( d % 2 == 0) { 

239 f o r ( i n t i = 0 ; i < tTree . evenGen . s i z e ( ) ; i ++){ 

240 c r e a t e C h i l d r e n ( tTree . evenGen . get ( i ) , d ) ; 

241 } 

242 evenGenToLeaves ( ) ; 

243 tTree . evenGen . c l e a r ( ) ; 

244 } 

245 } 

246 //Node t = tNode . createCloneNode ( tTree . Leaves [ 1 ] ) ; 

247 // c r e a t e C h i l d r e n ( t ) ; 

248 // System . out . p r i n t l n (” createGen ”+tTree . Leaves . get ( 0 ) ) ; 

249 // f o r ( i n t i =0; i

148 Bilag A 

280 } 

281 

282 // f l y t t e r noder t i l Leaves h v i s de e r f i n a l s t a t e s , e l l e r s 

s a e t t e s s c o r e t i l min 

283 p r i v a t e void oddGenToLeaves ( ) { 

284 f o r ( i n t i = 0 ; i


329 i f ( tTree . evenGen . get ( i ) . a > tTree . evenGen . get ( i ) . 

par . get ( j ) . a ) 

330 tTree . evenGen . get ( i ) . par . get ( j ) . a = tTree . 

evenGen . get ( i ) . a ; 

331 } 

332 } 

333 } 

334 i f ( d % 2 == 1) { 

335 f o r ( i n t i =0; i

150 Bilag A 

377 // i f ( tTree . max [ i ] . d > 0) { // f o r at undgaa n u l l 

p o i n t e r h v i s roden e r med i ”max” 

378 // i f ( tTree . max [ i ] . par == n u l l ) 

379 // // System . out . p r i n t l n (”maxMax Null i ”+ i +” 

curMax ”+tTree . curMax+” D ”+tTree . max [ i ] . d ) ; 

380 // i f ( tTree . max [ i ] . par . a < tTree . max [ i ] . a ) { 

381 // tTree . max [ i ] . par . a = tTree . max [ i ] . a ; 

382 // // System . out . p r i n t l n (” minMin a ”+tTree . 

max [ i ] . a+” par . a ”+tTree . max [ i ] . par . a ) ; 

383 // i f ( ! tTree . checkMin ( tTree . max [ i ] . par ) ) 

384 // tTree . addMin ( tTree . max [ i ] . par ) ; 

385 // } 

386 // } 

387 // } 

388 //} 

389 

390 p u b l i c Node returnMove ( ) { 

391 Node n ; 

392 n = tTree . oddGen . get ( 0 ) ; 

393 i f ( tTree . oddGen . s i z e ( ) > 1) { 

394 f o r ( i n t i = 0 ; i tTree . oddGen . get ( i ) . a ) { 

396 n=tTree . oddGen . get ( i ) ; 

397 } 

398 } 

399 } 

400 r e t u r n ( n ) ; 

401 } 

402 

403 // r e t u r n e r e r det t r a e k der s k a l t a g e s ved at r e t u r n e r e r noden 

med som i n d e h o l d e r t r a e k k e t , vaer opmaerksom 

404 // paa at nodens b r a e t i k k e e r b l e v e t r o t t e r e t kun s e l v e 

t r a e k k e t der s k a l f o r e t a g e s . 

405 p u b l i c Node returnMoveMirRot ( ) { 


407 Node n ; 



410 n = tTree . oddGen . get ( 0 ) ; 

411 i f ( tTree . oddGen . s i z e ( ) > 1) { 

412 f o r ( i n t i = 0 ; i tTree . oddGen . get ( i ) . a ) { 

414 n=tTree . oddGen . get ( i ) ; 

415 } 

416 } 

417 f o r ( i n t i = 0 ; i


427 wR = n . wr ; 

428 bC = n . bc ; 

429 bR = n . br ; 

430 n . nodeBoard [wC ] [ wR]=2; 

431 n . nodeBoard [ bC ] [ bR]=2; 

432 



434 i f (mr == 1) { 

435 r e t u r n ( n ) ; 

436 } 

437 i f (mr == 2) { 



440 r e t u r n ( n ) ; 

441 } 

442 i f (mr == 3) { 



445 r e t u r n ( n ) ; 

446 } 

447 i f (mr == 4) { 





452 r e t u r n ( n ) ; 

453 } 

454 i f (mr == 5) { 

455 n . bc = bR ; 

456 n . wc = wR; 

457 n . br = bC ; 

458 n . wr = wC; 

459 r e t u r n ( n ) ; 

460 } 

461 i f (mr == 6) { 



464 n . br = bC ; 

465 n . wr = wC; 

466 r e t u r n ( n ) ; 

467 } 

468 i f (mr == 7) { 

469 n . bc = bR ; 

470 n . wc = wR; 



473 r e t u r n ( n ) ; 

474 } 

475 i f (mr == 8) { 





480 r e t u r n ( n ) ;

152 Bilag A 

481 } 

482 r e t u r n ( n ) ; 

483 } 

484 

485 

486 p r i v a t e void p r i n t L e a v e s ( ) { 

487 System . out . p r i n t l n (” Current Leaves ”) ; 

488 f o r ( i n t i =0; i


[ 1 ] [ 2 ] + ” ”+tTree . evenGen . get ( i ) . nodeBoard 

[ 2 ] [ 2 ] ) ; 


507 } 

508 } 

509 

510 p r i v a t e void printOddGen ( ) { 

511 System . out . p r i n t l n (”OddGen”) ; 

512 f o r ( i n t i =0; i

154 Bilag A 

532 // System . out . p r i n t l n ( tTree . Leaves [ i ] . c h i l d r e n . get ( j 

) . nodeBoard [ 0 ] [ 2 ] + ” ”+tTree . Leaves [ i ] . c h i l d r e n . get ( j ) . 

nodeBoard [ 1 ] [ 2 ] + ” ”+tTree . Leaves [ i ] . c h i l d r e n . get ( j ) . 

nodeBoard [ 2 ] [ 2 ] ) ; 

533 // System . out . p r i n t l n ( ) ; 

534 // } 

535 //} 

536 

537 p r i v a t e boolean checkMaxMin ( ) { 


539 i f ( tTree . oddGen . get ( i ) == n u l l ) { 

540 System . out . p r i n t l n (” Null i ”+ i +” s i z e even ”+tTree 

. curMax ) ; 

541 r e t u r n ( f a l s e ) ; 

542 } 

543 } 

544 f o r ( i n t j = 0 ; j < tTree . evenGen . s i z e ( ) ; j++){ 

545 i f ( tTree . evenGen . get ( j ) == n u l l ) { 

546 System . out . p r i n t l n (” Null j ”+ j +” s i z e odd ”+tTree . 

curMin ) ; 

547 r e t u r n ( f a l s e ) ; 

548 } 

549 

550 } 

551 r e t u r n ( t r u e ) ; 

552 } 

553 

554 p r i v a t e boolean checkMaxMinPar ( ) { 


556 i f ( tTree . oddGen . get ( i ) . par == n u l l ) { 

557 System . out . p r i n t l n (” Null Par i ”+ i +” odd ”+tTree . 

oddGen . s i z e ( ) ) ; 

558 r e t u r n ( f a l s e ) ; 

559 } 

560 } 

561 f o r ( i n t j = 0 ; j < tTree . evenGen . s i z e ( ) ; j++){ 

562 i f ( tTree . evenGen . get ( j ) . par == n u l l ) { 

563 System . out . p r i n t l n (” Null Par j ”+ j +” even ”+tTree . 

evenGen . s i z e ( ) ) ; 

564 r e t u r n ( f a l s e ) ; 

565 } 

566 

567 } 

568 r e t u r n ( t r u e ) ; 

569 } 

570 

571 // e r s a e t t e s maxDepth 

572 p r i v a t e void setMaxDepth ( i n t mode ) { 

573 // i ”Mode 0” f o r s o e g e r den at regne h e l e t r a e e t igennem 

574 i f ( mode == 0) { 

575 maxDepth = ( tModel . noCols ∗ tModel . noRows /2) ; 

576 System . out . p r i n t l n (” minimax Mode 0 maxDepth = ”+ 

maxDepth ) ; 

577 }

A.5 Board.java 155 

578 // i ”Mode 1” s a e t t e s max fremregningen t i l 2 , h v i s der e r 

mere en 5 t r a e k t i l b a g e , 

579 // e l l e r s r e g n e r den h e l t igennem . 

580 i f ( mode == 1) { 

581 i n t maxT = tModel . maxTurnsLeft ( ) ; 

582 i f (maxT > 10) 

583 maxDepth = 2 ; 

584 i f (maxT > 5 && maxT

156 Bilag A 

33 p u b l i c i n t [ ] [ ] getOneBoard ( i n t t ) 

34 { 

35 oneBoard = board [ t ] ; 

36 r e t u r n oneBoard ; 

37 

38 } 

39 

40 // P l a c e r e r en b r i k ( n e u t r a l , white e l l e r black ) paa e t f e l t i 

den nuvaerende tur . 

41 // Modtager p o s i t i o n e n og f a r v e n paa brikken som argument . 

42 p u b l i c void s e t P i e c e ( i n t col , i n t row , i n t p i e c e ) 

43 { 

44 board [ tModel . currentTurn ] [ c o l ] [ row ] = p i e c e ; 

45 } 

46 

47 // Reset . Toemmer b r a e t t e t , s a e t t e r o e j e b l i k s v a e r d i e r n e t i l 

u d g a n g s p o s i t i o n e n . 

48 p u b l i c void r esetBoard ( ) 

49 { 

50 i n t C = tModel . getNoCols ( ) ; 

51 i n t R = tModel . getNoRows ( ) ; 

52 

53 f o r ( i n t c = 0 ; c < C; c++) 

54 { 

55 f o r ( i n t r = 0 ; r < R; r++) 

56 { 

57 s e t P i e c e ( c , r , 2 ) ; 

58 } 

59 } 

60 board [ 0 ] [ 0 ] [ 0 ] = 1 ; 

61 } 

62 

63 // Kopiere b r a e t t e t f r a den nuvaerende tur t i l den n a e s t e . 

64 p u b l i c void copyBoard ( ) 

65 { 

66 f o r ( i n t c =0; c < tModel . noCols ; c++) 

67 f o r ( i n t r =0; r < tModel . noRows ; r++) 

68 board [ tModel . currentTurn +1][ c ] [ r ] = board [ tModel . 

currentTurn ] [ c ] [ r ] ; 

69 } 

70 // Kopiere b r a e t t e t f r a den nuvaerende tur t i l tur t . 

71 p u b l i c void copyBoardTo ( i n t t ) 

72 { 



75 board [ tModel . currentTurn+t ] [ c ] [ r ] = board [ tModel . 

currentTurn ] [ c ] [ r ] ; 

76 } 

77 

78 // Laver en klon a f b r a e t t e t f o r tur t 

79 p u b l i c void cloneBoard ( i n t t ) 

80 { 

81 c l o n e = new i n t [ tModel . noCols ] [ tModel . noRows ] ; 


83 f o r ( i n t r =0; r < tModel . noRows ; r++)


84 c l o n e [ c ] [ r ] = board [ t ] [ c ] [ r ] ; 

85 } 

86 

87 // Kloner e t b r a e t og r e t u n e r e r klonen 

88 p u b l i c i n t [ ] [ ] c l o n e ( i n t [ ] [ ] b ) 

89 { 




93 c l o n e [ c ] [ r ] = b [ c ] [ r ] ; 

94 r e t u r n ( b ) ; 

95 } 

96 

97 // Laver og r e t u r n e r e en klon a f b r a e t t e t f o r tur t 

98 p u b l i c i n t [ ] [ ] getClone ( i n t t ) 

99 { 

100 cloneBoard ( t ) ; 

101 r e t u r n ( c l o n e ) ; 

102 } 

103 

104 // sammenligner to braet , h v i s de e r h e l t ens r e t u r n e r e s t r u e 

105 p u b l i c boolean compareBoards ( i n t [ ] [ ] b , i n t [ ] [ ] d ) { 



108 i f ( ( b [ c ] [ r ] != d [ c ] [ r ] ) ) { 

109 r e t u r n ( f a l s e ) ; 

110 } 

111 } 

112 } 

113 r e t u r n ( t r u e ) ; 

114 } 

115 

116 // Sammenligner to braet , h v i s de e r ens ( r o t t e r e t og/ e l l e r 

s p e j l v e n d t ) r e t u r n e r e s en v a e r d i mellem 1 og 8 

117 // e f t e r hvordan de e r ens (1 e r ens uden r o t a t i o n e l l e r 

s p e j l v e n d i n g ) . Er de i k k e ens r e t u r n e r e s 0 

118 p u b l i c i n t compareBoardsInt ( i n t [ ] [ ] b , i n t [ ] [ ] d ) { 

119 i n t C = tModel . noCols −1; 

120 i n t R = tModel . noRows −1; 

121 boolean br = f a l s e ; 



124 i f ( b [ c ] [ r ] != d [ c ] [ r ] ) { 

125 br = t r u e ; 

126 break ; 

127 } 

128 } 

129 i f ( br ) 

130 break ; 

131 } 

132 i f ( ! br ) 

133 r e t u r n ( 1 ) ; 

134 

135 br = f a l s e ; 

136 f o r ( i n t c =0; c < tModel . noCols ; c++){

158 Bilag A 


138 i f ( b [ c ] [ r ] != d [ c ] [ R−r ] ) { 

139 br = t r u e ; 

140 break ; 

141 } 

142 } 

143 i f ( br ) 

144 break ; 

145 } 

146 i f ( ! br ) 

147 r e t u r n ( 2 ) ; 

148 

149 br = f a l s e ; 



152 i f ( b [ c ] [ r ] != d [ C−c ] [ r ] ) { 

153 br = t r u e ; 

154 break ; 

155 } 

156 } 

157 i f ( br ) 

158 break ; 

159 } 

160 i f ( ! br ) 

161 r e t u r n ( 3 ) ; 

162 

163 br = f a l s e ; 



166 i f ( b [ c ] [ r ] != d [ C−c ] [ R−r ] ) { 

167 br = t r u e ; 

168 break ; 

169 } 

170 } 

171 i f ( br ) 

172 break ; 

173 } 

174 i f ( ! br ) 

175 r e t u r n ( 4 ) ; 

176 

177 i f ( tModel . noCols != tModel . noRows ) // de f o e l g e n d e e r kun 

mulige hvis , b r a e t t e t e r k v a d r a t i s k 

178 r e t u r n ( 0 ) ; 

179 

180 br = f a l s e ; 



183 i f ( b [ c ] [ r ] != d [ r ] [ c ] ) { 

184 br = t r u e ; 

185 break ; 

186 } 

187 } 

188 i f ( br ) 

189 break ; 

190 }


191 i f ( ! br ) 

192 r e t u r n ( 5 ) ; 

193 

194 br = f a l s e ; 



197 i f ( b [ c ] [ r ] != d [R−r ] [ c ] ) { 

198 br = t r u e ; 

199 break ; 

200 } 

201 } 

202 i f ( br ) 

203 break ; 

204 } 

205 i f ( ! br ) 

206 r e t u r n ( 6 ) ; 

207 

208 br = f a l s e ; 



211 i f ( b [ c ] [ r ] != d [ r ] [ C−c ] ) { 

212 br = t r u e ; 

213 break ; 

214 } 

215 } 

216 i f ( br ) 

217 break ; 

218 } 

219 i f ( ! br ) 

220 r e t u r n ( 7 ) ; 

221 

222 br = f a l s e ; 



225 i f ( b [ c ] [ r ] != d [R−r ] [ C−c ] ) { 

226 br = t r u e ; 

227 break ; 

228 } 

229 } 

230 i f ( br ) 

231 break ; 

232 } 

233 i f ( ! br ) 

234 r e t u r n ( 8 ) ; 

235 

236 r e t u r n ( 0 ) ; 

237 } 

238 

239 // sammenligner to braet , h v i s de e r ens ( r o t t e r e t og/ e l l e r 

s p e j l v e n d t ) r e t u r n e r e s t r u e 

240 p u b l i c boolean compareBoardsBool ( i n t [ ] [ ] b , i n t [ ] [ ] d ) { 

241 i n t C = tModel . noCols −1; 

242 i n t R = tModel . noRows −1; 

243 boolean br = f a l s e ; 


160 Bilag A 


246 i f ( b [ c ] [ r ] != d [ c ] [ r ] ) { 

247 br = t r u e ; 

248 break ; 

249 } 

250 } 

251 i f ( br ) 

252 break ; 

253 } 

254 i f ( ! br ) 

255 r e t u r n ( t r u e ) ; 

256 

257 br = f a l s e ; 



260 i f ( b [ c ] [ r ] != d [ c ] [ R−r ] ) { 

261 br = t r u e ; 

262 break ; 

263 } 

264 } 

265 i f ( br ) 

266 break ; 

267 } 

268 i f ( ! br ) 

269 r e t u r n ( t r u e ) ; 

270 

271 br = f a l s e ; 



274 i f ( b [ c ] [ r ] != d [ C−c ] [ r ] ) { 

275 br = t r u e ; 

276 break ; 

277 } 

278 } 

279 i f ( br ) 

280 break ; 

281 } 

282 i f ( ! br ) 

283 r e t u r n ( t r u e ) ; 

284 

285 br = f a l s e ; 



288 i f ( b [ c ] [ r ] != d [ C−c ] [ R−r ] ) { 

289 br = t r u e ; 

290 break ; 

291 } 

292 } 

293 i f ( br ) 

294 break ; 

295 } 

296 i f ( ! br ) 

297 r e t u r n ( t r u e ) ; 

298


299 i f ( tModel . noCols != tModel . noRows ) // de f o e l g e n d e e r kun 

mulige hvis , b r a e t t e t e r k v a d r a t i s k 

300 r e t u r n ( f a l s e ) ; 

301 

302 br = f a l s e ; 



305 i f ( b [ c ] [ r ] != d [ r ] [ c ] ) { 

306 br = t r u e ; 

307 break ; 

308 } 

309 } 

310 i f ( br ) 

311 break ; 

312 } 

313 i f ( ! br ) 

314 r e t u r n ( t r u e ) ; 

315 

316 br = f a l s e ; 



319 i f ( b [ c ] [ r ] != d [R−r ] [ c ] ) { 

320 br = t r u e ; 

321 break ; 

322 } 

323 } 

324 i f ( br ) 

325 break ; 

326 } 

327 i f ( ! br ) 

328 r e t u r n ( t r u e ) ; 

329 

330 br = f a l s e ; 



333 i f ( b [ c ] [ r ] != d [ r ] [ C−c ] ) { 

334 br = t r u e ; 

335 break ; 

336 } 

337 } 

338 i f ( br ) 

339 break ; 

340 } 

341 i f ( ! br ) 

342 r e t u r n ( t r u e ) ; 

343 

344 br = f a l s e ; 



347 i f ( b [ c ] [ r ] != d [R−r ] [ C−c ] ) { 

348 br = t r u e ; 

349 break ; 

350 } 

351 } 

352 i f ( br )

162 Bilag A 

353 break ; 

354 } 

355 i f ( ! br ) 

356 r e t u r n ( t r u e ) ; 

357 

358 r e t u r n ( f a l s e ) ; 

359 } 

360 } 

A.6 FigureMap.java 

1 

2 

3 

4 p u b l i c c l a s s FigureMap { 

5 p r i v a t e i n t [ ] [ ] f i g B o a r d ; 

6 p r i v a t e i n t figW = 1 ; // Laveste nummer f o r hvide f i g u r e r , der 

e r endnu i k k e har v a e r e t i brug . 

7 p r i v a t e i n t f i g B = 2 ; // Laveste nummer f o r s o r t e f i g u r e r , der 

e r endnu i k k e har v a e r e t i brug . 

8 p r i v a t e i n t w h i t e P i e c e s = 0 , b l a c k P i e c e s = 0 ; 

9 p r i v a t e i n t noCols ; // a n t a l kolonner 

10 p r i v a t e i n t noRows ; // a n t a l r a e k k e r 

11 



14 

15 p u b l i c FigureMap ( TaijiModel m) { 


17 } 

18 

19 p u b l i c FigureMap ( Node n ) 

20 { 

21 t h i s . tNode = n ; 

22 } 

23 

24 // udregner s c o r e n f o r b r a e t t e t b . 

25 p u b l i c i n t [ ] c a l S c o r e ( i n t [ ] [ ] b , i n t c o l s , i n t rows ) 

26 { 

27 noCols = c o l s ; 

28 noRows = rows ; 

29 r e s e t F i g B o a r d ( ) ; 

30 mapFigures ( b ) ; 

31 c o u n t P i e c e s ( ) ; 

32 i n t [ ] s c o r e ; 

33 s c o r e = new i n t [ 2 ] ; 

34 s c o r e [0]= w h i t e P i e c e s ; 

35 s c o r e [1]= b l a c k P i e c e s ; 

36 r e t u r n ( s c o r e ) ; 

37 } 

38 

39 // udregner d i f f e r e n s e n mellem hvid og s o r t s c o r e 

40 p u b l i c i n t c a l D i f ( i n t [ ] [ ] b , i n t c o l s , i n t rows )

A.6 FigureMap.java 163 

41 { 





46 c o u n t P i e c e s ( ) ; 

47 i n t s c o r e ; 

48 s c o r e = w h i t e P i e c e s − b l a c k P i e c e s ; 

49 // System . out . p r i n t l n (” s c o r e ”+s c o r e+” WhiteS ”+w h i t e P i e c e s 

+” BlackS ”+b l a c k P i e c e s ) ; 

50 r e t u r n ( s c o r e ) ; 

51 } 

52 

53 // Returner f i g B o a r d e t f o r e t b r a e t ( f i g u r B r a e t t e t ) 

54 p u b l i c i n t [ ] [ ] getFigBoard ( i n t [ ] [ ] b , i n t c o l s , i n t rows ) { 





59 r e t u r n ( f i g B o a r d ) ; 

60 } 

61 

62 

63 

64 // Navnegiver de e n k e l t e f e l t e r e f t e r h v i l k e n f i g u r de hoere 

t i l . 

65 //( Navnene e r l i g e t a l f o r s o r t e f i g u r e og u l i g e f o r hvide ) 

66 p u b l i c void mapFigures ( i n t [ ] [ ] b ) { 

67 { // F o e r s t e kolone nedad 

68 f i g B o a r d = new i n t [ tModel . noCols ] [ tModel . noRows ] ; 

69 i n t c =0; 

70 { 


72 { 

73 i f ( b [ c ] [ r ] == 1) 

74 { 

75 i f ( f i g B o a r d [ c ] [ r ] == 0) 

76 { 

77 s e t F i g u r e ( c , r , figW ) ; 

78 figW = figW +2; 

79 } 

80 } 

81 e l s e 

82 { 

83 i f ( b [ c ] [ r ] == 0) 

84 { 

85 i f ( f i g B o a r d [ c ] [ r ] == 0) 

86 { 

87 s e t F i g u r e ( c , r , f i g B ) ; 

88 f i g B = f i g B +2; 

89 } 

90 } 

91 } 

92 } 

93 }

164 Bilag A 

94 } 

95 { // H o r i s o n t a l k o r t l a e n g i n g 

96 f o r ( i n t c =0; c < tModel . noCols −1; c++) 

97 { 


99 { 

100 i f ( b [ c ] [ r ] == 0 && b [ c +1][ r ] == 0 ) 

101 { 

102 i f ( f i g B o a r d [ c ] [ r ] == 0) 

103 { 


105 f i g B=f i g B +2; 

106 } 

107 s e t F i g u r e ( c +1, r , f i g B o a r d [ c ] [ r ] ) ; 

108 } 

109 e l s e 

110 { 

111 i f ( b [ c ] [ r ] == 1 && b [ c +1][ r ] == 1 ) 

112 { 

113 i f ( f i g B o a r d [ c ] [ r ] == 0) 

114 { 


116 figW=figW +2; 

117 } 

118 s e t F i g u r e ( c +1, r , f i g B o a r d [ c ] [ r ] ) ; 

119 } 

120 e l s e 

121 { 

122 i f ( b [ c ] [ r ] != 1 && b [ c +1][ r ] == 1 ) 

123 { 

124 s e t F i g u r e ( c +1, r , figW ) ; 

125 figW = figW +2; 

126 } 

127 e l s e 

128 { 

129 i f ( b [ c ] [ r ] != 0 && b [ c +1][ r ] == 0 

) 

130 { 

131 s e t F i g u r e ( c +1, r , f i g B ) ; 

132 f i g B = f i g B +2; 

133 } 

134 } 

135 } 

136 } 

137 } 

138 } 

139 } 

140 { // V e r t i k a l t k o r t l a e n g i n g 


142 { 

143 f o r ( i n t r =0; r < tModel . noRows−1; r++) 

144 { 

145 i f ( b [ c ] [ r ] == 0 && b [ c ] [ r +1] == 0 ) 

146 { 

147 i f ( f i g B o a r d [ c ] [ r ] != 0)


148 { 

149 i f ( ( f i g B o a r d [ c ] [ r ] != f i g B o a r d [ c ] [ r 

+1]) && f i g B o a r d [ c ] [ r +1] != 0) 

150 { 

151 r e p l a c e F i g ( f i g B o a r d [ c ] [ r +1] , 

f i g B o a r d [ c ] [ r ] ) ; 

152 } 

153 } 

154 

155 e l s e 

156 { 

157 i f ( f i g B o a r d [ c ] [ r +1] != 0) 

158 s e t F i g u r e ( c , r , f i g B o a r d [ c ] [ r +1]) ; 

159 e l s e 

160 { 


162 f i g B=f i g B +2; 

163 } 

164 } 

165 s e t F i g u r e ( c , r +1, f i g B o a r d [ c ] [ r ] ) ; 

166 } 

167 e l s e 

168 { 

169 i f ( b [ c ] [ r ] == 1 && b [ c ] [ r +1] == 1 ) 

170 { 

171 i f ( f i g B o a r d [ c ] [ r ] != 0) 

172 { 

173 i f ( ( f i g B o a r d [ c ] [ r ] != f i g B o a r d [ c ] [ 

r +1]) && f i g B o a r d [ c ] [ r +1] != 0) 

174 { 

175 r e p l a c e F i g ( f i g B o a r d [ c ] [ r +1] , 

f i g B o a r d [ c ] [ r ] ) ; 

176 } 

177 } 

178 

179 e l s e 

180 { 

181 i f ( f i g B o a r d [ c ] [ r +1] != 0) 

182 s e t F i g u r e ( c , r , f i g B o a r d [ c ] [ r +1]) 

; 

183 e l s e 

184 { 


186 figW=figW +2; 

187 } 

188 } 

189 s e t F i g u r e ( c , r +1, f i g B o a r d [ c ] [ r ] ) ; 

190 } 

191 } 

192 } 

193 } 

194 } 

195 } 

196 

197 // s a e t t e r e t f i g u r n r . f o r e t f e l t .

166 Bilag A 

198 p r i v a t e void s e t F i g u r e ( i n t col , i n t row , i n t f i g ) 

199 { 

200 f i g B o a r d [ c o l ] [ row ] = f i g ; 

201 } 

202 

203 // Reset v a e r d i e r n e i f i g B oard . 

204 p u b l i c void r e s e t F i g B o ard ( ) 

205 { 

206 figW = 1 ; 

207 f i g B = 2 ; 

208 f i g B o a r d = new i n t [ noCols ] [ noRows ] ; 

209 f o r ( i n t c = 0 ; c < noCols ; c++) 

210 f o r ( i n t r = 0 ; r < noRows ; r++) 

211 s e t F i g u r e ( c , r , 0 ) ; 

212 } 

213 

214 // E r s t a t e r a l l e f i g u r e med e t bestemt navn med e t nyt navn . 

215 p r i v a t e void r e p l a c e F i g ( i n t oldF , i n t newF) 

216 { 

217 f o r ( i n t c =0; c


251 i n t maxW2 = −1; 

252 i n t maxB1 = −2; 

253 i n t maxB2 = −2; 

254 

255 f o r ( i n t w=1; wcountFig (maxW1) ) 

257 { 

258 maxW2 = maxW1; 

259 maxW1 = w; 

260 } 

261 e l s e 

262 i f ( countFig (w)>countFig (maxW2) ) 

263 maxW2 = w; 

264 f o r ( i n t b=2; bcountFig (maxB1) ) 

266 { 

267 maxB2 = maxB1 ; 

268 maxB1 = b ; 

269 } 

270 e l s e 

271 i f ( countFig ( b )>countFig (maxB2) ) 

272 maxB2 = b ; 

273 w h i t e P i e c e s = countFig (maxW1)+countFig (maxW2) ; 

274 b l a c k P i e c e s = countFig (maxB1)+countFig (maxB2) ; 

275 } 

276 

277 // r e t u r n e r numrene f o r de 2 s t o e r s t e hvid og de 2 s t o e r s t e 

s o r t e f i g u r e , som der endnu kan p l a c e r e s b r i k opad . 

278 p u b l i c i n t [ ] [ ] [ ] g e t F i g s ( i n t [ ] [ ] fb ) { 

279 i n t [ ] [ ] [ ] f = new i n t [ 2 ] [ 2 ] [ 2 ] ; 

280 // f [ ] [ ] [ 0 ] = f i g u r navnet (nummer) , f [ ] [ ] [ 1 ] = f i g u r e n s 

s t o e r r e l s e 

281 // f [ 1 ] [ ] [ ] = hvid f i g u r , f [ 0 ] [ ] [ ] = s o r t f i g u r 

282 // f [ ] [ 0 ] [ ] = s t o e r s t e f i g u r , f [ ] [ 1 ] [ ] = n a e s t s t o e r r e s t e 

f i g u r 

283 f [ 1 ] [ 0 ] [ 0 ] = −1; 

284 f [ 1 ] [ 1 ] [ 0 ] = −1; 

285 f [ 0 ] [ 0 ] [ 0 ] = −2; 

286 f [ 0 ] [ 1 ] [ 0 ] = −2; 

287 f [ 1 ] [ 0 ] [ 1 ] = 0 ; 

288 f [ 1 ] [ 1 ] [ 1 ] = 0 ; 

289 f [ 0 ] [ 0 ] [ 1 ] = 0 ; 

290 f [ 0 ] [ 1 ] [ 1 ] = 0 ; 

291 i n t [ ] figN ; 

292 figN = findMaxFigNames ( fb ) ; 

293 

294 

295 f o r ( i n t w=1; wf [ 1 ] [ 0 ] [ 1 ] ) 

299 { 

300 f [ 1 ] [ 1 ] [ 0 ] = f [ 1 ] [ 0 ] [ 0 ] ; 

301 f [ 1 ] [ 1 ] [ 1 ] = f [ 1 ] [ 0 ] [ 1 ] ; 

302 f [ 1 ] [ 0 ] [ 0 ] = w;

168 Bilag A 

303 f [ 1 ] [ 0 ] [ 1 ] = W; 

304 } 

305 e l s e 

306 i f (W>f [ 1 ] [ 1 ] [ 1 ] ) { 

307 f [ 1 ] [ 1 ] [ 0 ] = w; 

308 f [ 1 ] [ 1 ] [ 1 ] = W; 

309 } 

310 } 

311 } 

312 f o r ( i n t b=2; bf [ 0 ] [ 0 ] [ 1 ] ) { 

316 f [ 0 ] [ 1 ] [ 0 ] = f [ 0 ] [ 0 ] [ 0 ] ; 

317 f [ 0 ] [ 1 ] [ 1 ] = f [ 0 ] [ 0 ] [ 1 ] ; 

318 f [ 0 ] [ 0 ] [ 0 ] = b ; 

319 f [ 0 ] [ 0 ] [ 1 ] = B; 

320 } 

321 e l s e 

322 i f (B>f [ 0 ] [ 1 ] [ 1 ] ) { 

323 f [ 0 ] [ 1 ] [ 0 ] = b ; 

324 f [ 0 ] [ 1 ] [ 1 ] = B; 

325 } 

326 } 

327 } 

328 r e t u r n ( f ) ; 

329 } 

330 

331 // r e t u r n e r numrene f o r de 3 s t o e r s t e hvid og de 3 s t o e r s t e 

s o r t e f i g u r e , som der endnu kan p l a c e r e s b r i k opad . 

332 p u b l i c i n t [ ] [ ] [ ] g e t F i g s 3 ( i n t [ ] [ ] fb ) { 

333 i n t [ ] [ ] [ ] f = new i n t [ 2 ] [ 3 ] [ 2 ] ; 

334 // f [ ] [ ] [ 0 ] = f i g u r navnet (nummer) , f [ ] [ ] [ 1 ] = f i g u r e n s 

s t o e r r e l s e 

335 // f [ 1 ] [ ] [ ] = hvid f i g u r , f [ 0 ] [ ] [ ] = s o r t f i g u r 

336 // f [ ] [ 0 ] [ ] = s t o e r s t e f i g u r , f [ ] [ 1 ] [ ] = n a e s t s t o e r r e s t e 

f i g u r , f [ ] [ 2 ] [ ] = 3 . s t o e r s t e f i g u r 

337 f [ 1 ] [ 0 ] [ 0 ] = −1; 

338 f [ 1 ] [ 1 ] [ 0 ] = −1; 

339 f [ 1 ] [ 2 ] [ 0 ] = −1; 

340 f [ 0 ] [ 0 ] [ 0 ] = −2; 

341 f [ 0 ] [ 1 ] [ 0 ] = −2; 

342 f [ 0 ] [ 2 ] [ 0 ] = −2; 

343 f [ 1 ] [ 0 ] [ 1 ] = 0 ; 

344 f [ 1 ] [ 1 ] [ 1 ] = 0 ; 

345 f [ 1 ] [ 2 ] [ 1 ] = 0 ; 

346 f [ 0 ] [ 0 ] [ 1 ] = 0 ; 

347 f [ 0 ] [ 1 ] [ 1 ] = 0 ; 

348 f [ 0 ] [ 2 ] [ 1 ] = 0 ; 

349 i n t [ ] figN ; 

350 figN = findMaxFigNames ( fb ) ; 

351 

352 f o r ( i n t w=1; w


355 i f (W>f [ 1 ] [ 0 ] [ 1 ] ) { 

356 f [ 1 ] [ 2 ] [ 0 ] = f [ 1 ] [ 1 ] [ 0 ] ; 

357 f [ 1 ] [ 2 ] [ 1 ] = f [ 1 ] [ 2 ] [ 1 ] ; 

358 f [ 1 ] [ 1 ] [ 0 ] = f [ 1 ] [ 0 ] [ 0 ] ; 

359 f [ 1 ] [ 1 ] [ 1 ] = f [ 1 ] [ 0 ] [ 1 ] ; 

360 f [ 1 ] [ 0 ] [ 0 ] = w; 

361 f [ 1 ] [ 0 ] [ 1 ] = W; 

362 } 

363 e l s e 

364 i f (W>f [ 1 ] [ 1 ] [ 1 ] ) { 

365 f [ 1 ] [ 2 ] [ 0 ] = f [ 1 ] [ 1 ] [ 0 ] ; 

366 f [ 1 ] [ 2 ] [ 1 ] = f [ 1 ] [ 2 ] [ 1 ] ; 

367 f [ 1 ] [ 1 ] [ 0 ] = w; 

368 f [ 1 ] [ 1 ] [ 1 ] = W; 

369 } 

370 e l s e { 

371 i f (W>f [ 1 ] [ 2 ] [ 1 ] ) { 

372 f [ 1 ] [ 2 ] [ 0 ] = w; 

373 f [ 1 ] [ 2 ] [ 1 ] = W; 

374 } 

375 } 

376 } 

377 f o r ( i n t b=2; bf [ 0 ] [ 0 ] [ 1 ] ) 

381 { 

382 f [ 0 ] [ 1 ] [ 0 ] = f [ 0 ] [ 0 ] [ 0 ] ; 

383 f [ 0 ] [ 1 ] [ 1 ] = f [ 0 ] [ 0 ] [ 1 ] ; 

384 f [ 0 ] [ 0 ] [ 0 ] = b ; 

385 f [ 0 ] [ 0 ] [ 1 ] = B; 

386 } 

387 e l s e 

388 i f (B>f [ 0 ] [ 1 ] [ 1 ] ) { 

389 f [ 0 ] [ 2 ] [ 0 ] = f [ 0 ] [ 1 ] [ 0 ] ; 

390 f [ 0 ] [ 2 ] [ 1 ] = f [ 0 ] [ 2 ] [ 1 ] ; 

391 f [ 0 ] [ 1 ] [ 0 ] = b ; 

392 f [ 0 ] [ 1 ] [ 1 ] = B; 

393 } 

394 e l s e { 

395 i f (B>f [ 0 ] [ 2 ] [ 1 ] ) { 

396 f [ 0 ] [ 2 ] [ 0 ] = b ; 

397 f [ 0 ] [ 2 ] [ 1 ] = B; 

398 } 

399 } 

400 } 

401 } 

402 } 

403 r e t u r n ( f ) ; 

404 } 

405 

406 // r e t u r n e r e true , h v i s der e r minimum en f r i p l a d s opad 

f i g u r e n 

407 p r i v a t e boolean checkFig ( i n t f , i n t [ ] [ ] fb ) { 


170 Bilag A 


410 i f ( fb [ c ] [ r ] == f ) { 

411 i f ( c < tModel . noCols −1 && fb [ c +1][ r ] == 0) { 

412 i f ( r < tModel . noRows−1 && fb [ c +1][ r +1] == 

0) 

413 r e t u r n ( t r u e ) ; 

414 i f ( r > 0 && fb [ c +1][ r −1] == 0) 

415 r e t u r n ( t r u e ) ; 

416 i f ( c < tModel . noCols −2 && fb [ c +2][ r ] == 0) 

417 r e t u r n ( t r u e ) ; 

418 } 

419 i f ( c > 0 && fb [ c −1][ r ] == 0) { 

420 i f ( r < tModel . noRows−1 && fb [ c −1][ r +1] == 

0) 

421 r e t u r n ( t r u e ) ; 

422 i f ( r > 0 && fb [ c −1][ r −1] == 0) 

423 r e t u r n ( t r u e ) ; 

424 i f ( c > 1 && fb [ c −2][ r ] == 0) 

425 r e t u r n ( t r u e ) ; 

426 } 

427 i f ( r < tModel . noRows−1 && fb [ c ] [ r +1] == 0) { 

428 i f ( c < tModel . noCols −1 && fb [ c +1][ r +1] == 

0) 

429 r e t u r n ( t r u e ) ; 

430 i f ( c > 0 && fb [ c −1][ r +1] == 0) 

431 r e t u r n ( t r u e ) ; 

432 i f ( r < tModel . noRows−2 && fb [ c ] [ r +2] == 0) 

433 r e t u r n ( t r u e ) ; 

434 } 

435 i f ( r > 0 && fb [ c ] [ r −1] == 0) { 

436 i f ( c < tModel . noCols −1 && fb [ c +1][ r −1] == 

0) 

437 r e t u r n ( t r u e ) ; 

438 i f ( c > 0 && fb [ c −1][ r −1] == 0) 

439 r e t u r n ( t r u e ) ; 

440 i f ( r > 1 && fb [ c ] [ r −2] == 0) 

441 r e t u r n ( t r u e ) ; 

442 } 

443 } 

444 } 

445 } 

446 r e t u r n ( f a l s e ) ; 

447 } 

448 

449 // f i n d e r og r e t u r n e r de h o e j s t e f i g navne anvendt i fb 

450 p r i v a t e i n t [ ] findMaxFigNames ( i n t [ ] [ ] fb ) { 

451 i n t [ ] figN = new i n t [ 2 ] ; 



454 i f ( fb [ c ] [ r ]%2 == 1) { 

455 i f ( fb [ c ] [ r ] > figN [ 1 ] ) 

456 figN [ 1 ] = fb [ c ] [ r ] ; 

457 } 

458 i f ( fb [ c ] [ r ]%2 == 0) { 

459 i f ( fb [ c ] [ r ] > figN [ 0 ] )

A.7 Node.java 171 

460 figN [ 0 ] = fb [ c ] [ r ] ; 

461 } 

462 } 

463 } 

464 r e t u r n ( figN ) ; 

465 } 

466 

467 } 

A.7 Node.java 

1 


3 

4 

5 

6 p u b l i c c l a s s Node{ 

7 p u b l i c i n t [ ] [ ] nodeBoard ; 

8 p u b l i c i n t a ; // Score o f the board 

9 p u b l i c i n t wc ; // Whire Column 

10 p u b l i c i n t wr ; // White Row 

11 p u b l i c i n t bc ; // Black Column 

12 p u b l i c i n t br ; // Black Row 

13 p u b l i c i n t d ; // Depth 

14 p u b l i c ArrayList par ; 

15 p u b l i c ArrayList c h i l d r e n ; 


17 

18 p u b l i c Node ( Node parent ) { 

19 t h i s . par = new ArrayList () ; 

20 t h i s . c h i l d r e n = new ArrayList () ; 

21 f o r ( i n t i = 0 ; i < 1 2 3 ; i ++) 

22 f o r ( i n t j = 0 ; j < 1 2 3 ; j++) 

23 nodeBoard [ i ] [ j ] = 0 ; 

24 } 

25 

26 p u b l i c Node ( ) { 

27 t h i s . c h i l d r e n = new ArrayList () ; 

28 nodeBoard = new i n t [ 1 2 3 ] [ 1 2 3 ] ; 

29 f o r ( i n t i = 0 ; i < 1 2 3 ; i ++) 

30 f o r ( i n t j = 0 ; j < 1 2 3 ; j++) 

31 nodeBoard [ i ] [ j ] = 0 ; 

32 } 

33 

34 p u b l i c Node addChild ( Node n ) { 

35 i f ( n == n u l l ) 

36 System . out . p r i n t l n (” Null002 node”+n ) ; 

37 t h i s . c h i l d r e n . add ( n ) ; 

38 

39 r e t u r n ( n ) ; 

40 } 

41 

42 // Laver en node udfra en given tur .

172 Bilag A 

43 p u b l i c Node createNode ( i n t t , TaijiModel tModel ) 

44 { 

45 nodeBoard = tModel . getOneBoard ( t ) ; 

46 a = tModel . g e t D i f ( nodeBoard ) ; 

47 t h i s . tModel = tModel ; 

48 r e t u r n t h i s ; 

49 } 

50 

51 // Returnerer b r a e t t e t f o r en Node 

52 p r i v a t e i n t [ ] [ ] getNodeBoard ( Node n ) 

53 { 

54 r e t u r n ( n . nodeBoard ) ; 

55 } 

56 

57 // Laver en node udfra givne parameter . 

58 p u b l i c Node createChildNode ( i n t wC, i n t wR, i n t bC , i n t bR, Node 

parent ) 

59 { 

60 Node n = new Node ( ) ; 

61 i n t [ ] [ ] c l o n e ; 




65 c l o n e [ c ] [ r ] = parent . nodeBoard [ c ] [ r ] ; 

66 n . nodeBoard = c l o n e ; 

67 n . wc = wC; 

68 n . wr = wR; 

69 n . bc = bC ; 

70 n . br = bR ; 

71 n . par = new ArrayList () ; 

72 n . par . add ( parent ) ; 

73 n . d = parent . d+1; 

74 i f ( n . d % 2 == 0) 

75 n . a = tModel . noRows∗ tModel . noCols ; 

76 i f ( n . d % 2 == 1) 

77 n . a = tModel . noRows∗ tModel . noCols ; 

78 

79 r e t u r n ( n ) ; 

80 } 

81 

82 // Laver en kopie a f en node . 

83 p u b l i c Node createCloneNode ( Node org ) 

84 { 

85 Node n = new Node ( ) ; 

86 i n t [ ] [ ] c l o n e ; 




90 c l o n e [ c ] [ r ] = org . nodeBoard [ c ] [ r ] ; 

91 n . nodeBoard = c l o n e ; 

92 n . a = tModel . g e t D i f ( nodeBoard ) ; 

93 n . wc = org . wc ; 

94 n . wr = org . wr ; 

95 n . bc = org . bc ; 

96 n . br = org . br ;

A.8 TaijiDriver.java 173 

97 n . par = org . par ; 

98 r e t u r n ( n ) ; 

99 } 

100 } 

A.8 TaijiDriver.java 

1 

2 c l a s s T a i j i D r i v e r 

3 { 

4 

5 //Main metoden , e r d r i v e r f o r a l l e de andre k l a s s e r . 

Konstruerer en TaijiFrame og v i s e r den . 

6 p u b l i c s t a t i c void main ( S t r i n g [ ] a r g s ) 

7 { 

8 TaijiFrame tFrame = new TaijiFrame ( ) ; 

9 tFrame . showIt ( ) ; 

10 } 

11 } 

A.9 TaijiFrame.java 

1 

2 import java . awt . event . ∗ ; 

3 import javax . swing . ∗ ; 

4 import java . awt . event . MouseListener ; 

5 import java . awt . event . MouseEvent ; 

6 

7 p u b l i c c l a s s TaijiFrame extends JFrame 

8 { 

9 // V a r i a b l e r t i l k o n s t r u k t i o n e n a f modellen . 

10 p r i v a t e i n t noCols = 9 ; 

11 p r i v a t e i n t noRows = 9 ; 

12 

13 // Elementerne i framen gemmes som p u b l i c v a r i a b l e r , saa de kan 

r e f e r e r e s t i l f r a metoder inde i de andre e l e m e n t e r . 

14 p u b l i c TurnPanel uPanel ; 

15 p u b l i c T a i j i P a n e l tPanel ; 


17 p u b l i c ScorePanel whiteScore , b l a c k S c o r e ; 

18 p u b l i c TaijiMenu tMenu ; 

19 

20 // Constructor . Laver a l l e de f o r s k e l l i g e e l e m e n t e r og p l a c e r e r 

dem i e t border−l a y o u t . 

21 p u b l i c TaijiFrame ( ) 

22 { 

23 s e t L o c a t i o n ( 1 0 0 , 100) ; 

24 s e t T i t l e (” T a i j i ”) ; 

25 

26 tModel = new TaijiModel ( noCols , noRows ) ;

174 Bilag A 

27 whiteScore = new ScorePanel ( t h i s , 1 ) ; 

28 b l a c k S c o r e = new ScorePanel ( t h i s , 0 ) ; 

29 tPanel = new T a i j i P a n e l ( t h i s ) ; 

30 uPanel = new TurnPanel ( t h i s ) ; 

31 tMenu = new TaijiMenu ( t h i s ) ; 

32 

33 getContentPane ( ) . add ( tPanel , ” Center ”) ; 

34 getContentPane ( ) . add ( whiteScore , ”West ”) ; 

35 getContentPane ( ) . add ( blackScore , ” East ”) ; 

36 getContentPane ( ) . add ( uPanel , ” South ”) ; 

37 

38 t h i s . setJMenuBar ( tMenu ) ; 

39 t h i s . s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame . EXIT ON CLOSE) ; 

40 t h i s . pack ( ) ; 

41 } 

42 

43 //Metode som r e p a i n t e r a l l e elementerne i framen . 

44 p u b l i c void r e p a i n t A l l ( ) 

45 { 

46 t h i s . tPanel . r e p a i n t ( ) ; 

47 t h i s . whiteScore . r e p a i n t ( ) ; 

48 t h i s . b l a c k S c o r e . r e p a i n t ( ) ; 

49 t h i s . uPanel . update ( ) ; 

50 } 

51 

52 // Goer TaijiFrame s y n l i g r e n t g r a f i s k . 

53 p u b l i c void showIt ( ) 

54 { 

55 s e t V i s i b l e ( t r u e ) ; 

56 } 

57 

58 // S k j u l e r TaijiFrame ( b l i v e r i k k e brugt ) 

59 p u b l i c void h i d e I t ( ) 

60 { 

61 s e t V i s i b l e ( f a l s e ) ; 

62 } 

63 

64 } 

A.10 TaijiHash.java 

1 

2 p u b l i c c l a s s TaijiHash { 

3 p r i v a t e TaijiModel tModel ; 

4 p r i v a t e i n t [ ] [ ] valueBoard ; // valueBoard , b r a e t t e t med 

symmetrisk ens v a e r d i e r 

5 

6 

7 p u b l i c TaijiHash ( TaijiModel m) 

8 { 

9 tModel = m; 

10 valueBoard = new i n t [ tModel . noCols ] [ tModel . noRows ] ; 

11 f o r ( i n t i = 0 ; i

A.10 TaijiHash.java 175 

12 f o r ( i n t j = 0 ; j=tModel . noCols /2) 

51 bc = 1 ; 

52 e l s e 

53 bc = 0 ; 

54 

55 i f ( tModel . noRows%2==0 && r>=tModel . noRows /2) 

56 br = 1 ; 

57 e l s e 

58 br = 0 ; 

59 

60 v = ( v + ( ( ( Math . abs ( tModel . noCols/2−c )+bc ) ∗ ( 

Math . abs ( tModel . noRows/2−r )+br ) ) /2) )%maxV ; 

61 } 

62 

63 i f ( b [ c ] [ r ] == 1) { 

64 i f ( tModel . noCols%2==0 && c>=tModel . noCols /2)

176 Bilag A 

65 bc = 1 ; 

66 e l s e 

67 bc = 0 ; 

68 

69 i f ( tModel . noRows%2==0 && r>=tModel . noRows /2) 

70 br = 1 ; 

71 e l s e 

72 br = 0 ; 

73 

74 v = ( v +( (Math . abs ( tModel . noCols/2−c )+bc ) ∗ ( 

Math . abs ( tModel . noRows/2−r )+br ) ) )%maxV ; 

75 } 

76 } 

77 } 

78 r e t u r n ( v ) ; 

79 } 

80 

81 // r e t u r n e r e r den h o e j s t mulige v a e r d i f o r hashFunction2 

82 p u b l i c i n t getMaxH2 ( ) { 

83 i n t maxH = ( tModel . noCols ∗ tModel . noRows ) −1; 

84 r e t u r n (maxH) ; 

85 } 

86 

87 // r e t u r n e r en hash v a e r d i som e r sammen s a t a f hashFunction 1 

og 2 

88 p u b l i c i n t hashFunction3 ( i n t [ ] [ ] b ) { 

89 i n t v = ( hashFunction ( b )+hashFunction2 ( b ) )%getMaxH ( ) ; 

90 r e t u r n ( v ) ; 

91 } 

92 

93 // r e t u r n e r e r den h o e j s t mulige v a e r d i f o r hashFunction3 

94 p u b l i c i n t getMaxH3 ( ) { 

95 r e t u r n ( getMaxH ( ) ) ; 

96 } 

97 } 

A.11 TaijiListeners.java 

1 


3 import java . awt . ∗ ; 


5 import java . i o . ∗ ; 

6 

7 // L i s t e n e r e n t i l s e l v e b r a e t t e t , T a i j i P a n e l . 

8 c l a s s T a i j i P a n e l L i s t e n e r implements MouseListener 

9 { 

10 // Variablen som i n d e h o l d e r den TaijiFrame h v o r i p a n e l e t 

T a i j i P a n e l L i s t e n e r b l i v e r i n i t i a l i s e r e t . 

11 p r i v a t e TaijiFrame tFrame ; 

12 

13 // V a r i a b l e r t i l k o o r d i n a t e r n e f r a de mouseevents som l i s t e n e r e n 

f a n g e r .

A.11 TaijiListeners.java 177 

14 p r i v a t e i n t c l i c k C o l , clickRow ; 

15 

16 // V a r i a b l e r som bruges i mouseClicked t i l at bestemme om det e r 

f o e r s t e l l e r andet ryk , e l l e r t i l at gemme vinderen . 

17 p r i v a t e S t r i n g winner ; 

18 

19 // Constructor 

20 // Modtager en TaijiFrame som argument . 

21 p u b l i c T a i j i P a n e l L i s t e n e r ( TaijiFrame frame ) 

22 { 

23 tFrame = frame ; 

24 } 

25 

26 //Den metode som modtager MouseEvent og k a l d e r move metoden i 

modellen , h v i s 

27 // det f l e t der k l i k k e s paa f o e r s t gang e r den f r i t . 

28 // Hvis s p i l l e t a f s l u t t e s i det paagaeldende ryk , v i s e r den en 

d i a l o g med vinderen . 

29 // Modtager e t MouseEvent som argument . 

30 p u b l i c void mouseClicked ( MouseEvent event ) 

31 { 

32 i n t x , y ; 

33 x = event . getX ( ) ; 

34 y = event . getY ( ) ; 

35 

36 c l i c k C o l = x /( tFrame . tPanel . getWidth ( ) /tFrame . 

tModel . getNoCols ( ) ) ; 

37 clickRow = y /( tFrame . tPanel . getHeight ( ) /tFrame . 

tModel . getNoRows ( ) ) ; 

38 winner = tFrame . tModel . move ( c l i c k C o l , clickRow ) ; 

39 i f ( ! winner . e q u a l s (” None ”) ) 

40 { 

41 i f ( winner . e q u a l s (”Draw”) ) 

42 JOptionPane . showMessageDialog ( n u l l , ” 

The game i s a draw . \ n ” , ”Game over 

. ” , JOptionPane .INFORMATION MESSAGE 

) ; 

43 e l s e 

44 JOptionPane . showMessageDialog ( n u l l , 

winner +” wins ! ” , ”Game over . ” , 

JOptionPane .INFORMATION MESSAGE) ; 

45 } 

46 tFrame . r e p a i n t A l l ( ) ; 

47 } 

48 

49 // Metoder t i l at o v e r s k r i v e de a b s t r a k t e metoder f r a 

f o r a e l d r e r e n MouseListener . 

50 p u b l i c void mousePressed ( MouseEvent event ) 

51 { 

52 } 

53 

54 p u b l i c void mouseReleased ( MouseEvent event ) 

55 { 

56 } 

57

178 Bilag A 

58 p u b l i c void mouseExited ( MouseEvent event ) 

59 { 

60 } 

61 

62 p u b l i c void mouseEntered ( MouseEvent event ) 

63 { 

64 } 

65 

66 } 

67 

68 //Denne k l a s s e ” l y t t e r ” t i l de to knapper paa e t TurnPanel . Den kan 

enten s t i l l e en tur frem e l l e r en t i l b a g e . 

69 c l a s s TurnListener implements A c t i o n L i s t e n e r 

70 { 


72 

73 // Constructor . 


75 p u b l i c TurnListener ( TaijiFrame frame ) 

76 { 


78 } 

79 

80 //Den metode der r e a g e r e r paa e t ActionEvent . S t i l l e r enten 

turen en frem 

81 // e l l e r t i l b a g e , og k a l d e r r e p a i n t A l l ( ) f r a framen . 

82 p u b l i c void actionPerformed ( ActionEvent event ) 

83 { 

84 S t r i n g aCommand = event . getActionCommand ( ) ; 

85 

86 i f (aCommand . e q u a l s (” Next Turn ”) ) 

87 { 

88 tFrame . tModel . turnForward ( ) ; 


90 } 

91 e l s e 

92 { 

93 tFrame . tModel . turnBack ( ) ; 


95 } 

96 } 

97 } 

98 

99 // L i s t e n e r e n t i l TaijiMenuen tMenu . 

100 c l a s s TMListener implements A c t i o n L i s t e n e r 

101 { 

102 

103 //En TaijiFrame som kan i n d e h o l d e tFrame , saa der kan r e f e r e r s 

t i l den . 


105 

106 // C o n s t r u c t e r . 


108 p u b l i c TMListener ( TaijiFrame frame ) 

109 {



111 } 

112 

113 //Metode som r e a g e r e r paa det event som a k t i v e r e r l i s t e n e r e n . 

Konstruerer en J F i l e C h ooser der enten kan bruges t i l at 

gemme e l l e r 

114 // aabne gemte s p i l . Kan ogsaa lukke programmet ned e l l e r s t a r t e 

e t nyt s p i l . 

115 // Modtager e t ActionEvent som argument . 

116 p u b l i c void actionPerformed ( ActionEvent evt ) 

117 { 

118 J F i leChooser c h o o s e r = new J F i l e C hooser ( ) ; 

119 

120 i f ( evt . g e t S o u r c e ( ) i n s t a n c e o f JMenuItem ) 

121 { 

122 S t r i n g command = evt . getActionCommand ( ) ; 

123 i f (command . e q u a l s (”Same s e t t i n g s ”) ) 

124 { 

125 tFrame . tModel . r e s e t ( ) ; 


127 } 

128 e l s e i f (command . e q u a l s (” Change s e t t i n g s ”) ) 

129 { 

130 T a i j i S e t t i n g s s e t t i n g s = new T a i j i S e t t i n g s ( 

tFrame ) ; 

131 s e t t i n g s . showIt ( ) ; 

132 } 

133 e l s e i f (command . e q u a l s (” Save ”) ) 

134 { 

135 i n t returnVal = c h o o s e r . showSaveDialog ( 

tFrame . tPanel ) ; 

136 i f ( returnVal == JFileChooser . 

APPROVE OPTION) 

137 { 

138 boolean save = t r u e ; 

139 i f ( c h o o s e r . g e t S e l e c t e d F i l e ( ) . 

e x i s t s ( ) == t r u e ) 

140 i f ( JOptionPane . 

showConfirmDialog ( n u l l , ” 

F i l e a l r e a d y e x i s t s , 

o v e r w r i t e ?” , ”Warning ” , 

JOptionPane . YES NO OPTION) 

!= JOptionPane . YES OPTION) 

141 save = f a l s e ; 

142 

143 i f ( save == t r u e ) 

144 { 

145 i n t noCols = tFrame . tModel . 

getNoCols ( ) ; 

146 i n t noRows = tFrame . tModel . 

getNoRows ( ) ; 

147 i n t [ ] [ ] [ ] board = tFrame . 

tModel . getBoard ( ) ; 

148 i n t lastTurn = board 

[ 0 ] [ 0 ] [ 0 ] ;

180 Bilag A 

149 S t r i n g t x t = ” ” ; 

150 t x t = t x t + lastTurn + ”T” ; 

151 f o r ( i n t t =1; t


181 FileReader l o a d e r = new 

FileReader ( c h o o s e r . 

g e t S e l e c t e d F i l e ( ) ) ; 

182 BufferedReader input = new 

BufferedReader ( l o a d e r ) ; 

183 S t r i n g l i n e = input . 

readLine ( ) ; 

184 i n t pos = 0 ; 

185 S t r i n g l a s t T u r n S t r i n g = ” ” ; 

186 w h i l e ( l i n e . charAt ( pos ) != 

’T’ ) 

187 { 

188 l a s t T u r n S t r i n g = 

l a s t T u r n S t r i n g 

+ l i n e . charAt ( 

pos ) ; 

189 pos++; 

190 } 

191 pos++; 

192 i n t lastTurn = I n t e g e r . 

p a r s e I n t ( l a s t T u r n S t r i n g 

) ; 

193 board [ 0 ] [ 0 ] [ 0 ] = lastTurn ; 

194 f o r ( i n t t =1; t

182 Bilag A 

l o a d i n g the f i l e . ” ) ; 

209 } 

210 } 

211 } 

212 e l s e i f (command . e q u a l s (” Exit ”) ) 

213 { 

214 System . e x i t ( 0 ) ; 

215 } 

216 e l s e i f (command . e q u a l s (” Rules ”) ) 

217 { 

218 JOptionPane . showMessageDialog ( n u l l , ” Each 

p l a y e r t a k e s t u r n s p l a c i n g one p e i c e on 

the board . \ nAll p i e c e s has a Dark and 

a Light end . \nThe winner i s the one to 

have the g r e a s t number\ nof t h i e r 

c o l o u r placed t o g e h t e r i n two f i g u r e s . \ 

nOnly the two b i g g e s t f i g u r e s count f o r 

each p l a y e r . ” , ”Game r u l e s ” , 

JOptionPane .INFORMATION MESSAGE) ; 

219 } 

220 e l s e i f (command . e q u a l s (” About ”) ) 

221 { 

222 JOptionPane . showMessageDialog ( n u l l , ”The 

boardgame , T a i j i i s the c r e a t i o n o f 

223 } 

224 } 

225 } 

226 } 

A.12 TaijiMenu.java 

NÃ c○stor Romeral AndrÃ c○s \ nThis 

implementation was made by Morten Rask 

” , ”About T a i j i ” , JOptionPane . 

INFORMATION MESSAGE) ; 

1 




5 

6 //Denne k l a s s e e r menuen som e r p l a c e r e t i TaijiFrame . Den 

i n d e h o l d e r menu 

7 // o b j e k t e r t i l at s t a r t e nyt s p i l , samt hente e l l e r gemme s p i l . 

8 //Der e r ogsaa mulighed f o r at l a e s e r e g l e r n e . 

9 // TaijiMenu e r nedarvet f r a JMenuBar . 

10 c l a s s TaijiMenu extends JMenuBar 

11 { 

12 

13 // C o n s t r u c t e r . Laver a l l e menu−o b j e k t e r og t i l f o e j e r en 

l i s t e n e r t i l dem . 

14 // Modtager en TaijiFrame som argument og g i v e r den v i d e r e t i l 

l i s t e n e r e n . 

15 p u b l i c TaijiMenu ( TaijiFrame frame )

A.13 TaijiModel.java 183 

16 { 

17 JMenu fileMenu = new JMenu(”Game”) ; 

18 add ( fileMenu ) ; 

19 

20 //JMenuItem gameItem = new JMenuItem (”New game ”) ; 

21 JMenuItem saveItem = new JMenuItem (” Save ”) ; 

22 JMenuItem loadItem = new JMenuItem (” Load ”) ; 

23 JMenuItem e x i t I t e m = new JMenuItem (” Exit ”) ; 

24 

25 JMenu subMenu = new JMenu(”New game ”) ; 

26 JMenuItem sameSet = new JMenuItem (”Same s e t t i n g s ”) ; 

27 JMenuItem changeSet = new JMenuItem (” Change s e t t i n g s ”) ; 

28 subMenu . add ( sameSet ) ; 

29 subMenu . add ( changeSet ) ; 

30 

31 fileMenu . add ( subMenu ) ; 

32 fileMenu . addSeparator ( ) ; 

33 fileMenu . add ( saveItem ) ; 

34 fileMenu . add ( loadItem ) ; 

35 fileMenu . addSeparator ( ) ; 

36 fileMenu . add ( e x i t I t e m ) ; 

37 

38 JMenu helpMenu = new JMenu(” Help ”) ; 

39 add ( helpMenu ) ; 

40 

41 JMenuItem r u l e s I t e m = new JMenuItem (” Rules ”) ; 

42 JMenuItem aboutItem = new JMenuItem (” About ”) ; 

43 

44 helpMenu . add ( r u l e s I t e m ) ; 

45 helpMenu . add ( aboutItem ) ; 

46 

47 TMListener TMLi = new TMListener ( frame ) ; 

48 

49 sameSet . a d d A c t i o n L i s t e n e r (TMLi) ; 

50 changeSet . a d d A c t i o n L i s t e n e r (TMLi) ; 

51 saveItem . a d d A c t i o n L i s t e n e r (TMLi) ; 

52 loadItem . a d d A c t i o n L i s t e n e r (TMLi) ; 

53 e x i t I t e m . a d d A c t i o n L i s t e n e r (TMLi) ; 

54 r u l e s I t e m . a d d A c t i o n L i s t e n e r (TMLi) ; 

55 aboutItem . a d d A c t i o n L i s t e n e r (TMLi) ; 

56 } 

57 

58 } 

A.13 TaijiModel.java 

1 import java . u t i l . Date ; // b e n y t t e s t i l at tage t i d paa AI ’ erne 

2 

3 // Klassen TaijiModel som r e p r a e s e n t e r e r h e l e den ikke −g r a f i s k e d e l 

a f s p i l l e t . 

4 p u b l i c c l a s s TaijiModel 

5 { 

6

184 Bilag A 

7 p u b l i c AITaijiMinimax minimax ; 

8 p u b l i c FigureMap fMap ; 

9 p u b l i c Board tBoard ; 

10 p u b l i c TaijiHash tHash ; 

11 p u b l i c T a i j i P r i n t t P r i n t ; 

12 p u b l i c AITaijiAlphaBeta alphaBeta ; 

13 p u b l i c AITaijiPureAlphaBeta pureAlphaBeta ; 

14 p u b l i c AITaijiMinimax2 minimax2 ; 

15 p u b l i c AITaijiGrowth growth ; 

16 p u b l i c AITaijiLocalAreaAB localAreaAB ; 

17 

18 

19 // V a r i a b l e r 

20 p u b l i c i n t noRows , noCols ; // a n t a l l e t a f r a e k k e r og kolonner 

21 p u b l i c i n t maxTurns = 1 0 0 0 ; // max a n t a l t u r e programmet kan 

haandtere 

22 p u b l i c i n t maxScore ; // Score h v i s e t h e l t b r a e t var daekket a f 

en f a r v e . 

23 p u b l i c i n t maxS ; // den maximale s c o r e f o r en s p i l l e r . 

24 // ( h v i s a l l e b r i k k e r a f en f a r v e e r med i 

enten den s t o e r s t e e l l e r n a e s t s t o e r s t e 

f i g u r ) 

25 

26 f i n a l p r i v a t e i n t white = 1 , black = 0 , n e u t r a l = 2 ; // 

Konstanter f o r de f o r s k e l l i g e b r i k k e r paa b r a e t t e t . 

27 

28 // o e j e b l i k s −i n f o r m a t i o n f o r s p i l l e t . 

29 p r i v a t e i n t c u r r e n t P l a y e r = 1 ; 

30 p u b l i c i n t currentTurn = 1 , noTurns = 1 , showTurn = 0 , s t a r t e r 

= 1 ; 

31 p r i v a t e i n t whScore =0, b l S c o r e =0; 

32 p r i v a t e i n t whitePlayer = 0 , b l a c k P l a y e r = 2 ; // 0 human , 1 

minimax , 2 ab , 3 pure ab , 4 growth , 5 minimax2 , 6 

localAreaAB 

33 

34 p r i v a t e i n t preCol , preRow ; // husker f o r r i g e k l i k , som sammen 

med det nye k l i k b l i v e r t i l p l a c e r i n g e n a f en b r i k . 

35 p r i v a t e boolean c l i c k = f a l s e ; 

36 p r i v a t e boolean gameOver = f a l s e ; 

37 

38 

39 // Konstruktor . Laver b r a e t t e t . Modtager a n t a l l e t a f s o e j l e r og 

r a e k k e r som argumenter . 

40 p u b l i c TaijiModel ( i n t col , i n t row ) 

41 { 

42 noCols = c o l ; 

43 minimax = new AITaijiMinimax ( t h i s ) ; 

44 alphaBeta = new AITaijiAlphaBeta ( t h i s ) ; 

45 pureAlphaBeta = new AITaijiPureAlphaBeta ( t h i s ) ; 

46 minimax2 = new AITaijiMinimax2 ( t h i s ) ; 

47 growth = new AITaijiGrowth ( t h i s ) ; 

48 localAreaAB = new AITaijiLocalAreaAB ( t h i s ) ; 

49 fMap = new FigureMap ( t h i s ) ; 

50 tBoard = new Board ( t h i s ) ; 

51 tHash = new TaijiHash ( t h i s ) ;


52 t P r i n t = new T a i j i P r i n t ( t h i s ) ; 

53 noRows = row ; 

54 tBoard . board = new i n t [ maxTurns ] [ noCols ] [ noRows ] ; 

55 maxScore = noCols ∗noRows ; 

56 maxS = noCols ∗noRows / 2 ; 

57 r e s e t ( ) ; 

58 } 

59 

60 

61 // Reset . Toemmer b r a e t t e t , s a e t t e r o e j e b l i k s v a e r d i e r n e t i l 

u d g a n g s p o s i t i o n e n . 

62 p u b l i c void r e s e t ( ) 

63 { 

64 currentTurn = 1 ; 

65 showTurn = 0 ; 

66 f o r ( i n t c = 0 ; c < noCols ; c++) 

67 { 

68 f o r ( i n t r = 0 ; r < noRows ; r++) 

69 { 

70 tBoard . s e t P i e c e ( c , r , 2 ) ; 

71 } 

72 } 

73 c u r r e n t P l a y e r = 1 ; 

74 tBoard . board [ 0 ] [ 0 ] [ 0 ] = 1 ; 

75 } 

76 

77 

78 // haandtere t r a e k f o r menneskelig s p i l l e r e r og AI ’ erne 

79 // r e t u r n e r e om der e r en v i n d e r . 

80 p u b l i c S t r i n g move ( i n t curCol , i n t curRow ) 

81 { 

82 S t r i n g winner = ”None ” ; 

83 

84 i f ( showTurn % 2 != s t a r t e r ) { // == 0 , s t a r t e r s p i l l e r e n ( 

hvid ) , == 1 s t a r t e r ai ’ en ( s o r t ) 

85 i f ( whitePlayer == 0) 

86 playerTurn ( curCol , curRow , f a l s e ) ; 


88 alphaBetaTurn ( f a l s e ) ; 


90 growthTurn ( f a l s e ) ; 


92 localAreaABTurn ( f a l s e ) ; 

93 

94 } 

95 e l s e 

96 { 

97 i f ( b l a c k P l a y e r == 0) 

98 playerTurn ( curCol , curRow , t r u e ) ; 


100 minimaxTurn ( ) ; 


102 alphaBetaTurn ( t r u e ) ; 


104 pureAlphaBetaTurn ( ) ;

186 Bilag A 


106 growthTurn ( t r u e ) ; 


108 minimax2Turn ( ) ; 


110 localAreaABTurn ( t r u e ) ; 

111 } 

112 

113 switch ( gameOver ( ) ) 

114 { 

115 c a s e −1: 

116 break ; 

117 c a s e 0 : 

118 winner = ” Black ” ; 

119 r e t u r n ( winner ) ; 

120 c a s e 1 : 

121 winner = ”White ” ; 


123 c a s e 2 : 

124 winner = ”Draw ” ; 


126 } 

127 

128 

129 


131 } 

132 

133 // Lader den menneskelige s p i l l e r f o r e t a g e e t ryk 

134 // F o r e t a g e r e t ryk , h v i s det e r l o v l i g t . ( Et ryk e r d e l t op i 

en hvid og en s o r t d e l ) 

135 // Modtager p o s i t i o n f r a k l i k som argument 

136 p r i v a t e void playerTurn ( i n t curCol , i n t curRow , boolean b ) { 

137 i n t b1 = 1 ; 

138 i n t b2 = 0 ; 

139 i f ( b ) { 

140 b1=0; 

141 b2=1; 

142 } 

143 

144 i f ( c l i c k == f a l s e ) 

145 { 

146 i f ( checkMove ( tBoard . board [ currentTurn ] , curCol , 

curRow ) ) 

147 { 

148 tBoard . copyBoard ( ) ; 

149 currentTurn++; 

150 tBoard . board [ 0 ] [ 0 ] [ 0 ] = currentTurn ; 

151 tBoard . s e t P i e c e ( curCol , curRow , b1 ) ; 

152 c l i c k = t r u e ; 

153 preCol = curCol ; 

154 preRow = curRow ; 

155 tBoard . getOneBoard ( currentTurn ) ; 

156 } 

157 }


158 e l s e 

159 { 

160 i f ( checkMove ( tBoard . board [ currentTurn ] , curCol , curRow 

) ) { 


162 tBoard . s e t P i e c e ( curCol , curRow , b2 ) ; 

163 c u r r e n t P l a y e r = ( c u r r e n t P l a y e r +1) % 2 ; 

164 c l i c k = f a l s e ; 



167 showTurn++; 

168 } 

169 e l s e { 

170 tBoard . s e t P i e c e ( preCol , preRow , 2) ; 



173 c l i c k = f a l s e ; 

174 currentTurn −−; 

175 } 

176 

177 } 

178 } 

179 

180 // f o r e t a g e r e t t r a e k ved h j a e l p a f minimax ai ’ en . ( s p i l l e r kun 

som s o r t ) 

181 p r i v a t e void minimaxTurn ( ) { 

182 Date time = new Date ( ) ; 

183 long t1 = time . getTime ( ) ; 

184 minimax . c r e a t e T r e e ( ) ; 

185 Node n ; 

186 n = minimax . returnMoveMirRot ( ) ; 





191 tBoard . s e t P i e c e ( n . wc , n . wr , white ) ; 

192 tBoard . s e t P i e c e ( n . bc , n . br , black ) ; 

193 Date time2 = new Date ( ) ; 

194 long t2 = time2 . getTime ( ) ; 

195 long t3 = t2−t1 ; 

196 System . out . p r i n t l n (”TM − minimaxTurn time : ”+t3 ) ; 

197 } 

198 

199 // f o r e t a g e r e t t r a e k ved h j a e l p a f AlphaBeta ai ’ en . 

200 // b = t r u e h v i s den s k a l s p i l l e s o r t , f a l s e f o r hvid 

201 p r i v a t e void alphaBetaTurn ( boolean b ) { 



204 Node n ; 

205 n = alphaBeta . returnMove ( b ) ; 





210 tBoard . s e t P i e c e ( n . wc , n . wr , white ) ;

188 Bilag A 




214 long t3 = t2−t1 ; 

215 System . out . p r i n t l n (”TM − ABTurn time : ”+t3 ) ; 

216 } 

217 // f o r e t a g e r e t t r a e k ved h j a e l p a f pureAlphaBeta AI ’ en . ( 

s p i l l e r kun som s o r t ) 

218 p r i v a t e void pureAlphaBetaTurn ( ) { 



221 Node n ; 

222 n = pureAlphaBeta . returnMoveBlack ( ) ; 









231 long t3 = t2−t1 ; 

232 System . out . p r i n t l n (”TM − PureABTurn time : ”+t3 ) ; 

233 } 

234 // f o r e t a g e r e t t r a e k ved h j a e l p a f minimax2 AI ’ en . ( s p i l l e r 

kun som s o r t ) 

235 p r i v a t e void minimax2Turn ( ) { 



238 Node n ; 

239 n = minimax2 . returnMoveBlack ( ) ; 









248 long t3 = t2−t1 ; 

249 System . out . p r i n t l n (”TM − growthTurn time : ”+t3 ) ; 

250 } 

251 // f o r e t a g e r e t t r a e k ved h j a e l p a f Growth AI ’ en . 


253 p r i v a t e void growthTurn ( boolean b ) { 



256 Node n ; 

257 n = growth . returnMove ( b ) ; 






263 tBoard . s e t P i e c e ( n . bc , n . br , black ) ;




266 long t3 = t2−t1 ; 

267 System . out . p r i n t l n (”TM − growthTurn time : ”+t3 ) ; 

268 } 

269 

270 // f o r e t a g e r e t t r a e k ved h j a e l p a f LocalArea AI ’ en . 


272 p r i v a t e void localAreaABTurn ( boolean b ) { 



275 Node n ; 

276 n = localAreaAB . returnMove ( b ) ; 









285 long t3 = t2−t1 ; 

286 System . out . p r i n t l n (”TM − LAABTurn time : ”+t3 ) ; 

287 } 

288 

289 // Bestemmer om der e r n o g l e l o v l i g e ryk t i l b a g e . 

290 p u b l i c boolean movesLeft ( ) 

291 { 

292 f o r ( i n t c =0; c < noCols ; c++) 

293 { 

294 f o r ( i n t r =0; r < noRows−1; r++) 

295 { 

296 i f ( tBoard . board [ currentTurn ] [ c ] [ r ] == 2 && 

tBoard . board [ currentTurn ] [ c ] [ r +1] == 2 

) 

297 r e t u r n ( t r u e ) ; 

298 } 

299 } 

300 f o r ( i n t c =0; c < noCols −1; c++) 

301 { 

302 f o r ( i n t r =0; r < noRows ; r++) 

303 { 

304 i f ( tBoard . board [ currentTurn ] [ c ] [ r ] == 2 && 

tBoard . board [ currentTurn ] [ c +1][ r ] == 2 

) 

305 r e t u r n ( t r u e ) ; 

306 } 

307 } 

308 r e t u r n ( f a l s e ) ; 

309 } 

310 

311 // Bestemmer om der e r n o g l e l o v l i g e ryk t i l b a g e f o r Noden n . 

312 p u b l i c boolean movesLeftN ( Node n ) 

313 { 

314 f o r ( i n t c =0; c < noCols ; c++)

190 Bilag A 

315 { 


317 { 

318 i f ( n . nodeBoard [ c ] [ r ] == 2 && n . nodeBoard [ c 

] [ r +1] == 2 ) 

319 r e t u r n ( t r u e ) ; 

320 } 

321 } 

322 f o r ( i n t c =0; c < noCols −1; c++) 

323 { 


325 { 

326 i f ( n . nodeBoard [ c ] [ r ] == 2 && n . nodeBoard [ c 

+1][ r ] == 2 ) 

327 r e t u r n ( t r u e ) ; 

328 } 

329 } 

330 r e t u r n ( f a l s e ) ; 

331 } 

332 

333 // r e t u r n e r e r e t g y l d i g t t r a e k 

334 p u b l i c i n t [ ] getAMove ( Node n ) { 

335 i n t [ ] m = new i n t [ 4 ] ; 

336 f o r ( i n t c =0; c < noCols ; c++) 

337 { 


339 { 

340 i f ( n . nodeBoard [ c ] [ r ] == 2 && n . nodeBoard [ c ] [ r +1] 

== 2 ) { 

341 m[ 0 ] = c ; 

342 m[ 1 ] = r ; 

343 m[ 2 ] = c ; 

344 m[ 3 ] = r +1; 

345 r e t u r n (m) ; 

346 } 

347 } 

348 } 

349 f o r ( i n t c =0; c < noCols −1; c++){ 

350 { 


352 { 

353 i f ( n . nodeBoard [ c ] [ r ] == 2 && n . nodeBoard [ c +1][ r ] 

== 2 ) { 

354 m[ 0 ] = c ; 

355 m[ 1 ] = r ; 

356 m[ 2 ] = c +1; 

357 m[ 3 ] = r ; 

358 r e t u r n (m) ; 

359 } 

360 } 

361 } 

362 } 

363 r e t u r n (m) ; 

364 } 

365


366 // Undersoeger om e t ryk e r l o v l i g t i s p i l l e t s nuvaerende tur . 

367 // Modtager p o s i t i o n e n der rykkes f r a og t i l som argumenter , 

r e t u r n e r e r t r u e h v i s rykket e r l o v l i g t . 

368 p u b l i c boolean checkMove ( i n t [ ] [ ] b , i n t curCol , i n t curRow ) 

369 { 

370 boolean r e s u l t = f a l s e ; 

371 i f ( c l i c k == f a l s e ) 

372 { 

373 // M i d t e r s e k t i o n e n 

374 i f ( ( curCol > 0) && ( curCol < noCols −1) && ( curRow > 0) && 

( curRow < noRows−1) ) 

375 { 

376 i f ( checkMidle ( b , curCol , curRow ) ) 

377 { 

378 r e s u l t = t r u e ; 

379 } 

380 r e t u r n ( r e s u l t ) ; 

381 } 

382 e l s e 

383 { 

384 // Venstre s i d e 

385 i f ( ( curCol == 0) && ( curRow > 0) && ( curRow < noRows 

−1) ) 

386 { 

387 i f ( c h e c k L e f t ( b , curCol , curRow ) ) 

388 { 

389 r e s u l t = t r u e ; 

390 } 

391 r e t u r n ( r e s u l t ) ; 

392 } 

393 e l s e 

394 { 

395 // Hoejre s i d e 

396 i f ( ( curCol == noCols −1) && ( curRow > 0) && ( curRow 

< noRows−1) ) 

397 { 

398 i f ( checkRight ( b , curCol , curRow ) ) 

399 { 

400 r e s u l t = t r u e ; 

401 } 

402 r e t u r n ( r e s u l t ) ; 

403 } 

404 e l s e 

405 { 

406 //Toppen 

407 i f ( ( curCol > 0) && ( curCol < noCols −1) && ( 

curRow == 0) ) 

408 { 

409 i f ( checkTop ( b , curCol , curRow ) ) 

410 { 

411 r e s u l t = t r u e ; 

412 } 

413 r e t u r n ( r e s u l t ) ; 

414 } 

415 e l s e

192 Bilag A 

416 { 

417 //Bunden 

418 i f ( ( curCol > 0) && ( curCol < noCols −1) && 

( curRow == noRows−1) ) 

419 { 

420 i f ( checkBottom ( b , curCol , curRow ) ) 

421 { 

422 r e s u l t = t r u e ; 

423 } 

424 r e t u r n ( r e s u l t ) ; 

425 } 

426 e l s e 

427 { 

428 // o e v e r s t e v e n s t r e h j o e r n e 

429 i f ( curCol == 0 && curRow == 0) 

430 { 

431 i f ( checkTLC ( b , curCol , curRow ) ) 

432 { 

433 r e s u l t = t r u e ; 

434 } 

435 r e t u r n ( r e s u l t ) ; 

436 } 

437 e l s e 

438 { 

439 // o e v e r s t e h o e j r e h j o e r n e 

440 i f ( curCol == noCols −1 && curRow == 

0) 

441 { 

442 i f ( checkTRC ( b , curCol , curRow ) 

) 

443 { 

444 r e s u l t = t r u e ; 

445 } 

446 r e t u r n ( r e s u l t ) ; 

447 } 

448 e l s e 

449 { 

450 // Nederste v e n s t r e h j o e r n e 

451 i f ( curCol == 0 && curRow == 

noRows−1) 

452 { 

453 i f ( checkBLC ( b , curCol , 

curRow ) ) 

454 { 

455 r e s u l t = t r u e ; 

456 } 

457 r e t u r n ( r e s u l t ) ; 

458 } 

459 e l s e 

460 { 

461 // Nederste h o e j r e h j o e r n e 

462 i f ( curCol == noCols −1 && 

curRow == noRows−1) 

463 {


464 i f ( checkBRC ( b , curCol , 

curRow ) ) 

465 { 

466 r e s u l t = t r u e ; 

467 } 

468 r e t u r n ( r e s u l t ) ; 

469 } 

470 } 

471 } 

472 } 

473 } 

474 } 

475 } 

476 } 

477 } 

478 } 

479 e l s e 

480 // check f o r andet k l i k ( p l a c e r i n g e n a f den s o r t e d e l a f 

brikken ) 

481 i f ( ( b [ curCol ] [ curRow ] == 2) && ( ( ( curCol == preCol +1) && ( 

curRow == preRow ) ) | | ( ( curCol == preCol −1) && ( curRow 

== preRow ) ) | | ( ( curCol == preCol ) && ( curRow == 

preRow+1) ) | | ( ( curCol == preCol ) && ( curRow == preRow 

−1) ) ) ) 

482 { 

483 r e s u l t = t r u e ; 

484 r e t u r n ( r e s u l t ) ; 

485 } 

486 r e t u r n ( r e s u l t ) ; 

487 } 

488 

489 // anvendes i checkMove 

490 p r i v a t e boolean checkMidle ( i n t [ ] [ ] b , i n t Col , i n t Row) 

491 { 

492 i f ( ( b [ Col ] [ Row ] == 2) && ( ( ( b [ Col ] [ Row+1] == 2 ) | | ( b [ Col ] [ 

Row−1] == 2 ) | | ( b [ Col +1][Row ] == 2 ) | | ( b [ Col −1][Row ] == 

2 ) ) ) ) 

493 { 

494 r e t u r n ( t r u e ) ; 

495 } 

496 r e t u r n ( f a l s e ) ; 

497 } 

498 


500 p r i v a t e boolean c h e c k L e f t ( i n t [ ] [ ] b , i n t Col , i n t Row) 

501 { 

502 i f ( ( b [ Col ] [ Row ] == 2) && ( ( ( b [ Col ] [ Row+1] == 2 ) | | ( b [ Col ] [ 

Row−1] == 2 ) | | ( b [ Col +1][Row ] == 2 ) ) ) ) 

503 { 

504 r e t u r n ( t r u e ) ; 

505 } 

506 r e t u r n ( f a l s e ) ; 

507 } 

508 

509 // anvendes i checkMove

194 Bilag A 

510 p r i v a t e boolean checkRight ( i n t [ ] [ ] b , i n t Col , i n t Row) 

511 { 

512 i f ( ( b [ Col ] [ Row ] == 2) && ( ( ( b [ Col ] [ Row+1] == 2 ) | | ( b [ Col 

] [ Row−1] == 2 ) | | ( b [ Col −1][Row ] == 2 ) ) ) ) 

513 { 

514 r e t u r n ( t r u e ) ; 

515 } 

516 r e t u r n ( f a l s e ) ; 

517 } 

518 


520 p r i v a t e boolean checkTop ( i n t [ ] [ ] b , i n t Col , i n t Row) 

521 { 


+1][Row ] == 2 ) | | ( b [ Col −1][Row ] == 2 ) ) ) ) 

523 { 

524 r e t u r n ( t r u e ) ; 

525 } 

526 r e t u r n ( f a l s e ) ; 

527 } 

528 


530 p r i v a t e boolean checkBottom ( i n t [ ] [ ] b , i n t Col , i n t Row) 

531 { 

532 i f ( ( b [ Col ] [ Row ] == 2) && ( ( ( b [ Col ] [ Row−1] == 2 ) | | ( b [ Col 

+1][Row ] == 2 ) | | ( b [ Col −1][Row ] == 2 ) ) ) ) 

533 { 

534 r e t u r n ( t r u e ) ; 

535 } 

536 r e t u r n ( f a l s e ) ; 

537 } 

538 


540 p r i v a t e boolean checkTLC ( i n t [ ] [ ] b , i n t Col , i n t Row) 

541 { 


+1][Row ] == 2 ) ) ) ) 

543 { 

544 r e t u r n ( t r u e ) ; 

545 } 

546 r e t u r n ( f a l s e ) ; 

547 } 

548 


550 p r i v a t e boolean checkTRC ( i n t [ ] [ ] b , i n t Col , i n t Row) 

551 { 


−1][Row ] == 2 ) ) ) ) 

553 { 

554 r e t u r n ( t r u e ) ; 

555 } 

556 r e t u r n ( f a l s e ) ; 

557 } 

558 

559 // anvendes i checkMove


560 p r i v a t e boolean checkBLC ( i n t [ ] [ ] b , i n t Col , i n t Row) 

561 { 


+1][Row ] == 2 ) ) ) ) 

563 { 

564 r e t u r n ( t r u e ) ; 

565 } 

566 r e t u r n ( f a l s e ) ; 

567 } 

568 


570 p r i v a t e boolean checkBRC ( i n t [ ] [ ] b , i n t Col , i n t Row) 

571 { 


−1][Row ] == 2 ) ) ) ) 

573 { 

574 r e t u r n ( t r u e ) ; 

575 } 

576 r e t u r n ( f a l s e ) ; 

577 } 

578 

579 

580 

581 

582 

583 

584 // Undersoeger om der e r en vinder , i den nuvaerende tur . 

585 p r i v a t e i n t gameOver ( ) 

586 { 

587 i f ( fMap == n u l l ) 

588 System . out . p r i n t l n (” Null ”) ; 

589 i n t [ ] s ; 

590 s = new i n t [ 2 ] ; 

591 s = fMap . c a l S c o r e ( tBoard . board [ currentTurn ] , noCols 

, noRows ) ; 

592 whScore = s [ 0 ] ; 

593 b l S c o r e = s [ 1 ] ; 

594 i n t winner= −1; 

595 i f ( movesLeft ( ) == f a l s e && c l i c k == f a l s e ) 

596 { 

597 i f ( whScore > b l S c o r e ) 

598 { 

599 winner = 1 ; 

600 } 

601 i f ( b l S c o r e > whScore ) 

602 { 

603 winner = 0 ; 

604 } 

605 i f ( b l S c o r e == whScore ) 

606 { 

607 winner = 2 ; 

608 } 

609 } 

610 

611 r e t u r n winner ;

196 Bilag A 

612 } 

613 

614 // b e r e g n e r det h o e j s t a n t a l mulige t i l b a g e v a e r e n d e t r a e k 

615 p u b l i c i n t maxTurnsLeft ( ) { 

616 i n t turns , boxed ; // Boxed e r a n t a l l e t a f e n k e l t e 

i n d l y k k e d e f r i e f e l t e r 

617 boxed = getBoxedIn ( ) ; 

618 t u r n s = ( noRows∗ noCols /2) − ( currentTurn −1) − ( boxed /2) ; 

619 r e t u r n ( t u r n s ) ; 

620 } 

621 

622 // f i n d e r a n t a l l e t a f f r i e i n d e l u k k e d e f e l t e r . (De f r i e f e l t e r 

hvor det i k k e l a e n g e r e e r muligt at p l a c e r e en b r i k paa . ) 

623 p u b l i c i n t getBoxedIn ( ) { 

624 i n t boxed = 0 ; 

625 f o r ( i n t r =0; r < noRows ; r++){ 

626 f o r ( i n t c =0; c < noCols ; c++){ // was noRows 

627 i f ( getPieceAt ( c , r ) == 2) { 

628 i f (0 < r && r < noRows−1){ // Midten a f 

r a e k k e r n e 

629 i f (0 < c && c < noCols −1) 

630 i f ( getPieceAt ( c+1 , r ) != 2 && 

getPieceAt ( c−1 , r ) != 2 && 

getPieceAt ( c , r +1) != 2 && 

getPieceAt ( c , r −1) != 2) 

631 boxed++; 

632 i f ( c == 0) 


getPieceAt ( c , r +1) != 2 && 


634 boxed++; 

635 i f ( c == noCols −1) 

636 i f ( getPieceAt ( c−1 , r ) != 2 && 

getPieceAt ( c , r +1) != 2 && 


637 boxed++; 

638 } 

639 i f ( r == 0) { // o e v e r s t e raekke 

640 i f (0 < c && c < noCols −1) 


getPieceAt ( c−1 , r ) != 2 && 

getPieceAt ( c , r +1) != 2) 

642 boxed++; 

643 i f ( c == 0) 



645 boxed++; 

646 i f ( c == noCols −1) 



648 boxed++; 

649 } 

650 i f ( r == noRows−1){ // Nedereste raekke 

651 i f (0 < c && c < noCols −1)



getPieceAt ( c−1 , r ) != 2 && 


653 boxed++; 

654 i f ( c == 0) 



656 boxed++; 

657 i f ( c == noCols −1) 



659 boxed++; 

660 } 

661 } 

662 } 

663 } 

664 

665 

666 

667 r e t u r n ( boxed ) ; 

668 } 

669 

670 // r e t u r n e r e r whScore 

671 p u b l i c i n t getWhiteScore ( ) 

672 { 

673 r e t u r n ( whScore ) ; 

674 } 

675 // r e t u r n e r e r b l S c o r e 

676 p u b l i c i n t g e t B l a c k S c o r e ( ) 

677 { 

678 r e t u r n ( b l S c o r e ) ; 

679 } 

680 

681 // Returnere den nuvaerende tur . 

682 p u b l i c i n t getCurrentTurn ( ) 

683 { 

684 r e t u r n ( currentTurn ) ; 

685 } 

686 

687 // Returnere den tur /” a n t a l b r i k k e r paa b r a e t t e t ” der s k a l v i s e s 

i GUI ’ en . 

688 p u b l i c i n t getShowTurn ( ) 

689 { 

690 r e t u r n ( showTurn ) ; 

691 } 

692 

693 // s a e t t e r showTurn , bruges kun ved i n d l a e s n i n g a f gemt s p i l . 

694 p u b l i c void setShowTurn ( ) 

695 { 

696 showTurn = currentTurn −1; 

697 } 

698 

699 // s a e t t e r om hvid e l l e r s o r t s t a r t e r (0 = s o r t , 1 = hvid ) 

700 p u b l i c void s e t S t a r t e r ( i n t s ) { 

701 s t a r t e r = s ;

198 Bilag A 

702 } 

703 

704 // s a e t t e r hvem der s p i l l e r hvid 

705 p u b l i c void setWhitePlayer ( i n t w) { 

706 whitePlayer = w; 

707 } 

708 

709 // s a e t t e r hvem der s p i l l e r s o r t 

710 p u b l i c void s e t B l a c k P l a y e r ( i n t b ) { 

711 b l a c k P l a y e r = b ; 

712 } 

713 

714 // Returnere a n t a l l e t a f kolonner . 

715 p u b l i c i n t getNoCols ( ) 

716 { 

717 r e t u r n ( noCols ) ; 

718 } 

719 

720 // Returnere a n t a l l e t a f r a e k k e r . 

721 p u b l i c i n t getNoRows ( ) 

722 { 

723 r e t u r n ( noRows ) ; 

724 } 

725 

726 // Returnerer den nuvaerende s p i l l e r . 

727 p u b l i c i n t g e t C u r r e n t P l a y e r ( ) 

728 { 

729 r e t u r n ( c u r r e n t P l a y e r ) ; 

730 } 

731 

732 // r e t u r n e r e r h e l e b r a e t h i s t o r i e n f o r nuvaerende s p i l 

733 p u b l i c i n t [ ] [ ] [ ] getBoard ( ) 

734 { 

735 i n t [ ] [ ] [ ] b = tBoard . getBoard ( ) ; 

736 r e t u r n ( b ) ; 

737 } 

738 

739 // r e t u r n e r e r b r a e t f o r t r a e k nr . t 

740 p u b l i c i n t [ ] [ ] getOneBoard ( i n t t ) 

741 { 

742 // tBoard . copyBoardTo ( t +1) ; 

743 // i n t [ ] [ ] b = tBoard . getOneBoard ( t ) ; 

744 i n t [ ] [ ] b = tBoard . getClone ( t ) ; 

745 r e t u r n ( b ) ; 

746 } 

747 

748 // r e t u r n e r e r f a r v e n a f brikken paa p l a d s ( col , row ) ( s o r t , hvid 

, f r i ) 

749 p u b l i c i n t getPieceAt ( i n t col , i n t row ) 

750 { 

751 i n t p = tBoard . getPieceAt ( col , row ) ; 

752 r e t u r n ( p ) ; 

753 } 

754


755 // r e t u r n e r e r f o r s k e l l e n mellem hvid og s o r t s c o r e f o r b r a e t t e t 

nb 

756 p u b l i c i n t g e t D i f ( i n t [ ] [ ] nb ) 

757 { 

758 i n t d i f = fMap . c a l D i f ( nb , noCols , noRows ) ; 

759 r e t u r n ( d i f ) ; 

760 } 

761 

762 // S t i l l e r turen en t i l b a g e , s k i f t e r s p i l l e r . Hvid , h v i s der 

s k i f t e s t i l u l i g e tur , s o r t , h v i s det e r en l i g e tur . 

763 p u b l i c void turnBack ( ) 

764 { 

765 i f ( currentTurn > 1) 

766 { 

767 currentTurn −−; 

768 showTurn−−; 

769 c u r r e n t P l a y e r = currentTurn % 2 ; 

770 i n t [ ] s ; 

771 s = new i n t [ 2 ] ; 


, noRows ) ; 

773 whScore = s [ 0 ] ; 

774 b l S c o r e = s [ 1 ] ; 

775 } 

776 } 

777 

778 // S t i l l e r turen en frem , s k i f t e r s p i l l e r . Hvid , h v i s der 

s k i f t e s t i l en u l i g e tur , s o r t , h v i s der s k i f t e s t i l en 

l i g e tur . 

779 p u b l i c void turnForward ( ) 

780 { 

781 i f ( currentTurn < tBoard . board [ 0 ] [ 0 ] [ 0 ] ) 

782 { 




786 i n t [ ] s ; 

787 s = new i n t [ 2 ] ; 


, noRows ) ; 

789 whScore = s [ 0 ] ; 

790 b l S c o r e = s [ 1 ] ; 

791 } 

792 } 

793 

794 // S k i f t e r t i l den n a e s t e s p i l l e r , s o r t h v i s nuvaerende e r hvid , 

og v i c e v e r s a . 

795 p u b l i c void changePlayer ( ) 

796 { 

797 c u r r e n t P l a y e r = ( c u r r e n t P l a y e r +1) % 2 ; 

798 } 

799 

800 // Modtager e t nyt b r a e t ( f r a e t gemt s p i l ) , s a e t t e r den 

nuvaerende tur t i l turen gemt i [ 0 ] [ 0 ] [ 0 ] i det nye board . 

801 // Modtager e t 3−d i m e n s i o n e l t array som argument .

200 Bilag A 

802 p u b l i c void newBoard ( i n t [ ] [ ] [ ] board ) 

803 { 

804 t h i s . tBoard . board = board ; 

805 currentTurn = board [ 0 ] [ 0 ] [ 0 ] ; 


807 i n t [ ] s ; 

808 s = new i n t [ 2 ] ; 

809 s = fMap . c a l S c o r e ( board [ currentTurn ] , noCols , noRows ) ; 

810 whScore = s [ 0 ] ; 

811 b l S c o r e = s [ 1 ] ; 

812 } 

813 

814 // Returnerer det maksimale a n t a l t u r e programmet kan haandtere . 

815 p u b l i c i n t getMaxTurns ( ) 

816 { 

817 r e t u r n ( maxTurns ) ; 

818 } 

819 

820 // Returnerer det s e n e s t e traek , u a f h a e n g i g t a f h v i l k e n type 

s p i l l e r der har f o r e t a g e t det 

821 p u b l i c i n t [ ] getLatestMove ( ) { 

822 i n t [ ] t = new i n t [ 4 ] ; 

823 i f ( currentTurn == 0) { 

824 r e t u r n ( t ) ; 

825 } 

826 f o r ( i n t c =0; c < noCols ; c++){ 

827 f o r ( i n t r =0; r < noRows ; r++){ 

828 i f ( tBoard . board [ currentTurn ] [ c ] [ r ] != tBoard . board 

[ currentTurn −1][ c ] [ r ] ) { 

829 i f ( tBoard . board [ currentTurn ] [ c ] [ r ] == 1) { 

830 t [0]= c ; 

831 t [1]= r ; 

832 } 

833 i f ( tBoard . board [ currentTurn ] [ c ] [ r ] == 0) { 

834 t [2]= c ; 

835 t [3]= r ; 

836 } 

837 } 

838 } 

839 } 

840 r e t u r n ( t ) ; 

841 } 

842 

843 

844 } 

A.14 TaijiPanels.java 

1 



4 import java . lang . ∗ ; 

5

A.14 TaijiPanels.java 201 

6 // Klassen T a i j i P a n e l e r s e l v e b r a e t t e t hvor a l l e ryk f o r e t a g e s og 

a l l e b r i k k e r v i s e s . 

7 //Er nedarvet f r a JPanel . 

8 c l a s s T a i j i P a n e l extends JPanel 

9 { 

10 

11 // V a r i a b l e r med i n f o r m a t i o n om b r a e t t e t s udseende . 

12 p r i v a t e i n t noRows , noCols ; 

13 

14 //En TaijiFrame som metoderne i T a i j i P a n e l kan r e f e r e r e t i l . 


16 // p r i v a t e Board tBoard ; 

17 

18 // Constructor . Giver tFrame en v a e r d i saa der kan r e f e r e r e s t i l 

den , d e f i n e r e r a n t a l l e t a f r a e k k e r og s o e j l e r . 

19 // Modtager en tFrame som argument . 

20 p u b l i c T a i j i P a n e l ( TaijiFrame frame ) 

21 { 


23 T a i j i P a n e l L i s t e n e r a b l i s = new T a i j i P a n e l L i s t e n e r ( tFrame ) ; 

24 t h i s . addMouseListener ( a b l i s ) ; 

25 noRows = tFrame . tModel . getNoRows ( ) ; 

26 noCols = tFrame . tModel . getNoCols ( ) ; 

27 t h i s . setBackground ( Color . gray ) ; 

28 t h i s . s e t P r e f e r r e d S i z e ( new Dimension ( 5 0 0 , 5 0 0 ) ) ; 

29 } 

30 

31 // Tegner s e l v e b r a e t t e t . 

32 p u b l i c void paintComponent ( Graphics g ) 

33 { 

34 super . paintComponent ( g ) ; 

35 i n t width = t h i s . getWidth ( ) ; 

36 i n t h e i g h t = t h i s . getHeight ( ) ; 

37 i n t colWidth = width / noCols ; 

38 i n t rowHeight = h e i g h t /noRows ; 

39 

40 g . s e t C o l o r ( Color . black ) ; 

41 

42 f o r ( i n t i = 1 ; i

202 Bilag A 

59 g . f i l l R e c t ( c ∗ colWidth , r ∗ rowHeight , 

colWidth , rowHeight ) ; 

60 } 

61 e l s e i f ( tFrame . tModel . getPieceAt ( c , r ) == 0) 

62 { 


64 g . f i l l R e c t ( c ∗ colWidth , r ∗ rowHeight , 

colWidth , rowHeight ) ; 

65 } 

66 } 

67 } 

68 } 

69 } 

70 

71 // Klassen ScorePanel v i s e r s c o r e n f o r enten hvid e l l e r s o r t s p i l l e r 

. 


73 c l a s s ScorePanel extends JPanel 

74 { 

75 

76 // V a r i a b e l der v i s e r s c o r e n i o e j e b l i k k e t . Samt a n g i v e r h v i l k e n 

s p i l l e r s c o r e ScorePanel s k a l v i s e . 

77 p r i v a t e i n t s c o r e ; 

78 p r i v a t e i n t playerNumber ; 

79 

80 //En TaijiFrame som metoderne i T a i j i P a n e l kan r e f e r e r e t i l . 


82 


84 // Modtager en frame og en s p i l l e r som argumenter . 

85 p u b l i c ScorePanel ( TaijiFrame frame , i n t p l a y e r ) 

86 { 


88 playerNumber = p l a y e r ; 

89 t h i s . s e t P r e f e r r e d S i z e ( new Dimension ( 5 0 , 5 0 0 ) ) ; 

90 } 

91 

92 // V i s e r g r a f i s k s t i l l i n g e n f o r de to s p i l l e r . 

93 p u b l i c void paintComponent ( Graphics g ) 

94 { 

95 super . paintComponent ( g ) ; 

96 S t r i n g s c o r e S t r i n g ; 

97 i n t middleHeight = ( t h i s . getHeight ( ) /2) ; 

98 i n t middleWidth = ( t h i s . getWidth ( ) /2) ; 

99 i f ( playerNumber == 1) 

100 { 

101 s c o r e = tFrame . tModel . getWhiteScore ( ) ; 

102 s c o r e S t r i n g = ”” + s c o r e ; 


104 g . s e t C o l o r ( Color . white ) ; 

105 g . drawString ( s c o r e S t r i n g , middleWidth , middleHeight 

) ; 

106 } 

107 e l s e 

108 {

A.14 TaijiPanels.java 203 

109 s c o r e = tFrame . tModel . g e t B l a c k S c o r e ( ) ; 

110 s c o r e S t r i n g = ”” + s c o r e ; 



113 g . drawString ( s c o r e S t r i n g , middleWidth , middleHeight 

) ; 

114 } 

115 } 

116 } 

117 

118 // Klassen TurnPanel v i s e r h v i l k e n f a r v e s tur det e r . Bruges ogsaa 

t i l at gaa frem og t i l b a g e gennem t urene . 


120 c l a s s TurnPanel extends JPanel 

121 { 

122 p r i v a t e TaijiFrame uFrame ; 

123 

124 //En l a b e l som v i s e r hvor mange b r i k k e r der e r b l e v e t l a g t ( tur 

) . 

125 p r i v a t e JLabel uLabel ; 

126 


128 // Modtager TaijiFrame som argument . 

129 p u b l i c TurnPanel ( TaijiFrame frame ) 

130 { 

131 uFrame = frame ; 

132 

133 t h i s . s e t P r e f e r r e d S i z e ( new Dimension ( 5 0 0 , 5 0 ) ) ; 

134 t h i s . setBackground ( Color . l i g h t G r a y ) ; 

135 

136 

137 BorderLayout bLayout = new BorderLayout ( ) ; 

138 t h i s . setLayout ( bLayout ) ; 

139 

140 JButton fButton = new JButton (” Next Turn ”) ; 

141 JButton bButton = new JButton (” Last Turn ”) ; 

142 uLabel = new JLabel (””+ uFrame . tModel . getShowTurn ( ) , 

SwingConstants .CENTER) ; 

143 

144 t h i s . add ( fButton , ” East ”) ; 

145 t h i s . add ( uLabel , ” Center ”) ; 

146 t h i s . add ( bButton , ”West ”) ; 

147 

148 TurnListener t L i s t = new TurnListener ( uFrame ) ; 

149 fButton . a d d A c t i o n L i s t e n e r ( t L i s t ) ; 

150 bButton . a d d A c t i o n L i s t e n e r ( t L i s t ) ; 

151 

152 } 

153 

154 // Opdaterer uLabel og s k i f t e r baggrundsfarven e f t e r h v i l k e n 

s p i l l e r s tur det e r . 

155 p u b l i c void update ( ) 

156 { 

157 uLabel . setText (””+uFrame . tModel . getShowTurn ( ) ) ; 

158 i f ( uFrame . tModel . g e t C u r r e n t P l a y e r ( ) == 1)

204 Bilag A 

159 { 

160 t h i s . setBackground ( Color . l i g h t G r a y ) ; 

161 } 

162 e l s e 

163 { 


165 } 

166 } 

167 

168 } 

A.15 TaijiPrint.java 

1 // denne k l a s s e r s t a a r f o r at u d s k r i v e r i n d e h o l d e t a f Nodes t i l 

t e s t formaal 

2 p u b l i c c l a s s T a i j i P r i n t { 


4 

5 p u b l i c T a i j i P r i n t ( TaijiModel m) { 


7 } 

8 

9 // u d s k r i v e r v a e r d i e r n e f o r f o r a e l d r e n e t i l Noden n 

10 p u b l i c void p r i n t P a r S c o r e ( Node n ) { 

11 System . out . p r i n t (” t P r i n t p r i n t P a r S c o r e d=”+n . d+” n . par 

s c o r e s : ”) ; 

12 f o r ( i n t i =0; i

A.15 TaijiPrint.java 205 

39 e l s e 

40 i f ( tModel . noCols == 8) 

41 f o r ( i n t i =0; i

206 Bilag A 

81 System . out . p r i n t l n ( n . c h i l d r e n . get ( i ) . nodeBoard 

[ 0 ] [ 1 ] + ” ”+n . c h i l d r e n . get ( i ) . nodeBoard [ 1 ] [ 1 ] + ” 

”+n . c h i l d r e n . get ( i ) . nodeBoard [ 2 ] [ 1 ] ) ; 




83 i f ( tModel . noRows > 3) { 


[ 0 ] [ 3 ] + ” ”+n . c h i l d r e n . get ( i ) . nodeBoard 


[ 2 ] [ 3 ] ) ; 


86 System . out . p r i n t l n ( n . c h i l d r e n . get ( i ) . 

nodeBoard [ 0 ] [ 4 ] + ” ”+n . c h i l d r e n . get ( i ) . 


nodeBoard [ 2 ] [ 4 ] ) ; 



nodeBoard [ 0 ] [ 5 ] + ” ”+n . c h i l d r e n . get ( 

i ) . nodeBoard [ 1 ] [ 5 ] + ” ”+n . c h i l d r e n . 

get ( i ) . nodeBoard [ 2 ] [ 5 ] ) ; 


90 System . out . p r i n t l n ( n . c h i l d r e n . get ( i 

) . nodeBoard [ 0 ] [ 6 ] + ” ”+n . 

c h i l d r e n . get ( i ) . nodeBoard 

[ 1 ] [ 6 ] + ” ”+n . c h i l d r e n . get ( i ) . 

nodeBoard [ 2 ] [ 6 ] ) ; 


92 System . out . p r i n t l n ( n . c h i l d r e n . 

get ( i ) . nodeBoard [ 0 ] [ 7 ] + ” ”+ 

n . c h i l d r e n . get ( i ) . nodeBoard 

[ 1 ] [ 7 ] + ” ”+n . c h i l d r e n . get ( i 

) . nodeBoard [ 2 ] [ 7 ] ) ; 


94 System . out . p r i n t l n ( n . 

c h i l d r e n . get ( i ) . 

nodeBoard [ 0 ] [ 8 ] + ” ”+n . 


nodeBoard [ 1 ] [ 8 ] + ” ”+n . 


nodeBoard [ 2 ] [ 8 ] ) ; 


96 System . out . p r i n t l n ( n . 


nodeBoard [ 0 ] [ 9 ] + ” 

”+n . c h i l d r e n . get ( i ) 

. nodeBoard [ 1 ] [ 9 ] + ” 

”+n . c h i l d r e n . get ( i ) 

. nodeBoard [ 2 ] [ 9 ] ) ; 

97 } 

98 } 

99 } 

100 } 

101 } 

102 }


103 } 


105 } 

106 } 

107 

108 // f o r b r a e t med 4 k o l o n e r 

109 p u b l i c void p r i n t C h i l d r e n 4 x ( Node n ) { 

110 System . out . p r i n t l n (” t P r i n t P r i n t Children ”+n ) ; 

111 f o r ( i n t i =0; i 3) { 



”+n . c h i l d r e n . get ( i ) . nodeBoard [ 2 ] [ 3 ] + ” ”+n . 

c h i l d r e n . get ( i ) . nodeBoard [ 3 ] [ 3 ] ) ; 






[ 3 ] [ 4 ] ) ; 






nodeBoard [ 3 ] [ 5 ] ) ; 





get ( i ) . nodeBoard [ 2 ] [ 6 ] + ” ”+n . 




) . nodeBoard [ 0 ] [ 7 ] + ” ”+n . 

c h i l d r e n . get ( i ) . nodeBoard

208 Bilag A 


nodeBoard [ 2 ] [ 7 ] + ” ”+n . c h i l d r e n . 







) . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 


[ 3 ] [ 8 ] ) ; 

129 

130 } 

131 } 

132 } 

133 } 

134 } 

135 } 


137 } 

138 } 

139 




143 f o r ( i n t i =0; i 3) { 




c h i l d r e n . get ( i ) . nodeBoard [ 3 ] [ 3 ] + ” ”+n . c h i l d r e n . 


151 i f ( tModel . noRows > 4) {







[ 4 ] [ 4 ] ) ; 







nodeBoard [ 4 ] [ 5 ] ) ; 






c h i l d r e n . get ( i ) . nodeBoard [ 3 ] [ 6 ] + ” 

”+n . c h i l d r e n . get ( i ) . nodeBoard 

[ 4 ] [ 6 ] ) ; 



) . nodeBoard [ 0 ] [ 7 ] + ” ”+n . 






[ 4 ] [ 7 ] ) ; 






) . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 4 ] [ 8 ] ) ; 

161 

162 } 

163 } 

164 } 

165 } 

166 } 

167 } 


169 } 

170 } 

171 




175 f o r ( i n t i =0; i

210 Bilag A 

176 System . out . p r i n t l n ( i +” ”+n . c h i l d r e n . get ( i )+” Depth : ”+n 

. c h i l d r e n . get ( i ) . d+” Score ”+n . c h i l d r e n . get ( i ) . a ) ; 

177 System . out . p r i n t l n ( n . c h i l d r e n . get ( i ) . par+” ”+n . c h i l d r e n 

. get ( i ) . a+” b ”+n . c h i l d r e n . get ( i ) . bc+”,”+n . c h i l d r e n 

. get ( i ) . br+” w ”+n . c h i l d r e n . get ( i ) . wc+”,”+n . 

c h i l d r e n . get ( i ) . wr+” ”+n . c h i l d r e n . get ( i ) . c h i l d r e n +” 

”+n . c h i l d r e n . get ( i ) . nodeBoard ) ; 

178 System . out . p r i n t l n ( n . c h i l d r e n . get ( i ) . nodeBoard [ 0 ] [ 0 ] + ” 

”+n . c h i l d r e n . get ( i ) . nodeBoard [ 1 ] [ 0 ] + ” ”+n . c h i l d r e n . 

get ( i ) . nodeBoard [ 2 ] [ 0 ] + ” ”+n . c h i l d r e n . get ( i ) . 

nodeBoard [ 3 ] [ 0 ] + ” ”+n . c h i l d r e n . get ( i ) . nodeBoard 

[ 4 ] [ 0 ] + ” ”+n . c h i l d r e n . get ( i ) . nodeBoard [ 5 ] [ 0 ] ) ; 

















nodeBoard [ 5 ] [ 3 ] ) ; 








[ 5 ] [ 4 ] ) ; 








nodeBoard [ 5 ] [ 5 ] ) ; 









nodeBoard [ 5 ] [ 6 ] ) ; 




) . nodeBoard [ 0 ] [ 7 ] + ” ”+n . 







nodeBoard [ 5 ] [ 7 ] ) ; 






) . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 4 ] [ 8 ] + ” ”+n . 


[ 5 ] [ 8 ] ) ; 

193 

194 } 

195 } 

196 } 

197 } 

198 } 

199 } 


201 } 

202 } 

203 




207 f o r ( i n t i =0; i

212 Bilag A 





[ 4 ] [ 2 ] + ” ”+n . c h i l d r e n . get ( i ) . nodeBoard [ 5 ] [ 2 ] + ” ”+n . 









[ 6 ] [ 3 ] ) ; 









[ 6 ] [ 4 ] ) ; 









nodeBoard [ 6 ] [ 5 ] ) ; 










i ) . nodeBoard [ 6 ] [ 6 ] ) ; 



) . nodeBoard [ 0 ] [ 7 ] + ” ”+n . 















) . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 4 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 6 ] [ 8 ] ) ; 

225 

226 } 

227 } 

228 } 

229 } 

230 } 

231 } 


233 } 

234 } 

235 




239 f o r ( i n t i =0; i 3) {

214 Bilag A 

















[ 7 ] [ 4 ] ) ; 










nodeBoard [ 7 ] [ 5 ] ) ; 














) . nodeBoard [ 0 ] [ 7 ] + ” ”+n . 










[ 7 ] [ 7 ] ) ; 




n . c h i l d r e n . get ( i ) . nodeBoard



) . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 4 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 6 ] [ 8 ] + ” ”+n . 


[ 7 ] [ 8 ] ) ; 

257 

258 } 

259 } 

260 } 

261 } 

262 } 

263 } 


265 } 

266 

267 

} 




271 f o r ( i n t i =0; i

216 Bilag A 

[ 8 ] [ 2 ] ) ; 




















[ 8 ] [ 4 ] ) ; 











nodeBoard [ 8 ] [ 5 ] ) ; 















) . nodeBoard [ 0 ] [ 7 ] + ” ”+n . 








get ( i ) . nodeBoard [ 6 ] [ 7 ] + ” ”+n .




nodeBoard [ 8 ] [ 7 ] ) ; 






) . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 4 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 6 ] [ 8 ] + ” ”+n . 



) . nodeBoard [ 8 ] [ 8 ] ) ; 

289 

290 } 

291 } 

292 } 

293 } 

294 } 

295 } 


297 } 

298 } 

299 

300 // u d s k r i v e r i n f o r m a t i o n f o r en e n k e l t node 

301 p u b l i c void printNode ( Node n ) { 


303 printNode3x ( n ) ; 

304 e l s e 



307 e l s e 



310 e l s e 



313 e l s e 



316 e l s e 



319 e l s e 



322 

323 } 

324 

325 // f o r b r a e t med 3 k o l o n e r

218 Bilag A 

326 p u b l i c void printNode3x ( Node n ) { 

327 System . out . p r i n t l n (” t P r i n t PrintNode ”+n+” Depth : ”+n . d+” 

Score ”+n . a+” par ”+n . par+” w ”+n . wc+”,”+n . wr+” b ”+n . 

bc+”,”+n . br+” c h i l d r e n : ”+n . c h i l d r e n ) ; 

328 System . out . p r i n t l n ( n . nodeBoard [ 0 ] [ 0 ] + ” ”+n . nodeBoard 

[ 1 ] [ 0 ] + ” ”+n . nodeBoard [ 2 ] [ 0 ] ) ; 


[ 1 ] [ 1 ] + ” ”+n . nodeBoard [ 2 ] [ 1 ] ) ; 


[ 1 ] [ 2 ] + ” ”+n . nodeBoard [ 2 ] [ 2 ] ) ; 



[ 1 ] [ 3 ] + ” ”+n . nodeBoard [ 2 ] [ 3 ] ) ; 


334 System . out . p r i n t l n ( n . nodeBoard [ 0 ] [ 4 ] + ” ”+n . 

nodeBoard [ 1 ] [ 4 ] + ” ”+n . nodeBoard [ 2 ] [ 4 ] ) ; 








340 System . out . p r i n t l n ( n . nodeBoard [ 0 ] [ 7 ] + ” 

”+n . nodeBoard [ 1 ] [ 7 ] + ” ”+n . nodeBoard 

[ 2 ] [ 7 ] ) ; 


342 System . out . p r i n t l n ( n . nodeBoard 

[ 0 ] [ 8 ] + ” ”+n . nodeBoard [ 1 ] [ 8 ] + ” 

”+n . nodeBoard [ 2 ] [ 8 ] ) ; 

343 

344 

345 } 

346 } 

347 } 

348 } 

349 } 

350 } 


352 } 

353 







[ 1 ] [ 0 ] + ” ”+n . nodeBoard [ 2 ] [ 0 ] + ” ”+n . nodeBoard [ 3 ] [ 0 ] ) ; 







[ 1 ] [ 3 ] + ” ”+n . nodeBoard [ 2 ] [ 3 ] + ” ”+n . nodeBoard [ 3 ] [ 3 ] )


; 



nodeBoard [ 1 ] [ 4 ] + ” ”+n . nodeBoard [ 2 ] [ 4 ] + ” ”+n . 

nodeBoard [ 3 ] [ 4 ] ) ; 



nodeBoard [ 1 ] [ 5 ] + ” ”+n . nodeBoard [ 2 ] [ 5 ] + ” ”+n 

. nodeBoard [ 3 ] [ 5 ] ) ; 



nodeBoard [ 1 ] [ 6 ] + ” ”+n . nodeBoard [ 2 ] [ 6 ] + ” 

”+n . nodeBoard [ 3 ] [ 6 ] ) ; 




[ 2 ] [ 7 ] + ” ”+n . nodeBoard [ 3 ] [ 7 ] ) ; 



[ 0 ] [ 8 ] + ” ”+n . nodeBoard [ 1 ] [ 8 ] + ” 

”+n . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 

nodeBoard [ 3 ] [ 8 ] ) ; 

372 

373 

374 } 

375 } 

376 } 

377 } 

378 } 

379 } 


381 } 

382 







[ 1 ] [ 0 ] + ” ”+n . nodeBoard [ 2 ] [ 0 ] + ” ”+n . nodeBoard [ 3 ] [ 0 ] + ” ”+ 

n . nodeBoard [ 4 ] [ 0 ] ) ; 



n . nodeBoard [ 4 ] [ 1 ] ) ; 



n . nodeBoard [ 4 ] [ 2 ] ) ; 



[ 1 ] [ 3 ] + ” ”+n . nodeBoard [ 2 ] [ 3 ] + ” ”+n . nodeBoard 

[ 3 ] [ 3 ] + ” ”+n . nodeBoard [ 4 ] [ 3 ] ) ; 




nodeBoard [ 3 ] [ 4 ] + ” ”+n . nodeBoard [ 4 ] [ 4 ] ) ;

220 Bilag A 




. nodeBoard [ 3 ] [ 5 ] + ” ”+n . nodeBoard [ 4 ] [ 5 ] ) ; 





[ 4 ] [ 6 ] ) ; 




[ 2 ] [ 7 ] + ” ”+n . nodeBoard [ 3 ] [ 7 ] + ” ”+n . 

nodeBoard [ 4 ] [ 7 ] ) ; 



[ 0 ] [ 8 ] + ” ”+n . nodeBoard [ 1 ] [ 8 ] + ” 

”+n . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 

nodeBoard [ 3 ] [ 8 ] + ” ”+n . nodeBoard 

[ 4 ] [ 8 ] ) ; 

401 

402 

403 } 

404 } 

405 } 

406 } 

407 } 

408 } 


410 } 

411 








n . nodeBoard [ 4 ] [ 0 ] + ” ”+n . nodeBoard [ 5 ] [ 0 ] ) ; 










[ 3 ] [ 3 ] + ” ”+n . nodeBoard [ 4 ] [ 3 ] + ” ”+n . nodeBoard [ 5 ] [ 3 ] ) 

; 





nodeBoard [ 5 ] [ 4 ] ) ;





. nodeBoard [ 3 ] [ 5 ] + ” ”+n . nodeBoard [ 4 ] [ 5 ] + ” ”+ 

n . nodeBoard [ 5 ] [ 5 ] ) ; 





[ 4 ] [ 6 ] + ” ”+n . nodeBoard [ 5 ] [ 6 ] ) ; 




[ 2 ] [ 7 ] + ” ”+n . nodeBoard [ 3 ] [ 7 ] + ” ”+n . 


[ 5 ] [ 7 ] ) ; 



[ 0 ] [ 8 ] + ” ”+n . nodeBoard [ 1 ] [ 8 ] + ” 

”+n . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 


[ 4 ] [ 8 ] + ” ”+n . nodeBoard [ 5 ] [ 8 ] ) ; 

430 

431 

432 } 

433 } 

434 } 

435 } 

436 } 

437 } 


439 } 

440 








n . nodeBoard [ 4 ] [ 0 ] + ” ”+n . nodeBoard [ 5 ] [ 0 ] + ” ”+n . nodeBoard 

[ 6 ] [ 0 ] ) ; 




[ 6 ] [ 1 ] ) ; 




[ 6 ] [ 2 ] ) ; 





[ 5 ] [ 3 ] + ” ”+n . nodeBoard [ 6 ] [ 3 ] ) ;

222 Bilag A 















[ 4 ] [ 6 ] + ” ”+n . nodeBoard [ 5 ] [ 6 ] + ” ”+n . 

nodeBoard [ 6 ] [ 6 ] ) ; 




[ 2 ] [ 7 ] + ” ”+n . nodeBoard [ 3 ] [ 7 ] + ” ”+n . 


[ 5 ] [ 7 ] + ” ”+n . nodeBoard [ 6 ] [ 7 ] ) ; 



[ 0 ] [ 8 ] + ” ”+n . nodeBoard [ 1 ] [ 8 ] + ” 

”+n . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 


[ 4 ] [ 8 ] + ” ”+n . nodeBoard [ 5 ] [ 8 ] + ” 

”+n . nodeBoard [ 6 ] [ 8 ] ) ; 

459 

460 

461 } 

462 } 

463 } 

464 } 

465 } 

466 } 


468 } 

469 









[ 6 ] [ 0 ] + ” ”+n . nodeBoard [ 7 ] [ 0 ] ) ; 




[ 6 ] [ 1 ] + ” ”+n . nodeBoard [ 7 ] [ 1 ] ) ; 


[ 1 ] [ 2 ] + ” ”+n . nodeBoard [ 2 ] [ 2 ] + ” ”+n . nodeBoard [ 3 ] [ 2 ] + ” ”+



[ 6 ] [ 2 ] + ” ”+n . nodeBoard [ 7 ] [ 2 ] ) ; 





[ 5 ] [ 3 ] + ” ”+n . nodeBoard [ 6 ] [ 3 ] + ” ”+n . nodeBoard [ 7 ] [ 3 ] ) 

; 






nodeBoard [ 7 ] [ 4 ] ) ; 





n . nodeBoard [ 5 ] [ 5 ] + ” ”+n . nodeBoard [ 6 ] [ 5 ] + ” 

”+n . nodeBoard [ 7 ] [ 5 ] ) ; 





[ 4 ] [ 6 ] + ” ”+n . nodeBoard [ 5 ] [ 6 ] + ” ”+n . 





[ 2 ] [ 7 ] + ” ”+n . nodeBoard [ 3 ] [ 7 ] + ” ”+n . 


[ 5 ] [ 7 ] + ” ”+n . nodeBoard [ 6 ] [ 7 ] + ” ”+n . 

nodeBoard [ 7 ] [ 7 ] ) ; 



[ 0 ] [ 8 ] + ” ”+n . nodeBoard [ 1 ] [ 8 ] + ” 

”+n . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 


[ 4 ] [ 8 ] + ” ”+n . nodeBoard [ 5 ] [ 8 ] + ” 

”+n . nodeBoard [ 6 ] [ 8 ] + ” ”+n . 

nodeBoard [ 7 ] [ 8 ] ) ; 

488 

489 

490 } 

491 } 

492 } 

493 } 

494 } 

495 } 


497 } 

498 


500 p u b l i c void printNode9x ( Node n ) {

224 Bilag A 





















[ 7 ] [ 3 ] + ” ”+n . nodeBoard [ 8 ] [ 3 ] ) ; 











n . nodeBoard [ 5 ] [ 5 ] + ” ”+n . nodeBoard [ 6 ] [ 5 ] + ” 

”+n . nodeBoard [ 7 ] [ 5 ] + ” ”+n . nodeBoard [ 8 ] [ 5 ] ) ; 





[ 4 ] [ 6 ] + ” ”+n . nodeBoard [ 5 ] [ 6 ] + ” ”+n . 


”+n . nodeBoard [ 8 ] [ 6 ] ) ; 




[ 2 ] [ 7 ] + ” ”+n . nodeBoard [ 3 ] [ 7 ] + ” ”+n . 


[ 5 ] [ 7 ] + ” ”+n . nodeBoard [ 6 ] [ 7 ] + ” ”+n . 


[ 8 ] [ 7 ] ) ; 



[ 0 ] [ 8 ] + ” ”+n . nodeBoard [ 1 ] [ 8 ] + ” 

”+n . nodeBoard [ 2 ] [ 8 ] + ” ”+n . 


[ 4 ] [ 8 ] + ” ”+n . nodeBoard [ 5 ] [ 8 ] + ” 

”+n . nodeBoard [ 6 ] [ 8 ] + ” ”+n .

A.16 TaijiSettings.java 225 

517 

518 

519 } 

520 } 

521 } 

522 } 

523 } 

524 } 


526 } 

527 } 

A.16 TaijiSettings.java 


[ 8 ] [ 8 ] ) ; 




4 

5 p u b l i c c l a s s T a i j i S e t t i n g s extends JDialog { 

6 // S e l v e d i a l o g e n s panel . 

7 p r i v a t e JPanel mainPanel = new JPanel ( ) ; 

8 

9 // Radiobuttons t i l at v a e l g e AI og andre s e t t i n g s . 

10 p r i v a t e JRadioButton oneButton = new JRadioButton (” Player VS 

Player ”) ; 

11 p r i v a t e JRadioButton twoButton = new JRadioButton (” Player VS 

LocalArea ”) ; 

12 p r i v a t e JRadioButton threeButton = new JRadioButton (” Player VS 

AlphaBeta ”) ; 

13 p r i v a t e JRadioButton fourButton = new JRadioButton (” Player VS 

Growth ”) ; 

14 p r i v a t e JRadioButton f i v e B u t t o n = new JRadioButton (” LocalArea 

VS Player ”) ; 

15 p r i v a t e JRadioButton sixButton = new JRadioButton (” AlphaBeta VS 

Player ”) ; 

16 p r i v a t e JRadioButton sevenButton = new JRadioButton (” Growth VS 

Player ”) ; 

17 p r i v a t e ButtonGroup group = new ButtonGroup ( ) ; 

18 

19 //To knapper som godkende e l l e r a f v i s e r det a n t a l b l o c k s som e r 

v a l g t . 

20 p r i v a t e JButton okButton = new JButton (”Ok”) ; 

21 p r i v a t e JButton cancelButton = new JButton (” Cancel ”) ; 

22 


24 


26 // Modtager en AtaxxFrame som argument . 

27 p u b l i c T a i j i S e t t i n g s ( TaijiFrame frame ) 

28 { 

29 super ( frame , ” T a i j i s e t t i n g s ” , t r u e ) ;

226 Bilag A 

30 


32 

33 JLabel q u e s t i o n = new JLabel (” S h a l l we play a game ?”) ; 

34 JLabel f i r s t F i l l e r = new JLabel ( ) ; 

35 JLabel s e c o n d F i l l e r = new JLabel ( ) ; 

36 JLabel t h i r d F i l l e r = new JLabel ( ) ; 

37 JLabel f o u r t h F i l l e r = new JLabel ( ) ; 

38 JLabel f i f t h F i l l e r = new JLabel ( ) ; 

39 JLabel s i x t h F i l l e r = new JLabel ( ) ; 

40 

41 t h i s . getContentPane ( ) . setLayout ( new BorderLayout ( ) ) ; 

42 t h i s . getContentPane ( ) . add ( mainPanel , ” Center ”) ; 

43 

44 mainPanel . setLayout ( new GridLayout ( 8 , 2 , 1 0 , 0 ) ) ; 

45 mainPanel . add ( q u e s t i o n ) ; 

46 mainPanel . add ( oneButton ) ; 

47 mainPanel . add ( f i r s t F i l l e r ) ; 

48 mainPanel . add ( twoButton ) ; 

49 mainPanel . add ( s e c o n d F i l l e r ) ; 

50 mainPanel . add ( threeButton ) ; 

51 mainPanel . add ( t h i r d F i l l e r ) ; 

52 mainPanel . add ( fourButton ) ; 

53 mainPanel . add ( f o u r t h F i l l e r ) ; 

54 mainPanel . add ( f i v e B u t t o n ) ; 

55 mainPanel . add ( f i f t h F i l l e r ) ; 

56 mainPanel . add ( sixButton ) ; 

57 mainPanel . add ( s i x t h F i l l e r ) ; 

58 mainPanel . add ( sevenButton ) ; 

59 mainPanel . add ( okButton ) ; 

60 mainPanel . add ( cancelButton ) ; 

61 

62 group . add ( oneButton ) ; 

63 group . add ( twoButton ) ; 

64 group . add ( threeButton ) ; 

65 group . add ( fourButton ) ; 

66 group . add ( f i v e B u t t o n ) ; 

67 group . add ( sixButton ) ; 

68 group . add ( sevenButton ) ; 

69 oneButton . setActionCommand ( ” 1 ” ) ; 

70 twoButton . setActionCommand ( ” 2 ” ) ; 

71 threeButton . setActionCommand ( ” 3 ” ) ; 

72 fourButton . setActionCommand ( ” 4 ” ) ; 

73 f i v e B u t t o n . setActionCommand ( ” 5 ” ) ; 

74 sixButton . setActionCommand ( ” 6 ” ) ; 

75 sevenButton . setActionCommand ( ” 7 ” ) ; 

76 oneButton . s e t S e l e c t e d ( t r u e ) ; 

77 twoButton . s e t S e l e c t e d ( f a l s e ) ; 

78 threeButton . s e t S e l e c t e d ( f a l s e ) ; 

79 fourButton . s e t S e l e c t e d ( f a l s e ) ; 

80 f i v e B u t t o n . s e t S e l e c t e d ( f a l s e ) ; 

81 sixButton . s e t S e l e c t e d ( f a l s e ) ; 

82 sevenButton . s e t S e l e c t e d ( f a l s e ) ; 

83 

84 S e t t i n g s L i s t e n e r BLis = new S e t t i n g s L i s t e n e r ( ) ;

A.16 TaijiSettings.java 227 

85 okButton . a d d A c t i o n L i s t e n e r ( BLis ) ; 

86 cancelButton . a d d A c t i o n L i s t e n e r ( BLis ) ; 

87 

88 t h i s . pack ( ) ; 

89 } 

90 

91 //Metode der goer d i a l o g e n s y n l i g . 

92 p u b l i c void showIt ( ) 

93 { 

94 s e t V i s i b l e ( t r u e ) ; 

95 } 

96 

97 // L i s t e n e r −k l a s s e n t i l d i a l o g e n . Implementerer i n t e r f a c e t 

A c t i o n L i s t e n e r . 

98 // Giver enten e t s a e t b l o c k s v i d e r e t i l r e s e t i AtaxxModel , 

e l l e r gaar ud a f d i a l o g e n uden at s t a r t e e t nyt s p i l . 

99 c l a s s S e t t i n g s L i s t e n e r implements A c t i o n L i s t e n e r 

100 { 

101 //Metode der r e a g e r e r paa e t ActionEvent . Ved ok gaar den 

v i d e r e t i l at s t a r t e e t nyt s p i l , ved e t h v e r t andet 

event l u k k e s d i a l o g e n . 

102 // Modtager e t ActionEvent som argument . 

103 p u b l i c void actionPerformed ( ActionEvent evt ) 

104 { 

105 i f ( evt . getActionCommand ( ) . e q u a l s (”Ok”) ) 

106 { 

107 i n t s e t = I n t e g e r . p a r s e I n t ( group . g e t S e l e c t i o n ( ) 

. getActionCommand ( ) ) ; 

108 System . out . p r i n t l n (” S e t t i n g ”+s e t ) ; 

109 i f ( s e t == 1) { // Player VS Player 

110 tFrame . tModel . s e t S t a r t e r ( 1 ) ; 

111 tFrame . tModel . setWhitePlayer ( 0 ) ; 

112 tFrame . tModel . s e t B l a c k P l a y e r ( 0 ) ; 

113 } 

114 i f ( s e t == 2) { // Player VS LocalArea 




118 } 

119 i f ( s e t == 3) { // Player VS AlphaBeta 




123 } 

124 i f ( s e t == 4) { // Player VS Growth 




128 } 

129 i f ( s e t == 5) { // LocalAera VS Player 




133 } 

134 i f ( s e t == 6) { // AlphaBeta VS Player

228 Bilag A 




138 } 

139 i f ( s e t == 7) { // Growth VS Player 




143 } 

144 tFrame . tModel . r e s e t ( ) ; 



147 } 

148 e l s e 

149 { 


151 } 

152 } 

153 } 

154 } 

A.17 Tree.java 


2 p u b l i c c l a s s Tree { // denne k l a s s e e r kun anvendt i Minimax AI ’ en 

3 p u b l i c Node Root ; 

4 p u b l i c Node Cur ; // c u r r e n t node 

5 p u b l i c ArrayList evenGen ; 

6 p u b l i c ArrayList oddGen ; 

7 p u b l i c ArrayList Leaves ; 

8 p u b l i c i n t curLeaves ; // Current number o f l e a v e s 

9 p u b l i c i n t t o t a l L e a v e s ; // Temperary number o f l e a v e s . curLeaves 

+newly added l e a v e s . 

10 p u b l i c i n t curMin ; 

11 p u b l i c i n t curMax ; 

12 

13 

14 p u b l i c Tree ( ) { 

15 Root = new Node ( ) ; 

16 Cur = new Node ( ) ; 

17 Leaves = new ArrayList () ; 

18 evenGen = new ArrayList () ; 

19 oddGen = new ArrayList () ; 

20 

21 } 

22 

23 // s a e t t e r roden 

24 p u b l i c void setRoot ( Node n ) { 

25 Root = n ; 

26 } 

27 // s a e t t e r c u r r e n t node 

28 p u b l i c void setCur ( Node n ) { 

29 Cur = n ;

A.17 Tree.java 229 

30 } 

31 

32 // t i l f o e j e r e t blad 

33 p u b l i c void addLeave ( Node n ) { 

34 Leaves . add ( n ) ; 

35 } 

36 

37 p u b l i c void addMin ( Node n ) { 

38 curMin++; 

39 } 

40 

41 

42 p u b l i c void addMax( Node n ) { 

43 curMax++; 

44 } 

45 

46 p u b l i c void resetMin ( ) { 

47 curMin =0; 

48 } 

49 

50 p u b l i c void resetMax ( ) { 

51 curMax=0; 

52 } 

53 

54 p u b l i c void addLeaveT ( Node n ) { 

55 t o t a l L e a v e s ++; 

56 } 

57 

58 p u b l i c void removeLeave ( i n t l ) { 

59 Leaves . remove ( l ) ; 

60 } 

61 

62 p u b l i c void removeLeaveT ( i n t l ) { 

63 t o t a l L e a v e s −−; 

64 } 

65 

66 p u b l i c void removeLeaveC ( i n t l ) { 

67 curLeaves −−; 

68 t o t a l L e a v e s −−; 

69 } 

70 

71 

72 p u b l i c i n t getCurLeaves ( ) { 

73 r e t u r n ( curLeaves ) ; 

74 } 

75 

76 }

230

Bilag B 

B.1 Hjemmesider: 

Taiji beskrivelse p˚a boardgamegeek.com 

http://www.boardgamegeek.com/boardgame/31926 

Sidst besøgt: 1/10-09 

Taiji anmeldelse p˚a ogrecave.com 

http://ogrecave.com/reviews/taiji.shtml 


Opfriskning af Java 

http://javabog.dk/ 


B.2 Bøger: 

Kildeliste 

”Artificial Inteligence - A Moderne Approach - Second Edition” 

af Stuart J. Russel og Peter Norvig

232 Bilag B 

”Introduction to Algorithms - Second Edition” 

af Thmos H. Cormen, Charles E. Leiserson, Ronald L. Rivest og Clifford Stein

233

234

Kunstig Intelligens til Brætspillet Taiji - Danmarks Tekniske Universitet

Create successful ePaper yourself

Delete template?

Save as template?