Code:
;
; AutoHotkey Version: 1.x
; Language: English
; Platform: Win9x/NT
; Author: Everlong @ 2p2 forums, thanks to marand for testing/improvement!!
;
; add name and nameT to reset
#NoEnv ; Recommended for performance and compatibility with future AutoHotkey releases.
SendMode Input ; Recommended for new scripts due to its superior speed and reliability.
SetWorkingDir %A_ScriptDir% ; Ensures a consistent starting directory.
;Menu, Tray, Icon, bbf.ico
;Gui, color, FFA230
Gui, Color, d8c46c
Gui, Add, Text, x16 y5, Payouts
Gui, add, Checkbox, x95 y5 v6max g6maxgui Checked0, 6m
Gui, add, Checkbox, x58 y5 v9max g9maxgui Checked1, FR
Gui, Add, Edit, x16 y20 vPayf, 50
Gui, Add, Edit, x50 y20 vPays, 30
Gui, Add, Edit, x84 y20 vPayt, 20
Gui, Add, Text, x16 y45 w120 h20 -background vEv1, Stack 1:
Gui, Add, Edit, x16 y65 w50 h20 vStack1 Number, 0
Gui, Add, Text, x16 y85 w120 h20 -background vEv2, Stack 2:
Gui, Add, Edit, x16 y105 w50 h20 vStack2 Number, 0
Gui, Add, Text, x16 y125 w120 h20 -background vEv3, Stack 3:
Gui, Add, Edit, x16 y145 w50 h20 vStack3 Number, 0
Gui, Add, Text, x16 y165 w120 h20 -background vEv4, Stack 4:
Gui, Add, Edit, x16 y185 w50 h20 vStack4 Number, 0
Gui, Add, Text, x16 y205 w120 h20 -background vEv5, Stack 5:
Gui, Add, Edit, x16 y225 w50 h20 vStack5 Number, 0
Gui, Add, Text, x16 y245 w120 h20 -background vEv6, Stack 6:
Gui, Add, Edit, x16 y265 w50 h20 vStack6 Number, 0
Gui, Add, Text, x16 y285 w56 h20 vChiptot, Chiptotal: 0
Gui, Add, Text, x16 y305 w120 h20 , Paste hand history here:
Gui, Add, Edit, x16 y325 w400 h128 vHH,
Gui, Add, Button, x465 y427 w80 h30 ghhinput, Calc. from HH
Gui, Add, Button, x465 y377 w80 h30 gcalcglobal, Calculate
Gui, Add, Button, x465 y327 w80 h30 greset, Reset
Gui, Add, GroupBox, x136 y5 w430 h280 -background , Bubble Factors
Gui, Add, Text, x145 y55 w55 h20 vName1, Stack1
Gui, Add, Text, x145 y95 w55 h20 VName2, Stack2
Gui, Add, Text, x145 y135 w55 h20 vName3, Stack3
Gui, Add, Text, x145 y175 w55 h20 vName4, Stack4
Gui, Add, Text, x145 y215 w55 h20 vName5, Stack5
Gui, Add, Text, x145 y255 w55 h20 vName6, Stack6
Gui, Add, Text, x195 y23 w55 h20 vNameT1, Stack1
Gui, Add, Text, x255 y23 w55 h20 vNameT2, Stack2
Gui, Add, Text, x315 y23 w55 h20 vNameT3, Stack3
Gui, Add, Text, x375 y23 w55 h20 vNameT4, Stack4
Gui, Add, Text, x435 y23 w55 h20 vNameT5, Stack5
Gui, Add, Text, x495 y23 w55 h20 vNameT6, Stack6
Gui, Add, Text, x255 y55 w30 h20 vbf1v2,
Gui, Add, Text, x315 y55 w30 h20 vbf1v3,
Gui, Add, Text, x375 y55 w30 h20 vbf1v4,
Gui, Add, Text, x435 y55 w30 h20 vbf1v5,
Gui, Add, Text, x495 y55 w30 h20 vbf1v6,
Gui, Add, Text, x195 y95 w30 h20 vbf2v1,
Gui, Add, Text, x315 y95 w30 h20 vbf2v3,
Gui, Add, Text, x375 y95 w30 h20 vbf2v4,
Gui, Add, Text, x435 y95 w30 h20 vbf2v5,
Gui, Add, Text, x495 y95 w30 h20 vbf2v6,
Gui, Add, Text, x195 y135 w30 h20 vbf3v1,
Gui, Add, Text, x255 y135 w30 h20 vbf3v2,
Gui, Add, Text, x375 y135 w30 h20 vbf3v4,
Gui, Add, Text, x435 y135 w30 h20 vbf3v5,
Gui, Add, Text, x495 y135 w30 h20 vbf3v6,
Gui, Add, Text, x195 y175 w30 h20 vbf4v1,
Gui, Add, Text, x255 y175 w30 h20 vbf4v2,
Gui, Add, Text, x315 y175 w30 h20 vbf4v3,
Gui, Add, Text, x435 y175 w30 h20 vbf4v5,
Gui, Add, Text, x495 y175 w30 h20 vbf4v6,
Gui, Add, Text, x195 y215 w30 h20 vbf5v1,
Gui, Add, Text, x255 y215 w30 h20 vbf5v2,
Gui, Add, Text, x315 y215 w30 h20 vbf5v3,
Gui, Add, Text, x375 y215 w30 h20 vbf5v4,
Gui, Add, Text, x495 y215 w30 h20 vbf5v6,
Gui, Add, Text, x195 y255 w30 h20 vbf6v1,
Gui, Add, Text, x255 y255 w30 h20 vbf6v2,
Gui, Add, Text, x315 y255 w30 h20 vbf6v3,
Gui, Add, Text, x375 y255 w30 h20 vbf6v4,
Gui, Add, Text, x435 y255 w30 h20 vbf6v5,
Gui, Add, Text, x156 y305 w180 h20 Vmess,
Gui, Show, , EV and BubbleFactor calculator v.1.4 (by Everlong)
Return
GuiClose:
ExitApp
6maxgui:
6max := 1
9max := 0
payf := 65
pays := 35
payt := 0
GuiControl, , payf, %payf%
GuiControl, , pays, %pays%
GuiControl, , payt, %payt%
GuiControl, , 6max, 1
GuiControl, , 9max, 0
;gui, submit, nohide
Return
9maxgui:
6max := 0
9max := 1
payf := 50
pays := 30
payt := 20
GuiControl, , payf, %payf%
GuiControl, , pays, %pays%
GuiControl, , payt, %payt%
GuiControl, , 6max, 0
GuiControl, , 9max, 1
;gui, submit, nohide
Return
^!r::Reload
Return
reset:
Loop, 6
{
GuiControl, , Stack%A_Index%, 0
Stack%A_Index% := 0
GuiControl, , EV%A_index%, Stack %A_Index%:
Name%A_Index% =
GuiControl, , Name%A_Index%,
GuiControl, , NameT%A_Index%,
}
payf := 50
pays := 30
payt := 20
GuiControl, , mess,
GuiControl, , 6max, 0
GuiControl, , 9max, 1
6max := 0
9max := 1
GuiControl, , hh, %hh%
GuiControl, , payf, %payf%
GuiControl, , pays, %pays%
GuiControl, , payt, %payt%
hh :=""
GuiControl, ,hh, %hh%
Gosub, calcglobal
Loop, 6
{
GuiControl, , EV%A_index%, Stack %A_Index%:
Gui, font, cBlack
GuiControl, font, EV%A_Index%
}
return
hhinput:
GuiControlGet, hh,, hh
Loop, 9
{
Stack%A_Index% =
}
GuiControl, , hh, %hh%
StringReplace, hh, hh, -, , all
StringReplace, hh, hh, _, , all
StringReplace, hh, hh, `,, , all
StringReplace, hh, hh, %A_Space%in chips, , all
StringReplace, hh, hh, %A_Space%, , all
StringReplace, hh, hh, `r, , all
StringReplace, hh, hh, `n, , all
StringReplace, hh, hh, Seat10, Seat| , all
hh := RegExReplace(hh, "smallblind(.*)", "")
hh := RegExReplace(hh, "bigblind(.*)", "")
hh := RegExReplace(hh, "antes(.*)", "")
hh := RegExReplace(hh, "postsante(.*)", "")
hh := RegExReplace(hh, "dealingdowncards(.*)", "")
grep(hh, "\([0-9]{1,5}\)", Stack)
StringSplit, Stack, Stack , "", "(" ")"
grep(hh, "Seat[0-9|]\:[a-zA-Z0-9_]+", Name)
Loop, parse, Name, ""
{
StringTrimLeft, Name%A_Index%, A_LoopField, 6
Name%A_Index% := abbrstr(Name%A_Index%,7)
loopname := abbrstr(Name%A_Index%,7)
GuiControl, , Name%A_Index%, %loopname%
GuiControl, , NameT%A_Index%, %loopname%
}
If Stack5 is not Number
Stack5 := 0
Else
Stack5 := Stack5
If Stack6 is not Number
Stack6 := 0
Else
Stack6 := Stack6
stacktot := Stack1 + Stack2 + Stack3 + Stack4 + Stack5 + Stack6
GuiControl, , Stack1, %Stack1%
GuiControl, , Stack2, %Stack2%
GuiControl, , Stack3, %Stack3%
GuiControl, , Stack4, %Stack4%
GuiControl, , Stack5, %Stack5%
GuiControl, , Stack6, %Stack6%
; if Stack4 is not number
;msgbox, Hand history has less than 4 players / no bubble!
If Stack7 is Number
MsgBox, Hand history has more than 6 remaining players!`nOnly the First six seats will be calculated.
IfInString, hh, 6max
6max := 1
if hh contains seat7,seat8,seat9,seat10
6max = 0
ifinstring, hh, FullTiltPokerGame
site = Full Tilt Poker
ifinstring, hh, STTTournament
site = Party Poker
ifinstring, hh, USDBuyinTrny
site = Party Poker
if site = Full Tilt Poker
{
if stacktot = 9000
{
6max = 1
9max = 0
}
else
{
6max = 0
9max = 1
}
}
;
ifinstring, hh, PokerStars
site = PokerStars
if hh not contains PokerStars,FullTiltPokerGame,STTTournament,USDBuyinTrny
site = Unknown site
If 6max = 1
{
type = 6-max hand history
9max := 0
payf := 65
pays := 35
payt := 0
Checkstr = 6max
GuiControl, , 6max, 1
GuiControl, , 9max, 0
GuiControl, , payf, %payf%
GuiControl, , pays, %pays%
GuiControl, , payt, %payt%
}
Else
{
type = full-ring hand history
9max := 1
payf := 50
pays := 30
payt := 20
Checkstr = 9max
GuiControl, , 6max, 0
GuiControl, , 9max, 1
GuiControl, , payf, %payf%
GuiControl, , pays, %pays%
GuiControl, , payt, %payt%
}
Gosub calcglobal
Guicontrol, , mess, %Site% %type%
Gui, font, cRed
GuiControl, font, mess
Return
calcglobal:
Gui, Submit, NoHide
stacktot := Stack1 + Stack2 + Stack3 + Stack4 + Stack5 + Stack6
GuiControl, Move, Chiptot, w80
Gui, font, cGreen
GuiControl, font, Chiptot
GuiControl, , Chiptot, Chiptotal: %stacktot%
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
if ( (9max = 1) AND (Stack4 = 0) AND (Stack3 > 0) )
{
6max := 1
type = 6-max hand history
9max := 0
payf := 75
pays := 25
payt := 0
Checkstr = 6max
}
EVCALC()
SetFormat, Float, 0.2
If 6max = 1
{
Loop, 6
{
%A_Index%t := 0
pEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays)
}
}
Else
{
Loop, 6
{
pEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays)+ (%A_Index%t * payt)
}
}
GuiControl, , EV1, %name1% $EV: %pEV1%
GuiControl, , EV2, %name2% $EV: %pEV2%
GuiControl, , EV3, %name3% $EV: %pEV3%
GuiControl, , EV4, %name4% $EV: %pEV4%
GuiControl, , EV5, %name5% $EV: %pEV5%
GuiControl, , EV6, %name6% $EV: %pEV6%
Loop, 6
{
Gui, font, cRed
GuiControl, font, EV%A_Index%
}
;BubbleFcAlc
;Stack 1 vs Stack 2
;Stack 1 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack2)
{
Stack1 := Stack1 + Stack2
Stack2 := Stack2 - Stack2
}
Else
{
Stack2 := Stack2 - Stack1
Stack1 := Stack1 + Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbAEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst2w1 := bbAEV1 - pEV1
;Stack 1 vs Stack 2
;Stack 2 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack2)
{
Stack1 := Stack1 - Stack2
Stack2 := Stack2 + Stack2
,%stack2%
}
Else
{
Stack2 := Stack2 + Stack1
Stack1 := Stack1 - Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbBEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst2w2 := pEV1 - bbBEV1
bf1v2 := st1vst2w2 / st1vst2w1
GuiControl, , bf1v2, %bf1v2%
;Stack 1 vs Stack 3
;Stack 1 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack3)
{
Stack1 := Stack1 + Stack3
Stack3 := Stack3 - Stack3
}
Else
{
Stack3 := Stack3 - Stack1
Stack1 := Stack1 + Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbCEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst3w1 := bbCEV1 - pEV1
;Stack 1 vs Stack 3
;Stack 3 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack3)
{
Stack1 := Stack1 - Stack3
Stack3 := Stack3 + Stack3
}
Else
{
Stack3 := Stack3 + Stack1
Stack1 := Stack1 - Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbDEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst3w3 := pEV1 - bbDEV1
bf1v3 := st1vst3w3 / st1vst3w1
GuiControl, , bf1v3, %bf1v3%
;Stack 1 vs Stack 4
;Stack 1 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack4)
{
Stack1 := Stack1 + Stack4
Stack4 := Stack4 - Stack4
}
Else
{
Stack4 := Stack4 - Stack1
Stack1 := Stack1 + Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbEEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst4w1 := bbEEV1 - pEV1
;Stack 1 vs Stack 4
;Stack 4 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack4)
{
Stack1 := Stack1 - Stack4
Stack4 := Stack4 + Stack4
}
Else
{
Stack4 := Stack4 + Stack1
Stack1 := Stack1 - Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbFEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst4w4 := pEV1 - bbFEV1
bf1v4 := st1vst4w4 / st1vst4w1
GuiControl, , bf1v4, %bf1v4%
;Stack 1 vs Stack 5
;Stack 1 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack5)
{
Stack1 := Stack1 + Stack5
Stack5 := Stack5 - Stack5
}
Else
{
Stack5 := Stack5 - Stack1
Stack1 := Stack1 + Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbMEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst5w1 := bbMEV1 - pEV1
;Stack 1 vs Stack 5
;Stack 5 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack5)
{
Stack1 := Stack1 - Stack5
Stack5 := Stack5 + Stack5
}
Else
{
Stack5 := Stack5 + Stack1
Stack1 := Stack1 - Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbNEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst5w5 := pEV1 - bbNEV1
bf1v5 := st1vst5w5 / st1vst5w1
GuiControl, , bf1v5, %bf1v5%
;Stack 1 vs Stack 6
;Stack 1 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack6)
{
Stack1 := Stack1 + Stack6
Stack6 := Stack6 - Stack6
}
Else
{
Stack6 := Stack6 - Stack1
Stack1 := Stack1 + Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbOEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst6w1 := bbOEV1 - pEV1
;Stack 1 vs Stack 6
;Stack 6 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack1 >= Stack6)
{
Stack1 := Stack1 - Stack6
Stack6 := Stack6 + Stack6
}
Else
{
Stack6 := Stack6 + Stack1
Stack1 := Stack1 - Stack1
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbPEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st1vst6w6 := pEV1 - bbPEV1
bf1v6 := st1vst6w6 / st1vst6w1
GuiControl, , bf1v6, %bf1v6%
;Stack 2 vs Stack 3
;Stack 2 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack3)
{
Stack2 := Stack2 + Stack3
Stack3 := Stack3 - Stack3
}
Else
{
Stack3 := Stack3 - Stack2
Stack2 := Stack2 + Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbGEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst3w2 := bbGEV2 - pEV2
;Stack 2 vs Stack 3
;Stack 3 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack3)
{
Stack2 := Stack2 - Stack3
Stack3 := Stack3 + Stack3
}
Else
{
Stack3 := Stack3 + Stack2
Stack2 := Stack2 - Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbHEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst3w3 := pEV2 - bbHEV2
bf2v3 := st2vst3w3 / st2vst3w2
GuiControl, , bf2v3, %bf2v3%
;Stack 2 vs Stack 4
;Stack 2 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack4)
{
Stack2 := Stack2 + Stack4
Stack4 := Stack4 - Stack4
}
Else
{
Stack4 := Stack4 - Stack2
Stack2 := Stack2 + Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbIEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst4w2 := bbIEV2 - pEV2
;Stack 2 vs Stack 4
;Stack 4 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack4)
{
Stack2 := Stack2 - Stack4
Stack4 := Stack4 + Stack4
}
Else
{
Stack4 := Stack4 + Stack2
Stack2 := Stack2 - Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbJEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst4w4 := pEV2 - bbJEV2
bf2v4 := st2vst4w4 / st2vst4w2
GuiControl, , bf2v4, %bf2v4%
;msgbox %bf2v4%
;Stack 2 vs Stack 5
;Stack 2 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack5)
{
Stack2 := Stack2 + Stack5
Stack5 := Stack5 - Stack5
}
Else
{
Stack5 := Stack5 - Stack2
Stack2 := Stack2 + Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbQEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst5w2 := bbQEV2 - pEV2
;Stack 2 vs Stack 5
;Stack 5 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack5)
{
Stack2 := Stack2 - Stack5
Stack5 := Stack5 + Stack5
}
Else
{
Stack5 := Stack5 + Stack2
Stack2 := Stack2 - Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbREV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst5w5 := pEV2 - bbREV2
bf2v5 := st2vst5w5 / st2vst5w2
GuiControl, , bf2v5, %bf2v5%
;Stack 2 vs Stack 6
;Stack 2 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack6)
{
Stack2 := Stack2 + Stack6
Stack6 := Stack6 - Stack6
}
Else
{
Stack6 := Stack6 - Stack2
Stack2 := Stack2 + Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbSEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst6w2 := bbSEV2 - pEV2
;Stack 2 vs Stack 6
;Stack 6 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack2 >= Stack6)
{
Stack2 := Stack2 - Stack6
Stack6 := Stack6 + Stack6
}
Else
{
Stack6 := Stack6 + Stack2
Stack2 := Stack2 - Stack2
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbTEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st2vst6w6 := pEV2 - bbTEV2
bf2v6 := st2vst6w6 / st2vst6w2
GuiControl, , bf2v6, %bf2v6%
;Stack 3 vs Stack 4
;Stack 3 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack3 >= Stack4)
{
Stack3 := Stack3 + Stack4
Stack4 := Stack4 - Stack4
}
Else
{
Stack4 := Stack4 - Stack3
Stack3 := Stack3 + Stack3
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbKEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st3vst4w3 := bbKEV3 - pEV3
;Stack 3 vs Stack 4
;Stack 4 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack3 >= Stack4)
{
Stack3 := Stack3 - Stack4
Stack4 := Stack4 + Stack4
}
Else
{
Stack4 := Stack4 + Stack3
Stack3 := Stack3 - Stack3
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbLEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st3vst4w4 := pEV3 - bbLEV3
bf3v4 := st3vst4w4 / st3vst4w3
GuiControl, , bf3v4, %bf3v4%
;Stack 3 vs Stack 5
;Stack 3 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack3 >= Stack5)
{
Stack3 := Stack3 + Stack5
Stack5 := Stack5 - Stack5
}
Else
{
Stack5 := Stack5 - Stack3
Stack3 := Stack3 + Stack3
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbUEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st3vst5w3 := bbUEV3 - pEV3
;Stack 3 vs Stack 5
;Stack 5 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack3 >= Stack5)
{
Stack3 := Stack3 - Stack5
Stack5 := Stack5 + Stack5
}
Else
{
Stack5 := Stack5 + Stack3
Stack3 := Stack3 - Stack3
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbVEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st3vst5w5 := pEV3 - bbVEV3
bf3v5 := st3vst5w5 / st3vst5w3
GuiControl, , bf3v5, %bf3v5%
;Stack 3 vs Stack 6
;Stack 3 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack3 >= Stack6)
{
Stack3 := Stack3 + Stack6
Stack6 := Stack6 - Stack6
}
Else
{
Stack6 := Stack6 - Stack3
Stack3 := Stack3 + Stack3
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbWEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st3vst6w3 := bbWEV3 - pEV3
;Stack 3 vs Stack 6
;Stack 6 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack3 >= Stack6)
{
Stack3 := Stack3 - Stack6
Stack6 := Stack6 + Stack6
}
Else
{
Stack6 := Stack6 + Stack3
Stack3 := Stack3 - Stack3
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbXEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st3vst6w6 := pEV3 - bbXEV3
bf3v6 := st3vst6w6 / st3vst6w3
GuiControl, , bf3v6, %bf3v6%
;Stack 4 vs Stack 5
;Stack 4 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack4 >= Stack5)
{
Stack4 := Stack4 + Stack5
Stack5 := Stack5 - Stack5
}
Else
{
Stack5 := Stack5 - Stack4
Stack4 := Stack4 + Stack4
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbYEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st4vst5w4 := bbYEV4 - pEV4
;Stack 4 vs Stack 5
;Stack 5 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack4 >= Stack5)
{
Stack4 := Stack4 - Stack5
Stack5 := Stack5 + Stack5
}
Else
{
Stack5 := Stack5 + Stack4
Stack4 := Stack4 - Stack4
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbZEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st4vst5w5 := pEV4 - bbzEV4
bf4v5 := st4vst5w5 / st4vst5w4
GuiControl, , bf4v5, %bf4v5%
;Stack 4 vs Stack 6
;Stack 4 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack4 >= Stack6)
{
Stack4 := Stack4 + Stack6
Stack6 := Stack6 - Stack6
}
Else
{
Stack6 := Stack6 - Stack4
Stack4 := Stack4 + Stack4
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbAAEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st4vst6w4 := bbAAEV4 - pEV4
;Stack 4 vs Stack 6
;Stack 6 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack4 >= Stack6)
{
Stack4 := Stack4 - Stack6
Stack6 := Stack6 + Stack6
}
Else
{
Stack6 := Stack6 + Stack4
Stack4 := Stack4 - Stack4
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbBBEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st4vst6w6 := pEV4 - bbBBEV4
bf4v6 := st4vst6w6 / st4vst6w4
GuiControl, , bf4v6, %bf4v6%
;Stack 5 vs Stack 6
;Stack 5 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack5 >= Stack6)
{
Stack5 := Stack5 + Stack6
Stack6 := Stack6 - Stack6
}
Else
{
Stack6 := Stack6 - Stack5
Stack5 := Stack5 + Stack5
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbCCEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st5vst6w5 := bbCCEV5 - pEV5
;Stack 5 vs Stack 6
;Stack 6 wins
SetFormat, Float, 0.6
Loop, 6
{
GuiControlGet, Stack%A_Index%,, Stack%A_Index%
}
If (Stack5 >= Stack6)
{
Stack5 := Stack5 - Stack6
Stack6 := Stack6 + Stack6
}
Else
{
Stack6 := Stack6 + Stack5
Stack5 := Stack5 - Stack5
}
EVCALC()
SetFormat, Float, 0.2
Loop, 6
{
bbDDEV%A_Index% := (%A_Index%f * payf) + (%A_Index%s * pays) + (%A_Index%t * payt )
}
st5vst6w6 := pEV5 - bbDDEV5
bf5v6 := st5vst6w6 / st5vst6w5
GuiControl, , bf5v6, %bf5v6%
; ************Stack2 vs. Stack1 taken from Stack1 vs. Stack2 variables******************
st2vsst1w2 := bbBEV2 - pEV2
st2vsst1w1 := pEV2 - bbAEV2
bf2v1 := st2vsst1w1 / st2vsst1w2
GuiControl, , bf2v1, %bf2v1%
; ************Stack3 vs. Stack1 taken from Stack1 vs. Stack3 variables******************
st3vsst1w3 := bbDEV3 - pEV3
st3vsst1w1 := pEV3 - bbCEV3
bf3v1 := st3vsst1w1 / st3vsst1w3
GuiControl, , bf3v1, %bf3v1%
; ************Stack3 vs. Stack2 taken from Stack2 vs. Stack3 variables******************
st3vsst2w3 := bbhEV3 - pEV3
st3vsst2w2 := pEV3 - bbgEV3
bf3v2 := st3vsst2w2 / st3vsst2w3
GuiControl, , bf3v2, %bf3v2%
; ************Stack4 vs. Stack1 taken from Stack1 vs. Stack4 variables******************
st4vsst1w4 := bbFEV4 - pEV4
st4vsst1w1 := pEV4 - bbEEV4
bf4v1 := st4vsst1w1 / st4vsst1w4
GuiControl, , bf4v1, %bf4v1%
; ************Stack4 vs. Stack2 taken from Stack2 vs. Stack4 variables******************
st4vsst2w4 := bbJEV4 - pEV4
st4vsst2w2 := pEV4 - bbIEV4
bf4v2 := st4vsst2w2 / st4vsst2w4
GuiControl, , bf4v2, %bf4v2%
; ************Stack4 vs. Stack3 taken from Stack3 vs. Stack4 variables******************
st4vsst3w4 := bbLEV4 - pEV4
st4vsst3w3 := pEV4 - bbKEV4
bf4v3 := st4vsst3w3 / st4vsst3w4
GuiControl, , bf4v3, %bf4v3%
; ************Stack5 vs. Stack1 taken from Stack1 vs. Stack5 variables******************
st5vsst1w5 := bbNEV5 - pEV5
st5vsst1w1 := pEV5 - bbMEV5
bf5v1 := st5vsst1w1 / st5vsst1w5
GuiControl, , bf5v1, %bf5v1%
; ************Stack5 vs. Stack2 taken from Stack2 vs. Stack5 variables******************
st5vsst2w5 := bbREV5 - pEV5
st5vsst2w2 := pEV5 - bbQEV5
bf5v2 := st5vsst2w2 / st5vsst2w5
GuiControl, , bf5v2, %bf5v2%
; ************Stack5 vs. Stack3 taken from Stack3 vs. Stack5 variables******************
st5vsst3w5 := bbVEV5 - pEV5
st5vsst3w3 := pEV5 - bbUEV5
bf5v3 := st5vsst3w3 / st5vsst3w5
GuiControl, , bf5v3, %bf5v3%
; ************Stack5 vs. Stack4 taken from Stack4 vs. Stack5 variables******************
st5vsst4w5 := bbZEV5 - pEV5
st5vsst4w4 := pEV5 - bbYEV5
bf5v4 := st5vsst4w4 / st5vsst4w5
GuiControl, , bf5v4, %bf5v4%
; ************Stack6 vs. Stack1 taken from Stack1 vs. Stack6 variables******************
st6vsst1w6 := bbPEV6 - pEV6
st6vsst1w1 := pEV6 - bbOEV6
bf6v1 := st6vsst1w1 / st6vsst1w6
GuiControl, , bf6v1, %bf6v1%
; ************Stack6 vs. Stack2 taken from Stack2 vs. Stack6 variables******************
st6vsst2w6 := bbTEV6 - pEV6
st6vsst2w2 := pEV6 - bbSEV6
bf6v2 := st6vsst2w2 / st6vsst2w6
GuiControl, , bf6v2, %bf6v2%
; ************Stack6 vs. Stack3 taken from Stack3 vs. Stack6 variables******************
st6vsst3w6 := bbXEV6 - pEV6
st6vsst3w3 := pEV6 - bbWEV6
bf6v3 := st6vsst3w3 / st6vsst3w6
GuiControl, , bf6v3, %bf6v3%
; ************Stack6 vs. Stack4 taken from Stack4 vs. Stack6 variables******************
st6vsst4w6 := bbBBEV6 - pEV6
st6vsst4w4 := pEV6 - bbAAEV6
bf6v4 := st6vsst4w4 / st6vsst4w6
GuiControl, , bf6v4, %bf6v4%
; ************Stack6 vs. Stack5 taken from Stack5 vs. Stack6 variables******************
st6vsst5w6 := bbDDEV6 - pEV6
st6vsst5w5 := pEV6 - bbCCEV6
bf6v5 := st6vsst5w5 / st6vsst5w6
GuiControl, , bf6v5, %bf6v5%
vslist = bf1v2,bf1v3,bf1v4,bf1v5,bf1v6,bf2v1,bf2v3,bf2v4,bf2v5,bf2v6,bf3v1,bf3v2,bf3v4,bf3v5,bf3v6,bf4v1,bf4v2,bf4v3,bf4v5,bf4v6,bf5v1,bf5v2,bf5v3,bf5v4,bf5v6,bf6v1,bf6v2,bf6v3,bf6v4,bf6v5
Loop, parse, vslist, `,
{
Gui, font, Cblue
GuiControl, font, %A_Loopfield%
}
Return
;Function for lengthy EV calculation
EVCALC() {
global
stacktot := Stack1 + Stack2 + Stack3 + Stack4 + Stack5 + Stack6
Loop, 6
{
%A_Index%f := Stack%A_Index% / Stacktot
}
;CHANCES OF SECOND
2f1s := stack1 /(Stacktot - stack2) ; chances of stack finishing 2nd if stack2 finishes First
3f1s := stack1 /(Stacktot - stack3) ; chances of stack finishing 2nd if stack3 finishes First
4f1s := stack1 /(Stacktot - stack4) ; chances of stack finishing 2nd if stack4 finishes First
5f1s := stack1 /(Stacktot - stack5) ; chances of stack finishing 2nd if stack5 finishes First
6f1s := stack1 /(Stacktot - stack6) ; chances of stack finishing 2nd if stack6 finishes First
1f2s := stack2 /(Stacktot - stack1) ; chances of stack finishing 2nd if stack1 finishes First
3f2s := stack2 /(Stacktot - stack3) ; chances of stack finishing 2nd if stack3 finishes First
4f2s := stack2 /(Stacktot - stack4) ; chances of stack finishing 2nd if stack4 finishes First
5f2s := stack2 /(Stacktot - stack5) ; chances of stack finishing 2nd if stack5 finishes First
6f2s := stack2 /(Stacktot - stack6) ; chances of stack finishing 2nd if stack6 finishes First
1f3s := stack3 /(Stacktot - stack1) ; chances of stack finishing 2nd if stack1 finishes First
2f3s := stack3 /(Stacktot - stack2) ; chances of stack finishing 2nd if stack2 finishes First
4f3s := stack3 /(Stacktot - stack4) ; chances of stack finishing 2nd if stack4 finishes First
5f3s := stack3 /(Stacktot - stack5) ; chances of stack finishing 2nd if stack5 finishes First
6f3s := stack3 /(Stacktot - stack6) ; chances of stack finishing 2nd if stack6 finishes First
1f4s := stack4 /(Stacktot - stack1) ; chances of stack finishing 2nd if stack1 finishes First
2f4s := stack4 /(Stacktot - stack2) ; chances of stack finishing 2nd if stack2 finishes First
3f4s := stack4 /(Stacktot - stack3) ; chances of stack finishing 2nd if stack3 finishes First
5f4s := stack4 /(Stacktot - stack5) ; chances of stack finishing 2nd if stack5 finishes First
6f4s := stack4 /(Stacktot - stack6) ; chances of stack finishing 2nd if stack6 finishes First
1f5s := stack5 /(Stacktot - stack1) ; chances of stack finishing 2nd if stack1 finishes First
2f5s := stack5 /(Stacktot - stack2) ; chances of stack finishing 2nd if stack2 finishes First
3f5s := stack5 /(Stacktot - stack3) ; chances of stack finishing 2nd if stack3 finishes First
4f5s := stack5 /(Stacktot - stack4) ; chances of stack finishing 2nd if stack4 finishes First
6f5s := stack5 /(Stacktot - stack6) ; chances of stack finishing 2nd if stack6 finishes First
1f6s := stack6 /(Stacktot - stack1) ; chances of stack finishing 2nd if stack1 finishes First
2f6s := stack6 /(Stacktot - stack2) ; chances of stack finishing 2nd if stack2 finishes First
3f6s := stack6 /(Stacktot - stack3) ; chances of stack finishing 2nd if stack3 finishes First
4f6s := stack6 /(Stacktot - stack4) ; chances of stack finishing 2nd if stack4 finishes First
5f6s := stack6 /(Stacktot - stack5) ; chances of stack finishing 2nd if stack5 finishes First
1s := (2f1s * 2f) + (3f1s * 3f) + (4f1s * 4f) + (5f1s * 5f) + (6f1s * 6f) ; chances of Stack1 finishing 2nd
2s := (1f2s * 1f) + (3f2s * 3f) + (4f2s * 4f) + (5f2s * 5f) + (6f2s * 6f) ; Chances of Stack2 finishing 2nd
3s := (1f3s * 1f) + (2f3s * 2f) + (4f3s * 4f) + (5f3s * 5f) + (6f3s * 6f) ; chances of Stack3 finishing 2nd
4s := (1f4s * 1f) + (2f4s * 2f) + (3f4s * 3f) + (5f4s * 5f) + (6f4s * 6f) ; chances of Stack4 finishing 2nd
5s := (1f5s * 1f) + (2f5s * 2f) + (3f5s * 3f) + (4f5s * 4f) + (6f5s * 6f) ; chances of Stack5 finishing 2nd
6s := (1f6s * 1f) + (2f6s * 2f) + (3f6s * 3f) + (4f6s * 4f) + (5f6s * 5f) ; chances of Stack6 finishing 2nd
If 9max = 1
{
;CHANCES OF THIRD
;_____________Stack1 - 3rd________________________________
2f3s1t := stack1 / (Stacktot - (Stack2 + stack3))
2f4s1t := stack1 / (Stacktot - (Stack2 + stack4))
2f5s1t := stack1 / (Stacktot - (Stack2 + stack5))
2f6s1t := stack1 / (Stacktot - (Stack2 + stack6))
3f2s1t := stack1 / (Stacktot - (Stack3 + stack2))
3f4s1t := stack1 / (Stacktot - (Stack3 + stack4))
3f5s1t := stack1 / (Stacktot - (Stack3 + stack5))
3f6s1t := stack1 / (Stacktot - (Stack3 + stack6))
4f2s1t := stack1 / (Stacktot - (Stack4 + stack2))
4f3s1t := stack1 / (Stacktot - (Stack4 + stack3))
4f5s1t := stack1 / (Stacktot - (Stack4 + stack5))
4f6s1t := stack1 / (Stacktot - (Stack4 + stack6))
5f2s1t := stack1 / (Stacktot - (Stack5 + stack2))
5f3s1t := stack1 / (Stacktot - (Stack5 + stack3))
5f4s1t := stack1 / (Stacktot - (Stack5 + stack4))
5f6s1t := stack1 / (Stacktot - (Stack5 + stack6))
6f2s1t := stack1 / (Stacktot - (Stack6 + stack2))
6f3s1t := stack1 / (Stacktot - (Stack6 + stack3))
6f4s1t := stack1 / (Stacktot - (Stack6 + stack4))
6f5s1t := stack1 / (Stacktot - (Stack6 + stack5))
;_____________Stack2 - 3rd________________________________
1f3s2t := stack2 / (Stacktot - (Stack1 + stack3))
1f4s2t := stack2 / (Stacktot - (Stack1 + stack4))
1f5s2t := stack2 / (Stacktot - (Stack1 + stack5))
1f6s2t := stack2 / (Stacktot - (Stack1 + stack6))
3f1s2t := stack2 / (Stacktot - (Stack3 + stack1))
3f4s2t := stack2 / (Stacktot - (Stack3 + stack4))
3f5s2t := stack2 / (Stacktot - (Stack3 + stack5))
3f6s2t := stack2 / (Stacktot - (Stack3 + stack6))
4f1s2t := stack2 / (Stacktot - (Stack4 + stack1))
4f3s2t := stack2 / (Stacktot - (Stack4 + stack3))
4f5s2t := stack2 / (Stacktot - (Stack4 + stack5))
4f6s2t := stack2 / (Stacktot - (Stack4 + stack6))
5f1s2t := stack2 / (Stacktot - (Stack5 + stack1))
5f3s2t := stack2 / (Stacktot - (Stack5 + stack3))
5f4s2t := stack2 / (Stacktot - (Stack5 + stack4))
5f6s2t := stack2 / (Stacktot - (Stack5 + stack6))
6f1s2t := stack2 / (Stacktot - (Stack6 + stack1))
6f3s2t := stack2 / (Stacktot - (Stack6 + stack3))
6f4s2t := stack2 / (Stacktot - (Stack6 + stack4))
6f5s2t := stack2 / (Stacktot - (Stack6 + stack5))
;_____________Stack3 - 3rd________________________________
1f2s3t := stack3 / (Stacktot - (Stack1 + stack2))
1f4s3t := stack3 / (Stacktot - (Stack1 + stack4))
1f5s3t := stack3 / (Stacktot - (Stack1 + stack5))
1f6s3t := stack3 / (Stacktot - (Stack1 + stack6))
2f1s3t := stack3 / (Stacktot - (Stack2 + stack1))
2f4s3t := stack3 / (Stacktot - (Stack2 + stack4))
2f5s3t := stack3 / (Stacktot - (Stack2 + stack5))
2f6s3t := stack3 / (Stacktot - (Stack2 + stack6))
4f1s3t := stack3 / (Stacktot - (Stack4 + stack1))
4f2s3t := stack3 / (Stacktot - (Stack4 + stack2))
4f5s3t := stack3 / (Stacktot - (Stack4 + stack5))
4f6s3t := stack3 / (Stacktot - (Stack4 + stack6))
5f1s3t := stack3 / (Stacktot - (Stack5 + stack1))
5f2s3t := stack3 / (Stacktot - (Stack5 + stack2))
5f4s3t := stack3 / (Stacktot - (Stack5 + stack4))
5f6s3t := stack3 / (Stacktot - (Stack5 + stack6))
6f1s3t := stack3 / (Stacktot - (Stack6 + stack1))
6f2s3t := stack3 / (Stacktot - (Stack6 + stack2))
6f4s3t := stack3 / (Stacktot - (Stack6 + stack4))
6f5s3t := stack3 / (Stacktot - (Stack6 + stack5))
;_____________Stack4 - 3rd_______________________________
1f2s4t := stack4 / (Stacktot - (Stack1 + stack2))
1f3s4t := stack4 / (Stacktot - (Stack1 + stack3))
1f5s4t := stack4 / (Stacktot - (Stack1 + stack5))
1f6s4t := stack4 / (Stacktot - (Stack1 + stack6))
2f1s4t := stack4 / (Stacktot - (Stack2 + stack1))
2f3s4t := stack4 / (Stacktot - (Stack2 + stack3))
2f5s4t := stack4 / (Stacktot - (Stack2 + stack5))
2f6s4t := stack4 / (Stacktot - (Stack2 + stack6))
3f1s4t := stack4 / (Stacktot - (Stack3 + stack1))
3f2s4t := stack4 / (Stacktot - (Stack3 + stack2))
3f5s4t := stack4 / (Stacktot - (Stack3 + stack5))
3f6s4t := stack4 / (Stacktot - (Stack3 + stack6))
5f1s4t := stack4 / (Stacktot - (Stack5 + stack1))
5f2s4t := stack4 / (Stacktot - (Stack5 + stack2))
5f3s4t := stack4 / (Stacktot - (Stack5 + stack3))
5f6s4t := stack4 / (Stacktot - (Stack5 + stack6))
6f1s4t := stack4 / (Stacktot - (Stack6 + stack1))
6f2s4t := stack4 / (Stacktot - (Stack6 + stack2))
6f3s4t := stack4 / (Stacktot - (Stack6 + stack3))
6f5s4t := stack4 / (Stacktot - (Stack6 + stack5))
;_____________Stack5 - 3rd_______________________________
1f2s5t := stack5 / (Stacktot - (Stack1 + stack2))
1f3s5t := stack5 / (Stacktot - (Stack1 + stack3))
1f4s5t := stack5 / (Stacktot - (Stack1 + stack4))
1f6s5t := stack5 / (Stacktot - (Stack1 + stack6))
2f1s5t := stack5 / (Stacktot - (Stack2 + stack1))
2f3s5t := stack5 / (Stacktot - (Stack2 + stack3))
2f4s5t := stack5 / (Stacktot - (Stack2 + stack4))
2f6s5t := stack5 / (Stacktot - (Stack2 + stack6))
3f1s5t := stack5 / (Stacktot - (Stack3 + stack1))
3f2s5t := stack5 / (Stacktot - (Stack3 + stack2))
3f4s5t := stack5 / (Stacktot - (Stack3 + stack4))
3f6s5t := stack5 / (Stacktot - (Stack3 + stack6))
4f1s5t := stack5 / (Stacktot - (Stack4 + stack1))
4f2s5t := stack5 / (Stacktot - (Stack4 + stack2))
4f3s5t := stack5 / (Stacktot - (Stack4 + stack3))
4f6s5t := stack5 / (Stacktot - (Stack4 + stack6))
6f1s5t := stack5 / (Stacktot - (Stack6 + stack1))
6f2s5t := stack5 / (Stacktot - (Stack6 + stack2))
6f3s5t := stack5 / (Stacktot - (Stack6 + stack3))
6f4s5t := stack5 / (Stacktot - (Stack6 + stack4))
;_____________Stack6 - 3rd_______________________________
1f2s6t := stack6 / (Stacktot - (Stack1 + stack2))
1f3s6t := stack6 / (Stacktot - (Stack1 + stack3))
1f4s6t := stack6 / (Stacktot - (Stack1 + stack4))
1f5s6t := stack6 / (Stacktot - (Stack1 + stack5))
2f1s6t := stack6 / (Stacktot - (Stack2 + stack1))
2f3s6t := stack6 / (Stacktot - (Stack2 + stack3))
2f4s6t := stack6 / (Stacktot - (Stack2 + stack4))
2f5s6t := stack6 / (Stacktot - (Stack2 + stack5))
3f1s6t := stack6 / (Stacktot - (Stack3 + stack1))
3f2s6t := stack6 / (Stacktot - (Stack3 + stack2))
3f4s6t := stack6 / (Stacktot - (Stack3 + stack4))
3f5s6t := stack6 / (Stacktot - (Stack3 + stack5))
4f1s6t := stack6 / (Stacktot - (Stack4 + stack1))
4f2s6t := stack6 / (Stacktot - (Stack4 + stack2))
4f3s6t := stack6 / (Stacktot - (Stack4 + stack3))
4f5s6t := stack6 / (Stacktot - (Stack4 + stack5))
5f1s6t := stack6 / (Stacktot - (Stack5 + stack1))
5f2s6t := stack6 / (Stacktot - (Stack5 + stack2))
5f3s6t := stack6 / (Stacktot - (Stack5 + stack3))
5f4s6t := stack6 / (Stacktot - (Stack5 + stack4))
;chances of Stack1 finishing 3rd
1t := (2f3s1t * (2f * 2f3s)) + (2f4s1t * (2f * 2f4s)) + (2f5s1t * (2f * 2f5s)) + (2f6s1t * (2f * 2f6s))
1t := 1t + (3f2s1t * (3f * 3f2s)) + (3f4s1t * (3f * 3f4s)) + (3f5s1t * (3f * 3f5s)) + (3f6s1t * (3f * 3f6s))
1t := 1t + (4f2s1t * (4f * 4f2s)) + (4f3s1t * (4f * 4f3s)) + (4f5s1t * (4f * 4f5s)) + (4f6s1t * (4f * 4f6s))
1t := 1t + (5f2s1t * (5f * 5f2s)) + (5f3s1t * (5f * 5f3s)) + (5f4s1t * (5f * 5f4s)) + (5f6s1t * (5f * 5f6s))
1t := 1t + (6f2s1t * (6f * 6f2s)) + (6f3s1t * (6f * 6f3s)) + (6f4s1t * (6f * 6f4s)) + (6f5s1t * (6f * 6f5s))
;chances of Stack2 finishing 3rd
2t := (1f3s2t * (1f * 1f3s)) + (1f4s2t * (1f * 1f4s)) + (1f5s2t * (1f * 1f5s)) + (1f6s2t * (1f * 1f6s))
2t := 2t + (3f1s2t * (3f * 3f1s)) + (3f4s2t * (3f * 3f4s)) + (3f5s2t * (3f * 3f5s)) + (3f6s2t * (3f * 3f6s))
2t := 2t + (4f1s2t * (4f * 4f1s)) + (4f3s2t * (4f * 4f3s)) + (4f5s2t * (4f * 4f5s)) + (4f6s2t * (4f * 4f6s))
2t := 2t + (5f1s2t * (5f * 5f1s)) + (5f3s2t * (5f * 5f3s)) + (5f4s2t * (5f * 5f4s)) + (5f6s2t * (5f * 5f6s))
2t := 2t + (6f1s2t * (6f * 6f1s)) + (6f3s2t * (6f * 6f3s)) + (6f4s2t * (6f * 6f4s)) + (6f5s2t * (6f * 6f5s))
;chances of Stack3 finishing 3rd
3t := (1f2s3t * (1f * 1f2s)) + (1f4s3t * (1f * 1f4s)) + (1f5s3t * (1f * 1f5s)) + (1f6s3t * (1f * 1f6s))
3t := 3t + (2f1s3t * (2f * 2f1s)) + (2f4s3t * (2f * 2f4s)) + (2f5s3t * (2f * 2f5s)) + (2f6s3t * (2f * 2f6s))
3t := 3t + (4f1s3t * (4f * 4f1s)) + (4f2s3t * (4f * 4f2s)) + (4f5s3t * (4f * 4f5s)) + (4f6s3t * (4f * 4f6s))
3t := 3t + (5f1s3t * (5f * 5f1s)) + (5f2s3t * (5f * 5f2s)) + (5f4s3t * (5f * 5f4s)) + (5f6s3t * (5f * 5f6s))
3t := 3t + (6f1s3t * (6f * 6f1s)) + (6f2s3t * (6f * 6f2s)) + (6f4s3t * (6f * 6f4s)) + (6f5s3t * (6f * 6f5s))
;chances of Stack4 finishing 3rd
4t := (1f2s4t * (1f * 1f2s)) + (1f3s4t * (1f * 1f3s)) + (1f5s4t * (1f * 1f5s)) + (1f6s4t * (1f * 1f6s))
4t := 4t + (2f1s4t * (2f * 2f1s)) + (2f3s4t * (2f * 2f3s)) + (2f5s4t * (2f * 2f5s)) + (2f6s4t * (2f * 2f6s))
4t := 4t + (3f1s4t * (3f * 3f1s)) + (3f2s4t * (3f * 3f2s)) + (3f5s4t * (3f * 3f5s)) + (3f6s4t * (3f * 3f6s))
4t := 4t + (5f1s4t * (5f * 5f1s)) + (5f2s4t * (5f * 5f2s)) + (5f3s4t * (5f * 5f3s)) + (5f6s4t * (5f * 5f6s))
4t := 4t + (6f1s4t * (6f * 6f1s)) + (6f2s4t * (6f * 6f2s)) + (6f3s4t * (6f * 6f3s)) + (6f5s4t * (6f * 6f5s))
;chances of Stack5 finishing 3rd
5t := (1f2s5t * (1f * 1f2s)) + (1f3s5t * (1f * 1f3s)) + (1f4s5t * (1f * 1f4s)) + (1f6s5t * (1f * 1f6s))
5t := 5t + (2f1s5t * (2f * 2f1s)) + (2f3s5t * (2f * 2f3s)) + (2f4s5t * (2f * 2f4s)) + (2f6s5t * (2f * 2f6s))
5t := 5t + (3f1s5t * (3f * 3f1s)) + (3f2s5t * (3f * 3f2s)) + (3f4s5t * (3f * 3f4s)) + (3f6s5t * (3f * 3f6s))
5t := 5t + (4f1s5t * (4f * 4f1s)) + (4f2s5t * (4f * 4f2s)) + (4f3s5t * (4f * 4f3s)) + (4f6s5t * (4f * 4f6s))
5t := 5t + (6f1s5t * (6f * 6f1s)) + (6f2s5t * (6f * 6f2s)) + (6f3s5t * (6f * 6f3s)) + (6f4s5t * (6f * 6f4s))
;chances of Stack6 finishing 3rd
6t := (1f2s6t * (1f * 1f2s)) + (1f3s6t * (1f * 1f3s)) + (1f4s6t * (1f * 1f4s)) + (1f5s6t * (1f * 1f5s))
6t := 6t + (2f1s6t * (2f * 2f1s)) + (2f3s6t * (2f * 2f3s)) + (2f4s6t * (2f * 2f4s)) + (2f5s6t * (2f * 2f5s))
6t := 6t + (3f1s6t * (3f * 3f1s)) + (3f2s6t * (3f * 3f2s)) + (3f4s6t * (3f * 3f4s)) + (3f5s6t * (3f * 3f5s))
6t := 6t + (4f1s6t * (4f * 4f1s)) + (4f2s6t * (4f * 4f2s)) + (4f3s6t * (4f * 4f3s)) + (4f5s6t * (4f * 4f5s))
6t := 6t + (5f1s6t * (5f * 5f1s)) + (5f2s6t * (5f * 5f2s)) + (5f3s6t * (5f * 5f3s)) + (5f4s6t * (5f * 5f4s))
}
Else
sleep 1
}
abbrstr(string,newl) {
Length := StrLen(string)
if length > %newl%
{
triml := length - newl
StringTrimRight, string, string, %triml%
return string
}
else
if length < %newl%
{
addl := newl - length
Loop, %addl%
{
string := string . " "
}
return string
}
else
return string
}
grep(h, n, ByRef v, s = 1, e = 0, d = "") {
v =
StringReplace, h, h, %d%, , All
Loop
If s := RegExMatch(h, n, c, s)
p .= d . s, s += StrLen(c), v .= d . (e ? c%e% : c)
Else Return, SubStr(p, 2), v := SubStr(v, 2)
}
