(* ::Package:: *)

(* ::Section:: *)
(*Roulette.m*)


(* ::Text:: *)
(*alles was das Roulette.nb braucht*)


(* ::Text:: *)
(*Achtung: fast alle Variablen sind global*)


(* ::Subsection::Closed:: *)
(*BeginPackage*)


BeginPackage["Roulette`"];


(* ::Subsection:: *)
(*Dialoge*)


(* ::Subsubsection::Closed:: *)
(*Dialog "Kugel rollt"*)


CreatePanel[nHighlight_]:=
Module[
{i=1},
Prepend[
Table[
Panel[If[nHighlight==i, Style[i++,Red,Bold],i++],ImageSize->41],
{12},{3}
],
{"",Panel[If[nHighlight==0,Style[0,Red,Bold],Style[0,Green]],ImageSize->41]}
]//TableForm
]
zeigeKugelRolltDialog[iSoll_]:=
Module[
{iMax=30,kugelRolltDialog},
kugelRolltDialog=CreateDialog[
Animate[
CreatePanel[If[i==iMax,iSoll,RandomInteger[{0,36}]]],
{{i,1,""},1,iMax,1,AppearanceElements->"",AnimationRepetitions->1,AnimationDirection->Forward}
]
];
Pause[7];
NotebookClose[kugelRolltDialog];
];


(* ::Subsubsection:: *)
(*Dialog "Einsatzh\[ODoubleDot]he eingeben"*)


einsatzSumme=1;


createDialogEinsatz[]:=
Module[
{number=1,button,clearButton,backspaceButton,digits2number,digits={}},
If[NumberQ[einsatzSumme],digits=IntegerDigits[einsatzSumme]];
button[i_]:=
Button[i,
If[
(Length[digits]>0||i>0)&&
Length[digits]<6,
AppendTo[digits,i];einsatzSumme=digits2number[]
],ImageSize->{40,40}
];
digits2number[]:=Plus@@Table[digits[[i]]10^(Length[digits]-i),{i,Length[digits]}];
clearButton=Button["C",digits={};einsatzSumme=digits2number[]];
backspaceButton=Button["\[LeftArrow]",If[Length[digits]>0,digits=Delete[digits,-1];einsatzSumme=digits2number[]]];
CreateDialog[
Column[{
Grid[
Table[button[number++],{3},{3}]~Join~
{{clearButton,button[0],backspaceButton}}
],
Row[
{"Einsatz: ",
Dynamic[Refresh[einsatzSumme,TrackedSymbols->{digits},UpdateInterval->0.1]]}
],
DefaultButton[]
}
],WindowTitle->"Einsatz"
]
]


(* ::Subsubsection::Closed:: *)
(*Dialog "Spielergebnis"*)


createDialogResult[gewinnZahl_]:=
Module[{colorString,ergebnistext},
If[isRed[gewinnZahl],colorString="rote ",colorString="schwarze "];
If[gewinnZahl==0,colorString=""];
ergebnistext="Es kam die "<>colorString<>ToString[gewinnZahl]<>". Ihr Ergebnis: "<>ToString[auszahlung[gewinnZahl]];
NotebookClose[dialogResult];
dialogResult=CreateDialog[
{TextCell[ergebnistext],DefaultButton[]},
WindowMargins->{{Automatic,Automatic},{Automatic,200}},Modal->True
];
]


(* ::Subsection:: *)
(*Der Roulettetisch*)


(* ::Subsubsection::Closed:: *)
(*Logische Setzfelder*)


(*Setzfelder im Format {Namen,Auszahlungsfaktor,Einsatz}*)
erzeugeSetzfelder[]:=
Module[
{auszahlungsfaktor,anfangseins\[ADoubleDot]tze,spielfelderEinfacheChancen,spielfelderZahlen,feldnamen},
auszahlungsfaktor=Table[1,{6}];
anfangseins\[ADoubleDot]tze=Table[0,{6}];
spielfelderEinfacheChancen=Transpose@
{{"Red","Black","1-18","19-36","Even","Odd"},auszahlungsfaktor,anfangseins\[ADoubleDot]tze};
feldnamen=Table[ToString[i],{i,0,36}];
auszahlungsfaktor=Table[35,{37}];
anfangseins\[ADoubleDot]tze=Table[0,{37}];
spielfelderZahlen=Transpose@{feldnamen,auszahlungsfaktor,anfangseins\[ADoubleDot]tze};
spielfelderEinfacheChancen~Join~spielfelderZahlen
]


setzfelder=erzeugeSetzfelder[];


(* ::Subsubsection:: *)
(*logische Funktionen und globale Variable*)


setze[feldindex_,summe_]:=
Module[
{},
If[feldindex<=6,h\[ODoubleDot]chsteinsatz=12000,h\[ODoubleDot]chsteinsatz=350];
setzfelder[[feldindex,3]]=Min[summe,h\[ODoubleDot]chsteinsatz];
If[summe>h\[ODoubleDot]chsteinsatz,statuszeile="Gew\[UDoubleDot]nschter Einsatz von "<>ToString[summe]<>" ist \[UDoubleDot]ber dem Limit "<>ToString[h\[ODoubleDot]chsteinsatz]
]
]


clearBoard[]:=
Module[
{i},
For[i=1,i<=Length[setzfelder],i++,setzfelder[[i,3]]=0]
]


(* ::Text:: *)
(*Hier werden die globalen Variablen initialisiert*)


newGame[]:=
Module[{},
clearBoard[];
initAutomatischeSpiele[];
history={0};
einsatzSumme=1;
kassenstand=0;
umsatz=0;
historyGewinnzahlen={};
statuszeile="";
updateTrigger=0;
]


changeBet[]:=
Module[{},
SetSelectedNotebook[dlgEinsatz];
If[SelectedNotebook[]==dlgEinsatz,Return[]];
dlgEinsatz=createDialogEinsatz[];
SetOptions[dlgEinsatz,WindowFrame->"ModalDialog"];
]


play[]:=
Module[{i,anzahlSpiele},
anzahlSpiele=log2Int[anzahlSpieleLog];
For[i=1,i<=anzahlSpiele,i++,
gewinnZahl=RandomInteger[{0,36}];
(*zeigeKugelRolltDialog[gewinnZahl];*)
setzeAutomatisch[];
spielschrittAutomatisch[];
If[anzahlSpiele==1&&ergebnisDialogZeigen,createDialogResult[gewinnZahl]];
kassenstand+=auszahlung[gewinnZahl];
AppendTo[history,kassenstand];
AppendTo[historyGewinnzahlen,gewinnZahl];
If[anzahlSpiele==1&&!einsatzBleibtStehen,clearBoard[]];
setzeAutomatisch[];
];
updateTrigger++;
]


auszahlung[zahl_]:=
Module[{gewinn=0,i},
For[i=1,i<=Length[setzfelder],i++,
umsatz+=setzfelder[[i,3]];
If[
hatGewonnen[zahl,setzfelder[[i,1]]],
gewinn+=setzfelder[[i,2]]*setzfelder[[i,3]],
gewinn-=setzfelder[[i,3]]
]
];
gewinn
]


(* ::Subsubsection:: *)
(*grafische Funktionen*)


darkGreen=RGBColor[0,0.4,0];
windowsGray=RGBColor[212/255,208/255,200/255];


toggleEinsatz[index_]:=
Module[{},
If[
einsatzSumme==0,
CreateDialog[
{TextCell["Sie m\[UDoubleDot]ssen einen Einsatz festlegen"],DefaultButton[]},
WindowMargins->{{Automatic,Automatic},{Automatic,200}},
Modal->True
];changeBet[];
Return []
];
If[
setzfelder[[index,3]]==0,
setzfelder[[index,3]]=einsatzSumme,
setzfelder[[index,3]]=0
]
]


makeChip[index_,{{x_,y_},discsize_},textsize_]:=(*either a white disk with black number or an invisible disk*)
If[
setzfelder[[index,3]]==0,
{},
{White,Disk[{x,y},discsize],Black,Text[Style[ToString[setzfelder[[index,3]]],textsize],{x,y}]}
]


bigButton[index_]:=
DynamicModule[
{chipCoords={0,-0.4},labelCoords={0,0.2},discsize=0.4,textsize=20},
Button[
Dynamic[ 
Graphics[
{
Text[Style[setzfelder[[index,1]],25],labelCoords],
makeChip[index,{chipCoords,discsize},textsize]},
ImageSize->{70,70},Background->darkGreen,PlotRange->{{-1,1},{-1,1}}
]
],
toggleEinsatz[index]
]
]


smallButton[index_]:=
DynamicModule[
{number,numberString,textColor,chipCoords={0,0},labelCoords={0,0},discsize=0.5,textsize=15},
numberString=setzfelder[[index,1]];
number=ToExpression[numberString];
If[isRed[number],textColor=Red,textColor=Black];
If[number==0,textColor=Green];
Button[
Dynamic[ 
Graphics[
{Text[Style[numberString,textColor,30],{0,0}],
makeChip[index,{chipCoords,discsize},textsize]},
ImageSize->{50,30},Background->darkGreen,PlotRange->{{-1,1},{-1,1}}
]
],toggleEinsatz[index]
]
]


actionButton[{text_,action_}]:=Button[Style[text,15,Bold],action[],ImageSize->{77,77},Method->"Queued"]


makeActionButtons[]:=
Module[{i=1},
actions={
{"Clear\nBoard",clearBoard},
{"New\nGame",newGame},
{"Change\nBet",changeBet},
{"Play",play}};
Table[actionButton[actions[[i++]]],{2},{2}]
]


makeButtonsZero2ThirtySix[]:=
Module[{i=8,buttonsOne2ThirtySix,buttonZero},
buttonsOne2ThirtySix=Table[smallButton[i++],{12},{3}];
buttonZero={{"",smallButton[7],""}};
Grid@(buttonZero~Join~buttonsOne2ThirtySix)
]


makeButtonsSimpleChances[]:=
Module[{i=1},
Table[bigButton[i++],{3},{2}]
]


makeHistoryPanel[]:=
Module[{i=1,plotLabel,plotRange,kassenstandRelativ,xList,yMin,yMax,yRange,xText,xTextCoords},
Dynamic[
{yMin,yMax}={Min[history],Max[history]};
yRange=yMax-yMin;
xList=If[Length[history]>1000,Range[Length[history]]/1000,Range[Length[history]]];
kassenstandRelativ=If[umsatz>0,N[Round[1000kassenstand/umsatz]/10],0];
plotLabel=Style["Gewinn: "<>ToString[kassenstandRelativ]<>"% v. Umsatz",darkGreen];
plotRange={Min[yMin,xTextCoords[[2]]]-yRange/7,yMax};
xText=If[Length[history]>1000,"x 1000",""];
xTextCoords={0.5Last[xList],-0.5yRange};
Panel[
ListPlot[
Transpose@{xList,history},
ImageSize->{145,110},
Joined->True,
PlotLabel->plotLabel,
PlotRange->plotRange,
AxesOrigin->{0,Automatic},
AspectRatio->0.7,
Epilog->Text[xText,xTextCoords]
]
]
]
]


makeHistogramPanel[switch_,dummy_]:=
Module[{},
If[
switch,
Panel[
Histogram[
historyGewinnzahlen,{-0.5,36.5,1},
Ticks->{Range[0,36,3],Automatic},
ChartElementFunction->"FadingRectangle",
ChartStyle->Orange,
ImageSize->{180,180},
Epilog->First@Plot[Length[historyGewinnzahlen]/37,{x,-0.5,36.5},PlotStyle->Red]
]
],
""
]
]


makeLogarithmicSlider[anzahlSpieleLog_]:=
Module[{},
Grid[
{{Slider[Dynamic[anzahlSpieleLog],ImageSize->Small],
Style[Dynamic[ToString[log2Int[anzahlSpieleLog]]],Bold]}},Spacings->1
]
]


makeCheckbox[var_,txt_,opts___]:=Grid[{{Checkbox[var,opts],txt}},Spacings->1]


makeLogSlider[var_]:=
Grid[
{{Slider[var,ImageSize->Small],
Style[Dynamic[ToString[log2Int[var/.a_[b_]:>b]]],Bold]}},
Spacings->1
]


makeStatuszeile[dummy_,text_]:=Style[text,Bold,Red]


(* ::Subsubsection::Closed:: *)
(*Hilfsfunktionen*)


isRed[n_Integer]:=
Module[
{listeRot={1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36}},
Length[Select[listeRot,(n==#)&,1]]==1
]


isBlack[n_Integer]:=!isRed[n]&&n!=0


isEven[n_Integer]:=EvenQ[n]&&n!=0


isOdd[n_Integer]:=OddQ[n]


isLow[n_Integer]:=1<=n<=18


isHigh[n_Integer]:=19<=n<=36


hatGewonnen[zahl_,feld_]:=
Module[{i},
If[feld=="Red",Return[isRed[zahl]]];
If[feld=="Black",Return[isBlack[zahl]]];
If[feld=="1-18",Return[isLow[zahl]]];
If[feld=="19-36",Return[isHigh[zahl]]];
If[feld=="Even",Return[isEven[zahl]]];
If[feld=="Odd",Return[isOdd[zahl]]];
Return[feld==ToString[zahl]]
]


log2Int[nLog_,nMax_]:=Floor[Exp[nLog *Log[nMax]]]


nMax=10000;
log2Int[nLog_]:=log2Int[nLog,nMax]


(* ::Subsection::Closed:: *)
(*Automatische Spiele*)


(* ::Subsubsection::Closed:: *)
(*Hilfetexte*)


hilfetextFreiesSpiel="Sie k\[ODoubleDot]nnen frei setzen. Es ist m\[ODoubleDot]glich, den Einsatz stehen zu lassen und n Spiele mit einem Knopfdruck zu spielen. Das Ergebnis zeigt die Grafik \"Gewinn\". Der Einsatz kann mit dem Men\[UDoubleDot] \"Einsatz \[ADoubleDot]ndern\" angepasst werden. Gesetzt wird durch Klicken auf das gew\[UDoubleDot]nschte Feld.";


hilfetextMartingale="Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die

Als Martingalespiel oder kurz Martingale bezeichnet man seit dem 18. Jahrhundert eine Strategie im Gl\[UDoubleDot]cksspiel, bei der der Einsatz im Verlustfall erh\[ODoubleDot]ht wird.

Die klassische und einfachste Form der Martingale, die Martingale classique ist das Doublieren oder Verdoppeln: Man beginnt mit einem Einsatz von einer Einheit (einem St\[UDoubleDot]ck) auf eine einfache Chance, z. B. Rouge oder Noir beim Roulette.

Der Martingale-Spieler setzt zumeist auf die Perdante (siehe Marche), das ist diejenige Chance, die zuletzt verloren hat: ist die Kugel zuletzt auf Rouge gefallen, so setzt er daher auf Noir.

Verliert er, so setzt er im n\[ADoubleDot]chsten Coup zwei St\[UDoubleDot]ck, verliert er wieder, so setzt er vier St\[UDoubleDot]ck, usw. Sobald er gewinnt, sind alle bis dahin eingetretenen Verluste getilgt, und der Spieler darf sich \[UDoubleDot]ber einen Gesamtgewinn von einem St\[UDoubleDot]ck freuen. Nach einem Gewinn setzt er seinen Angriff auf die Spielbank wieder mit einem St\[UDoubleDot]ck fort.";


hilfetextMontanteAm\[EAcute]ricaine="Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die

Die Montante Am\[EAcute]ricaine, Annulation Am\[EAcute]ricaine oder kurz Am\[EAcute]ricaine ist eine popul\[ADoubleDot]re Form des Martingalespiels, welche von vielen Spielern beim Setzen auf die einfachen Chancen beim Roulette angewendet wird.

Vor Beginn seines Angriffs auf die Spielbank schreibt der Spieler die Zahlen

1 \[Dash] 2 \[Dash] 3 \[Dash] 4

auf einen Zettel. W\[ADoubleDot]hrend des Spiels setzt er stets die Summe der beiden \[ADoubleDot]u\[SZ]ersten Zahlen dieser Folge; d.h. im ersten Coup setzt der Spieler 1+4=5 Einheiten (St\[UDoubleDot]ck). Gewinnt er diesen Coup, so streicht er die beiden \[ADoubleDot]u\[SZ]ersten Zahlen durch, und seine Notiz zeigt

(1) \[Dash] 2 \[Dash] 3 \[Dash] (4).

Nun setzt er 2 + 3 = 5 Einheiten. Verliert der Spieler einen Coup, so f\[UDoubleDot]gt er die Anzahl der zuletzt gesetzten Einheiten seinen Aufzeichnungen hinzu und erh\[ADoubleDot]lt folgendes Bild

(1) \[Dash] 2 \[Dash] 3 \[Dash] (4) \[Dash] 5.

Im n\[ADoubleDot]chsten Coup sind daher 2 + 5 = 7 Einheiten zu setzen; wird dieser Coup gewonnen, so setzt der Spieler danach 3 Einheiten; usf.

Gelingt es einem Spieler alle Zahlen seiner Reihe durchzustreichen, so hat er das Ziel erreicht und insgesamt zehn Einheiten gewonnen und kann nun einen neuen Angriff starten.

Die Am\[EAcute]ricaine ist so wie die Montante Hollandaise ein Beispiel einer Abstreichprogression (Stellentilgungssystem, Annulation): Durch jeden Gewinn werden vorangegangene Verluste getilgt und auf der Liste gestrichen.";


hilfetextFitzroy="Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die

Das Fitzroy-System oder die Fitzroy-Progression ist eine popul\[ADoubleDot]re Form des Martingalespiels, die von manchen Spielern beim Setzen auf die einfachen Chancen beim Roulette und Trente et quarante angewendet wird.

In der einfachen Form dieses Systems beginnt der Spieler seinen Angriff auf die Spielbank mit einem Einsatz von einer Einheit (St\[UDoubleDot]ck). Gewinnt der Spieler diesen Coup, so ist diese Spielserie beendet, und er beginnt eine neue Spielserie; d.h. solange der Spieler gewinnt, setzt er immer nur eine Einheit.

Sobald der Spieler aber das erste Mal verliert, setzt er im folgenden Coup zwei Einheiten. Da der Einsatz nach dem ersten Verlust erh\[ODoubleDot]ht wird, handelt es sich bei dieser Spielweise um eine Form des Martingalespiels.

Verliert der Spieler auch diesen Coup, so setzt er im folgenden Coup drei Einheiten, und in Folge unabh\[ADoubleDot]ngig von Gewinn oder Verlust der einzelnen Coups nacheinander stets um eine Einheit mehr als im vorangegangenen Coup, d.h. er setzt nacheinander 1, 2, 3, 4, 5, ... St\[UDoubleDot]ck, solange, bis er innerhalb dieser Spielserie einen positiven Saldo erreicht.";


hilfetextParoli="Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die

Im Gegensatz zum Martingale-Spieler, der seinen Einsatz nach einem Verlust steigert, versucht ein Paroli-Spieler z. B. beim Roulette dadurch zu gewinnen, dass er seinen Einsatz nach einem Gewinn steigert.

Der Spieler setzt sich vor Beginn des Spiels ein Gewinnziel, z. B. den Gewinn eines Dreifachen Paroli (Quinze et le va) und startet seinen Angriff auf die Spielbank mit einem Einsatz von einer Einheit (St\[UDoubleDot]ck).

Gewinnt er, so l\[ADoubleDot]sst er Einsatz und Gewinn stehen (Erstes Paroli), gewinnt er nochmals, so l\[ADoubleDot]sst er den urspr\[UDoubleDot]nglichen Einsatz mitsamt den bisherigen Gewinnen stehen (Zweites Paroli) und sollte er noch zwei Mal gewinnen, so ist das Ziel erreicht.

Verliert er aber einen Coup, bevor das Ziel erreicht ist, so beginnt er einen neuen Angriff mit einer Einheit.";


(* ::Subsubsection::Closed:: *)
(*Namen, Funktionen, Buttons*)


strategieNamen={"Freies Spiel","Martingale","Montante","Fitzroy","Paroli"};


strategieHilfetexte={hilfetextFreiesSpiel,hilfetextMartingale,hilfetextMontanteAm\[EAcute]ricaine,hilfetextFitzroy,hilfetextParoli};


strategy=strategieNamen[[1]];(*Init*)


boldIfChosen=Style[#,If[strategy==#,Bold,Plain,Italic]]&


makeStrategyButtons[dummy_]:=
Dynamic@
TableForm@
MapThread[
Button[Tooltip[#2,#3],strategy=#1,ImageSize->100]&,
{strategieNamen,boldIfChosen/@strategieNamen,strategieHilfetexte}
]


setzeAutomatisch[]:=
Module[
{},
If[strategy==strategieNamen[[2]],setzeMartingale[]];(*Martingale*)
If[strategy==strategieNamen[[3]],setzeMontante[]];(*Montante*)
If[strategy==strategieNamen[[4]],setzeFitzroy[]];(*Fitzroy*)
If[strategy==strategieNamen[[5]],setzeParoli[]](*Paroli*)
]


spielschrittAutomatisch[]:=
Module[{},
If[strategy==strategieNamen[[2]],spielschrittMartingale[]];(*Martingale*)
If[strategy==strategieNamen[[3]],spielschrittMontante[]];(*Montante*)
If[strategy==strategieNamen[[4]],spielschrittFitzroy[]];(*Fitzroy*)
If[strategy==strategieNamen[[5]],spielschrittParoli[]](*Paroli*)
]


initAutomatischeSpiele[]:=
Module[{},
initMartingale[];
initMontante[];
initFitzroy[];
initParoli[];
]


(* ::Subsubsection::Closed:: *)
(*Martingale*)


(* ::Text:: *)
(*Martingale = {angriffsfarbeIndex, AnzahlVerlorenerSpiele}*)


initMartingale[]:= 
parameterMartingale=
{RandomInteger[{1,6}],0
};


einsatzMartingale[]:=
Module[{einsatz,anzVerloren=parameterMartingale[[2]],h\[ODoubleDot]chsteinsatz=12000},
einsatz=einsatzSumme*2^anzVerloren
]


setzeMartingale[]:=
Module[{angriffsfarbeIndex=parameterMartingale[[1]]},
setze[angriffsfarbeIndex,einsatzMartingale[]];
]


spielschrittMartingale[]:=
Module[
{angriffsfarbeIndex=parameterMartingale[[1]],anzVerluste=parameterMartingale[[2]]},
If[hatGewonnen[gewinnZahl,setzfelder[[angriffsfarbeIndex,1]]],anzVerluste=0,anzVerluste++];
parameterMartingale[[2]]=anzVerluste;
]


(* ::Subsubsection::Closed:: *)
(*Fitzroy*)


(* ::Text:: *)
(*parameterMontanteAmericain={angriffsFeld, anzSpiele,saldo};*)


initFitzroy[]:=
parameterFitzroy={RandomInteger[{1,6}],0,0}


einsatzFitzroy[]:=
Module[{einsatz,anzSpiele=parameterFitzroy[[2]]},
einsatz=einsatzSumme (1+anzSpiele)
]


setzeFitzroy[]:=
Module[{angriffsFarbeindex=parameterFitzroy[[1]]},
clearBoard;
setze[angriffsFarbeindex,einsatzFitzroy[]]
]


spielschrittFitzroy[]:=
Module[{angriffsfarbeIndex=parameterFitzroy[[1]],anzSpiele=parameterFitzroy[[2]],saldo=parameterFitzroy[[3]]},
parameterFitzroy[[2]]=++anzSpiele;
If[
hatGewonnen[gewinnZahl,setzfelder[[angriffsfarbeIndex,1]]],saldo+=anzSpiele,saldo-=anzSpiele];
If[saldo>0,parameterFitzroy[[3]]=0,parameterFitzroy[[3]]=saldo];
If[saldo>0,parameterFitzroy[[2]]=0];
]


(* ::Subsubsection::Closed:: *)
(*Paroli*)


(* ::Text:: *)
(*parameterParoli={angriffsfarbeIndex,Anzahl der Gewinne/Einsatzfaktor};*)


initParoli[]:=
parameterParoli={RandomInteger[{1,6}],0}


einsatzParoli[]:=
Module[
{einsatz,anzGewinne=parameterParoli[[2]]},
einsatz=einsatzSumme*2^anzGewinne
]


setzeParoli[]:=
Module[{angriffsfarbeIndex=parameterParoli[[1]]},
setze[angriffsfarbeIndex,einsatzParoli[]];
]


spielschrittParoli[]:=
Module[
{angriffsfarbeIndex=parameterParoli[[1]],anzGewinne=parameterParoli[[2]],maxAnzGewinne=5},
If[
hatGewonnen[gewinnZahl,setzfelder[[angriffsfarbeIndex,1]]],
If[
anzGewinne>=maxAnzGewinne,
anzGewinne=0,
anzGewinne++
],
anzGewinne=0
];
parameterParoli[[2]]=anzGewinne;
]


(* ::Subsubsection:: *)
(*Montante Americain*)


(* ::Text:: *)
(*parameterMontanteAmericain={angriffsfarbeIndex,einsatzListe};*)


initMontante[]:= 
parameterMontante=
{RandomInteger[{1,6}],
{1,2,3,4}
};


einsatzMontante[]:=
Module[
{einsatz,einsatzListe=parameterMontante[[2]],h\[ODoubleDot]chsteinsatz=12000,verbose=False},
einsatz=einsatzSumme*First[einsatzListe];
If[Length[einsatzListe]>1,einsatz+=Last[einsatzListe],einsatz]
]


setzeMontante[]:=
Module[{einsatzListe=parameterMontante[[2]],angriffsfarbeIndex=parameterMontante[[1]],verbose=False},
clearBoard[];
setze[angriffsfarbeIndex,einsatzMontante[]];
]


spielschrittMontante[]:=
Module[{einsatzListe=parameterMontante[[2]],angriffsfarbeIndex=parameterMontante[[1]]},
If[
hatGewonnen[gewinnZahl,setzfelder[[angriffsfarbeIndex,1]]],
If [Length[einsatzListe]<=2,
initMontante[];
einsatzListe=parameterMontante[[2]],
 einsatzListe=Drop[Drop[einsatzListe,1],-1]
],
einsatzListe=Append[einsatzListe,einsatzMontante[]]
];
parameterMontante[[2]]=einsatzListe;
]


(* ::Subsection::Closed:: *)
(*End Package*)


EndPackage[ ]
