| neue Message hinzufügen |

Jody 2011-10-16 16:45:07
Eigentlich kann ich die Argumentation zur sofortigen Einführung sehr gut nachvollziehen: Es ist ein sehr(!) später Bugfix und kein neues Feature, und daher sehe ich keinen zwingenden Grund, ältere Spiele mit dem Bug weiterlaufen zu lassen.

ultimate 2011-10-07 11:01:08
Ich würde die Diskussion gerne wieder aufleben lassen (wegen diesem Topic hier)

Wie ich dort bereits geschrieben habe, denke ich über eine 2. CCC nach und da wäre es super, wenn Didi vorher die "if(GID>X) neuerZZZ; else alterZZZ;"-Variante umsetzen könnte

ultimate 2011-02-02 20:53:36

Dann aber kili 2011-02-02 13:58:41
noch einen Kommentar /* Nie wieder anfassen! So bald wie moeglich entsorgen */ ueber den alten Code ;-)

Aenderungen quabla 2011-02-02 13:32:00
if (GID >= GID_von_dem_ersten_Spiel_das_nach_der_Aenderung_gestartet_wurde) {
    neuer_ZZZ_Code();
} else {
    alter_ZZZ_Code();
}  

@ulli kili 2011-02-01 23:01:10
1. warum Didi es so programmiert hat

Warum nicht? (Das ganze Zeugs ist vermutlich in die jetzige Situation hineingewachsen; frueher gab's keinen variablen ZZZ etc.). Didi hat da wahrscheinlich mal was nachgebessert, und nun haben wir den Salat (naemlich die vergurkten Ruecksetzer). Und wenn Didi das jetzt repariert (Patches gibt's wie gesagt genug), kommen irgendwelche Nasen an und beschweren sich, dass sich die Crash-Regeln geaendert haben. Tolle Wurst.

2. warum es falsch ist

Weil beim Crash ein kuenstlicher Zug in die Datenbank eingetragen wird, der dann aber bei spaeteren Crashes nicht korrekt beruecksichtigt wird.

Juhuu ulli 2011-02-01 22:29:21
OK, nachdem ich jetzt eine halbe Stunde über Didis PHP Quellen gebrütet habe (das ganze erschließt sich nur wenn man davon ausgeht bzw. weiss, dass für einen Zug das *Ziel* in xpos und ypos steht und nicht die Quelle (was etwas kurios ist)) habe ich es  ... verstanden!!! ... Pic:-

und dazu noch
1. warum Didi es so programmiert hat und
2. warum es falsch ist

Mal sehen, vielleicht programmiere ist diesen Algorithmus bei den Bots ein, dann sind sie in Crash-Spielen unschlagbar, weil sie dann die einzigen sind, die dieses Verhalten gezielt ausnutzen können. (hehe)

kili 2011-02-01 21:38:20
Nach meinem novecrash.c Prograemmchen passt das schon. Es ist aber wiirklich total verwirrend, und es gibt ja genug Verbesserungsvorschlaege (inklusive fertiger Patches),. von denen ich mir wuenschen wuerde, dass Didi sie einfach mal einbaut. (Und wenn's die CrazyZZZ-Meisterschaft vergeigt: mir doch egal)..

aristarch 2011-02-01 20:19:40
Lies mal das von Jody weiter unten (2010-12-12 15:59:08) mit dem Wald, den Bäume usw.
Das dürfte in die richtige Richtung gehen.

aristarch 2011-02-01 20:16:50
Du bist nicht 4 Züge weiter hinten, sondern einen weiter vorne (auf der alten Linie) als dein Crashpunkt.
Das klingt verwirrend, aber ich kann es nicht besser beschreiben.
Oder vielleicht so: du müsstest eigentlich genau auf deinem Crashpunkt landen, aber da wird irgendein Zähler um 1 hochgesetzt, weshalb du einen Zug weiter in die alte Richtung rückst.

Nochmal anders: du machst sieben Züge.
1234567
du crashst bei 7. ZZZ=2 -> Zurück auf fünf. Du machst 2 weitere Züge und crashst wieder. Du stehst jetzt auf 6.

Das ist vermutlich nicht so gewollt, aber so ist es programmiert.

Kann mir jemand das mit den Crashs erklären? ulli 2011-02-01 19:35:28
Hallo an alle, die versuchen die Crash regeln zu verstehen,

nach der ganzen Diskussion dachte ich, ich hätte die Regeln beim Crash, insbesondere bei Doppelcrashs ansatzweise verstanden, aber dann habe ich mal selber rumprobiert (hätte ich das mal nicht getan...). Vielleicht kann mir mal jemand mal erklären warum ich in diesem Testspiel nach dem zweiten Crash dahin gesetzt wurde wo ich hingesetzt wurde. Da ich vor dem zweiten Crash 2 Züge gemacht habe (mit ZZZ=2) hätte die Spezialregel für Doppelcrashs gar nicht angewendet werden dürfen und ich hätte genau 2 Züge zurück gesetzt werden müssen. Wurde ich aber nicht , sondern so ca. 4 Züge zurück.
Versteht das jemand?

Gruß
Ulli

Erklärung & Selbstkorrektur ultimate 2010-12-13 14:50:23
Zuerst einmal die Erklärung:

- Die SQL-Abfrage liefert mir nur die Züge seit dem letzten Crash zurück
- Es wird unterschieden:
a) mehr als zzz Züge seit diesem Crash --> zzz Züge zurück
b) weniger als zzz Züge seit diesem Crash --> bis zum Crash zurück
- Es werden dann die entsprechenden Züge aus der Zugliste gelöscht, bis ich beim Zielpunkt angekommen bin
- Der Crash-Zug wird zu diesem Punkt erzeugt...

Dann noch eine kleine Korrektur:

Die "elegante" Full-SQL-Lösung wird wahrscheinlich nicht funktionieren, weil ich (vermutlich irrtümlicher Weise) davon ausgegangen bin, dass M_ID sowas wie ein Rundenzähler ist... Werde das wohl nochmal anpassen

Bitte beschreiben kili 2010-12-12 23:03:35
was denn Dein Code tun soll ultimte.  Oder eine lesbare eingerueckte Version irgendwo auf gist.github..com oder pastebin.com  oder so hinterlegen.

Um noch mal den (vereinfachten) aktuellen Code von Didi zu erklaeren:

- laufer rueckwaerts ZZZ + 1 Zyege durch die Zugliste
- wenn dabei ein Crashzug vorkommt, verlanegere die Anzahl der zu durchlaufenden Zuege um  ZZZ + 1 (das +1 wird wegen der erzeugten Crash-Zuege benoetigt).
- wenn man am Startzug angekommen ist, braucht (und darf)  wird die Suche abgebrochen
- fuer die so ermittelte ZZZ-Position wird ein kuenstlicher Zug erzeugt, der den Spieler auf die ZZZ-Position setzt.


Lösungsvorschlag ultimate 2010-12-12 22:30:09
Gute Analyse Jody Ich hatte mir den Code auch schon angeschaut und war nur noch nicht zum Posten einer Antwort gekommen.

Hier mal mein Code-Entwurf für den von mir auch stark favorisierten Vorschlag von quabla:
(Ich hoffe, dass ist syntaktisch Korrekt, ich bin kein php-Profi )

if ($possibles==0)
{
$query="select M_ID,x_pos,y_pos,crash from $movestable WHERE G_ID=$GID AND U_ID=$uid AND date >= (select max(date) from $movestable WHERE G_ID=$GID AND U_ID=$uid AND crash = 1) ORDER BY date DESC";
$res=do_query($query);
$movesSinceLastCrash=mysql_num_rows($res)-1;
if($movesSinceLastCrash > $aussetzen)
{
$i = $aussetzen;
}
else
{
$i = $movesSinceLastCrash;
}

while($i>=0)
{
$row=mysql_fetch_array($res);
$i--;
}

$sysmsg="Ich werde $aussetzen Züge zurückgesetzt";
$query="insert into $movestable (G_ID,U_ID,date,x_pos,y_pos,x_vec,y_vec,crash,movemessage) VALUES($GID,$uid,now(),$row[x_pos],$row[y_pos],0,0,1,"$sysmsg")";
do_query($query);
logfile($GID,"$username CRASHT!!! ZZZ:$zzz");

echo "AUAAAA! Es quietscht und du knatterst ins Gras... Dafür wirst Du um $aussetzen Züge zurückgesetzt und startest wieder von 0.<BR><BR>";

...
}

Man kann das ganze natürlich auch in eine große SQL-Anweisung ballern... Das ist wie ich finde wesentlich eleganter und sähe dann so aus:

if ($possibles==0)
{
$sysmsg="Ich werde $aussetzen Züge zurückgesetzt";
$query="insert into $movestable (G_ID,U_ID,date,x_pos,y_pos,x_vec,y_vec,crash,movemessage) VALUES (select $GID,$uid,now(),x_pos,y_pos,0,0,1,"$sysmsg" from $movestable where M_ID = (select max(target) from ((select max(M_ID) as target from movestable where G_ID = $GID AND U_ID = $uid AND crash = 1) union (select max(M_ID)-$aussetzen as target from movestable where G_ID = $GID AND U_ID = $uid)) as target))";

do_query($query);
logfile($GID,"$username CRASHT!!! ZZZ:$zzz");

echo "AUAAAA! Es quietscht und du knatterst ins Gras... Dafür wirst Du um $aussetzen Züge zurückgesetzt und startest wieder von 0.<BR><BR>";

...
}

Bei diese Variante übernimmt dann die Datenbank die Arbeit, was in der Regel deutlich schneller gehen und den Server entlasten sollte...

Grüße ultimate

Oder optional kili 2010-12-12 21:52:40
quabla: Jody meinte vorhin, dass man den quabla-Crashmode (ich nennen den jetzt einfach mal nach Dir) auch optional machen koennte, also bei Spielerstellung. Das waere dann aber wohl eher was fuer den Karolender 2011, und ich weisi auch nicht, ob das wirklich eine tiolle Idee waere (*noch* ein Parameter, an dem man schrauben kann).

Was den Bug selbst angeht: ja, da wuerde ich mir wuenschen, dass Didi dem Bugfix mal einen oder zwei weitere Tests verpasst und das dann einfach reinwirft. Meinetwegen auch nach Vorankuendigung.

Und ich wuerde da ehrlichgesagt auch keine Sonderlocke fuer bereits laufende Spiele einbauen, sondern einfach auf die neue Version umschalten. Wer das (fehlerhafte) aktuelle Verhalten beim ZZZ in seine Spiele eingeplant hat, hat dann zwar Pech gehabt, aber davon sind doch alle gleichermassen betroffen. Eine Sonderlocke wie `Spiel vor dem Stichtag erstellt => alter Code, ansonsten => neuer Code` fuehrt doch nur wieder dazu, dass der Code unverstaendlich und fehleranfaelliger wird.

Ist halt was grundsaetzlich verschiedenes. quabla 2010-12-12 21:06:52
Welches Verhalten man nach einem 2. crash bei weniger als ZZZ Zuegen nach dem 1. Crash haben will, kann man ja in 2 Varianten fahren (entweder immer weiter zurueck oder auf das Feld des 1. der beiden). Huet bin ich auch nicht mehr der Meinung, dass die 2. Variante das ist was man will - hab mich halt auch an das Verhalten, wie es ist, gewoehnt. Bloss den Bug sollte man beseitigen.

Jody... kili 2010-12-12 16:22:47
was meinst Du mit `so ist es nicht so leicht, mit hohen ZZZ-Werten durch wiederholte Crashes zum Ziel zurückzuspringen' im letzten Satz?

Man kann doch allenfalls zum *Start* zurueckspringen, oder denkst Du jetzt gerade an ringfoermige Kurse, wo man ueber den Start ins Ziel fahren kann?

Davon mal abgesehen finde ich es auch einfach logischer, wenn mich $n Crashes um insgesasmt $n * $zzz Zuege zuruecksetzen.

Und da es sowieso wohl nur fuer Spiele mit TC relevant ist, sollte das auch kein Problem sein, immerhin haben alle die gleichen Chancen, sich geschickt zum Start zurueckzucrashen.

Der Wald, die Bäume und die selektive Wahrnehmung Jody 2010-12-12 15:59:08
Ich weiß nicht, warum das in all den Jahren, in denen das in der Wiki steht, niemandem bewusst geworden ist, aber der Grund für das Problem ist doch recht offensichtlich:
Didi hat einen Zug übersehen.

Nehmen wir ZZZ=8 an. Nach Zug 10 crasht Spieler1. Dann sind in der Datenbank insgesamt 11 Züge eingetragen: die ersten 10 Züge bis zum Crash und das Zurücksetzen selber, das auch ein Zug ist. Crasht Spieler1 in Zug 15 noch ein weiteres mal, wird er vorerst ZZZ=8 Züge zurückgesetzt. Dabei geht der Algorithmus rückwärts die entsprechenden Züge durch, erkennt als elften Zug einen Crash, und addiert dann auf den auf den Gesamtzugzähler $sum (auf recht umständliche Art) weitere 8 Züge hinzu, die der Algorithmus auf weitere Crashes prüft. Und dabei wird eben dieser eine oben genannte Zug des Zurücksetzens vergessen.

$sum=$aussetzen+$walker+$i;

$i sind die bereits zurückgesetzten Züge, $walker die noch zurückzusetzenden Züge und $aussetzen ist der ZZZ.  Demnach ist $walker+$i = ZZZ*(Anzahl_der_registrierten_Crashes +1). Also einfach ans Ende der Zeile +1 setzen und alles ist so, wie es sein sollte.


Übrigens finde ich quablas Vorschlag, das Zurücksetzen am letzten Zurücksetzpunkt zu beenden, recht verlockend. so ist es nicht so leicht, mit hohen ZZZ-Werten durch wiederholte Crashes zum Ziel zurückzuspringen.

Und hier noch die (hoffentlich reparierte) PHP-Fassung kili 2010-12-12 15:25:45
http://pastebin.com/7hZj8BdD

Ich habe das mitzaehlen der generierten Crashzuege eingebaut und ausserdem noch die etwas komplizierten Versuche, nicht ueber den Startzug hinaus zurueckzusetzen, vereinfacht. Das spart gleich jede Menge Code ein ;-)

Ungetestet, aber zumindest in der C-Variante, die ich zum Testen gebastelt habe, und mit einigen relativ uebersichtichen Testsituationen kommt das gleiche raus wie bei meinem Algorithmus.

Und noch einer kili 2010-12-12 14:34:45
http://pastebin.com/uu9KKweu

Jetzt doch wieder mit extra Crash-Zuegen, weil Didi das in seinem Code auch so macht.

Ahsserdem kann man jetzt zwischen meinem Algorithmus und dem von Didi hin- und herschalten (erstes Argument entweder `k` oder `d`)  und angeben, bei welchen Zunummern Crashes simuliert werden (das ist besser als die Crashes zufaellig passieren zu lassen). Ob ich Didis Algorithmus wirklich korrekt simuliere, weiss ich nicht, ich hoffe es aber (und ein Test mit einem richtigen Spiel scheint das auch so einigermassen zu belegen).

Um z.B. direkt nach dem Startzug und dann drei Zuege spaeter noch einmal zu crashen, dasn ganze mit ZZZ=2 und Didis Algorithmus, ruft man das Programm z.B. mit

./movecrash d 2 1 3

Im Spiel mit der GID 57848 kann man uebrigens sehen, dass der aktuelle Algorithmus tatsaechlich ernsthafte Probleme mit ueberlappenden Crashes hat. Z.B. wurde ich da nach dem zweiten Crash (nach Zug 11) faelschlicherweise auf die gleiche Position (von Zug 4) gesetzt, wie bei dem Crash *drei* Zuege vorher, was natuerlich bei ZZZ=4 verkehrt ist.

Etwas aehnliches passiert dann zwei Crashs spaeter. Der Didizuruecksetzer waehlt hier die Position des 12. Zuges, der Kilizuruecksetzer die des dritten Zuges (das ist dem Spiel-Logfile schlecht zu entnehmen, weil der 3. und der 12. Zug die gleichen Koordinaten haben, aber mit meinem Didizuruecksetzsomilator kommt eben dieser Unterschied raus).

Wenn ich Didis Zuruecksetzer richtig verstanden habe, laeuft er rueckwaerts ZZZ + 1 Eintraege durch die Zugliste und erzeugt dann einen synthetischen Crashzug (der mit dem Bordfunkeintrag `Ich werde $zzz Zuege zurueckgesetzt`) mit der Position des aeltesten der gefundenen Zuege. Rennt er zwischendurch ueber so einen synthetischen Crashzug (passiert bei ueberlappenden Zuegen), dann laeuft er zusaeztliche ZZZ Eintraege in der Zugliste zurueck. Klingt eigentlich logisch, geht nur leider offensichtlich in die Hose.

Das *koennte* daran liegen, dass Didi vergessen hat, den synthetischen Crash-Zug (mit dem `Ich werde ... zurueckgesetzt') mit zu zaehlen. Wenn ich in meinem Simulator in didi_crash() die entsprechende Zeile (i = i + zzz) in (i = i + zzz + 1) aendere, dann kommen jedenfalls fuer die Crashes von GID 57848 die gleichen Werte raus, wie bei meinem Algorithmus.

Ich weiss natuerlich nicht, ob es nicht noch weitere Grenzfaelle gibt, insbseondere habe ich nicht die Situationen getestet, in denen man bis zum Start zurueckgesetzt wird.

besser kili 2010-12-11 22:11:49
http://pastebin.com/qNr72KDE

Keine `synthetischen'  Zuege mehr.

Ganz ehrlich... Didi 2010-12-11 20:33:05
... ich hab mich nie mehr wieder damit beschäftigt - und auch im Moment keine AHnung, was es für Probleme, Lösungsvorschläge und Diskrepanzen gibt ;-)
(Nene, nicht nochmal erklären, ich les das dann nach...)

Fakt: Ich werde jetzt, nachdem es 5 Jahre so war, nächste Woche nicht mit Gewalt was ändern. Fahrt ihr Eure  Crash-Challenges nur mal weiter und wundert Euch - oder trefft weise und kluge voraussagen mit Hilfe von diesem Fetzen Code:

https://gist.github.com/737587

Vorschläge werden gerne angenommen (wie demletzt beim Berechnen der möglichen Züge)

Ich werde mich aber intensiv erst damit auseinandersetzen, wenn ich bei Karo2.0 so weit bin, dass dies dran kommt.

Und wie wir das dann Regeln, sehen wir.
Vermutlich wird es eh ein paar Dinge/Optionen in Karo2.0 geben, die es unmöglich machen, bestimmte Spiele in Karo1.0 zu ziehen. Und das könnte man da dann auch so handhaben.
Mal ganz ehrlich - dem Otto-Normal-Crasher isses ja meist egal, wenn er bei nem Crash in 1.0 woanders landen würde als in Karo2.0 - es wird nur bei High-End-Taktisch-Multi-Crashing interessant. Und da könnte ich mir vorstellen, dass man eben für solche Turniere FESTSCHREIBT, dass in Karo2.0 gezogen werden muss.

Und irgendwann geht ziehen im Karo1.0 vielleicht auch gar nicht mehr? Armer kili, muss er das OS wechseln ;-)

Gruß

:)idi

ultimate 2010-12-11 17:21:36
@quabla:
Nur so zum verständis...
Was meinst du mit Position der 1. Crashes? Ich nehme nicht an, den ersten Crash im ganzen Rennen, sondern den ersten Crash in der Serie der letzten Crashes. Das ist also der letzte Crash, vor dem mehr als ZZZ Züge seit dem vorangegangenen Crash gemacht wurden... (Ich hoffe ich habe mich verständlich ausgedrückt...)

Crashalgorithmus (und -Simulation) kili 2010-12-11 16:30:11
Hier mal ein Experiment in C:

http://pastebin.com/4ezRWsm0

Sollte sich auch in einer Datenbank bzw. mit SQL zusammen mit PHP machen lassen (ein entsprechender Kommentar ist in do_crash()).

Das Ding wuerfelt Zuege per Zufallsgenerator aus, und auch Crashes passieren per Zufi, eine richtige Map oder so gibt's nicht.

Das Prinzip ist einfach: beim Zuruecksetzen wird jeder gespeicherte Zug, ueber den zurueckgesetzt wird, als bereits `becrasht' gekennzeichnet (ein besserer Ausdruck faellt mir gerade nicht ein). Ebenfalls werden beim Zuruecksetzen becrashte Zuege uebersprungen, d.h. beim Zuruecksetzen wird niemals der gleiche Zug zum Zuruecksetzen beruecksichtigt.

Fuer einen Aufruf mit

Cmovecrash 6 50 8

gibt's z.B. folgende Ausgabe (besser formatiert auch unter http://pastebin.com/7pSHur5A):

Running 50 moves. ZZZ = 6, crash probability 1/8

    0: p(  10|  10) v(   0|   0)
    1: p(  10|  11) v(   0|   1)
    2: p(  10|  12) v(   0|   1)
    3: p(  11|  13) v(   1|   1)
    4: p(  11|  14) v(   0|   1)
    5: p(  10|  15) v(  -1|   1)
    6: p(   8|  15) v(  -2|   0)
    7: p(   5|  16) v(  -3|   1)
    8: p(   3|  17) v(  -2|   1)
    9: p(   0|  19) v(  -3|   2)
   10: p(  -4|  22) v(  -4|   3)
   11: p(  -8|  24) v(  -4|   2)
   12: p( -13|  27) v(  -5|   3)
   13: p( -18|  30) v(  -5|   3)
   14: p( -23|  33) v(  -5|   3)
   15: p( -29|  36) v(  -6|   3)
Crash after move 15, back to position of move 9
   16: p(   0|  19) v(   0|   0)
   17: p(   0|  20) v(   0|   1)
   18: p(  -1|  22) v(  -1|   2)
   19: p(  -1|  24) v(   0|   2)
   20: p(  -1|  26) v(   0|   2)
   21: p(  -1|  29) v(   0|   3)
Crash after move 21, back to position of move 8
   22: p(   3|  17) v(   0|   0)
   23: p(   4|  16) v(   1|  -1)
   24: p(   5|  14) v(   1|  -2)
   25: p(   5|  12) v(   0|  -2)
   26: p(   6|   9) v(   1|  -3)
   27: p(   7|   6) v(   1|  -3)
Crash after move 27, back to position of move 7
   28: p(   5|  16) v(   0|   0)
   29: p(   4|  17) v(  -1|   1)
   30: p(   2|  17) v(  -2|   0)
   31: p(  -1|  18) v(  -3|   1)
   32: p(  -5|  19) v(  -4|   1)
Crash after move 32, back to position of move 5
   33: p(  10|  15) v(   0|   0)
   34: p(  11|  14) v(   1|  -1)
   35: p(  13|  14) v(   2|   0)
   36: p(  16|  14) v(   3|   0)
   37: p(  19|  14) v(   3|   0)
   38: p(  23|  13) v(   4|  -1)
   39: p(  26|  12) v(   3|  -1)
   40: p(  28|  12) v(   2|   0)
   41: p(  31|  13) v(   3|   1)
   42: p(  35|  13) v(   4|   0)
   43: p(  39|  13) v(   4|   0)
Crash after move 43, back to position of move 37
   44: p(  19|  14) v(   0|   0)
   45: p(  20|  13) v(   1|  -1)
Crash after move 45, back to position of move 4
   46: p(  11|  14) v(   0|   0)
   47: p(  12|  15) v(   1|   1)
Crash after move 47, back to position of move 0
   48: p(  10|  10) v(   0|   0)
   49: p(  11|  11) v(   1|   1)
   50: p(  12|  12) v(   1|   1)
   51: p(  14|  12) v(   2|   0)
   52: p(  15|  11) v(   1|  -1)
   53: p(  15|  10) v(   0|  -1)
   54: p(  16|   9) v(   1|  -1)
   55: p(  18|   7) v(   2|  -2)
   56: p(  19|   6) v(   1|  -1)
   57: p(  20|   5) v(   1|  -1)
Crash after move 57, back to position of move 51
   58: p(  14|  12) v(   0|   0)


Summary (moves touched during crash resets are marekd with an `*'):

    0: p(  10|  10) v(   0|   0)
    1: p(  10|  11) v(   0|   1) *
    2: p(  10|  12) v(   0|   1) *
    3: p(  11|  13) v(   1|   1) *
    4: p(  11|  14) v(   0|   1) *
    5: p(  10|  15) v(  -1|   1) *
    6: p(   8|  15) v(  -2|   0) *
    7: p(   5|  16) v(  -3|   1) *
    8: p(   3|  17) v(  -2|   1) *
    9: p(   0|  19) v(  -3|   2) *
   10: p(  -4|  22) v(  -4|   3) *
   11: p(  -8|  24) v(  -4|   2) *
   12: p( -13|  27) v(  -5|   3) *
   13: p( -18|  30) v(  -5|   3) *
   14: p( -23|  33) v(  -5|   3) *
   15: p( -29|  36) v(  -6|   3) *
Crash!
   16: p(   0|  19) v(   0|   0) *
   17: p(   0|  20) v(   0|   1) *
   18: p(  -1|  22) v(  -1|   2) *
   19: p(  -1|  24) v(   0|   2) *
   20: p(  -1|  26) v(   0|   2) *
   21: p(  -1|  29) v(   0|   3) *
Crash!
   22: p(   3|  17) v(   0|   0) *
   23: p(   4|  16) v(   1|  -1) *
   24: p(   5|  14) v(   1|  -2) *
   25: p(   5|  12) v(   0|  -2) *
   26: p(   6|   9) v(   1|  -3) *
   27: p(   7|   6) v(   1|  -3) *
Crash!
   28: p(   5|  16) v(   0|   0) *
   29: p(   4|  17) v(  -1|   1) *
   30: p(   2|  17) v(  -2|   0) *
   31: p(  -1|  18) v(  -3|   1) *
   32: p(  -5|  19) v(  -4|   1) *
Crash!
   33: p(  10|  15) v(   0|   0) *
   34: p(  11|  14) v(   1|  -1) *
   35: p(  13|  14) v(   2|   0) *
   36: p(  16|  14) v(   3|   0) *
   37: p(  19|  14) v(   3|   0) *
   38: p(  23|  13) v(   4|  -1) *
   39: p(  26|  12) v(   3|  -1) *
   40: p(  28|  12) v(   2|   0) *
   41: p(  31|  13) v(   3|   1) *
   42: p(  35|  13) v(   4|   0) *
   43: p(  39|  13) v(   4|   0) *
Crash!
   44: p(  19|  14) v(   0|   0) *
   45: p(  20|  13) v(   1|  -1) *
Crash!
   46: p(  11|  14) v(   0|   0) *
   47: p(  12|  15) v(   1|   1) *
Crash!
   48: p(  10|  10) v(   0|   0) *
   49: p(  11|  11) v(   1|   1)
   50: p(  12|  12) v(   1|   1)
   51: p(  14|  12) v(   2|   0)
   52: p(  15|  11) v(   1|  -1) *
   53: p(  15|  10) v(   0|  -1) *
   54: p(  16|   9) v(   1|  -1) *
   55: p(  18|   7) v(   2|  -2) *
   56: p(  19|   6) v(   1|  -1) *
   57: p(  20|   5) v(   1|  -1) *
Crash!
   58: p(  14|  12) v(   0|   0) *

Grandios ulli 2010-12-11 15:58:02
Ich wäre auch sofort dafür quablas grandiosen Beitrag umzusetzen und zwar für alle neuen Spiele. Dann kann sich niemand bei laufenden Spielen beschweren. Die jetzige regel ist kaum nachzuvollziehen.

| neue Message hinzufügen |
| Anfang | Vorherige | Nächste |

Brought to you by Didi

Letzter Satz im Chat:
quabla (0:18): du redest wie kabotte