Datenstrukturen Look-Up Tabellen, Zufallszahlen, Listen, Speichermanagement und Dateiverwaltung

Look-Up Tabellen: Probleme bei Spielen Spielszenen müssen sehr oft pro Sekunden berechnet werden Wenn es zu viele Berechnungen werden fängt das Spiel an zu „ruckeln“ Problem ist nicht immer die Grafikkarte (bei 3D spielen) Häufig ist KI schuld (z.B. bei Strategiespielen: viele Einheiten werden von Computer bewegt und kommandiert) wiederkehrende Operationen werden immer neu berechnet

Lösung: Look Up Tabelle Wikipedia: In der Informatik ist eine Look-Up-Table eine Datenstruktur, meist ein (assoziatives) Array, das komplizierte Laufzeitberechnungen durch einen einfachen Zugriff auf die Datenstruktur ersetzt. Dies führt zu einem signifikanten Geschwindigkeitsgewinn, sofern die benötigten Speicherzugriffe schneller sind als die normale Berechnung. Alle wiederkehrenden Berechnungen werden durch Look-Up Tabellen vermieden

Was macht eine Look-Up Tabelle? Vor Beginn des Spiels werden alle benötigten Werte vorberechnet Es gibt verschiedene Typen von Look-Up Tabellen, so dass man sich vorher überlegen muss, von welcher Art (sin, cos, Quadratwurzel) diese sein muss und welche Genauigkeit diese haben muss Es können nicht nur Funktionswerte, sondern bsplw. auch Zufallszahlen in Look-Up Tabellen gespeichert werden Um flexibel mit Look Up Tabellen arbeiten zu können sollte man sie in Klassen einbetten

Beispiel: #include <iostream.h> #include <math.h> #define SAFE_DELETE(p) {if(p) {delete (p); (p)=NULL;}} #define SAFE_DELETE_ARRAY(p) {if(p) {delete[] (p); (p)=NULL;}} // bis hier hin nur „Vorgeplänkel“, Includen von iostream und math-Klasse und Einbinden von Makros von Heap-Speicher //Beispiel: sinus-Tabelle

class CSinLookUp { private: long AnzElements; float Genauigkeit; float* Tabelle;

public: CSinLookUp(float Schrittweite = 1.0f) // Konstruktor { Genauigkeit = 1.0f/Schrittweite; AnzElements = (long)(360*Genauigkeit); Tabelle = new float[AnzElements]; for(long winkel = 0; winkel < AnzElements; winkel++) // Berechnung der Sinus Look-Up Tabelle Tabelle[winkel] = sinf(winkel*Schrittweite*3.141592654f/180.0f); } ~CSinLookUp() // Destruktor SAFE_DELETE_ARRAY(Tabelle) // Zerstören des Arrays float ReturnSinValue(float winkel) // Zugriffsfunktion if(winkel < 0.0f) winkel += 360.0f; else if(winkel > 360.0f) winkel -= 360.0f; return(Tabelle[(long)(winkel*Genauigkeit)]); };

Aufruf in Methode mit: CSinLookUp* SinLookUp = new CSinLookUp(0.1f); // Schrittweite //von 0.1 cout << "sin(45 DEG) = " << SinLookUp->ReturnSinValue(45.0f) << endl; SAFE_DELETE(SinLookUp) // zerstören der Tabelle

Zufallszahlen Werden in einem Spiel hauptsächlich für die Variation des Spielablaufes und des Gegnerverhaltens eingesetzt In C++ gibt es eine Funktion für Zufallszahlen rand()-Funktion ist komfortabel für die Erzeugung von Zufallszahlen Am komfortabelsten ist es, eine Klasse alleine für Zufallszahlen anzulegen und die Zahlen in einer Tabelle zu speichern

Aufruf der Zufallszahlenmethode und Initialisierung des „Zufallsgenerators“ int main(void) { // Initialisierung des Zufallsgenerators srand(time(0)); // dann Aufruf der Zufallszahlenfunktion cout << frnd(-5.0f,5.0f) << endl; }

Erzeugung von Zufallszahlen mit rand()-Funktionen Mit einfachen Inline-Funktion (hier float-Zufallszahl): float tempFrnd; inline float frnd(float low, float high) { tempFrnd = low + ( high - low ) * ( (long)rand() ) / RAND_MAX; // RAND_MAX enthält die größtmögliche Zufallszahl if(tempFrnd < high) return tempFrnd; else return low; } // weiteres Beispiel im Buch (extra Klasse für Zufallszahlen)

Einfach verkettete Listen Einheit zur Speicherung und Verwaltung relevanter Daten Besteht aus mehreren Knoten (sofern mehrere Daten vorhanden sind) Jeder Knoten ist über einen Zeiger mit dem nächsten Knoten verbunden Jeder Knoten ist entweder eine Strukturvariable oder ein Klassenobjekt Erster Knoten = Head-Knoten Letzter Knoten = Tail-Knoten

Wie sieht eine einfach verkettete Liste aus? Head  Node  Node  Node  Tail

Probleme Probleme bei Listen Sehr unflexibel Sehr langsam Will man auf ein Element zugreifen, muss die gesamte Liste durchlaufen werden um das Element zu finden (es sei denn es befindet sich am Anfang) Die Reihenfolge der abgelegten Objekte entspricht meistens nicht der Reihenfolge der im Spiel benötigten Objekte

Speicherfragmentierung Speicherprobleme Jedes Erzeugen von Knoten kostet Speicherplatz (mit „new“ wird Speicherplatz reserviert) „new“ sucht nach einem Speicherblock mit geeigneter Größe Nur wenn ein geeigneter Block gefunden wird kann Objekt angelegt werden Sind alle gefundenen Speicherblöcke zu klein, kann Objekt nicht erzeugt werden Speicherfragmentierung

Arrays lösen diese Probleme Arrays reservieren einen bestimmten Speicherplatz Kritik: unnötiger Speicherplatz wird verschenkt und Arrays sind zu unflexibel Für Spieleprogrammierung gilt das nicht Beispiel: Spiel mit animierten Asteroiden Obergrenze der Anzahl an Asterioden wird durch vordefiniertes Array festgelegt Kein Nachteil, weil sowieso nur eine gewisse Anzahl gerendert und animiert werden können Zugriff auf Array geht viel schneller als Zugriff auf Element in verketteter Liste

Memory Manager Es ist sinnvoll eine Klasse zu entwerfen die die Speicherverwaltung in einem Spiel übernimmt Also alles in einer Memory Manager Klasse Klasse hat vordefiniertes Array mit dem gearbeitet werden kann Beispiel im Buch Programmbeispiele  Tag2  Memory Manager

Dateiverwaltung Dazu zählt etwa eine Speicherfunktion für ein Spiel Wichtige Struktur in Beispiel: _finddata_t  Speichert alle Informationen über die Dateiarbeit Wichtige Funktionen sind: _findfirst( "Szenarien/*.*", &c_file ) Untersucht ob der Ordner überhaupt existiert _findnext( hFile, &c_file ) Alle weiteren Dateien werden durchsucht