Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Sandbox_script ver2.12 by Ruzli #7111, If you liked my sandbox and want say big thanks, or want support my team, you can make donation to our team here - 1GUU7UZLAWUAA58bx9zuJiTM7eLGUoK6wi
var config = {
//******************COMMON****************** */
PASTE_CASE: { label: "Paste", type: "text", value: "Paste raw text [see F12]" },
cb_globals: {
label: "Sandbox", type: "radio", value: "sandbox_mode", options: {
sandbox_mode: { label: "Sandbox Mode (if you set it to true will trigger below configuration to be used)", type: "noop", value: "" },
SETUP: { label: "Configuration Launch Case", type: "number", value: 0 },
merged: { label: "Run both in sandbox and configuration launch", type: "noop", value: "" },
}
},
//******************GLOBAL****************** */
riskHeader: { label: "Global Risk's Settings", type: "noop", value: "" },
RISK_FACTOR: { label: "Risk Factor (skipping amount - 1.0 = 100%, no skipping - 0.0 = 0%)", type: "multiplier", value: 0.7 },
RISK_MULTIPLIER: { label: "Risk Multiplier (multiplier amount - Add)", type: "multiplier", value: 0.0 },
RISK_BASE: { label: "Risk Base (overall base bet regulation)", type: "multiplier", value: 1.0 },
globalHeader: { label: "Global Settings (-1 = disable, 0 = auto)", type: "noop", value: "" },
sb_stw: { label: "STW - Streak To Wait", type: "number", value: 25 },
sb_increase_bb_on_streak: { label: "Increase basebet after streak happen(rolls)", type: "number", value: -1 },
//******************BETS****************** */
bettingHeader: { label: "Bets", type: "noop", value: "" },
sb_base_bet: { label: "Base Bet", type: "balance", value: 300 },
sb_max_bet_turns: { label: "Max Bet turns (set to -1 to play infinity amount of rolls until hit)", type: "number", value: 27 },
sb_increase_bb_on_wins: { label: "Increase basebet after hit win(satoshi)", type: "number", value: 20 },
sb_increase_bb_times: { label: "Increase basebet after hit win amount times", type: "number", value: 0 },
sb_max_bk_percent: { label: "Max percent bet of balance usage", type: "number", value: 100 },
cb_bets_modes: {
label: "Bet Change [sub, mul, add]", type: "radio", value: "mul", options: {
mul: { label: "Bet Multiplier", type: "multiplier", value: 1.08 },
add: { label: "Static Change", type: "balance", value: 100 },
}
},
//***************BETS CONDITIONS**************** */
bets_conditionHeader: { label: "Bets Conditions", type: "noop", value: "" },
sb_bets_maximal: { label: "Bet Maximal", type: "balance", value: 10000000 },
sb_bets_minimal: { label: "Bet Minimal", type: "balance", value: 100 },
sb_return_base: { label: "Return to base bet", type: "checkbox", value: true },
sb_return_on_win: { label: "Return on win", type: "checkbox", value: true },
sb_return_on_lose: { label: "Return on lose", type: "checkbox", value: false },
//******************TARGETS****************** */
cb_targets: {
label: "Targets", type: "radio", value: "sb_array", options: {
sb_base_target: { label: "Single Strategy", type: "number", value: 10 },
sb_array: { label: "List of Strategies", type: "text", value: "100, 150, 100, 200, 100, 350, 100, 500, 100, 1000" }, // 3, 5, 10, 14, 19, 35, 75, 100, 250
}
},
cb_target_modes: {
label:"Target Change [sub, mul, add]", type: "radio", value: "mul", options: {
mul: { label: "Target Multiplier", type: "multiplier", value: 1.0 },
add: { label: "Static Change", type: "number", value: 0.30 }
}
},
//**************TARGET CONDITIONS*************** */
targets_conditionHeader: { label: "Targets Conditions", type: "noop", value: "" },
sb_target_minimal: { label: "Minimal Target", type: "number", value: 2 },
sb_target_maximal: { label: "Maximal Target", type: "number", value: 10000 },
sb_target_return_base: { label: "Return to base target", type: "checkbox", value: false },
sb_target_return_on_win: { label: "Return on win", type: "checkbox", value: true },
sb_target_return_on_lose: { label: "Return on lose", type: "checkbox", value: false },
//******************GAMEPLAY MODIFICATIONS****************** Gameplay modifications (-1 = Disabled, 0 = Automatic fill) */
att_mod_cc_Header: { label: "Gameplay Feature - Chain chase", type: "noop", value: "" },
sb_chain_chase: { label: "Chain chase enabled", type: "checkbox", value: false },
sb_chain_chase_queue: { label: "Chain chase queue", type: "number", value: 3 },
att_ff__betsHeader: { label: "Gameplay Feature - Fast Betting", type: "noop", value: "" },
fast_betting_enabled: { label: "Use Fast Betting", type: "checkbox", value: false },
fast_betting_chase: { label: "Target", type: "multiplier", value: 1.01 },
fast_betting_wager: { label: "Flat bets", type: "balance", value: 100 },
att_mod_median_Header: { label: "Gameplay Feature - Median", type: "noop", value: "" },
sb_median_enabled: { label: "Use Median", type: "checkbox", value: false },
sb_median_bettable: { label: "Bettable bet", type: "multiplier", value: 0.1 },
sb_median_min_cut: { label: "Min cut", type: "multiplier", value: 1.5 },
sb_median_max_cut: { label: "Max cut", type: "multiplier", value: 2.0 },
sb_median_skips: { label: "Cargo size", type: "number", value: 3 },
att_mod_pullee_Header: { label: "Gameplay Feature - Pullee", type: "noop", value: "" },
sb_pullee_enabled: { label: "Use Pullee", type: "checkbox", value: false },
sb_pullee: { label: "Target Power", type: "multiplier", value: 0.1 },
//******************CONDITIONS****************** */
conditionHeader: { label: "Condition Regulations", type: "noop", value: "" },
minProfit: { label: "Amount allow to lose", type: "balance", value: -1000000 },
maxProfit: { label: "Maximal profit", type: "balance", value: 1000000 },
//******************OTHER*********************** */
otherHeader: { label: "Other Settings", type: "noop", value: "" },
sb_debug: { label: "Minimize output in logging", type: "checkbox", value: true },
sb_debug_common: { label: "Show debug logging", type: "checkbox", value: false },
sb_test: { label: "Test mode [for emulated rolls]", type: "checkbox", value: false },
sb_simulation_balance: { label: "Simulation Balance", type: "balance", value: 10000000 },
sb_simulation_mode: { label: "Simulation Mode", type: "checkbox", value: false },
sb_emulate_rolls: { label: "Emulate rolls", type: "checkbox", value: false },
sb_save_script: { label: "Save Script in text format", type: "checkbox", value: false },
};
var RISK_FACTOR = config.RISK_FACTOR.value /* Overall change for every target. Set to 0.0 to run without Streak To Wait(STW), set 1.0(100%, i.o. normal) to run with STW feature */
var RISK_MULTIPLIER = config.RISK_MULTIPLIER.value /* Overall change for all bets size after lose bet, value is added to base multiplier for every target */
var RISK_BASE = config.RISK_BASE.value /* Overall change for all targets base bet, if value set to 1, then basebet = 1, if value set to 0.2, then basebet = 20 satoshi */
var min_Profit = config.minProfit.value /* max lose before stop. In bits */
var max_Profit = config.maxProfit.value /* max profit before stop. In bits */
var change_seed_next_STW = 100000
var change_seed = 20000
var BET_PERCENT_FROM_BK = config.sb_max_bk_percent.value /* 100 = 100%, i.o use all balance to bet size */
var FORCE_STOP_IF_LOWER = 0 /* Don't allow balance drop lower than this value. 0 to disable this feature. */
const FULL = 1, NORMAL = 0
var simulation = config.sb_simulation_mode.value
var simulation_balance = config.sb_simulation_balance.value
var simulation_MODE = NORMAL /* NORMAL - DON'T SHOW TARGET / FULL - SHOW PLACE TARGET */
var HIT_MIN_PROFIT_TIMES = 1 /* Moving stop, after reach minProfit X times it will reset script, 0 to disable */
var HIT_MAX_PROFIT_TIMES = 1 /* Moving profit reacher, when hit maxProfit, do reset profit, so you don't risk it, 0 to disable */
const LONGEST_DIFFCULTY = 16 /* STW calculated based on this formula */
const PLAY_IN_RANGE = 4 /* Seed numbers has 4 distances, early, mid, late, extra late */
const ver = 2.12
// clientSeed, gameSeed, auditSeed
var auditSeed = "469cd022ade40d200fded1da1704709db25bba932ca1bf9c74516b4babc61e6e" //"04097893aa9456880f62b29d4c52cf256935868cf50f0eae7ba9c6c02099b589"
var clientSeed = "b27cd3fe415600657a29590fb07e78e12a45075aec492061e3a52ca5c0f6057b"
var gameSeed = `glorious subdued berry`
var setup = config.cb_globals.options.SETUP.value /* Preset configuration selector */
/** Number you set must be in function load_pattern() > switch statement > case with number. */
var fast_loading_config = true /* Don't wait when script will launch, force it launch immediatly */
var allow_seed_reset = true /* Set rule for seed being reset only when all tactics have ended their period */
var ex = { /* Global settings to game */ /*(990000 / ( 100 * (multiplier + 0.01) * 100 - 1))*/
calculate_base: false, /* For big balances, automatically calculates effecient multiplier and STW */
analyze_streaks: true, /* STW mechanism */
winning_frequency: false, // BETA
luck_usage: false, // BETA
reset_to_first_on_hit_win: false, /* Reset all memory bets to base bets after one of targets has won */
increase_STW_by_same_targets: false, /* Increases STW by one with same target and STW amount */
reset_STW_after_game_pass: true,
disable_target_at_bust: false, /* Make current playing target at bust go offline till it ressurect's */
increasing_bets_at_peak: false, /* If tactic have memorized bets, and loses 2 full cycles, it will increase and decrease base bets */
increasing_bets_at_peak_value: 2, /* Multiply base bet on that amount */
mul_target: 1.0,
stop_on_streak_catch: false,
game_sounds: true,
interval_rolls: 0, /* Pause between rolls */
debug: config.sb_debug_common.value, /* Logging output enabled or disabled */
advanced_log: !config.sb_debug.value, /* Logging output for more detailed information, ignores debug value */
reset_static_stats_on_launch: true, /* Reset static client stats on script launch */
session_game: {
enabled: false, /* SessionProfit will risk profit after reach this amount of overall profit */
sessionProfit: 500, /* Amount in bits to risk while chase high multipliers after accuiring that amount of overall profit */
sessionBet: 10, /* Amount to bet while chasing high multipliers after sessionProfit triggered */
sessionTarget: 5, /* Target and higher will trigger sessionProfit to start */
sessionMode: true, /* Single bet session profit or multiple */
},
hard_style: {
enabled: false,
max_loss: -25000,
multiplier: 0.08,
streak_range: 2,
},
fast_betting: {
enabled: config.fast_betting_enabled.value,
wager: config.fast_betting_wager.value,
chase: config.fast_betting_chase.value,
},
stats_logging: {
median: !config.sb_debug.value,
median_cargo: 20000,
median_history: false,
},
increase_basebet_after_streak: config.sb_increase_bb_on_streak.value, // Increase basebet after reach streak amount you set in GUI
increase_basebet_on_wins: config.sb_increase_bb_on_wins.value, // Increase basebet on amount of satoshi you set each time you win unless increase_times more than 0
increase_basebet_times: config.sb_increase_bb_times.value, // Specify for streaks/wins (two values above) amount of times to repeat this, 0 to disable, more than 1 will activate it(each trigger decreases this value)
}
var engine = this
var last_strategy = null
var change_seed_next = change_seed_next_STW
var game_array = new Array(), patterns = new Array(), history = [], queue = [], log_history = [], rolls_history = [], cases = new Array();
var PLAY_HARD = false
var skip_enabled = true
var downloaded = false /* Flag for do once operation as prompt save script case */
var notification_timeout = 5;
var cool_down = 10;
const queueSize = 5;
var skipStep = 1; /* 0 = skip | 1 = bet */
var minProfit = min_Profit, maxProfit = max_Profit; // Converting to satoshies
const RISK_MULTIPLIER_DEFAULT = config.RISK_MULTIPLIER.value;
const RISK_FACTOR_DEFAULT = config.RISK_FACTOR.value;
const RISK_BASE_DEFAULT = config.RISK_BASE.value;
var nonce = 0, PROFIT = 0, TOTAL_BETS = 0, TOTAL_ROLLS = 0, TOTAL_WINS = 0, profit_times = 0,
hard_style_played = 0, WINS_OVERALL = 0, session_value = 0, STREAK_ROLL = 0, luck_activation = 0;
var output_message = ``, output_msg = ``, luck_output = ``, output_features = ``
var skips_used_by_median = 3, results = [], loses = [], vectorApex, nextBet, DEBUG = true, BET_BALANCE = 0.1;
var diffculty_sleep = ex.interval_rolls;
/* Syntax to use game_array.push(new Strategy(TARGET, basebet, max turns, STW, multiplier, return_to_base)) */
async function load_pattern() {
Sandbox_delete_strategies()
let description = ``
let listing = ``
let cost = ``
let targets = 9.44 // for some cases common setting
let multipliers = 1.2 // for some cases common setting
let segmentar_betting_sectors = 6
if (config.cb_globals.value == "sandbox_mode" || config.cb_globals.value == "merged") {
description = `Sandbox mode`
engine.log(description)
await ScriptConstructorArea()
engine.log(`Reading GUI`)
}
if (config.cb_globals.value == "SETUP" || config.cb_globals.value == "merged") {
switch (config.cb_globals.options.SETUP.value) {
case 1:
description = `Create randomized targets, with random bets, turns, stws`
ex.disable_target_at_bust = true
ex.increase_STW_by_same_targets = false
ex.increasing_bets_at_peak = true
ex.reset_STW_after_game_pass = false
ex.reset_to_first_on_hit_win = true
RISK_BASE = 1.0
RISK_FACTOR =
minProfit = 500 * 100
maxProfit = 500 * 100
HIT_MAX_PROFIT_TIMES = 30
HIT_MIN_PROFIT_TIMES = 30
for (let i = 1; i < segmentar_betting_sectors; i++) {
let rnd_bet = 5
let rnd_target = 16
let rnd_turn = 5
let temp = get_random(1.2) * rnd_target
game_array.push(new Strategy(temp, get_random(1.5) * rnd_bet, get_random(1.2) * rnd_turn, 0, get_formula_multiplier(temp) + RISK_MULTIPLIER, true))
}
Sandbox_do_sort_random()
break;
case 2:
description = `Segmentar for 9.44 with 8 max turns and 8 stw and high various Math.pow`
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.6), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.8), 6, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.4), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.7), 6, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.1), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.3), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.5), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(1 * RISK_BASE, 2.72), 6, 8, multipliers))
break;
case 3:
description = `Segmentar for 9.44 with 8 max turns and 8 stw`
game_array.push(new Strategy(targets, Math.pow(5, 2.72), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(6, 2.72), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(7, 2.72), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(8, 2.72), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(9, 2.72), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(10, 2.72), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(11, 2.72), 8, 8, multipliers))
game_array.push(new Strategy(targets, Math.pow(12, 2.72), 8, 8, multipliers))
break;
case 4:
description = `Single safe 4.72x play`
cost = `15.000 bits`
RISK_BASE = 1.0
RISK_FACTOR = 1.0
RISK_MULTIPLIER = 0.01
game_array.push(new Strategy(4.72, 2))
break;
case 5:
description = `Many multiplier targets with high multipliers play and risk_multiplier set to 0`
cost = `30.000 bits bankroll`
/* Target arrays: 5x - 25x, risk: multiplier 0.0, base 3.0, factor 0.7 */
for (let i = 0; i < 5; i++) {
RISK_BASE = 1.0
RISK_FACTOR = 1.0
RISK_MULTIPLIER = 0.0
let lower_chase_target = i * 5 + 5
let lower_chase_max_turns = 3 * lower_chase_target // To disable max turns, change value to 0.
game_array.push(new Strategy(lower_chase_target, 1, lower_chase_max_turns, get_stw(lower_chase_target), get_formula_multiplier(lower_chase_target), true))
}
/* Target arrays: 30x - 45x, risk: multiplier 0.0, base 1.0, factor 0.8 */
for (let i = 5; i < 10; i++) {
RISK_BASE = 1.0
RISK_FACTOR = 1.0
RISK_MULTIPLIER = 0.0
game_array.push(new Strategy(i * 5 + 5))
}
/* Target arrays: 50x - 95x, risk: multiplier 0.0, base 1.0, factor 1.2 */
for (let i = 0; i < 9; i++) {
RISK_FACTOR = 1.1
RISK_BASE = 1
RISK_MULTIPLIER = 0.0
game_array.push(new Strategy(i * 5 + 50))
}
/* Target arrays: 100x - 200x, risk: multiplier 0.0, base 1.0, factor 1.0 */
for (let i = 0; i < 10; i++) {
RISK_FACTOR = 1.2
RISK_BASE = 1.0
RISK_MULTIPLIER = 0.0
game_array.push(new Strategy(i * 10 + 100))
}
/* Target arrays: 200x - 450x, risk: multiplier 0.0, base 1.0, factor 1.0 */
for (let i = 0; i < 10; i++) {
RISK_FACTOR = 1.35
RISK_BASE = 1.0
RISK_MULTIPLIER = 0.0
game_array.push(new Strategy(i * 25 + 200))
}
/* Target arrays: 500x - 1000x, risk: multiplier 0.0, base 1.0, factor 1.2 */
for (let i = 0; i < 10; i++) {
RISK_FACTOR = 1.5
RISK_BASE = 1.0
RISK_MULTIPLIER = 0.0
game_array.push(new Strategy(i * 50 + 500))
}
/* Target arrays: 5000x - 10000x, risk: multiplier 0.0, base 1.0, factor 1.3 */
for (let i = 0; i < 10; i++) {
RISK_FACTOR = 2.0
RISK_BASE = 1.0
RISK_MULTIPLIER = 0.0
game_array.push(new Strategy(i * 500 + 5000))
}
RISK_FACTOR = 1.0
RISK_BASE = 1.0
RISK_MULTIPLIER = 0.0
break;
case 6:
description = `Many targets from 5x to 1000x`
cost = `30.000 bits`
for (let i = 5; i < 999; i++) {
game_array.push(new Strategy(i))
}
break;
case 7:
description = `26.6x playing with chains`
cost = `30.000 bits`
ex.analyze_streaks = true
//game_array.push(new Strategy(26.6, 1, 0, 30, 1.049))
game_array.push(new Strategy(26, 1))
game_array[ 0 ].Settings.modifications.chain_chase.enabled = true
game_array[ 0 ].Settings.modifications.chain_chase.queue_base = 1
break;
case 8:
description = `Target manipulation: 20x to 5x; 5x to 20x; 100x to 35x`
cost = `5.000 bits`
ex.analyze_streaks = false
RISK_FACTOR = 0.0
let play_20x = true;
let play_5x = true;
let play_100x = false;
if (play_20x) {
game_array.push(new Strategy(20, 1))
game_array[ 0 ].Settings.target.multiplier = 0.95
game_array[ 0 ].Settings.target.maximal = 20
game_array[ 0 ].Settings.target.minimal = 5
game_array[ 0 ].Settings.target.digits_round = 0
game_array[ 0 ].Settings.bet.maximal = 1.2
game_array[ 0 ].Settings.bet.base = 1
game_array[ 0 ].Settings.bet.multiplier = 1.113
game_array[ 0 ].Settings.target.return_at.on_win = true
}
if (play_5x) {
game_array.push(new Strategy(5, 1))
game_array[ 1 ].Settings.target.multiplier = 1.0
game_array[ 1 ].Settings.target.maximal = 4
game_array[ 1 ].Settings.target.minimal = 4
game_array[ 1 ].Settings.target.base = 4
game_array[ 1 ].Settings.bet.maximal = 1.2
game_array[ 1 ].Settings.bet.base = 1
game_array[ 1 ].Settings.bet.multiplier = 1.3
game_array[ 1 ].Settings.target.return_at.on_win = true
}
if (play_100x) {
game_array.push(new Strategy(100, 1))
game_array[ 2 ].Settings.target.multiplier = 0.98
game_array[ 2 ].Settings.target.maximal = 100
game_array[ 2 ].Settings.target.minimal = 35
game_array[ 2 ].Settings.target.digits_round = 0
game_array[ 2 ].Settings.bet.maximal = 0.35
game_array[ 2 ].Settings.bet.base = 1
game_array[ 2 ].Settings.bet.multiplier = 1.015
game_array[ 2 ].Settings.target.return_at.on_win = true
}
for (let i = 0; i < game_array.length; i++) {
game_array[ i ].Settings.modifications.chain_chase.enabled = true
if (game_array[ i ].target > 40) {
game_array[ i ].Settings.modifications.chain_chase.queue = 1
game_array[ i ].Settings.modifications.chain_chase.queue_base = 1
} else {
game_array[ i ].Settings.modifications.chain_chase.queue = 2
game_array[ i ].Settings.modifications.chain_chase.queue_base = 2
}
}
break;
case 9:
description = `Target manipulation: 20x to 5x;`
cost = `5.000 bits`
ex.analyze_streaks = false;
RISK_FACTOR = 0.0;
game_array.push(new Strategy(20, 1));
game_array[ 0 ].Settings.target.multiplier = -1;
game_array[ 0 ].Settings.target.mode = "add";
game_array[ 0 ].Settings.target.return_at.on_win = true;
game_array[ 0 ].Settings.target.maximal = 20;
game_array[ 0 ].Settings.target.minimal = 5;
//game_array[ 0 ].Settings.target.digits_round = 0
game_array[ 0 ].Settings.bet.base = 1;
game_array[ 0 ].Settings.bet.multiplier = 1.1;
break;
case 10:
ex.analyze_streaks = true;
RISK_FACTOR = 1;
RISK_MULTIPLIER = 0;
RISK_BASE = 1;
BET_PERCENT_FROM_BK = 100;
minProfit = -500000;
maxProfit = 500000;
simulation = false;
simulation_balance = 100000;
ex.increase_basebet_after_streak = -1;
ex.increase_basebet_on_wins = 0;
ex.increase_basebet_times = 0;
game_array.push(new Strategy(10, 100, 35, 7, 1.12, true));
game_array[ 0 ].target = 10;
game_array[ 0 ].basebet = 100;
game_array[ 0 ].basebet_default = 100;
game_array[ 0 ].bet = 100;
game_array[ 0 ].MAX_BET_TURNS = 35;
game_array[ 0 ].STW = 7;
game_array[ 0 ].enabled = true;
game_array[ 0 ].Settings.bet.multiplier = 1.12;
game_array[ 0 ].Settings.bet.base = 100;
game_array[ 0 ].Settings.bet.mode = "mul";
game_array[ 0 ].Settings.bet.minimal = 100;
game_array[ 0 ].Settings.bet.maximal = 4800;
game_array[ 0 ].Settings.bet.return_at.RETURN_BASE = true;
game_array[ 0 ].Settings.bet.return_at.on_win = true;
game_array[ 0 ].Settings.bet.return_at.on_lose = false;
game_array[ 0 ].Settings.target.multiplier = 1;
game_array[ 0 ].Settings.target.base = 10;
game_array[ 0 ].Settings.target.mode = "mul";
game_array[ 0 ].Settings.target.minimal = 1.01;
game_array[ 0 ].Settings.target.maximal = 10000;
game_array[ 0 ].Settings.target.return_at.return = false;
game_array[ 0 ].Settings.target.return_at.on_win = true;
game_array[ 0 ].Settings.target.return_at.on_lose = false;
break;
}
}
if (config.cb_globals.options.SETUP.value == -1 || config.PASTE_CASE.value != `Paste raw text [see F12]`) {
eval("{" + config.PASTE_CASE.value + "}")
}
if (!config.sb_simulation_mode.value && config.sb_emulate_rolls.value){
simulation_balance = engine.balance / 100
}
if (!fast_loading_config && config.cb_globals.options.SETUP.value != 0) {
engine.log(`Setup [${setup}] [${description}] [${cost}] being initialized.`)
engine.log(`There is list of ${game_array.length} strategies will play:`)
let arr_tar = []
for (let i = 0; i < game_array.length; i++) {
listing = listing + `${game_array[ i ].target}x, `
arr_tar.push(game_array[ i ].target)
}
engine.log(listing)
}
form_cases()
}
/* Syntax to use game_array.push(new Strategy(TARGET, basebet, max turns, STW, multiplier, return_to_base)) */
async function ScriptConstructorArea(){
var numArray = JSON.parse(`[${config.cb_targets.options.sb_array.value}]`);
let len = numArray
let sm_bb = config.sb_base_bet.value / 100
let sm_t = config.cb_targets.options.sb_base_target.value
let sm_mbt = config.sb_max_bet_turns.value
let sm_stw = config.sb_stw.value
let sm_mul = config.cb_bets_modes.options.mul.value
let sm_rb = config.sb_return_base.value
let sm_mode = config.cb_target_modes.value
if (sm_bb == 0){ sm_bb = 1};
await engine.log(`Constructing Script`)
switch (sm_mbt) {
case -1:
sm_mbt = 0
sm_rb = true
break;
case 0:
sm_mbt = get_max_turns(sm_t)
sm_rb = false
break;
};
switch (sm_mul) {
case -1:
sm_mul = 1.0
break;
case 0:
sm_mul = get_formula_multiplier(sm_t)
break;
};
switch (sm_stw) {
case -1:
sm_stw = 0
ex.analyze_streaks = false
ex.reset_STW_after_game_pass = false
break;
case 0:
ex.analyze_streaks = true
ex.reset_STW_after_game_pass = true
sm_stw = get_stw(sm_t)
break;
case sm_stw > 0:
ex.analyze_streaks = true
ex.reset_STW_after_game_pass = true
break;
};
if (config.cb_targets.value == `sb_array`) {
for (var i = 0; i < numArray.length; i++) {
if (sm_mbt == 0) {
sm_rb = false
sm_mbt = get_max_turns(numArray[ i ])
}
if (config.sb_stw.value == 0) {
ex.analyze_streaks = true
ex.reset_STW_after_game_pass = true
sm_stw = get_stw(numArray[ i ])
}
if (config.sb_stw.value == -1) {
ex.analyze_streaks = false
ex.reset_STW_after_game_pass = false
sm_stw = 0
}
if (config.cb_bets_modes.options.mul.value == 0) { sm_mul = get_formula_multiplier(numArray[ i ]) }
game_array.push(new Strategy(numArray[ i ], sm_bb, sm_mbt, sm_stw, sm_mul, sm_rb)) /* Generate tactics */
await ScriptMasterizeArea(i)
engine.log(`sm_bb ${sm_bb}; sm_t ${numArray[ i ]}; sm_mbt ${sm_mbt}; sm_stw ${sm_stw}; sm_mul ${sm_mul}; sm_rb ${sm_rb}`)
};
};
if (config.cb_targets.value == `sb_base_target`) {
game_array.push(new Strategy(sm_t, sm_bb, sm_mbt, sm_stw, sm_mul, sm_rb)) /* Generate tactic */
await ScriptMasterizeArea(0)
engine.log(`sm_bb ${sm_bb}; sm_t ${sm_t}; sm_mbt ${sm_mbt}; sm_stw ${sm_stw}; sm_mul ${sm_mul}; sm_rb ${sm_rb}`)
};
//let isBustable = await check_bustable(clientSeed, auditSeed, gameSeed, 200, true, true, 0)
};
/* Allign GUI to Script logic. */
async function ScriptMasterizeArea(number){
/* Bet */
game_array[number].Settings.bet.base = game_array[number].basebet_default
game_array[number].Settings.bet.maximal = config.sb_bets_maximal.value
game_array[number].Settings.bet.minimal = config.sb_bets_minimal.value
game_array[number].Settings.bet.mode = config.cb_bets_modes.value // Will show 'mul' or 'add' of string value
if (game_array[number].Settings.bet.mode == "mul"){
let temp_mul = config.cb_bets_modes.options.mul.value
if (temp_mul == 0){
temp_mul = get_formula_multiplier(game_array[number].target)
}
game_array[number].Settings.bet.multiplier = temp_mul
}
if (game_array[number].Settings.bet.mode == "add"){
game_array[number].Settings.bet.multiplier = config.cb_bets_modes.options.add.value
}
game_array[number].Settings.bet.return_at.RETURN_BASE = config.sb_return_base.value
game_array[number].Settings.bet.return_at.on_lose = config.sb_return_on_lose.value
game_array[number].Settings.bet.return_at.on_win = config.sb_return_on_win.value
/* Target */
game_array[number].Settings.target.base = game_array[number].target
game_array[number].Settings.target.minimal = config.sb_target_minimal.value
game_array[number].Settings.target.maximal = config.sb_target_maximal.value
game_array[number].Settings.target.mode = config.cb_target_modes.value
if (game_array[number].Settings.target.mode == "mul"){
game_array[number].Settings.target.multiplier = config.cb_target_modes.options.mul.value
}
if (game_array[number].Settings.target.mode == "add"){
game_array[number].Settings.target.multiplier = config.cb_target_modes.options.add.value
}
game_array[number].Settings.target.return_at.return = config.sb_target_return_base.value
game_array[number].Settings.target.return_at.on_win = config.sb_target_return_on_win.value
game_array[number].Settings.target.return_at.on_lose = config.sb_target_return_on_lose.value
//game_array[number].Settings.target.digits_round
/* Modifications */
game_array[number].Settings.modifications.chain_chase.enabled = config.sb_chain_chase.value
game_array[number].Settings.modifications.chain_chase.queue_base = config.sb_chain_chase_queue.value
game_array[number].Settings.modifications.median.enabled = config.sb_median_enabled.value
game_array[number].Settings.modifications.median.bet_balance = config.sb_median_bettable.value
game_array[number].Settings.modifications.median.max_cut = config.sb_median_max_cut.value
game_array[number].Settings.modifications.median.min_cut = config.sb_median_min_cut.value
game_array[number].Settings.modifications.median.skips_used_by_median = config.sb_median_skips.value
game_array[number].Settings.modifications.pullee.enabled = config.sb_pullee_enabled.value
game_array[number].Settings.modifications.pullee.power = config.sb_pullee.value
/* Triggers */
if (game_array[number].Settings.modifications.median.enabled){
ex.analyze_streaks = true
game_array[number].ACTION = await median_loop(game_array[number])
}
if (game_array[ number ].Settings.modifications.pullee.enabled){
ex.analyze_streaks = false
let bet_base = config.sb_bets_minimal.value
let bet_max = config.sb_bets_minimal.value
let bet_power = config.cb_bets_modes.options.mul.value
let target_base = config.sb_target_minimal.value
let target_max = config.sb_target_maximal.value
let target_power = config.sb_pullee.value
let target_pull = CreatePullee(target_base, target_base, target_max, target_power)();
let bet_pull = CreatePullee(bet_base, bet_base, bet_max, bet_power)();
game_array[ number ].ACTION = await strategy_pullee(bet_pull, target_pull)
};
};
function console_write_create_launch(){
let output = ``
output+= `ex.analyze_streaks = ${ex.analyze_streaks};\n\n`
output+= `RISK_FACTOR = ${RISK_FACTOR};\n`
output+= `RISK_MULTIPLIER = ${RISK_MULTIPLIER};\n`
output+= `RISK_BASE = ${RISK_BASE};\n`
output+= `BET_PERCENT_FROM_BK = ${BET_PERCENT_FROM_BK};\n\n`
output+= `minProfit = ${minProfit};\n`
output+= `maxProfit = ${maxProfit};\n\n`
//output+= `simulation = ${simulation};\n`
//output+= `simulation_balance = ${simulation_balance};\n\n`
output+= `ex.increase_basebet_after_streak = ${ex.increase_basebet_after_streak};\n`
output+= `ex.increase_basebet_on_wins = ${ex.increase_basebet_on_wins};\n`
output+= `ex.increase_basebet_times = ${ex.increase_basebet_times};\n\n`
for (let i = 0; i < game_array.length; i++){
let gs = game_array[i]
output+= `game_array.push(new Strategy(${gs.target}, ${config.sb_base_bet.value}, ${gs.MAX_BET_TURNS}, ${gs.STW}, ${gs.Settings.bet.multiplier}, ${gs.Settings.bet.return_at.RETURN_BASE}));\n`
}
output+= `\n`
for (let i = 0; i < game_array.length; i++){
let gs = game_array[i]
output+= `game_array[ ${i} ].target = ${gs.target};\n`
output+= `game_array[ ${i} ].basebet = ${config.sb_base_bet.value};\n`
output+= `game_array[ ${i} ].basebet_default = ${config.sb_base_bet.value};\n`
output+= `game_array[ ${i} ].bet = ${config.sb_base_bet.value};\n`
output+= `game_array[ ${i} ].MAX_BET_TURNS = ${gs.MAX_BET_TURNS};\n`
output+= `game_array[ ${i} ].STW = ${gs.STW};\n`
output+= `game_array[ ${i} ].enabled = ${gs.enabled};\n\n`
/* Object Bet Attributes || bet: multiplier, base, mode(mul/add), minimal, maximal, return_at(RETURN_BASE, on_win, on_lose) */
let temp_mul = gs.Settings.bet.multiplier
if (temp_mul == 0){
temp_mul = get_formula_multiplier(gs.Settings.target)
}
output+= `game_array[ ${i} ].Settings.bet.multiplier = ${gs.Settings.bet.multiplier};\n`
output+= `game_array[ ${i} ].Settings.bet.base = ${gs.Settings.bet.base};\n`
output+= `game_array[ ${i} ].Settings.bet.mode = "${gs.Settings.bet.mode}";\n`
output+= `game_array[ ${i} ].Settings.bet.minimal = ${gs.Settings.bet.minimal};\n`
output+= `game_array[ ${i} ].Settings.bet.maximal = ${gs.Settings.bet.maximal};\n`
output+= `game_array[ ${i} ].Settings.bet.return_at.RETURN_BASE = ${gs.Settings.bet.return_at.RETURN_BASE};\n`
output+= `game_array[ ${i} ].Settings.bet.return_at.on_win = ${gs.Settings.bet.return_at.on_win};\n`
output+= `game_array[ ${i} ].Settings.bet.return_at.on_lose = ${gs.Settings.bet.return_at.on_lose};\n\n`
/* Object Target Attributes || target: multiplier, base, mode(mul/add), minimal, maximal, return_at(return, on_win, on_lose) */
output+= `game_array[ ${i} ].Settings.target.multiplier = ${gs.Settings.target.multiplier};\n`
output+= `game_array[ ${i} ].Settings.target.base = ${gs.Settings.target.base};\n`
output+= `game_array[ ${i} ].Settings.target.mode = "${gs.Settings.target.mode}";\n`
output+= `game_array[ ${i} ].Settings.target.minimal = ${gs.Settings.target.minimal};\n`
output+= `game_array[ ${i} ].Settings.target.maximal = ${gs.Settings.target.maximal};\n`
output+= `game_array[ ${i} ].Settings.target.return_at.return = ${gs.Settings.target.return_at.return};\n`
output+= `game_array[ ${i} ].Settings.target.return_at.on_win = ${gs.Settings.target.return_at.on_win};\n`
output+= `game_array[ ${i} ].Settings.target.return_at.on_lose = ${gs.Settings.target.return_at.on_lose};\n\n\n`
/* Object Trigger Attribute */
output+= `game_array[ ${i} ].ACTION = async function () { await strategy_play(this) };\n\n`
/* Object Modifications - Chain Chase */
if (gs.Settings.modifications.chain_chase.enabled){
output+= `game_array[ ${i} ].Settings.modifications.chain_chase.enabled = ${gs.Settings.modifications.chain_chase.enabled};\n`
output+= `game_array[ ${i} ].Settings.modifications.chain_chase.queue_base = ${gs.Settings.modifications.chain_chase.queue_base};\n\n`
}
/* Object Modifications - Median */
if (gs.Settings.modifications.median.enabled){
output+= `ex.analyze_streaks = true;\n`
output+= `game_array[ ${i} ].ACTION = await median_loop(game_array[ ${i} ]);\n`
output+= `game_array[ ${i} ].Settings.modifications.median.enabled = ${gs.Settings.modifications.median.enabled};\n`
output+= `game_array[ ${i} ].Settings.modifications.median.min_cut = ${gs.Settings.modifications.median.min_cut};\n`
output+= `game_array[ ${i} ].Settings.modifications.median.max_cut = ${gs.Settings.modifications.median.max_cut};\n`
output+= `game_array[ ${i} ].Settings.modifications.median.bet_balance = ${gs.Settings.modifications.median.bet_balance};\n`
output+= `game_array[ ${i} ].Settings.modifications.median.skips_used_by_median = ${gs.Settings.modifications.median.skips_used_by_median};\n\n`
}
/* Object Modifications - Pullee */
if (gs.Settings.modifications.pullee.enabled){
output+= `ex.analyze_streaks = false;\n`
output+= `let bet_base = config.sb_bets_minimal.value;\n`
output+= `let bet_max = config.sb_bets_minimal.value;\n`
output+= `let bet_power = config.cb_bets_modes.options.mul.value;\n\n`
output+= `let target_base = config.sb_target_minimal.value;\n`
output+= `let target_max = config.sb_target_maximal.value;\n`
output+= `let target_power = config.sb_pullee.value;\n\n`
output+= `let target_pull = CreatePullee(target_base, target_base, target_max, target_power)();\n`
output+= `let bet_pull = CreatePullee(bet_base, bet_base, bet_max, bet_power)();\n\n`
output+= `game_array[ ${i} ].ACTION = await strategy_pullee(bet_pull, target_pull);\n`
output+= `game_array[ ${i} ].Settings.modifications.pullee.enabled = ${gs.Settings.modifications.pullee.enabled};\n`
output+= `game_array[ ${i} ].Settings.modifications.pullee.power = ${gs.Settings.modifications.pullee.power};\n`
};
};
if (config.PASTE_CASE.value == `Paste raw text [see F12]`){
console.log(output)
if (config.sb_save_script.value && !downloaded){
downloaded = true
downloadString(output, "txt", "ScriptCase.txt")
}
} else {
console.log(config.PASTE_CASE.value)
}
};
/* Form prompt for save file with selected information. */
function downloadString(text, fileType, fileName) {
var blob = new Blob([text], { type: fileType });
var a = document.createElement('a');
a.download = fileName;
a.href = URL.createObjectURL(blob);
a.dataset.downloadurl = [fileType, a.download, a.href].join(':');
a.style.display = "none";
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
setTimeout(function() { URL.revokeObjectURL(a.href); }, 1500);
};
/* Download CSV table history of rolls */
function downloadRolls(){
downloadString(engine.log_history, `text/csv`, `rolls_history.csv`)
};
/* Sandbox Constructor - Set all strategies bets return to base. */
function Sandbox_set_return_to_base(isOn = false) {
for (let i = 0; i < game_array.length; i++) {
game_array[ i ].Settings.bet.return_at.RETURN_BASE = isOn;
}
};
/* Sandbox Constructor - Set max bet turns to infinity amount. */
function Sandbox_off_max_bet_turns() {
for (let i = 0; i < game_array.length; i++) {
game_array[ i ].MAX_BET_TURNS = 0
}
};
/* HARD_STYLE TABLE for maximum profit, ps not using it anymore. */
var bet_levels_hard_hit_mod = {
T2_36: { base: 26, prev: 2 },
T4_72: { base: 12, prev: 2 },
T9_44: { base: 3, prev: 3 },
T15: { base: 1, prev: 1 },
T30: { base: 1, prev: 1 },
T60: { base: 16, prev: 6 },
T100: { base: 6, prev: 1 },
};
function check_multiplier(balance, turns, wager = 100, precision = 5) {
let num = 0, bal = balance, mul = 1.01, last = mul;
let p = 0, inc = 0.1;
for (let mul = 1.01; mul < balance; mul += inc) {
bal = balance, num = 0
while (bal > 0) {
bal -= (wager * Math.pow(mul, num));
num++;
}
if (num < turns) {
if (p >= precision) return last;
p++ , mul = last, inc /= 10;
}
last = mul;
}
};
async function calculate_bankroll() {
let balance = 0
if (!simulation) {
engine.log(`Starting calculating max turns for balance ${engine.balance / 100}`)
balance = engine.balance
} else {
engine.log(`Starting calculating max turns for simulated balance ${simulation_balance / 100}`)
balance = simulation_balance
}
for (let i = 0; i < game_array.length; i++) {
if (ex.debug) {
engine.log(`Calculating bets for ${game_array[ i ].target}x, base bet ${game_array[ i ].basebet / 100}, STW ${game_array[ i ].STW}`)
engine.log(`${game_array[ i ].target}x, mul ${game_array[ i ].Settings.bet.multiplier.toFixed(5)}`)
}
let last_bet_size = 0
let turns = 0
let start_bet_size = game_array[ i ].basebet
let bet_size = start_bet_size
let cost = 0
let longest = Math.round(game_array[ i ].target * LONGEST_DIFFCULTY)
let solution_found = false
let multiplier_found = false
while (!solution_found) {
turns++
last_bet_size = bet_size
bet_size *= game_array[ i ].multiplier
cost = cost + bet_size
if (cost > balance) {
turns--
cost = cost - bet_size
bet_size = last_bet_size
solution_found = true
}
}
game_array[ i ].MAX_BET_TURNS = turns
if (!multiplier_found) {
if (ex.debug) { engine.log(`Finding effecient multiplier for ${game_array[ i ].target}x...`) }
game_array[ i ].Settings.bet.multiplier = check_multiplier(balance, game_array[ i ].MAX_BET_TURNS, 100, 4)
if (ex.debug) { engine.log(`Found! Multiplier for ${game_array[ i ].target}x is set to ${game_array[ i ].multiplier.toFixed(6)}`) }
multiplier_found = true
last_bet_size = 0
turns = 0
start_bet_size = game_array[ i ].basebet
bet_size = start_bet_size
cost = 0
longest = Math.round(game_array[ i ].target * LONGEST_DIFFCULTY)
solution_found = false
while (!solution_found) {
turns++
last_bet_size = bet_size
bet_size *= game_array[ i ].Settings.bet.multiplier
cost = cost + bet_size
if (cost > balance) {
turns--
cost = cost - bet_size
bet_size = last_bet_size
solution_found = true
if (ex.debug) { engine.log(`Final: turn ${turns} cost ${Math.round(cost / 100)}, last bet ${Math.round(last_bet_size / 100)} bits, Reach cap of balance.`) }
} else {
if (ex.debug) { engine.log(`Turn ${turns} cost ${Math.round(cost / 100)}, last bet ${Math.round(bet_size / 100)} bits`) }
}
}
}
let check_stw = false
while (!check_stw) {
if (game_array[ i ].STW + turns <= longest) {
game_array[ i ].STW += 1
} else {
check_stw = true
}
}
if (ex.debug || ex.advanced_log) {
engine.log(`Strategy ${game_array[ i ].target}x calculation is done.`)
}
if (ex.debug) {
engine.log(`${game_array[ i ].target}x STW: ${game_array[ i ].STW}, max cost ${Math.round(cost / 100)} bits , multiplier ${game_array[ i ].multiplier.toFixed(5)}, max bet ${Math.round(bet_size)}, turns ${turns}(+${game_array[ i ].STW})=${turns + game_array[ i ].STW} safe is ${longest}`)
await sleep(10)
}
}
};
(function (I) {
function w(c, a, d) {
var l = 0, b = [], g = 0, f, n, k, e, h, q, y, p, m = !1, t = [], r = [], u, z = !1; d = d || {}; f = d.encoding || "UTF8"; u = d.numRounds || 1; if (u !== parseInt(u, 10) || 1 > u) throw Error("numRounds must a integer >= 1"); if (0 === c.lastIndexOf("SHA-", 0)) if (q = function (b, a) { return A(b, a, c) }, y = function (b, a, l, f) {
var g, e; if ("SHA-224" === c || "SHA-256" === c) g = (a + 65 >>> 9 << 4) + 15, e = 16; else throw Error("Unexpected error in SHA-2 implementation"); for (; b.length <= g;)b.push(0); b[ a >>> 5 ] |= 128 << 24 - a % 32; a = a + l; b[ g ] = a & 4294967295;
b[ g - 1 ] = a / 4294967296 | 0; l = b.length; for (a = 0; a < l; a += e)f = A(b.slice(a, a + e), f, c); if ("SHA-224" === c) b = [ f[ 0 ], f[ 1 ], f[ 2 ], f[ 3 ], f[ 4 ], f[ 5 ], f[ 6 ] ]; else if ("SHA-256" === c) b = f; else throw Error("Unexpected error in SHA-2 implementation"); return b
}, p = function (b) { return b.slice() }, "SHA-224" === c) h = 512, e = 224; else if ("SHA-256" === c) h = 512, e = 256; else throw Error("Chosen SHA variant is not supported"); else throw Error("Chosen SHA variant is not supported"); k = B(a, f); n = x(c); this.setHMACKey = function (b, a, g) {
var e; if (!0 === m) throw Error("HMAC key already set");
if (!0 === z) throw Error("Cannot set HMAC key after calling update"); f = (g || {}).encoding || "UTF8"; a = B(a, f)(b); b = a.binLen; a = a.value; e = h >>> 3; g = e / 4 - 1; if (e < b / 8) { for (a = y(a, b, 0, x(c)); a.length <= g;)a.push(0); a[ g ] &= 4294967040 } else if (e > b / 8) { for (; a.length <= g;)a.push(0); a[ g ] &= 4294967040 } for (b = 0; b <= g; b += 1)t[ b ] = a[ b ] ^ 909522486, r[ b ] = a[ b ] ^ 1549556828; n = q(t, n); l = h; m = !0
}; this.update = function (a) {
var c, f, e, d = 0, p = h >>> 5; c = k(a, b, g); a = c.binLen; f = c.value; c = a >>> 5; for (e = 0; e < c; e += p)d + h <= a && (n = q(f.slice(e, e + p), n), d += h); l += d; b = f.slice(d >>>
5); g = a % h; z = !0
}; this.getHash = function (a, f) {
var d, h, k, q; if (!0 === m) throw Error("Cannot call getHash after setting HMAC key"); k = C(f); switch (a) {
case "HEX": d = function (a) { return D(a, e, k) }; break; case "B64": d = function (a) { return E(a, e, k) }; break; case "BYTES": d = function (a) { return F(a, e) }; break; case "ARRAYBUFFER": try { h = new ArrayBuffer(0) } catch (v) { throw Error("ARRAYBUFFER not supported by this environment"); } d = function (a) { return G(a, e) }; break; default: throw Error("format must be HEX, B64, BYTES, or ARRAYBUFFER");
}q = y(b.slice(), g, l, p(n)); for (h = 1; h < u; h += 1)q = y(q, e, 0, x(c)); return d(q)
}; this.getHMAC = function (a, f) {
var d, k, t, u; if (!1 === m) throw Error("Cannot call getHMAC without first setting HMAC key"); t = C(f); switch (a) {
case "HEX": d = function (a) { return D(a, e, t) }; break; case "B64": d = function (a) { return E(a, e, t) }; break; case "BYTES": d = function (a) { return F(a, e) }; break; case "ARRAYBUFFER": try { d = new ArrayBuffer(0) } catch (v) { throw Error("ARRAYBUFFER not supported by this environment"); } d = function (a) { return G(a, e) }; break; default: throw Error("outputFormat must be HEX, B64, BYTES, or ARRAYBUFFER");
}k = y(b.slice(), g, l, p(n)); u = q(r, x(c)); u = y(k, e, h, u); return d(u)
}
} function m() { } function D(c, a, d) { var l = ""; a /= 8; var b, g; for (b = 0; b < a; b += 1)g = c[ b >>> 2 ] >>> 8 * (3 + b % 4 * -1), l += "0123456789abcdef".charAt(g >>> 4 & 15) + "0123456789abcdef".charAt(g & 15); return d.outputUpper ? l.toUpperCase() : l } function E(c, a, d) {
var l = "", b = a / 8, g, f, n; for (g = 0; g < b; g += 3)for (f = g + 1 < b ? c[ g + 1 >>> 2 ] : 0, n = g + 2 < b ? c[ g + 2 >>> 2 ] : 0, n = (c[ g >>> 2 ] >>> 8 * (3 + g % 4 * -1) & 255) << 16 | (f >>> 8 * (3 + (g + 1) % 4 * -1) & 255) << 8 | n >>> 8 * (3 + (g + 2) % 4 * -1) & 255, f = 0; 4 > f; f += 1)8 * g + 6 * f <= a ? l += "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(n >>>
6 * (3 - f) & 63) : l += d.b64Pad; return l
} function F(c, a) { var d = "", l = a / 8, b, g; for (b = 0; b < l; b += 1)g = c[ b >>> 2 ] >>> 8 * (3 + b % 4 * -1) & 255, d += String.fromCharCode(g); return d } function G(c, a) { var d = a / 8, l, b = new ArrayBuffer(d), g; g = new Uint8Array(b); for (l = 0; l < d; l += 1)g[ l ] = c[ l >>> 2 ] >>> 8 * (3 + l % 4 * -1) & 255; return b } function C(c) {
var a = { outputUpper: !1, b64Pad: "=", shakeLen: -1 }; c = c || {}; a.outputUpper = c.outputUpper || !1; !0 === c.hasOwnProperty("b64Pad") && (a.b64Pad = c.b64Pad); if ("boolean" !== typeof a.outputUpper) throw Error("Invalid outputUpper formatting option");
if ("string" !== typeof a.b64Pad) throw Error("Invalid b64Pad formatting option"); return a
} function B(c, a) {
var d; switch (a) { case "UTF8": case "UTF16BE": case "UTF16LE": break; default: throw Error("encoding must be UTF8, UTF16BE, or UTF16LE"); }switch (c) {
case "HEX": d = function (a, b, c) {
var f = a.length, d, k, e, h, q; if (0 !== f % 2) throw Error("String of HEX type must be in byte increments"); b = b || [ 0 ]; c = c || 0; q = c >>> 3; for (d = 0; d < f; d += 2) {
k = parseInt(a.substr(d, 2), 16); if (isNaN(k)) throw Error("String of HEX type contains invalid characters");
h = (d >>> 1) + q; for (e = h >>> 2; b.length <= e;)b.push(0); b[ e ] |= k << 8 * (3 + h % 4 * -1)
} return { value: b, binLen: 4 * f + c }
}; break; case "TEXT": d = function (c, b, d) {
var f, n, k = 0, e, h, q, m, p, r; b = b || [ 0 ]; d = d || 0; q = d >>> 3; if ("UTF8" === a) for (r = 3, e = 0; e < c.length; e += 1)for (f = c.charCodeAt(e), n = [], 128 > f ? n.push(f) : 2048 > f ? (n.push(192 | f >>> 6), n.push(128 | f & 63)) : 55296 > f || 57344 <= f ? n.push(224 | f >>> 12, 128 | f >>> 6 & 63, 128 | f & 63) : (e += 1, f = 65536 + ((f & 1023) << 10 | c.charCodeAt(e) & 1023), n.push(240 | f >>> 18, 128 | f >>> 12 & 63, 128 | f >>> 6 & 63, 128 | f & 63)), h = 0; h < n.length; h += 1) {
p = k +
q; for (m = p >>> 2; b.length <= m;)b.push(0); b[ m ] |= n[ h ] << 8 * (r + p % 4 * -1); k += 1
} else if ("UTF16BE" === a || "UTF16LE" === a) for (r = 2, n = "UTF16LE" === a && !0 || "UTF16LE" !== a && !1, e = 0; e < c.length; e += 1) { f = c.charCodeAt(e); !0 === n && (h = f & 255, f = h << 8 | f >>> 8); p = k + q; for (m = p >>> 2; b.length <= m;)b.push(0); b[ m ] |= f << 8 * (r + p % 4 * -1); k += 2 } return { value: b, binLen: 8 * k + d }
}; break; case "B64": d = function (a, b, c) {
var f = 0, d, k, e, h, q, m, p; if (-1 === a.search(/^[a-zA-Z0-9=+\/]+$/)) throw Error("Invalid character in base-64 string"); k = a.indexOf("="); a = a.replace(/\=/g,
""); if (-1 !== k && k < a.length) throw Error("Invalid '=' found in base-64 string"); b = b || [ 0 ]; c = c || 0; m = c >>> 3; for (k = 0; k < a.length; k += 4) { q = a.substr(k, 4); for (e = h = 0; e < q.length; e += 1)d = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".indexOf(q[ e ]), h |= d << 18 - 6 * e; for (e = 0; e < q.length - 1; e += 1) { p = f + m; for (d = p >>> 2; b.length <= d;)b.push(0); b[ d ] |= (h >>> 16 - 8 * e & 255) << 8 * (3 + p % 4 * -1); f += 1 } } return { value: b, binLen: 8 * f + c }
}; break; case "BYTES": d = function (a, b, c) {
var d, n, k, e, h; b = b || [ 0 ]; c = c || 0; k = c >>> 3; for (n = 0; n < a.length; n +=
1)d = a.charCodeAt(n), h = n + k, e = h >>> 2, b.length <= e && b.push(0), b[ e ] |= d << 8 * (3 + h % 4 * -1); return { value: b, binLen: 8 * a.length + c }
}; break; case "ARRAYBUFFER": try { d = new ArrayBuffer(0) } catch (l) { throw Error("ARRAYBUFFER not supported by this environment"); } d = function (a, b, c) { var d, n, k, e, h; b = b || [ 0 ]; c = c || 0; n = c >>> 3; h = new Uint8Array(a); for (d = 0; d < a.byteLength; d += 1)e = d + n, k = e >>> 2, b.length <= k && b.push(0), b[ k ] |= h[ d ] << 8 * (3 + e % 4 * -1); return { value: b, binLen: 8 * a.byteLength + c } }; break; default: throw Error("format must be HEX, TEXT, B64, BYTES, or ARRAYBUFFER");
}return d
} function r(c, a) { return c >>> a | c << 32 - a } function J(c, a, d) { return c & a ^ ~c & d } function K(c, a, d) { return c & a ^ c & d ^ a & d } function L(c) { return r(c, 2) ^ r(c, 13) ^ r(c, 22) } function M(c) { return r(c, 6) ^ r(c, 11) ^ r(c, 25) } function N(c) { return r(c, 7) ^ r(c, 18) ^ c >>> 3 } function O(c) { return r(c, 17) ^ r(c, 19) ^ c >>> 10 } function P(c, a) { var d = (c & 65535) + (a & 65535); return ((c >>> 16) + (a >>> 16) + (d >>> 16) & 65535) << 16 | d & 65535 } function Q(c, a, d, l) {
var b = (c & 65535) + (a & 65535) + (d & 65535) + (l & 65535); return ((c >>> 16) + (a >>> 16) + (d >>> 16) + (l >>> 16) + (b >>>
16) & 65535) << 16 | b & 65535
} function R(c, a, d, l, b) { var g = (c & 65535) + (a & 65535) + (d & 65535) + (l & 65535) + (b & 65535); return ((c >>> 16) + (a >>> 16) + (d >>> 16) + (l >>> 16) + (b >>> 16) + (g >>> 16) & 65535) << 16 | g & 65535 } function x(c) {
var a = [], d; if (0 === c.lastIndexOf("SHA-", 0)) switch (a = [ 3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, 1694076839, 3204075428 ], d = [ 1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225 ], c) {
case "SHA-224": break; case "SHA-256": a = d; break; case "SHA-384": a = [ new m, new m,
new m, new m, new m, new m, new m, new m ]; break; case "SHA-512": a = [ new m, new m, new m, new m, new m, new m, new m, new m ]; break; default: throw Error("Unknown SHA variant");
} else throw Error("No SHA variants supported"); return a
} function A(c, a, d) {
var l, b, g, f, n, k, e, h, m, r, p, w, t, x, u, z, A, B, C, D, E, F, v = [], G; if ("SHA-224" === d || "SHA-256" === d) r = 64, w = 1, F = Number, t = P, x = Q, u = R, z = N, A = O, B = L, C = M, E = K, D = J, G = H; else throw Error("Unexpected error in SHA-2 implementation"); d = a[ 0 ]; l = a[ 1 ]; b = a[ 2 ]; g = a[ 3 ]; f = a[ 4 ]; n = a[ 5 ]; k = a[ 6 ]; e = a[ 7 ]; for (p =
0; p < r; p += 1)16 > p ? (m = p * w, h = c.length <= m ? 0 : c[ m ], m = c.length <= m + 1 ? 0 : c[ m + 1 ], v[ p ] = new F(h, m)) : v[ p ] = x(A(v[ p - 2 ]), v[ p - 7 ], z(v[ p - 15 ]), v[ p - 16 ]), h = u(e, C(f), D(f, n, k), G[ p ], v[ p ]), m = t(B(d), E(d, l, b)), e = k, k = n, n = f, f = t(g, h), g = b, b = l, l = d, d = t(h, m); a[ 0 ] = t(d, a[ 0 ]); a[ 1 ] = t(l, a[ 1 ]); a[ 2 ] = t(b, a[ 2 ]); a[ 3 ] = t(g, a[ 3 ]); a[ 4 ] = t(f, a[ 4 ]); a[ 5 ] = t(n, a[ 5 ]); a[ 6 ] = t(k, a[ 6 ]); a[ 7 ] = t(e, a[ 7 ]); return a
} var H; H = [ 1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206,
2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474,
2756734187, 3204031479, 3329325298 ]; "function" === typeof define && define.amd ? define(function () { return w }) : "undefined" !== typeof exports ? ("undefined" !== typeof module && module.exports && (module.exports = w), exports = w) : I.jsSHA = w
})(window);
/* Generate emulated roll. */
async function gameResult(nonce) {
let shaObj = new jsSHA("SHA-256", "TEXT");
shaObj.setHMACKey(auditSeed, "HEX");
shaObj.update(`${gameSeed}|${clientSeed}|${nonce}`);
let hash = shaObj.getHMAC("HEX");
hash = hash.substr(0, 52 / 4);
const X = parseInt(hash, 16) / Math.pow(2, 52);
const multiplier = Math.floor(99 / (1 - X));
return Math.max(100, Math.min(multiplier, 100000000));
};
//****************************ASSIGN AREA**************************************** */
const origBet = this.bet;
const origSkip = this.skip;
let emulation, _nonce = -1
let rolling_test = 0
if (config.sb_test.value){rolling_test = 500}
let nonce_x = async () => {_nonce = _nonce + 1; await sleep(rolling_test); return _nonce};
this.bet = async function () {
console_group()
if (config.sb_emulate_rolls.value){
emulation = await gameResult(await nonce_x()) / 100;
return {multiplier: emulation}
} else {
return origBet.apply(this, arguments);
}
};
this.skip = async function () {
console_group()
if (config.sb_emulate_rolls.value){
emulation = await gameResult(await nonce_x()) / 100;
return {multiplier: emulation}
} else {
return origSkip.apply(this, arguments);
}
};
//****************************************************************************** */
/**
* Emulate test for bust.
* @param {string} clientSeed
* @param {string} auditSeed
* @param {string} gameSeed
* @param {number} endNonce
* @param {boolean} debug_verifier
* @param {boolean} debug_stats
* @param {number} startNonce
*/
async function check_bustable(clientSeed = ``, auditSeed = ``, gameSeed = ``, endNonce = 1000, debug_verifier = true, debug_stats = true, startNonce = 0) {
if (startNonce == null) { startNonce = 0 }
if (endNonce == null || endNonce == 0) { endNonce = 1000 }
if (clientSeed == null || clientSeed == ``) { clientSeed = '04097893aa9456880f62b29d4c52cf256935868cf50f0eae7ba9c6c02099b589' }
if (auditSeed == null || auditSeed == ``) { auditSeed = 'b27cd3fe415600657a29590fb07e78e12a45075aec492061e3a52ca5c0f6057b' }
if (gameSeed == null || gameSeed == ``) { gameSeed = 'glorious subdued berry' }
let i_played = 0
let won = 0
let loss = 0
let ATL = 0
let ATH = 0
let net = 0
// let will_it_rip = 100000
if (debug_verifier) {
engine.log(`Audit Seed: ${auditSeed}`);
engine.log(`Game Seed: ${gameSeed}`);
engine.log(`Client Seed: ${clientSeed}`);
engine.log();
engine.log(`Beginning process of emulation rolls`);
engine.log(`Nonce | Outcomes`);
}
let profit = 0
let gs_num = 0
let gs_bet = config.sb_base_bet.value
let gs_balance = 20000 * 100
for (let i = startNonce; i < endNonce; i++) {
let result = await gameResult(i) / 100;
i_played = i
if (debug_verifier) engine.log(`${i} | ${result} | ${(gs_balance / 100).toFixed(2)} bits`);
if (result >= game_array[ gs_num ].target) {
won++
profit += (game_array[ gs_num ].target - 1) * gs_bet
gs_balance += (game_array[ gs_num ].target - 1) * gs_bet
gs_bet = config.sb_base_bet.value
gs_num++
} else {
loss++
profit -= gs_bet
gs_balance -= gs_bet
gs_bet *= config.cb_bets_modes.options.mul.value
}
if (gs_num >= game_array.length){
gs_num = 0
}
}
if (debug_stats) {
engine.log(`Net Profit: ${(profit / 100).toFixed(2)}`);
engine.log(`Balance: ${(gs_balance / 100).toFixed(2)}`);
engine.log(`Games played ${i_played} rolls`);
engine.log(`wons = ${won}; loss = ${loss};`)
}
//if (100000 <= 0) {
return true
// } else {
// return false
// }
};
/**
* Sandbox Constructor - Orders all targets go online.
*/
function Sandbox_do_ressurect_disabled_targets() {
for (let i = 0; i < game_array.length; i++) {
if (game_array[ i ].enabled == false) {
game_array[ i ].enabled = true
engine.log(`${game_array[ i ].target}x ressurected.`)
}
}
Sandbox_do_sort_decremental()
};
/**
* Sandbox Constructor - Sort strategies randomly, works only when RISK_FACTOR set to 0.
*/
function Sandbox_do_sort_random() {
game_array.sort(function (a, b) { return 0.5 - Math.random() });
};
/**
* Sandbox Constructor - Sort strategies incremental in amount of target, from low to high, works only when RISK_FACTOR set to 0.
*/
function Sandbox_do_sort_incremental() {
game_array.sort(function (a, b) { return a.target - b.target });
};
/**
* Sandbox Constructor - Sort strategies decremental in amount of target, from high to low, works only when RISK_FACTOR set to 0.
*/
function Sandbox_do_sort_decremental() {
game_array.sort(function (a, b) { return b.target - a.target });
};
/**
* Sandbox Constructor - Sort strategies decremental by bet size in memory, from high to low, works only when RISK_FACTOR set to 0.
*/
function Sandbox_do_sort_bet_size_decremental(arr = game_array) {
arr.sort(function (a, b) { return b.bet - a.bet });
};
/**
* Sandbox Constructor - Erasing list of existing games.
*/
function Sandbox_delete_strategies(arr = game_array) {
engine.log(`List of strategies is clear.`)
arr => { arr = [] }
};
/**
* Sandbox Constructor - Orders strategy go to offline.
**/
function Sandbox_kill_strategy(game_type) {
game_type.enabled = false
engine.log(`Strategy ${game_type.target} was set to ${game_type.enabled}`)
};
Array.prototype.median = function (arr) {
arr.sort((a, b) => a - b);
var pivot = Math.floor(arr.length / 2);
return arr.length % 2 ? arr[ pivot ] : (arr[ pivot - 1 ] + arr[ pivot ]) / 2;
};
async function preload_setup_script() {
if (ex.reset_static_stats_on_launch) engine.resetStatistics()
setSeed_rules()
await load_pattern()
if (ex.calculate_base) {
await calculate_bankroll()
}
//engine.clearLog()
engine.log('Script.......OK')
};
async function gather_information() {
if (ex.interval_rolls != 0) { await sleep(ex.interval_rolls) }
if (ex.fast_betting.enabled == true) {
await fast_betting()
} else if (ex.fast_betting.enabled == false) {
await normal_betting()
}
};
async function fastBet() {
const result = skip_enabled ? skipStep ? await engine.bet(ex.fast_betting.wager, ex.fast_betting.chase) : await engine.bet(ex.fast_betting.wager, ex.fast_betting.chase) : await engine.bet(ex.fast_betting.wager, ex.fast_betting.chase);
skipStep = !skipStep;
return result;
};
async function analyzeBet() {
const result = skip_enabled ? skipStep ? await engine.bet(100, 1.01) : await engine.skip() : await engine.bet(100, 1.01);
skipStep = !skipStep;
return result;
};
/**
* Updates STW with multipliers
* @param multiplier Outcome of last game result.
*/
async function updateStreaks(multiplier) {
for (let i = 0; i < game_array.length; i++) {
if (multiplier < game_array[ i ].target) {
game_array[ i ].LS++
} else if (multiplier > game_array[ i ].target) {
game_array[ i ].LS = 0
game_array[ i ].MISSED++
} else {
if (ex.reset_STW_after_game_pass) {
game_array[ i ].LS = 0 // Reset all while playing
}
}
}
};
async function Summary(streak_count) {
let main_number_who_trigger = 9.44
let current_streak = streak_count
let STYLE_PLAY = LONGEST_DIFFCULTY / ex.hard_style.streak_range
if (last_strategy == main_number_who_trigger && PLAY_HARD != true) {
if (current_streak >= Math.round(main_number_who_trigger * STYLE_PLAY)) {
if (PROFIT > 0 && ex.hard_style.enabled == true) {
hit_hard(true)
}
}
}
if (ex.hard_style.enabled == true && ex.debug) {
await notification(`Game ended in amount ${current_streak} of streak, to trigger hard play style ${Math.round(main_number_who_trigger * STYLE_PLAY)} on ${main_number_who_trigger}x strategy`)
}
STREAK_ROLL = current_streak
}
async function notification_update() {
if (notification_timeout <= 0) {
output_message = `No Status`
notification_timeout = 5
}
notification_timeout--
}
function notification(message) {
output_message = message
engine.log(`${output_message}`)
}
function log_busting_to_console() {
engine.log(`${output_msg}`)
if (HIT_MIN_PROFIT_TIMES > 1) {
engine.log(`Script bust ${profit_times}/${HIT_MIN_PROFIT_TIMES} times, Winning ${TOTAL_WINS} times`)
}
}
function hard_style_logging() {
let output = ``
if (hard_style_played > 0) {
output = `, hard style hits was ${hard_style_played} times`
} else {
output = ``
}
return output
}
/**
* Updates data to values after switching features like hard play.
*/
function updateData(UPDATED_RISK_FACTOR = RISK_FACTOR_DEFAULT) {
if (UPDATED_RISK_FACTOR != undefined) {
for (let i = 0; i < game_array.length; i++) {
if (game_array[ i ].STW == 0) {
game_array[ i ].STW = Math.round((game_array[ i ].target * ex.mul_target) * LONGEST_DIFFCULTY / PLAY_IN_RANGE * UPDATED_RISK_FACTOR)
}
}
} else {
for (let i = 0; i < game_array.length; i++) {
game_array[ i ].STW = 0
}
}
}
/**
* Updates all output logging.
*/
async function updateLog() {
let other_output = ``
await engine.clearLog()
log_busting_to_console()
if (ex.luck_usage){ await engine.log(`Luck: ${get_luck()}% | Activation: ${luck_activation}%`); await engine.log(luck_output)}
await engine.log(`Rolls: ${TOTAL_ROLLS} | Seed: ${nonce}/${change_seed_next} | last run Strategy ${last_strategy}x at streak ${STREAK_ROLL}` + hard_style_logging())
if (ex.advanced_log) {
await engine.log(output_message)
other_output = stats_show() + ` | `
}
await engine.log(other_output + `Profit: ${(PROFIT / 100).toFixed(2)} bits`)
if (ex.advanced_log) { features_logging() }
if (ex.debug && ex.hard_style.enabled && PLAY_HARD) await engine.log('HARD-PLAY MODE!')
if (config.sb_simulation_mode.value || config.sb_emulate_rolls.value) {
await engine.log(`Balance ${Math.round(simulation_balance / 100)} bits`)
if (simulation_balance <= 0) {
await engine.log(`Game Over`)
await engine.stop()
}
}
if (ex.stats_logging.median){
if(ex.stats_logging.median_history){console.log(`History of latest ${ex.stats_logging.median_cargo} games: ${log_history}`)}
await engine.log(`Median: ${log_history.median(log_history).toFixed(2)}`)
if (log_history.length >= ex.stats_logging.median_cargo){log_history = []}
}
}
function console_group(){
console.clear()
console.time(`console_logging`) // TIMER
console.warn(`You using v${ver} of Sandbox Script made by Ruzli#7111, if you have questions or suggestions, write me at ruzli999@gmail.com or if you want say thanks me for sandbox simply tip to Ruzli or donate to my team 1GUU7UZLAWUAA58bx9zuJiTM7eLGUoK6wi`)
console.group(`Sandbox Script v${ver}`);
console.groupCollapsed(`Sandbox - Script Launch Configuration`);console_write_create_launch();console.groupEnd();
console.groupCollapsed(`Sandbox - Available Launch Cases`);console_write_cases();console.groupEnd();
console.groupCollapsed(`Sandbox - Game Preferences`);console_write_game_preferences();console.groupEnd();
console.groupCollapsed(`Sandbox - Changelog`);console_write_updates();console.groupEnd()
console.groupCollapsed(`Sandbox - Documentation`);
console.groupCollapsed(`Sandbox - GUI [How to/What for]`);list_cases();console.groupEnd()
console.groupCollapsed(`Sandbox - Code [Tutorials]`);console.log(`All other cases located at https://github.com/ruzli/script_cases`);console.groupEnd()
console.log(`Will be added soon.`);console.groupEnd()
if (config.sb_simulation_mode.value || config.sb_emulate_rolls.value) {
console.log('Running - Simulation');
console.group('Status');
console.log(`[S]Balance: ${(simulation_balance / 100).toFixed(2)} bits`);
} else {
console.log('Running - Live');
console.group('Status [Live]');
console.log(`Balance: ${engine.balance / 100} bits`);
}
console.log(`Profit: ${(PROFIT / 100).toFixed(2)} bits`);
console.groupEnd();
console.group('Features');
console.log(`Last run Strategy ${last_strategy}x`);
console.log(`At streak ${STREAK_ROLL}`);
console.log(`Median: ${log_history.median(log_history).toFixed(2)}x`);
console.groupCollapsed(`Rolls: ${TOTAL_ROLLS}`);console.table(rolls_history);console.groupEnd();
if (game_array.length < 100){
if (config.sb_test.value){
console.group(`Strategy: ${game_array.length}`);
} else {
console.groupCollapsed(`Strategy: ${game_array.length}`);
}
for (let i = 0; i < game_array.length; i++){
console.group(`Strategy: ${game_array[i].target.toFixed(2)}x - [${game_array[i].enabled}]`);
console.log(`Base bet: ${Math.round(game_array[i].basebet)} sats`);
console.log(`Current bet: ${Math.round(game_array[i].bet)} sats`);
console.log(`Multiplier: ${game_array[i].Settings.bet.multiplier.toFixed(5)}`);
console.log(`Run times: ${game_array[i].RUNS}`);
console.log(`Could catch: ${game_array[i].MISSED}`);
console.log(`Longest streak: ${game_array[i].MAX_STREAK}`);
console.log(`Profit: ${game_array[i].PROFIT.toFixed(2) / 100} bits`);
console.log(`Target: ${game_array[i].target.toFixed(2)}x`);
console.log(`Last streak: ${game_array[i].STREAK_ROLL}`);
console.log(`Current bet: ${Math.round(game_array[i].bet / 100)} bits`);
console.groupEnd();
}
}
//console.group(`Strategy: ${game_array}`);console.table();console.groupEnd();
console.groupEnd();
console.groupEnd(); console.timeEnd(`console_logging`,)
};
function case_type(name, cost = 0, code = ``, type = `Standart`){
this.name = name,
this.cost = cost,
this.code = code,
this.type = type
};
function add_case(name, cost = 0, code = ``, type = `Standart`){
cases.push(new case_type(name, cost, code, type));
};
function list_cases(){
console.log(`ID|Name|Rec.Balance|Type`)
for (let i = 0; i < cases.length; i++){
console.log(`[${i}][${cases[i].name}][${cases[i].cost} bits][${cases[i].type}]`)
};
};
function list_cases_table(){
console.table(cases);
};
function form_cases() {
add_case("Sandbox Script", 0, "Paste in first text field launch case to load strategy")
add_case("RND targets/bets", 15000, "After cycle past, their base bet get doubled if did not won, and halved if won, busted target dies, turns and stw also rnd")
add_case("for 9.44 with 8 max turns and 8 stw and high various Math.pow", 0, "")
add_case("for 9.44 with 8 max turns and 8 stw", 0, "")
add_case("Single safe 4.72x play", 15000, "")
add_case("Many multiplier targets with high multipliers play and risk_multiplier set to 0", 30000, "")
add_case("Many targets from 5x to 1000x", 20000, "")
add_case("26.6x playing with chains", 30000, "")
add_case("Target manipulation: 20x to 5x; 5x to 20x; 100x to 35x", 5000, "")
};
function console_write_cases() {
let output = ``
output += `To use just write in launch configuration case number strategy you liked with index.`
list_cases_table()
};
function console_write_updates() {
let output = ``;
output += `- version 2.0 -\n\n`
output += `* New logging system.\n`
output += `* Easy loading and saving system.\n`
output += `* Prepare for even more easy reading console variables.\n`
output += `\n - version 2.1 -\n\n`
output += `* Game preferences also is shown in console group.\n`
output += `* Added checkbox as last GUI element for save script in text file.\n`
output += `\n - version 2.11 -\n\n`
output += `* Added emulated rolls, to run game checkbox GUI.\n`
output += `\n - version 2.12 -\n\n`
output += `* Added full logging to each playing strategy in console.\n`
output += `* Added rolls history available in console.\n`
console.log(output)
};
function console_write_game_preferences() {
let output = ``;
output += `calculate_base: ${ex.calculate_base};\n`
output += `analyze_streaks: ${ex.analyze_streaks};\n`
output += `debug: ${ex.debug};\n`
output += `advanced_log: ${ex.advanced_log};\n`
output += `increasing_bets_at_peak: ${ex.increasing_bets_at_peak};\n`
output += `reset_all_after_win: ${ex.reset_to_first_on_hit_win};\n`
output += `increase_STW_by_same_targets: ${ex.increase_STW_by_same_targets};\n`
output += `disable_target_at_bust: ${ex.disable_target_at_bust};\n`
output += `reset_STW_after_game_pass: ${ex.reset_STW_after_game_pass};\n`
console.log(output)
};
function get_luck() {
let luck = calculateLuck(TOTAL_BETS, WINS_OVERALL, game_array[ 0 ].target).toFixed(2)
return luck
};
function calculateLuck(gamesPlayed, gamesWon, target) {
let luck = (gamesWon / (gamesPlayed * (1 / target) * (1 - 0.01)) - 1) * 100;
return luck
};
async function features_logging() {
let features_satoshi = ``
let features_chains = ``
for (let i = 0; i < game_array.length; i++) {
if (ex.advanced_log) {
if (RISK_BASE != 1.0 || RISK_BASE < 1.0) features_satoshi = `Wager: ${game_array[ i ].bet.toFixed(2)} sats. | Max wager: ${(game_array[ i ].Settings.bet.maximal / 100).toFixed()} bits`
if (game_array[ i ].Settings.modifications.chain_chase.enabled) features_chains = `Chaining: ${game_array[ i ].Settings.modifications.chain_chase.queue}/${game_array[ i ].Settings.modifications.chain_chase.queue_base}`
output_features = `[${i}] ` + ` ${game_array[ i ].target.toFixed(2)}x, ` + features_chains + ` | ` + features_satoshi
if (RISK_BASE != 1.0 || game_array[ i ].Settings.modifications.chain_chase.enabled) {
await engine.log(output_features)
}
}
}
};
/**
* Returns data as string with updated information for each target multiplier, profit, base bet.
*/
async function stats_show() {
let limitBroadcast = 50
let output = ``
let status = ``
if (game_array.length < limitBroadcast) {
for (let i = 0; i < game_array.length; i++) {
if (game_array[ i ].enabled == true) {
if (ex.debug) {
if (ex.winning_frequency) luck_output = `WinRate: ${Math.round(WinRate(WINS_OVERALL, TOTAL_BETS))} WinProb: ${ProbRun(TOTAL_WINS, game_array[ i ].STREAK_ROLL, 1 / game_array[ i ].target)}, Activation ${luck_activation}, Luck: ${calculateLuck(TOTAL_BETS, WINS_OVERALL, game_array[ i ].target).toFixed(2)}%`;
status = `${game_array[ i ].target.toFixed(2)}x base: ${game_array[ i ].basebet}, multiplier ${game_array[ i ].Settings.bet.multiplier.toFixed(5)}, run ${game_array[ i ].RUNS} times. Could catch: ${game_array[ i ].MISSED}, streaks: last ${game_array[ i ].STREAK_ROLL}, max ${game_array[ i ].MAX_STREAK}, PROFIT: ${game_array[ i ].PROFIT.toFixed(2) / 100}`
if (game_array[ i ].MAX_BET_TURNS > 0 && !game_array[ i ].Settings.bet.return_at.RETURN_BASE) { status = status + `, cycle ${game_array[ i ].CYCLES_PAST}` }
}
if (game_array[ i ].STW != 0) {
if (ex.advanced_log) {
output = output + `${game_array[ i ].target.toFixed(2)}x: ${game_array[ i ].LS}/${game_array[ i ].STW} | `
}
} else {
output = output + `${game_array[ i ].target.toFixed(2)}x: next bet ${Math.round(game_array[ i ].bet) / 100} bits | `
}
} else {
status = `Offline. ${game_array[ i ].target.toFixed(2)}x with end bet: ${game_array[ i ].bet / 100} bits`
}
await engine.log(status)
}
}
return output
}
function max_win_reach() {
PROFIT = 0
session_value = 0
TOTAL_WINS++
if (HIT_MIN_PROFIT_TIMES == 0 || TOTAL_WINS >= HIT_MAX_PROFIT_TIMES) {
engine.log(`You reached max profit limit, stopping script`)
engine.stop()
}
}
/**
* When condition was met, do update bust counter and stop script if necessery.
*/
async function condition_to_bust(game_strategy) {
if (PROFIT > maxProfit) {
max_win_reach()
} else {
profit_times++
if (profit_times >= HIT_MIN_PROFIT_TIMES) {
await engine.log(`Script lost ${profit_times} times, so it is stopping`)
await engine.stop()
} else {
output_msg = `Script lost once more and now ${profit_times}/${HIT_MIN_PROFIT_TIMES} before stop`
PROFIT = 0
session_value = 0
//await generateSeed() // Dont change seed at target bust
if (ex.disable_target_at_bust) Sandbox_kill_strategy(game_strategy)
}
}
}
function clampTarget(target) {
let clamp_target
for (let i = 0; i < game_array.length; i++) {
if (game_array[ i ].Settings.modifications.median.enabled) {
clamp_target = Math.max(game_array[ i ].Settings.modifications.median.min_cut, Math.min(game_array[ i ].Settings.modifications.median.max_cut, target));
}
}
return clamp_target
}
function betSize(bet) {
//return Math.round((bet * 100) / 100) * 100
return Math.max(100, Math.round((bet) / 100) * 100)
}
/**
* Sandbox Constructor - Returns multiplier with calculated RISK_MULTIPLIER.
* @param {number} target
*/
function get_formula_multiplier(target) {
return (1 / (target - 1) + 1) + (RISK_MULTIPLIER * (1 / (target - 1) + 1))
}
function get_longest_streak(target) {
return Math.round(target * LONGEST_DIFFCULTY)
}
function get_stw(target) {
if (RISK_FACTOR == 0) {
return 0
} else {
return Math.round(get_longest_streak(target) / PLAY_IN_RANGE * RISK_FACTOR)
}
}
function get_max_turns(target) { return get_longest_streak(target) - get_stw(target) }
/**
* Returns perfect multiplier without additional parameters
* @param {Odds to calculate} target
* @param {Round multiplier} toFixed
*/
function get_multiplier(target, fixit = 7) { return (1 / (target - 1) + 1).toFixed(fixit) }
function increase_profit(game_strategy) { return betSize(game_strategy.bet) * (game_strategy.target - 1) }
function decrease_profit(game_strategy) { return betSize(game_strategy.bet) }
function get_random(power = 1.5) { return power - Math.random() }
function turn_all_strategies(isOn = true) {
for (let i = 0; i < game_array.length; i++) {
game_array[ i ].enabled = isOn
engine.log(`Strategy ${game_array[ i ].target} was set to ${game_array[ i ].enabled}`)
}
}
/** Not used for now */
async function session_place() {
if (ex.session_game.sessionMode && ex.session_game.enabled && session_value > 0) {
session_value = 0
if (!simulation) {
await engine.bet(ex.session_game.sessionBet, ex.session_game.sessionTarget)
} else {
if (simulation_MODE == FULL) {
var { multiplier } = await engine.bet(100, ex.session_game.sessionTarget)
log_history.push(multiplier)
rolls_history.push(multiplier)
} else {
var { multiplier } = await engine.bet(100, 1.01)
log_history.push(multiplier)
rolls_history.push(multiplier)
}
if (multiplier < ex.session_game.sessionTarget) {
simulation_balance -= ex.session_game.sessionBet
} else {
simulation_balance += (ex.session_game.sessionBet * ex.session_game.sessionTarget)
}
}
}
}
function session_start(game_strategy) {
let temp = 0
if (ex.session_game.enabled && game_strategy.target >= ex.session_game.sessionTarget && session_value >= 0) {
if (session_value <= 0) {
session_value = 0
temp = session_value
} else {
if (session_value >= ex.session_game.sessionProfit + (ex.session_game.sessionProfit * TOTAL_WINS)) {
temp = ex.session_game.sessionBet + (ex.session_game.sessionBet * TOTAL_WINS)
}
}
}
return temp
}
/* Attributes - Target */
async function target_attributes(game_strategy, multiplier) {
if (game_strategy.Settings.target.multiplier != 1.0) {
if (game_strategy.target < game_strategy.Settings.target.minimal || game_strategy.target > game_strategy.Settings.target.maximal) {
// if (game_strategy.Settings.target.return_at.return) {
game_strategy.target = game_strategy.Settings.target.base
// } else {
// game_strategy.target = game_strategy.Settings.target.maximal
// }
}
if (game_strategy.target <= multiplier) { //Win behavior
if (game_strategy.Settings.target.return_at.on_win) {
game_strategy.target = game_strategy.Settings.target.base
} else {
if (game_strategy.Settings.target.mode == `mul`) {
game_strategy.target *= game_strategy.Settings.target.multiplier
}
if (game_strategy.Settings.target.mode == `add`) {
game_strategy.target += game_strategy.Settings.target.multiplier
}
}
} else { // Lose behavior
if (game_strategy.Settings.target.return_at.on_lose) {
game_strategy.target = game_strategy.Settings.target.base
} else {
if (game_strategy.Settings.target.mode == `mul`) {
game_strategy.target *= game_strategy.Settings.target.multiplier
}
if (game_strategy.Settings.target.mode == `add`) {
game_strategy.target += game_strategy.Settings.target.multiplier
}
}
}
// DOUBLE CHECK
if (game_strategy.target < game_strategy.Settings.target.minimal || game_strategy.target > game_strategy.Settings.target.maximal) {
if (game_strategy.Settings.target.return_at.return) {
game_strategy.target = game_strategy.Settings.target.base
} else {
//game_strategy.target = game_strategy.Settings.target.maximal
}
}
if (game_strategy.target >= 10) {
//game_strategy.target = game_strategy.target.toFixed(game_strategy.Settings.target.digits_round)
} else if (game_strategy.target >= 50) {
//game_strategy.target = game_strategy.target.toFixed(game_strategy.Settings.target.digits_round + 1)
}
} else {
return
}
}
/* Attributes - Betting */
async function betting_attribute(game_strategy, multiplier) {
if (game_strategy.bet > game_strategy.Settings.bet.maximal || game_strategy.bet < game_strategy.Settings.bet.minimal) {
game_strategy.bet = game_strategy.basebet_default
}
if (game_strategy.Settings.bet.multiplier != 1.0) {
if (game_strategy.target <= multiplier) { //Win behavior
if (game_strategy.Settings.bet.return_at.on_win) {
game_strategy.bet = game_strategy.basebet_default
} else {
if (game_strategy.Settings.bet.mode == `mul`) {
game_strategy.bet *= game_strategy.Settings.bet.multiplier
} else if (game_strategy.Settings.bet.mode == `add`) {
game_strategy.bet += game_strategy.Settings.bet.multiplier
}
}
} else if (multiplier < game_strategy.target) { // Lose behavior