public bool CheckHighLow(DiceBet NewBet, bool win, SessionStats Stats, out bool NewHigh, SiteStats siteStats)
{
NewHigh = false;
if (EnableSwitchWins && Stats.Wins % SwitchWins == 0)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchWinStreak && Stats.WinStreak % SwitchWinStreak == 0 && win)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchLosses && Stats.Losses % SwitchLosses == 0)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchLossStreak && Stats.LossStreak % SwitchLossStreak == 0 && !win)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchBets && Stats.Bets % SwitchBets == 0)
{
NewHigh = !NewBet.High;
return(true);
}
return(false);
}
public bool CheckTips(Bet NewBet, bool win, SessionStats Stats, out decimal Amount, SiteStats siteStats)
{
Amount = 0;
Amount = 0;
if (EnableUpperLimit && UpperLimitCompare == "Balance" && UpperLimitAction == LimitAction.Tip)
{
if (siteStats.Balance >= UpperLimit)
{
Amount = UpperLimitActionAmount;
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Balance" && LowerLimitAction == LimitAction.Tip)
{
if (siteStats.Balance <= LowerLimit)
{
Amount = LowerLimitActionAmount;
return(true);
}
}
if (EnableUpperLimit && UpperLimitCompare == "Profit" && UpperLimitAction == LimitAction.Tip)
{
if (Stats.Profit >= UpperLimit)
{
Amount = UpperLimitActionAmount;
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Profit" && LowerLimitAction == LimitAction.Tip)
{
if (Stats.Profit <= LowerLimit)
{
Amount = LowerLimitActionAmount;
return(true);
}
}
return(false);
}
public bool CheckResetSeed(Bet NewBet, bool win, SessionStats Stats, SiteStats siteStats)
{
if (EnableResetSeedBets && Stats.Bets % ResetSeedBets == 0)
{
return(true);
}
if (EnableResetSeedWins && Stats.Wins % ResetSeedWins == 0)
{
return(true);
}
if (EnableResetSeedLosses && Stats.Losses % ResetSeedLosses == 0)
{
return(true);
}
if (EnableResetSeedWinStreak && Stats.WinStreak % ResetSeedWinStreak == 0 && win)
{
return(true);
}
if (EnableResetSeedLossStreak && Stats.LossStreak % ResetSeedLossStreak == 0 && !win)
{
return(true);
}
return(false);
}
public bool CheckStopPOstStats(Bet NewBet, bool win, SessionStats Stats, out string reason, SiteStats siteStats)
{
if (EnableUpperLimit && UpperLimitCompare == "Balance" && UpperLimitAction == LimitAction.Stop)
{
if (siteStats.Balance >= UpperLimit)
{
reason = "Upper balance limit reached.";
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Balance" && LowerLimitAction == LimitAction.Stop)
{
if (siteStats.Balance <= LowerLimit)
{
reason = "lower balance limit reached.";
return(true);
}
}
if (EnableUpperLimit && UpperLimitCompare == "Profit" && UpperLimitAction == LimitAction.Stop)
{
if (Stats.Profit >= UpperLimit)
{
reason = "Upper profit limit reached. Stopping.";
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Profit" && LowerLimitAction == LimitAction.Stop)
{
if (Stats.Profit <= LowerLimit)
{
reason = "Lower profit limit reached. Stopping.";
return(true);
}
}
if (EnableStopAfterBets && Stats.Bets >= StopAfterBets)
{
reason = "Stop after " + StopAfterBets + " bets condition triggered with " + Stats.Bets + " bets, Stopping.";
return(true);
}
if (EnableStopAfterTime && (Stats.RunningTime + (long)(DateTime.Now - Stats.StartTime).TotalMilliseconds) > StopAfterTime)
{
reason = "Stop after " + StopAfterTime.ToString("HH:mm:ss") + " run time condition triggered with " + (new TimeSpan(0, 0, 0, 0, (int)(Stats.RunningTime + (long)(DateTime.Now - Stats.StartTime).TotalMilliseconds))).ToString("HH:mm:ss") + " running time, Stopping.";
return(true);
}
if (win)
{
if (EnableStopAfterWinStreak && Stats.WinStreak >= StopAfterWinStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterWinStreak, "Wines in a row", Stats.WinStreak);
return(true);
}
if (EnableStopAfterBtcWin && Stats.Profit >= StopAfterBtcWin)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcWin, "Currency Win", Stats.Profit);
return(true);
}
if (EnableStopAfterBtcWinStreak && Stats.CurrentProfit >= StopAfterBtcWinStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcWinStreak, "Currency Streak Win", Stats.CurrentProfit);
return(true);
}
if (EnableStopAfterWins && Stats.Wins % StopAfterWins == 0)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterWins, "Wins", Stats.Wins);
return(true);
}
if (EnableStopWinFromMinProfit && Stats.Profit - Stats.MinProfit >= StopWinFromMinProfit)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopWinFromMinProfit, "profit since min profit", Stats.Profit - Stats.MinProfit);
return(true);
}
}
else
{
if (EnableStopAfterLoseStreak && Stats.LossStreak >= StopAfterLoseStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterLoseStreak, "Losses in a row", Stats.LossStreak);
return(true);
}
if (EnableStopAfterBtcLoss && -Stats.Profit >= StopAfterBtcLoss)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcLoss, "Currency Loss", Stats.Profit);
return(true);
}
if (EnableStopAfterBtcLoseStreak && Stats.CurrentProfit <= -StopAfterBtcLoseStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcLoseStreak, "Currency Streak Loss", Stats.CurrentProfit);
return(true);
}
if (EnableStopAfterLosses && Stats.Losses % StopAfterLosses == 0)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterLosses, "Losses", Stats.Losses);
return(true);
}
if (EnableStopLossFromMaxProfit && Stats.MaxProfit - Stats.Profit >= StopLossFromMaxProfit)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopLossFromMaxProfit, "loss since max profit", Stats.MaxProfit - Stats.Profit);
return(true);
}
}
reason = "";
return(false);
}
public bool CheckStopPreStats(Bet NewBet, bool win, SessionStats Stats, out string reason, SiteStats siteStats)
{
reason = "";
return(false);
}
public bool CheckResetPostStats(Bet NewBet, bool win, SessionStats Statsn, SiteStats siteStats)
{
bool reset = false;
if (EnableResetAfterBets && Statsn.Bets % ResetAfterBets == 0)
{
reset = true;
}
if (EnableUpperLimit && UpperLimitCompare == "Balance" && UpperLimitAction == LimitAction.Reset)
{
reset = reset || (siteStats.Balance >= UpperLimit);
}
if (EnableLowerLimit && UpperLimitCompare == "Balance" && LowerLimitAction == LimitAction.Reset)
{
reset = reset || (siteStats.Balance <= LowerLimit);
}
if (EnableUpperLimit && UpperLimitCompare == "Profit" && UpperLimitAction == LimitAction.Reset)
{
if (Statsn.PorfitSinceLimitAction >= UpperLimit)
{
reset = true;
Statsn.PorfitSinceLimitAction = 0;
}
}
if (EnableLowerLimit && UpperLimitCompare == "Profit" && LowerLimitAction == LimitAction.Reset)
{
if (Statsn.PorfitSinceLimitAction >= LowerLimit)
{
reset = true;
Statsn.PorfitSinceLimitAction = 0;
}
}
if (win)
{
if (EnableResetAfterWinStreak && Statsn.WinStreak % ResetAfterWinStreak == 0)
{
reset = true;
}
if (EnableResetAfterBtcStreakWin && Statsn.StreakProfitSinceLastReset >= ResetAfterBtcStreakWin)
{
reset = true;
Statsn.StreakProfitSinceLastReset = 0;
}
if (EnableResetAfterBtcWin && Statsn.ProfitSinceLastReset >= ResetAfterBtcWin)
{
reset = true;
Statsn.ProfitSinceLastReset = 0;
}
if (EnableResetAfterWins && Statsn.Wins % ResetAfterWins == 0)
{
reset = true;
}
if (EnableResetWinFromMinProfit && Statsn.Profit - Statsn.MinProfitSinceReset >= ResetWinFromMinProfit)
{
Statsn.MinProfitSinceReset = Statsn.Profit;
reset = true;
}
}
else
{
if (EnableResetAfterLoseStreak && Statsn.LossStreak % ResetAfterLoseStreak == 0)
{
reset = true;
}
if (EnableResetAfterBtcStreakLoss && Statsn.StreakLossSinceLastReset <= -ResetAfterBtcStreakLoss)
{
reset = true;
Statsn.StreakLossSinceLastReset = 0;
}
if (EnableResetAfterBtcLoss && Statsn.ProfitSinceLastReset <= -ResetAfterBtcLoss)
{
reset = true;
Statsn.ProfitSinceLastReset = 0;
}
if (EnableResetAfterLosses && Statsn.Losses % ResetAfterLosses == 0)
{
reset = true;
}
if (EnableResetLossFromMaxProfit && Statsn.MaxProfitSinceReset - Statsn.Profit >= ResetLossFromMaxProfit)
{
Statsn.MaxProfitSinceReset = Statsn.Profit;
reset = true;
}
}
return(reset);
}
public bool CheckResetPreStats(Bet NewBet, bool win, SessionStats Stats, SiteStats siteStats)
{
return(false);
}
