Inhalt

Titelei

Impressum

Inhalt

Widmung

Vorwort

1 Grundlagen

1.1 Einleitung

1.1.1 An wen richtet sich dieses Buch?

1.1.2 Welche Vorkenntnisse werden benötigt?

1.1.3 Wie arbeitet man am effektivsten mit diesem Buch?

1.1.4 Geduld, Motivation und gelegentliche Tiefschläge

1.1.5 Das Begleitmaterial zum Buch

1.1.6 Fragen zum Buch

1.2 Die Programmiersprache C++

1.2.1 Von Lochkarten zu C++

1.2.2 Objektorientiertes Programmieren

1.2.3 Der ANSI-Standard

1.2.4 Warum gerade C++?

1.3 Jetzt geht es los … unser erstes Programm

1.3.1 Kommentare im Quelltext

1.3.2 Die #include-Anweisung

1.3.3 Die main-Funktion

1.3.4 „cout“ und einige mögliche Escape-Zeichen

1.4 Die Entwicklungsumgebung Visual Studio 2015 Community Edition

1.4.1 Anlegen eines neuen Projektes

1.4.2 Das Programm mithilfe des Quelltexteditors eingeben

1.4.3 Laden der Programmbeispiele

1.4.4 Das Programm kompilieren und linken

1.4.5 Ausführen des Programms

1.5 Die Entwicklungsumgebung Xcode

1.5.1 Anlegen eines neuen Projekts

1.5.2 Hinzufügen und Erstellen von neuen Dateien

1.5.3 Das Programm mithilfe des Quelltexteditors eingeben

1.5.4 Laden der Programmbeispiele

1.5.5 Das Programm kompilieren und linken

1.5.6 Ausführen des Programms

1.6 Umstellen der Build-Konfiguration

1.6.1 Build-Konfiguration in Visual Studio 2015 Community Edition umstellen

1.6.2 Build-Konfiguration in Xcode 6.4 umstellen

1.6.3 Der Unterschied zwischen Debug und Release

1.7 Aufgabe

2 Variablen

2.1 Was sind Variablen, und wozu dienen sie?

2.2 Datentyp, Variablenname und Wert

2.3 Deklarieren und Definieren von Variablen

2.4 Rechnen mit Variablen

2.4.1 Weitere Rechenoperatoren

2.5 Die verschiedenen Datentypen

2.6 Namenskonventionen

2.7 Konstanten

2.7.1 Konstanten mit „const“ erzeugen

2.7.2 Konstanten mit „#define“ erzeugen

2.7.3 Konstanten mit „enum“ erzeugen

2.7.4 Welche der drei Möglichkeiten ist die beste?

2.8 Mach mal Platz: Speicherbedarf der Datentypen

2.8.1 Überlauf von Variablen

2.9 Eingabe von Werten mit „cin“

2.10 Casting: Erzwungene Typenumwandlung

2.10.1 Casting im C-Stil

2.10.2 Casting mit C++

2.11 Fehlerquelltext

2.11.1 Was soll das Programm eigentlich tun?

2.11.2 Lösung zum Fehlerquelltext

3 Schleifen und Bedingungen

3.1 Was sind Schleifen und Bedingungen, und wozu dienen sie?

3.2 Boolesche Operatoren (==, <, >, !=)

3.3 Die if-Bedingung

3.4 Mittels „else“ flexibler verzweigen

3.5 else if und verschachtelte if-Bedingungen

3.6 Logische Operatoren

3.7 Verzweigen mit switch und case

3.8 Immer und immer wieder: for-Schleifen

3.8.1 Initialisierungsteil

3.8.2 Bedingungsteil

3.8.3 Aktionsteil

3.8.4 Zusammenfassung

3.8.5 Mehrere Initialisierungen im Aktionsteil

3.8.6 Leere Initialisierungs-, Bedingungs- und Aktionsteile

3.9 Eine weitere Rechenoperation: Modulo

3.10 Aufgabenstellung

3.10.1 Wie geht man an die Aufgabe heran?

3.10.2 Lösungsvorschlag

3.11 Schleifen mit while und do-while

3.12 Verschachtelte Schleifen

3.13 Fehlerquelltext

3.13.1 Was soll das Programm eigentlich tun?

3.13.2 Lösung zum Fehlerquelltext

4 Funktionen

4.1 Was sind Funktionen, und wozu dienen sie?

4.2 Aufbau des Funktionskopfes

4.2.1 Rückgabetyp

4.2.2 Funktionsname

4.2.3 Parameterliste

4.3 Aufrufen einer Funktion

4.3.1 Funktionsprototypen

4.4 Gültigkeitsbereiche

4.4.1 Lokale Variablen

4.4.2 Globale Variablen

4.4.3 Das wäre ja zu einfach gewesen: globale Variablen am Pranger

4.5 Verwenden der Funktionsparameter

4.5.1 Der Stack

4.6 inline-Funktionen

4.7 Wann setzt man Funktionen ein?

4.7.1 Und wann soll's inline sein?

4.8 Überladene Funktionen

4.9 Aufgabenstellung

4.9.1 Wie geht man an die Aufgabe heran?

4.9.2 Lösungsvorschlag

4.10 Der sinnvolle Aufbau des Quellcodes

4.11 Erstellen und Hinzufügen der neuen Dateien

4.12 Das Schlüsselwort „extern“

4.13 Ein kleines Spiel: Zahlenraten

4.13.1 Zufallszahlen und Bibliotheken

4.13.2 Die Hauptfunktion (main)

4.13.3 Die Funktion „WaehleLevel“

4.13.4 Die Funktion „Spielen“

4.13.5 Was gibt es an diesem Listing zu kritisieren?

5 Arrays und Strukturen

5.1 Was sind Arrays, und wozu dienen sie?

5.2 Ein Array erzeugen

5.3 Ein Array gleichzeitig deklarieren und definieren

5.4 Fehler beim Verwenden von Arrays

5.5 char-Arrays

5.6 Eingabe von Strings über die Tastatur

5.7 Mehrdimensionale Arrays

5.8 Arrays und Speicherbedarf

5.9 Was sind Strukturen, und wozu dienen sie?

5.10 Spielerverwaltung mit Strukturen und Arrays

5.11 Aufgabenstellung

5.11.1 Wie geht man an die Aufgabe heran?

5.11.2 Lösungsvorschlag

6 Zeiger und Referenzen

6.1 Was sind Zeiger, und wozu dienen sie?

6.1.1 Der Stack

6.1.2 Vom Flur in den Keller

6.2 Die Adresse einer Variablen

6.3 Die Adresse einer Variablen in einem Zeiger speichern

6.3.1 Schreibweisen bei der Deklaration

6.4 Variablen mittels Zeigern ändern

6.5 Schön und gut, aber wozu wird das gebraucht?

6.6 Noch einmal zurück zum Flur

6.7 Was sind Referenzen, und wozu dienen sie?

6.7.1 Mit Referenzen arbeiten

6.7.2 Regeln bei der Verwendung von Referenzen

6.8 Referenzen als Funktionsparameter

6.9 Warum Zeiger nehmen, wenn es Referenzen gibt?

6.10 Aufgabenstellung

6.10.1 Wie geht man an die Aufgabe heran?

6.10.2 Lösungsvorschlag

7 Klassen

7.1 Was sind Klassen, und wozu dienen sie?

7.2 Eine einfache Klasse erzeugen und verwenden

7.3 Ordnung muss sein

7.4 Jetzt wird es privat

7.4.1 Private Membervariablen

7.4.2 Private Membervariablen und Performance

7.4.3 Private Memberfunktionen

7.5 Konstruktoren und Destruktoren

7.5.1 Der Konstruktor

7.5.2 Konstruktoren mit Parameterliste

7.5.3 Überladene Konstruktoren

7.6 Der Destruktor

7.7 Speicherreservierung

7.7.1 New und Delete

7.7.2 Ein sinnvolleres Beispiel

7.7.3 Friss mich, ich bin Dein Speicher

7.8 Aufgabenstellung

7.8.1 Wie geht man an die Aufgabe heran?

7.8.2 Lösungsvorschlag

7.9 Vererbung

7.9.1 Überschreiben von Memberfunktionen

7.9.2 Virtuelle Memberfunktionen

7.9.3 Vererbung und Performance

7.10 Statische Membervariablen

8 Fortgeschrittene Themen

8.1 Über dieses Kapitel

8.2 printf und sprintf_s

8.2.1 printf

8.2.2 sprintf_s

8.3 Templates

8.3.1 Template-Funktionen

8.3.2 Template-Klassen

8.4 Singletons

8.4.1 Eine Klasse für Singletons

8.4.2 Einsatz von Singletons

8.5 Dateien: Ein- und Ausgabe

8.5.1 Werte in eine Datei schreiben und auslesen

8.5.2 So viel Zeit muss sein: Fehlerabfrage

8.5.3 Instanzen von Klassen in Dateien schreiben

8.5.4 Weitere Flags und ihre Bedeutung

8.6 Eine nützliche Logfile-Klasse

8.6.1 Die Header-Datei der Logfile-Klasse

8.6.2 Die Implementierung der Logfile-Klasse

8.6.3 Anwendung der Logfile-Klasse

8.7 Try, Catch und Assert

8.7.1 Das Makro „assert“

8.7.2 Fang mich, wenn Du kannst: try und catch

8.8 Der Debugger

8.8.1 Das Programm im Einzelschrittmodus durchlaufen

8.8.2 Haltepunkte und Funktionsaufrufe

8.9 Bitweise Operatoren

8.9.1 Das Binärformat

8.9.2 Die Operatoren & (und), | (oder) und ^ (exklusiv oder)

8.9.3 Der ~-Operator (nicht)

8.9.4 Shifting-Operatoren (<< und >>)

8.9.5 Ein reales Beispiel

8.9.6 Weitere Einsatzgebiete

8.10 SAFE_DELETE ‒ ein nützliches Makro

9 Die STL

9.1 STL ‒ was ist das?

9.1.1 Vektoren

9.1.2 Verkettete Listen

9.1.3 Strings

9.1.4 Maps und Multimaps

10 Grundlagen der Windows-Programmierung

10.1 Raus aus der Konsole, rein ins Fenster

10.1.1 Anlegen eines Win32-Projektes

10.1.2 Ein Windows-Grundgerüst

10.1.3 Die WinMain-Funktion

10.1.4 Die Callback-Funktion

10.1.5 Zusammenfassung

10.1.6 Ein kurzer Abstecher: Funktionszeiger

10.2 Aufgabenstellung

10.2.1 Wie geht man an die Aufgabe heran?

10.2.2 Lösungsvorschlag

10.3 Ein bisschen mehr Interaktion

10.3.1 Statischer Text

10.3.2 Buttons und Editboxen

10.3.3 Messageboxen

10.4 Alles noch einmal zusammen

11 Sonst noch was?

11.1 Um was geht es in diesem Kapitel?

11.2 Standardwerte für Funktionsparameter

11.3 Memberinitialisierung im Konstruktor

11.4 Der this-Zeiger

11.5 Der Kopierkonstruktor

11.6 Überladen von Operatoren

11.7 Mehrfachvererbung

11.8 Friend-Klassen

11.9 Goto

11.10 Der ternäre Operator

11.10.1 Einfache Verwendung

11.10.2 Code direkt ausführen

11.10.3 Rangfolge der Operatoren

11.10.4 Eine weitere Verwendungsmöglichkeit

11.11 Namensbereiche (Namespaces)

11.11.1 Ordnung halten mit Namespaces

11.11.2 Verschachtelte Namensbereiche

11.12 Unions

12 Ein Spiel mit der SDL

12.1 Die SDL ‒ was ist das?

12.2 Erstellen und Einrichten des Projekts unter Visual Studio Community 2015

12.2.1 Das Projekt anlegen und einrichten

12.2.2 Die restlichen Quellcode-Dateien und die .dll-Datei

12.3 Erstellen und Einrichten des Projekts unter Xcode

12.3.1 Das Projekt anlegen und einrichten

12.3.2 Die restlichen Quellcode-Dateien

12.4 Projektübersicht

12.4.1 Warum plötzlich Englisch? Und wo sind die Zeilennummern?

12.4.2 Übersicht der Klassen

12.5 Die Implementierung des Spiels

12.5.1 Die main-Funktion des Spiels

12.5.2 Zeit ist wichtig: Die Klasse CTimer

12.5.3 Die Klasse CFramework

12.5.4 Bunte Bilder: Die Klasse CSprite

12.5.5 Feuer frei: die Klasse CShot

12.5.6 Die Klasse CAsteroid

12.5.7 Die Hauptfigur: Die Klasse CPlayer

12.5.8 Die Klasse CGame

12.6 Erweiterungsmöglichkeiten

13 Der Einstieg in die Szene

13.1 Wie geht's nun weiter?

13.2 Die Szene … was ist das eigentlich?

13.3 Welche Möglichkeiten gibt es?

13.4 Foren benutzen

13.4.1 Ich sag Dir, wer ich bin

13.4.2 Richtig posten

13.4.3 FAQs und die Suchfunktion

13.4.4 Die Kunst zu lesen

13.4.5 Selbst Initiative ergreifen und anderen helfen

13.5 Weiterbildung mit Tutorials

13.6 Anlegen einer Linksammlung

13.7 Copy & Paste

13.8 Die Sprache neben C++: Englisch

13.9 Auf dem Weg zum eigenen Spiel

13.9.1 Mein erstes Spiel: ein 3D-Online-Rollenspiel für 500 Leute

13.9.2 Teammitglieder suchen

13.9.3 Das fertige Spiel bekannt machen

13.9.4 Besuchen von Events zum Erfahrungsaustausch

13.10 return 0;

Copyright 2010, 2012, 2014 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.

Hallo und herzlich willkommen! Du möchtest also gerne das Spieleprogrammieren lernen und hast Dich für dieses Buch entschieden. Genau jetzt, wenn Du diese Zeilen liest, befindest Du Dich auf den ersten Metern eines langen Weges, den es sich jedoch definitiv lohnt zu gehen.

Vor über zwei Jahrzehnten brach eine neue Ära an, als die Homecomputer die heimischen Wohnzimmer eroberten. Recht schnell fanden viele Leute Gefallen daran, nicht nur fertige Computerspiele zu spielen, sondern selbst herauszufinden, wie man solche eigenständig entwickeln kann. „Herauszufinden“ trifft dabei den Nagel auf den Kopf, denn Medien wie das Internet waren zu dieser Zeit nicht vorhanden und Buchmaterial war kaum bis gar nicht in den Regalen der Buchhandlungen zu finden. Aus diesem Grund trennte sich schnell die Spreu vom Weizen, und manche gaben auf. Manche klemmten sich jedoch so lange dahinter, bis die gewünschten Resultate über den Bildschirm flackerten. Genau dieser „Forschergeist“ ist es, der einen Spieleprogrammierer ausmacht. Man muss Geduld haben, bereit sein zu lernen und einen unermüdlichen Drang besitzen, sein Vorhaben in die Tat umzusetzen. Dazu könnte es keine bessere Zeit geben als die heutige. Im Internet gibt es eine Fülle von Informationen, Hilfestellungen und sogar ganze Communities, die sich mit dem Thema Spieleprogrammierung befassen. Früher bestanden die Quelltexte (Programmcodes) von Spielen noch aus einer endlosen Reihe von kryptischen, meist aus drei Buchstaben bestehenden Befehlen und unübersichtlichen Sprunganweisungen. Heute hingegen hat man mit C++ eine mächtige Hochsprache in der Hand, die leicht zu erlernen ist und viele Dinge einfacher und logischer macht. Informationen sind leichter zugänglich, und Spieleprogrammierer sind längst keine kleine Gruppe mehr, die sich gut gehütete Geheimnisse teilt. Heute ist es jedem möglich, sich selbst mit dieser Thematik zu befassen, solange er bereit ist, sich intensiv damit auseinander zu setzen.

Sicherlich ist mit der wachsenden Leistung der Computer und den immer höher werdenden Anforderungen an das System auch die Komplexität gestiegen. Dabei bleiben jedoch bestimmte Grundlagen immer gleich. Wer schon eine Programmiersprache beherrscht oder sich generell bereits mit der Thematik des Programmierens befasst hat, wird hier einige Dinge antreffen, die ihm bekannt vorkommen werden. Trotzdem ist Stillstand der größte Feind eines Spieleprogrammierers. Deshalb ist es enorm wichtig, die mittlerweile unglaublich ergiebige Informationsflut im Internet zu nutzen und immer auf dem neuesten Stand zu bleiben. Schneller als je zuvor kann man sich heute über das Internet die gewünschten Informationen beschaffen. Jedoch birgt diese Möglichkeit der Informationssuche auch eine Gefahr: Man lässt sich schnell verleiten, den eigenen Kopf zugunsten einer Suchmaschine auszuschalten. Deshalb möchte ich an dieser Stelle unbedingt darauf hinweisen, dass man zuerst selbst versuchen sollte, ein Problem zu lösen, und erst dann auf Diskussionsforen oder Ähnliches zugreift, wenn man selbst wirklich nicht mehr anders weiterkommt. Diese Vorgehensweise ist enorm wichtig, um auf lange Sicht Erfolg zu haben. Oftmals findet man selbst eine bessere oder effektivere Lösung, wenn man darüber nachdenkt, statt andere für sich denken zu lassen. Nutze deshalb das Internet als Werkzeug und nicht, um den eigenen Kopf zu ersetzen.

Viele Bücher über die Spieleprogrammierung setzen an einem Punkt an, an dem schon weitreichende Vorkenntnisse der Programmiersprache C++ gefordert sind, oder bieten nur einen kleinen Crash-Kurs im Programmieren an. Andere Bücher befassen sich zwar mit der Programmiersprache C++, ohne dabei jedoch einen Bezug zur Spieleprogrammierung herzustellen. Dieses Buch versucht nun, diese Lücke zu schließen und den Grundstein zu legen, der auf dem Weg zum Spieleprogrammierer nötig ist: Das Erlernen der Programmiersprache C++. Nach dem Durcharbeiten dieses Buches solltest Du also über das essenzielle Grundlagenwissen verfügen, das nötig ist, um erfolgreich Spiele zu entwickeln.

In diesem Sinne: Let's code!

Anmerkungen zur fünften Auflage

Als ich vor über zehn Jahren die Idee hatte, ein Buch über C++ mit Bezug zur Spieleprogrammierung zu schreiben, hätte ich nie gedacht, dass dieses Buch einmal in die fünfte Auflage gehen würde. Doch nun ist es tatsächlich so weit und ich blicke zugegebenermaßen ein wenig erstaunt auf den kleinen Stapel Bücher, der gerade neben mir liegt. Erstaunt darüber, wie viel Zeit seit der ersten Auflage vergangen ist und welchen Wandel das Buch hinter sich hat. Beinhaltete die erste Auflage lediglich zehn Kapitel, wurde die zweite Auflage um drei Kapitel erweitert. Grundlagen der Windows-Programmierung, weitere fortgeschrittene Themen sowie ein kleines, aber vollständiges Spiel mit der SDL kamen hinzu. Dies war durch das rege Feedback und die tollen Vorschläge der Leser der ersten Auflage möglich.

In der dritten Auflage wurde das Buch hinsichtlich der verwendeten Entwicklungsumgebungen aktualisiert. Von Visual Studio 6.0 und Visual Studio .net 2003 fand ein Umstieg auf die Visual Studio 2008 Express Edition statt, die wesentlich moderner und benutzerfreundlicher war. Zudem gab es diese Entwicklungsumgebung kostenlos ‒ eine feine Sache für Einsteiger und Hobby-Entwickler.

Mit der vierten Auflage wurde neben der Aktualisierung auf Visual Studio 12 eine weitere Entwicklungsumgebung auf einem anderen Betriebssystem vorgestellt: Xcode unter Mac OS X. Somit konnten auch Leser, die lieber auf Apple-Computern arbeiten, das Buch verwenden. Lediglich bei den Beispielen zur Windows-Programmierung gab es naturgemäß Einschnitte. Da der Quellcode zu den restlichen Beispielen fast komplett plattformunabhängig war, musste nur an wenigen Stellen auf systemspezifische Unterschiede eingegangen werden. Doch gerade in der heutigen Zeit, in der es eine größere Plattformvielfalt gibt als je zuvor (nicht zu vergessen die ganze Mobil-Sparte), ist es besonders wichtig, auch einmal über den Tellerrand hinauszuschauen und nicht nur auf einem einzigen System zu entwickeln.

In dieser fünften Auflage wurden die verwendeten Entwicklungsumgebungen ebenfalls wieder auf den neuesten Stand gebracht. Zudem hielt ich es für angebracht, die bestehenden Kapitel um einige Themen zu ergänzen, die bisher außen vor blieben. Dazu gehören Unions, Namensbereiche, der ternäre Operator, bitweise Operatoren und einiges mehr. Außerdem wurde das gesamte Kapitel 12 ("Ein Spiel mit der SDL") auf Version 2 der SDL aktualisiert.

Alle diese Auflagen wären ohne das Feedback und die konstruktiven Vorschläge der Leser und der Community nicht möglich gewesen. Aus diesem Grunde möchte ich mich hier noch einmal ganz besonders bei allen Lesern bedanken!

Danksagung

Bevor es nun losgeht, möchte ich mich an dieser Stelle bei allen Leuten bedanken, die mich beim Schreiben dieses Buches unterstützt haben und mithalfen, es zu verwirklichen. Marc Kamradt und Jörg Winterstein haben sich mühsam durch alle Kapitel geackert und mir überall dort auf die Finger geklopft, wo es angebracht war. Jörg hat es dabei immer wieder geschafft, mich mit seinem unverwechselbaren Humor in seinen Kommentaren zum Lachen zu bringen. Ohne Eure Hilfe wäre dieses Buch nicht zustande gekommen. Danke, Jungs!

Für die Grafiken des kleinen Demo-Spiels möchte ich mich bei Thomas Schreiter und seiner gestalterischen Zauberhand bedanken, die mich immer wieder verblüfft.

Matthias Gall und Mathias Ricken hatten immer dann ein offenes Ohr, wenn eine Frage auftauchte und beantwortet werden musste.

Peter Schraut und David Scherfgen haben sich ebenfalls einige Kapitel vorgenommen und mit vielen nützlichen Hinweisen und Vorschlägen zu diesem Buch beigetragen. Euch beiden ein dickes Dankeschön hierfür. Und David: Öle deine Maus und mach die Tastatur startklar…bald geht ein gewisses Spiel in eine neue Runde. Ach ja, Peter: Warum liegt denn da Stroh rum?

Fernando Schneider vom Hanser Verlag hat mir mit Rat und Tat zur Seite gestanden, wenn es um dieses Buchprojekt ging, und uns auf der Dusmania hilfreich unter die Arme gegriffen. Ich hoffe, dass es Dir gut geht und wir uns mal wieder sehen!

Weiterhin möchte ich mich bei Sieglinde Schärl, Julia Stepp und Irene Weilhart sowie allen anderen Mitarbeitern des Hanser Verlages für die gute Zusammenarbeit bedanken. Bei Sieglinde Schärl möchte ich mich vor allem für ihre große Geduld bedanken, denn mein ständiges „Ja, nein, vielleicht, vielleicht doch nicht“ bei Neuauflagen ist sicherlich nicht einfach.

Der größte Dank gilt meiner Mutter und allen Freunden, die daran geglaubt haben, dass die Idee dieses Buches auch in die Tat umgesetzt wird.

Spezieller Dank geht an Marc Grimm, dafür, dass er da ist!

Dreieich, im Dezember 2015

Heiko Kalista