Häufig steht man bei Spielen vor dem Problem, dass man Tabellen (meistens Arrays) nach mehreren Kriterien sortieren möchte. Dieses Tutorial zeigt anhand einer Sport-Tabelle, wie man das einfach realisiert.
Die Tabelle
In einem der letzten Tutorials ging es um einen Spielplangenerator. Diesen Gedanken möchte ich aufgreifen, um das Tutorial zu erklären. Angenommen, wir haben ein Spiel, in dem in einem Ligamodus mehrere Spieler gegeneinander spielen. Nach jedem Spieltag wollen wir eine Tabelle sehen. Diese sieht zufällig wie eine Fußballtabelle aus.
Wir haben Platzierung, Name, Spiele, Siege, Unentschieden, Niederlagen, Tore, Tordifferenz und die Punkte. Sortiert wurde die Tabelle wie folgt:
- Alphabetisch
- nach Punkten
- nach der Tordifferenz
- Siege
- Anzahl Spiele
Das ist ein bisschen komplexer, aber ich denke, dass viele von euch mehrere solcher Kriterien suchen. Bevor es los geht, brauchen wir aber ein Array, welches sortiert werden kann.
Array und Structs
Bevor wir Daten verarbeiten, müssen wir uns darüber Gedanken machen, wie wir Daten erfassen. Um GameMaker Studio gibt es dazu sehr viele verschiedene Methoden, die alle ihre Vor- und Nachteile haben. Ich bin generell ein großer Fan von Arrays, weil die in nahezu jeder Sprache funktionieren und ich dadurch die Option behalte, Code einfach von einer Sprache in die andere zu konvertieren (etwa in PHP oder JavaScript).
Nun gibt es aber auch die Möglichkeit von Structs. Ein Struct ist eine Variable, die eine Sammlung von anderen Variablen enthält. Die Variablen, die ein Struct enthält, können verschiedene Datentypen haben, und diese Variablen können nach der anfänglichen Struct-Deklaration gelesen und beschrieben werden.
Man kann Structs und Arrays kombinieren, was im Code große Vorteile bringt. Um das zu demonstrieren, zeige ich gleich das Create-Event:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
arr_clubs[0] = { name: „Ajax Dauerstramm", league: 1, wins: 11, draws: 6, defeat: 6, go: 45, goa: 33, player: 2 }; arr_clubs[1] = { name: „Hangover 96", league: 1, wins: 9, draws: 3, defeat: 11, go: 35, goa: 43, player: 0 }; arr_clubs[2] = { name: „Arminia Bierzelt", league: 1, wins: 6, draws: 1, defeat: 16, go: 24, goa: 56, player: 0 }; arr_clubs[3] = { name: „SC Dunkelwald", league: 1, wins: 12, draws: 6, defeat: 5, go: 46, goa: 29, player: 0 }; arr_clubs[4] = { name: „Eintracht Zwietracht", league: 1, wins: 12, draws: 6, defeat: 5, go: 35, goa: 32, player: 0 }; arr_clubs[5] = { name: „1. FC Hoch und weit", league: 1, wins: 14, draws: 7, defeat: 2, go: 66, goa: 22, player: 1 }; arr_clubs[6] = { name: „Dynamo Tresen", league: 1, wins: 10, draws: 5, defeat: 8, go: 38, goa: 34, player: 0 }; arr_clubs[7] = { name: „FC Saufhemden", league: 1, wins: 9, draws: 7, defeat: 7, go: 42, goa: 31, player: 0 }; arr_clubs[8] = { name: „Glashoch Rangers", league: 1, wins: 9, draws: 4, defeat: 10, go: 40, goa: 37, player: 0 }; arr_clubs[9] = { name: „AS Koma", league: 1, wins: 8, draws: 6, defeat: 9, go: 38, goa: 39, player: 0 }; arr_clubs[10] = { name: „FC Blutgrätsche", league: 1, wins: 16, draws: 1, defeat: 6, go: 47, goa: 28, player: 0 }; arr_clubs[11] = { name: „Inter Heiland", league: 1, wins: 6, draws: 9, defeat: 8, go: 32, goa: 36, player: 3 }; arr_clubs[12] = { name: „VFL Vollsuff", league: 1, wins: 8, draws: 3, defeat: 12, go: 28, goa: 39, player: 0 }; arr_clubs[13] = { name: „SC Heiß Haufen", league: 1, wins: 5, draws: 5, defeat: 13, go: 28, goa: 44, player: 0 }; arr_clubs[14] = { name: „Feiern 04 Leberbluten",league: 1, wins: 4, draws: 7, defeat: 12, go: 28, goa: 40, player: 0 }; arr_clubs[15] = { name: „AS Pirin", league: 1, wins: 5, draws: 4, defeat: 14, go: 29, goa: 42, player: 0 }; arr_clubs[16] = { name: „FC Biercelona", league: 1, wins: 4, draws: 7, defeat: 12, go: 18, goa: 42, player: 0 }; arr_clubs[17] = { name: „Borussia Maulkorb", league: 1, wins: 13, draws: 5, defeat: 5, go: 35, goa: 27, player: 0 }; arr_table = give_club_table(arr_clubs, 1); |
Wir haben das Array arr_clubs angelegt. Hier befinden sich die 18 Vereine (0 bis 17). Doch anstatt wie in einem 2D-Array mit Nummern zu arbeiten, enthält jedes Array weitere Variablen. In diesem Fall:
- league (die Liga, falls es mehrere Ligen geben sollte)
- wins
- draws
- defeat
- go (die Tore)
- goa (die Gegentore)
- player
Im Beispiel wird es drei menschliche Spieler geben, die in der Tabelle mit ihren eigenen Farben angezeigt werden.
Wenn man sich das anschaut, ist der Vorteil von Structs offensichtlich: Statt bspw. nach arr_table[i][2] zu suchen, suchen wir arr_table[i].wins. So lässt sich der Code leichter schreiben und lesen.
Wichtig ist noch folgendes: Das Array arr_clubs wird nicht sortiert. Hier verändern wir lediglich die Werte. Sortiert wird das Array arr_table. Dafür nutzen wir die Funktion give_club_table, welche wiederum auf drei kleine Funktionen zugreift.
Die Hilfsfunktionen
Wie man aus dem Array sehen kann, speichern wir nicht die Anzahl der gespielten Spiele, Punkte und die Tordifferenz. Das berechnen wir, bevor die Tabelle sortiert wird. Da es jeweils nur eine Zeile ist, könnte man das auch in die Hauptfunktion legen, aber ich fand es so eleganter. Hier sind die drei selbsterklärenden Funktionen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Anzahl der Spiele in der laufenden Saison function club_all_games(club) { return club.wins + club.draws + club.defeat; } // Anzahl der Punkte in der laufenden Saison function club_points(club) { return club.wins * 3 + club.draws; } // Anzahl der Punkte in der laufenden Saison function club_goal_difference(club) { return club.go - club.goa; } |
Array sortieren
Nun geht es an die Hauptfunktion. Zunächst der Code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
function give_club_table(arr, league) { var arr_table = []; for (var i=0; i<array_length(arr); i++) { if (arr[i].league == league) { arr_table[i] = arr[i]; arr_table[i].score = club_points(arr_table[i]); arr_table[i].games = club_all_games(arr_table[i]); arr_table[i].diff = club_goal_difference(arr_table[i]); } } // Sortiere Array for (i=0; i<array_length(arr_table); ++i) { for (var j=i+1; j<array_length(arr_table); ++j) { // Alphabetisch if (string_lower(arr_table[i].name) > string_lower(arr_table[j].name)) { var a = arr_table[i]; arr_table[i] = arr_table[j]; arr_table[j] = a; } // Punkte if (arr_table[i].score < arr_table[j].score) { var a = arr_table[i]; arr_table[i] = arr_table[j]; arr_table[j] = a; } // Tordifferenz if (arr_table[i].score == arr_table[j].score) { if (arr_table[i].diff < arr_table[j].diff) { var a = arr_table[i]; arr_table[i] = arr_table[j]; arr_table[j] = a; } } // Siege if (arr_table[i].diff == arr_table[j].diff) { if (arr_table[i].wins < arr_table[j].wins) { var a = arr_table[i]; arr_table[i] = arr_table[j]; arr_table[j] = a; } } // Spiele if (arr_table[i].wins == arr_table[j].wins) { if (arr_table[i].games < arr_table[j].games) { var a = arr_table[i]; arr_table[i] = arr_table[j]; arr_table[j] = a; } } } } return arr_table; } |
Wir übergeben zwei Argumente: Array und Liga. Zuerst deklarieren wir die lokale Variable arr_table. Daraufhin gehen wir das übergebene Array arr in einer Schleife durch. Wenn der Verein der jeweiligen Liga entspricht, übergeben wir die Zeile an das lokale Array. Anschließend berechnen wir Punkte, Spiele und Differenz mit den Hilfsfunktionen.
Sobald das geschafft ist, haben wir das lokale Array vorbereitet und können es nun sortieren. Dafür benötigen wir zwei Schleifen. In der ersten Schleife greifen wir uns einen Verein. Dann gehen wir in der zweiten Schleife alle Vereine durch, die darauf folgen.
Zuerst sortieren wir das Array alphabetisch. In der Praxis ist das vor allem vor dem ersten Spieltag wichtig, da wir keine anderen Werte haben bzw. alles andere auf null steht. Mit string_lower wandeln wir intern die Vereinsnamen in Kleinbuchstaben um und Vergleichen dann ihre „größe“. Bspw. ist „b“ größer „a“, „c“ größer „b“ etc. Wenn aus den beiden Schleifen i größer ist als j, tauschen die Vereine die Plätze. Hierfür wird die Hilfsvariable a benutzt.
Nachdem das getan ist, geht es an die Punkte. Im Kern funktioniert das ebenso, nur verschieben wir hier i nur, wenn es kleiner ist als j.
Ab der Tordifferenz läuft es etwas anders, weil hier erst sichergestellt werden muss, dass die Punktzahl gleich ist. So geht das stufenweise weiter. Ist die Tordifferenz ebenfalls identisch, geht es um die Siege. Man könnte hier natürlich auch nach der Anzahl erzielter Tore sortieren. Und wenn das ebenfalls gleich ist, sortieren wir nach den Spielen, wobei die Mannschaft höher steht, die mehr Spiele gespielt hat.
Noch einmal zum Verständnis: Wenn die Punkte unterschiedlich sind, spielt der Rest keine Rolle mehr.
Das Prinzip lässt sich beliebig erweitern, etwa mit der Anzahl der Karten, Platzverweise, Fans und was auch immer.
Draw-Event
Die sortierte Tabelle soll angezeigt werden. Hier ein Beispiel:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
draw_set_color(#FFFFFF); draw_set_font(fnt_table); draw_set_alpha(1); var startX = 20; var startY = 20; // Header draw_text(startX+20, startY+16, „#"); draw_text(startX+60, startY+16, „Mannschaft"); draw_text(startX+380, startY+16, „Sp."); draw_text(startX+420, startY+16, „S"); draw_text(startX+460, startY+16, „U"); draw_text(startX+500, startY+16, „N"); draw_text(startX+540, startY+16, „Tore"); draw_text(startX+630, startY+16, „Diff."); draw_text(startX+690, startY+16, „Pkt."); for (var i=0; i<array_length(arr_table); i++) { switch arr_table[i].player { case 0: draw_set_color(#FFFFFF); break; case 1: draw_set_color(#E7FE3B); // Spieler 1 break; case 2: draw_set_color(#3BD6FE); // Spieler 2 break; case 3: draw_set_color(#5EFE3B); // Spieler 3 break; } // Array draw_text(startX+20, startY+50+30*i, string(i+1) + „."); draw_text(startX+60, startY+50+30*i, string(arr_table[i].name)); // Name draw_text(startX+380, startY+50+30*i, string(arr_table[i].games)); // Gespielt draw_text(startX+420, startY+50+30*i, string(arr_table[i].wins)); // Siege draw_text(startX+460, startY+50+30*i, string(arr_table[i].draws)); // Unentschieden draw_text(startX+500, startY+50+30*i, string(arr_table[i].defeat)); // Niederlagen draw_text(startX+540, startY+50+30*i, string(arr_table[i].go) + „:" + string(arr_table[i].goa)); // Tore draw_text(startX+630, startY+50+30*i, string(arr_table[i].diff)); // Tordifferenz draw_text(startX+690, startY+50+30*i, string(arr_table[i].score)); // Punkte } |
Mit startx und starty kann man die Tabelle beliebig verschieben. In der Switch unterscheiden wir die Farben für die drei Spieler. Selbstredend ist, dass wir erst die Kopfzeile der Tabelle zeichnen und dann in der Schleife die einzelnen Vereine darstellen.
Mögliche Variationen
In solchen Spielen gibt es häufig die Möglichkeit, dass verschiedene Arten von Tabellen angezeigt werden. So gibt es eine sehr ausführliche Tabelle und vielleicht eine verkürzte Fassung, die lediglich Mannschaft, Spiele, Differenz und Punkte anzeigt.
Dafür kann man entweder die vorhandene Funktion anpassen oder eine neue schreiben. Dann wird auch der Vorteil der Hilfsfunktionen deutlich: Man muss später nicht in jeder Hauptfunktion die Berechnungen ändern, sollte dies erforderlich sein.
Beispiele für weitere Anwendungen gibt es genug. Man kann das auch bei einem Array für die besten Torschützen machen, Vereine mit Titeln, eine Highscore-Liste, die mehr Werte hat als nur die Punktzahl u. v. m.
Viel Spaß dabei!
