BUSTABIT

What you will need:

● 600 bits+ on your Bustabit account
● A script (included)
● Calculator
● Hope

If you’ve played Bustabit for a while but can’t seem to churn out profit then you have
a fundamental problem. There are many causes as to why this may happen such as
betting to high, cashing out too late, or being affected by the “rape trains.”

Our solution to this problem is to change the traditional system and turn it into
something that allows you to have continuous success.

Our solution:

First thing we need to do is to change the base bet. You will need to calculate
whether you have enough bits to survive through rape trains. The best formula for
this is:

Your Bits / 96

This will give you enough bits to bet and return a profit whilst being considerate of
rape trains happening.



Second thing we need to fix is the base multiplier or as it’s commonly known, the
auto­cashout. Normally it’s set to 1.10 or 1.13. What’s the point of that? You’re
missing out on the ripeness of plum that’s being picked. The best base multiplier is
either 1.25x or 1.33x (you decide on this one!). This will allow you to continuously
make a decent profit when compared to cashing out at 1.10x.



The third, yet final thing we need to change is the loss multiplier. When rape trains
happens this is essentially your life support so that you can return any losses. The
problem with the default value of the loss multiplier (4) is that if you lose five times in
a row, as an example, you lose all your bits. We need to change this value to something lower to either 3 or 2.
When the value is set to 2 it doubles the value
rather than quadrupling it, it also cashes out at 1.5x. When the value is set to 3 it
triples your loss, this may not seem like much of an improvement from quadrupling
the value but in the end it may save your bits which is what you want.This value
causes it to cash out at 1.33x on loss, also.




As you can see from my gains this method smells and looks like success without any
major losses. In the Bustabit community we call this the ‘slow, but steady’ method. It
takes advantage of the ‘slow and steady wins the race’ philosophy.

This method benefits you the most when you invest money into it.

This method does semi­work with less than 600 bits but it is quite risky and you have
a higher chance of losing most of your bits.




In this book we’re going to be explaining the reasoning and logic behind the original
book.

How much to properly bet.

In the initial book I had made a vague statement about how much to bet. This had
people getting more likely to lose their hard earned money during a rape train. I’m
going to better explain why I chose 96 and 128.

When I had chosen those numbers I had done it so it was in binary accounting for
rape trains. Eg. 3, 9, 27, 81, 243 etc. This seems logical as it would protect you
against 5 continuous rapes. If you had the multiply on loss set to 3 then that binary
would of done well against 4 rape trains (as it was 96 divided your total).

If you would want to set your multiply on loss you 2 you could do 2, 4, 8, 16, 32, 64,
128, 256 etc. This protects you against 8 rapetrains and you’re spending way less
compared to the 3, but you cash out at x1.5.

If you’re interested in a script that changes the bet as you earn more bits than I
recommend this: var baseBet = Math.round(engine.getBalance() / 100 / 256); You
need to change the last number if you want to do multiply on loss at 3.

Note: ​Removing the 100 from the variable above will make you bet all your bits as it
is done in satoshi’s. The 100 divides satoshis so that you can bet in bits.



How much to ideally multiply on loss.

The default multiplier of Procon is set to 4. I’ve suggested 2 or 3 cashout. I
personally use cashout of 2 and I’ve never lost any money during rapetrains with
this. It has been a different story when I use 3 though. I now suggest setting cashout
at 2 instead of 3 because you’ll save money and you won’t lose it all during rape
trains.

Advice: ​If variablebase is set to true, set it to false. That way it won’t bet 2 bits when
you set it to do higher.






// Settings
var baseBet = 6; // In bits
var baseMultiplier = 1.33; // Target multiplier: 1.13 recommended
var variableBase = false; // Enable variable mode (very experimental), read streakSecurity.
var streakSecurity = 4; // Number of loss-streak you wanna be safe for. Increasing this massively reduces the variableBase calculated. (1-loss = 20%, 2-loss = 5%, 3-loss = 1.25% of your maximum balance). Recommended: 2+
var maximumBet = 999999; // Maximum bet the bot will do (in bits).

// Variables - Do not touch!
var baseSatoshi = baseBet * 100; // Calculated
var currentBet = baseSatoshi;
var currentMultiplier = baseMultiplier;
var currentGameID = -1;
var firstGame = true;
var lossStreak = 0;
var coolingDown = false;

// Initialization
console.log('====== Procon\'s BustaBit Bot ======');
console.log('My username is: ' + engine.getUsername());
console.log('Starting balance: ' + (engine.getBalance() / 100).toFixed(2) + ' bits');
var startingBalance = engine.getBalance();

if (variableBase) {
      console.warn('[WARN] Variable mode is enabled and not fully tested. Bot is resillient to ' + streakSecurity + '-loss streaks.');
}

// On a game starting, place the bet.
engine.on('game_starting', function(info) {
      console.log('====== New Game ======');
    console.log('[Bot] Game #' + info.game_id);
      currentGameID = info.game_id;

      if (coolingDown) {
      if (lossStreak == 0) {
      coolingDown = false;
      }
      else {
      lossStreak--;
      console.log('[Bot] Cooling down! Games remaining: ' + lossStreak);
      return;
      }
      }

      if (!firstGame) { // Display data only after first game played.
      console.log('[Stats] Session profit: ' + ((engine.getBalance() - startingBalance) / 100).toFixed(2) + ' bits');
      console.log('[Stats] Profit percentage: ' + (((engine.getBalance() / startingBalance) - 1) * 100).toFixed(2) + '%');
      }

      if (engine.lastGamePlay() == 'LOST' && !firstGame) { // If last game loss:
      lossStreak++;
      var totalLosses = 0; // Total satoshi lost.
      var lastLoss = currentBet; // Store our last bet.
      while (lastLoss >= baseSatoshi) { // Until we get down to base bet, add the previous losses.
      totalLosses += lastLoss;
      lastLoss /= 4;
      }

      if (lossStreak > streakSecurity) { // If we're on a loss streak, wait a few games!
      coolingDown = true;
      return;
      }

      currentBet *= 3; // Then multiply base bet by 4!
      currentMultiplier = 1 + (totalLosses / currentBet);
      }
      else { // Otherwise if win or first game:
      lossStreak = 0; // If it was a win, we reset the lossStreak.
      if (variableBase) { // If variable bet enabled.
      // Variable mode resists (currently) 1 loss, by making sure you have enough to cover the base and the 4x base bet.
      var divider = 100;
      for (i = 0; i < streakSecurity; i++) {
      divider += (100 * Math.pow(4, (i + 1)));
      }

      newBaseBet = Math.min(Math.max(1, Math.floor(engine.getBalance() / divider)), maximumBet * 100); // In bits
      newBaseSatoshi = newBaseBet * 100;

      if ((newBaseBet != baseBet) || (newBaseBet == 1)) {
      console.log('[Bot] Variable mode has changed base bet to: ' + newBaseBet + ' bits');
      baseBet = newBaseBet;
      baseSatoshi = newBaseSatoshi;
      }
      }
      // Update bet.
      currentBet = baseSatoshi; // in Satoshi
      currentMultiplier = baseMultiplier;
      }

      // Message and set first game to false to be sure.
      console.log('[Bot] Betting ' + (currentBet / 100) + ' bits, cashing out at ' + currentMultiplier + 'x');
      firstGame = false;

      if (currentBet <= engine.getBalance()) { // Ensure we have enough to bet
      if (currentBet > (maximumBet * 100)) { // Ensure you only bet the maximum.
      console.warn('[Warn] Bet size exceeds maximum bet, lowering bet to ' + (maximumBet * 100) + ' bits');
      currentBet = maximumBet;
      }
      engine.placeBet(currentBet, Math.round(currentMultiplier * 100), false);
      }
      else { // Otherwise insufficent funds...
      if (engine.getBalance() < 100) {
      console.error('[Bot] Insufficent funds to do anything... stopping');
      engine.stop();
      }
      else {
      console.warn('[Bot] Insufficent funds to bet ' + (currentBet / 100) + ' bits.');
      console.warn('[Bot] Resetting to 1 bit basebet');
      baseBet = 1;
      baseSatoshi = 100;
      }
      }
});

engine.on('game_started', function(data) {
    if (!firstGame) { console.log('[Bot] Game #' + currentGameID + ' has started!'); }
});

engine.on('cashed_out', function(data) {
    if (data.username == engine.getUsername()) {
      console.log('[Bot] Successfully cashed out at ' + (data.stopped_at / 100) + 'x');
      }
});

engine.on('game_crash', function(data) {
    if (!firstGame) { console.log('[Bot] Game crashed at ' + (data.game_crash / 100) + 'x'); }
});