--------------------------------------------------------------

label = "Wild Wager v1.6.5"

--------------------------------------------------------------
-- developed by winmachine (pd/stake/wolf/duckdice: WinMachine)
-- dreamed by WildCoins
--------------------------------------------------------------
--------------------------------------------------------------
-----------------------------------------------------------------------------------
-
-- THERE ARE NO PERFECT STRATS OR SCRIPTS WHEN GAMBLING, BE
SAFE!-------------------
-----------------------------------------------------------------------------------
-
-----------------------------------------------------------------------------------
-

game="dice"

local coin = string.upper(currency)

if coin=="ETH" then
minbet = 0.00000015
elseif coin=="BTC" then
minbet = 0.00000001
elseif coin=="BCH" then
minbet = 0.00000100
elseif coin=="BNB" then
minbet = 0.00000050
elseif coin=="ADA" then
minbet = 0.00100
elseif coin=="USDT" then
minbet = 0.0003
elseif coin=="LTC" then
minbet = 0.00000250
else
minbet = 0.00000001
end

risk = 2

maxbet = minbet * (10*risk)

bethigh = false

-----------------------------------------------------------------------------------
-

checkpoints =
{
[0] = {
enabled = true,
prerol = 0,
getInLoses = 0, -- number of in row loses to enter the stage
getOutLoses = 0,-- (WIP) number of in row loses to try hit
getOutTo = 1,
bb = minbet * (2*risk),
ch = 95.9,
incOnLose = 0,
bethigh = true,
 ignoreMaxBet = false,
lowerAmountOnWin = 1 -- percentage -- 0 = disabled
},
[1] = {
enabled = true,
prerol = 0,
getInLoses = 1,-- number of in row loses to enter the stage
getOutLoses = 0,-- (WIP) number of in row loses to try hit
getOutTo = 1,
bb = minbet * (1*risk), -- (0) = previousbetamount (-2) =
previousbetamount/2
ch = 22.5,
incOnLose = 20,
bethigh = true,
ignoreMaxBet = false,
},
[2] = {
enabled = true,
prerol = 0,
getInLoses = 4,-- number of in row loses to enter the stage
getOutLoses = 0,-- (WIP) number of in row loses to try hit
getOutTo = 1,
bb = -2,--minbet * 10, -- (0) = previousbetamount (-2) =
previousbetamount/2
ch = 14.14,
incOnLose = 20,
bethigh = true,
ignoreMaxBet = false
},
[3] = {
enabled = true,
prerol = 0,
getInLoses = 12,-- number of in row loses to enter the stage
getOutLoses = 0,-- (WIP) number of in row loses to try hit
getOutTo = 2,
bb = -2,-- (0) = previousbetamount (-2) = previousbetamount/2
ch = 9,
incOnLose = 6.5,
bethigh = true,
ignoreMaxBet = false
},
[4] = {
enabled = true,
prerol = 0,
getInLoses = 50,-- number of in row loses to enter the stage
getOutLoses = 0,-- (WIP) number of in row loses to try hit
getOutTo = 2,
bb = 0,-- (0) = previousbetamount (-2) = previousbetamount/2
ch = 9,
incOnLose = 5.5,
bethigh = true,
ignoreMaxBet = true
}
}
-----------------------------------------------------------------------------------
-

stage = 0
stage_tracker = {}
inc_on_lose = bb1_inc

firstOnStage=false

stageLocked = false
ignoreMaxBet = false

-----------------------------------------------------------------------------------
-

function fCurrency(value) return string.format("%9.10f %s", value, currency) end

function fPercentage(value) return string.format("%.3f %s", value, "%") end

function iff(cond, a, b) if cond then return a else return b end end

function addPercentage(value,percentage)
if tonumber(percentage) and tonumber(value) then return value + (value *
(percentage / 100)) end
return 0
end

function removePercentage(value,percentage)
if tonumber(percentage) and tonumber(value) then return value-
(value*percentage)/100 end
return 0
end

function getPercentageOf(value,percentage)
if tonumber(percentage) and tonumber(value) then return (value*percentage)/100
end
return 0
end

-----------------------------------------------------------------------------------
-

function printCheckpoint(position)
print("------------------------------------------------------------------------")
print ("pos:" .. position)
print ("ch:" .. fPercentage(checkpoints[position].ch))
print ("bb:" .. fCurrency(checkpoints[position].bb))
print ("bethigh:" .. tostring(checkpoints[position].bethigh))
print ("incOnLose:" .. fPercentage(checkpoints[position].incOnLose))
print("------------------------------------------------------------------------")
end

function getNextBetAmount(currentStage)

print ("currentStage " ..currentStage)

print ("previousbet " ..previousbet)
print ("checkpoints[currentStage].bb " ..checkpoints[currentStage].bb)

local bbdyn =0
if checkpoints[currentStage].bb == 0 then
 bbdyn = previousbet
elseif checkpoints[currentStage].bb == -2 then
bbdyn = previousbet/2
elseif checkpoints[currentStage].bb == -4 then
bbdyn = previousbet/4
else
bbdyn = checkpoints[currentStage].bb
end
return bbdyn
end

function SetupNextStage(newStage)

ignoreMaxBet = false

if checkpoints[newStage] ~= nill and checkpoints[newStage].enabled then

printCheckpoint(stage)
stage=newStage
printCheckpoint(stage)
firstOnStage = true
printCheckpoint(newStage)
chance = checkpoints[newStage].ch

nextbet = getNextBetAmount(newStage)

bethigh = checkpoints[newStage].bethigh

else
-- try get next stage,
-- if bigger then the collection size, back to begin
local ns = newStage + 1
if ns > #checkpoints then
SetupNextStage(0)
else
SetupNextStage(ns)
end
end

end

local doTrackXXXc =0

function doTrack(rolledNumber)
print("track numbers " .. rolledNumber)
if rolledNumber >= 96.99 then
print("track match " .. rolledNumber .. ":" .. doTrackXXXc )
doTrackXXXc=0
else
doTrackXXXc=doTrackXXXc+1
end
end

-----------------------------------------------------------------------------------
-

chance = checkpoints[0].ch
nextbet = checkpoints[0].bb
bethigh = checkpoints[0].bethigh
printCheckpoint(stage)

if stage > 0 then

nextbet = math.max(nextbet, minbet)
nextbet = math.min(nextbet, maxbet)
end

function dobet()

doTrack(lastBet.Roll)

if stage == 0 then
if checkpoints[stage].lowerAmountOnWin>0 and (previousbet >
checkpoints[stage].bb/2) then
nextbet = removePercentage(previousbet, checkpoints[stage].lowerAmountOnWin )
end
if win then
resetpartialprofit()
else
SetupNextStage(1)
end
end

if stage == 1 then
if win then
if partialprofit > 0 then
resetpartialprofit()
SetupNextStage(0)
else
if winstreak % 2 == 0 then
nextbet = getNextBetAmount(stage)
end
if (nextbet > (maxbet/2)) then
nextbet = getNextBetAmount(stage)
end
end
else
if losestreak > 1 then
if firstOnStage then
firstOnStage = false
else
nextbet = addPercentage(previousbet,checkpoints[stage].incOnLose)

end
if checkpoints[2].getInLoses>0 and losestreak == checkpoints[2].getInLoses
then
SetupNextStage(2)
end
end
end
end

if stage == 2 then
if win then
if partialprofit > 0 then
SetupNextStage(0)
else
 SetupNextStage(1)
end
else
if losestreak > 1 then
if firstOnStage then
firstOnStage = false
else
nextbet = addPercentage(previousbet,checkpoints[stage].incOnLose)
end
if checkpoints[3].getInLoses > 0 and losestreak ==
checkpoints[3].getInLoses then
SetupNextStage(3)
end
end
end
end

if stage == 3 then
if win then
if partialprofit > 0 then
SetupNextStage(0)
else
if (nextbet > (maxbet/2)) then
nextbet = previousbet/2
end
chance = checkpoints[stage].ch
if doTrackXXXc > 30 then
SetupNextStage(4)
end
end
else
if losestreak > 1 then
ignoreMaxBet = checkpoints[stage].ignoreMaxBet
if firstOnStage then
firstOnStage = false
else
nextbet = addPercentage(previousbet,checkpoints[stage].incOnLose)
end
if checkpoints[4].getInLoses>0 and losestreak == checkpoints[4].getInLoses
then
SetupNextStage(4)
end
if checkpoints[stage].getOutLoses > 0 and losestreak ==
checkpoints[stage].getOutLoses then
SetupNextStage(checkpoints[stage].getOutTo)
end
end
end
end

if stage == 4 then
if win then
if partialprofit > 0 then
SetupNextStage(0)
else
SetupNextStage(3)
end
else
if losestreak > 1 then
 ignoreMaxBet = checkpoints[stage].ignoreMaxBet
if firstOnStage then
firstOnStage = false
else
nextbet = addPercentage(previousbet,checkpoints[stage].incOnLose)
end
if checkpoints[stage].getOutLoses > 0 and losestreak ==
checkpoints[stage].getOutLoses then
SetupNextStage(checkpoints[stage].getOutTo)
end
end
end
end

if ignoreMaxBet==false and nextbet >= maxbet then

nextbet = nextbet/4
end

if stage > 0 then

nextbet = math.max(nextbet, minbet)
nextbet = iff((ignoreMaxBet==false),math.min(nextbet, maxbet),nextbet)
end

end