ZFX
ZFX Neu
Home
Community
Neueste Posts
Chat
FAQ
IOTW
Tutorials
Bücher
zfxCON
ZFXCE
Mathlib
ASSIMP
NES
Wir über uns
Impressum
Regeln
Suchen
Mitgliederliste
Membername:
Passwort:
Besucher:
4421997
Jetzt (Chat):
13 (0)
Mitglieder:
5239
Themen:
24223
Nachrichten:
234554
Neuestes Mitglied:
-insane-
3D Spieleprogrammierung - Kompendium (aka Band III)

 

Status: ERHÄLTLICH SEIT DEZEMBER 2003

Titel:              "3D Spieleprogrammierung - Kompendium"     
Seitenanzahl:
950
Preis:              59,95 € Hardcover
Autor:             Stefan Zerbst, Oliver Düvel, Eike Anderson
Verlag:
           Markt und Technik

ISBN               
3-8272-6400-6
Bestellen:      
bei Amazon  

      Cover                     


Screenshots  |  Downloads  |  Inhaltsverzeichnis


Liste bekannter Fehler des Kompendiums: Errata Seite

Beschreibung des Buchinhalts

Dieses Buch richtet vor allem an Fortgeschrittene die bereits viel Grundlagenwissen im Bereich 3D-Programmierung mitbringen. Die wichtigsten Grundlagen werden zwar in aller Kürze reflektiert, jedoch nicht weiter vertieft. Um Kern des Buches geht es vor allem um das Design einer API-unabhängigen, schnellen 3D-Engine sowie die Implementierung eines Ego-Shooters auf aktuellen grafischem Stand. Die Engine setzt sich aus verschiedenen, über DLL's und Interfaces implementierten Komponenten zusammen, beispielsweise einer Render DLL, einer Input DLL und einer Audio DLL. Sämtliche DLL's können bei Bedarf durch eigene Implementierungen ersetzt werden (z.B. Direct3D durch OpenGL) ohne an den Applikationen die die Engine verwenden etwas ändern zu müssen. Die jeweiligen Applikationen arbeiten entsprechend über Interfaces. 

Die folgenden Themen werden unter anderem im Buch behandelt:

  • Begriff und Design einer 3D-Engine
  • Implementierung eines Render-Interface
  • Render-DLL für das Interface basierend auf Direct3D 9
  • 3D-Mathe Bibliothek mit Vektoren, Matrizen, AABB, Quaternions usw.
  • Unterstützung von SIMD SSE Assembler falls vorhanden
  • Einfache Initialisierung der Render-DLL über einen Dialog
  • Rendern in beliebig viele Child-Windows und Viewports
  • Automatisches Vertex-Batching über dynamische Vertex-Buffer
  • Manager für Texturen, Materialien und dynamische Vertex-Buffer
  • Einfach zu bedienende Kapselung für statische Vertex-Buffer
  • Vertex- und Pixel-Shader gesteuerte Engine
  • Character Animation
  • Netzwerk-Programmierung (Chat, Multiplayer Deathmatch)
  • Einführung in 3D-Indoor Techniken
  • Portal-Engine mit Octrees für Kollisionsabfragen
  • Editor für Indoor-Level für die Engine
  • Genaue Kollisionsabfragen
  • Bots mit Scripting
  • usw., usw., usw.

ACHTUNG: Voraussetzung für das korrekte Ausführen der späteren Kapitel des Buches ist eine aktuelle Grafikkarte die Vertex-Shader und Pixel-Shader jeweils in der Version 1.1 in Hardware unterstützt (z.B. GeForce3 Ti, GeForce 4 Ti; insb. nicht der GeForce MX Chipsatz). Ohne eine solche Grafikkarte laufen die Beispiele ebenfalls, jedoch unter Verwendung deutlich weniger Effekte. 

ACHTUNG: Ein SIMD-fähiger Prozessor (z.B. Pentium III oder IV, sowie  neueste AMD Athlon XP oder AMD Duron 1000+ Modelle) ist zwar keine Voraussetzung, bringt aber deutliche Performance-Vorteile bei der 3D-Mathe Bibliothek. Alternativ schaltet der Code jedoch auch auf eine reine C++ Implementierung um.


Screenshots der Programme aus dem Buch:

Abbildung 1: Auswahldialog beim Start der Engine
Auswahldialog

Abbildung 2: Stück Geometrie in Zerlegung durch BSP-Tree für Kollisionsdetektion
BSP Zerlegung

Abbildung 3: Directional Light über Shader
Shader Directional Light

Abbildung 4: Per-Pixel Point-Light über Shader
Shader PerPixel Light

Abbildung 5: Bump Mapping über Shader
Shader Bump Mapping

Abbildung 6: PanBox Edit Low Polygon Editor
PanBox Edit

Abbildung 7: Spot Light Simulation durch Point Lights
Fake Spot-Light

Abbildung 8: Ein Gang im Demo-Level
Demo Level Screen 1

Abbildung 9: Ein Lager im Demo-Level
Demo Level Screen 2

Abbildung 10: LowPoly Editor PanBox für Indoor Level
PanBox Level Editor


Downloads

Im folgenden sind einige Downloads aufgelistet, die einige kleinere Anwendungen der Programme aus dem Buch zeigen sollen. Sollte es bei der Funktion der Demos Probleme und Inkompatibilitäten geben, so meldet das bitte an Stefan.Zerbst@zfx.info

Kapitel 4: SIMD Test-Programm
Um zu testen ob Euer Prozessor den verwendeten SIMD Befehlssatz unterstützt gibt es hier das kleine SIMD Testprogramm zum Download. Nach der Ausführung zeigt es eine Dialogbox mit dem Ergebnis der CPU Untersuchung an. Ein SIMD-fähiger Prozessor ist für die Verwendung der Beispiele aus dem Buch nützlich, aber nicht notwendig.

Kapitel 11: Chat Programm
Das Download-Programm ist eine Demo der ZFXNetwork DLL welche die WinSock 2.0 API kapselt. Man kann beliebig viele Instanzen der EXE starten. Um einen Server zu betreiben muss man einen Port angeben beispielsweise 6000. Um einen Client zu starten muss man denselben Port wie beim Server angeben und zusätzlich die IP Adresse des Servers. Über den Befehl
ipconfig.exe kann beispielsweise man im DOS Modus die IP Adresse des eigenen Computers abfragen. Server und Client können auch ohne Netzwerk auf demselben Computer betrieben werden. 
Server und Client verwenden für den Chat dieselbe Eingabemaske, der Server kann also auch Chat-Nachrichten absetzen. Die Clients werden von Server zusätzlich über spezielle Events informiert, beispielsweise über das An- und Abmelden neuer Clients.


Inhaltsübersicht

I. Teil: Einleitung

Inhalt dieses Buches
      Was steht in diesem Buch
      Was steht nicht in diesem Buch
Konzeptionelle Vorgehensweise
Verwendete Werkzeuge
      Tools
      Komponenten


II. Teil: Einführung in die Thematik

I. Kapitel: 3D-Engines und Spiele-Entwicklung
Modewort 3D Engine
Eine Art von Magie
      Nostalgie
      Der Zauberer von Ozz...
      ...und die Verantwortung eines Gottes
Entstehungsprozess eines Spiels
      Spieleprogrammierung (Game Programming)
      Spiel-Design (Game Design)
      Spiel-Entwurf (Game Proposal)

           Game Treatment
           Competitive Analysis
           Team Introduction
           Budget
           Schedule
           Weitere Elemente
      Publisher, Veröffentlichung und Finanzierung
      Verkaufszahlen
      Alternativen
Sage mir mit wem Du gehst...
DirectX und OpenGL, Versionspolitik
Warum schwer wenn's auch einfach geht?
Auf los geht's los

II. Kapitel: Design der ZFXEngine
Anforderungen an die Engine
API-Unabhängigkeit durch Interface-Definition
Struktur der ZFXEngine
Komponenten der ZFXEngine
      ZFXRenderDevice Interface
      ZFXInputDevice Interface
      ZFXNetworkDevice Interface
      ZFXAudioDevice Interface
      ZFX3D Bibliothek
      ZFXGeneral Bibliothek

Ein Blick zurück, zwei Schritt nach vorn

III. Kapitel: Rahmenanwendung der ZFXEngine
Begriffsbestimmung Interface
Unser Interface
Der Arbeitsbereich für unsere Implementierung
      ZFXRenderer, eine statische Bibliothek als Manager
      ZFXD3D, eine dynamische Bibliothek als Render-Device
      ZFXRenderDevice, ein Interface als abstrakte Klasse
Implementierung der statischen Bibliothek
Implementierung der dynamischen Bibliothek
      Exportierte Funktionen
      Komfort durch einen Dialog
      Initialisierung, Enumeration und Shutdown
      Zwischen Child-Windows wechseln
      Render-Funktionen
Testlauf der Implementierung
Ein Blick zurück, zwei Schritt nach vorn

IV. Kapitel: Schnelle 3D Mathematik
Schnell, schneller am schnellsten
      Grundlagen der Assembler-Programmierung
      Einführung in SIMD
           Multimedia-Extensions, MMX
           AMD dreidimensional, 3DNow!
           Intels Streaming-SIMD-Extensions, SSE
           Intels Streaming-SIMD-Extensions die Zweite, SSE2
           AMD dreidimensionaler, 3DNow!-Professional
      Wie sag ich's meinem Compiler?
      Identifikation einer CPU und des OS
      Unterstützung für SSE zur Laufzeit überprüfen
Rechnen mit Vektoren
      Grundlegende (arithmetische) Operationen
      Komplexere Operationen mit SSE Unterstützung
Rechnen mit Matrizen
      Grundlegende Operationen
Rechnen mit Strahlen
      Grundlegende Operationen
      Kollision mit Dreiecken
      Kollision mit Ebenen
      Kollision mit Bounding Boxen
Rechnen mit Ebenen
      Grundlegende Operationen
      Kollision mit Dreiecken
      Kollision zwischen Ebenen
      Kollision mit Bounding Boxen
Rechnen mit AABB und OBB
      Grundlegende Operationen und Culling
      Kollision mit Dreiecken
      Kollision zweier orientierter Boxen
      Ebenen einer AABB
      Strahl in AABB
Rechnen mit Polygonen
      Grundlegende Operationen
      Punkte für das Polygon festlegen
      Clippen eines Polygons
           Clipping an einer AABB
           Clipping an einer Ebene
      Culling mit Bounding Boxen
      Kollision mit Strahlen
Rechnen mit Quaternions
      Einführung in den 4D-Raum
      Grundlegende Operationen
      Multiplikation zweier Quaternions
      Konstruktion aus Euler-Winkeln
      Rotationsmatrix zu einem Quaternion
Ein Blick zurück, zwei Schritt nach vorn


III. Teil: Rendern von Grafik

V. Kapitel: Materialen, Texturen und Transparenz
Mittleres Management
Eine Klasse für Skins
      Texturen
      Licht und Materialien
      Grundlegende Strukturen
      Interface-Definition für einen Skin-Manager
      Skin-Manager des Direct3D Renderers
      Farben und Materialen vergleichen
      Skins austeilen
Skins und Materialen erzeugen
Texturen erzeugen
      Texturen zu den Skins hinzufügen
      Grafikdateien als Texturen laden
Transparenz der Texturen einstellen
      Color Keys über Alpha Channels einstellen
      Allgemeine Transparenz über Alpha Channels
Ein Blick zurück, zwei Schritt nach vorn

VI. Kapitel: Render Interface der ZFXEngine
Simplizität versus Komplexität
Projekteinstellungen
Sicht und Projektion
      Multiple Stages
      Viewports, Viewmatrizen und der Frustrum
      Perspektivische Projektion
      Orthogonale Projektion
      Aktivieren von Sicht und Projektion
      Koordinatenumrechnung 2D zu 3D und zurück
      Resümee: Sicht und Projektion
      Festlegen der Welttransformation
Vertex-Strukturen
Shader Support
      Notwendige Vorbereitungen
      Vertex-Shader
           Laden und Kompilieren eines Vertex-Shaders
           Aktivieren eines Vertex-Shaders
      Pixel-Shader
           Laden und Kompilieren eines Pixel-Shaders
           Aktivieren eines Pixel-Shaders
Aktivierung von Renderstates
Effizientes Rendern von grafischen Primitiven
      Grundlagen zur Hardware und Performance
      Caching beim Rendern
      Statische versus dynamische Vertex- und Indexbuffer
      Interface-Definition für einen Vertex-Cache Manager
      Vertex-Cache Objekt
           Erstellung und Freigabe eines Vertex-Cache Objektes
           Skin des Vertex-Cache Objekts einstellen
           Hinzufügen von Daten
           Rendern aus dem Vertex-Cache Objekt
      Vertex-Cache Manager
           Erstellung und Freigabe eines Vertex-Cache Managers
           Management dynamischer Render-Listen
           Buffer Flushing
           Statische Buffer erzeugen und Rendern
Rendern von Text, Punkten und Linien
      Fonts anlegen und Text rendern
      Punktlisten rendern
      Linien rendern
Darstellung einer Szene
Demo Applikation zur Anwendung der DLL
      Multiple Child-Windows mit 3D-Grafik
      Einfacher Geometrie-Loader
Ein Blick zurück, zwei Schritt nach vorn

VII. Kapitel: 3D-Pipeline und Vertex-/Pixel-Shader
Grundlagen von Shadern
      3D-Pipeline
      CPU-lastig versus GPU-lastig
      Vertex-Manipulationen über Vertex-Shader
      Pixel-Manipulationen über Pixel-Shader
Shader Techniken und Beispiel Applikationen
      Demo 1: Basis Transformation
           Ein einfacher Vertex-Shader
           Ein einfacher Pixel-Shader
           Demo Framework
      Demo 2: Single Pass Multitexturing
           Vertex-Shader
           Pixel-Shader
           Demo Framework
      Demo 3: Directional Lighting per-Vertex
           Vertex-Shader
           Pixel-Shader
           Demo Framework
      Demo 4: Per Pixel Omni Lights
           Omni Light Matrix berechnen
           Vertex-Shader
           Pixel-Shader
           Demo Framework
      Demo 5: Graustufen-Bild
      Demo 6: Bump Mapping
           Heightmap zu Nomalmap konvertieren
           Tangent Space aufmachen
           Vertex-Shader
           Pixel-Shader
           Demo Framework
Ein Blick zurück, zwei Schritt nach vorn

VIII. Kapitel: Skeletale Animation von Charakteren
Eine Revolution?
      Der Siegeszug
Das Modellformat CBF
      Was ist ein Chunk?
      Auslesen eines Chunks
      Unsere Hauptmethode
      Den Kopf einlesen
      Einlesen der Vertices
      Triangle-Information einlesen
      Das Netz
      Auf das Material kommt es an
      Die Joints bitte
      Der Hauptjoint
      Die Rotation
      Die Position
      Sei animiert
      Passt es?
Verarbeitung der Daten im Speicher
      Vorbereiten der Daten
      Skeletale Animation
      Bewegung im Modell
      Vorbereitung ist alles
      Meine Position
Updaten und Nutzen des Modells
      Aktueller Stand
      Der Präsentationstermin
      Bis auf die Knochen runter
      Voll Normal
Ein Blick zurück, zwei Schritt nach vorn

IV. Teil: Hilfsmodule für die Engine

IX. Kapitel: Eingabe Interface der ZFXEngine
Kurz und schmerzlos
      Altbekanntes Interface Design
      Interface-Definition für eine Eingabe-Klasse
Basisklasse für DirectInput Devices
      Erstellen und Freigeben des Objektes
      Inbetriebnahme
      Abfrage des Inputs
Ran an die Tasten
      ZFXKeyboard Klasse
      Initialisierung und Freigabe
      Update
      Abfrage des Inputs
Die Rattenfänger von Redmond
      ZFXMouse Klasse
      Initialisierung und Freigabe
      Update
Kein Spaß ohne Joystick
      ZFXJoystick Klasse
      Initialisierung und Freigabe
      Update
Implementierung des Interfaces
      Initialisierung und Freigabe
      Update
      Abfrage der Daten
Demo Applikation zur Anwendung der DLL
Ein Blick zurück, zwei Schritt nach vorn

X. Kapitel: Audio Interface der ZFXEngine
Kurz und schmerzlos
      Altbekanntes Interface Design
      Interface-Definition für eine Eingabe-Klasse
Implementierung des Interfaces
      ZFXAudio Klasse
      Initialisierung und Freigabe
      Zuhörer und Quelle für 3D-Sound
      Laden und Abspielen von Sounds
      Abfrage der Daten
Demo Applikation zur Anwendung der DLL
Ein Blick zurück, zwei Schritt nach vorn

XI. Kapitel: Netzwerk Interface der ZFXEngine
Netzwerk Spiele
      Session-basiert
           Deathmath
           Team und Coop
           Capture the Flag
      Persistente Welten
           RPG
           MMORPG
      LAG
Netzwerk-Architektur
      Peer-to-Peer
      Client-Server
Netzwerk-Technik
      Das OSI Modell
      Protokolle
           UDP
           TCP/IP
      Synchronschwimmen
      APIs
           Berkeley Sockets
           Windows Sockets (WinSock)
           DirectPlay
Implementierung der Netzwerk-Bibliothek
      Altbekanntes Interface-Design
      Server versus Clients
      Pakete schnüren
      Warteschlangen
      Socket Objekte
           ZFXSocketObject Klasse
           Erzeugung eines Sockets
           Namensgebung
           Reden ist Silber, Zuhören ist Gold
           Akzeptieren von Clients
           Konnektieren zum Server
           Diskonnektieren vom Server
           Senden von Daten
           Empfangen von Daten
           Abfragen des Postfachs
      Interface-Definition für eine Netzwerk-Klasse
      Windows Sockets Kapselung
           ZFXWS Klasse
           Initialisieren des Netzwerks
           Erstellen eines Servers
           Erstellen eines Clients
           Senden von Daten an den Server
           Senden von Daten an die Clients
           Nachrichten Prozedur
           Anmeldung von Clients
           Abmeldung von Clients
           Empfangen von Packet über das Netzwerk
Demo Applikation zur Anwendung der DLL
      Chatten übers Netzwerk
      Dateien versenden
Ein Blick zurück, zwei Schritt nach vorn

XII. Kapitel: Timing und Bewegung in der ZFXEngine
Hilfsbibliothek ZFXGeneral
Verschiedene Kameramodi
      Freie Kamera
      1st-Person Kamera
      3rd-Person Kamera
      Fixe Kamera
Bewegung durch ZFXMovementController
      Wozu einen Movement-Controller?
      Implementierung der Basisklasse
           ZFXMovementController Klasse
           Setzen der Attribute
           Neuberechnung der Achsen
           Kopplung mit der Viewmatrix
      Ableitung einer freien Kamera
           Einstellen der Rotationen
           Update der Kamera
      Ableitung einer 1st-Person-Kamera
           Einstellen der Rotationen
           Neuberechnung der Achsen
           Update der Kamera
Demo Applikation zur Anwendung der Bibliothek
Ein Blick zurück, zwei Schritt nach vorn

XIII. Kapitel: Scene Management
Sinn des Scene Managements
Scene Management Techniken
      Keine Lösung ist auch eine Lösung
      Kontinuierliches und diskretes Detaillevel
      Quadtrees
           Allgemeine Quadtrees
           Ausflug in die Grundlagen von Heightmaps
           Quadtrees für Terrain
      Octrees
      Binary Space Partitioning Bäume
           BSP-Algorithmus
           Finden des besten Splitters
           Node-Based-, Leavy- und solide BSP-Trees
      Portal-Engines
           Idee der Portal-Engine
           Special Effects mit Portalen
           Automatische Portal-Generation
      Potential Visibility Set
Implementierung eines BSP-Trees
      Klassen-Deklaration
      Erzeugen und Freigeben einer Instanz
      Rekursives erstellen des Baums
      Auswahl des besten Splitters
      Kollisionsabfragen
      Durchlaufen des Baumes
Implementierung eines Octrees
      Klassen-Deklaration
      Erzeugen und Freigeben einer Instanz
      Initialisieren eines Child Nodes
      Rekursives erstellen des Baums
      Polygonliste auf einen Node beschneiden
      Kollisionsabfragen
      Höhe des Spielers im Octree
      Durchlaufen des Baumes
Demo-Applikation BSP-Tree und Octree
      Rendern von ZFXPolygon Instanzen
      Laden der Leveldaten
      Berechnung eines Frames
      Sehenswertes in der Demo
Ein Blick zurück, zwei Schritt nach vorn

V. Teil: Schwarze Magie der Spieleprogrammierung

XIV. Kapitel: Computer Aided Design
Konzeptionelle Grundlagen
      Ingenieur, Architekt, Spieleentwickler
      Level Editing Tools
Low Poly Editor PanBox Edit
      Fähigkeiten des Tools
      WinAPI Rahmenanwendung
Klassen-Design des Tools
      Genereller Aufbau eines Levels
      Grundlage allen Seins: CLevelObject
      Auf unterster Ebene: CPolygon
           Klassen-Deklaration
           Erzeugen einer Instanz
           Laden und Speichern
           Kopieren einer Instanz
           Kollisionsabfrage
           Rendern einer Instanz
           Transformationen für Polygone
           Texturkoordinaten für Polygone
           MISC Methoden für Polygone
      Komplexe Modelle: CPolymesh
           Klassen-Deklaration
           Erzeugen einer Instanz
           Laden und Speichern
           Kopieren einer Instanz
           Kollisionsabfrage
           Rendern einer Instanz
           Texturkoordinaten für Polymeshs
           Auswahl total und Versteckspielen
           MISC-Methoden für Polymeshs
      Aufbruch in eine neue Welt: CPortal
           Mehr über PanBox Portale
           Klassen-Deklaration
           Erzeugen einer Instanz
           Laden und Speichern
           Kopieren einer Instanz
           Kollisionsabfrage und Rendern einer Instanz
           MISC-Methoden für Portale
      Es werde Licht: CLight
           Klassen-Deklaration
           Laden, Speichern und Kopieren einer Instanz
           Kollisionsabfrage und Rendern einer Instanz
      Interaktive Objekte: CEntity
           Klassen-Deklaration
           Erzeugen einer Instanz
           Die üblichen Funktionalitäten
           MISC-Methoden für Entities
           Entities mit Portalen verbinden
      Ich mach den Fisch: CSpawnPoint
      Lokales Management: CSector
           Klassen-Deklaration
           Erzeugen einer Instanz
           Laden und Speichern
           Laden eines PreFabs
           Kollisionsabfrage und Selektion von LOBs
           Verstecken von Objekten im Sektor
           Hinzufügen und Entfernen von Objekten
           Rendern einer Instanz
           Portale und Entities verbinden
      Alle zusammen: CLevel
           Klassen Deklaration
           Laden und Speichern
      In der engeren Auswahl: CSelectionBuffer
           Klassen-Deklaration
           Objekte hinzufügen
           Löschen und Kopieren von Objekten
           Polys zu Meshs, Meshs zu Polys
           Speichern eines PreFabs
Ausgewählte Aspekte des GUI
      Klassen-Deklaration
      Wichtige Attribute
      Erstellen eines Polygons
Ein Blick zurück, zwei Schritt nach vorn

XV. Kapitel: Pandora's Legacy
Deathmatch Ego-Shooter Pandoras Legacy
      Simple Game Design
      Altbekannte Klassen neu aufgelegt
Im Schatten unserer Selbst
      Zur Theorie der Shadow Volumes
      Implementierung von Shadow Volumes
           Klassen-Deklaration
           Initialisieren einer Instanz
           Erstellen des Shadow Volumes
           Rendern des Shadow Volumes
           Ein Wort zu Shadow Volumes über Shader
Laden eines Levels
      Benötigte Hilfs-Datenstrukturen
      Lade-Methode in CGameLevel
      Lade-Methode in CGameSector
           Polygone aus Meshs laden
           Freie Polygone laden
           Polygonliste kompilieren
      Herstellen der Verbindungen zwischen den Portalen
Rendern eines Levels
      Rendern der Geometrie
           Rendern des Depth-Pass
           Rendern des Ambient-Pass
           Rendern der Light-Passes
      Rendern der Schatten
Integration von Characters
      CGameCharacter, Basisklasse für Spieler und NPCs
      Netzwerknachrichten von und für Characters
CGame, die Klasse für das Spiel
      Update des Spiels
      Aufgaben für das Netzwerk
      Kollisionsdetektion
Ein Blick zurück, zwei Schritt nach vorn

XVI. Kapitel: Scripting und Definition von NPC-Verhalten
Kontrolle von NPCs
ZBL/0 ZFX Bot Language - die Scriptsprache für ZFX-Bots
ZBL-API - Integrieren der ZBL/0-Virtual Machine
      Mehr über das ZBL-API-Interface
      Mehr über die Virtual Machine
           Stack-Automaten
           Die Virtual Machine als paralleler Stack-Automat
ZBL/0 Toolkit - die ZBL-Entwicklungsumgebung
ZBL/0-Bot-Design - Entwickeln von Bots mit der ZFX-Bot-Language
      Die Scriptsprache ZBL/0 (Syntax)
      ZBL/0-Standardbefehle und Anweisungen
      Die Entwicklung eines Game-Bots mit ZBL/0
Ein Blick zurück, zwei Schritt nach vorn