Roulette-Strategie-Simulator

[lbccaleb]

Also siehe mein Edit:

Wenn das nicht zutrifft:

while ((aManque - aPasse) < 5) and ((aPasse - aManque) < 5) do


also aManque - aPasse und aPasse - aManque größer als 5 sind, wird i nicht mehr abgearbeitet und die Funktion ruft sich immer wieder selbst auf.

[Der Siedler]

Wenn die Bedingung nicht eintritt, ruft die Prozedur "Stueckgewinn" immer wieder "Wurf" auf, nicht sich selbst. Und das sollte doch kein Problem sein, auch, wenn das von mir aus 100.000 Mal passieren muss, bis die Bedingung eintritt. Mein Problem ist, dass ich genau die Zahl haben will, nachdem der gesuchte Fall endlich eintritt, um einen Überblick zu bekommen. Wenn das Programm aber bei den wirklich großen Zahlen abbricht, nützt mir das de facto gar nichts. Dass es viele Fälle gibt, wo das recht zeitnah eintritt, ist mir klar, aber ich will eben auch die Fälle erfassen, wo es eine halbe Ewigkeit oder länger dauert.

@DeddyH: Danke! Werde ich mir mal ansehen und ausprobieren.

[baumina]

Noch 2 kleine Tipps:

1. Schreibe im btStartClick vor Stueckgewinn ein Screen.Cursor := crHourGlass und nach Stueckgewinn ein Screen.Cursor := crDefault. Dadurch hast du eine Sanduhr während er läuft.

2. Schreibe am Ende innerhalb aller while-Schleifen ein Application.ProcessMessages. Dadurch legst du nicht alles lahm und der "weisse Bildschirm" ist damit auch nimmer.

[Volker Z.]

Hallo,

vielleicht verstehe ich da etwas falsch. Wenn Du Deine Anwendung startest, dann zählt Dir zunächst

Delphi-Quellcode:

  while ((aManque - aPasse) < 5) and ((aPasse - aManque) < 5) do
    Wurf('Keine Wette');

aManque und aPasse solange hoch, bis die Differenz kleiner als fünf ist (aGewinn und aMinus verändern sich nicht). Dies wird u. U. auch irgendwann (bevor es zu einem Rangeoverflow kommt) erreicht.
Danach rufst Du Passespiel (oder Manquespiel egal) auf. Du startest mit

Delphi-Quellcode:

aGewinn := 0;
aGewinnziel := 1;
Wurf ('Passe'); // (für Random() in {1..18}) => aGewinn = -1 (die Bedingung der while Schleife ist weiterhin erfüllt) also
Wurf ('Passe'); // (für Random() in {19..36}) => aGewinn = 0 (die Bedingung der while Schleife ist weiterhin erfüllt) also
Wurf ('Passe'); // (für Random() in {1..18}) => aGewinn = -1 usw. und Deine Anwendung läuft in ggf. in eine schöne Endlosschleife

Natürlich kann es nun sein, dass aGewinn - im ungünstigen Fall - immer weiter Richtung minus Unendlich wandert, aber auch ein kleiner Eins reicht bereits aus, um weiterhin die Schleifenbedingung zu erfüllen (Endlosschleife). Deshalb erweitere ich die Forderung, nicht nur eine untere Schranke für den Verlust (mein Hinweis auf aMinus) einzuführen, sondern auch eine maximale Obergrenze für die Anzahl für die Versuche der Passe bzw. Manque Spiele zu definieren. Ersteres zum Schutz des Spielers (bevor noch Haus und Hof draufgeht); zum zweiten: Die Angestellten der Spielbank möchten auch mal Feierabend haben.

[EDIT]
BTW: Ich wäre als Spieler schon mächtig angefressen, wenn der Croupier mir bei einem Passespiel zunächst von meinem Gewinn meinen Spieleinsatz abknöpft, um mir anschließend - vielleicht mit breitem Grinsen - meinen Einsatz als Gewinn zuschiebt und auch als solchen verkaufen möchte (mit anderen Worten: Schau Dir nochmal Deine Wurf-Methode und meine Anmerkungen dazu an).
[/EDIT]

Zitat:

Das Problem dabei ist, dass dafür nicht eine bestimmte Schranke von aMinus unterschritten werden muss. Es kann sich auch konstant bei 10 Abweichung einpendeln und nie auf 4 fallen. Somit würde das ganze auch gefühlt ewig laufen, obwohl aMinus gar nicht sonderlich unüberschaubar wird.

Sorry, damit kann ich nun gar nix anfangen.

Gruß

[Der Siedler]

Zu Absatz 1, wahrscheinlich bloß ein Tippfehler deinerseits: Ich zähle nicht hoch, bis die Differenz kleiner, sondern bis sie bei 5 ist. Kleiner ist sie ja immer von Anfang an.

Zu Absatz 2: Die Anzahl der Manque-/Passespiele ist quasi limitiert, wenn ich in edAnzahl 1 eingebe. Dann wird in den allermeisten Fällen ein Passe-/Manquespiel ausreichen, um das benötigte Stück zu gewinnen.

Zum Edit: Naja, das ist vllt nicht authentisch umgesetzt, aber es passiert doch genau das, was passieren sollte? Für mich kommt es ja nun wirklich auf dasselbe raus, an der Prozedur Wurf werde ich deshalb nun nicht mehr rumbasteln. Wenn es dich aber glücklich macht, dann hast du dir das wahrscheinlich so vorgestellt

Code:

procedure TfMasseEgale.Wurf (pWette : string);
begin
  a := Random(37);
  case a of
    0 : begin
               aZero := aZero + 1;
               if pWette <> 'Keine Wette'
                 then aGewinn := aGewinn - 0.5;
             end;
    1..18 : begin
               aManque := aManque + 1;
               if pWette = 'Manque'
                 then aGewinn := aGewinn + 1
               else
                 if pWette = 'Passe'
                   then aGewinn := aGewinn - 1
             end;
    19..36 : begin
               aPasse := aPasse + 1;
               if pWette = 'Passe'
                 then aGewinn := aGewinn + 1
               else
                 if pWette = 'Manque'
                   then aGewinn := aGewinn - 1
             end;
  end;
  i := i + 1;
  if aGewinn < aMinus
    then aMinus := aGewinn;
end;

Und all die Grenzen, die ich einführen könnte, würden letztendlich mein Vorhaben ad absurdum führen, denn gerade diese extremen Fälle will ich ja aufzeichnen und statistisch auswerten. Wenn ich da immer aufhöre, bevor es spannend wird, dann kann ich mir genau diese Auswertung auch sparen.

Vielen Dank für die Mühen,

Der Siedler

[Volker Z.]

Hallo,

ich vermute mal, dass Dein Problem mit Endlosschleifen hier liegt:

Delphi-Quellcode:

procedure TfMasseEgale.Manquespiel;
var 
  aGewinnziel : real;
begin
  aGewinnziel := aGewinn + 1;
  while aGewinn < aGewinnziel do
    Wurf('Manque')
end;

bzw.

Delphi-Quellcode:

procedure TfMasseEgale.Passespiel;
var 
  aGewinnziel : real;
begin
  aGewinnziel := aGewinn + 1;
  while aGewinn < aGewinnziel do
    Wurf('Passe')
end;

Annahme: Der Aufruf von Stueckgewinn erfolgt über btStartClick und die Bedingung |aManque - aPasse| < 5 ist irgendwann erfüllt. Die while Schleife wird verlassen und es erfolgt der Aufruf von Passespiel (oder Manquespiel was aufs selbe rausläuft). Dann ist aGewinn zunächst 0. Nun wird Wurf ('Passe') mindestens einmal aufgerufen. Ist Dir das Glück nicht hold, kommen häufiger die Zahlen 0..18 und aus Deinem Gewinn wird bald ein ordentlicher Verlust (und aGewinn < aGewinnziel bleibt erfüllt). Selbst wenn gelegentlich die Kugel im Bereich 19..36 zu liegen kommt, erhöhst Du den Gewinn immer nur um Eins (pWette = Passe damit ist pWette <> 'Keine Wette' immer erfüllt).
Ändere mal Deine Wurf Methode ab:

Delphi-Quellcode:

procedure TfMasseEgale.Wurf (pWette : string);
begin
  a := Random(37);
  case a of
    0      : begin
               aZero := aZero + 1;
               if pWette <> 'Keine Wette'
                 then aGewinn := aGewinn - 0.5;
             end;
    1..18  : begin
               aManque := aManque + 1;
               if pWette = 'Manque'
                 then aGewinn := aGewinn + 2
               else
                 if pWette <> 'Keine Wette'
                   then aGewinn := aGewinn - 1
             end;
    19..36 : begin
               aPasse := aPasse + 1;
               if pWette = 'Passe'
                 then aGewinn := aGewinn + 2
               else
                 if pWette <> 'Keine Wette'
                   then aGewinn := aGewinn - 1
             end;
  end;
  i := i + 1;
  if aGewinn < aMinus
    then aMinus := aGewinn;
end;

und nutze aMinus als zusätzliche Abbruchbedingung, wenn eine bestimmte Schranke unterschritten wird.

Gruß

[Der Siedler]

@Volker: Das Problem dabei ist, dass dafür nicht eine bestimmte Schranke von aMinus unterschritten werden muss. Es kann sich auch konstant bei 10 Abweichung einpendeln und nie auf 4 fallen. Somit würde das ganze auch gefühlt ewig laufen, obwohl aMinus gar nicht sonderlich unüberschaubar wird.

@Jumpy: Doch, diese Ungleichverteilung kommt vor. Nur kommt es eben manchmal auch vor, dass das Ganze sich nicht wieder auf ein normales Niveau einpendelt. Es wird aber durchaus das Manque-/Passespiel aufgerufen, das haben zahlreiche Testläufe gezeigt.

Trotzdem Danke für eure Ideen! Das, was Volker da als Annahme schreibt, wird wohl wirklich das Problem sein. Nur frage ich mich, wieso... Gibt es in Delphi irgendeine bekannte Grenze von Nicht-Zähl-Schleifen, sprich in puncto Durchläufe? Ich kann mir keine andere Möglichkeit vorstellen. Aber wie könnte man das umgehen? Vielleicht eine while-Schleife nur 1000 Mal laufen lassen und dann wiederholen. Aber das wäre lächerlich und alles andere als elegant.