Roulette-Strategie-Simulator

[Der Siedler]

Hallo zusammen,

ich bin ganz neu hier und deshalb bitte ich darüber hinwegzusehen, wenn ich hier im falschen Teil des Forums gepostet habe. Ich habe heute Abend ein paar Zeilen geschrieben, die die sog. "Masse egale"-Strategie beim Roulette auf Herz und Nieren überprüfen soll.

Im Grunde ist das Programm aber auch unabhängig vom Roulette betrachtbar. Vereinfacht könnte man sagen, ich zähle Münzwürfe, bis ein bestimmtes Verhältnis von Kopf zu Zahl gefallen ist. Das kann natürlich lange dauern, wie man sich vorstellen kann. Jedenfalls läuft das Programm irgendwann ohne Fehlermeldung einfach nicht mehr weiter. Ich würde mich sehr freuen, wenn mir jemand einen Tipp geben kann.

Anbei der Code. Auch hier weiß ich nicht, inwiefern es üblich ist, hier den Code einfach als bedrohliche Wall of Text zu posten, aber ich wusste mir nicht anders zu helfen.

Gute Nacht,

Der Siedler

Code:

unit MasseEgale;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TfMasseEgale = class(TForm)
    btStart: TButton;
    edAnzahl: TEdit;
    lbGewinn: TLabel;
    procedure btStartClick(Sender: TObject);
  private
    i,a : integer;
    aManque,aPasse,aZero,aGewinn,aMinus : real;
    procedure Wurf (pWette : string);
    procedure StueckGewinn;
    procedure Manquespiel;
    procedure Passespiel;
  public
    { Public declarations }
  end;

var
  fMasseEgale: TfMasseEgale;

implementation

{$R *.dfm}

procedure TfMasseEgale.btStartClick(Sender: TObject);
begin
  i := 0;
  aManque := 0;
  aPasse := 0;
  aZero := 0;
  aGewinn := 0;
  aMinus := 0;
  Randomize;
  Stueckgewinn;
end;

procedure TfMasseEgale.Stueckgewinn;
begin
  if i < strtoint(edAnzahl.Text)
    then
    begin
      while ((aManque - aPasse) < 5) and ((aPasse - aManque) < 5) do
      begin
        Wurf('Keine Wette');
      end;
      if aManque - aPasse = 5
        then Passespiel
        else Manquespiel;
      Stueckgewinn;
    end;
  lbGewinn.Caption := floattostr(aGewinn) + ' Gewinn, Rückhalt: ' + floattostr(-aMinus);
  edAnzahl.Text := inttostr(i);
end;

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

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

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 <> 'Keine Wette'
                 then aGewinn := aGewinn -1;
               if pWette = 'Manque'
                 then aGewinn := aGewinn + 2;
             end;
    19..36 : begin
               aPasse := aPasse + 1;
               if pWette <> 'Keine Wette'
                 then aGewinn := aGewinn -1;
               if pWette = 'Passe'
                 then aGewinn := aGewinn + 2;
             end;
  end;
  i := i + 1;
  if aGewinn < aMinus
    then aMinus := aGewinn;
end;

end.

[Furtbichler]

Was verstehst Du unter 'läuft einfach nicht weiter'?

[baumina]

Delphi-Quellcode:

procedure TfMasseEgale.Stueckgewinn;
begin
  if i < strtoint(edAnzahl.Text) then
  begin
    while ((aManque - aPasse) < 5) and ((aPasse - aManque) < 5) do
    begin
      Wurf('Keine Wette');
    end;
    if aManque - aPasse = 5
      then Passespiel
      else Manquespiel;
    Stueckgewinn;
  end;
  lbGewinn.Caption := floattostr(aGewinn) + ' Gewinn, Rückhalt: ' + floattostr(-aMinus);
  edAnzahl.Text := inttostr(i);
end;

i wird immer wieder um 1 erhöht und wird irgendwann wohl die Zahl, die im Editfeld eingegeben wurde, erreichen, danach passiert nichts mehr, denn "if i < strtoint(edAnzahl.Text)" wird nicht mehr erfüllt und somit kommt er nicht mehr in die while-Schleife.

[Der Siedler]

Erstmal Danke für die Rückmeldung :)

Unter "läuft einfach nicht weiter" verstehe ich, dass das Programm sich "aufhängt". Es ist nicht mehr bedienbar und liefert auch bei sehr langem Warten kein Ergebnis. Nach einiger Zeit wird das Fenster dann komplett weiß.

Der Zähler i ist ja gerade dafür gedacht, dass das Programm nicht unendlich weiterläuft. Das ist quasi die Mindestanzahl von Würfen. Das funktioniert auch so weit alles wie gedacht, nur habe ich das Gefühl, dass Delphi das alles nicht unendlich oft durchführt, sondern bei der x-ten Wiederholung ins Stocken gerät. Könnte das sein?

[baumina]

Also ich habs bei mir mal laufen lassen. Ja, manchmal kommt er nie wieder aus der while-Schleife raus, weil aManque immer gleich aPasse ist.

Bei einem anderen Test kam er aus der anderen while-Schleife bei PasseSpiel nimmer raus, weil aGewinn -1193345 fallend war.

EDIT: Durch Setzen eines Haltepunkts innerhalb der while-Schleifen kannst du ganz leicht sehen, dass er sich nicht aufhängt, sondern brav in der Endlos-Schleife hängt.

[Der Siedler]

Wie hast du denn die beiden Werte im Auge? Oder ist das eine Vermutung?

Ich stimme dir zwar zu, dass es Fälle geben mag, wo der Fall von (aManque - aPasse) < 5 bzw. umgekehrt sehr lange nicht auftritt, aber irgendwann muss es doch so weit sein. Heißt das, hier sind einfach die Grenzen von Delphi erreicht :?

[lbccaleb]

Zitat:

Zitat von Der Siedler (Beitrag 1220196)

Delphi-Quellcode:

procedure TfMasseEgale.Stueckgewinn;
begin
  if i < strtoint(edAnzahl.Text)
    then
    begin
      while ((aManque - aPasse) < 5) and ((aPasse - aManque) < 5) do
      begin
        Wurf('Keine Wette');
      end;
      if aManque - aPasse = 5
        then Passespiel
        else Manquespiel;
      Stueckgewinn;
    end;
  lbGewinn.Caption := floattostr(aGewinn) + ' Gewinn, Rückhalt: ' + floattostr(-aMinus);
  edAnzahl.Text := inttostr(i);
end;

Ruft sich selber auf, dadurch kommt das Programm in eine Endlosschleife.
Solltest also die Werte im Auge behalten...

Edit:
Wenn das:

Delphi-Quellcode:

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

nicht erfüllt wird, hängt er hier in einer Endlosschleife.

[baumina]

Setz dir einen Haltepunkt in allen while-Schleifen und schau dir in den überwachten Ausdrücken die einzelnen Variablen an.

EDIT: Du kannst es auch erst eine Weile laufen lassen und wenn du meinst es hängt, dann erst die Haltepunkte setzen, bis er anhält.

[Der Siedler]

@lbccaleb: Auch das ist gewollt. Da dieser Selbstaufruf aber nur stattfindet, wenn i die Grenze noch nicht überschreitet, kann das nicht die Ursache des Fehlers sein. Der tritt schließlich auch dann auf, wenn als Grenze 1 eingegeben wird.

[DeddyH]

Zitat:

Zitat von Der Siedler (Beitrag 1220216)

Wie hast du denn die beiden Werte im Auge?

http://www.delphipraxis.net/41047-tu...ortgeschr.html

[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.

[p80286]

Delphi-Quellcode:

procedure TfMasseEgale.Stueckgewinn;
begin
  if i < strtoint(edAnzahl.Text) then begin
    while ((aManque - aPasse) < 5) and ((aPasse - aManque) < 5) do begin
      Wurf('Keine Wette');
    end;

    if aManque - aPasse = 5 then Passespiel
    else Manquespiel;
    
    Stueckgewinn;

  end;
  lbGewinn.Caption := floattostr(aGewinn) + ' Gewinn, Rückhalt: ' + floattostr(-aMinus);
  edAnzahl.Text := inttostr(i);
end;

Wenn das kein Selbstaufruf ist...
Und wo kommt deses i her. Ich finde die Verdammung der globalen Variablen oft zu ideologisch, in diesem Fall kann ich nur sagen "recht so". Zumindestens beim debuggen sind sie alles andere als hilfreich.

Gruß
K-H

[Der Siedler]

@p80286: Bei allem Respekt, ich glaube nicht, dass das Problem in diesem Programm am Selbstaufruf von "Stueckgewinn" liegt. Wenn man sich das ganze mal näher ansieht, wird man merken, dass der Fehler da nicht liegen kann. Der Aufruf passiert ja nur, wenn i unter der festgelegten Grenze liegt, und die habe ich in meinen Testläufen bisher immer auf 1 gesetzt. Trotzdem tritt der Fehler auf, obwohl der Selbstaufruf de facto nicht mehr auftreten kann! Das kann man also vorerst übergehen.

@baumina: Danke ;)

[Jumpy]

Ist jetzt nicht der Fehler/das Problem, aber wäre es nicht einfacher in Wurf, aManque und aPasse jeweils auf 0 zu setzen wenn das Gegenteilige Ereignis (und Zero?) eintritt? Dann muss man nicht mit dieser komplizierten while Bedingung und dem minus 5 usw. arbeiten:

Ausserdem könnte man eine variable für die maximale Anzahl an durchgängen machen und dann in ButtonClick einmalig:

imax:=strtoint(edAnzahl.Text);

und in Stückgewinn dann
if i < imax ...


Ausserdem ruft sich Stückgewinn ja immer wieder selber auf und wenn dann irgendwann mal diese Aufrufkette das Ende erreicht, schreiben alle diese Funktionen nacheinander Rückwärts 10.000 mal das selbe in die Labels, das ist glaub ich auch nicht was gewollt ist.

Das heißt diese Ausgabezeilen am Ende von Stückgewinn besser an das Ende von ButtonClick.

[Der Siedler]

Hi Jumpy, das mit dem Schreiben in die Labels war mir auch schon aufgefallen, fand ich aber jetzt nicht soo schlimm. Du hast aber Recht, so kann man es viel eleganter lösen.

if i < imax geht dagegen nicht. Es soll gerade so sein, dass Stueckgewinn noch aufgerufen wird, wenn i noch nicht erreicht ist. Dann soll das aber auf jeden Fall zu Ende geführt werden. Auch, wenn es dafür nicht i Durchgänge, sondern vielleicht sogar 2i oder noch mehr braucht. Aber wenn man nur edAnzahl.Text durch imax ersetzt, wird es höchstens übersichtlicher, aber ändern tut das doch nichts, oder?

Auch deinen ersten Vorschlag habe ich nicht ganz verstanden. Es geht ja nicht darum, fünf mal Manque oder Passe in einer Reihe zu haben, sondern insegsamt fünf mal mehr Manque als Passe oder umgekehrt. Mir ist da keiner andere Lösung eingefallen, als beide zu zählen und dann eben die Differenz zu ermitteln.

Jedenfalls Danke für deine Mühen!

[Jumpy]

Ich kannte diese Strategie nicht und war davon ausgegangen, dass dabei immer dann "das eine" gespielt wird, wenn x mal (oder mehr) "das andere" hintereinander gefallen ist. Deswegen der nicht hilfreiche Vorchlag 1.

Das mit dem imax war tatsächlich nur der übersichtlichkeit halber. Es wäre halt immer der aufruf strtoint(edAnzahl.Text) durch eine Variable ersetzt worden. edAnzahl.Text ändert sich ja nach dem ButtonClick erstmal nicht mehr, weswegen das ruhig in einer Variablen abgelegt werden könnte.

Vielleicht noch eine Idee: Debugging stell ich mir auch etwas schwierig vor, da ja evtl. einige hundert(?) Runden ins Land gehen können, bevor man was sieht. Vielleicht könntets du in jeder Runde die Inhalte deiner Variablen z.B. in eine Stringlist "loggen" und diese alle x-hundert Runden abspeichern und dir mal angucken, wie sich die Variablen verhalten?

Vielleicht ist ja der Zufallsgenerator so gleichverteilt(?), das nie eine Variante 5 Vorsprung vor der anderen hat...

[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.

[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.

:shock: 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 :D

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