ZZZ bei Crash

Vorwort

Da ich nun schon mehrfach gebeten wurde das ZZZ-Verhalten bei Crash zu erklären, nehme ich mir mal die Freiheit an dieser Stelle den ZZZ-Bug zu erläutern. Ich hoffe ich kriege das dabei so hin, dass es auch für Nicht-Informatiker verständlich ist! Den Original-Code von Didi gibt es zum selbst Nachvollziehen natürlich weiterhin unten im Anschluss zusammen mit der Diskussion und den Korrekturvorschlägen... --Ultimate 17:09, 11. Jul. 2014 (CEST)

Erläuterung des ZZZ-Bugs

Einleitung

Um die Erklärung verständlicher zu machen, werde ich sie an einem Beispiel machen. Dazu habe ich ein paar Bilder aufbereitet und werde das Vorgehen Schritt für Schritt erläutern. Ich werde dabei zwei Szenarien durchspielen, die beide gleich anfangen und dann aber unterschiedlich fortgeführt werden...

Der 1. Crash

Schritt 0 - Beispielkarte

Ich nehme für meine Erklärung einfach mal "Die Erste" Karte. Aus Platzgründen habe ich sie aber mal ein bisschen zurechtgestutzt... Für das Beispiel nehme ich mal ZZZ=4, da sich das Verhalten besser bei etwas größerem ZZZ erläutern lässt.

Schritt 1 - Gegen die Wand fahren

Möge das Rennen beginnen... Wir fahren nun einfach mal mit Vollgas gegen die Wand:

Schritt 2 - Der Algorithmus zählt rückwärts

In dem Moment indem keine Züge mehr möglich sind und klar ist, dass man crasht, wird die bisherige Route zurückverfolgt um den Zurücksetzpunkt zu finden. Dazu beginnt der Zähler (im Code $i) beim ZZZ (im Code $aussetzen), also in unserem Fall bei 4. Der Zähler zählt bis 0 rückwärst und schaut dabei für jeden Zug aus der Datenbank, ob das ein Crash war.

Hä was wie? - Ja, Crashs werden genauso wie Züge in der Datenbank abgelegt und unterscheiden sich nur durch einen zusätzlichen Eintrag. Wenn Didi also die Liste der Züge aus der Datenbank holt, sind dort auch die Crashs mittenmang. Aktuell sind wir aber noch nicht gecrasht, daher ist noch alles gut.

Schritt 3 - Crashpunkt gefunden

Wenn wir bis auf 0 runtergezählt haben, nehmen wir von dem soeben betrachteten Zug das Zielfeld als den Punkt, wohin wir zurück gesetzt werden.

Bis hierhin sollte alles klar sein, oder?

Der 2. Crash - Szenario 1 - Crash nach weniger als ZZZ Zügen

kommt noch --Ultimate 17:09, 11. Jul. 2014 (CEST)

Der 2. Crash - Szenario 2 - Crash nach genau als ZZZ Zügen

kommt noch --Ultimate 17:09, 11. Jul. 2014 (CEST)

Bisschen OpenSource

Original-Code von Didi

Da der (zugegebenermaßen evtl. etwas kompliziert programmierte) Algorithmus zur Bestimmung der Zurücksetzposition offenbar einen Bug hat, gibt's hier mal meinen "original"-Source code und danach eine korrektur bzw. Anmerkungen von Quabla.

Ich stell's hier jetzt mal zur Diskussion und möge sich die Community an diesem Stück Code beweisen :-D

               if ($possibles==0)
               {
                       $query="select M_ID,x_pos,y_pos,crash from $movestable [..]";
                       $res=do_query($query);
                       $maxmoves=mysql_num_rows($res);
                       if ($aussetzen>=$maxmoves)
                       {
                               $aussetzen=$maxmoves-1;
                       }
                       $walker=0;
                       $i=$aussetzen;
                       while ($i>=0)
                       {
                               $row=mysql_fetch_array($res);
                               if ($row[crash]==1)
                               {
                                       $sum=$aussetzen+$walker+$i;
                                       if (($sum)>=$maxmoves)
                                               $i=$maxmoves-$walker-1;
                                       else
                                               $i=$i+$aussetzen;
                               }
                               $i--;
                               $walker++;
                       }
                       $sysmsg="-:KIch werde $aussetzen Züge zurückgesetztK:-";
                       echo "AUAAAA! Es quietscht und du knatterst ins Gras... Dafür wirst Du um $aussetzen Züge zurückgesetzt und startest wieder von 0.";
               }

Kommentare & Korrekturvorschläge

von quabla

Hier die Kommentierung und Vorschläge von Quabla

 if ($possibles==0)
 {
         $query="select M_ID,x_pos,y_pos,crash from $movestable WHERE [..]";
         $res=do_query($query);
         $maxmoves=mysql_num_rows($res);
         if ($aussetzen>=$maxmoves)
         {
                 $aussetzen=$maxmoves-1;
         }

$walker kann wech

         #$walker=0;
         $i=$aussetzen;
         while ($i>=0)
         {
                 $row=mysql_fetch_array($res);
                 if ($row[crash]==1)
                 {

und den ganzen Kladderadatsch in diesem if-Zweig kann man dann ersetzen durch

                        $i = 0;
                        # $sum=$aussetzen+$walker+$i;
                        # if (($sum)>=$maxmoves)
                        #         $i=$maxmoves-$walker-1;
                        # else
                        #         $i=$i+$aussetzen;
                 }
                 $i--;
                 #$walker++;
         }

von Jody

Jody fügt hinzu:
Damit die richtige Anzahl an Zügen ausgegeben wird, müsste man quabla's Vorschlag noch wie folgt ändern:

                               # ...
                               if ($row[crash]==1)
                               {
                                       $aussetzen -= $i;
                                       $i = 0;
                               }
                               # ...

von zucker

Zucker: $query="select M_ID,x_pos,y_pos,crash from $movestable [..]"; Liese sich das ganze nicht über EIN sql ziehen und dann einfach einen normalen Zug machen ?

karopapier_singleplayer.zip Da drinn ist auch irgendwo sowas versteckt

von kili

Kili: vorhin schon im Forum verlinkt, aber sicherheitshalber noch mal hier: Bugfix (erzeugte Crashzuege mitzaehlen) und Aufraeumarbeiten (das $walker-Zeugs wird nicht benoetigt):

               #...
               $maxmoves=mysql_num_rows($res);
               $i=$aussetzen;
               while ($maxmoves>0 && $i>=0)
               {
                       $row=mysql_fetch_array($res);
                       if ($row[crash]==1)
                       {
                               $i=$i+$aussetzen+1;
                       }
                       $i--;
                       $maxmoves--;
               }
               #...