Sleeper Wheel Sections v3

Contenuto del file

system "Sleeper Wheel Sections v3"
{
*************************************
*      System by Turbo Genius       *
*        on the VIP Lounge          *
*************************************
    Sun Aug 07, 2005 12:53 am
        Rx-ed by St0rm0r

We track the last 37 spins at all times.
The bet is placed on the largest group(s) of side by side sleepers on the
wheel layout (not table) until a win.
The unit size is the amount just enough to generate a profit on the next spin.
After a win on any played number - we go back to our chart and find the
new section to play, based on it being the largest group of sleepers side by side.
If there is a tie - we play them all (numbers in both groups)
but only with the unit size of one group.

00 wheel: we track the last 38 spins}
method "main"
begin
while starting new session
    begin
    call "init"
    exit
    end


if record"loss"data >= record"stop loss"data
    begin
    call "reset"
    end

if net > 0
    begin
    call "reset"
    end

track last number for record"amount"data times record"last spin"layout
if record"last spin"layout count < record"amount"data
    begin
    exit
    end
if flag "qualify" false
begin
duplicate record"last spin" in record"37 spins"
call "determine all gaps"
call "determine biggest gap"
    if record"biggest gap"data > record"play when"data
        begin
        set flag "qualify" true
        end
end

if flag "qualify" true
    begin
    //bet
    call "bet"
    end
end

method "init"
begin
group
    begin
    display "Turbo Genius Sleeper Wheel Sections"
    input dropdown "Wheel type:
    1:= single wheel
    2:= double wheel" to record"wheel type"data
    input data "Betting unit" to record"betting unit"data
    input dropdown "Play largest group:
    0:= always
    1:= when bigger then 1
    2:= when bigger then 2
    3:= when bigger then 3
    4:= when bigger then 4
    5:= when bigger then 5
    6:= when bigger then 6
    7:= when bigger then 7
    8:= when bigger then 8
    9:= when bigger then 9
    10:= when bigger then 10
    11:= when bigger then 11
    12:= when bigger then 12
    13:= when bigger then 13
    14:= when bigger then 14
    15:= when bigger then 15
    16:= when bigger then 16
    17:= when bigger then 17
    18:= when bigger then 18" to record"play when"data
    input data "stop loss:" to record"stop loss"data
    end
if record"wheel type"data = 1
    begin
    load single wheel
    copy list [number 0,number 32,number 15,number 19,number 4,number 21,
    number 2,number 25,number 17,number 34,number 6,number 27,number 13,
    number 36,number 11,number 30,number 8,number 23,number 10,number 5,
    number 24,number 16, number 33,number 1,number 20,number 14,number 31,
    number 9,number 22,number 18,number 29,number 7,number 28,number 12,
    number 35,number 3, number 26] to record"wheel"layout
    put 37 in record"amount"data
    put 38 in record"amount+1"data
    end
    else
    begin
    load double wheel
    copy list [number 00,number 27,number 10,number 25,number 29,number 12,
    number 8,number 19,number 31,number 18,number 6,number 21,number 33,
    number 16,number 4,number 23,number 35,number 14,number 2,number 0,
    number 28,number 9, number 26,number 30,number 11,number 7,number 20,
    number 32,number 17,number 5,number 22,number 34,number 15,number 3,
    number 24,number 36, number 13, number 1] to record"wheel"layout
    put 38 in record"amount"data
    put 39 in record"amount+1"data
    end
call "reset"
end

method "reset"
begin
set flag "qualify" false
if record"wheel type"data = 1
    begin
    set list [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0] to record"gaps"data
    end
    else
    begin
    set list [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0] to record"gaps"data
    end
clear record"n1"data
clear record"n2"data
clear record"start point"data
clear record"gap start index"data
clear record"count"data
clear record"counter"data
clear record"biggest gap"data
put 0 record"loss"data
end

method "determine all gaps"
begin
put 0 record"count"data
// go to start point
put 1 record"wheel"layout index
loop until record"wheel"layout is found in record"37 spins"layout
    begin
    add 1 record"wheel"layout index
    end
copy record"wheel"layout to record"start point"layout
put 100% record"wheel"layout index in record"gap start index"data
// determine all gaps
add 1 record"wheel"layout index
loop until record"wheel"layout = record"start point"layout
    begin
    put 100% record"wheel"layout index in record"gaps"data index
    if record"wheel"layout is found in record"37 spins"layout
        begin
        put 0 record"gaps"data
        put 0 record"count"data
        end
        else
        begin
        add 1 to record"count"data
        put 100% record"count"data in record"gaps"data
        end
    add 1 record"wheel"layout index
    if record"wheel"layout index > record"wheel"layout count
        begin
        put 1 record"wheel"layout index
        end
    end
put 100% record"gap start index"data in record"gaps"data index
put 0 record"counter"data
loop until record"counter"data = record"amount"data
    begin
    put 100% of record"gaps"data in record"n1"data
    add 1 record"gaps"data index
        if record"gaps"data index = record"amount+1"data
            begin
            put 1 record"gaps"data index
            end
    put 100% of record"gaps"data in record"n2"data
    subtract 1 record"gaps"data index
    if record"gaps"data index = 0
        begin
        put 100% record"amount"data record"gaps"data index
        end
    if record"n2"data > record"n1"data
        begin
        if record"n1"data not = 0
            begin
            put 100% record"n2"data in record"gaps"data
            end
        end
    subtract 1 record"gaps"data index
    if record"gaps"data index = 0
        begin
        put 100% record"amount"data record"gaps"data index
        end
    add 1 record"counter"data
    end
end

method "determine biggest gap"
begin
put 0 record"biggest gap"data
put 1 record"gaps"data index
loop until record"gaps"data index > record"gaps"data count
    begin
    if record"gaps"data > record"biggest gap"data
        begin
        put 100% record"gaps"data in record"biggest gap"data
        end
    add 1 record"gaps"data index
    end
end

method "bet"
begin
put 0 record"bet amount"data
put 0 record"ref"data
put 0 record"future loss"data
loop until record"ref"data > record"future loss"data
    begin
    add 1 in record"bet amount"data
    put 100% record"bet amount"data in record"future loss"data
    multiply by 100% of record"biggest gap"data on record"future loss"data
    add 100% of record"loss"data on record"future loss"data
    put 3600% record"bet amount"data in record"ref"data
    end

put 1 record"wheel"layout index
loop until record"wheel"layout index > record"wheel"layout count
    begin
    put 100% record"wheel"layout index in record"gaps"data index
    if record"gaps"data = record"biggest gap"data
        begin
        add 100% record"bet amount"data on record"loss"data
        put 100% record"bet amount"data on record"wheel"layout
        multiply by 100% of record"betting unit"data on record"wheel"layout
        end
    add 1 record"wheel"layout index
    end
end