CrashBet | EtherCrash Script

EtherCrash Script - Po Changer V2

After a lost game with this script, you can make both bet and payout adjustment.

In the first “begin bet” field, enter the amount you want to play in the first game, enter the starting rate in the second “begin payout” field. After a game lost in the third zone, you can continue to play by setting the odds for the number of games you specified in the third “win repeat” field. If you don’t want to place a high bet, enter the limit in field Four. When you lose the game, use the lost area to increase your bet.Use increase to increase by a fixed amount and decrease to decrease by a fixed amount. You can use the fold area to increase using a multiplier ratio.select “base payout” or “base bet” if you don’t want to change it. You can also make the bets for the game won after the lost game. these settings work for the number of games you have entered in the “win repeat” field and then return to the initial bet amount. You can use the “fix fold calculate” table to calculate the bet fold ratio.

Watch the case study video.

Change Log

Ver.2

Bet settings after the lost game have been improved.
Adding and decreasing flat rate bets have been added.
Adding and decreasing flat rate payout has been added.
Bet settings have been improved for the game won after the game lost, the desired setting for the specified number of games.
Adding and decreasing flat rate bets have been added.
Adding and decreasing flat rate payout have been added.

        
//  **********  Crash.Bet EtherCrash PoChanger v2  **********

//  Base bet is Here 
var baseBet = 1;

//  Base Payout is Here 
var basePayout = 2;

//  loss Payout Settings is Here 
//  ** Adds to the base payout **
//  ** lossPayoutSet 0 = Base Payout **
//  ** lossPayoutSet 1 = Fold Payout **
//  ** lossPayoutSet 2 = Increase Payout **
//  ** 1 = 1.00x **
//  ** If the number is negative, the ratio decreases **
var lossPayoutSet = 0;
var lossFoldPayout = 0;
var lossIncreasePayout = 0;

//  Loss Bet Setting is Here 
//  ** This rate is multiplied by the current bet **
//  ** lossBetSet 0 = Base Bet**
//  ** lossBetSet 1 = Fold Bet**
//  ** lossBetSet 2 = Increase Bet**
//  ** 1 = 1 Currency**
//  ** If the number is negative, the ratio decreases **
var lossBetSet = 0;
var lossFoldBet = 0;
var lossIncreaseBet = 0;

//  Win Payout Settings is Here 
//  ** Adds to the base payout **
//  ** winPayoutSet 0 = Base Payout **
//  ** winPayoutSet 1 = Fold Payout **
//  ** winPayoutSet 2 = Increase Payout **
//  ** 1 = 1.00x **
//  ** If the number is negative, the ratio decreases **
var winPayoutSet = 0;
var winFoldPayout = 0;
var winIncreasePayout = 0;

//  Win Bet Setting is Here 
//  ** This rate is multiplied by the current bet **
//  ** winBetSet 0 = Base Bet**
//  ** winBetSet 1 = Fold Bet**
//  ** winBetSet 2 = Increase Bet**
//  ** 1 = 1 Currency**
//  ** If the number is negative, the ratio decreases **
var winBetSet = 0;
var winFoldBet = 0;
var winIncreaseBet = 0;

//  Max. Bet is Here 
var maxBetStop = 100000;

// Win Game Repeat Count
var winRepeat = 0;

// Win Game Starting Type
// ** 0 = Base value - 1 = Last Value **
var winStartingType = 0

//  *********   Do not make changes in this area   *********
var fixedBaseBet = baseBet * 100;
var currentBet = fixedBaseBet;
var currentPayout = basePayout;

var lossStatus = false
var firstWin = false
var winGameCount = 0

engine.on('game_starting', function () {

    var lastGamePlay = engine.lastGamePlay();

    if (lastGamePlay == 'WON'){
        console.log('You Won!!');
            winGameCount++
            currentBet = winBetSwitch(winBetSet);
            currentPayout = winPOSwitch(winPayoutSet);
            firstWin = false
            if(winGameCount > winRepeat){
                lossStatus = false
            }
    } else if (lastGamePlay == 'LOST') {
        console.log('You Loss!!');
        lossStatus = true
        firstWin = true
        winGameCount = 0
        currentBet = lossBetSwitch(lossBetSet)
        currentPayout = lossPOSwitch(lossPayoutSet)

    }
    var fixedCurrentBet = Math.round(currentBet / 100) * 100;
    if (fixedCurrentBet > 0 && fixedCurrentBet <= engine.getBalance() && fixedCurrentBet <= engine.getMaxBet() && fixedCurrentBet <= maxBetStop * 100) {
        engine.placeBet(fixedCurrentBet, Math.round(currentPayout * 100), false);
        console.log('Next game bet:', fixedCurrentBet / 100, ' Payout:', Math.round(currentPayout * 100));
    } else {
        engine.stop();
        console.log('You ran out of bits or exceeded the max bet or betting nothing :(');
    }
})
function winBetSwitch (switchValue){
    switch(switchValue) {
        case 1:
            if(lossStatus){
                if(winRepeat >= winGameCount){
                if(!winStartingType && firstWin){
                    return fixedBaseBet * winFoldBet
                }else{
                    return currentBet * winFoldBet
                }
            }
        }

        return fixedBaseBet

          break;
        case 2:
                if(lossStatus){                    
                    if(winRepeat >= winGameCount){                  
                    if(!winStartingType && firstWin){
                        return fixedBaseBet + (winIncreaseBet*100)
                    }else{
                        return currentBet + (winIncreaseBet*100)
                    }    
                }
            }
            return fixedBaseBet
          break;

        case 0:
            return fixedBaseBet
          break;
      }
}
function winPOSwitch (switchValue){
    switch(switchValue) {
        case 1:
                if(lossStatus){
                    if(winRepeat >= winGameCount){
                    if(!winStartingType && firstWin){
                        return basePayout * winFoldPayout
                    }else{
                        return currentPayout * winFoldPayout
                    }    
                }
            }
            return basePayout

          break;
        case 2:
                if(lossStatus){
                    if(winRepeat >= winGameCount){
                    if(!winStartingType && firstWin){
                        return basePayout + winIncreasePayout
                    }else{
                        return currentPayout + winIncreasePayout
                    }    
                }
            }
            return basePayout

          break;
        case 0:
            return basePayout
          break;
      }
}
function lossBetSwitch (switchValue){
    switch(switchValue) {
        case 1:
            return currentBet * lossFoldBet
          break;
        case 2:    
            return currentBet + (lossIncreaseBet*100)
          break;
        case 0:
            return fixedBaseBet
          break;
      }
}
function lossPOSwitch (switchValue){
    switch(switchValue) {
        case 1:
            return currentPayout * lossFoldPayout
          break;
        case 2:
            return currentPayout + lossIncreasePayout
          break;
        case 0:
            return fixedBaseBet
          break;
      }
}
//  **************************************************************

To help with the continuity of our site and better features, you can donate. Thank you for your support.