Künstliche Intelligenz und Lernmethoden in Computerspielen

Künstliche Intelligenz und
Lernmethoden in Computerspielen
Wolfgang Litzlbauer
DIPLOMARBEIT
eingereicht am
Fachhochschul-Masterstudiengang
Digitale Medien
in Hagenberg
im Juni 2006
© Copyright 2006 Wolfgang Litzlbauer
Alle Rechte vorbehalten
ii
Erklärung
Hiermit erkläre ich an Eides statt, dass ich die vorliegende Arbeit selbstständig und ohne fremde Hilfe verfasst, andere als die angegebenen Quellen
und Hilfsmittel nicht benutzt und die aus anderen Quellen entnommenen
Stellen als solche gekennzeichnet habe.
Hagenberg, am 22. Juni 2006
Wolfgang Litzlbauer
iii
Inhaltsverzeichnis
Erklärung
iii
Vorwort
viii
Kurzfassung
ix
Abstract
x
1 Einleitung
1.1 Lernmethoden . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Das Spiel Evolving Ogre . . . . . . . . . . . . . . . . . . . . .
1.3 Inhaltsüberblick . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1
2
2
2 Künstliche Intelligenz in Spielen
2.1 Künstliche Intelligenz (KI) . . . . . .
2.2 Intelligente Agenten . . . . . . . . .
2.2.1 Sensoren oder Eingabe . . . .
2.2.2 Gedächtnis oder Speicher . .
2.2.3 Schlussfolgerung und Analyse
2.2.4 Aktionen oder Ausgabe . . .
2.3 Akademische KI . . . . . . . . . . .
2.4 Spiele-KI . . . . . . . . . . . . . . .
2.4.1 Anforderungen . . . . . . . .
2.4.2 Aufgaben . . . . . . . . . . .
2.4.3 KI-Designer . . . . . . . . . .
2.4.4 Globale KI . . . . . . . . . .
2.4.5 Geschichte . . . . . . . . . . .
2.4.6 Aktueller Stand . . . . . . . .
2.5 Verwendete Techniken . . . . . . . .
2.5.1 A* Pfadfinder . . . . . . . . .
2.5.2 Detailstufen-KI . . . . . . . .
2.5.3 Influence Mapping . . . . . .
2.5.4 Zustandsautomaten . . . . .
2.5.5 Mehrebenen-Architektur . . .
iv
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
5
5
6
6
7
7
10
11
12
12
12
13
15
15
15
16
16
17
17
INHALTSVERZEICHNIS
v
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
18
19
19
19
20
20
21
21
21
3 Lernen und Adaptation
3.1 Maschinelles Lernen . . . . . . . . . . . .
3.1.1 Lernziel . . . . . . . . . . . . . . .
3.1.2 Lernart . . . . . . . . . . . . . . .
3.1.3 Lernmethoden . . . . . . . . . . .
3.1.4 Erfolgsmessgröße . . . . . . . . . .
3.1.5 Anwendungen . . . . . . . . . . . .
3.2 Einsatz in Computerspielen . . . . . . . .
3.2.1 Zwei unterschiedliche Phasen . . .
3.2.2 Adaptation in Computerspielen . .
3.3 Verwendete Techniken . . . . . . . . . . .
3.3.1 Dynamische Entscheidungsbäume .
3.3.2 Spieler-Modellierung . . . . . . . .
3.3.3 Neuronale Netze . . . . . . . . . .
3.3.4 Evolutionäre Algorithmen . . . . .
3.4 Genetische Algorithmen . . . . . . . . . .
3.4.1 Biologische Evolution . . . . . . .
3.4.2 Umsetzung . . . . . . . . . . . . .
3.5 Beispiele . . . . . . . . . . . . . . . . . . .
3.5.1 Black & White . . . . . . . . . . .
3.5.2 Command & Conquer Renegade .
3.5.3 Colin McRae Rally 2.0 . . . . . . .
3.5.4 Re-Volt . . . . . . . . . . . . . . .
3.6 Resümee . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
24
24
25
26
27
28
28
29
31
31
33
33
35
35
36
37
39
40
41
41
41
42
4 Implementierung
4.1 Das Spiel . . . . . . . . . .
4.1.1 Spielphasen . . . . .
4.1.2 Spielobjekte . . . . .
4.1.3 Der Ork . . . . . . .
4.2 Implementierung des Spiels
4.2.1 Crystal Space 3d . .
4.2.2 AIQuest . . . . . . .
4.2.3 Architektur . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
43
43
43
43
45
47
48
48
48
2.6
2.5.6 Scripting . . . . . . . . .
2.5.7 Schwarmverhalten . . . .
2.5.8 Befehlshierarchie . . . . .
2.5.9 Koppelnavigation . . . . .
2.5.10 Hindernis-Umgehung . . .
2.5.11 Trigger-Systeme . . . . .
KI und Spiel-Design . . . . . . .
2.6.1 Designer-kontrollierte KI
2.6.2 Eigenständige KI . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
INHALTSVERZEICHNIS
4.3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
51
51
52
55
56
58
59
60
60
61
62
63
5 Resultate
5.1 Messgrößen . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Testevolution . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1 Evolutionsparameter . . . . . . . . . . . . . . . .
5.2.2 Ergebnisse . . . . . . . . . . . . . . . . . . . . . .
5.2.3 Verlauf . . . . . . . . . . . . . . . . . . . . . . .
5.3 Ork-Evolution . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Evolutionsparameter . . . . . . . . . . . . . . . .
5.3.2 Annahmen . . . . . . . . . . . . . . . . . . . . .
5.3.3 Evolution . . . . . . . . . . . . . . . . . . . . . .
5.3.4 Ergebnis . . . . . . . . . . . . . . . . . . . . . . .
5.3.5 Testspiel . . . . . . . . . . . . . . . . . . . . . . .
5.3.6 Besonderheiten . . . . . . . . . . . . . . . . . . .
5.4 Vorteile . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4.1 Manuelle Einstellung durch den KI-Designer . .
5.4.2 Optimierung durch den genetischen Algorithmus
5.4.3 Vergleich . . . . . . . . . . . . . . . . . . . . . .
5.5 Mögliche Erweiterungen . . . . . . . . . . . . . . . . . .
5.5.1 Referenz-Ork . . . . . . . . . . . . . . . . . . . .
5.5.2 Personalisierung des Orks . . . . . . . . . . . . .
5.5.3 Online Einsatz . . . . . . . . . . . . . . . . . . .
5.5.4 Optimierungstechniken . . . . . . . . . . . . . . .
5.6 Resümee . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
64
64
65
65
66
68
69
69
70
70
73
74
75
75
75
76
76
77
77
77
78
78
79
4.4
4.5
Implementierung der KI . . . . . . . . . . . .
4.3.1 Aktionen . . . . . . . . . . . . . . . .
4.3.2 Ork-Agent . . . . . . . . . . . . . . . .
Implementierung des genetischen Algorithmus
4.4.1 Individuum . . . . . . . . . . . . . . .
4.4.2 Genetische Operationen . . . . . . . .
4.4.3 Evaluierung . . . . . . . . . . . . . . .
4.4.4 Laden und Speichern einer Population
4.4.5 Weiterentwicklung einer Population .
Weiterentwicklung des Orks . . . . . . . . . .
4.5.1 Evaluierung . . . . . . . . . . . . . . .
4.5.2 Evolution . . . . . . . . . . . . . . . .
vi
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6 Schlussbemerkungen
80
6.1 Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2 Erfahrungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
INHALTSVERZEICHNIS
vii
A Ergänzung zum genetischen System
A.1 Individuen als XML-Knoten speichern
A.2 Implementierung der Operationen . .
A.2.1 Selektion . . . . . . . . . . . .
A.2.2 Kreuzung . . . . . . . . . . . .
A.2.3 Mutation . . . . . . . . . . . .
A.2.4 Zufällige Generierung . . . . .
A.3 Laden und Speichern einer Population
A.4 Beispielsanwendung . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
82
82
83
83
83
84
85
85
86
B Mathematische Definitionen
B.1 Suchraum . . . . . . . . . . . . . . . .
B.2 Messgrößen . . . . . . . . . . . . . . .
B.2.1 Population . . . . . . . . . . .
B.2.2 Durchschnitts-Tauglichkeit . .
B.2.3 Distanz . . . . . . . . . . . . .
B.2.4 Durchschnittliches Individuum
B.2.5 Standardabweichung . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
88
88
88
88
88
89
89
89
C User Dokumentation
C.1 Installation . . . . . . . . . . . . . . .
C.1.1 Kopieren auf die Festplatte . .
C.1.2 Evolving Ogre starten . . . . .
C.1.3 Fehlerbehebung . . . . . . . . .
C.2 Spielmodus . . . . . . . . . . . . . . .
C.2.1 Spielmodus starten . . . . . . .
C.2.2 Interface . . . . . . . . . . . . .
C.2.3 Tastaturbelegung . . . . . . . .
C.2.4 Endbildschirm . . . . . . . . .
C.3 Lernmodus . . . . . . . . . . . . . . .
C.3.1 Lernmodus starten . . . . . . .
C.3.2 Übersichtsbildschirm . . . . . .
C.3.3 Training . . . . . . . . . . . . .
C.3.4 Automatischer Modus . . . . .
C.3.5 Übernahme in den Spielmodus
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
91
91
91
91
91
92
92
92
93
95
95
95
95
96
96
96
D Inhalt der CD-ROM
D.1 Diplomarbeit . . .
D.2 Evolving Ogre . . .
D.3 Screenshots . . . .
D.4 Graphiken . . . . .
D.5 Quellen . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
98
98
98
98
99
99
Literaturverzeichnis
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
100
Vorwort
Künstliche Intelligenz ist ein spannendes und aufregendes Forschungsgebiet.
Weit entfernt von den utopischen Visionen mancher Hollywood-Filme, wie
z. B. I, Robot, The Matrix oder A.I., ist der heutige Einsatz jedoch stark eingeschränkt. Trotzdem begegnen wir der künstlichen Intelligenz in unserem
alltäglichen Leben. Das reicht vom sekundenschnellen Suchen eines Begriffes
in einem Online-Lexikon, über die Berechnung der schnellsten Fahrtroute im
Navigationssystem, bis zur Spracherkennung am Computer. Einen breiten
Einsatz findet sie auch in Computerspielen. Der Mensch interagiert darin
mit computergesteuerten Charakteren und findet sich in virtuellen Welten
wieder, die die reale Welt und ihre Bewohner täuschend ähnlich simulieren.
Spielentwicklung und künstliche Intelligenz zählen für mich zu den interessantesten Gebiete der Software-Entwicklung. Mit dieser Arbeit konnte
ich die beiden Bereiche sinnvoll kombinieren. Bei meinen Recherchen entdeckte ich, dass die Möglichkeiten des Einsatzes der künstlichen Intelligenz
in Spielen wenig ausgenutzt werden. Spielentwickler greifen lieber auf altbekannte Methoden zurück, um Risiken zu vermeiden. In dieser Arbeit konnte
ich neue erfolgversprechende Ansätze und Techniken analysieren und später
auch implementieren.
Besonderer Dank gilt meinem Betreuer, Herrn DI Roman Divotkey, der
jederzeit mit Rat und Tat zur Seite stand, und Herrn Dr. Christoph Lürig,
der mir mit seinen Tipps aus der Praxis sehr viel weitergeholfen hat. Weiteren Dank möchte ich meiner Freundin, meinen Freunden, meiner Familie
und meinem Onkel aussprechen. Sie alle haben mich in den letzten Wochen
mit viel Geduld begleitet und verschiedene Versionen dieser Arbeit gelesen,
korrigiert und kommentiert.
viii
Kurzfassung
Künstliche Intelligenz (KI) ist ein wichtiges Element in Computerspielen.
Spiele-KI ist verantwortlich für das natürliche Verhalten der computergesteuerten Figuren in der Spielwelt und trägt daher wesentlich zum Spielerlebnis bei. Eine interessante Möglichkeit, die KI in einem Spiel abwechslungsreicher und herausfordernder zu gestalten, bieten Lernmethoden. Die
KI passt sich an den Spieler an und kann sich im Spiel weiterentwickeln.
In dieser Arbeit wird ein Überblick über den Einsatz von KI in Computerspielen gegeben und die Möglichkeiten von Lernmethoden anhand einer
konkreten Implementierung gezeigt.
Nachdem verwendete Terminologien und in aktuellen Spielen eingesetzte
KI-Techniken wie z. B. A*, Detailstufen KI, Scripting, künstliches Leben
oder endliche Automaten vorgestellt werden, wird auf Lernmethoden näher eingegangen. Neben den Grundlagen des maschinellen Lernens werden
verschiedene Techniken – Genetische Algorithmen, Neuronale Netze, Dynamische Entscheidungsbäume und Spieler-Modellierung – erläutert und einige
herausragende Spiele in diesem Bereich präsentiert.
Das entwickelte Spiel Evolving Ogre zeigt einen möglichen Einsatz von
Lernmethoden und demonstriert darüber hinaus den Einsatz von KI in Computerspielen. Im Spiel wird das Verhalten des computergesteuerten Gegners
mit Hilfe eines genetischen Algorithmus optimiert. Dazu wird ein generisch
aufgebautes genetisches System verwendet, welches in der Arbeit detailliert
beschrieben wird. Dieses System ist in der Lage beliebige Objekte, Daten,
künstliche Lebewesen oder Lösungsansätze evolutionär weiterzuentwickeln.
Durch die Analyse der Ergebnisse des genetischen Algorithmus können
Vor- und Nachteile dieser Lernmethode herausgearbeitet werden. Dabei wird
der Algorithmus gegenüber dem manuellen Einstellen der KI verglichen. Abschließend werden Optimierungstechniken vorgestellt und mögliche Erweiterungen vorgeschlagen.
ix
Abstract
Artificial intelligence (AI) is an important element of computer games. Game
AI is responsible for the authentic behaviour of the computer-controlled
characters in the game world and influences the gameplay significantly.
Learning methods are interesting techniques to produce smarter and more
robust AI. The computer-controlled characters will adapt to the human
player and can learn during the game. This thesis provides an overview
on game AI and demonstrates the possibilities of learning methods on a
specific implementation.
Commonly used terminologies and popular AI techniques in current
games such as A*, level-of-detail AI, scripting, A-Life, and finite state machines are explained. The thesis mainly focuses on learning methods. A basic
knowledge of machine learning is provided and successful methods—genetic
algorithms, neuronal nets, dynamic decision trees and player modeling—are
shown. Outstanding games using these methods are also presented.
Evolving Ogre, a game developed from scratch, demonstrates the use
of learning methods and the implementation of AI in computer games. A
genetic algorithm optimises the behaviour of the computer-controlled characters in the game. A flexible genetic system performs this task and is introduced in detail. This system is able to evolutionarily develop arbitrary
objects, data, artificial creatures and solutions.
An analysis of the results of the genetic algorithm points out the advantages and disadvantages. The algorithm is compared with designer-controlled
approaches to define the AI. Finally some optimisation techniques and possible enhancements are suggested.
x
Kapitel 1
Einleitung
Künstliche Intelligenz (KI) ist ein wichtiges Element in Computerspielen.
Spiele-KI ist verantwortlich für das natürliche Verhalten der computergesteuerten Figuren in der Spielwelt. Sie trägt daher wesentlich zum Spielerlebnis bei und ist für den Erfolg eines Spieles mitverantwortlich.
Bisher wurde die KI aufgrund der hohen Systemauslastung in Spielen
häufig vernachlässigt. Leistungsfähigere Prozessoren ermöglichen heute eine
aufwendige Berechnung der computergesteuerten Spieler. Glaubwürdige KI
wird ein immer wichtigeres Verkaufsargument in Spielen. So wird z. B. in
Oblivion das Leben jedes Bewohners in einer gigantischen Fantasie-Welt
simuliert. In Quake 4 kämpft der Spieler im Team mit intelligenten computergesteuerten Kameraden.
Spiele-KI verwendet Algorithmen aus unterschiedlichen Bereichen und
stellt den Spielentwickler vor eine große Herausforderung. Die Anforderungen sind von Spiel zu Spiel verschieden und erfordern unterschiedliche Ansätze. Höhere Rechenleistungen ermöglichen neue Techniken, die bisher in
Spielen nur beschränkt eingesetzt werden konnten. Emotionen, intelligente
Agenten und Lernmethoden bieten dem Spielentwickler neue Möglichkeiten, um das Spiel spannender, abwechslungsreicher und herausfordernder zu
gestalten.
1.1
Lernmethoden
Lernmethoden und Adaptation gehören sicherlich zu den erfolgversprechendsten Techniken in zukünftigen Spielen. Die KI passt sich an das Verhalten
des Spielers an oder lernt im Spiel dazu. Die Spiele Black & White I und II
zeigen, welches Potential hinter dieser Technik steckt. Der Spieler übernimmt
die Erziehung einer Kreatur und bestimmt dessen Verhalten im Spiel. Doch
Lernmethoden können auch in der Entwicklungsphase eines Spieles hilfreich
eingesetzt werden. Anstatt die KI langwierig einzustellen, wird sie im Spiel
trainiert. Die KI lernt dabei selbstständig, wie sie sich am besten verhalten
1
KAPITEL 1. EINLEITUNG
2
soll. Das Lernen erfolgt vor Veröffentlichung des Spieles und kann daher gut
kontrolliert werden. Eine interessante Möglichkeit, wie dieses Training umgesetzt werden kann, sind evolutionäre Algorithmen. Ein KI-Charakter wird
dabei ähnlich der natürlichen Evolution entwickelt und steht im Konkurrenzkampf mit anderen.
1.2
Das Spiel Evolving Ogre
Das entwickelte Spiel Evolving Ogre zeigt einen möglichen Einsatz von Lernmethoden und demonstriert darüber hinaus den Einsatz von KI in Computerspielen. In dem Spiel schlüpft der Spieler in die Rolle eines tapferen Ritters
und muss einen gefräßigen Ork bekämpfen. Der Ork wird zuvor trainiert und
stellt für den Spieler eine abwechselnde Herausforderung dar. Im Lernmodus werden Orks mit einem genetischen Algorithmus – eine Unterkategorie
der evolutionären Algorithmen – weiterentwickelt und der erfolgreichste Ork
tritt im eigentlichen Spiel gegen den Spieler an. Die Idee und der Lernansatz
basieren auf dem in [16] vorgestellten genetischen Algorithmus.
Evolving Ogre verwendet ein eigenständiges genetisches System, um die
Evolution des Orks zu simulieren. Dieses System ist generisch aufgebaut und
kann in anderen Spielen einfach eingesetzt werden. Evolving Ogre zeigt, wie
Lernmethoden in Spielen eingesetzt werden können und welche Vorteile sie
bieten.
1.3
Inhaltsüberblick
Kapitel 2, Künstliche Intelligenz in Spielen“ gibt einen Überblick
”
über künstliche Intelligenz im Allgemeinen und deren Einsatz in Computerspielen. Verwendete Terminologien werden erläutert, mögliche Einbettungen
in Spielen werden demonstriert und der aktuelle Stand wird erörtert. Abschließend werden aktuelle Techniken in diesem Bereich vorgestellt.
Kapitel 3, Lernen und Adaptation“ beschäftigt sich mit Lernmetho”
den in Computerspielen. Es werden die Grundlagen des maschinellen Lernens
erklärt und der Einsatz in Computerspielen gezeigt. Verschiedene Techniken
werden vorgestellt und einige herausragende Spiele in diesem Bereich präsentiert. Theorie und Funktionsweise des genetischen Algorithmus werden
näher erläutert. Vorteile und Möglichkeiten von Lernmethoden werden hervorgehoben.
Kapitel 4, Evolving Ogre“ zeigt eine mögliche Implementierung des
”
genetischen Algorithmus im Spiel Evolving Ogre. Das Spiel wird erklärt und
die Umsetzung der künstlichen Intelligenz im Spiel gezeigt. Ein genetisches
System wird detailliert vorgestellt und dessen Einsatz im Spiel erörtert.
KAPITEL 1. EINLEITUNG
3
Kapitel 5, Resultate“ fasst die Ergebnisse des genetischen Algorithmus
”
zusammen. Der Verlauf der simulierten Evolution wird anhand einer Testevolution und der Ork-Evolution in Evolving Ogre analysiert. Auf Besonderheiten im Verlauf wird hingewiesen. Vorteile und mögliche Erweiterungen
des Algorithmus werden vorgestellt.
Anhang A, Ergänzung zum genetischen System“ zeigt Details zur
”
Implementierung des genetischen Algorithmus.
Anhang B, Mathematische Definitionen“ fasst wichtige Messgrößen
”
des genetischen Algorithmus zusammen.
Anhang C, User Dokumentation“ gibt einen Überblick über das In”
stallieren und Verwenden von Evolving Ogre.
Anhang E, Inhalt der CD-ROM“ gibt einen Überblick über den In”
halt der beiliegenden CD-ROM.
Kapitel 2
Künstliche Intelligenz in
Computerspielen
2.1
Künstliche Intelligenz (KI)
Intelligenz ist die Verknüpfung und Anwendung verschiedener Fähigkeiten,
die es dem Menschen ermöglichen, Probleme mit beschränkten Mitteln zu
lösen [14]. Wichtige Fähigkeiten sind z. B. das Lernen, abstraktes Denken,
Planung, Vorstellungskraft und Kreativität.
Die künstliche Intelligenz (KI) versucht, diese Fähigkeiten maschinell
nachzubilden. Man versteht unter diesem Begriff auch eine Sammlung verschiedener Techniken, die es Maschinen ermöglichen, Lösungen für komplexe
Probleme in Menschen-ähnlicher Form zu finden. Dabei werden Eigenschaften der menschlichen Intelligenz in für den Computer verständliche Algorithmen umgewandelt. Man unterscheidet zwei Formen der künstlichen Intelligenz:
Starke KI: Sie soll wie der Mensch nachdenken und Probleme lösen. In
weiterer Form soll sie über ein Bewusstsein verfügen und Emotionen
haben. Die Ziele der starken KI sind nach Jahrzehnten der Forschung
illusionär und vom technischen Fortschritt unbeeindruckt geblieben.
Schwache KI: Diese soll konkrete Anwendungsprobleme meistern und simuliert intelligentes Verhalten mit Mitteln der Mathematik und der
Informatik. Es geht nicht um die Schaffung von Bewusstsein oder um
ein tieferes Verständnis von Intelligenz.
Während die starke KI an ihrer philosophischen Fragestellung bis heute
scheiterte, sind auf der Seite der schwachen KI in den letzten Jahren bedeutende Fortschritte erzielt worden. Neben den Forschungsergebnissen der
Kerninformatik selbst sind in die KI Ergebnisse der Psychologie und Neurologie, Mathematik und Logik, Kommunikationswissenschaft, Philosophie
4
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
5
und Linguistik eingeflossen. Man unterscheidet zwischen mindestens vier
verschiedenen Intelligenzarten:
Visuelle Intelligenz: Erkennung von Bildern, Mustern und Formen.
Sprachliche Intelligenz: Sprachsynthese und Spracherkennung, Umwandlung von Text in Sprache und umgekehrt.
Manipulative Intelligenz: Verrichtungen, Tätigkeiten und Bewegungssteuerung (z. B. Schweiß- und Lackierarbeiten von programmierbaren
Automaten in Fabriken).
Rationale Intelligenz: Schlussfolgerungen an Hand der vorher eingespeicherten Fakten (z. B. medizinische Computerdiagnose).
2.2
Intelligente Agenten
Der Agent ist ein virtueller Charakter in der Welt [3]. In Computerspielen werden Agenten für die Gegner, computergesteuerte Charaktere oder
Kameraden verwendet. Ein Agent kann aber auch die Hauptsteuereinheit in
einem Strategiespiel sein. Somit muss es sich nicht zwangsläufig um eine einzelne Einheit in der Spielwelt handeln. Das Ziel des Agenten ist ein realistisches Verhalten seines Charakters. Um besonders glaubwürdige Ergebnisse
zu erzielen, ist der Agent ähnlich dem menschlichen Gehirn aufgebaut und
berücksichtigt biologische Strukturen. Er besteht aus vier Komponenten:
• Sensoren oder Eingabe
• Gedächtnis oder Speicher
• Schlussfolgerung und Analyse
• Aktionen oder Ausgabe
2.2.1
Sensoren oder Eingabe
Um entsprechende Schlussfolgerungen zu ziehen, muss der Agent über die
Umgebung informiert werden. Dabei kann er die Welt mit Sensoren wahrnehmen, oder er erhält die Informationen als Eingabe. Die Art der Informationen hängt von der jeweiligen Anwendung oder dem Spiel ab. Ein Computergegner in einem Ego-Shooter benötigt andere Informationen als die
Hauptsteuereinheit in einem Strategiespiel:
Computergegner in einem Ego-Shooter
• Wo befindet sich der Gegner?
• Wie sieht die Geometrie der Umgebung aus?
• Welche Waffen habe ich zur Verfügung?
• Wie ist mein Zustand (z. B. Gesundheitszustand)?
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
6
Hauptsteuereinheit in einem Strategiespiel
• Wie ist die Machtverteilung auf der Landkarte?
• Wie viele Ressourcen habe ich zur Verfügung?
• Welche Einheiten kann ich bauen und welche Eigenschaften haben
diese?
• Welche Technologien kann ich erforschen?
• Wie sieht die Geometrie der Spielwelt aus?
Diese Informationen können teilweise sehr aufwendig zu berechnen sein.
Daher zählt dieser Teil zu den rechenintensivsten Bereichen der KI.
2.2.2
Gedächtnis oder Speicher
Um bessere Schlussfolgerungen zu ziehen, muss der Agent Informationen abspeichern können und über ein Gedächtnis verfügen. Ansonsten kann er seine
Schlussfolgerung nur aufgrund der aktuellen Informationen ziehen, ohne dabei auf vorhergehende Ergebnisse zurückzugreifen. Es gibt eine Vielzahl
von Informationen, die sich der Agent merken muss und die unterschiedlich schwierig zu speichern sind. Hier einige Beispiele:
• Aktueller Zustand: Was mache ich gerade?
• Ziele: Welche Ziele verfolge ich?
• Beobachtungen: Zum Beispiel letzte Position des Gegners, Gegenstände in der Welt.
• Abbildung der Welt: Wo befinde ich mich in der Welt? Welche
Gebiete habe ich schon erkundet?
• Abstrakte Informationen: Kräfteverhältnis in der Welt.
2.2.3
Schlussfolgerung und Analyse
Der wichtigste Teil des Agenten analysiert die aktuellen Informationen und
das Gedächtnis, um Entscheidungen zu treffen und damit die passenden Aktionen zu wählen. Dieser Prozess kann je nach Möglichkeiten, Datendichte
und verwendeten Algorithmen sehr umfangreich werden. In einem Schachspiel muss der Agent zwischen 20 und 50 verschiedenen Möglichkeiten wählen. In einem Ego-Shooter sind es nur ein paar wenige. Glücklicherweise
reichen meist einige einfache Methoden zur Entscheidungsfindung aus, um
passable Ergebnisse zu erzielen.
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
2.2.4
7
Aktionen oder Ausgabe
Mit Aktionen kann der Agent die Welt beeinflussen. Mögliche Aktionen sind
z. B. bewegen, Gegenstand benützen oder eine Einheit befehligen. Die Intelligenz eines Agenten wird durch seine Aktionen wahrgenommen. Sie sind
für eine glaubwürdige Intelligenz sehr wichtig und machen die Absichten
des Agenten sichtbar. Sie bieten auch eine Möglichkeit dem Agenten eine
Persönlichkeit zu geben. In Super Mario Bross wurden alle Kreaturen mit
derselben KI gesteuert, hatten aber unterschiedliche Aktionen. Durch individuelle Bewegungsaktionen wurden sie vom Spieler verschieden wahrgenommen und erhielten eine eigene Persönlichkeit, obwohl die Logik dieselbe
war.
2.3
Akademische KI
Mit akademischer KI (Academic AI oder Mainstream AI) wird die wissenschaftliche Auseinandersetzung mit der künstlichen Intelligenz bezeichnet.
Dieses Gebiet umfasst zahlreiche Unterdisziplinen, die sich oft ideologisch
entgegenstehen. Die nachfolgende Aufzählung beschreibt einige der wichtigsten Konzepte und Methoden, die zum Teil auch in Spielen verwendet
werden. Ein genauer Überblick findet sich in [24, 27].
Expertensysteme
Expertensysteme (Expert Systems) versuchen das Wissen von menschlichen
Experten in einem bestimmten Gebiet zu simulieren. Das System speichert
das Expertenwissen in seiner Wissensdatenbank und kann anhand dieser
automatische Schlussfolgerungen ziehen. Es ist in der Lage, gleiche Antworten wie ein menschlicher Experte zu erzeugen. Zum Einsatz kommen diese
Systeme z. B. in der Medizin.
Fallbasiertes Schließen
Fallbasiertes Schließen (Case-based Reasoning) analysiert ein Problem und
versucht die beste Lösung zurückzugeben. Das Ziel ist, zur Lösung eines
gegebenen Problems die Lösung eines ähnlichen und früher bereits gelösten
Problems heranzuziehen. Das System speichert dazu in einer Datenbank
gefundene Lösungen und greift darauf zurück. Dieses Prinzip ist auch beim
Menschen beobachtbar. Neue Situationen werden mit ähnlichen vergangenen
Erfahrungen verglichen.
Endliche Automaten
Endliche Automaten (Finite-state Machines) sind regelbasierte Systeme mit
einer beschränkten Anzahl an Zuständen“. Es kann immer nur genau ein
”
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
8
Zustand zur selben Zeit aktiv sein. Der Übergang zwischen den Zuständen
wird mit Transitionen“ definiert.
”
Regel- und Produktionssysteme
Regel- und Produktionssysteme (Rule- and Production Systems) verfügen
über eine Datenbank mit Regeln. Jede Regel beinhaltet beliebig komplexe
Bedingungen und eine Reihe von Aktionen, die ausgeführt werden sollen,
wenn diese Bedingungen erfüllt sind. Diese Systeme bestehen hauptsächlich
aus eine Liste von wenn/dann“-Anweisungen. Zusätzlich sind einige Kon”
fliktlösungsmechanismen erforderlich, da mehrere Regeln gleichzeitig erfüllt
sein können. Diese Mechanismen bestimmen dann, welche Regel zutrifft und
somit welche Aktionen ausgeführt werden.
Entscheidungsbäume
Entscheidungsbäume (Decision Trees) sind den komplexen wenn/dann“”
Bedingungen sehr ähnlich. Die Entscheidung wird anhand der Eingangsparameter getroffen. Beginnend bei der Wurzel des Baumes wird bei jedem
Knoten ein Unterknoten ausgewählt. Dabei bestimmen die Eingangsparameter, welcher Knoten ausgesucht wird. Die Algorithmen ID3 und C4.5 können
Entscheidungsbäume anhand von Beispieldaten automatisch konstruieren.
Suchmethoden
Suchmethoden (Search Methodes) finden eine Sequenz von Aktionen oder
Zuständen innerhalb eines Graphen. Um ein bestimmtes Ziel zu erreichen,
muss ein Ziel-Zustand“ definiert werden. Auch ist es möglich, bei der Suche
”
einen bestimmten Wert zu maximieren ohne das genaue Ziel zu definieren.
Bekannte Algorithmen sind z. B. Greedy Search oder A*.
Planungssysteme
Planungssysteme (Planning Systems und Scheduling Systems) sind eine Erweiterung der Suchmethoden, um die beste Sequenz von Aktionen über einen
bestimmten Zeitraum zu finden. Diese Aktionen können dabei von einander
abhängig sein. Der Anfangszustand der Welt und die genauen Auswirkungen
jeder möglichen Aktion sind genau definiert. Somit ist es möglich, komplizierte Handlungen zu planen. Eine Möglichkeit, die Welt und Aktionen zu
spezifizieren, bietet die Beschreibungssprache STRIPS, die in [6] erstmals
definiert wurde.
Beispiel: Der Agent muss sich selbstständig anziehen. Er hat dafür folgende Aktionen zur Verfügung: Linke Socke anziehen“, Rechte Socke anzie”
”
hen“, Linken Schuh anziehen“, Rechten Schuh anziehen“. Der Agent muss
”
”
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
9
nun die richtige Reihenfolge finden, um erfolgreich zu sein. Bevor er den
rechten Schuh anzieht, muss er also den rechten Socken anziehen.
Multiagentensystem
Bei einem Multiagentensystem (Multi-agent System) handelt es sich um ein
System aus mehreren gleichartigen oder unterschiedlich spezialisierten Agenten, die miteinander interagieren können. Die Agenten können kollektiv ein
Problem lösen oder sich gegenseitig konkurrieren.
Prädikatenlogik
Die Prädikatenlogik (First-order Logic) ermöglicht über andere Agenten, in
der Welt Schlussfolgerungen zu ziehen. Die Welt besteht aus Objekten“ mit
”
individuellen Identitäten und unterschiedlichen Eigenschaften“. Beziehun”
”
gen“ definieren das Verhältnis zwischen den Objekten.
Künstliches Leben
Künstliches Leben (Artifical Life oder A-Life) wendet die Eigenschaften und
Fähigkeiten des Lebens in einem Multiagentensystem an. Wie in der realen
Welt wird der Lebenszyklus von künstlichen Lebewesen in einer virtuellen
Welt simuliert. Ein bekanntes Spiel in diesem Gebiet ist Creatures von dem
englischen Computerforscher Steve Grand.
Schwarmverhalten
Das Schwarmverhalten (Flocking) ist eine Unterkategorie des künstlichen
Lebens und beschäftigt sich mit der koordinierten Bewegung von Agenten
in einem Multiagentensystem. Dabei imitiert man das natürliche Verhalten
von Schwärmen und Herden. Interessant ist dieses Gebiet auch in Zusammenhang mit Partikel-Systemen.
Robotik
Die Robotik (Robotics) ermöglicht einer Maschine, mit der echten Welt zu
interagieren. Es ist eines der ältesten und erfolgreichsten Gebiete der künstlichen Intelligenz. In der Robotik wird zwischen zwei Systemen – Steuerungssystem (Ausgabe) und Sensorsystem (Eingabe) – unterschieden.
Evolutionäre Algorithmen
Evolutionäre Algorithmen (Evolutionary Algorithms) versuchen den Prozess
der Evolution zu imitieren. Selektion, Mutation und Kreuzung werden auf
eine Reihe von Parametern angewendet, um im Laufe der Zeit die beste
Kombination zu finden. Dies ist mit teils beachtlichen Ergebnissen auch bei
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
10
Algorithmen und Programmen möglich, wie in [13] genauer nachzulesen ist.
Eine genaue Beschreibung ist in Abschnitt 3.3.4, Evolutionäre Algorithmen“
”
zu finden.
Maschinelles Lernen
Maschinelles Lernen (Machine Learning) ist ein Oberbegriff für die künst”
liche“ Generierung von Wissen aus Erfahrung. Ein künstliches System lernt
aus Beispielen und kann nach Beendigung der Lernphase verallgemeinern.
Das heißt, es lernt nicht einfach die Beispiele auswendig, sondern es erkennt“
”
Gesetzmäßigkeiten in den Lerndaten. So kann das System auch unbekannte
Daten beurteilen. Auf die Grundlagen des maschinellen Lernens wird in Abschnitt 3.1, Maschinelles Lernen“ näher eingegangen.
”
Neuronale Netze
Neuronale Netze (Neural Networks oder Neural-Net) basieren auf den neuronalen Verbindungen im biologischen Hirn und Nervensystem. Das Netzwerk
funktioniert mit laufender Adjustierung der internen numerischen Parametern oder Gewichtungen zwischen den verbundenen Komponenten. Dadurch
ist es möglich, eine beinahe optimale Antwort auf eine große Anzahl von Aufgaben zu erlernen. Eine genaue Beschreibung ist in Abschnitt 3.3.3, Neu”
ronale Netze“ zu finden.
Fuzzy-Logik
Anstatt boolescher Werte (Wahr oder Falsch) werden in der Fuzzy-Logik
(Fuzzy Logic) Gleitkommazahlen verwendet, um die Zugehörigkeit zu einer
Gruppe oder Klasse anzugeben. Dies ermöglicht den Grad einer Zugehörigkeit festzulegen, um gute Schlussfolgerungen zu erzielen.
Bayes’sche Netze
Bayes’sche Netze (Belief Networks oder Bayesian Inference) dienen der Repräsentation von unsicherem Wissen und ermöglichen daraus Schlussfolgerungen. Zwischen verschiedenen Ereignissen werden ursächliche Zusammenhänge definiert. Damit können trotz Ungewissheit oder fehlender Informationen
Rückschlüsse gezogen oder die wahrscheinlichen Auswirkungen einer Aktion
bestimmt werden.
2.4
Spiele-KI
Die Spiele-KI unterscheidet sich stark von der akademischen KI. Während
die akademischen KI korrekte“ Ergebnisse zum Ziel hat, ist es in der Spiele”
KI nur wichtig, intelligentes Verhalten vorzutäuschen. Solange das Verhal-
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
11
ten des Computergegners vom Spieler als glaubwürdig wahrgenommen wird,
kann die KI auch falsche Ergebnisse liefern. Dadurch können schnellere Techniken eingesetzt werden. Einfache Wahrscheinlichkeitstabellen, vorgerechnete Aktionsfolgen oder vordefinierte Ereignisse ermöglichen es mit einfachen Mitteln, den Computergegner intelligent wirken zu lassen. Trotzdem
werden viele Algorithmen aus der akademischen KI für Spiele angepasst.
2.4.1
Anforderungen
Bei der Entwicklung von Spiele-KI gibt es vier Herausforderungen, die sich
meist gegenüber stehen.
Optimale und richtige Lösung
Die KI muss die optimale und richtige Lösung für ein Problem finden. In
einem Strategie-Spiel muss z. B. der schnellste Weg von A nach B gefunden
werden. In einem Ego-Shooter muss die richtige Angriffsposition ermittelt
werden. Nur eine KI, die in der Lage ist, die richtigen Entscheidungen zu
treffen, stellt für den Spieler eine Herausforderung dar.
Glaubwürdigkeit
Da die KI meist menschliche Gegner simuliert, muss sie auch menschlich handeln. Ein computergesteuerter Spieler, der immer die beste Variante wählt,
wirkt unrealistisch. Es ist z. B. unwahrscheinlich, dass ein Mensch in einem
unbekannten Terrain sofort den schnellsten Weg findet. Auch wird er seine
Gegner nicht jedes Mal mit einem perfekten Treffer eliminieren können. Die
KI muss dies berücksichtigen. Da der Mensch fehleranfällig ist, muss die KI
ebenfalls Fehler zulassen. Ein perfekter Computergegner ist nicht nur unglaubwürdig, er zerstört auch die Spielermotivation. Der Spieler wird mit
einem übernatürlichen Gegner konfrontiert, den man kaum besiegen kann.
Unterhaltung
Die KI stellt einen wichtigen Teil des Spieles dar und muss die Geschicke des
Spielers herausfordern. Die Spieler sind verschieden und haben unterschiedliche Stärken und Schwächen. Dies muss bei der Entwicklung berücksichtigt
werden, damit die KI weder unbesiegbar noch zu einfach für die einzelnen
Spieltypen ist. Durch Emotionen, Nachahmung spannender oder lustiger Situationen (z. B. Hinterhalt, Überraschungsangriff) kann die Spielatmosphäre
stark verbessert werden.
Beschränkte Ressourcen
Echtzeit-Spiele sind rechenintensive Anwendungen. Neben der KI müssen
viele andere Aufgaben erledigt werden. Für die Berechnung der Compu-
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
12
tergegner bleibt meist nur wenig Zeit. Aber auch in anderen Spielen will
der Spieler nicht endlos auf die Entscheidung der KI warten. Schnelle Algorithmen sind wichtig, um die Aktualisierung der KI rasch und ohne großen
Ressourcenverbrauch durchzuführen. Neue Spiele müssen eine große Anzahl
eigenständiger Agenten gleichzeitig behandeln können.
2.4.2
Aufgaben
In Spielen übernimmt die KI die komplette Steuerung eines computergesteuerten Charakters. Die KI muss drei Grundaufgaben erfüllen [2]:
Grundverhalten: Aufnahme von Spielelementen, Betätigung von Schaltern, Benutzung von Objekten, Mimen von Gestiken und korrekte Animation des Charakters.
Bewegung: Bewegung innerhalb der Spielwelt, Vermeidung von Hindernissen und richtige Benützung von Türen und Liften.
Entscheidungen: Analyse der Spielwelt, Festlegung der Aufgaben eines
computergesteuerten Charakters, Ermittlung, welche Aktionen notwendig sind und in welcher Reihenfolge sie ausgeführt werden müssen.
2.4.3
KI-Designer
Der KI-Designer ist für den richtigen Einsatz der KI in einem Spiel verantwortlich. Er muss den Einsatz planen, die benötigten Techniken implementieren, die Integration der KI im Spiel abstimmen und die KI richtig
einstellen. In größeren Projekten wird diese Aufgabe von mehreren Personen wahrgenommen. Grundsätzlich kann zwischen zwei Bereichen unterschieden werden – der Implementierung der KI und der Anwendung der KI.
Während die Implementierung die notwendigen Techniken (z. B. Pfadfinder,
Entscheidungsbaum, Trigger-System) zur Verfügung stellt, müssen bei der
Anwendung diese Techniken richtig eingesetzt werden. Eine Beschreibung
der Techniken erfolgt in Abschnitt 2.5, Verwendete Techniken“. So müssen
”
die Pfade definiert, die Entscheidungsbäume konstruiert und die verschiedenen Trigger platziert werden. Diese Aufgaben werden häufig vom Spiel- und
Level-Designer übernommen. Im weiteren Verlauf der Arbeit wird jedoch
allgemein der Begriff KI-Designer verwendet.
2.4.4
Globale KI
Mit der globalen KI wird die grundlegende Steuerungsebene der KI bezeichnet. Die Ebene ist die Schnittstelle zwischen den Agenten und dem Spiel.
Sie initialisiert die Agenten, sorgt für deren Aktualisierung, berechnet deren Sensoren und sorgt für die Umsetzung ihrer Aktionen. Auch kann die
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
(a)
(b)
(c)
(d)
13
Abbildung 2.1: (a) In Pac-Man bewegen sich die Geister in einem Labyrinth. (b) In dem Echtzeit-Strategie Warcraft muss die KI strategische Entscheidungen treffen. (c) Die Soldaten in HalfLife koordinieren ihr Verhalten.
(d) In Die Sims wird das Leben der Hausbewohner simuliert.
Ebene die Agenten direkt beeinflussen oder manipulieren. In einfachen Spielen übernimmt die globale KI direkt die Steuerung der einzelnen computergesteuerten Einheiten. In diesem Fall werden keine Agenten benötigt.
2.4.5
Geschichte
Die Geschichte der Spiele-KI beginnt einige Jahre nach dem Erscheinen der
ersten Computerspiele. Die Screenshots einiger herausragender Spiele in diesem Bereich finden sich in Abbildung 2.1. Es folgt eine zeitliche Übersicht
über wichtige Entwicklungen.
1960 - 1970 In den ersten Computerspielen Spacewar, Pong und Gotcha
wurde keine KI benötigt, da es nur einen Wettkampf zwischen
zwei Spielern gab.
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
14
1974
Das erste beachtenswert Spiel mit Computergegner war Atari
Quak (Entenjagd) und Pursuit (Nahkampf-Simulation). Die
Gegner bewegten sich anhand gespeicherter Bewegungsmuster.
1978
In Space Invaders wurden die Bewegungsmuster stark erweitert. In dem Spiel mussten außerirdische Flugzeuge abgeschossen werden. Die Zufallszahl wurde mit einer Hashfunktion
über die letzten Benutzereingaben ermittelt, da die HardwareUnterstützung dafür fehlte.
1980
Pac-Man erweiterte das System der Bewegungsmuster für sein
Labyrinth. Die verschiedenen Gegner hatten zusätzlich unterschiedliche Persönlichkeiten.
1983
Zum ersten Mal gelang es einem Computer, einen Menschen
im Schach zu schlagen.
1980 - 1990 Anspruchsvolle Sportspiele wie z. B. Madden Football, Earl
Weaver Baseball und Tony La Russa Baseball trieben die
Spiele-KI voran. Diese Spiele verwendeten Expertensysteme,
um das Coaching einer Sportmannschaft besonders realistisch
zu gestalten.
ab 1990
Neue Spielgenres erforderten neue KI-Werkzeuge. Endliche
Automaten und Entscheidungsbäume wurden vermehrt eingesetzt. Echtzeit-Strategie-Spiele (Command & Conquer, WarCraft) strapazierten die KI mit unvollständigen Informationen, Pfadfinder-Problemen, Echtzeit-Entscheidungen und
wirtschaftlicher Planung beim Basisbau. Einige Anforderungen konnten erst spät gelöst werden. Dune II verwendete z. B.
zahlreiche Cheats1 , um Schwächen der KI auszugleichen.
1996
Das Spiel Creatures von dem englischen Computerforscher
Steve Grand befasste sich mit der Simulation von künstlichem
Leben. Dabei kamen neuronale Netze und genetische Algorithmen zum Einsatz. Battlecruiser 3000AD verwendete zum ersten Mal neuronale Netze in einem Aktionspiel.
1997
Der Schachcomputer Deep Blue besiegte den Schachweltmeister Garry Kasparov im Schach.
1999
Die taktische KI des Ego-Shooters Half-Life ermöglichte koordinierte Angriffe der gegnerischen Soldaten und gilt als richtungweisend in diesem Genre.
2000
In Die Sims zeichneten sich die simulierten Bewohner durch
detaillierte Persönlichkeiten aus. Das Spiel demonstrierte eindrucksvoll das Potential neuer KI-Techniken wie z. B. künstliches Leben, Fuzzy-Zustandsautomaten.
1
Der Computer schummelt“ und verschafft dem computergesteuerten Gegner einen
”
Vorteil gegenüber dem Spieler (z. B. durch unbegrenzte Geldmittel).
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
2001
2.4.6
15
Black & White evaluierte das Verhalten des Spielers und berücksichtigte die Ergebnisse im weiteren Spielverlauf. Der Spieler übernahm die Erziehung einer Kreatur, die sein Verhalten
imitiert und von seinem Erzieher lernt.
Aktueller Stand
Viele Experten sehen die Entwicklung der Spiele-KI ähnlich der 3D-Grafik
in Computerspielen. Früher wagten sich nur wenige Firmen an dieses komplexe Gebiet. Die beschränkten Ressourcen der damaligen Computer stellten ein beinahe unüberwindbares Hindernis dar. Trotzdem meisterten einige Pioniere diese Herausforderung2 . Anfängliche Fehler und Beschränkungen wurden nach und nach eliminiert. Neue Algorithmen und umfangreiche
Hardware-Unterstützung ermöglichen in heutigen Computerspielen fast fotorealistische Graphiken und atemberaubende Effekte.
In der Spiele-KI befindet man sich noch im ersten Stadium. Zwar gibt es
einige gut funktionierende und breit eingesetzte Techniken, doch die wirkliche Revolution ist noch ausgeblieben [2]. Leistungsfähigere Prozessoren ermöglichen immer aufwendigere Berechnungen. Auf neuen Mehrkernprozessoren kann die KI in einem eigenen Prozessorkern abgearbeitet werden. Aus
der akademischen KI bekannte Algorithmen können damit leichter in Spiele
eingesetzt werden.
Ähnlich wie in der 3D-Graphik gibt es Versuche für Spiele, allgemein
gültige KI-Engines3 zu entwickeln. Beispiele dafür finden sich in [4, 26]. Da
die Aufgaben und Herausforderungen der KI zwischen den Spielen stark
variieren, wird dies als sehr schwierig angesehen. Erfolgsversprechender sind
KI-Engines, die auf ein Spielgenre spezialisiert sind [27].
2.5
Verwendete Techniken
In der Spiele-KI kommen eine Vielzahl bekannter Techniken oder Methoden
zum Einsatz. Diese werden seit längerer Zeit erfolgreich eingesetzt und stellen die Grundbausteine der Spiele-KI dar. Ein detailierter Überblick findet
sich in [22, 23].
2.5.1
A* Pfadfinder
Der A* Pfadfinder (A* Pathfinder) Algorithmus wird verwendet, um den
optimalen Pfad in einer Umgebung zu finden. Die Besonderheit des A*Algorithmus ist, dass er im Gegensatz zu den uninformierten Suchalgorithmen zielgerichtet sucht. Er betrachtet von den vielen möglichen Wegen, die
2
3
net.
id Software setzte mit Wolfenstein 3D und Doom neue Maßstäbe in der Spielgraphik.
Als Engine werden die dem Spiel zu Grunde liegende Programmbibliotheken bezeich-
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
16
zum Ziel führen könnten, tatsächlich nur sehr wenige und findet das Ziel daher im Allgemeinen sehr schnell. Verglichen mit anderen Suchalgorithmen
ist A* der schnellste, der immer den optimalen Pfad findet.
Zunächst muss die Umgebung in einer Datenstruktur abgebildet werden.
Es gibt unterschiedliche Ansätze, wie genau die Welt in diesem Suchraum
repräsentiert wird. Rechteckige Gitternetze, Quadtree, Teilung des Raums
in konvexe Polygone sind populäre Methoden. Der Algorithmus findet den
Weg von A nach B als Liste von Wegpunkten, die der Agent verwenden
kann, um zum Ziel zu gelangen.
In Spielen wird A* besonders auf Geschwindigkeit optimiert. Es gibt aber
auch Varianten, um ästhetischere Resultate zu berechnen. Anstatt einem
abgehackten Pfad wird dabei ein abgerundeter Weg ermittelt.
2.5.2
Detailstufen-KI
Detailstufen-KI (Level-of-detail AI) skaliert den Rechenaufwand für einen
Agenten je nach seiner Wichtigkeit. Detailstufen (Level-of-detail) sind eine
wichtige Optimierungstechnik in der 3D-Graphik. Dabei wird die Polygonanzahl der Modelle je nach der Entfernung zur Kameraposition verringert.
Herangezoomte Modelle verwenden mehr Polygone als weiter entfernte. Dies
beschleunigt die Graphikberechnung enorm ohne merkbare Verschlechterung
der Graphik. Dasselbe Prinzip kann in Multiagentensystem ebenfalls verwendet werden. Aufwendige KI wird nur für Agenten, die sich in Sichtbereich
des Spielers befinden, verwendet.
Es gibt unterschiedliche Methoden Detailstufen in der KI zu realisieren.
Eine Möglichkeit ist die Aktualisierungsrate eines Agenten abhängig von der
Nähe des Spielers zu variieren. Auch ist es möglich, vereinfachte Methoden
für unsichtbare Agenten zu verwenden. Anstatt aufwendige Pfade zu berechnen, bewegen sich die Agenten auf geraden Linien. Diese Technik wird vor
allem in Echtzeit-Strategie-Spielen mit vielen Agenten eingesetzt.
2.5.3
Influence Mapping
Eine Influence Map stellt die Machtverteilung in der Spielwelt dar. Diese
kann von der KI verwendet werden, um strategisch wichtige Positionen zu
ermitteln. Üblicherweise wird dabei ein zwei-dimensionales Gitter über die
Landschaft gelegt. Innerhalb der Zellen wird die Anzahl der Einheiten in
diesem Bereich ermittelt und damit der Einfluss der Zelle bestimmt. Auch
wird angenommen, dass die Einheiten einen Einfluss auf die Nachbarzellen
haben. Damit gibt das 2D-Netz einen genauen Überblick über die Stärke
und Position der verschiedenen Kräfte.
Influence Maps können sowohl für die Angriffs- als auch Defensiveplanung verwendet werden. Die KI kann damit neutrale Routen zum Gegner
oder Schwachstellen in der eigenen Verteidigung finden. Influence Maps kön-
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
17
nen aber auch für gewaltlose Zwecke eingesetzt werden. In Sim City zeigen
Echtzeitkarten z. B. den Einfluss der Polizei- und Feuerwehrkräfte innerhalb
der Stadt. Der Spieler benötigt diese Informationen für die weitere Planung
der Gebäude. Auch verwendet das Spiel intern diese Karten, um die Welt
zu simulieren.
2.5.4
Zustandsautomaten
Zustandsautomaten (State Machines) und endliche Automaten (Finite State
Machines) sind wichtige Entwurfsmuster in der Software und Grundstein der
KI. Dabei handelt es sich um einfache, regelbasierte Systeme mit einer beschränkten Anzahl an Zuständen“ (siehe Abschnitt 2.3, Akademische KI“).
”
”
In Spielen stellt ein Zustand meist ein Verhalten wie z. B. Patrouillieren
dar. Innerhalb dieses Zustands wird der Agent eine spezifizierte Aufgabe ausführen. Verschiedene Ereignisse können eine Transition“ zu einem anderen
”
Zustand verursachen. Wird z. B. ein Gegner gesichtet, wird von dem Zustand
Patrouillieren auf Angriff gewechselt und der Agent führt andere Aufgaben durch. Ein Zustand überprüft entweder laufend, ob eine Transition
vorliegt, oder reagiert auf Ereignisse.
Stapel-basierte Zustandsautomaten (Stack-Based State Maschines) stellen eine Weiterentwicklung dar. Dabei merkt sich das System vorhergehende
Zustände und speichert sie auf einem Stapel. Dies kann in der KI häufig
sinnvoll sein, da es möglich ist, auf einen vorhergehenden Zustand zurückzuspringen. Wechselt der Automat von Patrouillieren auf Angriff, wird
der Zustand Patrouillieren am Stapel gespeichert. Ist der Agent erfolgreich und besiegt den Gegner, oder ist er zu langsam und verliert den Gegner
aus dem Auge, kann er einfach zum letzten Zustand Patrouillieren zurückspringen.
2.5.5
Mehrebenen-Architektur
Eine Mehrebenen-Architektur (Subsumption Architecture) teilt das Verhalten eines einzelnen Agenten in Ebenen. Die unteren Ebenen konzentrieren
sich auf das elementare Verhalten wie z. B. Pfad folgen“ oder Hindernis
”
”
umgehen“. Die höheren Ebenen setzen die Ziele fest und kontrollieren ihre
Erfüllung. Die unteren Ebenen haben Priorität, damit elementare Aufgaben ausgeführt werden, bevor sie von höheren Ebenen beeinflusst werden.
Die Architektur ist ideal für Charakter-basierte Spiele. Während sich die
unteren Ebenen um die Bewegung und Beobachtung kümmern, entscheiden
die oberen Ebenen über das weitere Vorgehen. Eine mögliche Methode sind
parallele Automaten. Dabei handelt es sich um endliche Automaten, die
zeitgleich auf mehreren Ebenen laufen.
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
2.5.6
18
Scripting
Scripting bezeichnet die Technik, die Spieldaten oder die Logik außerhalb
der Quellsprache des Spiels mit Hilfe von Ablaufbeschreibungen – sogenannten Skripts – zu beschreiben. Dazu werden selbstentwickelte Skriptsprachen
oder bestehende Sprachen (Python, Lua oder Java) verwendet. Es gibt verschiedene Stufen, wie stark dieses Konzept umgesetzt wird:
Stufe 0: Alles wird in der Quellsprache (C/C++) programmiert.
Stufe 1: Zustand und Position der Charaktere und Objekte wird in einer
Datei gespeichert.
Stufe 2: Zwischensequenzen werden in Skripten vordefiniert. Sie sind aber
nicht interaktiv.
Stufe 3: Einfache Logik wird in Skripten spezifiziert. Eine weit verbreitete Methode sind Trigger-Systeme (siehe Abschnitt 2.5.11, Trigger”
Systeme“).
Stufe 4: Die komplexe Logik im Skript ruft Kernfunktionen in der Quellsprache (C/C++) auf.
Stufe 5: Alles wird in Skripten programmiert. Die Skriptsprache stellt damit eine komplette Alternative zu C/C++ dar.
Kommerzielle Spiele wurden in allen sechs Stufen entwickelt. Mit Jak and
Daxter gibt es sogar ein erfolgreiches Spiel der Stufe 5. Dennoch kommen vor
allem die mittleren Stufen zum Einsatz, da die beiden Extreme als riskant,
zeitintensiv und teuer gelten.
Zunächst muss die Skriptsprache in dem Spiel integriert und deren Einfluss auf das Spiel definiert werden. Die Anwender der Sprache sind üblicherweise Künstler und Level-Designer. Die geschriebenen Skripts werden
entweder in Bytecode vorkompiliert oder innerhalb des Spieles zur Laufzeit
interpretiert.
Vorteil
• Die Spiellogik kann in dem Skript verändert werden, ohne das gesamte
Spiel neu zu kompilieren.
• Designer sind in der Lage, einfache Programmierungen ohne tiefe Programmierkenntnisse vorzunehmen.
• Scripting ermöglicht dem Spieler, die KI selber umzuprogrammieren
oder zu erweitern.
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
19
Nachteil
• Debugging und Fehlersuche werden durch Skripts erschwert.
• Nichtprogrammierer müssen plötzlich programmieren.
• Die Entwicklung und Unterstützung der Skriptsprache ist zeitaufwendig. Debug- und Fehlersuchwerkzeuge müssen erweitert werden.
2.5.7
Schwarmverhalten
Das Schwarmverhalten imitiert das natürliche Verhalten von Schwärmen
und Herden (siehe Abschnitt 2.3, Akademische KI“). Jede Kreatur in die”
sem Schwarm folgt drei einfachen Bewegungsregeln. Aus diesen individuellen
Regeln entsteht ein komplexes Gruppenverhalten (Emergenz-Verhalten):
Separation: Bewege dich weg, sobald dir jemand zu nahe kommt!
Ausrichtung: Bewege dich in etwa in dieselbe Richtung wie deine Nachbarn!
Zusammenhalt: Bewege dich in Richtung des Mittelpunkts derer, die du
in deinem Umfeld siehst!
In Spielen kommt das Schwarmverhalten vor allem für Hintergrundkreaturen wie z. B. Fisch-, Vögel- oder Insektenschwärme zum Einsatz. Da die
Bewegung der einzelnen Kreaturen sehr willkürlich ist, kann diese Methode
auch für Agenten ohne genauem Ziel verwendet werden.
2.5.8
Befehlshierarchie
Befehlshierarchien (Command Hierachy) verteilen die KI-Entscheidungen
auf verschiedenen Ebenen – vom General zum einfachen Soldaten. Ähnlich wie beim Militär entscheidet der General über die Gesamtstrategie auf
dem Schlachtfeld, während sich der Soldat auf den eigenen Kampf konzentriert. Die Ebenen dazwischen kümmern sich um die Kooperation zwischen
den Truppenteilen. Da die Entscheidungen auf verschiedene Ebenen verteilt
werden, sind sie überschaubarer und können besser abstrahiert werden.
Befehlshierarchien werden häufig in Strategiespielen eingesetzt. Die Entscheidungen werden typischerweise in Gesamtstrategie“, Gruppenkoordi”
”
nation“ und individueller Kampf“ unterteilt. Der Einsatz ist auch in Spielen
”
mit einer großen Anzahl zusammenhängender Agenten sinnvoll.
2.5.9
Koppelnavigation
Die Koppelnavigation (Dead Reckoning) versucht die zukünftige Position eines Spielers aufgrund vorhergehender Positionen, Geschwindigkeit und Beschleunigung vorherzusagen. Da die meisten Objekte über kurze Zeit geradlinige Bewegungen haben, ist diese Methode sehr erfolgreich. Verbesserte
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
20
Formen der Koppelnavigation können herausfinden, wie weit sich ein Objekt
nach der letzen Sichtung bewegt haben könnte.
In Ego-Shootern und Kampfsimulationen ist die Koppelnavigation wichtig, da sich die meisten Waffengeschosse nicht unendlich schnell bewegen
und der Computer zum genauen Zielen die zukünftige Position des Zieles
vorhersagen muss. Aber auch in Sportspielen ist die Vorhersage der gegnerischen Spieler wichtig. Die Koppelnavigation kann auch zur Anpassung
der Schwierigkeitsstufe verwendet werden, da sie die Treffergenauigkeit des
Computers bestimmt.
2.5.10
Hindernis-Umgehung
Mit A* Pfadfinder ist es einfach möglich, einen Weg von A nach B in einem statischen Gelände zu finden. Der Algorithmus berücksichtigt jedoch
keine dynamischen Hindernisse wie z. B. Spieler, andere Charaktere oder
Fahrzeuge. Dies führt zu Kollisionen und in engen Passagen versperren sich
Agenten oft gegenseitig den Weg. Eine besondere Herausforderung stellt die
Bewegungen mehrer Agenten als Gruppe dar. So ist es z. B. in Age of Empire
III noch immer ein Problem, wenn mehrere Schiffe gleichzeitig eine Engstelle
passieren [8]. Hindernis-Umgehungs-Algorithmen versuchen dies durch Vorhersage des Bewegungsablaufs und Bewegungsregeln zu verbessern.
Beispiel: Zwei Einheiten bewegen sich über eine enge Brücke. Damit nicht
beide gleichzeitig die Brücke betreten und sich gegenseitig blockieren, darf
zuerst die nächstgelegene Einheit die Brücke passieren. Dann folgt die Zweite.
Nähert sich eine weitere Einheit, um die Brücke zu überqueren, verringert
diese ihre Geschwindigkeit, um eine Kollision zu vermeiden.
2.5.11
Trigger-Systeme
Trigger-Systeme sind spezialisierte Scritping Systeme, die einfache wenn/
”
dann“-Abfragen innerhalb der Spielobjekte oder der Spielwelt ermöglichen.
Sie sind vor allem für Level-Designer konzipiert, da sie eine einfache und
robuste Möglichkeit zur Steuerung der Spielereignisse bieten. Es kann genau
definiert werden, wann ein Trigger ausgelöst wird und was danach passieren
soll.
Beispiel: Ein Hinterhalt kann mit diesem System einfach realisiert werden. Der Level-Designer platziert einen Trigger in der Mitte eines Raumes.
Betritt der Spieler diesen Trigger und löst damit die Bedingung aus, tauchen
Gegner auf und attackieren den Spieler.
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
2.6
21
KI und Spiel-Design
KI und Spiel-Design sind untrennbar miteinander verbunden. Der Spieler
bleibt von spannenden Missionen, wunderschönen Spielgraphiken und einer interessanten Hintergrundgeschichte unbeeindruckt, wenn der Computergegner dumm und leicht zu besiegen ist. Andererseits sind hochintelligente Agenten in einem Zombie-Ego-Shooter“ ebenfalls fehl am Platz. Die
”
KI ist ein wesentlicher Teil des Gameplay4 und beeinflusst unmittelbar die
Spielatmosphäre. Es gibt zwei unterschiedliche Ansätze KI in einem Spiel
zu entwickeln [2]:
2.6.1
Designer-kontrollierte KI
Der KI-Designer legt das Verhalten der computergesteuerten Charaktere
genau fest. Mit Scripting und Trigger-Systemen werden verschiedene Ereignisse im Vorhinein definiert. Betritt der Spieler z. B. zu dem Zeitpunkt A
den Raum B, wird Verstärkung angefordert. Vorgegebene Wahrscheinlichkeitstabellen legen fest, unter welchen Bedingungen der Computer angreifen
oder besser flüchten soll. Detaillierte Regeln bestimmen, wie sich der Gegner in einer konkreten Situation verhalten soll. Damit hat der Designer das
Verhalten der KI genau unter Kontrolle und kann die Spiellevels einfacher
und besser gestalten.
Vorteil
• Volle Kontrolle über die KI.
• Einfache Levelgestaltung.
Nachteil
• Gegner ist einfach zu durchschauen.
• Meist nur erzählendes und lineares Gameplay.
• Genaue Definition der KI sehr umfangreich.
2.6.2
Eigenständige KI
Neue Techniken ermöglichen den computergesteuerten Charakteren selbstständig zu agieren. Anstatt auf vorgegebene Ereignisse und Situationen zu
reagieren, entscheidet der Computer selbst, welche Aktion am besten ist.
Lernfähige KI kann im Spiel vom Spieler lernen und bedarf keiner langwierigen Feinabstimmung. Der Entwicklungsprozess des Spieles kann dadurch
4
Gesamtheit aller Spielererfahrungen in einem Spiel und damit ein Synonym zu Spie”
len“.
KAPITEL 2. KÜNSTLICHE INTELLIGENZ IN SPIELEN
22
maßgeblich erleichtert werden. Jedoch stellt dieser Ansatz neue Anforderungen an die Spielarchitektur und das Spiel-Design. Da das Verhalten der
KI nicht genau vorhergesagt werden kann, verliert der KI-Designer sehr viel
Kontrolle über das Spiel. Die Entwicklung erfordert komplexere und aufwendigere Algorithmen. Diese Nachteile schrecken viele Spielfirmen ab, zumal
es auch noch wenige erfolgreiche Beispiele in diesem Bereich gibt.
Vorteil
• Anspruchsvolle und eigenständige KI.
• Keine genaue Definition und Feinabstimmung der KI erforderlich.
• Völlig neue Spielkonzepte möglich.
Nachteil
• Weniger Kontrolle über das Spiel, da das KI-Verhalten nicht vorhergesagt werden kann.
• Erfordert komplexe und aufwendige Algorithmen.
Um das gesamte Potential der KI entfalten zu können, muss sich das
Spiel-Design vom Designer-kontrollierten erzählenden und linearen Ansatz
lösen. Eigenständige KI ermöglicht völlig neue Spielkonzepte, wie Die Sims
und Black & White eindrucksvoll bewiesen haben. Für Spielfirmen stellt es
zwar einen erhöhten Aufwand und damit ein größeres Risiko dar, doch bietet
es eine Möglichkeit, sich von der breite Masse abzuheben.
Kapitel 3
Lernen und Adaptation in
Computerspielen
Lern- und Anpassungsmethoden sind ein wichtiger Fortschritt in der SpieleKI. Sie stellen den Spieler vor neue Herausforderungen, da er kontinuierlich
neue Strategien finden muss, um den Gegner zu besiegen [18]:
It is anticipated that the widespread adoption of learning in
games will be one of the most important advances ever to be
made in game AI. Genuinely adaptive AIs will change the way
in which games are played by forcing the player to continually
search for new strategies to defeat the AI, rather than perfecting
a single technique.
Der sorgfältige und gewissenhafte Einsatz von Lernmethoden ermöglicht ein
schlaueres und robusteres Verhalten der Agenten, ohne sie vorher genau abzustimmen. Vor der Veröffentlichung eines Spieles muss der KI-Designer die
KI nicht mehr auf alle möglichen Spieleraktionen oder Strategien vorbereiten. Die Agenten stellen sich auf den Spieler ein und können sogar von ihm
lernen. Dieses Kapitel gibt einen Überblick über Lernmethoden und deren
Einsatz in Computerspielen.
3.1
Maschinelles Lernen
Maschinelles Lernen (Machine Learning) ist ein Oberbegriff für die künst”
liche“ Generierung von Wissen aus Erfahrung (siehe Kaptitel 2.3, Akade”
mische KI“). Man unterscheidet zwischen dem Lernziel, der Lernart und der
Lernmethode.
• Lernziel: Was wird gelernt?
• Lernart: Wie wird gelernt?
• Lernmethode: Mit welcher Methode wird gelernt?
23
KAPITEL 3. LERNEN UND ADAPTATION
3.1.1
24
Lernziel
Zuerst muss festgestellt werden, was erlernt werden soll. Es kann zwischen
Fakten-Wissen und Verhalten unterschieden werden [2].
Fakten-Wissen
Durch Beobachtung der Welt wird versucht, sie durch Fakten und statistische Annahmen zu verstehen. Wenn ich springe, falle ich wieder zu Boden“
”
ist z. B. ein Fakt und Der Spieler befindet sich häufig an diesem Ort“ ist
”
eine statistische Annahme. Genügend Erfahrungen vorausgesetzt, kann dieses Wissen sehr umfassend und genau werden. Es ist möglich, aus einer
Sammlung von eindeutigen Fakten zu generalisieren. Aus dem ersten Fakt
kann der Agent z. B. schließen, dass alle Objekte in der Luft auf den Boden
fallen.
Verhalten
Alternativ kann auch ein bestimmtes Verhalten erlernt werden. Agenten
können lernen ihre Bewegung zu steuern, durch Türen zu gehen oder eine
Waffe zu benutzen. Das Lernpotential reicht dabei von einfachen Aktionen
bis zu komplexen Handlungen. Es ist wichtig, dass der Agent lernt, das
Verhalten in allgemeingültigen Situationen anzuwenden.
Überschneidungen
Gerade in der Spielentwicklung ist es manchmal schwierig das Lernziel genau zuzuordnen. Zum Beispiel speichert ein Entscheidungsbaum Fakten und
beeinflusst gleichzeitig das Verhalten des Agenten.
3.1.2
Lernart
Die Lernart beschreibt, wie das Lernen erfolgt. Entweder wird schubweise
an Hand einer großen Datenmenge gelernt oder schrittweise anhand von
einzelnen Beispielen [2].
Schubweises Lernen
Schubweises Lernen (Batch Learning) verwendet eine große Datenmenge als
Ganzes, um die relevanten Fakten zu erlernen. Entscheidungsbäume sind ein
Beispiel dafür, da sie die gesamte Datenmenge verwenden, um den Baum zu
bauen.
KAPITEL 3. LERNEN UND ADAPTATION
25
Schrittweises Lernen
Schrittweises Lernen (Incremental Learning) verwendet die Beispiele einzeln
und justiert jedes Mal die interne Repräsentation geringfügig. Nach und nach
werden dadurch die Ergebnisse verbessert. Im Gegensatz zum schubweisen
Lernen verwenden schrittweise Verfahren weniger Speicher, da die Daten
sofort nach dem Lernen gelöscht werden können. Sie sind aber schwieriger
zu handhaben, da man beim Lernen immer nur ein einzelnes Beispiel und
nicht die gesamten Daten zur Verfügung hat.
3.1.3
Lernmethoden
Es gibt unterschiedliche Ansätze, wie das Lernen gesteuert wird. Die Methode beeinflusst nicht nur die Lerngeschwindigkeit, sondern auch das Endresultat [2].
Überwachtes Lernen
Beim überwachten Lernen (Supervised Learning) sind zu bestimmten Eingabedaten x ∈ X die gewünschten Ausgabedaten y ∈ Y bekannt. Dies
bedeutet eine Abbildung X → Y . Der Algorithmus kann diese Funktion aus
gegebenen Paaren von Ein- und Ausgaben lernen. Das Verfahren kann einfach durchgeführt werden, da immer eindeutig ermittelt werden kann, welche
Antwort in einer bestimmten Situation gegeben werden soll.
Beispiel: Ein Entscheidungsbaum gibt für eine bestimmte Situation eine
eindeutige Antwort. Er kann mit Hilfe von Beispielen aus dem Spiel gebildet
werden. Wichtig ist dabei, eine große Anzahl von Daten bereitzustellen. Nur
so bekommt die KI die Möglichkeit, die beste Lösung zu finden.
Bestärkendes Lernen
Bestärkendes Lernen (Reinforcement Learning) ist im Gegensatz zum überwachten Lernen nicht eindeutig. Der Agent versucht die Aktion x ∈ X in
einer bestimmten Situation y ∈ Y und bekommt je nach Resultat eine Belohnung. Dies bedeutet eine Abbildung X × Y → R. Wobei R die Stärke der
Belohnung darstellt.
Bestärkendes Lernen führt zu einigen Problemen. Das richtige Verhalten
kann nur mit einer großen Anzahl an Experimenten gefunden werden und
für komplexe Probleme ist es schwierig, ein geeignetes Belohnungsschema zu
finden. In der Praxis kommt das Verfahren daher nur für stark begrenzte
Suchräume zum Einsatz.
Beispiel: Der Agent bekommt eine positive Belohnung für die erfolgreiche
Vorwärtsbewegung und eine negative, wenn er gegen ein Hindernis stößt.
KAPITEL 3. LERNEN UND ADAPTATION
26
Evolutionäres Lernen
Evolutionäres Lernen (Evolutionary Learning) verwendet eine Fitnessfunktion (siehe Abschnitt 3.4.2, Umsetzung“), um einen Agenten zu beurteilen.
”
Im Gegensatz zum bestärkenden Lernen wird jedoch nicht eine Aktion oder
ein bestimmtes Verhalten bewertet, sondern das gesamte Abschneiden des
Agenten. Das bedeutet, dass eine Anzahl n von Eingangsparametern x ∈ X
und Ausgangsparametern y ∈ Y die Fitnessfunktion beeinflusst. Dies bedeutet eine Abbildung (X×Y )n → R. Wobei R das Ergebnis der Fitnessfunktion
darstellt.
Evolutionäres Lernen ist nur in der Entwicklung des Spieles sinnvoll, da
eine große Anzahl an Versuchen notwendig ist, um ein zufrieden stellendes
Ergebnis zu erhalten. Jedoch können, einer langen Lernphase vorausgesetzt,
sehr gute Resultate erzielt werden.
Beispiel: Das Waffenverhalten der Agenten kann evolutionär weiterentwickelt werden. Verschiedene Agenten werden getestet und miteinander kombiniert, um schließlich den besten Schützen auszuwählen.
Unüberwachtes Lernen
Unüberwachtes Lernen (Unsupervised Learning) hat keine im Voraus bekannten Zielwerte. Aus einer großen Datenmenge werden selbstständig Muster extrahiert, ohne genaue Vorgaben zu haben. Es sind jedoch andere KITechniken notwendig, um diese Muster zu interpretieren. Unüberwachtes
Lernen wird daher in Kombination mit anderen Methoden verwendet. Zum
Beispiel dient das Verfahren zur Klassifikation. Ein Entscheidungssystem
kann das Ergebnis dann interpretieren und Rückschlüsse daraus ziehen.
Vergleich
Spiele-KI verwendet hauptsächlich überwachtes Lernen. Die Ergebnisse sind
vorhersehbar und der Lernerfolg ist meist ausreichend. Die anderen Verfahren bieten wenige Möglichkeiten, um das Endresultat zu steuern, und
erfordern einen höheren Entwicklungs- und Rechenaufwand. Da sie jedoch
sehr hohe Lernerfolge erzielen können, kommen sie in der Entwicklung des
Spiels zum Einsatz.
3.1.4
Erfolgsmessgröße
Die Erfolgsmessgröße (Performance Measure) ermittelt den Erfolg eines bestimmten Verhaltens oder des Agenten im Allgemeinen. Sie wird verwendet,
um den Lernerfolg zu messen und den Lernprozess zu steuern. Ziel des Lernens ist, eine bessere Erfolgsmessgröße zu erreichen.
KAPITEL 3. LERNEN UND ADAPTATION
27
In der Spiele-KI wird dieser Wert normalerweise innerhalb des Spieles berechnet. Zur Beurteilung werden unterschiedliche Informationen oder Kennzahlen herangezogen [17]. Mögliche Kennzahlen für einen Agenten in einem
Ego-Shooter sind z. B. Treffergenauigkeit“, Anzahl der getöteten Feinde“
”
”
oder Überlebensdauer“. Dabei müssen folgende Probleme berücksichtigt
”
werden:
• Mehrere Kennzahlen beurteilen das gleiche Verhalten: Kann
der Agent mit der Waffe gut umgehen, erhöht sich nicht nur seine
Treffergenauigkeit, sondern auch die Anzahl der getöteten Feinde.
• Unterschiedliches Verhalten ergibt ähnliche Kennzahlen: Eine
lange Überlebensdauer kann z. B. durch zwei unterschiedliche Fähigkeiten ausgelöst werden:
– Der Agent ist in der Lage seine Gegner auszuschalten, bevor sie
ihn ausschalten.
– Der Agent kann besonders gut vor dem Gegner fliehen.
• Falsch gesetzte Erfolgsmessgrößen: Wird die Erfolgsmessgröße
zur Optimierung der Lernmethode verwendet, führen sorglos gesetzte
Erfolgsmessgrößen zu einer langsamen Lernrate und im schlimmsten
Fall zu ungewolltem Verhalten. Wird lediglich die Überlebensdauer“
”
als Kriterium verwendet, kann es sein, dass der Agent nur noch vor
dem Spieler flieht, um seine Überlebenschance zu erhöhen. Dies verringert den Spielspass und ist sicher nicht Ziel des KI-Designers.
3.1.5
Anwendungen
Maschinelles Lernen wird in der KI in unterschiedlicher Form angewendet.
Training
Als Training wird das Bereitstellen von Beispielen, von denen die KI lernen
kann, bezeichnet. Beispiele werden entweder wahllos aus dem Spiel generiert
oder von Experten angefertigt. Der Experte analysiert dabei das Problem
und verwandelt das Wissen in geeignete Beispiele. Ziel des Trainings ist es,
dass die KI auch in Fällen ohne entsprechendes, vorher gelerntes Beispiel
richtig reagiert [2].
Imitieren
Der Agent lernt vom Spieler und imitiert sein Verhalten. Dabei werden die
Aktionen des Spielers in einer bestimmten Situation oder über einen bestimmten Zeitraum aufgenommen. Der Agent verwendet in der gleichen Situation die gleiche Aktionsfolge [17].
KAPITEL 3. LERNEN UND ADAPTATION
28
Versuch und Irrtum
Versuch und Irrtum (Trial and Error) ist eine Form des bestärkenden Lernens. Es wird keine Vorgabe darüber gemacht, was zu tun ist, sondern die
Qualität der Aktionen oder des Verhalten wird bewertet. Der Agent versucht
die bestmögliche Bewertung zu erzielen. Der KI-Designer muss sicherstellen,
dass der Agent entsprechendes Feedback erhält [2].
Formen
Beim Formen (Shaping) versucht der KI-Designer, dem Agenten mit seinem
Wissen über die Aufgaben zu helfen [20]. Zum Beispiel wird das Problem
in einfachere Unterprobleme geteilt, damit der Agent die Lösung schneller
finden kann. Formen kann in Kombination mit Training verwendet werden.
Dem Agenten werden zunächst nur die wichtigsten Beispiele gegeben.
Optimierung
Die Optimierung versucht für ein bestimmtes Problem die optimale Lösung
zu finden. Das Problem ändert sich nicht, es sind aber verschiedene Lösungen
möglich. Ziel der Optimierung ist, die beste Lösung zu erlernen.
Adaptation
Bei der Adaptation ist das Ziel genau definiert, jedoch ändern sich die Rahmenbedingungen. Im Gegensatz zur Optimierung können gefundene Lösungen nach einer bestimmten Zeit nicht mehr erfolgreich sein. Der Agent muss
daher sein Verhalten anpassen oder gänzlich neues Verhalten entwickeln.
3.2
Einsatz in Computerspielen
Maschinelles Lernen wird entweder in der Entwicklung oder im laufenden
Spiel eingesetzt. Im laufenden Spiel werden Lernmethoden vor allem zur
Adaptation verwendet. Verschiedene Techniken wurden bereits in Spielen
ausprobiert und unterschiedliche Ansätze getestet.
3.2.1
Zwei unterschiedliche Phasen
Lernmethoden können entweder in der Entwicklung des Spieles offline, oder
nach der Veröffentlichung im laufendem Spiel online eingesetzt werden [2].
Offline
Die Lernmethode wird in der Entwicklung eingesetzt und kann als Vorprozess verstanden werden. Ähnlich wie die Graphiken komprimiert und die
Zwischensequenzen vorberechnet werden, wird das Verhalten der Agenten
KAPITEL 3. LERNEN UND ADAPTATION
29
im vorhinein trainiert und für das Spiel aufbereitet. Der KI-Designer kann
den Lernprozess genau überprüfen und gegebenenfalls beeinflussen.
Online
Die Lernmethoden werden nach der Veröffentlichung im laufenden Spiel angewendet. Der Spieler soll durch glaubwürdigere Charaktere besser von der
Spielwelt angezogen werden. Der Einsatz muss jedoch sorgfältig überlegt
werden, da die Auswirkungen im Spiel schwierig abzuschätzen sind und nicht
alle Situationen getestet werden können.
3.2.2
Adaptation in Computerspielen
Online in Computerspielen verwendete Lernmethoden werden vor allem zur
Adaptation eingesetzt. Mit Adaptation ist es möglich, die Spiele-KI im Lauf
des Spieles anzupassen und weiterzuentwickeln. Es gibt zwei unterschiedliche
Arten: indirekte und direkte Adaptation. In Spielen wird die Adaptation
häufig nur vorgetäuscht [17].
Adaptation vortäuschen
Adaptation kann einfach vorgetäuscht werden. Dabei wird die Fehleranfälligkeit der KI im Lauf des Spieles verringert. Der KI-Designer kann genau
festlegen, ab welchem Zeitpunkt oder bei welchem Ereignis sich die KI verbessert. Der Spieler gewinnt somit den Eindruck, dass sich der Computergegner weiterentwickelt und im Spiel lernt.
Indirekte Adaptation
Informationen aus der Spielwelt werden von der KI verwendet, um das Verhalten der Agenten anzupassen. Zum Beispiel kann ermittelt werden, wo
sich der Spieler in einem Ego-Shooter besonders häufig aufhält. Die KI sorgt
anschließend dafür, dass die computergesteuerten Gegner öfter bei dieser
Position vorbeigehen. Die Lernmethode beschränkt sich auf das Ermitteln
von Informationen aus der Spielwelt und beeinflusst damit das Verhalten des
Agenten nur indirekt. Indirekte Adaptation hat folgende Vor- und Nachteile:
• Vorteil
– Die Informationen können sehr einfach und schnell aus der Spielwelt ermittelt werden.
– Die Anpassung wird von der globalen KI und nicht von den einzelnen Agenten vorgenommen. Dies ermöglicht eine genaue Kontrolle der Adaptation und ist einfach zu testen.
KAPITEL 3. LERNEN UND ADAPTATION
30
Genre
Information
Einfluss
Ego-Shooter
Aufenthalt des Spielers.
Routenplanung
Ego-Shooter
Welche Waffe erzielt die
meisten Treffer?
Waffenauswahl
Echtzeit-Strategie Dauer bis der Spieler den
ersten Angriff startet.
Ausbau der Basis
Echtzeit-Strategie Welche Einheit verwendet
der Spieler?
Auswahl der Einheiten
Tabelle 3.1: Verschiedene Informationen können verwendet werden, um das
Verhalten der Agenten anzupassen.
• Nachteil
– Die Adaptation kann nur in einem sehr beschränkten Bereich angewendet werden.
Welche Informationen sich auf welches Verhalten auswirken, muss im
Vorhinein von dem KI-Designer genau festgelegt werden. Eine Liste von
möglichen Anwendungsgebieten findet sich in der Tabelle 3.1. Eine in Spielen
eingesetzte Form der indirekten Adaptation ist in Abschnitt 3.3.2 Spieler”
Modellierung“ beschrieben.
Direkte Adaptation
Das Verhalten des Agenten wird direkt durch Lernmethoden verändert. Die
Methode testet dabei üblicherweise eine Modifikation des Agenten in der
Spielwelt und überprüft, ob sich die Änderung positiv auswirkt. Dazu wird
das Verhalten des Agenten parametrisiert. Das heißt, dass eine Anzahl von
Parametern oder Attributen bestimmt, wie sich der Agent verhält. Diese Parameter können anschließend mit unterschiedlichen Optimierungsmethoden
verbessert werden.
Beispiel: In einem Ego-Shooter definiert ein Parameter, innerhalb welchen
Radius der Gegner keinen Raketenwerfer benutzt, um nicht selbst Schaden
zu nehmen. Somit wird das Verhalten des Agenten, ab wann er welche Waffe
verwendet, mit einem einzelnen Wert bestimmt.
• Vorteil
– Individuelle Anpassung: Agenten können sich individuell an
den Spieler anpassen. Direkte Adaptation eröffnet somit völlig
neue Möglichkeiten in der Spiele-KI.
KAPITEL 3. LERNEN UND ADAPTATION
31
• Nachteil
– Überprüfung der Adaptation: Ob sich die Adaptation positiv auswirkt, wird empirisch im Spiel bestimmt. Dabei muss der
Agent über längere Zeit beobachtet werden, um den Einfluss von
zufälligen Ereignissen zu minimieren. Außerdem stellt sich die
Frage, wie man den Erfolg einer Adaptation messen kann. Eine
Möglichkeit bieten Erfolgsmessgrößen (siehe Abschnitt 3.1.4, Er”
folgsmessgröße“).
– Unvorhersehbares Verhalten: Das Verhalten des Agenten ist
schwierig vorherzusagen. Der KI-Designer hat wenige Möglichkeiten den Adaptationsprozess zu kontrollieren. Im schlimmsten
Fall wird das Spiel durch das entwickelte Verhalten des Agenten unspielbar oder sogar instabil (z. B. in der Physik-Simulation
werden Fehler verursacht).
Um den zweiten Nachteil zu vermeiden, soll die Adaptation nur für einen
beschränkten und genau definierten Bereich angewandt werden. Das vorhergehende Beispiel zeigt ein gutes Anwendungsgebiet. Der Parameter beeinflusst lediglich die Wahl der Waffe und führt zu keinen unerwarteten Auswirkungen.
3.3
Verwendete Techniken
In Spielen werden verschiedene Techniken und Algorithmen zum Lernen verwendet. In Tabelle 3.2 ist eine Reihe von Verfahren, die nachfolgend genauer
beschrieben werden, aufgelistet. Bei einigen ist es schwierig, das Lernziel, die
Lernart oder die Lernmethode richtig zuzuordnen. Dies hängt meist von dem
genauen Einsatz im Spiel ab.
3.3.1
Dynamische Entscheidungsbäume
Entscheidungsbäume sind eine wichtige Methode in der KI (siehe Abschnitt
2.3, Akademische KI“) und werden auch in Spielen häufig eingesetzt. Sie
”
stellen aufeinander folgende, hierarchische Entscheidungen anschaulich dar.
Beispiel: Die KI muss in einem Strategie-Spiel entscheiden, ob der Spieler
angegriffen werden soll oder nicht. Dazu wird ein in Abbildung 3.1 illustrierter Entscheidungsbaum verwendet, der die Wahrscheinlichkeit für einen Angriff auf den Spieler ermittelt. Der Entscheidungsbaum überprüft zunächst,
ob eine Allianz mit dem Spieler besteht. Im nächsten Schritt wird die Verteidigungsstärke des Spielers beurteilt [7].
KAPITEL 3. LERNEN UND ADAPTATION
32
Verfahren
Lernziel
Lernart
Methode
Einsatz
Evolutionäre
Algorithmen
Verhalten
Schrittweise
Evolutionäres
Lernen
offline
Neuronale
Netze
Verhalten, Schrittweise, Überwachtesund UnüberWissen
Schubweise
wachtes Lernen
offline,
online
Dynamische
Entscheidungsbäume
Verhalten, Mischform
Wissen
Überwachtes
Lernen
online
SpielerModellierung
Verhalten, Schrittweise
Wissen
Überwachtes
Lernen
online
Tabelle 3.2: Eine Liste von eingesetzten Techniken und Algorithmen. Die
Zuordnung des Lernziels, der Lernart und der Lernmethode kann je nach
Einsatzgebiet abweichen.
Allianz
Befreundet
Feindlich
Verteidigung
-1,0
Schwach Mittel
0,4
0,1
Stark
-0,3
Abbildung 3.1: Entscheidungsbäume stellen aufeinander folgende, hierarchische Entscheidungen anschaulich dar. Anhand dieses Entscheidungsbaumes kann die KI entscheiden, ob sie den Spieler angreifen soll oder nicht.
Aufbau und dynamische Anpassung
Entscheidungsbäume können entweder vom KI-Designer entworfen oder aus
einer Reihe von Erfahrungen automatisch konstruiert oder erlernt“ werden.
”
Es ist möglich, im Spiel den Entscheidungsbaum dynamisch neu zu berechnen. Der Baum wird dabei laufend mit neuen Erfahrungen aktualisiert. Gelingt z. B. ein Angriff auf einen starken Gegner, kann diese Erfahrung dem
Baum hinzugefügt werden. Die Wahrscheinlichkeit, einen starken Gegner anzugreifen, steigt daher. Ähnlich wie ein Spieler bei Erfolgen selbstbewusster
und mutiger wird, entwickelt sich die KI weiter und attackiert in Zukunft
auch starke Gegner.
KAPITEL 3. LERNEN UND ADAPTATION
33
Besonders wirkungsvoll sind dynamische Entscheidungsbäume, wenn sie
durch Spielereinwirken direkt beeinflusst werden. Die KI verwendet z. B. den
Baum, um die richtige Taktik zu wählen. Ist eine spezielle Taktik gegen den
Spieler immer erfolglos, wird der Entscheidungsbaum entsprechend aktualisiert und die KI wird in Zukunft diese Taktik meiden.
3.3.2
Spieler-Modellierung
Die Spieler-Modellierung (Player Modeling) erstellt ein Profil vom Spieler
und ist eine Form der indirekten Adaptation. In diesem Profil werden Fähigkeiten, Schwächen, Präferenzen oder andere Charaktereigenschaften des
Spielers gespeichert. Die einzelnen Eigenschaften werden als Charakteristik
bezeichnet und beschreiben einen einzelnen Aspekt des Spielerverhaltens.
Das Profil wird während dem Spiel laufend aktualisiert [11].
Profilaktualisierung
Um das Profil im Spiel zu aktualisieren, wird der Spieler beobachtet. Bestimmte Ereignisse lösen eine Anpassung einer Charakteristik aus. Um den
Einfluss von zufälligen Ereignissen zu minimieren, ändert sich der Wert nur
geringfügig.
Beispiel: Jedes Mal, wenn der Spieler eine Granate verwendet, wird die
Charakteristik VerwendetGranaten“ um einen geringen Wert gesteigert.
”
Misslingt dem Spieler ein weiter Sprung, wird die Charakteristik Kann”
WeitSpringen“ vermindert.
Einfluss auf die KI
Die KI kann das Profil und die einzelnen Charakteristika verwenden, um
seine Strategie an den Spieler anzupassen. Ein Spieler, der gerne Granaten
wirft, erfordert eine andere Taktik, als ein Spieler, der sich auf den Nahkampf
konzentriert. Weiß die KI, dass der Spieler keine weiten Sprünge machen
kann, wird sie die Fluchtpfade der computergesteuerten Gegner so wählen,
dass sie beim Fliehen viele Abgründe überspringen.
3.3.3
Neuronale Netze
Computer verwenden deterministische binäre Rechenmodelle, um digitale
Informationen zu verarbeiten. Trotz enormer Leistung können einige Probleme in dieser rechenbetonten Form nicht gelöst werden. Neuronale Netze
(Neural Networks oder Neural-Nets) basieren auf einem anderem Model.
Parallel verteilte Zellen sind miteinander verbunden und verwenden Wahrscheinlichkeiten um gemeinsam eine Lösung zu formen. Jede Zelle ist ein
KAPITEL 3. LERNEN UND ADAPTATION
N Neuron
g
g
34
N
g Gewichtung
g
g
N
g
g
g
Eingang
N
g
Ausgang
Neuronales Netz
Abbildung 3.2: In einem neuronalen Netz sind mehrere Neuronen miteinander verbunden. Jeder Eingangsparameter wird zunächst mit einer Gewichtung multipliziert.
kleiner Teil des Problems. Dieser biologische Ansatz kann mit entsprechenden Algorithmen am Computer simuliert werden [15]. Neuronale Netze sind
inspiriert von dem menschlichen Gehirn. Das Neuron (oder die Nervenzelle)
steht mit anderen Neuronen oder Empfängerzellen in Verbindung und kommuniziert mit elektrischen Signalen.
Die besondere Eigenschaft neuronaler Netze besteht darin, dass sie komplexe Muster lernen können, ohne dass eine Abstraktion über die zugrunde
liegenden Regeln stattfindet. Das heißt, vor dem Lernen müssen diese Regeln nicht entwickelt werden – aber nachher kann aus dem neuronalen Netz
auch nicht die Logik ermittelt werden, die dessen Lernerfolg ausmachte.
Implementierung
Die Implementierung verwendet ein vereinfachtes Model des Neurons. Jedes
Neuron kombiniert eine Reihe von Eingangsparametern zu einem einzelnen
Ausgangsparameter und lässt sich mathematisch als Annäherung an eine
Funktion beschreiben. Jeder Eingangsparameter wird mit einer Gewichtung
multipliziert, die beim Lernvorgang angepasst wird. Neuronen können miteinander kombiniert werden. Dabei werden die Ausgänge mit den Eingängen
der anderen Neuronen verbunden, um gemeinsam ein Netz zu bilden, wie in
Abbildung 3.2 illustriert.
Beim Trainieren von Neuronen werden die Gewichtungen angepasst. Es
gibt verschiedene Verfahren, die versuchen, die richtigen Werte zu finden.
Die Lernrate bestimmt dabei, wie stark ein neues Beispiel die Gewichtungen verändern kann. Liefert ein Neuron die richtigen Ergebnisse, kann der
Lernvorgang gestoppt werden. Dann werden die Gewichtungen nicht mehr
verändert.
KAPITEL 3. LERNEN UND ADAPTATION
35
Anwendung in Spielen
Neuronale Netze bilden lediglich die Struktur des Gehirns ab. Es liegt am
Entwickler, daraus ein System zu entwerfen, das Schlussfolgerungen und Ableitungen durchführen kann. Neuronale Netze sind schwierig für die Spiele-KI
anzupassen. Sorgfältig und in Kombination mit anderen Techniken eingesetzt kann damit jedoch ein sehr robustes Denkmodel für Spiele entwickelt
werden, das mit unzähligen wenn/dann“-Abfragen kaum möglich ist. Neu”
ronale Netze werden verwendet, um die Umgebung zu klassifizieren, das
Gedächtnis des Agenten abzubilden oder direkt das Verhalten des Agenten
zu steuern [15].
3.3.4
Evolutionäre Algorithmen
Evolutionäre Algorithmen (Evolutionary Algorithm) sind eine Reihe von
Techniken basierend auf der Evolutionstheorie. Lösungsvorschläge“ werden
”
solange verändert und miteinander kombiniert, bis einer dieser Vorschläge
den gestellten Anforderungen entspricht. Diese Algorithmen sind eine populäre Methode, um Parameter in einem mehrdimensionalen Raum zu optimieren. Das Problem wird simuliert und die wehrfähigste Lösung gesucht. Nur
erfolgreiche Lösungen überleben und tragen zum Gesamtergebnis bei. Im
Allgemeinen unterscheidet man zwei Typen von evolutionären Algorithmen,
die unabhängig voneinander entstanden sind:
• Evolutionsstrategien,
• Genetische Algorithmen.
Beide Arten weisen eine ganze Reihe von Analogien auf. Grundsätzlich
kann festgestellt werden, dass Evolutionsstrategien strenger an der biologischen Evolution angelehnt sind. In genetischen Algorithmen wiederum ist
man daran interessiert, wie die Evolution die Informationen kodiert, verarbeitet und verbreitet [19]. In der Spiele-KI ist die Unterscheidung kaum
von Bedeutung. Es werden hauptsächlich genetische Algorithmen verwendet.
Konzepte der Evolutionsstrategien werden jedoch übernommen.
In Spielen werden diese Methoden vor allem offline verwendet. Quake 3
verwendet genetische Algorithmen, um die Waffen-Strategie anzupassen [28].
Verschiedene Parameter, wie z. B. die ideale Distanz bei einer bestimmten
Waffe, werden optimiert. Der genetische Algorithmus wird im nächsten Abschnitt ausführlich beschrieben, da er für die Arbeit besonders relevant ist.
3.4
Genetische Algorithmen
Genetische Algorithmen (Genetic Algorithm) sind eine Unterkategorie der
evolutionären Algorithmen. Die Grundidee ist, ähnlich der biologischen Evo-
KAPITEL 3. LERNEN UND ADAPTATION
36
lution, Lösungskandidaten durch Kombination der Kandidaten weiterzuentwickeln.
3.4.1
Biologische Evolution
Jedes Lebewesen ist einzigartig und hat seine eigenen Attribute, die an die
Nachkommen weitergegeben und vererbt werden. Die ebenfalls einzigartigen
Kinder übernehmen die Attribute der Eltern in leicht veränderter Form.
Die Weiterentwicklung der Lebewesen wird als Evolution bezeichnet und
wird durch den Einfluss der Natur verursacht. Die Lebewesen befinden sich
in einem ständigen Überlebenskampf und daher bestehen nur die mit den
wehrfähigsten Attributen. Diese natürliche Auslese wird von drei Faktoren
bestimmt [2]:
Umwelt: Jedes Lebewesen kämpft in der Umwelt ständig um sein Überleben, indem es Ressourcen (Nahrung und Wasser) finden muss.
Wettkampf: Lebewesen konkurrieren sich innerhalb der gleichen Spezies
gegenseitig, da sie ähnliche Aufgaben erfüllen müssen (z. B. Partnersuche).
Rivalität: Verschiedene Spezies beeinflussen sich gegenseitig durch direkte
Konfrontation (Jagd) oder indirekt durch den Kampf um dieselben
Ressourcen.
Biologische Fortpflanzung
Die Evolution wird durch die biologische Fortpflanzung ermöglicht. Günstige
Attribute werden an die Nachkommen vererbt. Der Aufbau eines jeden Lebewesens wird durch den genetischen Code bestimmt. Bei der Fortpflanzung
werden die genetischen Codes der Eltern miteinander gekreuzt und bilden
die Codes der Nachkommen. Während diesem komplexen Kopiervorgang
können Mutationen auftreten. Dies sind Fehler beim Kopieren des Codes
und können sich als vorteilhaft erweisen oder unwiderrufliche Probleme hervorrufen.
Inspiration
Evolution ist ein Optimierungsprozess. Der genetische Code wird unter Berücksichtigung der Umwelt verbessert. In der Informatik kann man diesen
Vorgang mit genetischen Algorithmen simulieren, um Lösungen zu optimieren. Diese Idee wurde erstmals von John Holland in [10] beschrieben.
KAPITEL 3. LERNEN UND ADAPTATION
Kreuzung
+
37
Mutation
=
Austausch
Selektion
Population
Abbildung 3.3: Die wichtigsten Schritte des genetische Algorithmus.
3.4.2
Umsetzung
Biologische Evolution ist ein komplexer Prozess, der für Menschen schwierig
zu erfassen ist. Damit Computer diesen Prozess nachahmen können, beschränken sich genetische Algorithmen auf die wichtigsten Operationen und
bilden diese Schritt für Schritt nach. Die Evolution muss dabei nicht zwangsläufig auf lebende künstliche Kreaturen angewandt werden, sondern ist auch
für statische Datenstrukturen geeignet [2].
Genetische Algorithmen operieren auf einer Sequenz von Attributen.
Diese Attribute können Gleitkomma-Zahlen oder einzelne Bits sein und
stellen den genetischen Code dar, der optimiert oder weiterentwickelt werden soll. Die Attribute bilden gemeinsam einen Suchraum. Eine bestimmte
Kombination dieser Attribute wird als Individuum definiert. Ähnlich der
natürlichen Evolution wird dieses Individuum weiterentwickelt. Ziel ist, das
Individuum mit den besten Attributen zu finden.
Der Prozess wird in fünf Schritte aufgeteilt, die in Abbildung 3.3 illustriert sind:
1. Initialisierung: Eine ausreichend große Menge unterschiedlicher Individuen wird erzeugt. Diese Menge wird als Population bezeichnet.
2. Selektion: Zufällige Auswahl von Individuen aus der vorhandenen
Population. Dabei werden erfolgsversprechende Individuen mit einer
höheren Wahrscheinlichkeit ausgewählt.
3. Kreuzung: Die Attribute – oder die genetischen Codes – der verschiedenen Individuen werden gemischt. Daraus wird die nächste Generation von Individuen erzeugt.
4. Mutation: Die Attribute der neuen Individuen werden verändert.
5. Austausch: Die neue Generation wird zu den bestehenden Individuen
hinzugefügt.
KAPITEL 3. LERNEN UND ADAPTATION
38
Population
Die Population ist eine Sammlung von Individuen und ändert sich mit der
Zeit. Neue Individuen werden geboren, während andere sterben. Man unterscheidet zwei Arten:
• Dauerpopulation: Neue Individuen werden in die bestehende Population eingefügt. Der Einfluss der neuen Individuen ist gering und führt
zu einer langsamen Evolution.
• Generations-Population: Jede neue Generation bildet eine eigene
neue Population. Bei der späteren Implementierung wird diese Populationsart verwendet.
Initialisierung
Die Initialpopulation sollte aus repräsentativen Individuen des Suchraumes
bestehen. Es ist daher üblich, die ersten Individuen zufällig zu erstellen. Mit
Hilfe eines guten Zufallsgenerators kann man Individuen mit unterschiedlichen Attributen erstellen, die im Suchraum gut verteilt sind. Je höher die
Zahl der Individuen, desto besser die Abdeckung des Raums.
Es ist auch möglich, bestehende und erfolgsversprechende Individuen in
die Population aufzunehmen. Die Attribute dieser Individuen können von
Experten oder mathematischen Algorithmen definiert werden.
Evaluierung
Jedes Individuum kann als Lösungsansatz angesehen werden. Die Evaluierung ermittelt, wie gut dieser Ansatz ist, und bestimmt die Tauglichkeit des
Individuums. Dazu wird eine Fitnessfunktion (Fitness Function) verwendet.
Die Funktion verwendet die Attribute als Eingabe und gibt deren Tauglichkeit als Gleitkommazahl zurück. Die Implementierung der Funktion simuliert
das Problem mit dem vorgeschlagenen Lösungsansatz. Je erfolgreicher das
Individuum die Simulation meistert, desto besser die Beurteilung. Das Ergebnis der Fitnessfunktion kann auch als Erfolgsmessgröße (siehe Abschnitt
3.1.4, Erfolgsmessgröße“) gesehen werden.
”
Die Fitnessfunktion ist der Grundbaustein eines genetischen Algorithmus. Sie beeinflusst den Optimierungsprozess durch Bewertung der Vorteile
eines Individuums. Schlecht gewählte Funktionen können den Prozess verlangsamen und stellen somit den Flaschenhals des Algorithmus dar.
Selektion
Die Selektion wählt die Individuen aus der Population aus, um daraus Nachkommen hervorzubringen. Zwei unterschiedliche Ansätze bestimmen den Selektionsprozess:
KAPITEL 3. LERNEN UND ADAPTATION
39
• Geschlechtliche Fortpflanzung: Die Attribute von zwei Individuen
werden kombiniert und formen die Nachkommen.
• Ungeschlechtliche Fortpflanzung: Die Attribute von einem Individuum formen die Nachkommen.
Kreuzung
Bei der geschlechtlichen Fortpflanzung werden die genetischen Codes der
beiden Eltern kombiniert. Beim Festlegen der einzelnen neuen Attribute
werden diese zufällig vom Vater oder der Mutter verwendet. Dadurch wird
sichergestellt, dass Eltern nicht zweimal dieselben Nachkommen haben. In
der Praxis sollen beide Elternteile gleichwertig ihre Attribute weitergeben.
Eine 95/5 Verteilung macht wenig Sinn, da es sich dabei schon fast um eine
ungeschlechtliche Fortpflanzung handelt.
Mutation
Bei der Fortpflanzung treten Fehler auf und der genetische Code wird geringfügig verändert. Mutationen führen zu abnormalen“ Nachkommen mit
”
beliebiger Tauglichkeit. In der Natur treten diese Fehler bei der Befruchtung auf. Genetische Algorithmen imitieren dieses Verhalten, nachdem ein
neues Individuum erzeugt wurde. Die Werte der Attribute werden mit einer
geringen Wahrscheinlichkeit verändert.
Austausch
Der Austausch bestimmt, ob und auf welche Weise ein neues Individuum
in die Population aufgenommen werden soll. Da die Attribute nun vollständig bekannt sind, kann eine Vorab-Evaluierung durchgeführt werden. Dabei
werden nur wehrfähige Individuen zugelassen.
Weitere Möglichkeiten
Genetische Algorithmen können auch an Entscheidungsbäumen und sogar
am Quellcode angewandt werden. In diesen Fällen stellt der genetische Code
den Baum bzw. den Quellcode dar und wird weiterentwickelt. Kreuzung und
Mutation werden dabei entsprechend angepasst [16].
3.5
Beispiele
Lernmethoden werden in unterschiedlicher Form in Spielen eingesetzt. Die
folgenden Beispiele zeigen mögliche Einsatzgebiete. Screenshots der Spiele
befinden sich in Abbildung 3.4.
KAPITEL 3. LERNEN UND ADAPTATION
40
(a)
(b)
(c)
(d)
Abbildung 3.4: Lernmethoden in Computerspielen: (a) In Black & White
übernimmt man die Erziehung einer Kreatur. (b) In Command & Conquer
Renegade merkt sich die KI die Pfade des Spielers. (c) In Colin McRae Rally
2.0 übernimmt ein neuronales Netz die Steuerung der computergesteuerten
Autos. (d) In Re-Volt werden die Fahrzeuge offline mit einem genetischen
Algorithmus verbessert.
3.5.1
Black & White
Maschinelles Lernen und Adaptation ist ein Grundbaustein von Black &
White1 . Der Spieler übernimmt die Erziehung einer Kreatur und herrscht als
Gott über sein Volk. Wenn der Spieler seine Kreatur belohnt oder bestraft,
sucht das Programm nach der letzten ausgeführten Aktion und merkt sich
diese. Die Kreatur wird fortan diese Aktion öfter ausführen bzw. unterlassen.
Diese Methode ist einfach und erzielt gute Resultate. Mit der Zeit macht die
Kreatur genau das, was der Spieler erwartet.
Zusätzlich passt sich die Spielatmosphäre an das Verhalten des Spielers
an. Ein böser“ Spieler der mit Gewalt und Unterdrückung herrscht, findet
”
eine dunkle Welt vor, während sich bei einem guten“ Spieler der Himmel
”
1
www.lionhead.com/bw/
KAPITEL 3. LERNEN UND ADAPTATION
41
erhellt. Auch stellen dynamische Entscheidungsbäume eine wichtige Technik
in dem Spiel dar.
Obwohl der Spieler der Kreatur ein beliebiges Verhalten lernen kann,
verfügt die Kreatur bereits über angeborenes Verhalten. Damit hat der KIDesigner mehr Möglichkeiten, das Spiel zu steuern. Eine wichtige Aufgabe
bei der Spielentwicklung war das Testen des Spieles. Von Beginn an wurde
das Lernverhalten umfassend getestet [12].
3.5.2
Command & Conquer Renegade
Command & Conquer Renegade2 ist ein Ego-Shooter und basiert auf der
gleichnamigen Echtzeit-Strategie-Reihe. Das Programm verfolgt die Bewegung des Spielers. Legt der Spieler durch das Zerstören von Fenstern neue
Wege frei, aktualisiert das Programm sein Pfadfinder-Modul. Der Computergegner kann nun den gleichen Weg wie der Spieler verwenden. Aus Zeitmangel wurde diese Funktion bei der Veröffentlichung leider deaktiviert, da
sie noch nicht vollständig implementiert war [12].
3.5.3
Colin McRae Rally 2.0
Colin McRae Rally 2.03 ist ein Rallye-Rennspiel und verwendet für die Steuerung der Autos ein neuronales Netz. Das Netz sorgt dafür, dass die RallyeAutos auf der vorher definierten Rennlinie bleiben. Ein regelbasierter Ansatz
reicht dafür nicht aus. Zu viele Parameter wie z. B. Schräglage und Schotter
müssen für das optimale Fahrverhalten berücksichtigt werden.
Der Einsatz des neuronalen Netzes ist genau beschränkt auf das Nachfahren der Rennlinie. Andere Funktionen werden mit Regeln gelöst. So ist
es nicht die Aufgabe des Netzes, Überholmanöver zu starten oder auf einen
Unfall zu reagieren. Es ist möglich, den verschiedenen Fahrern unterschiedliche Rennlinien zu geben, um ihnen eine Persönlichkeit zu verleihen. Das
neuronale Netz kann die neue Rennlinie ohne Trainingsaufwand beherrschen.
Colin McRae Rally ist ein gutes Beispiel für den gewissenhaften Einsatz von
Lernmethoden in Kombination mit anderen KI-Techniken [9].
3.5.4
Re-Volt
Re-Volt ist ein Rennspiel, das genetische Algorithmen verwendet, um das
Verhalten der Rennautos auf den verschiedenen Rennstrecken zu verbessern.
Im Entwicklungsprozess wurde die KI verwendet, um die besten Feinabstimmungsparameter der Autos zu finden. Die KI optimierte mit genetischen
Algorithmen die Parameter, um die schnellsten Rundenzeiten zu erzielen.
2
3
www.ea.com/official/cc/firstdecade/us/renegade.jsp
www.codemasters.de/cmr2pc/html/index.php
KAPITEL 3. LERNEN UND ADAPTATION
42
Dieser offline-Einsatz von Lernmethoden wird in den meisten Spielen bevorzugt. Quake 3 verwendet einen ähnlichen Ansatz um die Waffen-Strategie
zu verbessern [12].
3.6
Resümee
Lern- und Anpassungsmethoden in Computerspielen können das Gameplay
massiv verbessern. Wichtig ist der sorgfältige Einsatz der unterschiedlichen
Methoden. In den meisten Fällen erzielen die Techniken nur in Kombination mit anderen das gewünschte Ergebnis. Lernmethoden werden entweder
offline bei der Entwicklung des Spieles oder online während dem laufenden
Spiel angewendet.
Mit einigen wenigen Ausnahmen setzen Spiele Lernmethoden bisher nur
offline ein. Obwohl die notwendige Rechenleistung in aktuellen Computern
ausreichend zur Verfügung steht, schrecken die Spielfirmen vor dem Einsatz
im laufenden Spiel ab. Die Techniken sind für sie noch zu unerprobt und
stellen daher ein Risiko dar. Dabei bieten Lernmethoden drei wesentliche
Vorteile:
Neue Herausforderungen: Lernmethoden stellen den Spieler vor neue
Herausforderungen. Mit ihnen ist es möglich, glaubwürdigere Gegner
zu schaffen, die sich an den Spieler anpassen. Selbst beim wiederholten
Spielen bleibt das Spiel spannend, da die Gegner dazugelernt und ihr
Verhalten auf den Spieler abgestimmt haben.
Verbessertes Spiel-Design: Lernmethoden erweitern nicht nur bestehendes Spiel-Design, sie ermöglichen auch neue Spielideen. Spielfirmen
können sich mit neuen Spielkonzepten von der Konkurrenz abheben.
Vereinfachte Entwicklung: Sobald die notwendigen Techniken entwickelt
und erfolgreich erprobt wurden, kann sich der Entwicklungsaufwand
für ein Spiel drastisch vereinfachen. Die KI muss nicht mehr langwierig eingestellt und getestet werden. Die KI lernt automatisch offline
oder online das richtige Verhalten.
Durch Lernmethoden können Agenten eigenständig neues Verhalten lernen. Theoretisch ist es möglich, ein Spiel ohne KI nur mit Lernmethoden als
Basis auszuliefern. Die Agenten lernen im Spiel anhand ihrer Erfahrungen,
wie sie sich am besten verhalten sollen. Die Evolution des Agenten wäre nach
oben hin offen. Dieses Beispiel ist zwar utopisch, zeigt aber das gewaltige
Potenzial dieser Methoden.
Kapitel 4
Implementierung
4.1
Das Spiel
Evolving Ogre ist ein einfaches Spiel, das Lernmethoden offline einsetzt. In
dem Spiel schlüpft der Spieler in die Rolle eines tapferen Ritters und muss
einen gefräßigen Ork bekämpfen. Der Ork streift durch die Wälder und
frisst die weidenden Schafe. Die Aufgabe des Spielers ist es, den Ork davon
abzuhalten und ihn zu besiegen. Doch er muss vorsichtig sein, dass er dabei
nicht selber vom Ork gefressen wird.
Das Spiel kann von der beiliegenden CD-ROM einfach installiert und
gestartet werden. Eine User Dokumentation findet sich in Anhang C, User
”
Dokumentation“.
4.1.1
Spielphasen
Das Spiel hat zwei unterschiedliche Spielphasen. In der Lernphase wird der
Ork trainiert und in der Spielphase tritt der Spieler gegen den trainierten
Ork an:
Lernphase: Der Ork wird trainiert. Dabei kommt ein genetischer Algorithmus zum Einsatz und der Ork wird weiterentwickelt. Beim Training
werden die richtigen Attribute für den Ork gesucht. In der Lernphase
bekämpfen sich zwei Orks gegenseitig.
Spielphase: Der Spieler kämpft gegen den trainierten Ork und muss ihn
besiegen. Je nach Trainingsausgang verhält sich der Ork unterschiedlich und stellt den Spieler immer wieder vor neue Herausforderungen.
4.1.2
Spielobjekte
Um das Spiel abwechselnd zu gestalten, gibt es unterschiedliche Spielobjekte.
Folgende in Abbildung 4.1 dargestellten Objekte kommen im Spiel vor:
43
KAPITEL 4. IMPLEMENTIERUNG
(a)
(b)
(d)
(e)
44
(c)
Abbildung 4.1: Die Spielobjekte in Evolving Ogre: (a) Der Ork, (b) der
Ritter, (c) das Schaf, (d) die Waffe und (e) das Heilpaket.
Ork: Der Ork wird vom Computer gesteuert. Er wandert auf der Spielfläche
und frisst umliegende Schafe. Er kann sich selbst heilen und Waffen
sammeln. Ein zu nahe kommender Spieler wird angegriffen. Der Ork
wird in Abschnitt 4.1.3, Der Ork“ ausführlich beschrieben.
”
Ritter: Der Ritter wird vom Spieler gesteuert. Der Spieler kann sich heilen
und Waffen sammeln, um gegen den Ork zu bestehen.
Schaf: Ein Schaf weidet auf der Spielfläche. Es ist dem Ork schutzlos ausgeliefert und wird von ihm gefressen.
Waffe: Die Waffe ist eine Axt, die von dem Ritter oder dem Ork gesammelt
werden kann. Die Waffe verursacht einen größeren Schaden. Bei jedem
Schlag kann die Waffe wieder zerbrechen.
Heilpaket: Das Heilpaket kann den Ritter oder den Ork wieder heilen.
Sobald es gesammelt wurde, verbessert sich der Gesundheitszustand
des Sammlers.
KAPITEL 4. IMPLEMENTIERUNG
45
Spielende
Das Spiel ist beendet, wenn der Ork oder der Ritter stirbt. Zusätzlich gibt es
ein Zeitlimit, nachdem das Spiel abgebrochen wird. Im Spielmodus beträgt
das Limit 500 Sekunden und im Lernmodus 200 Sekunden. Das Limit ist
besonders im Lernmodus wichtig. Sind beide getesteten Orks friedlich und
attackieren sich nicht, würde das Spiel niemals enden.
4.1.3
Der Ork
Der Ork wird vom Computer gesteuert. Er kann verschiedene Aktionen ausführen und sein Verhalten wird von Attributen beeinflusst.
Aktionen
Der Ork kann folgende in Abbildung 4.2 dargestellten Aktionen durchführen:
Schaf fressen: Der Ork geht zum nächsten Schaf und frisst es. Dabei wählt
der Ork den schnellsten Weg zu seinem Opfer.
Heilen: Der Ork sucht das nächste Heilpaket auf, um sich zu heilen. Verschwindet das Heilpaket, bevor der Ork es erreichen konnte, wird die
Aktion abgebrochen.
Fliehen: Der Ork flieht vor dem Spieler. Dabei versucht er sich soweit wie
möglich vom Spieler zu entfernen.
Kämpfen: Der Ork attackiert den Ritter oder den gegnerischen Ork. Er
läuft dem Ziel nach und beginnt ab einem gewissen Radius zu attackieren.
Waffe sammeln: Der Ork sucht die nächste Waffe auf, um seine Kampfkraft zu steigern. Verschwindet die Waffe, bevor der Ork sie erreichen
konnte, wird die Aktion abgebrochen.
Erkunden: Der Ork erkundet die Spielwelt und marschiert zufällig durch
die Welt.
Attribute
Der Ork hat individuelle Attribute, die sein Verhalten bestimmen. Jedes
Attribut ist einer Aktion zugeordnet und bestimmt, wie häufig diese Aktion
ausgeführt wird.
Hunger: Die Gefräßigkeit des Orks wird mit dem Attribut Hunger bestimmt und ist der Aktion Schaf fressen“ zugeordnet. Ist der Wert
”
des Attributes sehr hoch, wird der Ork bevorzugt Schafe fressen.
KAPITEL 4. IMPLEMENTIERUNG
46
Abbildung 4.2: Der Ork kann verschiedene Aktionen durchführen.
Ausdauer: Die Ausdauer gibt die Widerstandsfähigkeit des Orks an und
bestimmt die Häufigkeit der Aktion Heilen“. Die Ausdauer bestimmt,
”
ab welchem Gesundheitszustand der Ork ein Heilpaket aufsucht. Bei
niedrigen Werten heilt sich der Ork früher als bei hohen Werten.
Angst: Die Angst bestimmt, ob der Ork vor dem Gegner fliehen soll. Das
Attribut ist der Aktion Fliehen“ zugeordnet. Ein hoher Wert bedeutet,
”
dass der Ork versucht, dem Gegner aus dem Weg zu gehen.
Mut: Der Mut ist das Gegenteil der Angst und beeinflusst die Aggressivität
des Orks und somit die Aktion Kämpfen“. Ein Ork mit hohem Mut
”
wird den Gegner eher angreifen.
Intelligenz: Wie schlau der Ork ist, gibt die Intelligenz an. Bei hohen Werten wird er zunächst eine Waffe suchen, bevor er den Spieler attackiert.
Die Intelligenz ist der Aktion Waffe sammeln“ zugeordnet.
”
Neugier: Die Neugier bestimmt, ob der Ork lieber die Welt erkundet oder
einer sinnvollen“ Tätigkeit nachkommt. Neugierige Orks wandern
”
durch die Welt, ohne ein genaues Ziel zu verfolgen. Das Attribut bestimmt, wie häufig die Aktion Welt erkunden“ ausgeführt werden soll.
”
Auswahl der Aktionen
Der Ork entscheidet laufend, welche Aktion er ausführen soll. Die Auswahl
der Aktion erfolgt mit Wahrscheinlichkeitswerten. Für jede Aktion wird be-
KAPITEL 4. IMPLEMENTIERUNG
Attribut
Hunger
Ausdauer
Angst
Mut
Intelligenz
Neugier
Zusatzfaktor
Entfernung zum nächsten Schaf
Gesundheitszustand,
Entfernung zum nächsten Heilpaket
Entfernung zum Gegner,
eigener Gesundheitszustand
Entfernung zum Gegner
Eigene Bewaffnung,
Entfernung zur nächsten Waffe
keiner
47
Aktion
Schaf essen
Heilen
Fliehen
Kämpfen
Waffe sammeln
Erkunden
Tabelle 4.1: Die Auswahl der Aktion hängt von dem Attribut und dem
Zusatzfaktor ab.
rechnet, wie wahrscheinlich deren Ausführung in der aktuellen Situation ist.
Der Wert wird bestimmt durch das zugeordnete Attribut und einen Zusatzfaktor, der die Situation beurteilt.
Wie bereits erwähnt, hat jede Aktion ein dazu passendes Attribut. Zum
Beispiel bestimmt das Attribut Hunger die Wahrscheinlichkeit der Aktion
Schaf fressen“. Der Zusatzfaktor bewertet die aktuelle Situation. Dies kann
”
die Entfernung zu einem bestimmten Objekt oder der eigene Zustand sein.
Der Zusatzfaktor bei der Aktion Schaf fressen“ ist z. B. die Entfernung zum
”
nächsten Schaf. Befindet sich der Ork unmittelbar neben einem Schaf, steigt
daher die Wahrscheinlichkeit, dass er das Schaf fressen wird. Es können aber
auch mehrere Faktoren kombiniert werden.
Eine genaue Auflistung aller Aktionen findet sich in Tabelle 4.1. Attribute und Zusatzfaktoren befinden sich immer im Wertebereich zwischen 0
und 1. Entfernungen zu Objekten werden daher entsprechend transformiert.
Die Wahrscheinlichkeit ergibt sich aus der Multiplikation von Attribut und
Zusatzfaktor. Der Ork führt schließlich die Aktion mit der höchsten Wahrscheinlichkeit aus.
Beispiel: Die Abbildung 4.3 zeigt die Berechnung der Wahrscheinlichkeit
für die Aktion Schaf fressen“. Das Attribut Hunger hat den Wert 0,5 und
”
der Zusatzfaktor Entfernung Schaf“ den Wert 0,75. Der Faktor gibt die Ent”
fernung zum Schaf im Wertebereich zwischen 0 und 1 an. Die Wahrscheinlichkeit, dass die Aktion gewählt wird, beträgt daher 0,375 (0,5 ∗ 0,75).
4.2
Implementierung des Spiels
Das Spiel verwendet die Spiele-Engine Crystal Space 3d und die im Vorprojekt entstandene KI-Entwicklungsumgebung AIQuest.
KAPITEL 4. IMPLEMENTIERUNG
Attribut
Hunger (0,5)
Zusatzfaktor
Entfernung Schaf (0,75)
48
Wahrscheinlichkeit
Schaf fressen (0,375)
Abbildung 4.3: Die Multiplikation von Attribut und Zusatzfaktor ergibt die
Wahrscheinlichkeit einer Aktion. Für die Aktion Schaf fressen“ beträgt sie
”
daher 0,375 (0,5 ∗ 0,75).
4.2.1
Crystal Space 3d
Als Basis wurde die Crystal Space 3d Engine1 verwendet. Diese Engine ist
unter GNU Lesser General Public License“ lizenziert und umfasst sämtliche
”
Bereiche, die für Spiele notwendig sind. Neben dem wichtigsten Modul –
dem Graphikmodul – verfügt die Engine über Sound-, Netzwerk-, Scriptingund Fenstersystemmodule. Diese Bibliothek wurde deshalb gewählt, da alle
benötigten Funktionen von ihr unterstützt werden.
4.2.2
AIQuest
Die im Vorprojekt entstandene KI-Entwicklungsumgebung AIQuest bietet
eine einfache Möglichkeit, spielerelevante KI zu testen. Der Anwender ist
nur für das korrekte Verhalten seines Agenten verantwortlich und muss sich
um keine anderen Komponenten des Spieles (Graphik, Physik, usw.) kümmern. AIQuest dient als Basis für Evolving Ogre und wurde stark angepasst.
Das später erklärte Entitäten-System wurde verbessert, neue Spielelemente
eingebaut und ungenutzte Funktionen entfernt.
4.2.3
Architektur
Das Spiel besteht aus fünf Komponenten, die in Abbildung 4.4 abgebildet
sind.
Basisapplikation
Die Basisapplikation startet das Spiel und initialisiert die Crystal Space. Je
nach Eingangsparameter wird der Lern- oder der Spielmodus gestartet.
1
http://www.crystalspace3d.org
KAPITEL 4. IMPLEMENTIERUNG
Genetisches
System
49
Level
Lernmodus
Spielmodus
Basisapplikation
Abbildung 4.4: Die Spielarchitektur von Evolving Ogre.
Lernmodus
Der Lernmodus trainiert den Ork und wendet den genetischen Algorithmus
an. Der Ablauf wird in Abschnitt 4.5, Weiterentwicklung des Orks“ beschrie”
ben. Es verwendet dafür das genetische System und evaluiert die Orks im
Level.
Spielmodus
Der Spielmodus startet das Spiel mit einem menschlichen Ritter und einem
computergesteuerten Ork. Der Ork wurde vorher im Lernmodus trainiert.
Genetisches System
Das in Abschnitt 4.4, Implementierung des genetischen Algorithmus“ be”
schriebene genetische System stellt alle Methoden zur Entwicklung des be”
sten“ Orks zur Verfügung.
Level
Der Level stellt das eigentliche Spiel dar. Es unterstützt zwei Modi. Es
können entweder zwei Orks gegenseitig kämpfen oder der Spieler tritt als
Ritter gegen einen Ork an. Die Attribute der Orks werden beim Laden
des Levels übergeben. Der Level verwendet ein einfaches aber mächtiges
Entitäten-System. Jedes Spielobjekt stellt eine eigene Spielentität dar. Ein
UML-Diagramm findet sich in Abbildung 4.5.
Basis: Die Basis (Base) ermöglicht Typinformation zur Laufzeit (Runtime
Type Information) und ist in Verbindung mit Spielentitäten sinnvoll.
KAPITEL 4. IMPLEMENTIERUNG
50
<<Interface>>
iMessageListener
Base
+DerivesFrom(id: int)
+QueryInterface(id: int)
World
+OnMessage(id: int, data: void*)
<<Interface>>
iUpdatable
GameEntity
-position: vector
-radius: float
-entities: GameEntity*
+AddGameEntity(entity: GameEntity)
+RemoveGameEntity(entity: GameEntity)
+Update(elapsedTime: float)
+MoveEntity(position: vector)
+RotateEntity(radius: float)
Player
Item
Agent
-health: float
-player: Player
+Attack()
Knight
Ogre
ManualAgent
OgreAgent
+EatSheep()
Abbildung 4.5: UML-Diagramm des Entitäten-Systems.
Nachrichtenempfänger: Nachrichtenobjekte2 können vom Nachrichtenempfänger (iMessageListener) empfangen werden. Unbekannten
Klassen kann man dadurch eine beliebige Informationen zukommen
lassen, sofern diese das Interface implementieren.
Spielentität: Die Spielentität (GameEntity) ist die Basisklasse aller Spielobjekte. Es implementiert den Nachrichtenempfänger und verfügt über
Typeinformation zur Laufzeit. Spielentitäten können daher miteinander interagieren, ohne über die andere Klasse Bescheid zu wissen. Kollidieren z. B. zwei Spielentitäten, können die Klassen mit Nachrichtenobjekten kommunizieren. Ist es notwendig, mehr über den anderen zu
erfahren, kann mittels Typeinformation zur Laufzeit die genaue Klasse
ermittelt werden.
Welt: Die Welt (World) speichert und verwaltet die Spielentitäten. Wird
eine Entität bewegt, prüft die Klasse, ob eine Kollision mit einer anderen Entität auftritt.
2
Ein Nachrichtenobjekt besteht aus einem Nachrichtentyp und einem Zeiger auf ein
beliebiges Objekt.
KAPITEL 4. IMPLEMENTIERUNG
51
Aktualisierbar: Das Interface Aktualisierbar (iUpdateable) wird zur Aktualisierung beliebiger Objekte verwendet. Die Klasse, die das Interface
implementiert, wird einmal beim Durchlaufen der Spielschleife (Gameloop) aufgerufen, um sich zu aktualisieren – vorausgesetzt das Objekt
hat sich im System registriert.
Akteur: Der Akteur (Player) ist ein Charakter im Spiel. Es gibt zwei Charaktere: den Ritter (Knight) und den Ork (Ogre). Ein Akteur wird von
einem Agenten gesteuert.
Gegenstand: Ein Gegenstand (Item) ist z. B. ein Heilpaket oder eine Waffe
und kann von einem Akteur gesammelt werden.
Agent: Der Agent (Agent) steuert einen Akteur. Der Agent wird nicht nur
zur Implementierung der KI verwendet, sondern auch zur manuellen
Steuerung eines Akteurs durch den Spieler.
Manueller Agent: Der manuelle Agent (ManuelAgent) wertet die Tastatureingaben des Spielers aus und wandelt sie in Steuerkommandos für
den Akteur um.
Ork-Agent: Der Ork-Agent (OgreAgent) übernimmt die Steuerung des
Orks und implementiert die KI des Orks. Er wird in Abschnitt 4.3.2,
Ork-Agent“ genau beschrieben.
”
4.3
4.3.1
Implementierung der KI
Aktionen
Einen wichtigen Teil der Implementierung der KI übernehmen Aktionen. Sie
sind Steuerkommandos und führen ein bestimmtes Verhalten aus. Die Aktion
Gehe Zu“ bewegt z. B. den Akteur zu einem bestimmten Punkt. Die Aktion
”
Attackieren“ führt einen Schlag durch. Aktionen können an jedem Akteur,
”
also sowohl am Ritter als auch am Ork, angewendet werden. Der manuelle
Agent wandelt die Tastatureingaben des Spielers in entsprechende Aktionen
um. Drückt der Spieler z. B. die Leertaste wird die Aktion Attackieren“ am
”
Ritter angewendet. Der Ork-Agent führt eine Reihe von Schlussfolgerungen
durch, um die passende Aktion am Ork anzuwenden. Folgende Aktionen gibt
es im Spiel:
Gehe zu: Diese einfache Aktion bewegt den Akteur zu einer bestimmten
Position. Dabei werden keine Hindernisse berücksichtigt. Sobald die
Position erreicht wurde, wird die Aktion beendet.
Pfad verfolgen: Diese Aktion sucht den Pfad zu einer bestimmten Position und bewegt den Akteur auf diesem Pfad zum Ziel. Hindernisse
KAPITEL 4. IMPLEMENTIERUNG
52
werden dabei berücksichtigt. Der Pfad wird mit Hilfe des PfadfinderModuls berechnet. Ein A* Suchalgorithmus (siehe Abschnitt 2.5.1, A*
”
Pfadfinder“) sucht den optimalen Weg. Sobald das Ziel erreicht wurde,
wird die Aktion beendet.
Entität verfolgen: Diese Aktion verfolgt eine beliebige Entität im Spiel.
Die Entität kann der Gegner, ein Schaf, ein Heilpaket oder eine Waffe
sein. Die Aktion ermittelt die Position der Entität und berechnet den
schnellsten Weg, um dorthin zu gelangen. Ändert sich die Position der
Entität, wird der Weg aktualisiert. Die Aktion wird beendet, wenn
die Entität erreicht wurde. Sollte die Entität verschwinden, wird die
Aktion abgebrochen.
Attackieren: Diese Aktion führt einen Schlag des Akteurs durch. Befindet
sich einen andere Entität in unmittelbarer Nähe, wird sie durch den
Schlag Schaden erleiden.
Ork-Aktionen: Der Ork verfügt zusätzlich über die in Abschnitt 4.1.3,
Der Ork“ beschriebenen Aktionen ( Schaf fressen“, Heilen“, Flie”
”
”
”
hen“, Kämpfen“, Waffe sammeln“ und Welt erkunden“). Der Ork”
”
”
Agent verwendet ausschließlich diese Aktionen um den Ork zu steuern.
Aktionen verschachteln
Aktionen können verschachtelt werden und ermöglichen daher eine Mehrebenen-Architektur, wie in Abschnitt 2.5.5, Mehrebenen-Architektur“) vor”
gestellt. Eine Aktion gibt dabei die elementaren Aufgaben an eine darunter
liegende Aktion weiter. Verschiedene Aktionen werden somit in hierarchischer Form verwendet.
Beispiel: Die Abbildung 4.6 zeigt eine verschachtelte Aktion. Die oberste Aktion Schaf fressen“ verwendet die Aktion Entität verfolgen“, um
”
”
zum Schaf zu gelangen. Diese Aktion wiederum verwendet die Aktion Pfad
”
verfolgen“, um einen Weg zu der Entität zu finden und diesem Weg zu folgen. Die Aktion Pfad verfolgen“ verwendet die Aktion Gehe Zu“, um den
”
”
nächsten Wegpunkt zu erreichen. Sobald eine Aktion beendet wird oder fehlgeschlagen ist, wird die nächst höhere Aktion informiert, um entsprechend
zu reagieren.
4.3.2
Ork-Agent
Die Steuerung des Orks wird von dem Ork-Agenten übernommen. Er wählt
die passende Ork-Aktion aus und implementiert die KI des Orks. Hauptfunktion des Agenten ist das eigentliche Schlussfolgern, also was der Ork in
KAPITEL 4. IMPLEMENTIERUNG
53
"Schaf fressen" Aktion
"Entitat verfolgen" Aktion
"Pfad verfolgen" Aktion
"Gehe zu" Aktion
Abbildung 4.6: Eine verschachtelte Aktion verwendet verschiedene Aktionen in hierarchischer Form.
der aktuellen Situation tun soll. Die jeweilige Aktion übernimmt die Umsetzung und kümmert sich um elementare Aufgaben wie z. B. PfadfinderOperationen. Der Agent kann daher die in Abschnitt 2.2, Intelligente Agen”
ten“ beschriebenen Komponenten sehr einfach implementieren.
Sensoren oder Eingabe
Der Agent hat Zugriff auf die gesamten Spieldaten. Ein eigenständiges Sensorensystem ist daher nicht notwendig. Zwar verfügt AIQuest über ein Wahrnehmungssystem, dies wird jedoch nicht benötigt. Der Agent berechnet die
notwendigen Informationen selbst. Folgende Daten sind für ihn interessant:
• Entfernung zum Gegner,
• Entfernung zum nächsten Schaf,
• Entfernung zur nächsten Waffe,
• Entfernung zum nächsten Heilpaket,
• eigener Gesundheitszustand,
• Waffenverfügbarkeit.
Gedächtnis oder Speicher
Der Agent benötigt kein Gedächtnis. Die Schlussfolgerungen werden immer
anhand der aktuellen Situation in der Welt gezogen.
Schlussfolgerung und Analyse
Dieser Teil sucht die aktuell passende Aktion aus. Es verwendet dazu das in
Abschnitt 4.1.3, Der Ork“ beschriebene Verfahren. Es wird für jede Aktion
”
KAPITEL 4. IMPLEMENTIERUNG
54
die Wahrscheinlichkeit ausgerechnet und die mit dem höchsten Wert ausgewählt. Die Zusatzfaktoren werden aus den vorher berechneten Informationen
der Spielwelt ermittelt.
Aktionen
Der Agent verwendet ausschließlich die Ork-Aktionen ( Schaf fressen“, Hei”
”
len“, Fliehen“, Kämpfen“, Waffe sammeln“ und Welt erkunden“), um den
”
”
”
”
Ork zu steuern. Jede Aktion führt die jeweilige Aufgabe durch und der Agent
kann sich auf das eigentliche Schlussfolgern konzentrieren.
Implementierung des Ork-Agenten
Einmal pro Sekunde ermittelt der Ork-Agent die passende Aktion und führt
eine Aktualisierung durch. Es ist übertrieben, dies bei jedem Durchlaufen
der Spielschleife zu berechnen, da unnötig Rechenleistung beansprucht wird.
Damit die aktuelle Situation dennoch laufend überprüft wird, erfolgt die Aktualisierung im Sekundentakt. Hat sich die Situation nicht verändert, wird
der Agent dieselbe Aktion wieder verwenden. Sind jedoch bestimmte Ereignisse eingetreten – z. B. das Auftauchen eines Heilpakets oder der Angriff
des Gegners – wird er sein Verhalten ändern und eine andere Aktion ausführen. Die Aktualisierung wird ebenfalls durchgeführt, wenn eine bestehende
Aktion abgeschlossen wurde oder sich der Gesundheitszustand des Akteurs
drastisch verändert hat.
void UpdateAction() {
// Informationen aus der Welt ermitteln
SensorWorld();
// Wahrscheinlichkeitstabelle aktualisieren
UpdateDecisionTable();
// bestmoegliche Aktion auswaehlen
Action* newAction = GetBestAction();
// Aktion setzen
SetAction(newAction); }
Die Methode UpdateAction() wird pro Sekunde einmal aufgerufen und
wählt eine Ork-Aktion aus. Zunächst werden die notwendigen Informationen
ermittelt. Mit der Methode SensorWorld() wird die Welt analysiert. Wichtige Informationen sind z. B. die Entfernung zum Gegner oder zum nächsten
Heilpaket. Sie werden benötigt um die Zusatzfaktoren der Aktionen zu berechnen.
In den nächsten beiden Schritten erfolgt die Schlussfolgerung. Die Methode UpdateDecisionTable() ermittelt die Wahrscheinlichkeiten der ein-
KAPITEL 4. IMPLEMENTIERUNG
55
zelnen Aktionen und speichert diese in einer internen Wahrscheinlichkeitstabelle. Für jede Aktion wird das entsprechende Attribut mit dem Zusatzfaktor
multipliziert. Die Methode GetBestAction() wählt aus dieser Tabelle die
Aktion mit der höchsten Wahrscheinlichkeit aus und diese kann anschließend
mit SetAction() gesetzt werden.
4.4
Implementierung des genetischen Algorithmus
Die Aufgaben des genetischen Algorithmus werden von der Klasse genetisches System gekapselt. Diese ermöglicht einen flexiblen Einsatz und kann
beliebige Objekte, Daten, künstliche Lebewesen oder Lösungsansätze evolutionär weiterentwickeln. Diese Objekte werden als Individuen bezeichnet
und haben eine beliebige Anzahl von Attributen. Diese Attribute sind Gleitkommazahlen und stellen den genetischen Code des Individuums dar. Die
Individuen werden in einer eigenen Klasse Individuum abgebildet. Das genetische System erlaubt die einfache Anwendung genetischer Operationen auf
die Individuen und kann für die Verwaltung von Populationen verwendet
werden. Zur Evaluierung wird das Interface Bewerter definiert. Ein UMLDiagramm der verschiedenen Klassen ist in Abbildung 4.7 dargestellt.
Individuum: Diese Klasse repräsentiert ein einzelnes Individuum und speichert die Attribute bzw. den genetischen Code. Es bietet Methoden,
um die Attribute zu setzen oder zu lesen. Es können Zusatzinformationen wie z. B. Name, Spezies oder Tauglichkeit ebenfalls mitgespeichert
werden. Im Quellcode wird die Klasse als Individual bezeichnet.
Genetisches System: Diese Klasse wendet die genetischen Operationen
auf die Individuen an und kann darüber hinaus eine Population verwalten und weiterentwickeln. Im Quellcode wird als Name der Klasse
die englische Bezeichnung GeneticSystem verwendet.
Bewerter: Der Bewerter ist ein Interface, dass von der Anwendung implementiert wird, um die Individuen zu evaluieren. Das Interface hat im
Quellcode den Name iEvaluator.
Das genetische System kann auf unterschiedliche Weise verwendet werden, um einen flexiblen Einsatz zu ermöglichen. Die Anwendung kann entweder nur die genetischen Operationen anwenden oder die Weiterentwicklung
der Population gänzlich dem genetischen System überlassen. Man unterscheidet zwischen drei Stufen:
Manuel: Die Anwendung verwendet nur die genetischen Operationen. Die
Verwaltung und Weiterentwicklung der Population wird selbst vorgenommen.
KAPITEL 4. IMPLEMENTIERUNG
GeneticSystem
-population: IndividualList
-evaluator: iEvaluator
Genetische Operationen:
+InitializePopulation(prototype: Individual,
sizeOfPopulation: int)
+SelectIndividual(): Individual
+Crossover(a: Individual, b: Individual): Individual
+Mutate(individual: Individual)
+Randomize(individual: Individual)
+AddToPopulation(individual: Individual)
Weiterentwicklung der Population:
+EvaluatePopulation()
+GenerateNewGeneration(sizeOfPopulation: int)
+Evolve(fitness: float, maxstep: int)
56
Individual
-name: string
-parent: string
-spezies: string
-attributes: AttriubteMap
+AddAttribute(name: string)
+RemoveAttribute(name: string)
+SetAttribute(name: string, value: float)
+GetAttribute(name: string): float
+HasAttribute(name: string): bool
<<interface>>
iEvaluator
+Evaluate(individual: Individual): float
Abbildung 4.7: Ein UML-Diagramm der Klassen, die bei der Implementierung des genetischen Algorithmus verwendet werden.
Unterstützend: Die Anwendung überlässt die Verwaltung der Population
der Klasse. Sie entscheidet jedoch selber, welche Individuen weiterentwickelt, entfernt oder hinzugefügt werden.
Automatisch: Die Anwendung überlässt die Verwaltung und Weiterentwicklung der Population dem genetischen System. Es muss lediglich
ein Bewerter implementiert werden, der die Tauglichkeit berechnet.
4.4.1
Individuum
Das Individuum ist ein einzelnes Lebewesen in der Population und speichert
den genetischen Code in Form von Attributen. Ein Beispielindividuum ist
in Tabelle 4.2 beschrieben. Folgende Informationen werden in dieser Klasse
gespeichert:
Name: Der Name des Individuums. Automatisch generierte Individuen erhalten eine fortlaufende Nummer.
Eltern: Die Eltern des Individuums. Der Name der Eltern gibt Auskunft
über die Herkunft des Individuums. Da nur die Namen der beiden
Eltern gespeichert werden, ist es wichtig, dass jedes Individuum einen
einzigartigen Namen hat. Nur dann kann die Herkunft genau bestimmt
werden.
Spezies: Die Spezies des Individuums. Das genetische System kann nur
Individuen derselben Spezies kreuzen. Die Spezies wird von den Eltern
übernommen.
KAPITEL 4. IMPLEMENTIERUNG
Name
Eltern
Spezies
Tauglichkeit
Attribute
57
Ork14
Ork02, Ork05
Ork
0,5
Angst
0,5
Mut
1,0
Neugier
0,1
Ausdauer 0,4
Hunger
0,25
Intelligenz 0,75
Tabelle 4.2: Ein Beispielindividuum.
Attribute: Eine Liste mit Attributen. Die Attribute werden in einem assoziativen Array gespeichert, wobei der Name des Attributes den Schlüssel darstellt. Beim Kreuzen erhält das Individuum automatisch alle
Attribute der Eltern.
Tauglichkeit: Das Ergebnis der Fitnessfunktion. Diese wird nachträglich
festgestellt. Solange das Individuum nicht evaluiert wurde, hat die
Tauglichkeit einen negativen Wert (-1).
Interface
Die Klasse verfügt über ein einfaches Interface zum Bearbeiten der Attribute
und der Tauglichkeit.
void AddAttribute(const string& name, float value = 0.0f);
void RemoveAttribute(const string& name);
Mit diesen beiden Methoden werden dem Individuum neue Attribute hinzugefügt oder bestehende entfernt. Neuen Attributen kann bereits ein konkreter Wert zugewiesen werden.
void SetAttribute(const string& name, float value);
float GetAttribute(const string& name) const;
bool HasAttribute(const string& name) const;
Die Attribute des Individuums können beliebig gesetzt und gelesen werden.
Bei unbekannten Individuen ist es sinnvoll, zunächst abzufragen, ob ein Attribut existiert.
KAPITEL 4. IMPLEMENTIERUNG
58
void SetEvaluation(float evaluation);
float GetEvaluation() const;
Zum Setzen und Lesen der Tauglichkeit werden diese beiden Methoden verwendet. Der Wert der Tauglichkeit liegt gewöhnlich zwischen 0 und 1. Wurde
das Individuum noch nicht evaluiert, ist die Tauglichkeit negativ.
Speichern als XML-Knoten
Individuen können in einem XML-Dokument gespeichert werden. Die Daten
werden dabei in lesbarer Form gespeichert und können von anderen Anwendungen weiterverarbeitet werden. Es ist auch möglich, Individuen aus einem
bestehenden XML-Dokument zu laden. So können die Ergebnisse einfach
zwischengespeichert und später wieder verwendet werden. Nähere Informationen darüber sind in Anhang A.1 angeführt.
4.4.2
Genetische Operationen
Die genetischen Operationen können vom genetischen System einfach durchgeführt werden. Details zur Implementierung der Operationen finden sich in
Anhang A.2.
Initialisierung einer Population
void InitializePopulation(const Individual* prototyp,
int numberOfPopulation);
Diese Methode generiert die Initialpopulation. Dabei muss ein Prototyp angegeben werden. Dieser Prototyp ist ein Individuum mit einem Speziesnamen und verschiedenen Attributen. Alle neu initialisierten Individuen haben
die gleichen Attribute und den gleichen Speziesnamen. Die Attribute der
neuen Individuen werden mit Zufallszahlen gefüllt. Dazu wird die Funktion
Randomize() verwendet.
Selektion
Individual* SelectIndividual(Individual* except = NULL) const;
Bei der Selektion wird ein Individuum aus der bestehenden Population ausgewählt. Individuen mit einer hohen Tauglichkeit haben eine höhere Wahrscheinlichkeit, dass sie ausgesucht werden, als Individuen mit einer geringen
Tauglichkeit. Um den zweiten Elternteil aus der Population zu finden, kann
ein Individuum übergeben werden, das bei der Selektion ausgeschlossen wird.
Damit wird verhindert, dass zwei Mal dasselbe Individuum ausgewählt wird.
KAPITEL 4. IMPLEMENTIERUNG
59
Kreuzung
Individual* Crossover(const Individual* a, const Individual* b) const;
Bei der Kreuzung werden die Attribute der Eltern kombiniert, um ein neues
Individuum zu generieren. Die Attribute der Nachkommen stammen dabei
jeweils zur Hälfte von den beiden Elternteilen.
Mutation
void Mutate(Individual* individual) const;
Bei der Mutation werden die Attribute des Individuums geringfügig verändert. Für jedes Attribut besteht die Wahrscheinlichkeit, dass eine Mutation stattfindet. Die Mutationsrate gibt dabei an, wie häufig eine Mutation
auftritt und kann mit SetMutationRate() beliebig gesetzt werden.
Zufällige Generierung
void Randomize(Individual* individual) const;
Bei der Initialisierung der Population ist es wichtig, verschiedenenartige Individuen zu generieren. Dazu werden die Attribute der ersten Individuen
mit zufälligen Werten gesetzt. Die Methode durchläuft alle Attribute des
Individuums und weist ihnen eine Zufallszahl zwischen 0 und 1 zu.
Austausch
void AddToPopulation(Individual* individual);
Mit der Methode AddToPopulation() kann ein neu geschaffenes Individuum
der Population hinzugefügt werden.
4.4.3
Evaluierung
Die wichtigste Aufgabe in einem genetischen Algorithmus ist die Bestimmung der Tauglichkeit der Individuen. Die Berechnung muss von der Anwendung übernommen werden. Beim manuellen oder unterstützenden Einsatz
des genetischen Systems kann die Anwendung die Tauglichkeit direkt bei
dem Individuum setzen. Die Individuum Klasse verfügt dazu über die Methode SetEvaluation(). Beim automatischen Einsatz übernimmt ein Bewerter (Evaluator) diese Aufgabe. Das Interface iEvaluator muss dabei
vom Bewerter implementiert werden.
KAPITEL 4. IMPLEMENTIERUNG
60
Genetisches System
Population
Individuum
Individuum
Individuum
Name: Prototyp
Spezies: Ork
Name: Ork01
Spezies: Ork
Name: Ork02
Spezies: Ork
Mut
Ausdauer
Intelligenz
Mut
Ausdauer
Intelligenz
Mut
Ausdauer
Intelligenz
0,1
1,0
0,5
0,6
0,3
0,8
Abbildung 4.8: Das genetische System verwaltet eine Population mit einer
beliebigen Anzahl an Individuen. Die Spezies und die Attribute der Individuen werden von einem Prototyp definiert.
virtual float Evaluate(const Individual* individual) = 0;
Die Methode Evaluate() wird vom genetischen System aufgerufen, wenn
ein Individuum evaluiert werden muss. Die Methode soll die Tauglichkeit im
Wertebereich 0 bis 1 zurückgeben. Der Bewerter muss am Beginn mit der
Methode SetEvaluator(iEvaluator* evaluator) gesetzt werden.
4.4.4
Laden und Speichern einer Population
Populationen können in einer Datei gespeichert, oder aus einer Datei geladen
werden. Dazu wird das XML-Format verwendet. Dies hat den Vorteil, dass
die Individuen in lesbarer Form gespeichert werden und von anderen Anwendungen einfach weiterverwendet werden können. Nähere Informationen
darüber sind in Anhang A.3 angeführt.
4.4.5
Weiterentwicklung einer Population
Das genetische System kann eine Population von beliebigen Individuen verwalten. Ein Prototyp legt die Spezies und die Attribute der Individuen in
der Population fest. Das Zusammenspiel wird in Abbildung 4.8 illustriert.
Das genetische System stellt einige Methoden zur Weiterentwicklung der
Population zur Verfügung.
void EvaluatePopulation();
Diese Methode sorgt für die Evaluierung der aktuellen Population. Jedes Individuum wird dabei vom gesetzten Bewerter evaluiert, um die Tauglichkeit
zu bestimmen.
KAPITEL 4. IMPLEMENTIERUNG
61
void GenerateNewGeneration(int sizeOfPopulation);
Aus der aktuellen Population wird eine neue Generation generiert. Die alte
Population wird gelöscht und durch die neue Generation ersetzt. Die Größe
der neuen Population wird als Parameter übergeben. Die neuen Individuen
sind noch nicht evaluiert.
void Evolve(float fitness, int maxstep = 1000);
Sobald eine Initialpopulation vorhanden ist und ein Bewerter gesetzt wurde,
kann mit dieser Methode die Evolution gestartet werden. Die Individuen werden solange weiterentwickelt, bis die übergebene Durchschnitts-Tauglichkeit
erreicht wird. Ist dies nicht möglich, wird der Evolutionsprozess beim Erreichen einer bestimmten Generation gestoppt. Standardmäßig endet die Evolution in der 1000. Generation. Dies kann mit dem zweiten Parameter selbst
bestimmt werden. Eine Beispiel zur Anwendung des genetischen Systems
wird in Anhang A.4 gezeigt.
4.5
Weiterentwicklung des Orks
Im Lernmodus wird der Ork mit Hilfe eines genetischen Algorithmus weiterentwickelt. Ziel der Weiterentwicklung ist es, die richtigen Attribute zu
finden und den besten“ Ork zu formen. Der entwickelte Ork soll für den
”
Spieler schließlich eine echte Herausforderung darstellen. Für die Entwicklung wird das in Abschnitt 4.4, Implementierung des genetischen Algorith”
mus“ vorgestellte genetische System unterstützend verwendet. Das heißt,
dass die genetischen Operationen verwendet werden und die Verwaltung der
Population vom genetischen System übernommen wird. Die Steuerung des
Evolutionsvorgangs wird jedoch selber vorgenommen.
Zunächst wird ein Prototyp des Ork-Individuums definiert. Er hat die
Attribute Hunger, Ausdauer, Angst, Mut, Intelligenz und Neugier und besitzt damit die gleichen Attribute wie ein Ork im Spiel. Im weiteren Verlauf
wird daher allgemein der Begriff Ork verwendet. Je nach Kontext bezieht
sich der Begriff auf das Individuum im genetischen System oder auf den
Akteur im Spiel.
Die Orks werden im Lernmodus weiterentwickelt. Dazu wird als Erstes eine Initialpopulation angelegt. Durch Kreuzung und Mutation werden unterschiedliche Orks mit verschiedenen Attribut-Kombinationen getestet. Orks mit hoher Tauglichkeit werden eher weiterverwendet als erfolglose.
Nach einer bestimmten Entwicklungszeit sollten die besten Attribute gefunden sein.
Die Tauglichkeit wird im Spiel ermittelt. Zwei Orks treten dabei gegenseitig an. Die Attribute der beiden Individuen werden ausgelesen und
KAPITEL 4. IMPLEMENTIERUNG
62
Abbildung 4.9: Die Tauglichkeit kann aus dem Abschneiden der Orks im
Spiel berechnet werden. Der Enddialog zeigt alle wichtigen Informationen an.
bestimmen gleichzeitig die Attribute der Orks im Spiel. Da beide Figuren
vom Computer gesteuert werden, läuft das Spiel automatisch ab. Der Benutzer kann das Geschehen jedoch beobachten. Nach dem Level wird das
Verhalten der beiden evaluiert. Die Tauglichkeit ermittelt sich dabei aus
dem Abschneiden des jeweiligen Orks im Spiel.
4.5.1
Evaluierung
Um den Erfolg der Orks im Spiel zu messen, wird ihr Verhalten im Spiel
beobachtet. Dazu werden verschiedene Ereignisse im Spiel mitprotokolliert.
So wird z. B. erfasst, wie viele Schafe ein Ork gefressen, wie viele Heilpakete er gesammelt und welchen Schaden er beim Gegner verursacht hat. Im
Enddialog des Spieles in Abbildung 4.9 werden diese Daten übersichtlich
dargestellt. Aus diesen Informationen kann die Evaluierung mit Hilfe der
folgenden Fitnessfunktion durchgeführt werden:
f =
Überlebt
Gegner
Schafe
Überlebt · 0,5 + Gegner · 0,25 + Schafe · 0,1
1,75
0≤f ≤1
1: Ork hat überlebt, 0: Ork ist gestorben,
Anzahl der getöteten Gegner,
Anzahl der gefressenen Schafe.
(4.1)
KAPITEL 4. IMPLEMENTIERUNG
63
Alte Generation
Tauglichkeit
Neue Generation
Ork 1
0,71
Ork 7
Ork 2
0,5
Ork 8
Ork 3
0,1
Ork 9
Ork 4
0,9
Ork 10
Ork 5
0,25
Ork 11
Ork 6
0,6
Ork 12
2
3
4
Evaluierung
Selektion
Kreuzung
Abbildung 4.10: Die drei wichtigsten Schritte bei der Weiterentwicklung
des Orks: Evaluierung, Selektion und Kreuzung.
4.5.2
Evolution
Die Weiterentwicklung des Orks erfolgt in fünf Schritten. Es wird eine Generations-Population (siehe Abschnitt 3.4.2, Population“) verwendet. Jede
”
neue Generation bildet daher eine neue Population. Die wichtigsten Schritte
(Evaluierung, Selektion und Kreuzung) werden in Abbildung 4.10 aufgezeigt. Die Ergebnisse der Ork-Evolution und eine detaillierte Analyse des
genetischen Algorithmus finden sich im nächsten Kapitel.
1. Initialisierung: Die Orks der Initialpopulation werden zufällig generiert und bilden die erste Generation.
2. Evaluierung: Die Orks der Population werden evaluiert. Dabei treten
die Orks nach der Reihe gegeneinander an. Das Spiel wird mit den
beiden Orks gestartet, um ihre Tauglichkeit zu ermitteln.
3. Selektion: Nachdem von allen Orks die Tauglichkeit ermittelt wurde,
werden jeweils zwei Orks ausgewählt. Die Orks mit einer hohen Tauglichkeit werden bevorzugt selektiert.
4. Kreuzung und Mutation: Die selektierten Orks werden gekreuzt,
um einen neuen Ork zu generieren. Dieser wird anschließend geringfügig mutiert. Die Schritte 3 und 4 werden solange wiederholt, bis es
gleich viele neue Orks wie in der bestehenden Population gibt. Die
Orks stellen die neue Generation dar.
5. Austausch: Die Orks der neuen Generation ersetzen die alte Population. Es wird mit dem zweiten Schritt fortgefahren.
Kapitel 5
Resultate
Im Lernmodus von Evolving Ogre werden die richtigen Attribute für den
Ork ermittelt. Der KI-Designer muss die Attribute nicht selber definieren,
sondern überlässt dem in Abschnitt 4.4, Implementierung des genetischen
”
Algorithmus“ vorgestellten genetischen Algorithmus die Wahl der Attribute.
Im folgenden Kapitel werden die Resultate des Algorithmus vorgestellt, der
Verlauf der Evolution analysiert, Vorteile des genetischen Algorithmus erörtert und mögliche Erweiterungen aufgezeigt.
5.1
Messgrößen
Um den Evolutionsprozess zu analysieren, werden verschiedene Messgrößen
definiert. Die genaue Berechnung ist in Anhang B, Mathematische Defini”
tion“ nachzulesen. Ein genauer Überblick über Messgrößen in genetischen
Algorithmen findet sich in [21].
Durchschnitts-Tauglichkeit: Die durchschnittliche Tauglichkeit aller Individuen in der Population wird als Durchschnitts-Tauglichkeit definiert.
Durchschnittliches Individuum: Das durchschnittliche Individuum ist
der Mittelwert aller Individuen in der Population.
Distanz: Die Distanz gibt den Unterschied zweier Individuen an. Je höher
die Distanz zwischen zwei Individuen ist, desto unterschiedlicher sind
deren Attribute.
Standardabweichung: Die Standardabweichung gibt an, wie unterschiedlich die Individuen der Population sind.
64
KAPITEL 5. RESULTATE
Name
Spezies
Attribute
65
Prototyp
Testindividuum
Mut
Hunger
Intelligenz
Tabelle 5.1: Das Individuum der Testevolution.
5.2
Testevolution
Zunächst wird der genetische Algorithmus an einem einfachen Beispiel überprüft, um die richtigen Parameter für den Evolutionsprozess in Evolving
Ogre zu finden. Es soll gezeigt werden, dass der Algorithmus in der Lage
ist, eine Population weiter zu entwickeln und der Verlauf der Evolution soll
dargestellt werden. Die Testevolution kann schneller berechnet werden, da
nicht das Spiel zur Ermittlung der Tauglichkeit simuliert werden muss. Unterschiedliche Evolutionsparameter können einfach getestet werden, ohne
mehrere Stunden auf das Ergebnis zu warten.
5.2.1
Evolutionsparameter
Individuum
Für die Testevolution wird ein einfaches Individuum mit nur drei Attributen
(Mut, Hunger, Intelligenz) verwendet. Das Individuum ist in der Tabelle
5.1 beschrieben. Die geringe Anzahl der Attribute ermöglicht eine rasche
Evolution, da wenige Attributkombinationen getestet werden müssen.
Evaluierung
Es wird eine einfache Fitnessfunktion verwendet, um die Tauglichkeit der Individuen festzustellen. Die drei Attribute werden summiert und durch drei
dividiert. Ein Individuum, mit hohen Attributwerten erzielt somit eine höhere Tauglichkeit. Ziel der Entwicklung ist es daher, die Attributwerte zu
maximieren.
f=
Mut + Hunger + Intelligenz
3
(5.1)
Populationsart
Wie bei der Evolution im Spiel wird eine Generationen-Population verwendet. Die neuen Individuen bildet eine eigene neue Population.
KAPITEL 5. RESULTATE
66
Populationsgröße
Die Größe der Population ist wichtig, um genügend verschiedenartige Individuen zu haben. Verschiedene Größen sollen ausprobiert werden, um die
richtige Populationsgröße zu finden. Folgende Größen werden verwendet:
• 5 Individuen,
• 10 Individuen,
• 20 Individuen,
• 40 Individuen,
• 100 Individuen.
Mutationsrate
Die Mutationsrate gibt an, wie häufig eine Mutation auftritt. Verschiedene
Raten sollen ausprobiert werden, um den Einfluss der Mutationsrate auf die
Evolution festzustellen. Folgende Raten werden verwendet:
• 0 (keine Mutation),
• 0,0001 (0,01% Mutation),
• 0,001 (0,1% Mutation),
• 0,01 (1% Mutation),
• 0,1 (10% Mutation),
• 1 (100% Mutation).
5.2.2
Ergebnisse
Die Evolution wird mehrmals für jede Parameterkombination bis zum Erreichen der Durchschnitts-Tauglichkeit 0,9 durchgeführt. Die Ergebnisse finden sich in der Tabelle 5.2. Durch den Einsatz von Zufallszahlen verläuft die
Entwicklung jedes Mal anders und die Ergebnisse können variieren. Es wird
daher für jede Kombination der Median von 11 verschiedenen Evolutionsdurchläufen angegeben. Der Median ist in diesem Fall sehr aussagekräftig, da
Ausreißer nicht berücksichtigt werden. Die Ergebnisse sind durchwegs erfolgreich. Nur in wenigen Kombinationen konnte die gewünschte DurchschnittsTauglichkeit nicht erreicht werden.
Populationsgröße
Generell kann festgestellt, dass größere Populationen weniger Generationen
benötigen, um die gewünschte Tauglichkeit zu erreichen. In einer großen Population ist die Anzahl unterschiedlicher Attributwerte höher und der Algorithmus hat eine größere Auswahl als bei kleinen Populationen. Andererseits
KAPITEL 5. RESULTATE
67
Mutationsrate
0
0,0001
0,001
0,01
0,1
1
5
746
100
31
105
Populationsgröße
10
20
40 100
10
4
4
7
5
4
314
6
4
4
28
5
5
3
8
6
5
4
66 312 253
-
Tabelle 5.2: Anzahl der Generationen, die eine Evolution mit unterschiedlicher Mutationsrate und Populationsgröße benötigt, um die DurchschnittsTauglichkeit von 0,9 zu erreichen.
ist der Rechenaufwand für große Populationen höher. Zum Beispiel müssen
in einer Population mit der Größe 100 für jede Generation 200 Individuen
selektiert und 100 neue Individuen generiert und evaluiert werden. In einer
Population mit der Größe 10 werden nur 20 Individuen selektiert und 10
neue generiert und evaluiert.
Beispiel: Die Anzahl der Generationen bei einer Mutationsrate von 0,01
beträgt bei einer Population mit der Größe 10: 28 und bei einer Population
mit der Größe 100: 3. Das heißt, dass bei den ersten 280 (28 * 10) Individuen
und bei der zweiten Populationsgröße 300 (100 * 3) Individuen generiert
werden. Der Rechenaufwand ist daher für die größere Population geringfügig
höher.
Mutationsrate
Interessant ist der Einfluss der Mutationsrate. Während eine hohe Mutationsrate bei kleinen Generationen bessere Ergebnisse verursacht, verschlechtert sich bei großen Populationen der Evolutionsprozess. So erreicht man bei
den Populationsgrößen 5 und 10 mit 0,1 und bei den restlichen Populationsgrößen mit 0,01 und 0,001 die schnellste Evolution. Dies ist einfach erklärt.
Kleine Populationen haben nur wenige Individuen. Es fehlen daher genügend unterschiedliche Attributwerte. Der Algorithmus ist auf die Mutation
angewiesen, um neue Attributwerte zu finden. In großen Populationen ist
eine hohe Mutationsrate eher ein Nachteil. Erfolgreiche Attributwerte werden durch die Mutation häufig verändert und gehen verloren. Die beiden
Extremwerte 0 (keine Mutation) und 1 (100% Mutation) sind wenig zielführend. Obwohl teilweise die Durchschnitts-Tauglichkeit erreicht werden
konnte, sollte sie nur in begründeten Fällen verwendet werden. In [2, 16, 25]
wird eine Mutationsrate von 0,001 empfohlen.
KAPITEL 5. RESULTATE
68
1
0.9
0.8
0.7
0.6
0.5
Tauglichkeit
0.4
Abweichung
0.3
Zieltauglichkeit
0.2
0.1
0
1
2
3
4
5
6
7
8
9
10
Abbildung 5.1: Entwicklung der Durchschnittstauglichkeit in einer Testevolution.
5.2.3
Verlauf
In Abbildung 5.1 ist ein Beispiel eines Evolutionsverlaufes (Mutationsrate
0,01 und Populationsgröße 20) dargestellt. Es wird der Verlauf der Durchschnitts-Tauglichkeit und der Standardabweichung aufgezeigt. Die Durchschnitts-Tauglichkeit beträgt zu Beginn 0,5. Die Standardabweichung ist in
den ersten beiden Generationen am höchsten und nimmt bis zur sechsten
Generation drastisch ab. Parallel steigt die Durchschnitts-Tauglichkeit und
flacht nach der sechsten Generation stark ab. Die Individuen sind zu ähnlich,
um eine rasche Weiterentwicklung zu ermöglichen. Die Evolution ist auf die
Mutation angewiesen, um neue Attributwerte zu finden. Generell kann festgestellt werden, dass die Durchschnitts-Tauglichkeit zu Beginn stark steigt
und nach einigen Generationen abflacht.
Selektion und Kreuzung
In Abbildung 5.2 ist der Selektions- und Kreuzungsprozess exemplarisch illustriert. Die Abbildung soll die Funktionsweise des genetischen Algorithmus
zeigen. Jeder Kreis stellt ein Individuum mit der jeweiligen Tauglichkeit dar.
Es werden jeweils zwei Individuen selektiert, um ein neues Individuum in der
nächsten Generation zu formen. Jedes Individuum hat daher zwei Vorfahren
aus der vorhergehenden Generation. Der Stammbaum des dritten Individuums der vierten Generation ist hervorgehoben. Anhand dieses kann man
die Entwicklung eines einzelnen Individuums beobachten. Zwei Individuen
werden miteinander kombiniert und formen ein neues, besseres Individuum.
Dieses wird mit einem anderen kombiniert, um wiederum ein besseres Individuum zu bilden. Erfolgreiche Individuen werden bevorzugt selektiert.
Individuen mit einer hohen Tauglichkeit haben daher mehr Nachkommen.
KAPITEL 5. RESULTATE
69
1. Generation
(Initialgeneration)
0,48
0,1
0,74
0,61
0,2
0,69
2. Generation
0,68
0,5
0,88
0,6
0,85
0,72
3. Generation
0,61
0,81
0,34
0,91
0,92
0,87
4. Generation
0,87
0,72
0,91
0,92
0,93
0,86
Abbildung 5.2: Selektions- und Kreuzungsprozess über mehrere Generationen. Jeder Kreis stellt ein Individuum mit der jeweiligen Tauglichkeit dar.
Erfolglose Individuen werden nicht weiterentwickelt. Von Generation zu Generation steigt daher die Durchschnitts-Tauglichkeit.
5.3
Ork-Evolution
Die Ergebnisse der Testevolution werden verwendet, um die richtigen Parameter für die Ork-Evolution zu wählen. Die Entwicklung erfolgt im Lernmodus von Evolving Ogre.
5.3.1
Evolutionsparameter
Fitnessfunktion
Die Tauglichkeit berechnet sich aus dem Abschneiden des Orks im Spiel.
Zwei Orks treten gegeneinander an, um die Tauglichkeit zu ermitteln. Das
Spiel wird simuliert und das Verhalten der Orks beobachtet. In Abschnitt
4.5.1, Evaluierung“ wird beschrieben, wie die für die Evaluierung notwendi”
gen Informationen ermittelt werden und welche Fitnessfunktion verwendet
wird.
Populationsart
Für die Entwicklung der Orks wird eine Generationen-Population verwendet.
Die Tauglichkeit eines Orks ist abhängig von der Stärke des anderen Orks,
gegen den er im Spiel antritt. Da die Orks durch die Evolution mit der
KAPITEL 5. RESULTATE
70
Zeit stärker werden, ist die Tauglichkeit eines älteren Individuums nicht
mehr aktuell. Die Individuen müssen daher ständig neu evaluiert werden.
Aus diesem Grund bilden neue Individuen eine neue Population, um eine
laufende Evaluierung zu garantieren.
Populationsgröße
Die Ork-Population wird mit 16 relativ klein definiert. Dies liegt daran,
dass bei der Evaluierung das Spiel simuliert wird. Obwohl die Simulation
beschleunigt werden kann, dauert die Evaluierung entsprechend lange. Ziel
ist es daher, die Anzahl der Evaluierungen möglichst zu reduzieren. Wie in
Abschnitt 5.2.2, Ergebnisse“ gezeigt, benötigt eine größere Population zwar
”
weniger Generationen, jedoch werden teilweise mehr Individuen generiert
und evaluiert. Trotzdem ist die gewählte Populationsgröße mit 16 Individuen
etwas gering. Doch ist sie ausreichend um zufrieden stellende Ergebnisse zu
erzielen.
Mutationsrate
Als Mutationsrate wird 0,01 verwendet. In der Testevolution hat sich gezeigt,
dass diese Rate bei einer Populationsgröße von 20 die besten Ergebnisse
erzielt.
5.3.2
Annahmen
Bevor die Ork-Evolution gestartet wird, werden einige Annahmen zum Endergebnis gemacht. Vermutlich wird die Neugier den geringsten Wert haben.
Ein Ork, der nur planlos marschiert, wird eine geringe Tauglichkeit erreichen. Mut und Hunger werden sehr hoch sein. Die Intelligenz wird einen
besonders hohen Wert erreichen, da ein Ork zunächst eine Waffe sammeln
sollte, um im Zweikampf zu bestehen.
5.3.3
Evolution
Initialpopulation
Die ersten 16 Orks werden zufällig generiert. Sie stellen die Initialpopulation
dar. Wichtig ist, dass die Individuen unterschiedliche Werte haben und die
Standardabweichung entsprechend hoch ist. In Abbildung 5.3 sind die Orks
der ersten Generation in einem Diagramm mit gestapelten Säulen dargestellt. Anstatt der Absolutwerte der einzelnen Attribute wird der Prozentanteil am Gesamtwert aller Attribute eines Individuums zur Darstellung
herangezogen. Diese Form wurde deshalb gewählt, da sie die Gewichtung
der Attribute am Besten visualisiert. Auch können die Individuen dadurch
leichter verglichen werden. Der erste Balken stellt das durchschnittliche Individuum dar.
KAPITEL 5. RESULTATE
71
100%
80%
Angst
Mut
60%
Neugier
Ausdauer
40%
Hunger
Intelligenz
20%
D
ur
ch
sc
hn
O itt
gr
O e1
gr
O e2
gr
O e3
gr
O e4
gr
O e5
gr
O e6
gr
O e7
gr
O e8
g
O re
gr 9
O e1
gr 0
O e1
gr 1
O e1
gr 2
O e1
gr 3
O e1
gr 4
O e1
gr 5
e
16
0%
Abbildung 5.3: Die Initialpopulation.
Dritte Generation
In Abbildung 5.4 ist die dritte Generation aufgelistet. Die Orks sind noch
sehr unterschiedlich. Es können bereits vereinzelte Trends beobachtet werden. So sind z. B. die Werte für Neugier und Ausdauer bei allen Individuen
sehr gering, während die Werte für Hunger und Mut allgemein sehr hoch
sind. Dieser Trend kann auch am durchschnittlichen Individuum abgelesen
werden. Die Werte für Angst und Intelligenz sind noch sehr unterschiedlich.
33. Generation
Nach einer Stunde erreicht die Evolution die 33. Generation. Diese ist in
Abbildung 5.5 dargestellt. Die Orks haben alle sehr ähnliche Werte. Der
Evolutionsprozess ist somit beinahe abgeschlossen. Wird die Evolution fortgesetzt, können die Attributwerte durch Mutation weiter verändert werden.
Dieser Prozess ist jedoch langwierig und wird viele Generationen dauern.
Auffällig ist, dass Mut und Hunger sehr hohe Werte haben, während die
Angst bei allen Orks sehr gering ist. Schwankungen bei den Werten gibt es
noch bei Hunger und Neugier.
Verlauf
In der Abbildung 5.6 ist die Entwicklung des durchschnittlichen Individuums
dargestellt. Jede Linie zeigt dabei die Entwicklung eines einzelnen Attributs.
In diesem Diagramm werden die Absolutwerte verwendet. Zusätzlich wird
die Standardabweichung angezeigt. Während in den ersten vier Generatio-
D
sc
O hnit
gr t
O e5
gr 13
O e5
gr 14
O e5
gr 15
O e5
gr 16
O e5
gr 17
O e5
gr 18
O e 51
gr 9
O e5
gr 20
O e 52
gr 1
O e5
gr 22
O e5
gr 23
O e5
gr 24
O e5
gr 25
O e5
gr 26
O e5
gr 27
e
52
8
ch
ur
sc
h
O nitt
gr
O e3
gr 3
O e3
gr 4
O e3
gr 5
O e3
gr 6
O e3
gr 7
O e3
gr 8
O e 39
gr
O e4
gr 0
O e 41
gr
O e4
gr 2
O e4
gr 3
O e4
gr 4
O e4
gr 5
O e4
gr 6
O e4
gr 7
e
48
ch
ur
D
KAPITEL 5. RESULTATE
80%
60%
40%
20%
80%
60%
40%
20%
0%
Abbildung 5.5: Die 33. Generation der Orks.
72
100%
Angst
Mut
Neugier
Ausdauer
Hunger
Intelligenz
0%
Abbildung 5.4: Die dritte Generation der Orks.
100%
Angst
Mut
Neugier
Ausdauer
Hunger
Intelligenz
KAPITEL 5. RESULTATE
73
1
0.9
0.8
0.75
0.7
0.65
0.6
Angst
Mut
Neugier
0.5
Ausdauer
0.4
0.37
0.35
0.3
0.25
0.2
0.1
Hunger
Intelligenz
Abweichung
0.08
0
1
5
9
13
17
21
25
29
33
Generation
Abbildung 5.6: Die Entwicklung des durchschnittlichen Individuums über
mehrere Generationen.
nen die einzelnen Attributwerte stark variieren, stabilisieren sie sich ab der
sechsten Generation. Die Attributwerte pendeln sich anschließend ein. Die
Standardabweichung nimmt in den ersten Generationen stark ab.
5.3.4
Ergebnis
Die Evolution wurde mehrere Male durchgeführt. Überraschend dabei sind
die Ähnlichkeiten der Resultate. Im Folgenden werden die einzelnen Attributwerte des durchschnittlichen Individuums anhand der vorher gezeigten Evolution kommentiert. Auf Abweichungen in anderen Evolutionen wird
ebenfalls eingegangen.
Hunger
Der Hunger ist mit 0,75 sehr hoch und ist sogar höher als der Mut. Der Ork
wird daher versuchen, zuerst die Schafe zu fressen und dann den Gegner
anzugreifen. Dieses Verhalten kann auf das Spielende zurückgeführt werden.
Sobald ein Ork stirbt, wird das Spiel beendet. Der Ork hat dann keine Möglichkeit mehr, die Schafe zu fressen. Es ist daher besser, die Schafe zuerst zu
fressen und dann den Gegner zu attackieren. In allen Evolutionen erreichte
der Hunger den höchsten Wert.
KAPITEL 5. RESULTATE
74
Angst
Die Angst hat den Wert 0,08. Der Ork wird daher in sehr wenigen Fällen
vor dem Gegner fliehen. Dieses Verhalten kann auf die Implementierung
zurückgeführt werden. Die Fliehen“-Aktion ist sehr einfach, und steuert den
”
Ork immer vom Gegner weg. Hindernisse werden dabei nicht berücksichtigt
und so kann es sein, dass der Ork in einer Sackgasse landet. In einigen
wenigen Evolutionen erreichte die Angst dennoch einen höheren Wert.
Intelligenz
Die Intelligenz hat den Wert 0,25. Sie ist verhältnismäßig gering und der
Ork wird den Gegner angreifen, bevor er eine Waffe hat. Die Annahme, dass
Orks als erstes eine Waffe sammeln, hat sich daher nicht bestätigt. Dies
kann daran liegen, dass zu viele Waffen im Spiel platziert werden und der
Ork automatisch eine Waffe beim Vorbeigehen“ einsammelt.
”
Mut
Der Mut ist mit 0,65 etwas geringer als der Hunger. Der Ork wird daher
den Gegner erst angreifen, wenn keine Schafe in der Nähe sind. In allen
Evolutionen lag der Wert unter dem Wert des Hungers.
Ausdauer
Die Ausdauer liegt mit 0,35 im unteren Bereich. Der Ork wird sich in einem
Kampf öfter heilen und nicht verbissen bis zum bitteren Ende kämpfen. In
anderen Evolutionen lag die Ausdauer etwas unterhalb von 0,35.
Neugier
Die Neugier ist mit 0,37 höher als angenommen. Trotzdem wird der Ork nur
in seltenen Fällen planlos durch die Spielwelt laufen. Da Mut und Hunger
viel höher sind, wird er bevorzugt Schafe fressen oder den Gegner angreifen.
Nur wenn keine Objekte in der Nähe sind, wird er die Welt erkunden.
5.3.5
Testspiel
Im Testspiel zeigt sich, dass der entwickelte Ork ein sehr robustes Verhalten
hat. Er beginnt zunächst, ein Schaf nach dem anderen zu fressen. Den Spieler
attackiert er jedoch erst sehr spät. Der Evolutionsprozess kann nun entweder
mit einer veränderten Fitnessfunktion, die den Schafen weniger Bedeutung
gibt, erneut gestartet werden. Oder die Werte für Mut und Hunger werden
manuell etwas verändert.
KAPITEL 5. RESULTATE
5.3.6
75
Besonderheiten
Wie bereits in Abschnitt 5.3.4, Ergebnisse“ erwähnt, wurde die Evolution
”
mehrere Male durchgeführt. Auch mit unterschiedlichen Evolutionsgrößen
und Mutationsraten konnten sehr ähnliche Ergebnisse erzielt werden. Dennoch wurden einige interessante Abweichungen zwischen den Evolutionen
beobachtet. In einer Evolution war der Wert für Angst und Intelligenz besonders hoch. Dies kann auf folgende Besonderheiten bei der verwendeten
Implementierung zurückgeführt werden.
Ausreißer und lokales Maximum
Der genetische Algorithmus und das Spiel verwenden Wahrscheinlichkeiten. Zufallswerte bestimmen die Selektion, die Mutation und sogar die Fitnessfunktion, da im Spiel ebenfalls zufällige Ereignisse stattfinden können.
Es können daher Konstellationen auftreten, die die Evolution in eine andere
Richtung lenken. Auch ist es möglich, nur ein lokales Maximum gefunden zu
haben. Es wird daher empfohlen, die Evolution öfters durchzuführen.
Abhängigkeit zwischen den Individuen
Die Individuen treten immer gegenseitig an. Das Ergebnis der Fitnessfunktion hängt daher auch von den Attributen des anderen Individuums ab. Ein
Ork kann z. B. einen friedlichen Ork leichter besiegen als einen aggressiven
Ork. Daher ist es schwierig die Tauglichkeit untereinander zu vergleichen.
Die Abhängigkeit kann durch die Verwendung eines Referenz-Orks (siehe
Abschnitt 5.5.1, Referenz-Orks“) vermieden werden.
”
5.4
Vorteile
Der genetische Algorithmus bietet eine automatisierte Form, um die Attribute der Orks zu ermitteln. Er stellt daher eine Alternative zum manuellen
Einstellen durch den KI-Designer dar.
5.4.1
Manuelle Einstellung durch den KI-Designer
Der KI-Designer legt die Attribute fest und testet das Spiel. Um die richtigen
Einstellungen finden zu können, muss er die Attribute ständig nachjustieren
und das Spiel erneut testen. Der Ablauf ist in Abbildung 5.7 dargestellt.
Dieser Vorgang kann sehr lange dauern. Bei einer steigenden Anzahl an
Attributen wird es für den KI-Designer immer schwieriger die richtige Kombination zu finden.
KAPITEL 5. RESULTATE
Attribute einstellen
76
Testen
Abbildung 5.7: Manuelle Einstellung der Attribute durch den KI-Designer.
5.4.2
Optimierung durch den genetischen Algorithmus
Bei diesem Ansatz muss der KI-Designer die richtige Fitnessfunktion festlegen. Will er z. B. einen aggressiven Ork, richtet sich die Tauglichkeit nach
den getöteten Gegnern. Will er einen gefräßigen Ork, werden zur Berechnung die Anzahl der gefressenen Schafe verwendet. Der genetische Algorithmus sorgt dafür, dass die Attribute entsprechend eingestellt werden. Der
KI-Designer startet den Evolutionsprozess und wartet auf das Endergebnis.
Er kann die ermittelten Attribute beliebig ändern oder den Evolutionsprozess erneut starten. Das Endergebnis muss ebenfalls getestet werden. Das
Testen ist jedoch weniger aufwendig als bei der manuellen Einstellung.
5.4.3
Vergleich
Zwar ist bei wenigen Attributen die manuelle Einstellung völlig ausreichend.
Bei einer großen Anzahl bietet der genetische Algorithmus jedoch eine wesentlich einfachere Möglichkeit die richtige Balance zu finden. Der KI-Designer definiert die Fitnessfunktion und überlässt dem Algorithmus das Einstellen der Attribute. Da das Verfahren offline eingesetzt wird, können die
ermittelten Attribute beliebig verändert werden. Der Algorithmus ist somit
eine wertvolle Unterstützung. Darüber hinaus kann der Algorithmus erweitert werden um neue Funktionen zu ermöglichen. Im nächsten Abschnitt
werden mögliche Erweiterungen vorgeschlagen. Zusammenfassend können
folgende Vor- und Nachteile angeführt werden.
Vorteil
• Automatische Einstellung der Attribute: Die Einstellung und
Balancierung der Attribute übernimmt der genetische Algorithmus.
• Geringerer Testaufwand: Das Spiel muss nicht laufend mit neuen
Attributen getestet werden. Es reicht, das Endergebnis des genetischen
Algorithmus zu testen.
• Variable Fitnessfunktion: Die Fitnessfunktion beeinflusst das Endergebnis. Der KI-Designer kann je nach gewünschtem Verhalten unterschiedliche Fitnessfunktionen definieren.
KAPITEL 5. RESULTATE
77
• Berücksichtigung der Implementierung: Die Tauglichkeit wird
im eigentlichen Spiel ermittelt. Schwächen in der Implementierung werden daher ebenfalls berücksichtigt. So meidet der Ork in Evolving Ogre
die Fliehen“-Aktion, weil sie den Ork leicht in eine Sackgasse steuert.
”
Durch eine bessere Ermittlung des Fluchtweges würde der Angst-Wert
in einer neuen Evolution wahrscheinlich steigen.
Nachteil
• Mehraufwand: Der Algorithmus stellt bei einer geringen Zahl an
Attributen eher einen Mehraufwand dar. Die Attribute können leicht
vom KI-Designer gesetzt werden. Bei einer großen Anzahl ist er jedoch
eine wertvolle Unterstützung. Der Algorithmus wird offline eingesetzt
und wirkt sich daher nicht auf die Spielgeschwindigkeit aus.
• Parametrisierung: Das zu optimierende Verhalten muss parametrisiert werden und mit Attributen beschreibbar sein.
5.5
Mögliche Erweiterungen
Der in Evolving Ogre gezeigte Einsatz stellt eine Möglichkeit des genetischen
Algorithmus dar. Der Algorithmus kann verbessert und erweitert werden.
5.5.1
Referenz-Ork
In der aktuellen Version treten jeweils zwei Orks aus der Population gegeneinander an. Es ist aber auch möglich, einen Referenz-Ork zu formen, gegen
den jeder Ork antreten muss. Die Orks trainieren dann immer am selben
Ork. Dieser kann bestimmt Eigenschaften haben und z. B. besonders aggressiv sein. Die Orks müssen darauf entsprechend reagieren. Der Referenz-Ork
kann auf unterschiedliche Art erstellt werden:
• Der KI-Designer definiert den Referenz-Ork selber und setzt die Attribute manuell.
• Der Referenz-Ork stammt aus einem anderen Evolutionsprozess.
• Der Referenz-Ork wird von einem Spieler gesteuert. Die Orks treten bei
der Evaluierung gegen einen echten Menschen an. Da bei der Evolution
viele Orks evaluiert werden müssen, kann dies jedoch sehr aufwendig
für den Spieler sein.
5.5.2
Personalisierung des Orks
Dem Ork kann ein individuelles Verhalten trainiert werden. Für jeden Ork
im späteren Spiel wird eine eigene Fitnessfunktion definiert. Jede Funktion
bewertet die Tauglichkeit des Orks gemäß dem gewünschten Verhalten. Will
KAPITEL 5. RESULTATE
78
man z. B. einen scheuen Ork, beurteilt die Funktion einen Kontakt mit dem
Feind negativ. Der genetische Algorithmus optimiert den Ork dahingehend,
dass er den Gegner meidet. Dabei ist es sinnvoll, einen besonders aggressiven Referenz-Ork zu definieren. Auf diese Weise können unterschiedliche
Orks einfach generiert werden. Der KI-Designer muss lediglich eine andere
Fitnessfunktion festlegen.
5.5.3
Online Einsatz
Es ist möglich den genetischen Algorithmus im laufenden Spiel online einzusetzen. Dies kann sinnvoll sein, wenn in Evolving Ogre der Spieler gegen eine
große Anzahl an Orks kämpfen muss. Zum Beispiel erwarten dem Spieler in
jeden Level immer eine neue Horde Orks. Die Orks entwickeln sich im Laufe
des Spieles weiter und passen sich dabei an den Spieler an. Ist der Spieler
besonders aggressiv, werden die Orks in den folgenden Generationen darauf reagieren. Wichtig ist, die Attribute der Orks zu Beginn mit sinnvollen
Werten zu setzen. Der Spieler wird dann von Beginn an mit intelligenten
Orks konfrontiert. Durch eine hohe Mutation ändern sich die Attribute häufig und die Orks verhalten sich unterschiedlich. Ist eine Modifikation gegen
den Spieler besonders erfolgreich, wird sie an die neuen Orks weitergegeben.
5.5.4
Optimierungstechniken
Die Implementierung des genetischen Algorithmus kann durch verschiedene
Techniken verbessert werden.
Automatische Anpassung der Mutationsrate
Wie bereits erwähnt, stagniert der Evolutionsprozess, sobald die Standardabweichung der Population zu gering ist. Der Algorithmus hat dabei zu
wenige unterschiedliche Attributwerte zur Verfügung. Neue Attributwerte
werden nur durch Mutation hervorgebracht. Es wäre daher sinnvoll, die Mutationsrate bei einer niedrigen Standardabweichung zu erhöhen. In den Evolutionsstrategien (siehe Abschnitt 3.3.4, Evolutionäre Algorithmen“) sind
”
integrierte Selbstadaptionen vorgesehen und ermöglichen die automatische
Anpassung der Mutationsrate während der Evolution [19]. Ein ähnlicher
Mechanismus wäre in genetischen Algorithmen sicher sinnvoll.
Skalierung der Tauglichkeit
Auffallend bei der Evolution ist die starke Abnahme der Standardabweichung innerhalb der ersten Generationen. Dies liegt daran, dass ein Individuen mit einer sehr hohen Tauglichkeit zu häufig selektiert wird und die
anderen Individuen verdrängt. Hat z. B. ein Individuum die Tauglichkeit 0,7
KAPITEL 5. RESULTATE
79
und die anderen eine Tauglichkeit unter 0,2, wird fast immer das Individuum mit der hohen Tauglichkeit selektiert. Dies hat zur Folge, dass der
Algorithmus nur noch wenige Attributwerte zur Verfügung hat und sich die
Evolution verlangsamt. Die Skalierung der Tauglichkeit kann dem entgegenwirken. Die Tauglichkeit der Individuen wird dabei transformiert, um den
Abstand zwischen den Tauglichkeiten zu vermindern. Eine genaue Beschreibung der Methoden findet sich in [1].
Elitismus
Elitismus (Elitism) ist eine weitere Optimierungsmöglichkeit für genetische
Algorithmen. Dabei wird eine definierte Anzahl der besten Individuen unverändert in die nächste Generation übernommen. Damit wird garantiert,
dass die Individuen mit der besten Tauglichkeit in der Population bleiben.
Es wird empfohlen 1 bis 10 % der neuen Individuen auf diese Weise zu
übernehmen [1].
5.6
Resümee
Abschließend kann festgestellt werden, dass der genetische Algorithmus gut
funktioniert und der Ork richtig entwickelt wird. Der Algorithmus optimiert
die Attribute gemäß der Fitnessfunktion. Trotz kleiner Population werden
schon nach kurzer Zeit zufrieden stellende Ergebnisse erzielt. Die gut balancierten Attributwerte sind manuell nur durch längeres Testen und Anpassen zu erreichen. Der genetische Algorithmus kann dem KI-Designer nicht
nur sehr viel Arbeit abnehmen, sondern berücksichtigt Elemente, die vom
KI-Designer nicht vorhergesehen werden können. Zum Beispiel reagiert das
System auf Schwächen in der Implementierung. Der Algorithmus bietet darüber hinaus weitere Einsatzmöglichkeiten wie in Abschnitt 5.5, Mögliche
”
Erweiterung“ gezeigt wird.
Kapitel 6
Schlussbemerkungen
Evolving Ogre zeigt, wie Lernmethoden in Computer Spielen erfolgreich eingesetzt werden können. Genetische Algorithmen ermöglichen, das Verhalten
der KI automatisch zu optimieren. Anstatt manuell die KI abzustimmen,
lernt sie selber, wie sie sich am Besten verhalten soll. Der Algorithmus erwies sich beim Testen als äußerst robust. Am Ende jeder Evolution erwartet
den Spieler ein neuer herausfordernder Ork. Weitere Vorteile wurden im
letzten Kapitel ausführlich erörtert.
Es ist interessant, die Orks bei der Evolution zu beobachten. Während sie
am Anfang planlos durch die Spielwelt wandern, lernen sie innerhalb weniger
Generationen vernünftige Handlungen durchzuführen. Obwohl der Lernprozess in einem separaten Modus offline erfolgt, ist ein online-Einsatz – also
ein Einsatz im Spielmodus – durchaus vorstellbar. Genetische Algorithmen
können verwendet werden, um das Verhalten einer großen Anzahl gleichartiger Agenten unterschiedlicher zu gestalten. Eine Weiterentwicklung von
Evolving Ogre und die Integration dieser Funktion wären sicher interessant.
Spiele-KI gehört zu den spannendsten Bereichen in der Spielentwicklung.
Wurde bisher auf altbekannte Techniken gesetzt, ermöglicht die steigende
Prozessorleistung neue Methoden, die KI glaubhafter und menschlicher wirken zu lassen. Es liegt an dem Spielentwickler – und natürlich auch an dem
Spielverleger – diese Möglichkeiten zu nutzen und neue Impulse in der SpieleKI zu setzen.
6.1
Entwicklung
Die Entwicklung von Evolving Ogre war generell aufwendiger als erwartet.
Das Projekt kann sich in vier Unterprojekte gliedern, die – jedes für sich –
eine große Herausforderung darstellten.
Das Spiel Evolving Ogre: Die künstliche Intelligenz und der genetische
Algorithmus müssen in einem Spiel getestet werden. Evolving Ogre
80
KAPITEL 6. SCHLUSSBEMERKUNGEN
81
basiert zwar auf dem im Vorprojekt entstandenen AIQuest, dennoch
musste vieles angepasst und umprogrammiert werden.
Die künstliche Intelligenz: Die künstliche Intelligenz in Evolving Ogre
musste implementiert werden, bevor der genetische Algorithmus getestet werden konnte. Aktionen, Pfadfindermodul und die Implementierung des Agenten erforderten komplexe Algorithmen wie z. B. den
A*-Algorithmus.
Der genetische Algorithmus: Das genetische System ist flexibel einsetzbar. Die Umsetzung des genetischen Algorithmus, der Entwurf einer
passenden Architektur und das Testen der Evolution nahm viel Zeit
in Anspruch.
Crystal Space 3d: Der Einsatz der Crystal Space 3d Engine stellte die
größte Schwierigkeit dar. Eigentlich als Vereinfachung des Entwicklungsprozesses vorgesehen, wurde viel Zeit damit verbracht, die Funktionsweise der Engine zu verstehen. Da die Entwicklung bereits weit
fortgeschritten war, wurde ein Umstieg auf die wesentlich einfachere
und flexiblere Irrlicht Engine zwar begonnen, aber nicht fertig durchgeführt.
6.2
Erfahrungen
Durch die Entwicklung von Evolving Ogre konnte ich wertvolle Erfahrungen
sammeln, wie man ein Spiel programmiert – und was man dabei vermeiden sollte. Aus diesem Grund wurde nicht auf bestehende Spiele aufgesetzt,
sondern ein eigenes Spiel entwickelt. Eine mögliche Alternative dazu ist das
in [5] vorgestellte KI-Framework FEAR. Die Einarbeitung in die künstliche
Intelligenz stellte sich als äußerst spannend heraus. Doch erst die konkrete
Umsetzung der KI im Spiel und des genetischen Algorithmus ermöglichten
ein tieferes Verständnis die Materie.
Anhang A
Ergänzung zum genetischen
System
A.1
Individuen als XML-Knoten speichern
Individuen können in einem XML-Dokument gespeichert werden. Die Klasse
verfügt über Methoden, um die Daten als XML-Knoten zurückzugeben oder
aus XML-Knoten zu laden. Es liegt an der Anwendung, die Knoten in einem
XML Dokument zu speichern bzw. die Knoten aus einem XML-Dokument
zu lesen.
Individual(const XMLNode& node);
void SaveToNode(XMLNode& node);
Der Konstruktor liest die Daten aus dem übergebenen XML-Knoten und
initialisiert entsprechend das Individuum. Die Methode SaveToNode() speichert die Daten in den übergebenen XML-Knoten. Das folgende XML-Fragment zeigt, wie ein Individuum mit XML beschrieben wird.
<individual name="Ork14" parent="Ork02, Ork05" spezies="Ork"
evaluation="0.5">
<Angst>0.5</Angst>
<Mut>1.0</Mut>
<Neugier>0.1</Neugier>
<Ausdauer>0.4</Ausdauer>
<Hunger>0.25</Hunger>
<Intelligenz>0.75</Intelligenz>
</individual>
Die Daten werden in dem <individual> Element gespeichert. Name,
Eltern, Spezies und Tauglichkeit werden als Attribut direkt beim Element
angegeben. Die einzelnen Attribute des Individuums sind Unterelemente.
82
ANHANG A. ERGÄNZUNG ZUM GENETISCHEN SYSTEM
83
Der Name des Attributes ist gleichzeitig der Name des Unterelements und
der Wert des Attributes wird im Inhalt des Unterelements gespeichert.
A.2
A.2.1
Implementierung der Operationen
Selektion
Individual* SelectIndividual(Individual* except = NULL) const;
Bei der Selektion wird ein Individuum aus der bestehenden Population ausgewählt. Individuen mit einer hohen Tauglichkeit haben eine höhere Wahrscheinlichkeit, dass sie ausgesucht werden, als Individuen mit einer geringen
Tauglichkeit.
float max = 0.0f;
Individual* result;
for every individual of population
{
float temp = GetRandomNumber() + individual->evaluation;
if (max < temp)
{
max = temp;
result = individual
}
}
Bei der Selektion werden alle Individuen der Population durchlaufen. Für
jedes Individuum wird die Wahrscheinlichkeit zur Selektion bestimmt. Diese
berechnet sich aus der Tauglichkeit des Individuums und einer Zufallszahl
zwischen 0 und 1. Das Individuum mit der höchsten Wahrscheinlichkeit wird
schließlich selektiert. Die Zufallszahl gewährleistet, dass nicht automatisch
das Individuum mit der höchsten Tauglichkeit ausgewählt wird. Es ist daher möglich, dass in einer Population das Individuum mit der niedrigsten
Tauglichkeit ausgesucht wird.
A.2.2
Kreuzung
Individual* Crossover(const Individual* a, const Individual* b) const;
Bei der Kreuzung werden die Attribute der Eltern kombiniert, um ein neues
Individuum zu generieren. Die Attribute der Nachkommen stammen dabei
jeweils zur Hälfte von den beiden Elternteilen.
ANHANG A. ERGÄNZUNG ZUM GENETISCHEN SYSTEM
84
Individual* Crossover(const Individual* a, const Individual* b) {
if(!IsCompatible(a, b)) return NULL;
Individual* result = new Individual();
for every attribute of a or b
{
if(GetRandomNumber() < 0.5)
{
result->AddAttribute(attribute,
a->GetAttribute(attribute));
} else {
result->AddAttribute(attribute,
b->GetAttribute(attribute));
}
}
return result; }
Zunächst wird überprüft, ob die beiden Eltern miteinander kombiniert werden können. Nachdem ein neues Individuum konstruiert wurde, durchläuft
die Methode die Attribute eines beliebigen Elternteils. Eine Zufallszahl bestimmt, von welchem Elternteil das aktuelle Attribut verwendet wird. Das
Attribut wird beim Nachkommen hinzugefügt und entsprechend gesetzt.
A.2.3
Mutation
void Mutate(Individual* individual) const;
Bei der Mutation wird das Individuum geringfügig verändert. Für jedes Attribut besteht die Wahrscheinlichkeit, dass eine Mutation stattfindet.
for every attribute of the individual
{
if (GetRandomNumber() < mutationRate)
{
MutateValue(attribute)
}
}
Die Methode durchläuft alle Attribute des Individuums. Bei jedem Attribut bestimmt eine Zufallszahl, ob es verändert werden soll oder nicht. Der
Zufallsgenerator liefert eine Zahl von 0 bis 1. Das bedeutet, dass bei einer
Mutationsrate von 0,001 in 0,1 % der Fälle eine Mutation auftritt. Ist dies
der Fall, wird der Wert des Attributes mit der Funktion MutateValue()
verändert.
ANHANG A. ERGÄNZUNG ZUM GENETISCHEN SYSTEM
A.2.4
85
Zufällige Generierung
void Randomize(Individual* individual) const;
Bei der zufälligen Generierung werden die Attribute des Individuums mit
zufälligen Werten gesetzt.
for every attribute of the individual
{
attribute = GetRandomNumber();
}
Die Methode durchläuft alle Attribute des Individuums und weist ihnen eine
Zufallszahl zwischen 0 und 1 zu.
A.3
Laden und Speichern einer Population
Populationen können in einer Datei gespeichert, oder aus einer Datei geladen
werden. Dazu stehen zwei Methoden zur Verfügung.
void LoadPopulation(const string& file);
void SavePopulation(const string& file);
Mit diesen beiden Methoden kann die Population geladen oder gespeichert
werden. Das XML-Dokument besteht aus dem Hauptknoten <population>
und dem Unterknoten <individual>. Der genaue Aufbau der Unterknoten
ist in Anhang A.1, Individuen als XML-Knoten speichern“ beschrieben.
”
<population>
<individual name="Ork1" parent="none" spezies="Ork"
evaluation="0.2">
<Attribute/>
</individual>
<individual name="Ork2" parent="none" spezies="Ork"
evaluation="0.7">
<Attribute/>
</individual>
<individual name="Ork3" parent="Ork1, Ork22" spezies="Ork"
evaluation="-1">
<Attribute/>
</individual>
</population>
ANHANG A. ERGÄNZUNG ZUM GENETISCHEN SYSTEM
A.4
86
Beispielsanwendung
Zunächst muss ein Bewerter implementiert werden. Dieser bestimmt die
Tauglichkeit der Individuen auf einfache Art und Weise. Die Attribute –
Mut, Ausdauer und Intelligenz – werden summiert und durch drei geteilt.
Folglich erreicht das Individuum die höchste Tauglichkeit, wenn alle Attribute den Wert 1 haben.
class Evaluator: public iEvaluator
{
public:
float Evaluate(const Individual* individual)
{
return (individual->GetAttribute("Mut") +
individual->GetAttribute("Ausdauer") +
individual->GetAttribute("Intelligenz")) / 3.0f;
}
};
Nachdem der Bewerter definiert wurde, kann der Algorithmus ausgeführt
werden. Zunächst wird eine neue Instanz des genetischen Systems und des
Bewerters erzeugt. Dann wird ein Prototyp angelegt. Dieser besitzt drei
unterschiedliche Attribute – Mut, Ausdauer und Intelligenz. Mit diesem
Prototyp wird die Population initialisiert. Nachdem der Bewerter gesetzt
wurde, kann die Evolution gestartet werden. Das genetische System wird die
Individuen solange weiterentwickeln, bis die Population die DurchschnittsTauglichkeit 0,9 erreicht.
GeneticSystem geneticSystem;
Evaluator evaluator;
Individual prototype("Prototype", "none", "Ork");
prototype.AddAttribute("Mut");
prototype.AddAttribute("Ausdauer");
prototype.AddAttribute("Intelligenz");
geneticSystem.InitializePopulation(&prototype, 10);
geneticSystem.SetEvaluator(&evaluator);
geneticSystem.Evolve(0.9f);
geneticSystem.PrintPopulation();
Ergebnis
Aufgrund des Einsatzes von Wahrscheinlichkeitszahlen kann das Ergebnis
stark variieren. Wie die Konsolenausgabe zeigt, wird in diesem Fall die
durchschnittliche Tauglichkeit in der 238. Generation erreicht.
ANHANG A. ERGÄNZUNG ZUM GENETISCHEN SYSTEM
Average fitness (0.910) reached in generation 238
Ork 2381 {
Parent
Spezies
Ausdauer
Intelligenz
Mut
Evaluation
}
Ork 2382 {
Parent
Spezies
Ausdauer
Intelligenz
Mut
Evaluation
}
...
Ork 2375, Ork 2378
Ork
0.816
1.000
1.000
0.939
Ork 2376, Ork 2377
Ork
0.816
0.788
1.000
0.868
87
Anhang B
Mathematische Definitionen
B.1
Suchraum
Individuen sind Vektoren in einem mehrdimensionalen Suchraum. Jedes Attribut stellt dabei eine eigene Dimension in diesem Suchraum dar. Hat das
Individuum drei Attribute, ist der Suchraum dreidimensional. In Abbildung
B.1 ist dieser Suchraum für ein Individuum mit den Attributen Ausdauer,
Intelligenz und Mut illustriert. Im Suchraum befinden sich alle Individuen
der Population.
B.2
B.2.1
Messgrößen
Population
Eine Population ist eine Menge von Individuen.
Population = {i1 ,i2 , . . . ,iN }
i
N
B.2.2
(B.1)
ein einzelnes Individuum,
Anzahl der Individuen in der Population.
Durchschnitts-Tauglichkeit
Die Durchschnitts-Tauglichkeit gibt die allgemeine Tauglichkeit einer Population an. Es handelt sich dabei um den durchschnittlichen Tauglichkeitswert
jedes Individuums in der Population.
Durchschnitts-Tauglichkeit =
N
1
·
Fitness(ik )
N
(B.2)
k=1
Fitness( i )
Die Fitnessfunktion berechnet die Tauglichkeit eines
Individuums.
88
ANHANG B. MATHEMATISCHE DEFINITIONEN
89
i2
Hunger
i1
i3
i4
Intelligenz
Mut
Abbildung B.1: Der Suchraum beinhaltet die Individuen der Population.
B.2.3
Distanz
Die Distanz gibt den Unterschied zweier Individuen an [21]. Sie berechnet
sich aus dem euklidischen Abstand der Individuen im Suchraum. (siehe Abbildung B.2[a]).
Distanz(ix ,iy ) = ix − iy B.2.4
(B.3)
Durchschnittliches Individuum
Aus der bestehenden Population kann ein durchschnittliches Individuum ermittelt werden [21]. Für jedes Attribut wird der Mittelwert dieses Attributs
in der Population berechnet. Das durchschnittliche Individuum ist gleichzeitig der Mittelpunkt aller Individuen im Suchraum (siehe Abbildung B.2[b]).
N
ik
iDurchschnitt = 1 ·
N
(B.4)
k=1
B.2.5
Standardabweichung
Um die Verteilung der Individuen im Suchraum anzugeben, wird die Standardabweichung aller Individuen zum durchschnittlichen Individuum verwendet. Mit diesem Wert kann einfach festgestellt werden, ob die Individuen
im Suchraum weit auseinander oder eng zusammen liegen.
N
1
·
Distanz(ik ,iDurchschnitt )2
Standardabweichung = N
k=1
(B.5)
ANHANG B. MATHEMATISCHE DEFINITIONEN
i2
i2
Hunger
i1
i3
i4
Intelligenz
(a)
90
Hunger
i3
iDurchschnitt
i1
i4
Mut
Intelligenz
Mut
(b)
Abbildung B.2: [a] Die Distanz ist der euklidische Abstand zweier Individuen im Suchraum. [b] Das durchschnittliche Individuum ist der Mittelpunkt
aller Individuen im Suchraum.
Neben der Standardabweichung gibt es andere Messgrößen um die Verteilung der Individuen in der Population anzugeben. In [21] werden dazu
Distanzverteilung und Distanzkarten definiert. Diese berücksichtigen unter
anderem auch die räumliche Verteilung der Individuen. Für die in der Arbeit verwendete Population reicht die Standardabweichung aus, da nur der
Unterschied der Individuen von Bedeutung ist.
Anhang C
User Dokumentation
C.1
C.1.1
Installation
Kopieren auf die Festplatte
Das Verzeichnis EvolvingOgre auf der CD muss zunächst auf die Festplatte
kopiert werden.
C.1.2
Evolving Ogre starten
Mit der Datei evolvingogre.bat im Verzeichnis EvolvingOgre wird das
Spiel gestartet. Standardmäßig wird in den Spielmodus gewechselt. Mit folgenden beliebig kombinierbaren Parametern kann man das Spiel anpassen:
-fs
Evolving Ogre wird im Vollbildmodus gestartet.
-learnmode Evolving Ogre wird im Lernmodus gestartet.
-noshaders Evolving Ogre wird ohne Shader-Unterstützung gestartet.
C.1.3
Fehlerbehebung
Sollten beim Starten Fehlermeldungen angezeigt werden, oder im Spiel Anzeigeprobleme (z. B. ein schwarzer Boden) auftreten, gibt es möglicherweise
Probleme mit der Shader-Unterstützung. In diesem Fall sollte entweder der
neueste Graphiktreiber installiert, oder Evolving Ogre ohne Shader-Unterstützung gestartet werden.
91
ANHANG C. USER DOKUMENTATION
92
Abbildung C.1: Der Startbildschirm von Evolving Ogre.
C.2
C.2.1
Spielmodus
Spielmodus starten
Der Spielmodus kann mit folgenden Befehlen im Fenster- oder Vollbildmodus
gestartet werden:
evolvingogre
evolvingogre -fs
Nach dem Starten erscheint der in Abbildung C.1 gezeigte Startbildschirm.
Mit der Eingabetaste wird ein neues Spiel gestartet. In dem Spiel steuert
man den Ritter und begibt sich in den Kampf gegen einen gefräßigen Ork
(siehe Abbildung C.2). Mit den Cursor-Tasten bewegt man den Ritter und
mit der Leertaste kann man attackieren.
C.2.2
Interface
In dem unteren Bereich des Bildschirms befindet sich das Interface von Evolving Ogre. Es zeigt nützliche Informationen zum Spiel an. In Abbildung C.3
werden die verschiedenen Komponenten herausgehoben:
Karte: Die Karte zeigt eine Übersicht der Spielwelt. In grün und rot wird
die aktuelle Position des Ritters bzw. Orks angezeigt.
ANHANG C. USER DOKUMENTATION
93
Abbildung C.2: Die Ausgangssituation in Evolving Ogre.
Zeit: Die abgelaufene Zeit wird angezeigt. Das Spiel wird im Spielmodus
nach 500 Sekunden und im Lernmodus nach 200 Sekunden beendet.
Kameraansicht: Es gibt drei verschieden Kameraansichten im Spiel. Die
Spieleransicht zeigt das Spiel aus Sicht des Ritters. Die Vogelansicht
zeigt das Spiel von oben und die freie Kameraansicht zeigt das Spiel
von einer beliebig positionierbaren Kamera.
Spielgeschwindigkeit: Das Spiel kann in zehn verschiedenen Geschwindigkeitsstufen gespielt werden. Diese Funktion ist jedoch für den Lernmodus gedacht und sollte im Spielmodus nicht verwendet werden.
Bewaffnung: Die Bewaffnung zeigt an, ob der Ritter oder Ork eine Waffe
besitzt und damit eine höhere Kampfkraft hat.
Gefressene Schafe: Beim Ork wird die Anzahl der im Spiel gefressenen
Schafe angezeigt.
Ork-Informationen: Zu dem Ork werden nützliche Informationen (OrkAttribute und aktuelle Aktion) eingeblendet.
C.2.3
Tastaturbelegung
Eine Tastaturbelegungsübersicht kann im Spiel mit der F1-Taste einfach
aufgerufen werden. Es folgt eine genaue Auflistung der verwendeten Tasten
und eine kurze Beschreibung ihrer Funktionen:
ANHANG C. USER DOKUMENTATION
94
Abbildung C.3: Das Interface von Evolving Ogre.
Spielersteuerung:
Cursor-Tasten
Leertaste
Kamera:
1
2
3
Spieleransicht:
TAB
Freie Kameraansicht:
A,W,S,D
Q,E
+, Einstellungen:
F1
H
P
C
Bild-Vor
Bild-Zurück
ESC
Spieler bewegen
Attackieren
Spieleransicht
Vogelansicht
Freie Kameraansicht
Spieler wechseln
Kamera bewegen
Kamera kippen
Kamerahöhe ändern
Ein- und Ausblenden der Tastaturbelegungsübersicht
Ein- und Ausblenden des Interfaces
Spiel pausieren oder fortsetzen
Spiel beenden
Spielgeschwindigkeit erhöhen
Spielgeschwindigkeit verringern
Programm beenden
ANHANG C. USER DOKUMENTATION
95
Abbildung C.4: Der Endbildschirm von Evolving Ogre.
C.2.4
Endbildschirm
Der Endbildschirm in Abbildung C.4 wird nach dem Spielende angezeigt
und gibt einen Überblick über das Abschneiden des Ritters und Orks im
Spiel. Die Evaluierung gibt das Ergebnis der im Lernmodus verwendeten
Fitnessfunktion an.
C.3
C.3.1
Lernmodus
Lernmodus starten
Im Lernmodus wird der Ork entwickelt und trainiert. Der Lernmodus kann
mit folgenden Befehlen im Fenster- oder Vollbildmodus gestartet werden:
evolvingogre -learnmode
evolvingogre -learnmode -fs
C.3.2
Übersichtsbildschirm
Der Übersichtsbildschirm in Abbildung C.5 zeigt die aktuelle Population an.
Die Attribute der Orks und die erreichten Tauglichkeiten werden aufgelistet.
Die zwei hervorgehobenen Orks treten im nächsten Spiel gegeneinander an,
um die Tauglichkeit zu ermitteln. Sobald eine Population vollständig evalu-
ANHANG C. USER DOKUMENTATION
96
Abbildung C.5: Im Lernmodus wird die aktuelle Ork-Population übersichtlich dargestellt.
iert wurde, wird sie gespeichert und es wird automatisch daraus eine neue
Generation entwickelt.
C.3.3
Training
Bei der Evaluierung der Orks wird das Spiel simuliert und die Orks treten gegenseitig an (siehe Abbildung C.6). Der Benutzer kann das Spiel beobachten,
aber nicht selber eingreifen. Beim Training ist es sinnvoll, die Spielgeschwindigkeit zu erhöhen, um die Evolution zu beschleunigen.
C.3.4
Automatischer Modus
Der Entwicklungsprozess kann automatisiert werden. Mit der Taste 0 kann
der automatische Modus beliebig ein- und ausgeschalten werden. Das Programm entwickelt die Population automatisch weiter, ohne auf eine Benutzereingabe zu warten. Wird der Modus ausgeschalten, wird das aktuelle Spiel
fertig simuliert.
C.3.5
Übernahme in den Spielmodus
Der im Lernmodus trainierte Ork wird automatisch im Spielmodus verwendet. Sobald eine Generation vollständig evaluiert wurde, wird sie gespeichert.
Der erfolgreichste Ork dieser Generation ist dann automatisch der Ork, gegen den der Spieler im Spielmodus antritt.
ANHANG C. USER DOKUMENTATION
Abbildung C.6: Zwei Orks treten gegenseitig an.
97
Anhang D
Inhalt der CD-ROM
File System: ISO9660/Joliet
Mode: Single-Session (CD-ROM)
D.1
Diplomarbeit
Pfad:
/
da.pdf . . . . . . . . . .
da.ps . . . . . . . . . . .
Diplomarbeit (PDF-Datei)
Diplomarbeit (PostScript-File)
D.2
Evolving Ogre
Pfad:
/EvolvingOgre/
evolvingogre.bat
visual/aiquest.sln
bin/∗ . . . . . .
include/∗ . . . .
src/∗ . . . . . . .
doc/index.html .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
D.3
Screenshots
Pfad:
/Screenshots/
.
.
.
.
.
.
screen∗.eps . . . . . . .
screen∗.tif . . . . . . . .
Startdatei
Microsoft Visual Studio Projektdatei
Ausführbare Datei von Evolving Ogre
Header-Datei von Evolving Ogre
Quelldateien von Evolving Ogre
Dokumentation des Quellcodes
Screenshots von Evolving Ogre
(EPS-Dateien)
Screenshots von Evolving Ogre
(TIF-Dateien)
98
ANHANG D. INHALT DER CD-ROM
D.4
Graphiken
Pfad:
/Graphiken/
∗.eps . . . . . . . . . . .
∗.tif . . . . . . . . . . .
D.5
Quellen
Pfad:
/Quellen/
Hannan06.pdf . . . . .
evocomp/∗.pdf . . . . .
99
Mehrere Graphiken der Arbeit
(EPS-Dateien)
Mehrere Graphiken der Arbeit (TIF-Dateien)
Webseite zu [9] (PDF-Datei)
Webseite zu [19] (PDF-Dateien)
Literaturverzeichnis
[1] Buckland, M.: Building Better Genetic Algorithms. In: Rabin, S.
(Hrsg.): AI Game Programming Wisdom 2 , Kap. 11.4. Charles River
Media, 2004.
[2] Champandard, A. J.: AI Game Development. New Riders, 2003.
[3] Dalmau, D. S.-C.: Core techniques and algorithms in game programming. New Riders, 2005.
[4] Engenuity Technologies Inc: AI.implant.
biographictech.com/, April 2006.
URL, http://www.
[5] FEAR - Foundations for Genuine Game AI: FEAR. URL, http:
//fear.sf.net, June 2006.
[6] Fikes, R. und N. Nilsson: STRIPS: a new approach to the application
of theorem proving to problem solving. 1971.
[7] Fu, D. und R. Houlette: Constructing a Decision Tree Based on Past
Experience. In: Rabin, S. (Hrsg.): AI Game Programming Wisdom 2 ,
Kap. 10.2. Charles River Media, 2004.
[8] Haake, O.: Age of Empries 3 . PC Games, 12:86, 2005.
[9] Hannan, J.: The caption Package.
content/2001/hannan.asp, Mai 2006.
nan06.pdf).
URL, www.generation5.org/
Kopie auf CD-ROM (Han-
[10] Holland, J. H.: Adaptation in Natural and Artificial Systems: An Introductory Analysis with Applications to Biology, Control, and Artificial
Intelligence. The University of Michigan Press, 1975.
[11] Houlette, R.: Player Modeling for Adaptive Games. In: Rabin, S.
(Hrsg.): AI Game Programming Wisdom 2 , Kap. 10.1. Charles River
Media, 2004.
[12] Kirby, N.: Getting Around the Limits of Machine Learning. In: Rabin,
S. (Hrsg.): AI Game Programming Wisdom 2 , Kap. 10.5. Charles River
Media, 2004.
100
LITERATURVERZEICHNIS
101
[13] Koza, J. R., F. H. Bennett, D. Andre und M. A. Keane: Genetic
Programming III: Darwinian Invention and Problem Solving. Morgan
Kaufmann, 1999.
[14] Kurzweil, R.: Are We Spiritual Machines?: Ray Kurzweil Vs. the
Critics of Strong AI . Discovery Institute, 2002.
[15] LaMothe, A.: A Neural-Net Primer . In: DeLoura, M. (Hrsg.):
Game Programming Gems, Kap. 3.9. Charles River Media, 2000.
[16] Laramée, F. D.: Genetic Algorihms: Evolving the Perfect Troll. In:
Rabin, S. (Hrsg.): AI Game Programming Wisdom, Kap. 11.9. Charles
River Media, 2002.
[17] Manslow, J.: Learning and Adaptation. In: Rabin, S. (Hrsg.): AI
Game Programming Wisdom, Kap. 11.1. Charles River Media, 2002.
[18] Manslow, J.: Learning and Adaption. In: Rabin, S. (Hrsg.): AI Game
Programming Wisdom 2 , Kap. 10.2. Charles River Media, 2004.
[19] Müller, A.: Evolutionsalgorithmen (Evolutionäre Algorithmen).
URL,
http://www.evocomp.de/themen/evolutionsalgorithmen/evoalg.
html, Juni 2006. Kopie auf CD-ROM (evocomp/*.pdf).
[20] Perkins, S.: Robot Shaping — Principles, Methods and Architectures.
URL, citeseer.ist.psu.edu/119783.html, 1996.
[21] Pohlheim, H.: Entwicklung und systemtechnische Anwendung Evolutionärer Algorithmen. Doktorarbeit, Technischen Universität Ilmenau,
Kleinmachnow, Juli 1997.
[22] Rabin, S.: Common Game AI Techniques. In: Rabin, S. (Hrsg.): AI
Game Programming Wisdom 2 , Kap. 1.1. Charles River Media, 2004.
[23] Rabin, S.: Promising Game AI Techniques. In: Rabin, S. (Hrsg.): AI
Game Programming Wisdom 2 , Kap. 1.1. Charles River Media, 2004.
[24] Russel, S. J. und P. Norvig: Artificial Intelligence: A Modern Approach. Prentice Hall, 1995.
[25] Sweetser, P.: How to Build Evolutionary Algorithms for Games.
In: Rabin, S. (Hrsg.): AI Game Programming Wisdom 2 , Kap. 11.2.
Charles River Media, 2004.
[26] The Soar Group: Soar . URL, http://sitemaker.umich.edu/soar, April
2006.
[27] Tozour, P.: The Evolution of Game AI . In: Rabin, S. (Hrsg.): AI
Game Programming Wisdom, Kap. 1.1. Charles River Media, 2002.
LITERATURVERZEICHNIS
102
[28] Waveren, V.: The Quake III Arena Bot. Diplomarbeit, Delft University of Technology, 2001.