Thanks to ND reminding me of this method, and gave it a name as Lazy24. I coded it in a version which suits on line and lower stakes, as on line you can accept longer sessions and use lower stakes. The script bet 1-1 until two winnings and then add one on each col every winning spin up to 5 chips, then it reset to one each, as it do on a loss. I expect about two weeks until the bot can be for public download.

The script:

var lose = ",0,1,4,7,10,13,16,19,22,25,28,31,34,";
var result = new Array();
function extfunc(number, betsize, bet){
var num = parseInt(number);
if(lose.indexOf("," + num + ",") >-1){
   result[result.length] = "L";
   return "co2,co3/" + betsize;
} else {
   result[result.length] = "W";
   temp = bet.split(",");
   if(result.length>1){
      if(temp.length<10){
         if(result[result.length-1] ==  "W" && result[result.length-2] ==  "W"){
            return  "co2,co3," + bet + "/" + betsize;
         }
         
      }
   }
}
return  "co2,co3/" + betsize;     
}

The comes closer to the release of the BV bot.  Some smaller issues to test more. Then a hope a few more are ready to write script for it.
I will concentrate of scripting later, and hope all popular methods can be scripted in rather short time. All scripts will automatic be updated for all users, as soon I have added it to the server.


The script here place the next bet on the last shown number and the two neigbors on both sides.  For  those not familar with programming it is a good script to examinate as it is rather easy to understand how it works.


The script get  the winning number, betsize and the bet. As it is straight up bets, it is the number which is the code for the bet.
It returns the new bet and the betsize.  The win target and stop loss is set in the main program. For example play 0.01 until 50 units plus or 200   units loss. The first release will handle session with maximum 100 Euros including the win target, which is 10000 units of the lowest bet size.



function extfunc (number,betsize, bet){
var num = parseInt(number);
switch(num){
   case 0:
   return "3,26,0,32,15/" + betsize;
   break;
   case 1:
   return "16,33,1,24,15/" + betsize;
   break;
   case 2:
   return "4,21,2,25,17/" + betsize;
   break;
   case 3:
   return "12,35,3,26,0/" + betsize;
   break;
   case 4:
   return "15,19,4,21,2/" + betsize;
   break;
   case 5:
   return "23,10,5,24,16/" + betsize;
   break;
   case 6:
   return "17,34,6,27,13/" + betsize;
   break;
   case 7:
   return "18,29,7,28,12/" + betsize;
   break;
   case 8:
   return "11,30,8,23,10/" + betsize;
   break;
   case 9:
   return "14,31,9,22,18/" + betsize;
   break;
   case 10:
   return "8,23,10,5,24/" + betsize;
   break;
   case 11:
   return "13,36,11,30,8/" + betsize;
   break;
   case 12:
   return "7,28,12,35,3/" + betsize;
   break;
   case 13:
   return "6,27,13,36,11/" + betsize;
   break;
   case 14:
   return "1,20,14,31,9/" + betsize;
   break;
   case 15:
   return "0,32,15,19,4/" + betsize;
   break;
   case 16:
   return "5,24,16,33,1/" + betsize;
   break;
   case 17:
   return "2,25,17,34,6/" + betsize;
   break;
   case 18:
   return "9,22,18,29,7/" + betsize;
   break;
   case 19:
   return "32,15,19,4,21/" + betsize;
   break;
   case 20:
   return "33,1,20,14,31/" + betsize;
   break;
   case 21:
   return "19,4,21,2,25/" + betsize;
   break;
   case 22:
   return "31,9,22,18,29/" + betsize;
   break;
   case 23:
   return "30,8,23,10,5/" + betsize;
   break;
   case 24:
   return "10,5,24,16,33/" + betsize;
   break;
   case 25:
   return "21,2,25,17,34/" + betsize;
   break;
   case 26:
   return "35,3,26,0,32/" + betsize;
   break;
   case 27:
   return "34,6,27,13,36/" + betsize;
   break;
   case 28:
   return "29,7,28,12,35/" + betsize;
   break;
   case 29:
   return "22,18,29,7,28/" + betsize;
   break;
   case 30:
   return "36,11,30,8,23/" + betsize;
   break;
   case 31:
   return "20,14,31,9,22/" + betsize;
   break;
   case 32:
   return "26,0,32,15,19/" + betsize;
   break;
   case 33:
   return "24,16,33,1,20/" + betsize;
   break;
   case 34:
   return "25,17,34,6,27/" + betsize;
   break;
   case 35:
   return "28,12,35,3,26/" + betsize;
   break;
   case 36:
   return "27,13,36,11,30/" + betsize;
   break;
}
}


For programers  or others, this script can be codet a lot of other ways.  You can use the winning numbers as key to a dic and you can place the return numbers in an Array at the index of the winning number.

Some  threads are locked with only one post!
The math shows figures which  are well known,  the 2.7% disadvantages in the play, We see these figures that we have seen before, a mathematical study of a game way usually give this results.  If I should use PB, my expectaion would be worse! The outcome may differ.

A roulette bot is dependet of reading the casino screen. It is almost impossible to make a robot working at any casino. My bot is made for Betvoyager Zero Wheel at the first hand. It will work on BV NOZero wheel as well, if the scripts not are written so it bet on zero as a default bet. It will count the balance and stop at win target on the NoZero wheel as well, but it will place 0.5 instead of 0.01 chips. As the balance at the casino account is read by the program, rather than a chip count it works on the NoZero, using the same scripts.  This feature makes the scripting much easier as well.


The multiball table will not work, as the program is not designed to read more than one winning number. You could use the multiball manual and let the bot place the bet, but it can not recognice the winning numbers. If you set the game to one ball it will work, but that is of minor use as it is the very same as the zero table.  The American table will not work if any bets are placed on zero or double zero, it can not understand and read the zero hits.


The first release the program will read the balance up to a certain amount in the range of 0.01 to 100 Euro a session. Higher values will be implementet later in coming versions. As most players use less than 100 Euro in one session, I will not let the program be delayed for that reason.


The program is ready, but I have to make test on many different computers first, it is not for sure a program works in all cases just because it works on the developers computer.  As said before the NET FRAMWORK have to be in the Windows, and I have not tested it on other platforms  with emulator for Windows. I  have to write a users manual as well.


The size of the program is about 2 megatbytes.  It will run in variable speed, most of the scripts will run a spin in about four seconds, and it can take a bit longer if for example 200 chips is to be placed.  It has a  slider which the user can slow down the speed or make it run faster. Depending on the scripts it is not always possible to run at the  maximum speed.


The program is designed to run on 32 and 64  computers, there are not different versions.  The program as such will never access the disk on the computer, If the casino cache or set cookies the program will not interfere, the usual settings for the computer security is used. The  security setting may ask the user for permission to access internet, which is to navigate to the casino.  The log in at the casino is the default page at the casino, the program can never  know this entries. The bot use the webbased version of the casino, not the exe version, and it is an instance of IExplorer which host the casino. A newer version should be present at the computer(It is included in Windows).


As the bot must force the casino window to not open in a new window, we should not use the program for navigating around, if we want to see the history, make deposits or other tasks, we shall do it using the ordinary webbrowser.  The program navigate to the casino main homepage, there we login at the default place, and then chose the game on the page. As soon a game is opened, we should try to not navigate so an other window will be forced to not open, it can be confusing for the casinos stylesheets or scripts.

I plan to make the bot accessable for using in about three weeks. How to script the bot I will publish some more later, for now here is an introduction for scripting.


Coding the Roullettetbot.com BVBot! There will be no fee for downloading the bot.
The bot will run using external scripts, and there are requirements to make it works well. The scripts are located at a server and will be accessable to all users, the same moment it will be added. The user can then chose a script for the play.
The script language can in principle be any, but to make it sure all users can run the scripts JavaScript or vBScript are best, as any users have that accessable via the OS in Windows.
The scripts should receive 3 arguments 1: The number won last spin. 2: The chip value 3:The bet.
The script should return the next bet, and the chip size.


       function extfunc(lastnumber,chipsize,bet){


          //the tasks of the script


          return bet + "/" + chipsize;


       }
   


The name of the receiving and returning function must have the name "extfunc". There could be more functions in the script.
The bets are described using string tokens which is separated by commas.
All possible bets or mix of bets can be used.
The bot will not work without a script, which the user chose in a listbox.
It is not for any other reason than calculate the next bet,the script need to know the win/loss, the bot reads the balance at the casino, and can be made to stop at a given win or loss.


The bets are described as follow:
The single, or straight up bets by the number. If the script returns "1,12,3" The bot place a chip straight up on the number 1,12 and 3.
If "13,13,13,14" is returned the bot place three chips on number 13 and one on number 14.


The other inside bets are easy to remember, it is always the lowest number following of a bet marker and the highest number.
A split use "#" as marker, and the split between 2 and 5 will be 2#5, important always the lowest number first and the bet marker followed by the highest number.
The street is similar 1s3 means the street 1,2,3.
The corner bet is 1c5 for the corner 1,2,4,5.
The line or double street has 1d6 for the first double street and all other the same style.
All bets can be mixed, if the script returns "1d6,1d6,7d12,7d12,35#36" the bot place two chips on the first and second line, and a split on number 35 and 36.


The outside bets have all tokens, the Ec "rr" for red,"bb" for black, "oo" for odd,"ee" for even, "ll" for low and "hh" for higth. Not hard to remember.


The dozen tokens are "ld", "md" and "hd". The Col tokens are "co1","co2","co3" ther co1 is the col with 1 on top and 34 on bottom.


This is about all you need to know to coding a script for any method! If you start with a simpler to get the concept, there are no limits making a method in scripting.


I will show a very simple script and explain the way a script should be written.


The example will be simple to follow, and will describe a martingale playing odd numbers.
The script needs at least one function, using the name "extfunc"!
        function extfunc(number,betsize,bets){
        }
   
The function receive three Args, in this case we assume number 2, betsize 0.1 and a bet on odd.
The function must first check if the number 2 is odd, if it win or lose.
       Partly pseudocode:
      function extfunc(number,betsize,bets){
       if(number == 0) { return as loss}
         if(number % 2 == 0) { return as loss }
          else { return as win }
          }
   
We check using a modular division if it is an odd or even number, but first handle zero.
If the bet lose we shall return two times the incoming bet, and if it wins we shall return the lowest bet.
           
      function extfunc(number,betsize,bets){
         if(number == 0) {return bets + "," + bets + "/0";}
         if(number % 2 == 0) {return bets + "," + bets + "/0";}
         else { return "oo"+"/0"; }
        }
   
That is the all the script checks if the number is odd, the args to the function was (2,0,oo) there 2 was the winning last number, 0 is the lowest bet (the index in the listbox) and "oo" the code for one chip on odd. If we had won the same bet will be returned, but on a loss the betsize will be double. The returnstring will because of a loss be "oo,oo/0" and the bot will place two 0.01 chips on odd.
Next time the bot will send the returned bet of two to the script, if we win the scrips return just one chip bet, if a loss it return four as it received a "oo,oo" bet and send it back two times the size.
This simple script can handle a martingale on one EC. Any coder familiar with the script language, are able to use Arrays or more advanced coding, no method is not possible. The main is the script get the bet, compute what to do the next bet and return that bet.
I will continue coding different methods, but invite all who code to make up the number of scripts.The scripts do not need to be wrapped what issue the bot can handle. Just a textfile with the script.A coder who do not have access to a scripting environment, can use the webbrowser and debug using alert or html to display the result during coding.