(* Content-type: application/mathematica *)

(*** Wolfram Notebook File ***)
(* http://www.wolfram.com/nb *)

(* CreatedBy='Mathematica 6.0' *)

(*CacheID: 234*)
(* Internal cache information:
NotebookFileLineBreakTest
NotebookFileLineBreakTest
NotebookDataPosition[       145,          7]
NotebookDataLength[     47744,        955]
NotebookOptionsPosition[     47127,        929]
NotebookOutlinePosition[     47642,        950]
CellTagsIndexPosition[     47599,        947]
WindowFrame->Normal*)

(* Beginning of Notebook Content *)
Notebook[{

Cell[CellGroupData[{
Cell[BoxData[{
 RowBox[{
  RowBox[{"Needs", "[", "\"\<Roulette`\>\"", "]"}], 
  ";"}], "\[IndentingNewLine]", 
 RowBox[{"Manipulate", "[", "\[IndentingNewLine]", 
  RowBox[{
   RowBox[{
    RowBox[{"newGame", "[", "]"}], ";", "\[IndentingNewLine]", 
    RowBox[{"Panel", "[", "\[IndentingNewLine]", 
     RowBox[{
      RowBox[{"Row", "[", "\[IndentingNewLine]", 
       RowBox[{"{", 
        RowBox[{
         RowBox[{"Column", "[", 
          RowBox[{"{", 
           RowBox[{
            RowBox[{"Grid", "@", 
             RowBox[{"(", 
              RowBox[{
               RowBox[{"makeActionButtons", "[", "]"}], "~", "Join", "~", 
               RowBox[{"makeButtonsSimpleChances", "[", "]"}]}], ")"}]}], ",", 
            RowBox[{"makeHistoryPanel", "[", "]"}]}], "}"}], "]"}], ",", 
         "\[IndentingNewLine]", 
         RowBox[{"makeButtonsZero2ThirtySix", "[", "]"}]}], 
        "\[IndentingNewLine]", "}"}], "]"}], ",", "\[IndentingNewLine]", 
      RowBox[{"Background", "->", "darkGreen"}]}], "\[IndentingNewLine]", 
     "]"}]}], ",", "\[IndentingNewLine]", "\[IndentingNewLine]", 
   RowBox[{"Dynamic", "[", 
    RowBox[{"makeStrategyButtons", "[", "True", "]"}], "]"}], ",", 
   "\[IndentingNewLine]", "Delimiter", ",", "\[IndentingNewLine]", 
   RowBox[{"Style", "[", 
    RowBox[{"\"\<Einstellungen\>\"", ",", "12"}], "]"}], ",", 
   "\[IndentingNewLine]", 
   RowBox[{"Style", "[", 
    RowBox[{"StringJoin", "[", 
     RowBox[{"Table", "[", 
      RowBox[{"\"\< \>\"", ",", 
       RowBox[{"{", "66", "}"}]}], "]"}], "]"}], "]"}], ",", 
   RowBox[{"(*", 
    RowBox[{"unsichtbarer", " ", "String"}], "*)"}], "\[IndentingNewLine]", 
   RowBox[{"Dynamic", "[", "\[IndentingNewLine]", 
    RowBox[{"makeCheckbox", "[", 
     RowBox[{
      RowBox[{"Dynamic", "@", "einsatzBleibtStehen"}], ",", 
      "\"\<Eins\[ADoubleDot]tze stehen lassen\>\"", ",", 
      RowBox[{"Enabled", "->", 
       RowBox[{
        RowBox[{"strategy", "==", "\"\<Freies Spiel\>\""}], "&&", 
        RowBox[{"anzahlSpieleLog", "==", "0"}]}]}]}], "]"}], 
    "\[IndentingNewLine]", "]"}], ",", "\[IndentingNewLine]", 
   RowBox[{"Dynamic", "[", "\[IndentingNewLine]", 
    RowBox[{"makeCheckbox", "[", 
     RowBox[{
      RowBox[{"Dynamic", "@", "ergebnisDialogZeigen"}], ",", 
      "\"\<Ergebnis anzeigen\>\"", ",", 
      RowBox[{"Enabled", "->", 
       RowBox[{"anzahlSpieleLog", "==", "0"}]}]}], "]"}], 
    "\[IndentingNewLine]", "]"}], ",", "\[IndentingNewLine]", 
   RowBox[{"Style", "[", "\"\<\\nAnzahl Spiele\>\"", "]"}], ",", 
   "\[IndentingNewLine]", 
   RowBox[{"Dynamic", "[", 
    RowBox[{"makeLogSlider", "[", 
     RowBox[{"Dynamic", "[", "anzahlSpieleLog", "]"}], "]"}], "]"}], ",", 
   "\[IndentingNewLine]", "Delimiter", ",", "\[IndentingNewLine]", 
   RowBox[{"Dynamic", "[", 
    RowBox[{"makeCheckbox", "[", 
     RowBox[{
      RowBox[{"Dynamic", "@", "histogrammZeigen"}], ",", 
      "\"\<Histogramm anzeigen\>\""}], "]"}], "]"}], ",", 
   "\[IndentingNewLine]", 
   RowBox[{"Dynamic", "[", 
    RowBox[{
     RowBox[{"makeHistogramPanel", "[", 
      RowBox[{"histogrammZeigen", ",", "updateTrigger"}], "]"}], ",", 
     RowBox[{"TrackedSymbols", ":>", 
      RowBox[{"{", 
       RowBox[{"updateTrigger", ",", "histogrammZeigen"}], "}"}]}]}], "]"}], 
   ",", "\[IndentingNewLine]", 
   RowBox[{"{", 
    RowBox[{
     RowBox[{"{", 
      RowBox[{"statuszeileZeigen", ",", "\"\<\>\"", ",", "\"\<\>\""}], "}"}], 
     ",", 
     RowBox[{
      RowBox[{"makeStatuszeile", "[", 
       RowBox[{"#", ",", 
        RowBox[{"Dynamic", "[", "statuszeile", "]"}]}], "]"}], "&"}], ",", 
     RowBox[{"ControlPlacement", "->", "Bottom"}]}], "}"}], ",", 
   "\[IndentingNewLine]", 
   RowBox[{"FrameLabel", "->", 
    RowBox[{"{", 
     RowBox[{
      RowBox[{"{", 
       RowBox[{"\"\<\>\"", ",", "\"\<\>\""}], "}"}], ",", 
      RowBox[{"{", 
       RowBox[{"\"\<\>\"", ",", 
        RowBox[{"Style", "[", 
         RowBox[{"\"\<Casino Merseburg\>\"", ",", "22", ",", "Bold"}], 
         "]"}]}], "}"}]}], "}"}]}], ",", "\[IndentingNewLine]", 
   RowBox[{"ControlPlacement", "->", "Right"}], ",", "\[IndentingNewLine]", 
   RowBox[{"SaveDefinitions", "->", "True"}]}], "\[IndentingNewLine]", 
  "]"}]}], "Input",
 ShowCellBracket->True,
 CellChangeTimes->{{3.436010142820125*^9, 3.436010151507625*^9}, 
   3.43601023252325*^9, {3.436091158601375*^9, 3.436091250882625*^9}, {
   3.43609128777325*^9, 3.436091328992*^9}, {3.4360914088045*^9, 
   3.43609142002325*^9}, {3.436092008742*^9, 3.436092109663875*^9}, {
   3.436092140726375*^9, 3.436092141820125*^9}, {3.436092211257625*^9, 
   3.436092214288875*^9}, 3.436092482007625*^9, 3.43609252958575*^9, {
   3.436092595992*^9, 3.436092604945125*^9}, 3.436093188242*^9, {
   3.436093620320125*^9, 3.436093635492*^9}, {3.436093668351375*^9, 
   3.436093678007625*^9}, {3.43609373883575*^9, 3.4360937404295*^9}, 
   3.436093987195125*^9, 3.436096012476375*^9, {3.436096222445125*^9, 
   3.43609623227325*^9}, {3.436096396382625*^9, 3.4360964114295*^9}, {
   3.436096444757625*^9, 3.436096465101375*^9}, {3.4360965798045*^9, 
   3.436096586195125*^9}, {3.436096640538875*^9, 3.4360966459295*^9}, {
   3.43609671046075*^9, 3.436096715476375*^9}, {3.43609690589825*^9, 
   3.436096907992*^9}, {3.43609697058575*^9, 3.436096975492*^9}, {
   3.436097025632625*^9, 3.436097030992*^9}, {3.4360971330545*^9, 
   3.4360971635545*^9}, 3.436097218992*^9, {3.43609725802325*^9, 
   3.436097266601375*^9}, {3.436097315851375*^9, 3.436097317320125*^9}, {
   3.436097521882625*^9, 3.43609752933575*^9}, {3.436344878078125*^9, 
   3.436344907265625*^9}, {3.4363449786875*^9, 3.436345095671875*^9}, {
   3.436345165390625*^9, 3.436345227453125*^9}, {3.436345269125*^9, 
   3.436345269546875*^9}, {3.436346412359375*^9, 3.436346432109375*^9}, {
   3.436347090515625*^9, 3.436347205203125*^9}, {3.436349611671875*^9, 
   3.436349638421875*^9}, {3.43634967509375*^9, 3.436349783921875*^9}, 
   3.436349900296875*^9, 3.436350266484375*^9, {3.43635086165625*^9, 
   3.436350865921875*^9}, {3.436351187640625*^9, 3.43635118775*^9}, 
   3.436351349171875*^9, 3.43635155665625*^9, {3.43650868640625*^9, 
   3.436508687453125*^9}, {3.436508816015625*^9, 3.436508818125*^9}, {
   3.43650893275*^9, 3.436508938*^9}, 3.436508982*^9, {3.4365307755625*^9, 
   3.436530783703125*^9}, {3.437048926921875*^9, 3.43704893153125*^9}, {
   3.4371328030625*^9, 3.437132818671875*^9}, {3.437132932765625*^9, 
   3.437132937625*^9}, {3.437133146359375*^9, 3.437133187578125*^9}, {
   3.4371425565232096`*^9, 3.4371426241169596`*^9}, {3.4371426728200846`*^9, 
   3.4371426764294596`*^9}, {3.4371429878825846`*^9, 
   3.4371429995700846`*^9}, {3.4371433825388346`*^9, 
   3.4371434745544596`*^9}, {3.437385849671875*^9, 3.437385872921875*^9}, {
   3.43738598790625*^9, 3.4373860106875*^9}, 3.437386097390625*^9, {
   3.43738622940625*^9, 3.437386231203125*^9}, {3.437386947203125*^9, 
   3.437387058*^9}, {3.437387436046875*^9, 3.437387456015625*^9}, {
   3.437392580125*^9, 3.437392594234375*^9}, {3.440138576453125*^9, 
   3.44013861534375*^9}, 3.440247340375*^9, 3.44025260609375*^9, {
   3.440252640046875*^9, 3.440252642578125*^9}, 3.440252683171875*^9, {
   3.440307363765625*^9, 3.440307366859375*^9}, {3.440307419421875*^9, 
   3.440307432703125*^9}, {3.4403076135*^9, 3.44030762003125*^9}, {
   3.4403081375625*^9, 3.440308142390625*^9}, {3.440315898234375*^9, 
   3.44031591959375*^9}, 3.440316207296875*^9, {3.440316501640625*^9, 
   3.44031652896875*^9}, {3.440316922453125*^9, 3.440316928015625*^9}, {
   3.44031704465625*^9, 3.440317061*^9}, {3.440317292*^9, 
   3.440317299703125*^9}, {3.4403173938125*^9, 3.44031740596875*^9}, {
   3.440317438046875*^9, 3.44031743853125*^9}, {3.440319625640625*^9, 
   3.4403196551875*^9}, 3.4403197451875*^9, {3.440320234078125*^9, 
   3.44032023959375*^9}, {3.44032038190625*^9, 3.440320428765625*^9}, {
   3.44032055328125*^9, 3.44032056753125*^9}, {3.44032060825*^9, 
   3.4403206395*^9}, {3.440320719703125*^9, 3.440320778125*^9}, {
   3.440320836015625*^9, 3.440320858546875*^9}, 3.44032088921875*^9, {
   3.440321150328125*^9, 3.4403212304375*^9}, {3.44032151984375*^9, 
   3.440321546984375*^9}, {3.440321868171875*^9, 3.4403218760625*^9}, {
   3.44032205065625*^9, 3.440322085890625*^9}, 3.440322579875*^9, {
   3.44032550809375*^9, 3.44032553296875*^9}, {3.440325960796875*^9, 
   3.440326044953125*^9}, {3.440326241515625*^9, 3.440326259953125*^9}, {
   3.440326290390625*^9, 3.44032629178125*^9}, {3.4403263333125*^9, 
   3.4403263365625*^9}, {3.44032637559375*^9, 3.440326388671875*^9}, {
   3.44032644221875*^9, 3.440326446515625*^9}, {3.440326500703125*^9, 
   3.44032657628125*^9}, 3.440326638859375*^9, {3.440326703109375*^9, 
   3.44032684084375*^9}, {3.440326977953125*^9, 3.44032701103125*^9}, 
   3.4403270490625*^9, {3.440327120890625*^9, 3.44032728934375*^9}, {
   3.440327327359375*^9, 3.44032740984375*^9}, {3.440327443140625*^9, 
   3.440327444265625*^9}, {3.440327476296875*^9, 3.440327683125*^9}, {
   3.440327739890625*^9, 3.440327741875*^9}, {3.440327834046875*^9, 
   3.440327836734375*^9}, 3.44032790553125*^9, {3.440327943671875*^9, 
   3.440328031828125*^9}, {3.440328064625*^9, 3.440328105390625*^9}, {
   3.4403282360625*^9, 3.440328242203125*^9}, {3.440328405171875*^9, 
   3.440328459828125*^9}, 3.440328579140625*^9, 3.44032861225*^9, 
   3.440328725171875*^9, {3.4403287580625*^9, 3.440328762*^9}, {
   3.440328793671875*^9, 3.440328802390625*^9}, 3.440328945734375*^9, {
   3.440329224328125*^9, 3.440329257609375*^9}, {3.440329404546875*^9, 
   3.440329421859375*^9}, {3.440329564515625*^9, 3.440329612171875*^9}, {
   3.44032972778125*^9, 3.440329776171875*^9}, {3.440329857421875*^9, 
   3.4403299195625*^9}, 3.44033072840625*^9, 3.440330841953125*^9, 
   3.440330899359375*^9, 3.440330938765625*^9, {3.440331054765625*^9, 
   3.440331080375*^9}, {3.440331753015625*^9, 3.4403318080625*^9}, {
   3.440332092609375*^9, 3.44033211521875*^9}, 3.440332265625*^9, {
   3.440332300578125*^9, 3.440332309171875*^9}, {3.44033262659375*^9, 
   3.440332687875*^9}, 3.44033273215625*^9, 3.440333059078125*^9, {
   3.4403331449375*^9, 3.440333146421875*^9}, {3.440333222328125*^9, 
   3.440333222609375*^9}, {3.443852101546875*^9, 3.44385220696875*^9}, {
   3.443852251921875*^9, 3.443852256140625*^9}, {3.443852369578125*^9, 
   3.443852373359375*^9}, {3.44385534025*^9, 3.443855359625*^9}, {
   3.443855617171875*^9, 3.44385563975*^9}, {3.443859134984375*^9, 
   3.443859136140625*^9}, {3.443859259328125*^9, 3.44385925996875*^9}, {
   3.443968217109375*^9, 3.44396821790625*^9}, {3.45489586259375*^9, 
   3.4548958674375*^9}, {3.454902779265625*^9, 3.454902932421875*^9}, {
   3.45490323915625*^9, 3.45490331303125*^9}, {3.454903588671875*^9, 
   3.45490361290625*^9}, {3.4549037541875*^9, 3.4549037730625*^9}, {
   3.45490382709375*^9, 3.454903829390625*^9}, {3.454903898734375*^9, 
   3.454903903875*^9}, {3.454904075859375*^9, 3.45490408540625*^9}, 
   3.45500320375*^9, 3.455024612609375*^9}],

Cell[BoxData[
 TagBox[
  StyleBox[
   DynamicModuleBox[{$CellContext`statuszeileZeigen$$ = "", Typeset`show$$ = 
    True, Typeset`bookmarkList$$ = {}, Typeset`bookmarkMode$$ = "Menu", 
    Typeset`animator$$, Typeset`animvar$$ = 1, Typeset`name$$ = 
    "\"untitled\"", Typeset`specs$$ = {{
      Hold[
       Dynamic[
        Roulette`makeStrategyButtons[True]]], 
      Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Style["Einstellungen", 12]], Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Style[
       "                                                                  "]],
       Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Dynamic[
        Roulette`makeCheckbox[
         Dynamic[Roulette`einsatzBleibtStehen], 
         "Eins\[ADoubleDot]tze stehen lassen", Enabled -> 
         And[Roulette`strategy == "Freies Spiel", Roulette`anzahlSpieleLog == 
           0]]]], Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Dynamic[
        Roulette`makeCheckbox[
         Dynamic[Roulette`ergebnisDialogZeigen], "Ergebnis anzeigen", Enabled -> 
         Roulette`anzahlSpieleLog == 0]]], 
      Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Style["\nAnzahl Spiele"]], Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Dynamic[
        Roulette`makeLogSlider[
         Dynamic[Roulette`anzahlSpieleLog]]]], 
      Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Dynamic[
        Roulette`makeCheckbox[
         Dynamic[$CellContext`histogrammZeigen], "Histogramm anzeigen"]]], 
      Manipulate`Dump`ThisIsNotAControl}, {
      Hold[
       Dynamic[
        Roulette`makeHistogramPanel[$CellContext`histogrammZeigen, 
         Roulette`updateTrigger], 
        TrackedSymbols :> {
         Roulette`updateTrigger, $CellContext`histogrammZeigen}]], 
      Manipulate`Dump`ThisIsNotAControl}, {{
       Hold[$CellContext`statuszeileZeigen$$], "", ""}, 
      Roulette`makeStatuszeile[#, 
       Dynamic[Roulette`statuszeile]]& }}, Typeset`size$$ = {
    378., {280.5, 285.5}}, Typeset`update$$ = 0, Typeset`initDone$$, 
    Typeset`skipInitDone$$ = False}, 
    DynamicBox[Manipulate`ManipulateBoxes[
     1, StandardForm, "Variables" :> {$CellContext`statuszeileZeigen$$ = ""}, 
      "ControllerVariables" :> {}, 
      "OtherVariables" :> {
       Typeset`show$$, Typeset`bookmarkList$$, Typeset`bookmarkMode$$, 
        Typeset`animator$$, Typeset`animvar$$, Typeset`name$$, 
        Typeset`specs$$, Typeset`size$$, Typeset`update$$, Typeset`initDone$$,
         Typeset`skipInitDone$$}, "Body" :> (Roulette`newGame[]; Panel[
         Row[{
           Column[{
             Grid[
              Join[
               Roulette`makeActionButtons[], 
               Roulette`makeButtonsSimpleChances[]]], 
             Roulette`makeHistoryPanel[]}], 
           Roulette`makeButtonsZero2ThirtySix[]}], Background -> 
         Roulette`darkGreen]), "Specifications" :> {
        Dynamic[
         Roulette`makeStrategyButtons[True]], Delimiter, 
        Style["Einstellungen", 12], 
        Style[
        "                                                                  "], 
        Dynamic[
         Roulette`makeCheckbox[
          Dynamic[Roulette`einsatzBleibtStehen], 
          "Eins\[ADoubleDot]tze stehen lassen", Enabled -> 
          And[Roulette`strategy == "Freies Spiel", Roulette`anzahlSpieleLog == 
            0]]], 
        Dynamic[
         Roulette`makeCheckbox[
          Dynamic[Roulette`ergebnisDialogZeigen], "Ergebnis anzeigen", 
          Enabled -> Roulette`anzahlSpieleLog == 0]], 
        Style["\nAnzahl Spiele"], 
        Dynamic[
         Roulette`makeLogSlider[
          Dynamic[Roulette`anzahlSpieleLog]]], Delimiter, 
        Dynamic[
         Roulette`makeCheckbox[
          Dynamic[$CellContext`histogrammZeigen], "Histogramm anzeigen"]], 
        Dynamic[
         Roulette`makeHistogramPanel[$CellContext`histogrammZeigen, 
          Roulette`updateTrigger], 
         TrackedSymbols :> {
          
          Roulette`updateTrigger, $CellContext`histogrammZeigen}], \
{{$CellContext`statuszeileZeigen$$, "", ""}, Roulette`makeStatuszeile[#, 
          Dynamic[Roulette`statuszeile]]& , ControlPlacement -> Bottom}}, 
      "Options" :> {FrameLabel -> {{"", ""}, {"", 
           Style["Casino Merseburg", 22, Bold]}}, ControlPlacement -> Right}, 
      "DefaultOptions" :> {}],
     ImageSizeCache->{640., {337., 342.}},
     SingleEvaluation->True],
    Deinitialization:>None,
    DynamicModuleValues:>{},
    Initialization:>({
      Roulette`newGame[] := 
       Module[{}, Roulette`clearBoard[]; Roulette`initAutomatischeSpiele[]; 
         Roulette`history = {0}; Roulette`einsatzSumme = 1; 
         Roulette`kassenstand = 0; Roulette`umsatz = 0; 
         Roulette`historyGewinnzahlen = {}; Roulette`statuszeile = ""; 
         Roulette`updateTrigger = 0; Null], Roulette`clearBoard[] := 
       Module[{Roulette`i}, 
         For[Roulette`i = 1, Roulette`i <= Length[Roulette`setzfelder], 
          Increment[Roulette`i], Part[Roulette`setzfelder, Roulette`i, 3] = 
          0]], Roulette`setzfelder = {{"Red", 1, 0}, {"Black", 1, 0}, {
         "1-18", 1, 0}, {"19-36", 1, 0}, {"Even", 1, 0}, {"Odd", 1, 0}, {
         "0", 35, 0}, {"1", 35, 0}, {"2", 35, 0}, {"3", 35, 0}, {
         "4", 35, 0}, {"5", 35, 0}, {"6", 35, 0}, {"7", 35, 0}, {
         "8", 35, 0}, {"9", 35, 0}, {"10", 35, 0}, {"11", 35, 0}, {
         "12", 35, 0}, {"13", 35, 0}, {"14", 35, 0}, {"15", 35, 0}, {
         "16", 35, 0}, {"17", 35, 0}, {"18", 35, 0}, {"19", 35, 0}, {
         "20", 35, 0}, {"21", 35, 0}, {"22", 35, 0}, {"23", 35, 0}, {
         "24", 35, 0}, {"25", 35, 0}, {"26", 35, 0}, {"27", 35, 0}, {
         "28", 35, 0}, {"29", 35, 0}, {"30", 35, 0}, {"31", 35, 0}, {
         "32", 35, 0}, {"33", 35, 0}, {"34", 35, 0}, {"35", 35, 0}, {
         "36", 35, 0}}, Roulette`initAutomatischeSpiele[] := 
       Module[{}, Roulette`initMartingale[]; Roulette`initMontante[]; 
         Roulette`initFitzroy[]; Roulette`initParoli[]; Null], 
       Roulette`initMartingale[] := (Roulette`parameterMartingale = {
          RandomInteger[{1, 6}], 0}), 
       Roulette`initMontante[] := (Roulette`parameterMontante = {
          RandomInteger[{1, 6}], {1, 2, 3, 4}}), 
       Roulette`initFitzroy[] := (Roulette`parameterFitzroy = {
          RandomInteger[{1, 6}], 0, 0}), 
       Roulette`initParoli[] := (Roulette`parameterParoli = {
          RandomInteger[{1, 6}], 0}), Roulette`einsatzSumme = 1, 
       Roulette`makeActionButtons[] := 
       Module[{Roulette`i = 1}, 
         Roulette`actions = {{"Clear\nBoard", Roulette`clearBoard}, {
            "New\nGame", Roulette`newGame}, {
            "Change\nBet", Roulette`changeBet}, {"Play", Roulette`play}}; 
         Table[
           Roulette`actionButton[
            Part[Roulette`actions, 
             Increment[Roulette`i]]], {2}, {2}]], Roulette`changeBet[] := 
       Module[{}, SetSelectedNotebook[Roulette`dlgEinsatz]; 
         If[SelectedNotebook[] == Roulette`dlgEinsatz, 
           Return[]]; Roulette`dlgEinsatz = Roulette`createDialogEinsatz[]; 
         SetOptions[Roulette`dlgEinsatz, WindowFrame -> "ModalDialog"]; Null],
        Roulette`createDialogEinsatz[] := 
       Module[{Roulette`number = 1, Roulette`button, Roulette`clearButton, 
          Roulette`backspaceButton, Roulette`digits2number, 
          Roulette`digits = {}}, If[
           NumberQ[Roulette`einsatzSumme], Roulette`digits = 
           IntegerDigits[Roulette`einsatzSumme]]; Roulette`button[
            Pattern[Roulette`i, 
             Blank[]]] := Button[Roulette`i, 
            If[
             And[
              Or[Length[Roulette`digits] > 0, Roulette`i > 0], 
              Length[Roulette`digits] < 6], 
             AppendTo[Roulette`digits, Roulette`i]; 
             Roulette`einsatzSumme = Roulette`digits2number[]], 
            ImageSize -> {40, 40}]; Roulette`digits2number[] := Apply[Plus, 
            Table[
            Part[Roulette`digits, Roulette`i] 
             10^(Length[Roulette`digits] - Roulette`i), {Roulette`i, 
              Length[Roulette`digits]}]]; 
         Roulette`clearButton = 
          Button["C", Roulette`digits = {}; 
            Roulette`einsatzSumme = Roulette`digits2number[]]; 
         Roulette`backspaceButton = Button["\[LeftArrow]", 
            If[
            Length[Roulette`digits] > 0, 
             Roulette`digits = Delete[Roulette`digits, -1]; 
             Roulette`einsatzSumme = Roulette`digits2number[]]]; CreateDialog[
           Column[{
             Grid[
              Join[
               Table[
                Roulette`button[
                 Increment[Roulette`number]], {3}, {3}], {{
                Roulette`clearButton, 
                 Roulette`button[0], Roulette`backspaceButton}}]], 
             Row[{"Einsatz: ", 
               Dynamic[
                Refresh[
                Roulette`einsatzSumme, TrackedSymbols -> {Roulette`digits}, 
                 UpdateInterval -> 0.1]]}], 
             DefaultButton[]}], WindowTitle -> "Einsatz"]], Roulette`play[] := 
       Module[{Roulette`i, Roulette`anzahlSpiele}, 
         Roulette`anzahlSpiele = Roulette`log2Int[Roulette`anzahlSpieleLog]; 
         For[Roulette`i = 1, Roulette`i <= Roulette`anzahlSpiele, 
           Increment[Roulette`i], 
           Roulette`gewinnZahl = RandomInteger[{0, 36}]; 
           Roulette`setzeAutomatisch[]; Roulette`spielschrittAutomatisch[]; If[
             And[Roulette`anzahlSpiele == 1, Roulette`ergebnisDialogZeigen], 
             Roulette`createDialogResult[Roulette`gewinnZahl]]; 
           AddTo[Roulette`kassenstand, 
             Roulette`auszahlung[Roulette`gewinnZahl]]; 
           AppendTo[Roulette`history, Roulette`kassenstand]; 
           AppendTo[Roulette`historyGewinnzahlen, Roulette`gewinnZahl]; If[
             And[Roulette`anzahlSpiele == 1, 
              Not[Roulette`einsatzBleibtStehen]], 
             Roulette`clearBoard[]]; Roulette`setzeAutomatisch[]; Null]; 
         Increment[Roulette`updateTrigger]; Null], Roulette`log2Int[
         Pattern[Roulette`nLog, 
          Blank[]], 
         Pattern[Roulette`nMax, 
          Blank[]]] := Floor[
         Exp[Roulette`nLog Log[Roulette`nMax]]], Roulette`log2Int[
         Pattern[Roulette`nLog, 
          Blank[]]] := Roulette`log2Int[Roulette`nLog, Roulette`nMax], 
       Roulette`nMax = 10000, Roulette`setzeAutomatisch[] := 
       Module[{}, If[Roulette`strategy == Part[Roulette`strategieNamen, 2], 
           Roulette`setzeMartingale[]]; 
         If[Roulette`strategy == Part[Roulette`strategieNamen, 3], 
           Roulette`setzeMontante[]]; 
         If[Roulette`strategy == Part[Roulette`strategieNamen, 4], 
           Roulette`setzeFitzroy[]]; 
         If[Roulette`strategy == Part[Roulette`strategieNamen, 5], 
           Roulette`setzeParoli[]]], Roulette`strategy = "Freies Spiel", 
       Roulette`strategieNamen = {
        "Freies Spiel", "Martingale", "Montante", "Fitzroy", "Paroli"}, 
       Roulette`setzeMartingale[] := 
       Module[{Roulette`angriffsfarbeIndex = 
          Part[Roulette`parameterMartingale, 1]}, 
         Roulette`setze[Roulette`angriffsfarbeIndex, 
           Roulette`einsatzMartingale[]]; Null], Roulette`setze[
         Pattern[Roulette`feldindex, 
          Blank[]], 
         Pattern[Roulette`summe, 
          Blank[]]] := 
       Module[{}, 
         If[Roulette`feldindex <= 6, Roulette`h\[ODoubleDot]chsteinsatz = 
           12000, Roulette`h\[ODoubleDot]chsteinsatz = 350]; 
         Part[Roulette`setzfelder, Roulette`feldindex, 3] = 
          Min[Roulette`summe, Roulette`h\[ODoubleDot]chsteinsatz]; 
         If[Roulette`summe > Roulette`h\[ODoubleDot]chsteinsatz, 
           Roulette`statuszeile = 
           StringJoin["Gew\[UDoubleDot]nschter Einsatz von ", 
             ToString[Roulette`summe], " ist \[UDoubleDot]ber dem Limit ", 
             ToString[Roulette`h\[ODoubleDot]chsteinsatz]]]], 
       Roulette`einsatzMartingale[] := 
       Module[{Roulette`einsatz, Roulette`anzVerloren = 
          Part[Roulette`parameterMartingale, 2], 
          Roulette`h\[ODoubleDot]chsteinsatz = 12000}, Roulette`einsatz = 
         Roulette`einsatzSumme 2^Roulette`anzVerloren], 
       Roulette`setzeMontante[] := 
       Module[{Roulette`einsatzListe = Part[Roulette`parameterMontante, 2], 
          Roulette`angriffsfarbeIndex = Part[Roulette`parameterMontante, 1], 
          Roulette`verbose = False}, Roulette`clearBoard[]; 
         Roulette`setze[Roulette`angriffsfarbeIndex, 
           Roulette`einsatzMontante[]]; Null], Roulette`einsatzMontante[] := 
       Module[{Roulette`einsatz, Roulette`einsatzListe = 
          Part[Roulette`parameterMontante, 2], 
          Roulette`h\[ODoubleDot]chsteinsatz = 12000, Roulette`verbose = 
          False}, Roulette`einsatz = 
          Roulette`einsatzSumme First[Roulette`einsatzListe]; 
         If[Length[Roulette`einsatzListe] > 1, 
           AddTo[Roulette`einsatz, 
            Last[Roulette`einsatzListe]], Roulette`einsatz]], 
       Roulette`setzeFitzroy[] := 
       Module[{Roulette`angriffsFarbeindex = 
          Part[Roulette`parameterFitzroy, 1]}, Roulette`clearBoard; 
         Roulette`setze[Roulette`angriffsFarbeindex, 
           Roulette`einsatzFitzroy[]]], Roulette`einsatzFitzroy[] := 
       Module[{Roulette`einsatz, Roulette`anzSpiele = 
          Part[Roulette`parameterFitzroy, 2]}, Roulette`einsatz = 
         Roulette`einsatzSumme (1 + Roulette`anzSpiele)], 
       Roulette`setzeParoli[] := 
       Module[{Roulette`angriffsfarbeIndex = 
          Part[Roulette`parameterParoli, 1]}, 
         Roulette`setze[Roulette`angriffsfarbeIndex, 
           Roulette`einsatzParoli[]]; Null], Roulette`einsatzParoli[] := 
       Module[{Roulette`einsatz, Roulette`anzGewinne = 
          Part[Roulette`parameterParoli, 2]}, Roulette`einsatz = 
         Roulette`einsatzSumme 2^Roulette`anzGewinne], 
       Roulette`spielschrittAutomatisch[] := 
       Module[{}, If[Roulette`strategy == Part[Roulette`strategieNamen, 2], 
           Roulette`spielschrittMartingale[]]; 
         If[Roulette`strategy == Part[Roulette`strategieNamen, 3], 
           Roulette`spielschrittMontante[]]; 
         If[Roulette`strategy == Part[Roulette`strategieNamen, 4], 
           Roulette`spielschrittFitzroy[]]; 
         If[Roulette`strategy == Part[Roulette`strategieNamen, 5], 
           Roulette`spielschrittParoli[]]], Roulette`spielschrittMartingale[] := 
       Module[{Roulette`angriffsfarbeIndex = 
          Part[Roulette`parameterMartingale, 1], Roulette`anzVerluste = 
          Part[Roulette`parameterMartingale, 2]}, If[
           Roulette`hatGewonnen[Roulette`gewinnZahl, 
            Part[Roulette`setzfelder, Roulette`angriffsfarbeIndex, 1]], 
           Roulette`anzVerluste = 0, 
           Increment[Roulette`anzVerluste]]; 
         Part[Roulette`parameterMartingale, 2] = Roulette`anzVerluste; Null], 
       Roulette`hatGewonnen[
         Pattern[Roulette`zahl, 
          Blank[]], 
         Pattern[Roulette`feld, 
          Blank[]]] := Module[{Roulette`i}, If[Roulette`feld == "Red", 
           Return[
            Roulette`isRed[Roulette`zahl]]]; If[Roulette`feld == "Black", 
           Return[
            Roulette`isBlack[Roulette`zahl]]]; If[Roulette`feld == "1-18", 
           Return[
            Roulette`isLow[Roulette`zahl]]]; If[Roulette`feld == "19-36", 
           Return[
            Roulette`isHigh[Roulette`zahl]]]; If[Roulette`feld == "Even", 
           Return[
            Roulette`isEven[Roulette`zahl]]]; If[Roulette`feld == "Odd", 
           Return[
            Roulette`isOdd[Roulette`zahl]]]; 
         Return[Roulette`feld == ToString[Roulette`zahl]]], Roulette`isRed[
         Pattern[Roulette`n, 
          Blank[Integer]]] := 
       Module[{Roulette`listeRot = {1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23,
            25, 27, 30, 32, 34, 36}}, Length[
           Select[Roulette`listeRot, Roulette`n == #& , 1]] == 1], 
       Roulette`isBlack[
         Pattern[Roulette`n, 
          Blank[Integer]]] := And[
         Not[
          Roulette`isRed[Roulette`n]], Roulette`n != 0], Roulette`isLow[
         Pattern[Roulette`n, 
          Blank[Integer]]] := 1 <= Roulette`n <= 18, Roulette`isHigh[
         Pattern[Roulette`n, 
          Blank[Integer]]] := 19 <= Roulette`n <= 36, Roulette`isEven[
         Pattern[Roulette`n, 
          Blank[Integer]]] := And[
         EvenQ[Roulette`n], Roulette`n != 0], Roulette`isOdd[
         Pattern[Roulette`n, 
          Blank[Integer]]] := OddQ[Roulette`n], 
       Roulette`spielschrittMontante[] := 
       Module[{Roulette`einsatzListe = Part[Roulette`parameterMontante, 2], 
          Roulette`angriffsfarbeIndex = Part[Roulette`parameterMontante, 1]}, 
         If[
           Roulette`hatGewonnen[Roulette`gewinnZahl, 
            Part[Roulette`setzfelder, Roulette`angriffsfarbeIndex, 1]], 
           If[
           Length[Roulette`einsatzListe] <= 2, Roulette`initMontante[]; 
            Roulette`einsatzListe = Part[Roulette`parameterMontante, 2], 
            Roulette`einsatzListe = Drop[
              Drop[Roulette`einsatzListe, 1], -1]], Roulette`einsatzListe = 
           Append[Roulette`einsatzListe, 
             Roulette`einsatzMontante[]]]; 
         Part[Roulette`parameterMontante, 2] = Roulette`einsatzListe; Null], 
       Roulette`spielschrittFitzroy[] := 
       Module[{Roulette`angriffsfarbeIndex = 
          Part[Roulette`parameterFitzroy, 1], Roulette`anzSpiele = 
          Part[Roulette`parameterFitzroy, 2], Roulette`saldo = 
          Part[Roulette`parameterFitzroy, 3]}, 
         Part[Roulette`parameterFitzroy, 2] = 
          PreIncrement[Roulette`anzSpiele]; If[
           Roulette`hatGewonnen[Roulette`gewinnZahl, 
            Part[Roulette`setzfelder, Roulette`angriffsfarbeIndex, 1]], 
           AddTo[Roulette`saldo, Roulette`anzSpiele], 
           SubtractFrom[Roulette`saldo, Roulette`anzSpiele]]; 
         If[Roulette`saldo > 0, Part[Roulette`parameterFitzroy, 3] = 0, 
           Part[Roulette`parameterFitzroy, 3] = Roulette`saldo]; 
         If[Roulette`saldo > 0, Part[Roulette`parameterFitzroy, 2] = 0]; 
         Null], Roulette`spielschrittParoli[] := 
       Module[{Roulette`angriffsfarbeIndex = 
          Part[Roulette`parameterParoli, 1], Roulette`anzGewinne = 
          Part[Roulette`parameterParoli, 2], Roulette`maxAnzGewinne = 5}, If[
           Roulette`hatGewonnen[Roulette`gewinnZahl, 
            Part[Roulette`setzfelder, Roulette`angriffsfarbeIndex, 1]], 
           If[
           Roulette`anzGewinne >= Roulette`maxAnzGewinne, Roulette`anzGewinne = 
            0, 
            Increment[Roulette`anzGewinne]], Roulette`anzGewinne = 0]; 
         Part[Roulette`parameterParoli, 2] = Roulette`anzGewinne; Null], 
       Roulette`createDialogResult[
         Pattern[Roulette`gewinnZahl, 
          Blank[]]] := 
       Module[{Roulette`colorString, Roulette`ergebnistext}, If[
           Roulette`isRed[Roulette`gewinnZahl], Roulette`colorString = 
           "rote ", Roulette`colorString = "schwarze "]; 
         If[Roulette`gewinnZahl == 0, Roulette`colorString = ""]; 
         Roulette`ergebnistext = 
          StringJoin["Es kam die ", Roulette`colorString, 
            ToString[Roulette`gewinnZahl], ". Ihr Ergebnis: ", 
            ToString[
             Roulette`auszahlung[Roulette`gewinnZahl]]]; 
         NotebookClose[Roulette`dialogResult]; 
         Roulette`dialogResult = CreateDialog[{
             TextCell[Roulette`ergebnistext], 
             DefaultButton[]}, 
            WindowMargins -> {{Automatic, Automatic}, {Automatic, 200}}, 
            Modal -> True]; Null], Roulette`auszahlung[
         Pattern[Roulette`zahl, 
          Blank[]]] := 
       Module[{Roulette`gewinn = 0, Roulette`i}, 
         For[Roulette`i = 1, Roulette`i <= Length[Roulette`setzfelder], 
           Increment[Roulette`i], AddTo[Roulette`umsatz, 
             Part[Roulette`setzfelder, Roulette`i, 3]]; If[
             Roulette`hatGewonnen[Roulette`zahl, 
              Part[Roulette`setzfelder, Roulette`i, 1]], 
             AddTo[
             Roulette`gewinn, Part[Roulette`setzfelder, Roulette`i, 2] 
              Part[Roulette`setzfelder, Roulette`i, 3]], 
             SubtractFrom[Roulette`gewinn, 
              Part[Roulette`setzfelder, Roulette`i, 3]]]]; Roulette`gewinn], 
       Roulette`actionButton[{
          Pattern[Roulette`text, 
           Blank[]], 
          Pattern[Roulette`action, 
           Blank[]]}] := Button[
         Style[Roulette`text, 15, Bold], 
         Roulette`action[], ImageSize -> {77, 77}, Method -> "Queued"], 
       Roulette`makeButtonsSimpleChances[] := Module[{Roulette`i = 1}, 
         Table[
          Roulette`bigButton[
           Increment[Roulette`i]], {3}, {2}]], Roulette`bigButton[
         Pattern[Roulette`index, 
          Blank[]]] := 
       DynamicModule[{
         Roulette`chipCoords = {0, -0.4}, Roulette`labelCoords = {0, 0.2}, 
          Roulette`discsize = 0.4, Roulette`textsize = 20}, 
         Button[
          Dynamic[
           Graphics[{
             Text[
              Style[
               Part[Roulette`setzfelder, Roulette`index, 1], 25], 
              Roulette`labelCoords], 
             Roulette`makeChip[
             Roulette`index, {Roulette`chipCoords, Roulette`discsize}, 
              Roulette`textsize]}, ImageSize -> {70, 70}, Background -> 
            Roulette`darkGreen, PlotRange -> {{-1, 1}, {-1, 1}}]], 
          Roulette`toggleEinsatz[Roulette`index]]], Roulette`makeChip[
         Pattern[Roulette`index, 
          Blank[]], {{
           Pattern[Roulette`x, 
            Blank[]], 
           Pattern[Roulette`y, 
            Blank[]]}, 
          Pattern[Roulette`discsize, 
           Blank[]]}, 
         Pattern[Roulette`textsize, 
          Blank[]]] := 
       If[Part[Roulette`setzfelder, Roulette`index, 3] == 0, {}, {White, 
          Disk[{Roulette`x, Roulette`y}, Roulette`discsize], Black, 
          Text[
           Style[
            ToString[
             Part[Roulette`setzfelder, Roulette`index, 3]], 
            Roulette`textsize], {Roulette`x, Roulette`y}]}], 
       Roulette`darkGreen = RGBColor[0, 0.4, 0], Roulette`toggleEinsatz[
         Pattern[Roulette`index, 
          Blank[]]] := Module[{}, If[Roulette`einsatzSumme == 0, CreateDialog[{
              TextCell["Sie m\[UDoubleDot]ssen einen Einsatz festlegen"], 
              DefaultButton[]}, 
             WindowMargins -> {{Automatic, Automatic}, {Automatic, 200}}, 
             Modal -> True]; Roulette`changeBet[]; Return[]]; 
         If[Part[Roulette`setzfelder, Roulette`index, 3] == 0, 
           Part[Roulette`setzfelder, Roulette`index, 3] = 
           Roulette`einsatzSumme, 
           Part[Roulette`setzfelder, Roulette`index, 3] = 0]], 
       Roulette`makeHistoryPanel[] := 
       Module[{Roulette`i = 1, Roulette`plotLabel, Roulette`plotRange, 
          Roulette`kassenstandRelativ, Roulette`xList, Roulette`yMin, 
          Roulette`yMax, Roulette`yRange, Roulette`xText, 
          Roulette`xTextCoords}, 
         Dynamic[{Roulette`yMin, Roulette`yMax} = {
             Min[Roulette`history], 
             Max[Roulette`history]}; 
          Roulette`yRange = Roulette`yMax - Roulette`yMin; 
          Roulette`xList = If[Length[Roulette`history] > 1000, Range[
               Length[Roulette`history]]/1000, 
             Range[
              Length[Roulette`history]]]; 
          Roulette`kassenstandRelativ = If[Roulette`umsatz > 0, 
             N[Round[(1000 Roulette`kassenstand)/Roulette`umsatz]/10], 0]; 
          Roulette`plotLabel = Style[
             StringJoin["Gewinn: ", 
              ToString[Roulette`kassenstandRelativ], "% v. Umsatz"], 
             Roulette`darkGreen]; Roulette`plotRange = {Min[Roulette`yMin, 
               Part[Roulette`xTextCoords, 2]] - Roulette`yRange/7, 
             Roulette`yMax}; 
          Roulette`xText = If[Length[Roulette`history] > 1000, "x 1000", ""]; 
          Roulette`xTextCoords = {
            0.5 Last[Roulette`xList], (-0.5) Roulette`yRange}; Panel[
            ListPlot[
             Transpose[{Roulette`xList, Roulette`history}], 
             ImageSize -> {145, 110}, Joined -> True, PlotLabel -> 
             Roulette`plotLabel, PlotRange -> Roulette`plotRange, 
             AxesOrigin -> {0, Automatic}, AspectRatio -> 0.7, Epilog -> 
             Text[Roulette`xText, Roulette`xTextCoords]]]]], 
       Roulette`makeButtonsZero2ThirtySix[] := 
       Module[{Roulette`i = 8, Roulette`buttonsOne2ThirtySix, 
          Roulette`buttonZero}, Roulette`buttonsOne2ThirtySix = Table[
            Roulette`smallButton[
             Increment[Roulette`i]], {12}, {3}]; Roulette`buttonZero = {{"", 
             Roulette`smallButton[7], ""}}; Grid[
           Join[Roulette`buttonZero, Roulette`buttonsOne2ThirtySix]]], 
       Roulette`smallButton[
         Pattern[Roulette`index, 
          Blank[]]] := 
       DynamicModule[{
         Roulette`number, Roulette`numberString, Roulette`textColor, 
          Roulette`chipCoords = {0, 0}, Roulette`labelCoords = {0, 0}, 
          Roulette`discsize = 0.5, Roulette`textsize = 15}, 
         Roulette`numberString = Part[Roulette`setzfelder, Roulette`index, 1]; 
         Roulette`number = ToExpression[Roulette`numberString]; If[
           Roulette`isRed[Roulette`number], Roulette`textColor = Red, 
           Roulette`textColor = Black]; 
         If[Roulette`number == 0, Roulette`textColor = Green]; Button[
           Dynamic[
            Graphics[{
              Text[
               Style[Roulette`numberString, Roulette`textColor, 30], {0, 0}], 
              Roulette`makeChip[
              Roulette`index, {Roulette`chipCoords, Roulette`discsize}, 
               Roulette`textsize]}, ImageSize -> {50, 30}, Background -> 
             Roulette`darkGreen, PlotRange -> {{-1, 1}, {-1, 1}}]], 
           Roulette`toggleEinsatz[Roulette`index]]], 
       Roulette`makeStrategyButtons[
         Pattern[Roulette`dummy, 
          Blank[]]] := Dynamic[
         TableForm[
          MapThread[Button[
            Tooltip[#2, #3], Roulette`strategy = #, ImageSize -> 100]& , {
           Roulette`strategieNamen, 
            Map[Roulette`boldIfChosen, Roulette`strategieNamen], 
            Roulette`strategieHilfetexte}]]], Roulette`boldIfChosen = Style[#, 
         If[Roulette`strategy == #, Bold, Plain, Italic]]& , 
       Roulette`strategieHilfetexte = {
        "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.", 
         "Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die\n\nAls \
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.\n\nDie 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.\n\nDer \
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.\n\nVerliert 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.", "Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die\n\nDie 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.\n\nVor Beginn seines Angriffs auf die Spielbank \
schreibt der Spieler die Zahlen\n\n1 \[Dash] 2 \[Dash] 3 \[Dash] 4\n\nauf \
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\n\n(1) \[Dash] 2 \[Dash] 3 \[Dash] (4).\n\nNun 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\n\n(1) \[Dash] 2 \[Dash] 3 \[Dash] (4) \[Dash] \
5.\n\nIm n\[ADoubleDot]chsten Coup sind daher 2 + 5 = 7 Einheiten zu setzen; \
wird dieser Coup gewonnen, so setzt der Spieler danach 3 Einheiten; usf.\n\n\
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.\n\nDie 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.", 
         "Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die\n\nDas \
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.\n\nIn \
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.\n\nSobald 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.\n\nVerliert 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.", 
         "Aus Wikipedia, der freien Enzyklop\[ADoubleDot]die\n\nIm 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.\n\nDer 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).\n\nGewinnt 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.\n\nVerliert er aber einen Coup, \
bevor das Ziel erreicht ist, so beginnt er einen neuen Angriff mit einer \
Einheit."}, Roulette`makeCheckbox[
         Pattern[Roulette`var, 
          Blank[]], 
         Pattern[Roulette`txt, 
          Blank[]], 
         Pattern[Roulette`opts, 
          BlankNullSequence[]]] := Grid[{{
           Checkbox[Roulette`var, Roulette`opts], Roulette`txt}}, Spacings -> 
         1], Roulette`makeLogSlider[
         Pattern[Roulette`var, 
          Blank[]]] := Grid[{{
           Slider[Roulette`var, ImageSize -> Small], 
           Style[
            Dynamic[
             ToString[
              Roulette`log2Int[
               ReplaceAll[Roulette`var, Pattern[Roulette`a, 
                  Blank[]][
                  Pattern[Roulette`b, 
                   Blank[]]] :> Roulette`b]]]], Bold]}}, Spacings -> 1], 
       Roulette`makeHistogramPanel[
         Pattern[Roulette`switch, 
          Blank[]], 
         Pattern[Roulette`dummy, 
          Blank[]]] := Module[{}, 
         If[Roulette`switch, 
          Panel[
           Histogram[Roulette`historyGewinnzahlen, {-0.5, 36.5, 1}, Ticks -> {
              Range[0, 36, 3], Automatic}, ChartElementFunction -> 
            "FadingRectangle", ChartStyle -> Orange, ImageSize -> {180, 180}, 
            Epilog -> First[
              Plot[
              Length[Roulette`historyGewinnzahlen]/37, {
               Roulette`x, -0.5, 36.5}, PlotStyle -> Red]]]], ""]], 
       Roulette`makeStatuszeile[
         Pattern[Roulette`dummy, 
          Blank[]], 
         Pattern[Roulette`text, 
          Blank[]]] := Style[Roulette`text, Bold, Red]}; 
     Typeset`initDone$$ = True),
    SynchronousInitialization->True,
    UnsavedVariables:>{Typeset`initDone$$},
    UntrackedVariables:>{Typeset`size$$}], "Manipulate",
   Deployed->True,
   StripOnInput->False],
  Manipulate`InterpretManipulate[1]]], "Output",
 CellChangeTimes->{3.4550246295625*^9}]
}, {2}]],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Grid", "[", "\[IndentingNewLine]", " ", 
  RowBox[{"{", "\[IndentingNewLine]", 
   RowBox[{
    RowBox[{"{", 
     RowBox[{"Style", "[", 
      RowBox[{"\"\<\>\"", ",", "500"}], "]"}], "}"}], ",", 
    "\[IndentingNewLine]", 
    RowBox[{"{", 
     RowBox[{
      RowBox[{"Spacer", "[", "250", "]"}], ",", 
      RowBox[{"Button", "[", 
       RowBox[{
       "\"\<\\n  Zur\[UDoubleDot]ck zum Hauptmen\[UDoubleDot]  \\n\>\"", ",", 
        RowBox[{"NotebookClose", "[", 
         RowBox[{"EvaluationNotebook", "[", "]"}], "]"}]}], "]"}]}], "}"}]}], 
   "\[IndentingNewLine]", "}"}], "\[IndentingNewLine]", "]"}]], "Input",
 CellChangeTimes->{{3.443860065046875*^9, 3.44386011659375*^9}, {
   3.44386017690625*^9, 3.4438601875*^9}, 3.44386039296875*^9, {
   3.4549064626875*^9, 3.454906494390625*^9}, {3.454906832453125*^9, 
   3.454906841046875*^9}, 3.45490694025*^9, {3.454906971484375*^9, 
   3.454906984390625*^9}, {3.454907073390625*^9, 3.4549071430625*^9}, {
   3.454936546765625*^9, 3.45493656734375*^9}, {3.454936627921875*^9, 
   3.454936690421875*^9}, {3.45493673790625*^9, 3.454936784140625*^9}}],

Cell[BoxData[
 TagBox[GridBox[{
    {
     StyleBox["\<\"\"\>",
      StripOnInput->False,
      FontSize->500], ""},
    {
     InterpretationBox[
      StyleBox[
       GraphicsBox[{},
        BaselinePosition->Baseline,
        ImageSize->{250, 0}],
       CacheGraphics->False],
      Spacer[250]], 
     ButtonBox["\<\"\\n  Zur\[UDoubleDot]ck zum Hauptmen\[UDoubleDot]  \
\\n\"\>",
      Appearance->Automatic,
      ButtonFunction:>NotebookClose[
        EvaluationNotebook[]],
      Evaluator->Automatic,
      Method->"Preemptive"]}
   },
   AutoDelete->False,
   GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}],
  "Grid"]], "Output",
 CellChangeTimes->{3.45502462971875*^9}]
}, {2}]]
},
AutoGeneratedPackage->None,
WindowSize->{957, 1103},
WindowMargins->{{61, Automatic}, {Automatic, 14}},
WindowFrame->"Normal",
Visible->True,
ScrollingOptions->{"VerticalScrollRange"->Fit},
ShowCellBracket->True,
$CellContext`WidowSize -> Full,
FrontEndVersion->"7.0 for Microsoft Windows (32-bit) (February 18, 2009)",
StyleDefinitions->"Default.nb"
]
(* End of Notebook Content *)

(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{}
*)
(*CellTagsIndex
CellTagsIndex->{}
*)
(*NotebookFileOutline
Notebook[{
Cell[CellGroupData[{
Cell[567, 22, 11002, 199, 652, "Input"],
Cell[11572, 223, 33668, 648, 696, "Output"]
}, {2}]],
Cell[CellGroupData[{
Cell[45274, 876, 1130, 23, 132, "Input"],
Cell[46407, 901, 707, 25, 291, "Output"]
}, {2}]]
}
]
*)

(* End of internal cache information *)
