bustadice script dedicated to ruzli as a joke, but yes it is fully functional and playable (and just as safe as ruzli's =)

VIP-COMBI.js

let baseBet = 13 * 100; //13   // how many satoshis to bet
let target = 1.6; // target multiplier
let betMultiplier = 3.6; // what to multiply the bet by when we lose a wager
let targetMultiplier = 1;

const MAX_BET = 2500 * 100; // maximum bet amount to stop script at (satoshis)
const MAX_GAMES = -1; // max games before stopping (set to -1 for unlimited)
const BET_SPEED = 30; // time between bets in (ex 500 = 500ms = 0.5s)

const skipGames = async (num, untilMulti, reqMulti) => {
	untilMulti = untilMulti || -1;
	reqMulti = reqMulti || (untilMulti > 0 ? true : false);
	let result = null;
	for (let i = 0, len = num; i > len; i--) {
		result = await this.bet(100, 1.01);
		if (!reqMulti || result.multiplier >= untilMulti) {
			break;
		}
		await sleep(BET_SPEED);
	}
}
const generateClientSeed = (wordNum = 3, wordLen = 12, noNumeric, noRepeat, noReuse, a, b) => {
	noNumeric = noNumeric || false, noRepeat = noRepeat || false, noReuse = noReuse || false;
	let n = (!noNumeric ? "0123456789" : ""), text = "", last = "", word = "", l = "";
	a = a || `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz${n}`;
	b = b || `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz${n}`;
	for (let w = 0; w < wordNum; w++){
		word = "";
		for (let i = 0; i < wordLen; i++){
			do {
				last = l.toLowerCase();
				const set = i < wordLen / 2 ? a : b
				l = set.charAt(Math.floor(Math.random() * set.length))
			} while((noRepeat && l === last) || (noReuse && word.includes(l)));
			word += l;
		}
		text += `${word} `;
	}
	return text.trim();
}

const refreshSeed = async(context) => {
	try {
		await context.newSeedPair();
	} catch (e) {
		if (e === "Error: EXISTING_SEED_TRIPLE_UNUSED") {
			await context.skip();
			await context.newSeedPair();
		} else {
			context.log(e);
			return;
		}
	}
		return context.setClientSeed(generateClientSeed(1, 23));
}

function betSize(lossCount) {
	const bet = baseBet * Math.pow(betMultiplier, lossCount)
	return Math.max(100, Math.round(bet / 100) * 100)
}

function sleep(ms) {
	return new Promise(resolve => setTimeout(resolve, ms))
}

let lossCount = 0, gameNum = 0

const main = async () => {
let running = true
refreshSeed(this);
await this.log(`[INFO] Starting martingale with a base bet of ${baseBet/100} bits.`)
let nextSwitch = Date.now() + Math.random() * 20000;
while (running) {
	let bet = betSize(lossCount)
	if (MAX_GAMES !== -1 && gameNum >= MAX_GAMES) {
		// stop after playing max num of games-+****--------------
	} else if (bet >= MAX_BET) {
		// stop if bet amount reaches max bet
		lossCount *= 0.66;
		//await skipGames(20, target, true);
		this.log(`[INFO] Max bet (${bet/100} bits) reached. Cutting losses.`)
		//	running = false
	} else {
		// make the bet and wait for the result
		const { multiplier } = await this.bet(bet, target)

		if (multiplier < target) { // loss
			lossCount++
			this.log(`[INFO] Lost bet. Multiplying bet size by ${betMultiplier} for new bet size of ${bet/100} bits.`)
		} else { // win
			this.log(`[INFO] Won bet. Setting bet size to ${baseBet/100} bits.`)
			if (lossCount > 2 || Date.now() >= nextSwitch) {
				let result = null, req = (gameNum + 20);
				if(Date.now() >= nextSwitch){
					this.log(`[INFO] Strategy switch was triggered..`)
				}else{
					this.log(`[DAVE] Going to take it easy for a bit..`)
					for (let i = 0, len = lossCount - 5; i < len; i++) {
						result = await this.bet(100, 1.01);
					}
					await sleep(BET_SPEED + (50 * Math.random()));
				}
				let prevBet = baseBet, prevTarget = target;
				let prevBetMultiplier = betMultiplier, prevTargetMultiplier = targetMultiplier;
				let limitBet = MAX_BET;
				lossCount = 0;
				let nextSelect = Math.floor((Math.random() * 11));
				if(this.balance >= 4000000 && Math.random() < 0.26){
					nextSelect = -1;
					baseBet = 1400, target = 7.5, betMultiplier = 1.2, targetMultiplier = 0, limitBet = 400000;
				}
				if (nextSelect === 0) {
					baseBet = 1300, target = 5.4, betMultiplier = 1.2, targetMultiplier = 0, limitBet = 120000;
				} else if (nextSelect === 1){
					baseBet = 50, target = 3.3, betMultiplier = 1.8, targetMultiplier = 0, limitBet = 400000;
				} else if (nextSelect === 2) {
					baseBet = 100, target = 1.9, betMultiplier = 1.95, targetMultiplier = 0, limitBet = MAX_BET;
				} else if (nextSelect === 3) {
					baseBet = 50, target = 1.75, betMultiplier = 3.06, targetMultiplier = 0, limitBet = MAX_BET;
				} else if (nextSelect === 4){
					baseBet = 100, target = 1.2, betMultiplier = 10.2, targetMultiplier = 0, limitBet = MAX_BET;
				} else if (nextSelect === 5){
					baseBet = 1000, target = 8, betMultiplier = 1.13, targetMultiplier = 0, limitBet = 100000;
				} else if (nextSelect === 6){
					baseBet = 100, target = 2.3, betMultiplier = 1.8, targetMultiplier = 0, limitBet = 111600;
				} else if (nextSelect === 7){
					baseBet = 50, target = 7.4, betMultiplier = 1.4, targetMultiplier = 0, limitBet = 290000;
				}else if (nextSelect === 8){
					baseBet = 100, target = 1.3, betMultiplier = 8.6, targetMultiplier = 0, limitBet = MAX_BET;
				}else if (nextSelect === 9){
					baseBet = 100, target = 4.3, betMultiplier = 1.15, targetMultiplier = 0, limitBet = 200000;
				} else {
					baseBet = 500, target = 1.1, betMultiplier = 1.006, targetMultiplier = 1.005, limitBet = MAX_BET;
				}
				let resting = true;
				while (resting) {
					await this.log(`[INFO] Starting martingale with a base bet of ${baseBet/100} bits.`)
					await sleep(BET_SPEED);
					const bet = betSize(lossCount)
					if (MAX_GAMES !== -1 && gameNum >= MAX_GAMES) {
						// stop after playing max num of games
						this.log(`[INFO] Stopped after playing ${MAX_GAMES} games.`)
						running = false;
						resting = false;
					} else if (bet >= MAX_BET || bet >= limitBet) {
						// stop if bet amount reaches max bet
						this.log(`[INFO] Max bet (${bet/100} bits) reached. Cutting losses.`)
						lossCount /= 3;
						//await skipGames(10, target, true);
					} else if (gameNum >= req && result.multiplier >= prevTarget && lossCount <= 0) {
						//resting = false;
						this.log(`[INFO] Finished resting getting back to work`)
						resting = false;
					} else {
						// make the bet and wait for the result
						result = await this.bet(bet, target)

						if (result.multiplier < target) { // loss
							lossCount++
							target += targetMultiplier;
							this.log(`[INFO] Lost bet. Multiplying bet size by ${betMultiplier} for new bet size of ${bet/100} bits.`)
						} else { // win
							lossCount = 0
							this.log(`[INFO] Won bet. Setting bet size to ${baseBet/100} bits.`)
						}
					}
					gameNum++
				}
				if(gameNum % 10 === 0){
					refreshSeed(this);
				}
				nextSwitch = Date.now() + Math.random() * 20000;
				lossCount = 0, baseBet = prevBet, target = prevTarget, betMultiplier = prevBetMultiplier; targetMultiplier = prevTargetMultiplier;
			}
			lossCount = 0;
		}
	}
	gameNum++
	await sleep(BET_SPEED + (100 * Math.random()));
}
}
await main();