RSS | Roulette Scripter Studio | Create your own roulette system using Roulette Scripter Studio
 

Do you want to code your own Roulette System?

 
 

Roulette Scripter Studio first auto play software for online roulette table.

 
Roulette Scripter Studio can create any type of roulette systems based on all existing roulette elements.
 
In future to refer to Roulette Scripter Studio we will use it short name RSS.
 
RSS scripts are written in open source format and this mean the player can always share, modify or extend them.
 
With RSS the player can create any possible types of roulette systems based on all roulette elements that will include betting on: numbers, red/black, high/low, odd/even, split bets, street bets, corner bets, line bets, four bet, columns, dozens also combined elements.
 
This roulette tool represent an auto play software that will follow the commands from the script line by line and always will do all is coded into your script.
 
RSS can play in all online roulette tables from any online casinos based on Playtech platform.
So it has several important features like auto play and real time landed numbers recognize procedure.
 
Related to auto play this mean the software has set of click procedures that will allow you to write code that will click on the roulette elements you may need from your roulette table.
 
Related to numbers recognize procedure then it will look into your roulette table and will capture the part of the screen related to it and after will run recognize procedure by returning to the player the last landed number.
 
These two are one of the most important features of the roulette scripter studio.
 
Also RSS have a set of decisional and loop blocks that will allow you to create any type of structures for your own unique roulette system.
 
RSS scripting is based on Pascal syntax so in case you can have any questions related to how to code several structures then internet will give you the answer to any of the questions you can have.
 
Anyway even without internet we have our tutorial and on our forum we just opened a new board called RSS-Coding Zone where our customers may put questions and receive answers from the other.
 

I want to tell to all that this roulette tool is not for analyze of your roulette system even if it can do this also.

It is supposed to be used to play the most complex roulette systems and this mean the single limitation is only your mind.
 
For example you can create roulette systems based on active analyze that's mean before to bet on several roulette elements RSS will analyze previous situation and will take the right decision based on your algorithm.
 
RSS can be extended without any limits via additional libraries that may be released as by our team as by our members so all the user should do is to add the new libraries to his roulette system.
 
RSS also allow several coders to work in a team while developing the most complex roulette systems.
 
People who already used scripting will find coding this tool very easy but the people who never used scripting can learn this process very easy using RSS tutorial or by asking the other users who already use it.
 
If you are professional roulette players then this roulette tool is for you but if you want to become and play like a professional then it is also for you.
 
Already have RSS installed?
Let suppose you already have RSS installed on your computer and already started it.
In this case you will see the next form that represent Roulette Scripter Studio IDE or RSS IDE.
 
As you see RSS IDE consist from 3 zones: Code Explorer, Source Explorer, Console
Code Explorer - is used to enter your script code.
Source Explorer - show all functions, procedures, units used in active script.
Console - will serve like a board that can show real time all active variables.
 

Now is the time to explain what can do this software but before this I want to present it menu.

 
File Menu is used to perform operations with files and in our cases these will be rss scripts or let say your own
roulette systems or even additional routines for your own roulette systems.
As you see from the screenshot you can create one new script or to load an already existing script from
your computer also to save it or even to save it as a new name.
 
Edit Menu is used to perform operations with your code.
As you know sometimes the code can have a lot of lines and you can need to perform copy/paste of some lines
from one function or procedure to another in order to avoid to write the same code from zero.
In the same time when your code is big you can need to search for a special code or to perform a replace procedure.
Cut, Copy, Paste- are used to operate with your script lines. The functionality is the same like in every text editor.
Find - is used to search for variable, function or procedure. The functionality is the same like in every text editor.
Replace - is used usually to change one old text with the other new . So this work like in every text editor.
 
Vew menu is used to activate or deactivate the next 3 view zones:code explorer, source explorer, console.
You can use this feature in case you will need more visibility for code explorer instead of source explorer or console.
 
Debug menu - is the most important part of this software.
It contain a lot of functionality all related to run time process.
Using this menu you can run your own script also to debug step by step your script also to check step by step how
work your script and to find most of the errors during the coding process.
Simply to say this will allow you to check and to avoid later most of the errors.
More info related to every Debug's menu function we will add later.
For now you should know that by pressing Run button you will execute your script.
 
Help menu at this time contain some functionality related to User Profile and RSS registration process.
Later we may add a quick online help but for now all the help you can find on our site.
 
Quick toolbar has a set of most used functions during the coding process.
 
Now when you have a general knowledge about this software we can start the coding process.
Before we will start I want to explain how RSS work and what RSS can do.
RSS can play Online Roulette and this mean it can bet on all roulette elements and can recognize landed numbers.
RSS don't use exe file memory or other methods that deal with memory or casino dll's to read the landed numbers.
It has several functions that works with images so it can recognize landed numbers.
 
RSS is a bridge between a normal scripter studio and online roulette table. It is based on Pascal scripting.
We also can release and Visual Basic scripting IDE for users who want to use this scripting language.
Due to the fact that RSS IDE is based on these well know scripting languages our future customers always will
be able to find tutorials and free code on the internet.
 
In the world exist more then 100 000 people who use Pascal and Visual Basic.
From our side scripting is the single way that will allow you to make any type of roulette systems.
 
In order to not understand me wrong i want to pay attention to all that RSS can interact with online roulette.
How it do this? Sure via our roulette routines embeded into RSS.
So after RSS IDE was started the next step is to start the online casino you want to use.
You should know that our software can be used with more then 50 online casinos all based on Playtech platform.
Now when your roulette window is started I will recommend to set for it fast mode to not wait until it will spin.
Look on the top left corner of the roulette window and you will see "European Roulette - onlineCasino.com"
This is the roulette window name that point to RSS which roulette window to use because in the same time you
can use more then one roulette window while playing.
Also for other language installations the roulette window name can differ from this one.
 
So the first procedure you will use in every script will be
set_roulette_window_name('Roulette Window Name');
For our example we will have the next code: set_roulette_window_name('European Roulette - onlineCasino.com');
 
Another most used procedure will be click_spin() that will do a free spin.
 
So now when we know at least 2 procedures let write our first simple code and to run it.

Enter in your RSS Code Explorer the next code:

set_roulette_window_name('European Roulette - onlineCasino.com');
click_spin();
and click RUN button(green triangle from tool bar) or from Debug->Run so you will see how RSS will do one free spin.
 
So after this small script I am sure you will understand how RSS will operate.

Now is the time to let you all know also about other procedures.

So I added a lot of procedures related to clicks and this mean you have all the procedures you can need while
using roulette window.
 

We have in RSS a feature called Code Completition that will help you to put the proper code and to avoid mistakes.

In order to activate this feature please click Ctrl+Space in your RSS Code Explorer and a combo box with all
available procedures and functions from RSS will open.
 
Now is the time to put here all available procedures related to clicks.
By click procedures I mean the click action that usually the player do but in our case the RSS will do.
 
Like I told before RSS can perform all possible roulette table clicks.
 
Now let continue with the most important procedures from RSS.
click_spin() - perform roulette spin procedure.
click_clear_bets() - perform roulette clear bets procedure.
click_rebet() - perform roulette rebet procedure.
 
As you know the roulette game consist in betting money on roulette elements.

To do this on every roulette table exist chips and every chip has it own value.

In our case we have 7 chips with the next values:1, 5, 10, 25, 100, 500, 1000
So chip1=1, chip2=5, chip3=10, chip4=25, chip5=100, chip6=500, chip7=1000
Please use the next procedures in dependence of the amount you want to bet on every roulette element.
click_chip1();
click_chip2();
click_chip3();
click_chip4();
click_chip5();
click_chip6();
click_chip7();
So what we do in a real game situation?
We click on the chip value we want to use.
After we click on the roulette element we want to bet this amount and after press spin button.

Example:

set_roulette_window_name('European Roulette - onlineCasino.com');
click_chip1();
click_straight_up_0(); //bet on number 0
click_spin();
So this script will bet 1$ on number 0 and will spin.
I suppose you know what to do in order to bet 2$ or 5$ or even 7$.
Remember you should tell to RSS via code to do the same will do a real player.

Example:

//How to bet 7$ on nnumber 7?
set_roulette_window_name('European Roulette - onlineCasino.com');
click_chip2(); //select 5$ chip
click_straight_up_7(); //bet on number "7" 5$
click_chip1(); //select 1$ chip
click_straight_up_7(); //bet on number "7" 1$
click_straight_up_7(); //bet on number "7" again 1$ so now we will have 5+1+1=7$ on number 7
click_spin();
Sure in some case we may need to write one click procedure more then 10-20 times.
Don't worry for such cases exist loop block that will help you to avoid this and I will talk about loop blocks later.
For now you should know that such method really will allow you to write any type of roulette systems.
 

By the way the code sometimes can be too long this is why in RSS we can put also comments.

 
For comment please use the next two structures // or {}
// Here your comment. Such structure should be used for line comment.
{} For multiline comments. Such structure should be used for multiline comments or when you don't want to use
some code for specific time. Yes you can mark it as a comment.
 

In the previos example we bet some amount of money on number 7.

 
Bellow you can see the procedures that will allow you to bet the wanted amount on the number you want.

Yes you can bet the wanted amount on every number you want.

click_straight_up_0();
click_straight_up_1();
click_straight_up_2();
click_straight_up_3();
click_straight_up_4();
click_straight_up_5();
click_straight_up_6();
click_straight_up_7();
click_straight_up_8();
click_straight_up_9();
click_straight_up_10();
click_straight_up_11();
click_straight_up_12();
click_straight_up_13();
click_straight_up_14();
click_straight_up_15();
click_straight_up_16();
click_straight_up_17();
click_straight_up_18();
click_straight_up_19();
click_straight_up_20();
click_straight_up_21();
click_straight_up_22();
click_straight_up_23();
click_straight_up_24();
click_straight_up_25();
click_straight_up_26();
click_straight_up_27();
click_straight_up_28();
click_straight_up_29();
click_straight_up_30();
click_straight_up_31();
click_straight_up_32();
click_straight_up_33();
click_straight_up_34();
click_straight_up_35();
click_straight_up_36();
Please use this procedures in case you want to bet some amount on one or more numbers;

As you see every procedure start with click_straight_up_X(); X is the number on which RSS will bet a value.

 
I think a simple example will explain more related to this.

Example:

//let bet 2$ on number 1 and 5$ on number 10
set_roulette_window_name('European Roulette - onlineCasino.com');
click_chip1();//activate 1$ chip
click_straight_up_1(); //put 1$ on 1
click_straight_up_1();//put again 1$ to 1 in order to have 2$
click_chip2();//activate 5$ chip
click_straight_up_10();//put 5$ on number 10
click_spin();
Now press Run button and you will see how RSS will bet 2$ on number 1 and 5$ on number 10 and will spin.
 
Ok now let move forward.

If you want to use split bets then please use the next procedures:

click_split_bet_0_1();
click_split_bet_0_2();
click_split_bet_0_3();
click_split_bet_1_2();
click_split_bet_2_3();
click_split_bet_1_4();
click_split_bet_2_5();
click_split_bet_3_6();
click_split_bet_4_5();
click_split_bet_5_6();
click_split_bet_4_7();
click_split_bet_5_8();
click_split_bet_6_9();
click_split_bet_7_8();
click_split_bet_8_9();
click_split_bet_7_10();
click_split_bet_8_11();
click_split_bet_9_12();
click_split_bet_10_11();
click_split_bet_11_12();
click_split_bet_10_13();
click_split_bet_11_14();
click_split_bet_12_15();
click_split_bet_13_14();
click_split_bet_14_15();
click_split_bet_13_16();
click_split_bet_14_17();
click_split_bet_15_18();
click_split_bet_16_17();
click_split_bet_17_18();
click_split_bet_16_19();
click_split_bet_17_20();
click_split_bet_18_21();
click_split_bet_19_20();
click_split_bet_20_21();
click_split_bet_19_22();
click_split_bet_20_23();
click_split_bet_21_24();
click_split_bet_22_23();
click_split_bet_23_24();
click_split_bet_22_25();
click_split_bet_23_26();
click_split_bet_24_27();
click_split_bet_25_26();
click_split_bet_26_27();
click_split_bet_25_28();
click_split_bet_26_29();
click_split_bet_27_30();
click_split_bet_28_29();
click_split_bet_29_30();
click_split_bet_28_31();
click_split_bet_29_32();
click_split_bet_30_33();
click_split_bet_31_32();
click_split_bet_32_33();
click_split_bet_31_34();
click_split_bet_32_35();
click_split_bet_33_36();
click_split_bet_34_35();
click_split_bet_35_36();

For Street Bets please use the next procedures:

click_street_bet_0_1_2();
click_street_bet_0_2_3();
click_street_bet_1_2_3();
click_street_bet_4_5_6();
click_street_bet_7_8_9();
click_street_bet_10_11_12();
click_street_bet_13_14_15();
click_street_bet_16_17_18();
click_street_bet_19_20_21();
click_street_bet_22_23_24();
click_street_bet_25_26_27();
click_street_bet_28_29_30();
click_street_bet_31_32_33();
click_street_bet_34_35_36();

For Corner Bets please use the next procedures:

click_corner_bet_1_2_4_5();
click_corner_bet_2_3_5_6();
click_corner_bet_4_5_7_8();
click_corner_bet_5_6_8_9();
click_corner_bet_7_8_10_11();
click_corner_bet_8_9_11_12();
click_corner_bet_10_11_13_14();
click_corner_bet_11_12_14_15();
click_corner_bet_13_14_16_17();
click_corner_bet_14_15_17_18();
click_corner_bet_16_17_19_20();
click_corner_bet_17_18_20_21();
click_corner_bet_19_20_22_23();
click_corner_bet_20_21_23_24();
click_corner_bet_22_23_25_26();
click_corner_bet_23_24_26_27();
click_corner_bet_25_26_28_29();
click_corner_bet_26_27_29_30();
click_corner_bet_28_29_31_32();
click_corner_bet_29_30_32_33();
click_corner_bet_31_32_34_35();
click_corner_bet_32_33_35_36();

For Line Bets please use the next procedures:

click_line_bet_1_2_3_4_5_6();
click_line_bet_4_5_6_7_8_9();
click_line_bet_7_8_9_10_11_12();
click_line_bet_10_11_12_13_14_15();
click_line_bet_13_14_15_16_17_18();
click_line_bet_16_17_18_19_20_21();
click_line_bet_19_20_21_22_23_24();
click_line_bet_22_23_24_25_26_27();
click_line_bet_25_26_27_28_29_30();
click_line_bet_28_29_30_31_32_33();
click_line_bet_31_32_33_34_35_36();

For four bet please use the next procedure:

click_four_bet();

For Dozen Bets please use the next procedures:

click_first_dozen_bet();
click_second_dozen_bet();
click_third_dozen_bet();

For Columns Bets please use the next procedures:

click_first_column_bet();
click_second_column_bet();
click_third_column_bet();

For Low/High bets please use the next procedures:

click_low();
click_high();

For Odd/Even bets please use the next procedures:

click_even();
click_odd();

For Black/Red bets please use the next procedures:

click_black();
click_red();

Now the last and most important procedures related to clicks.

click_spin();
click_clear_bets();
click_rebet();
 
During the game you always will need to take a decision and the decision always will depend on the last landed
number or numbers and this will depend on the strategy you will use for your roulette system.

In order to get the last landed number please use the next function:

get_landed_number();

Example:

This code will do one free click and will show the landed number in the RSS console.
set_roulette_window_name('European Roulette - onlineCasino.com');
click_spin();
print(inttostr(get_last_number()));
 
So this is all related to procedures and functions that can perform any actions with online roulette table.
The next step is to learn about decisional and loop blocks that will open for us an infinite world of posibilities.
 

Identifiers

Identifiers names in script (variable names, function and procedure names, etc.) follow the most
common rules in pascal : should begin with a character (a..z or A..Z), or '_', and can be followed by
alphanumeric chars or '_' char. Cannot contain any other character os spaces.
 

Assign statements

Just like in Pascal, assign statements (assign a value or expression result to a variable or object
property) are built using ":=". Examples:
MyVar := 2;
 

Character strings

Strings (sequence of characters) are declared in pascal using single quote (') character. Double quotes
(") are not used. You can also use #nn to declare a character inside a string. There is no need to use
'+' operator to add a character to a string. Some examples:
A := 'This is a text';
Str := 'Text '+'concat';
B := 'String with CR and LF char at the end'#13#10;
C := 'String with '#33#34' characters in the middle';
 

Comments

Comments can be inserted inside script. You can use // chars or (* *) or { } blocks. Using // char the
comment will finish at the end of line.
//This is a comment before ShowMessage
ShowMessage('Ok');
 
(* This is another comment *)
ShowMessage('More ok!');
 
{ And this is a comment
with two lines }
ShowMessage('End of okays');
 

Variables

There is no need to declare variable types in script. In this case, variables are implicit declared.
Examples:

A:=0;
A:=A+1;

 
S:='Hello World!';
ShowMessage(S);
 
Indexes
Strings, arrays and array properties can be indexed using "[" and "]" chars. For example, if Str is a
string variable, the expression Str[3] returns the third character in the string denoted by Str, while Str[I
+ 1] returns the character immediately after the one indexed by I. More examples:
MyChar:=MyStr[2];
MyStr[1]:='A';
MyArray[1,2]:=1530;
 

Arrays

Script support array constructors and support to variant arrays. To construct an array, use "[" and "]"
chars. You can construct multi-index array nesting array constructors. You can then access arrays
using indexes. If array is multi-index, separate indexes using ",".
If variable is a variant array, script automatically support indexing in that variable.
Arrays in script are 0-based index. Some examples:
NewArray := [ 2,4,6,8 ];
Num:=NewArray[1]; //Num receives "4"
MultiArray := [ ['green','red','blue'] , ['apple','orange','lemon'] ];
Str:=MultiArray[0,2]; //Str receives 'blue'
MultiArray[1,1]:='new orange';
 

If statements

There are two forms of if statement: if...then and the if...then...else. Like normal pascal, if the if
expression is true, the statement (or block) is executed. If there is else part and expression is false,
statement (or block) after else is execute. Examples:
begin
set_roulette_window_name('European Roulette - onlineCasino.com');
//repeat click_spin action until will land number 0
repeat
click_spin();
until (get_last_number()=0)
//make a new spin after landed number 0
click_spin();
//from this point the decision will be taken from the next number will land after zero
last_landed_number:=get_last_number();//assign to landed_number variable the last landed number
if (last_landed_number<19)
then
begin //bet on red if last landed number is <19
click_chip1();
click_red();
ShowMessage('Please check that RSS bet on RED')
click_spin();
end
else
begin //bet on black if last landed number is not (<19)
click_chip1();
click_black();
ShowMessage('Please check that RSS bet on BLACK')
click_spin();
end;
end;
So a simple comment related to this script.
RSS will spin untill will land number 0.
After this it will do another free spin and from the number will land it will take the decision on which color to bet.
If the number <19 then it will bet on red else on black.
How much? It will click on chip 1 so this will be 1$ in our case.
 

While statements

A while statement is used to repeat a statement or a block, while a control condition (expression) is
evaluated as true. The control condition is evaluated before the statement. Hence, if the constrol
condition is false at first iteration, the statement sequence is never executed. The while statement
executes its constituent statement (or block) repeatedly, testing expression before each iteration. As
long as expression returns True, execution continues. Examples:

Example Soon

 

Repeat statements

The syntax of a repeat statement is repeat statement1; ...; statementn; until expression where
expression returns a Boolean value. The repeat statement executes its sequence of constituent
statements continually, testing expression after each iteration. When expression returns True, the
repeat statement terminates. The sequence is always executed at least once because expression is
not evaluated until after the first iteration. Examples:

begin
set_roulette_window_name('European Roulette - onlineCasino.com');
//repeat click_spin action until will land number 0
repeat
click_spin();
until (get_last_number()=0)
end;

So this code will do free spins and will stop once the "0" will land.
 

For statements

Scripter support for statements with the following syntax: for counter := initialValue to finalValue do
statement. For statement set counter to initialValue, repeats execution of statement (or block) and increment
value of counter until counter reachs finalValue. Examples:
//Show all numbers that are black
begin
black_numbers := [2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35];
for k:=0 to 17 do
print(black_numbers[k]);
end;
or another example
//Show only first 10 numbers that are black
begin
black_numbers := [2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35];
for k:=0 to 9 do
print(black_numbers[k]);
end;
 

Case statements

Scripter support case statements with following syntax:
case selectorExpression of
caseexpr1: statement1;
...
caseexprn: statementn;
else
elsestatement;
end
If selectorExpression matches the result of one of caseexprn expressions, the respective statement (or
block) will be execute. Otherwise, elsestatement will be execute. Else part of case statement is
optional. Different from Pascal, case statement in script doesn't need to use only ordinal values. You
can use expressions of any type in both selector expression and case expression. Example:
begin
set_roulette_window_name('European Roulette - onlineCasino.com');
//repeat click_spin action until will land number 0
repeat
click_spin();
until (get_last_number()=0)
//make a new spin after landed number 0
click_spin();
//from this point the decision will be taken from the next number will land after zero
last_landed_number:=get_last_number();//assign to landed_number variable the last landed number
case last_landed_number of
1:ShowMessage('Landed 1');
2:ShowMessage('Landed 2');
3:ShowMessage('Landed 3');
4:ShowMessage('Landed 4');
5:ShowMessage('Landed 5');
6:ShowMessage('Landed 6');
7:ShowMessage('Landed 7');
8:ShowMessage('Landed 8');
9:ShowMessage('Landed 9');
else ShowMessage('Landed other number that is more then 9 or even 0');
end;
end;
 
So in case will land numbers from 1 to 9 then we will receive a show message and rss will tell us which number landed.
 
Sure we can have here more complex structure. Example:
begin
set_roulette_window_name('European Roulette - onlineCasino.com');
//repeat click_spin action until will land number 0
repeat
click_spin();
until (get_last_number()=0)
//make a new spin after landed number 0
click_spin();
//from this point the decision will be taken from the next number will land after zero
last_landed_number:=get_last_number();//assign to landed_number variable the last landed number
case last_landed_number of
1:
begin
//here can be another actions in case landed number 1
ShowMessage('Landed 1');
end;
2:
begin
//here can be another actions in case landed number 2
ShowMessage('Landed 2');
end;
3:
begin
//here can be another actions in case landed number 3
ShowMessage('Landed 3');
end;
4:
begin
//here can be another actions in case landed number 4
ShowMessage('Landed 4');
end;
5:
begin
//here can be another actions in case landed number 5
ShowMessage('Landed 5');
end;
6:
begin
//here can be another actions in case landed number 6
ShowMessage('Landed 6');
end;
7:
begin
//here can be another actions in case landed number 7
ShowMessage('Landed 7');
end;
8:
begin
//here can be another actions in case landed number 8
ShowMessage('Landed 8');
end;
9:
begin
//here can be another actions in case landed number 9
ShowMessage('Landed 9');
end;
else ShowMessage('Landed other number that is more then 9 or even 0');
end;
end;
 
Now is the time to go to something that will be more complex.
I know all will say:"Ok Now we know this but how to code the roulette system we want?"

I think from this point we can start to code something need our players.

 

So from this point I will start a section How To Do?

As you all know RSS can be extended so this mean every user can use for this units.
 
What represent an unit?
Simply to say this is a library of functions and procedures that come to help the player.
At this time we have one unit called rssutils
Bellow is the code of this unit:
//RSSUTILS unit
//Version 1
//made by MMM Admin on 14 October 2008

function is_red(number:integer):boolean;
begin
red_numbers := [1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36];

number_is_red:=false;

for k:=0 to 17 do
if number=red_numbers[k] then number_is_red:=true;

Result:=number_is_red;
end;
function is_black(number:integer):boolean;
begin
black_numbers := [2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35];

number_is_black:=false;

for k:=0 to 17 do
if number=black_numbers[k] then number_is_black:=true;

Result:=number_is_black;
end;
function is_low(number:integer):boolean;
begin
low_numbers := [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18];

number_is_low:=false;

for k:=0 to 17 do
if number=low_numbers[k] then number_is_low:=true;

Result:=number_is_low;
end;
function is_high(number:integer):boolean;
begin
high_numbers := [19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36];

number_is_high:=false;

for k:=0 to 17 do
if number=high_numbers[k] then number_is_high:=true;

Result:=number_is_high;
end;
function is_even(number:integer):boolean;
begin
even_numbers := [2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36];

number_is_even:=false;

for k:=0 to 17 do
if number=even_numbers[k] then number_is_even:=true;

Result:=number_is_even;
end;
function is_odd(number:integer):boolean;
begin
odd_numbers := [1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35];

number_is_odd:=false;

for k:=0 to 17 do
if number=odd_numbers[k] then number_is_odd:=true;

Result:=number_is_odd;
end;
function is_first_dozen(number:integer):boolean;
begin
first_dozen_numbers := [1,2,3,4,5,6,7,8,9,10,11,12];

number_is_from_first_dozen:=false;

for k:=0 to 11 do
if number=first_dozen_numbers[k] then number_is_from_first_dozen:=true;

Result:=number_is_from_first_dozen;
end;
function is_second_dozen(number:integer):boolean;
begin
second_dozen_numbers := [13,14,15,16,17,18,19,20,21,22,23,24];

number_is_from_second_dozen:=false;

for k:=0 to 11 do
if number=second_dozen_numbers[k] then number_is_from_second_dozen:=true;

Result:=number_is_from_second_dozen;
end;
function is_third_dozen(number:integer):boolean;
begin
third_dozen_numbers := [25,26,27,28,29,30,31,32,33,34,35,36];

number_is_from_third_dozen:=false;

for k:=0 to 11 do
if number=third_dozen_numbers[k] then number_is_from_third_dozen:=true;

Result:=number_is_from_third_dozen;
end;
function is_first_column(number:integer):boolean;
begin
first_column_numbers := [1,4,7,10,13,16,19,22,25,28,31,34];

number_is_from_first_column:=false;

for k:=0 to 11 do
if number=first_column_numbers[k] then number_is_from_first_column:=true;

Result:=number_is_from_first_column;
end;
function is_second_column(number:integer):boolean;
begin
second_column_numbers := [2,5,8,11,14,17,20,23,26,29,32,35];

number_is_from_second_column:=false;

for k:=0 to 11 do
if number=second_column_numbers[k] then number_is_from_second_column:=true;

Result:=number_is_from_second_column;
end;
function is_third_column(number:integer):boolean;
begin
third_column_numbers := [3,6,9,12,15,18,21,24,27,30,33,36];

number_is_from_third_column:=false;

for k:=0 to 11 do
if number=third_column_numbers[k] then number_is_from_third_column:=true;

Result:=number_is_from_third_column;
end;

 
As you know RSS has one function that allow the user to know the last landed number.
The function you can use for this is get_landed_number()
But how to be when we want to write a roulette system and we need to know:
if the number is black or red
if the number is low or high
if the number is even or odd
if the number is from first dozen or second dozen or third dozen
if the number is from first column or second column or third column
 
The solution is quite simple. Just use the rssutils unit and call the function you need for your roulette system.
is_black(number) or is_red(number) ;where the number can be last landed number
is_low(number) or is_high(number) ;where the number can be last landed number
is_even(number) or is_odd(number) ;where the number can be last landed number
is_first_dozen(number) or is_second_dozen(number) or is_trhird_dozen
is_first_column(number) or is_second_column(number) or is_third_column
 
I think a simple example will explain more:
uses rssutils;

begin
if (is_red(5)) then ShowMessage('Number 5 is Red');
if (is_black(6)) then ShowMessage('Number 6 is Black');
end;

 
Note: In order to be able to use rssutils unit please be sure that the script you will make are in the same directory as
rssutils unit.
 
How to wait for 5 consecutive reds?
I will post bellow the code that do this and after will follow some explanations:
uses rssutils;
procedure WaitFor5Red;
begin
counter:=0;//initialize the counter
repeat
click_spin();
if is_red(get_last_number())//verify if last landed number is RED
then Inc(counter) //If red then increment the counter by 1
else counter:=0; //If not then reset the counter to 0
until (counter=5) // this mean this loop block will run until 5 Reds will be found
end;

begin
ide_delay:=350;
set_roulette_window_name('European Roulette - onlineCasino.com');
WaitFor5Red;//clall the procedure that will wait for 5 consecutive reds
//Post below your code after the 5 consecutive Reds was found
click_chip1();//select 1$ chip
click_black();//bet on black
click_spin();
click_rebet();
click_clear_bets();
end;
 
So this code wait for 5 consecutive reds and after bet 1$ on the black.
But the code that do this is next:
counter:=0;//initialize the counter
repeat
click_spin();
if is_red(get_last_number())//verify if last landed number is RED
then Inc(counter) //If red then increment the counter by 1
else counter:=0; //If not then reset the counter to 0
until (counter=5) // this mean this loop block will run until 5 Reds will be found
 
As you see whole this code is written into WaitFor5Red procedure.
Sure you can wait for any type of sequences based on every roulette element or group of elements.
 
More info related to how to code your own roulette script with RSS is available only for our customers.
     
Copyright © 2007-2011, All rights reserved to Money Maker Machine