We bouwen een klasse GanzenSpel. Dit spel bevat een aantal vakjes, genummerd van 0 t.e.m. $$n-1$$. Elke speler start op vakje met nummer 0, en kan via het werpen van een dobbelsteen naar een ander vakje gaan. Per speler wordt dan ook bijgehouden waar hij/zij zich bevindt.

Het bord bevat een aantal speciale vakjes. Een speciaal vakje wordt gekenmerkt door een geheel getal (dus positief of negatief) $$g$$. Als een speler op een speciaal vakje terechtkomt, wordt zijn/haar positie bijkomend aangepast door bijkomend $$g$$ vakjes vooruit te gaan, indien $$g > 0$$ of door $$-g$$ vakjes achteruit te gaan indien $$g<0$$. Deze regel wordt maar 1 keer toegepast: een speler kan in een beurt maar 1 keer van een speciaal vakje genieten (met andere woorden, als een speler vanuit een speciaal vakje op een ander speciaal vakje terecht komt, dan blijft de speler op dit 2de speciale vakje). Indien een speler door een worp op een onbestaand vakje zou terecht komen, dan wordt deze beurt genegeerd.

Programmeer in de klasse GanzenSpel het volgende:

• een constructor met 3 argumenten, namelijk
  • de waarde $$n$$ (geheel en strikt positief): vakjes worden dus genummerd van 0 t.e.m. $$n-1$$
  • een lijst met de namen van de spelers (een lijst van strings dus)
  • een woordenboek met als sleutels rangnummers van vakjes en als bijhorende waarden $$g$$ (zoals hierboven gedefinieerd). Je mag aannemen dat dit woordenboek geldige sleutels en geldige waarden bevat.
• de methode __str__() levert een string-gedaante op. Om deze te construeren, bouw je een lijst van tuples. Deze lijst noemen we hierna $$\verb!speler_locatie!$$. Elk van de tuples uit $$\verb!speler_locatie!$$ bestaat uit 2 componenten, namelijk de naam van een speler (type str) en zijn/haar locatie (type int). De volgorde in deze lijst is dezelfde als de volgorde die gebruikt in de spelerslijst van de constructoroproep. De string gedaante is dan van de vorm $$\verb![n,speler_locatie]!$$, met $$n$$ het aantal vakjes en $$\verb!speler_locatie!$$ de stringgedaante van de zojuist geconstrueerde lijst.
• de operator "+=" waarbij in het linkerlid een object van de klasse GanzenSpel staat, verwacht in het rechterlid een tuple. Dit tuple bestaat uit 2 componenten, namelijk een string (type str) die de naam van de speler voorstelt, en een getal (type int) dat de waarde van de dobbelworp voorstelt. Je mag aannemen dat die waarden geldig zijn, en dat ook de speler een geldige speler is. De locatie van de speler in kwestie wordt aangepast, zoals hierboven geschreven.
• de methode reset() (zonder argumenten) herstart het spel, door alle spelers terug op het vakje met rangnummer 0 te plaatsen.

Voorbeeld

g = GanzenSpel(20, ['Jan', 'An'],{3:3, 6:5, 15:-5, 19:-19})
print(g) 		#[20,[('Jan', 0), ('An', 0)]]
g += ('Jan', 2) 
print(g)		#[20,[('Jan', 2), ('An', 0)]]
g += ('Jan', 1)
print(g)		#[20,[('Jan', 6), ('An', 0)]]
g += ('An', 6)
print(g)		#[20,[('Jan', 6), ('An', 11)]]
g += ('An', 4)
print(g)		#[20,[('Jan', 6), ('An', 10)]]
g += ('Jan', 6)
g += ('Jan', 6)
print(g)		#[20,[('Jan', 18), ('An', 10)]]
g += ('Jan', 1)
print(g)		#[20,[('Jan', 0), ('An', 10)]]
g.reset()
g += ('An', 5)
g += ('Jan', 3)
print(g)		#[20,[('Jan', 6), ('An', 5)]]