RX ScripRX Scripting Para Roulette Xtreme - Castellano - Capitulo 1 y 2ting Para Roulette Xtreme Castellano Capitulo 1 y 2

UX Software

Traducción libre - No oficial (Con el permiso de UX Software)

Realizada por RuleteroOnline http://ruleteroonline.blogspot.com.es

Versión Beta 2.0 – Diciembre/2015

RX Scripting para Roulette Xtreme - Castellano

Índice i – Introducción ....................................................................................................................... 5 ¿Para quién es este libro? .................................................................................................. 6 ¿Cómo usar este libro? ...................................................................................................... 7 Hora de comenzar.............................................................................................................. 8

1 - Conociendo RX Scripting .............................................................................................. 9 ¿Qué es RX Scripting? ..................................................................................................... 10 Que se puede hacer con RX Scripting ............................................................................... 11 La construcción del lenguaje ............................................................................................. 12 Comandos de acción ............................................................................................ 13 Comandos de condición ....................................................................................... 14 Juntando piezas ............................................................................................................... 15 El uso del auto generador de instrucciones ........................................................................ 17 Comenzando con el diseño de sistemas ............................................................................ 19 System ................................................................................................................ 19 Method ................................................................................................................ 19 Estructuras de bloque....................................................................................................... 22 Begin................................................................................................................... 22 End ..................................................................................................................... 22 Formatos estructurados .................................................................................................... 23 El uso de comentarios ...................................................................................................... 25 Comentarios de múltiples líneas ............................................................................ 25 Comentarios de una sola línea .............................................................................. 25 Almacenamiento de dat os................................................................................................. 26 Registros de dat os ............................................................................................... 27 Registros de estados ............................................................................................ 28 Comparadores para las declaraciones de condición ........................................................... 29 Comparadores de expresiones lógicas .................................................................. 30 Comparadores de conteo ..................................................................................... 31 Comparadores de apuestas perdidas .................................................................... 32 Comparadores de apuestas ganadas .................................................................... 33 Comparadores de salida de esquemas de ruleta .................................................... 34 Comparadores de valores en listas........................................................................ 35 Comparadores de respuesta ................................................................................. 36 Comparadores de distancia entre 2 números en la rueda de la ruleta ...................... 37 Comparadores de distancia entre 2 números en la marquesina de la ruleta ............. 38 Comparadores de patrones de salida .................................................................... 39

2 – Comandos de Condición ............................................................................................ 40 Iniciadores de condición ................................................................................................... 41 ¿Qué comando usar While o If? ............................................................................ 41 Condición Loop Until ............................................................................................ 42 Continuadores de condición .............................................................................................. 44 Uso del continuador Else ...................................................................................... 46 Condiciones de bloque ..................................................................................................... 47 El uso de la condición Group ................................................................................ 47

RO – Versión Beta 2.0 – Dic/2015

2


3 – Comandos de Acción ...................................................................................................... Acciones de colocación ........................................................................................................ Comando de acción Put............................................................................................ Comando de acción Put 100% .................................................................................. Acciones matemáticas .......................................................................................................... Comando de acción Add........................................................................................... Comando de acción Add 100% ................................................................................. Comando de acción Subtract y Subtract 100% ........................................................... Comando de acción Multiply ..................................................................................... Comando de acción Multiply 100% ............................................................................ Comando de acción Divide y Divide100% .................................................................. Acciones de entrada............................................................................................................. Comando de acción Input Data ................................................................................. Comando de acción Input Dropdown ......................................................................... Comando de acción Display ...................................................................................... Comando de acción Ask ........................................................................................... Acciones de asignación ........................................................................................................ Comandos de acciones de asignación para cambiar Roulette Xtreme ......................... Comando de acción Apply En Prison ............................................................... Comando de acción Apply Le Partage .............................................................. Comando de acción Load Double Wheel .......................................................... Comando de acción Load Single Wheel............................................................ Comando de acción Load No Zero Wheel ......................................................... Comando de acción Stop Session ................................................................... Comandos de acciones de asignación para copiar dat os ............................................ Comando de acción Copy.............................................................................. Comando de acción Copy Last ....................................................................... Comando de acción Copy List ........................................................................ Comando de acción Copy Neighbors ............................................................... Comando de acción Duplicate ........................................................................ Comandos de acciones de asignación de uso variado ................................................ Comando de acción Track Last....................................................................... Comando de acción Clear.............................................................................. Comando de acción Set Max .......................................................................... Comando de acción Set List........................................................................... Comando de acción Generate Random Number................................................. Comandos de acciones de asignación para registros de estado .................................. Comando de acción Set Flag .......................................................................... Comando de acción Reset All Flags.................................................................

4 – Los esquemas de apuestas de la ruleta .................................................................... Apuestas interiores Plenos ..................................................................................................................... Semiplenos .............................................................................................................. Semiplenos Horizontales .......................................................................................... Semiplenos Verticales .............................................................................................. Calles ...................................................................................................................... Seisenas (Líneas ) .................................................................................................... Cuadrados ............................................................................................................... Apuestas exteriores Docenas ..................................................................................................................


3


Columnas ................................................................................................................ Suertes Sencillas ..................................................................................................... Usando los esquemas con los comandos Comandos de acción ................................................................................................ Comandos de condición ...........................................................................................

5 – Creando sistemas de ruleta ........................................................................................... Sistema Martingala............................................................................................................... Ampliación del Sistema Martingala ........................................................................................ Sistema D’Alembert ............................................................................................................... Sistema D’Alembert Inverso..................................................................................................... Sistema Labouchere .............................................................................................................. Sistema Inside Number...........................................................................................................

6 – Plantilla de RX Scripting ................................................................................................. Uso de la plantilla para crear nuevos sistemas ....................................................................... Añadir la plantilla al editor del sistema ...................................................................................


4


i - Introducción Bienvenido a RX Scripting. Utilizando este sencillo lenguaje de programación, seremos capaces de crear una gran cantidad de sistemas de ruleta. El libro ha sido escrito para que sirva de int roducción al RX Scripting, sin necesidad de que tengas que ser un experto en programación para poder escribir sistemas de ruleta.


5


¿Para quién es este libro? Este libro, está escrito para aquellas personas que quieren aprovec har la potencia del lenguaje RX Scripting que incorpora Roulette Xtreme, para poder crear y probar sistemas de rulet a que posteriormente se podrán utilizar tanto en los casinos online como en los casinos reales. Suponemos que no tienes conocimientos de programación de ordenadores ni de lenguajes de secuencias de comandos. No obstant e, asumimos que conoc es el juego de la ruleta y sus diferentes combinaciones de apuestas y pagos. Si ya tienes nociones de programación, debes saber que este libro no tiene el mismo enfoque para aprender RX Scripting que el que pueden tener los libros para aprender otros lenguajes de programación. Este libro no profundiza en los detalles del lenguaje RX Scripting propiamente dicho, ya que se puede encontrar toda la información sobre los detalles y la sintaxis del lenguaje en la documentación de ayuda que se incluye con el software Roulette Xtreme. Sin embargo, llegado el caso, sí que es posible que ent remos en detalle en algunos tipos de comandos de acción y de condición concretos para que no tengas que pasar mucho tiempo leyendo la documentación de ayuda. Este libro se centra en mostrar cómo crear sistemas útiles con RX Scripting sin proporcionar información superflua.


6


¿Cómo usar este libro? A lo largo del libro, utilizaremos técnicas especiales, para que sea más fácil la lectura y la comprensión del mismo. Así pues, en las instrucciones paso a paso que conforman la mayor part e de este libro, existen estilos de letra especiales para remarcar el código RX Scripting como se muestra en el siguiente ejemplo:

Del mismo modo, en las ilustraciones que acompañan a las instrucciones paso a paso, las partes resaltadas del RX Scripting a las que se está haciendo referencia, estarán en rojo para poder localizar de forma rápida que parte del ejemplo se está describiendo. También hay que tener en cuenta que los comandos y sentencias propias del lenguaje RX Scripting están remarcados en negrita y con la primera letra en Mayúsculas, (por ejemplo Method, While, Begin). El resto de palabras, estarán en texto normal, haciendo referencia a cualquier ot ro identificador o texto que utilicemos en la declaración, pero que no pertenecen al lenguaje RX Scripting. En el ejemplo siguiente se muestra el código y los comandos utilizados par a realizar una acción de entrada (más adelante lo veremos en detalle) y con el texto que queremos que aparezca en el mensaje que vamos a presentar, el cual, como vemos va entre comillas:

Como estamos haciendo referencia al comando de acción de entra da todo el formato RX Scripting de esa declaración está en rojo. Los comandos y sentencias propias del RX Scripting están en Negrita y las demás palabras que no forman parte de los comandos del RX Scripting, estarán en texto normal, por lo que se consideran de relleno para ayudarnos a que el código sea más fácil de leer (por ejemplo la palabra to como se muestra en el último ejemplo). Cuando en las explicaciones que realicemos nos estemos refiriendo a los identificadores del lenguaje (comandos y sentencias del RX Scripting), veremos que aparec en subrayados y en negrita para distinguirlos del resto del texto explicativo. Por ejemplo el comando de acción Put


7


Hora de comenzar Con el RX Scripting es muy fácil comenzar a crear sistemas simples que nos permitan coloc ar apuestas en la mesa de la ruleta. Posteriormente iremos añadiendo mayor complejidad a medida que vaya siendo necesario. No es nec esario esperar a leer ni aprender todo el conjunto de posibilidades del libro y del lenguaje RX Scripting para poder crear sistemas de ruleta. Por supuesto, que cada viaje comienza con un primer pas o, así que vamos a empezar creando sistemas simples a los que poco a poco les iremos añadiendo mayor complejidad.


8


1 - Conociendo RX Scripting Para los jugadores de ruleta, la evolución en la creación de sistemas ha sido una bendición. En los inicios, crear un sistema de ruleta era tan simple como escribirlo en un pedazo de papel (o en la parte posterior de una servilleta). La única manera de poder probar estos sistemas era ir a probarlo en un casino real con el riesgo de perder el dinero en la prueba. Hoy en día, gracias a internet tenemos una gran cantidad de lugares online donde poder jugar. Los jugadores, ahora tienen la posibilidad de probar los sistemas escritos en modo de práctica (ofrecido en la mayoría de los casinos de internet) sin tener que arriesgar el dinero de forma real. No obstante, esos tipos de pruebas siguen siendo muy tediosos y lentos y a menudo nos llevan a cometer errores ya que los cálculos y las apuestas se siguen haciendo de forma manual . Ahora con el software de rulet a Xt reme System Designer, se pueden crear fácilmente sistemas y ejecutarlos pasándoles un gran batería de pruebas para validar el sistema y asegurarse que se trata de un sistema ganador antes de probarlo en cualquier casino real o de internet. En este capítulo, veremos todas las posibilidades que nos ofrec e el RX Scripting y a su vez también veremos algunos de los fundamentos del lenguaje.


9


¿Qué es RX Scripting? RX Scripting es un lenguaje de programación utilizado para crear sistemas de ruleta con el soft ware Roulette Xtreme System Designer. Pero, si no eres un programador, que no cunda el pánico por el término “lenguaje de programación”. Hay muchos ejemplos de RX Scripting en diferentes foros de ruleta, especialment e en las siguientes páginas web:    

http://www.uxsoftware.com/pages/system.html/ http://vlsroulette.com/ http://www.laroulette.it/ http://ruleteroonline.blogspot.com.es/ (es la mía y no estaba en el documento original)

El lenguaje básicamente consiste en una serie de acciones y condiciones que nos permit en reproducir de forma automática la colocación de las apuestas sobre la mesa, de forma que refleje el sistema creado. Para cada giro de la ruleta el programa realiza una serie de pasos y ejecuta una serie de comandos. La estructura del lenguaje es muy similar a la que utilizamos cuando escribimos una frase. Veamos por ejemplo el código marcado en rojo que se muestra a continuación:

En el código RX Scripting anterior (el cual, sea dicho de paso, es un comando de acción) le estamos diciendo al programa que en la mesa de la ruleta realice una apuesta de 1 unidad a la suerte s encilla de Negro. El resultado de este código es lo que se muestra a continuación:

Como vemos, el c ódigo del lenguaje, se c rea dentro de los bloques del método, entre los indicadores de Begin y End. El método main debe de existir siempre, ya que es el punto de inicio donde el programa comienza a ejecutar la serie de comandos que hayamos programado. Para todos los sistemas de ruleta que creemos, siempre debe de existir un método llamado Method “main”, ya que en caso contrario el programa fallará al realizar la interpretación de nuestro sistema.


10


Que se puede hacer con RX Scripting Hay muchas cosas que podemos hacer con el lenguaje RX Scripting cuando creemos un sistema de ruleta. RX Scripting nos permite crear una interfaz (pant alla), de forma que podamos interactuar con el usuario, solicitando o mostrando información antes de que comience o durante el transcurso de una sesión activa. Por ejemplo, podemos decirle al programa que pregunte por la caja inicial (unidades) al comienzo de una nueva sesión. Esta acción se realiza con el comando Input Data. En el ejemplo que mostramos a continuación vemos el código RX Scripting necesario para realizar esta acción de interfaz de usuario.

Cuando el script comienza a ejecutarse, el programa nos presenta un cuadro de diálogo que nos permite introducir las unidades de la caja inicial.

También podemos usar RX Scripting para realizar cálculos complejos, como el seguimiento de los últimos 37 números que han aparecido o colocar apuestas en diferentes posiciones de la mesa en función de los resultados obtenidos por varios tipos de condiciones. También podemos acceder a los datos estadísticos de los resultados de cualquiera de las posiciones de la mesa. Podemos obtener datos como puede ser la des viación estándar, la media, el mínimo y el máximo y proces ar estos datos estadísticos para realizar la toma de decisiones de cuando realizar una apuesta o cuando retirarse de una sesión Con RX Scripting, tenemos la posibilidad de acceder a la mayoría de las funciones de entrada y a las estadísticas de salida que disponemos en el soft ware Roulette Xt reme. Esto significa que podemos leer el historial de números salidos, acceder a los datos estadísticos, realizar comparaciones de diferentes resultados, cambiar el esquema de ruleta Europea a Americana o a ninguna y mucho más.


11


La construcción del lenguaje RX Scripting es un lenguaje formado por la unión de diferent es partes para formar una declaración completa (frase completa). La primera parte de la declaración es un comando que puede ser un comando de acción o un comando de condición. En realidad, estos dos tipos de comandos constituyen la totalidad del lenguaje RX Scripting. Podemos realizar una acción (por ejemplo colocar una apuesta) o también podemos a partir de los resultados de una condición, realizar alguna acción (por ejemplo cuando el Rojo aparezca 3 veces apostar a Negro). A continuación vamos a describir estos dos tipos de comandos.


12


Comandos de Acción Un comando de acción es un identificador que nos permitirá realiz ar alguna acción sin necesidad de que ocurra algún evento condicional.

Por ejemplo, digamos que quiero poner una apuesta de 5 unidades a Negro. Si estuviéramos jugando en un juego de ruleta real, colocaríamos 5 fichas en la apuesta simple de Negro. Este proceso se llama una acción. Hemos realizado una tarea sin tener en cuenta ningún tipo de evento condicional. En este caso, el identificador de acción Put es el comando que vamos a utilizar y va seguido por algunos otros identificadores para formar todos juntos una declaración.

A continuación mostramos como realizar este paso con RX Scripting.


13


Comandos de Condición Un comando de condición es un proceso lógico que produce un resultado de Verdadero o Falso.

Por ejemplo, digamos que quiero poner una apuesta de 5 unidades a Negro sólo después de que el color negro aparezca 3 veces seguidas. Así pues, esperamos pacient emente giro tras giro hasta que observemos en la marquesina de result ados que el negro ha aparecido las 3 veces. Una vez ocurrido esto, inmediatamente después colocamos la apuesta de 5 unidades en la casilla de la apuesta simple de Negro. Esto se llama evento de condición, donde esp eramos hasta que el evento sea Verdadero antes de colocar una apuesta. En este caso, el identificador de condición If es el comando que vamos a utilizar y va seguido por algunos otros identificadores para formar todos juntos una declaración.

El siguiente ejemplo, nos muestra cómo realizar este proceso con el lenguaje RX Scripting. El script está usando una declaración de condición para esperar a que el negro aparezca 3 veces seguidas antes de colocar 5 unidades en la casilla de Negro. Como podemos ver en la marquesina de resultados, los 3 últimos result ados son negros lo que provoca que el evento de condición pase a s er verdadero y por lo tanto que se ejecute la acción de colocar automáticamente 5 unidades a la casilla de Negro como se muestra en la imagen de la derecha.


14


Juntando piezas Construir sentencias en RX Scripting, consiste en juntar las diferent es partes que componen el lenguaje de programación propiament e dicho, con otras palabras de relleno, para formar fras es, de forma que nos permita tener una mejor descripción de lo que queremos hacer. Pensemos en la siguiente frase. Place 5 chips on the number 21 (Poner 5 fichas al número 21) Simplemente significa que vamos a poner $5.00 (suponiendo que una unidad tenga un valor de $1.00) en el número 21 de la mesa de la ruleta. El lenguaje de RX Scripting es muy similar en este caso. La diferencia es el vocabulario de algunas palabras concretas. A continuación mostramos la sintaxis exacta de las diferentes partes de la frase anterior.

Aunque el ejemplo es sencillo, podemos ver que esta sintaxis es un poco extraña para averiguar lo que está tratando de decir (Poner 5 Número 21). Una ventaja que tenemos con el lenguaje de RX Scripting es que podemos añadir palabras no funcionales o de relleno que nos ayuden a que la frase tenga mayor sentido. Así pues, basándonos en el ejemplo de querer apostar $5.00 al número 21, podríamos añadir algunas palabras no funcionales como se muestra en el ejemplo siguiente:

¿Verdad que ahora es más fácil de leer y entender? Es evidente que hay muchas formas diferentes de expresar la intención de querer apostar $5.00 al número 21, ahora bien, para el lenguaje RX Scripting sólo hay una forma de decirlo. Podemos escribir código RX Scripting con o sin palabras de relleno, ya que en realidad el programa sólo tiene en cuenta las partes que son propias del lenguaje, descart ando todo el resto de identificadores que aparezcan y que se permiten con el objetivo de hacer más sencilla la lectura del sistema. Así pues, tenemos que la declaración mostrada arriba se divide en 3 partes: La primera parte es el Put, la cual es la parte inicial de un comando de acción. La segunda parte (conocida como identificador) es el 5, el cual nos indica la cantidad a apostar. La tercera parte es el identificador Number 21, el cual hace referencia al número de la ruleta donde estamos colocando la apuesta con la esperanza de que aparezca en el siguiente giro de la ruleta. El script que se muestra a continuación nos muestra un ejemplo de cómo colocar apuestas en 6 números diferentes de la mesa de la ruleta, usando el comando de acción Put.


15


En cada giro de la ruleta, el sistema colocará las 6 apuestas de 1 unidad en los números 12, 13, 19, 21, 29 y 32.

Nota de RuleteroOnline: En realidad la imagen del código y el tapete que se muestran no son correctas: El código mostrado indica colocar 1 unidad en los números 12, 13, 21, 29, 29 (otra vez) y 32. El tapete resultado sólo tiene colocadas 5 fichas, ya que no contempla la dob le apu esta al 29. Además, ni el código ni el tapete reflejan el enunciado del ejemplo, no ob stante, lo dejamos tal cual, ya que es así como aparece en el lib ro original y el ejemplo es lo suficientemente simple como para ser entendib le.


16


El uso del auto generador de instrucciones El auto generador de instrucciones que incorporada Roulette Xtreme es una ayuda que nos permite crear completamente los comandos de acción o condición, de forma que sean válidos y no produzcan errores cuando el programa ejecute nuestro sistema. La mejor forma de describir esta funcionalidad es mediante un ejemplo:

Vamos a centrarnos en el comando de acción Put 5 units on Black y vamos a crear la sintaxis correcta usando el auto generador de instrucciones. Para el ejemplo, suponemos que ya hemos escrito el comando de condición indicado (If Black has Hit…Begin…End). Ahora vamos a seguir los siguientes pasos: 1.

Justo debajo del identificador Begin en una nueva línea, pulsamos la tecla F2. En ese moment o se mostrará una lista completa de comandos de condición y de acción válidos. Buscamos y seleccionamos el comando de acción Put que es el que queremos insertar y a continuación pulsamos la tecla Intro.

2.

Tras pulsar la tecla Intro, la palabra Put se habrá añadido a nuestro código. Ahora volvemos a pulsar la tecla F2. E n este caso, se mostrará el siguiente conjunto de identificadores válidos. Localizamos y seleccionamos el identificador numeric data y pulsamos de nuevo la tecla Intro. Por defecto el programa inserta un 1 a continuación del comando de acción Put que habíamos escrito anteriormente. En este caso, como lo que queremos es indicar 5 unidades, vamos a cambiar manualmente el valor numérico que ha puesto el programa de 1 a 5.


17


3.

Una vez realizado el cambio del valor numéric o, volvemos a pulsar la tecla F2. En este caso se mostrará el siguiente conjunto de identificadores válidos. En el listado que aparece, localizamos y seleccionamos la posición Black y pulsamos de nuevo la tecla Intro.

4.

En este caso se ha añadido el identificador Black a nuestro sistema. Volvemos a pulsar la tecla F2. En este caso se volverá a mostrar la lista completa de comandos de condición y acción, lo cual nos indicará que hemos terminado de escribir la instrucción para el comando de acción Put.

5.

A continuación lo que hac emos es completar la sentencia con palabras no funcionales que harán que sea más fácil leerla. En este caso añadimos las palabras units on. Recordemos que estas palabras de relleno no son tenidas en cuenta por el programa, y simplemente sirven para facilitar la lectura del sistema.

Como hemos visto, el uso del auto generador de instrucciones nos permite la construcción de comandos de acción o de condición válidos de una forma muy sencilla.


18


Comenzando con el diseño de sistemas En todos los sistemas que diseñemos, hay dos palabras que son obligat orias p ara que el programa pueda funcionar correctamente. Estas palabras son System y Method.

System La palabra clave System debe aparecer siempre y de forma obligatoria en la primera línea del documento. A continuación de esta palabra clave, escribiremos con texto entrecomillado “” una pequeña descripción a modo de nombre del sistema.

Esta palabra clave le indic a al compilador del Roulette Xtreme que lo que viene a continuación son las instrucciones de un sistema de ruleta.

Method La palabra clave Method nos indica la construcción de un bloque de control que siempre irá delimitado por los identificadores Begin y End. Dent ro de este bloque de control, es donde se incluirán todas las instrucciones y los comandos de acción y condición que vayan formando nuestro sistema. Los métodos nos ay udan a separar el código en diferentes partes o rutinas, de forma que todas en conjunto conformen nuestro sistema.

En el ejemplo anterior, el método llamado place bets únicamente lo que hace es colocar apuestas de 1 unidad en los números 13, 21 y 32. El uso de métodos, también nos va a permitir estructurar mejor la programación de nuestro sistema, de forma que podamos dividir en bloques las diferentes partes del mismo. En el ejemplo que se muestra a continuación, podemos ver como el sistema puede llamar más de una vez al mismo método. Estas llamadas se realizan utilizando el comando Call. Utilizando esta técnica de llamadas a métodos, se puede utilizar el mismo código en diferentes partes de nuestro sistema sin tener que duplicarlo. Nota: No te preocupes si a priori no se entiende el código completo del ejemplo. En este punto lo importante es entender el uso de los métodos y la llamada a los mismos mediante el comando Call.


19


Como hemos indicado, podemos crear o no (según nuestra elección) tantos métodos como queramos, ahora bien, siempre debe existir al menos uno llamado main como se muestra en el ejemplo siguiente. Sin este método, el programa no será capaz de saber cuál es el punto de entrada a nuestro sistema, mostrando un mensaje de error que hará que el sistema que hemos programado no funcione.

Así mismo, debemos tener en cuenta que cuando creemos múltiples métodos, estos deben ir separados unos de otros. En otras palabras, no podemos crear métodos dentro de otros métodos. A continuación mostramos un ejemplo del uso incorrecto de múltiples métodos.


20


SI intent amos crear mét odos dentro de otros mét odos nos aparecerá un mensaje de error similar al indicado a continuación:


21


Estructuras de bloque Una estructura de bloque es una sección de nuestro programa que engloba toda una serie de sentencias y comandos que se ejecutarán de forma conjunta en ese bloque. Las estructuras de bloque son usadas en los métodos y en las instrucciones de condición.

Un bloque se identifica por dos palabras claves:



Begin

Esta palabra clave nos indica el comienzo de un bloque y siempre va a continuación de la declaración de un método o de una condición. Cuando el programa entra en una estructura de bloque, comienza a ejecutar todo lo que hay a continuación de la palabra clave Begin.



End

Esta palabra clave nos indica el final de una estructura de bloque. Si la estructura de bloque corresponde a un método, cuando el programa lee la palabra clave End, continúa la ejecución regresando al punt o donde estaba la instrucción call que ha realizado la llamada a ese método. En el caso de que el bloque sea el que corresponde al método main, el programa lo que hace es terminar la ejecución y esperar al siguient e lanzamiento de la bola ya sea de forma automática o manual. Si la estructura de bloque corresponde a una instrucción de condición, el programa seguirá ejecutando la siguiente instrucción que aparezca tras el bloque.

Estos dos identificadores de estructura de bloque siempre deben de aparecer emparejados, es decir, por cada identificador de comienzo de bloque Begin, debe existir un identificador de final de bloque End. El programa está pensado para permitir tener múltiples estructuras de bloque, de forma que nos ayuden a mejorar la funcionalidad y la facilidad de lectura de los sistemas que estemos diseñando. En el siguiente ejemplo se muestra la utilización y la colocación de los identificadores Begin y End cuando son usados en los métodos y cuando son usados en las instrucciones de condición.


22


Formatos estructurados A la hora de escribir un sistema, el programa realiza un cont rol muy básico del formato que se esté utilizando, es decir, los comandos e identificadores que s e usen para escribir una sentencia no tienen que estar necesariamente escritos en la misma línea. En este sentido, el compilador es bastante permisivo y es capaz de reconocer cuando una sentencia comienza y acaba sin necesidad de que todos los identificadores que la forman estén escritos uno a continuación de otro. El único requisito, es que las instrucciones con los comandos y los identificadores correspondientes estén colocados en el orden correcto. Esto nos puede venir bien, por ejemplo, para dividir en varias líneas, de forma más estructurada, sentencias que sean muy largas y que de por si no quepan en una sola línea.

En el ejemplo que viene a continuación, podemos ver como las instrucciones que forman el programa están dispersadas en varias líneas.

Para ayudarnos a que nuestro sistema sea más fácil de leer y comprender, es una buena práctica escribir el sistema utilizando un formato estructurado. Cuando escribamos un método siempre pondremos el nombre en la misma línea y a continuaci ón el identificador Begin en la columna 1 de la línea siguiente. Cuando escribamos instrucciones de condición, si es posible, pondremos todas las condiciones que la forman en la misma línea y a continuación en la siguiente línea el identificador Begin justo a la misma altura del comienzo de la instrucción condicional Esto mismo, también es válido para las instrucciones de acción. Si las instrucciones de condición o de acción que tenemos que escribir fueran excesivamente largas y no se pueden coloc ar en una sola línea, lo que haremos es colocar el resto de la instrucción en la siguiente línea tabulándola con tres espacios. Otro formato que debemos tener en cuenta es que c uando pongamos los identificadores End, siempre los colocaremos a la altura de su pareja Begin correspondiente.

A continuación os mostramos un ejemplo del formato correcto a la hora de escribir nuestros sistemas:


23


Otra forma de colocar el identificador de Begin es ponerlo justo después de la instrucción condicional, en ese caso el identificador End lo colocaremos alineado con el comienzo de la instrucción de condición. Este tipo de formato también es usado por muchos dis eñadores de sistemas y se puede encontrar en algunos foros de ruleta.

En el siguiente ejemplo podemos ver una muestra del formato descrito:


24


El uso de comentarios Los identificadores de comentario, los usaremos para documentar el código de nuestro sistema. Se pueden colocar comentarios en cualquier lugar de nuestro programa, además de estar considerado por todo el mundo como una muy buena práctica. Los comentarios nos ayudan a explicar lo que queremos conseguir con el sistema. Si no colocamos comentarios, puede resultar muy difícil entender la lógica de nuestro sis tema.

A la hora de colocar comentarios, tenemos dos posibilidades:



Comentarios de múltiples líneas

En este caso, el texto que estamos escribiendo se colocará ente llaves { }. Se usará este formato cuando queramos documentar una parte de nuestro sistema y cuya explicación ocupe más de una línea.



Comentarios de una sola línea

En este caso el texto descriptivo lo colocaremos detrás de dos barras / /. Se usará este formato cuando el comentario quepa en una sola línea.

En el ejemplo que mostramos a continuació n, podemos ver los dos tipos de comentarios que hemos indicado:

Cuantos más comentarios le pongamos a nuestro sistema, más fácil será de entender.


25


Almacenamiento de datos La potencia de RX Scripting se basa en la capacidad de almacenar valores de datos. Los valores de datos pueden ser valores lógicos como verdadero o falso result ados de una condición o también se puede almacenar valores como el saldo inicial de nuestra caja, o la cantidad que estamos apostando o las posiciones de la mesa, etc. Almacenar valores de datos es muy simple y Roulette Xtreme nos proporciona los mecanismos para poder recuperarlos de una forma muy sencilla y que los podamos utilizar. Hay dos formas de almacenar los valores de datos y es utilizando los Registros de Dat os y los Registros de Estado


26


Registros de datos Los registros de datos nos proporcionan los mecanismos necesarios para almacenar valores numéricos (por ejemplo 5, 4.1, 100) o posiciones de la ruleta (por ejemplo Negro, Primera Docena, Número 19), etc. Una vez que los datos han sido guardados en los registros de datos, estos pueden ser recuperados para ser utilizados de múltiples maneras. Algunos ejemplos de uso pueden ser: o o o

Almacenar una lista con los valores de la progresión que vayamos a utilizar a la hora de colocar las apuestas, (por ejemplo, 1, 2, 4, 8, 16, 32) Almacenar una lista con las posiciones donde queremos colocar las fichas (por ejemplo Número 1, Número 19) Almacenar el conteo de aciertos y fallos que vamos teniendo, o el nivel de la progresión que estamos utilizando.

La sintaxis que utilizaremos para almacenar los valores en un registro de datos es: Record “algún nombre” Debemos tener que cuenta, que en este caso el texto “algún nombre” es un texto de ejemplo. Podemos crear tantos registros de dat os como queramos, pero cada registro de datos tiene que tener un nombre único en nuestro sistema que lo pondremos entre comillas y que nos servirá para hac er referencia a los datos que contiene. Cuando estemos almacenando datos numéricos, usaremos el identificador Data y cuando almacenemos información de posiciones de la ruleta usaremos el identificador Layout. Estos identificadores se colocan al final de la instrucción Record “algún nombre”. Hay otros identificadores que se usan con los registros de datos, pero los veremos un poco más adelante.

En el ejemplo siguiente podemos ver el uso de los registros de datos a la hora de almacena r valores numéricos y posiciones de la ruleta. Nos fijaremos en la colocación de los identificadores Data y Layout al final de las sentencias.


27


Registros de estados Los registros de estado nos proporcionan la forma de almacenar información lógica como verdadero (true) o falso (false). Cuando estemos diseñando nuestro sistema, puede ocurrir que en ocasiones necesitemos realizar alguna acción basándonos en una condición lógica, usando para ello el valor lógico almacenado previamente en un registro de estado. Algunos ejemplos de uso pueden ser: o o

Un valor lógico para indicar el final de una sesión. Un valor lógico que nos indica cuando comenzar a colocar fichas.

La sintaxis para almacenar los valores de estado es: Flag “algún nombre” seguida por el identificador True o False. Debemos tener que cuenta, que en este caso el texto “algún nombre” es un texto de ejemplo Podemos crear tantos registros de estado como queramos, pero cada registro tiene que tener un nombre único en nuestro sistema que lo pondremos entre comillas y que nos servirá para hac er referencia a los datos que contiene.

En el siguiente ejemplo podemos ver el uso de los registros de estado para almacenar valores lógicos.

Recomendamos como buena práctica, el hecho de identificar los registros de datos y los regis tros de estado con nombres que hagan referencia al tipo de información que están almacenando. Por ejemplo, si queremos crear una lista con la progresión que vayamos a utilizar, el nombre de nuestro registro de datos debería de ser algo similar a progression. De la misma forma, si queremos almacenar valores de verdadero/ falso y usarlos para que nos indique cuando colocar las apuestas en la mesa, el nombre del registro de estado debería de ser algo similar a place bets. Esto se conoce como registros de estado de propósito. Así pues cuando este registro de estado tiene valor verdadero, nos indicará que podemos colocar apuestas en la mesa, estableciendo las correspondientes acciones necesarias para realizar esto.


28


Comparadores para las declaraciones de condición Cuando usamos una declaración de condición, el sistema realiza algún tipo de la comparación lógica que nos devuelve los valores verdadero o falso. Basándonos en este resultado, podemos realizar alguna acción u otro proceso condicional. Podemos comparar un registro de dat os con otro o realizar una comparación de un valor de la ruleta con un valor numérico (por ejemplo, comprobar si una posición de la mesa en particular, por ejemplo Negro, ha aparecido un número n de veces).

A continuación, os mostramos varias tablas, con la lista de todas las posibles comparaciones lógicas que disponemos y el uso de las mismas. Se han agrupado en base a sus funciones de comparación.

En las tablas veremos cuatro variables X, Y, n y t, cuyo significado es el siguiente:    

X: representa la parte izquierda de la comparación. Y: representa la parte derecha de la comparación. n: representa un valor numérico. t: representa un segundo valor numérico, en caso de ser necesario.


29


Comparadores de expresiones lógicas

Comparación

Que hace

X=Y

Devuelve verdadero si X e Y son iguales

X Not = Y

Devuelve verdadero si X e Y no son iguales

X>Y

Devuelve verdadero si X es mayor que Y

X >= Y

Devuelve verdadero si X es mayor o igual que Y

X
Devuelve verdadero si X es menor que Y

X <= Y

Devuelve verdadero si X es menor o igual que Y

A continuación mostramos un ejemplo del uso de la comparación lógica de = (igual), para comprobar si nuestra caja es igual a 115 para finalizar la sesión. En la tabla anterior, tenemos que para este cas o, la variable X estaría representada por el identificador del Bankroll mientras que la variable Y se representa por el valor numérico 115.


30


Comparadores de conteo

Comparación

Que hace

X count = n

Devuelve verdadero si el conteo de X es igual a n

X count NOT = n

Devuelve verdadero si el conteo de X NO es igual a n

X count > n

Devuelve verdadero si el conteo de X es mayor que n

X count >= n

Devuelve verdadero si el conteo de X es mayor o igual que n

X count < n

Devuelve verdadero si el conteo de X es menor que n

X count <= n

Devuelve verdadero si el conteo de X es menor o igual que n

En el siguiente ejemplo usaremos la comparación Count = (igual) para comprobar si el conteo de las apuestas individuales que hemos colocado en la mesa de la ruleta es igual a 3. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador del Total Number Bets mientras que la variable n se representa por el valor numérico 3.


31


Comparadores de apuestas perdidas

Comparación

Que hace

X lost n

Devuelve verdadero si X ha perdido n veces consecutivas

X lost each

Devuelve verdadero cada vez que X pierde

X lost more n

Devuelve verdadero si X ha perdido más de n veces consecutivas

El siguiente ejemplo nos muestra el uso de la comparación Lost para comprobar si la suerte sencilla de Negro pierde 2 veces seguidas la apuesta. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador Black mientras que la variable n se representa por el valor numérico 2.


32


Comparadores de apuestas ganadas

Comparación

Que hace

X won n

Devuelve verdadero si X ha ganado n veces consecutivas

X won each

Devuelve verdadero cada vez que X gana

X won more n

Devuelve verdadero si X ha ganado más de n veces consecutivas

El siguiente ejemplo nos muestra el uso de la comparación Won para comprobar si la suerte sencilla de Rojo gana 3 veces seguidas la apuesta. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador Red mientras que la variable n se representa por el valor numérico 3.


33


Comparadores de salida de esquemas de ruleta

Comparación

Que hace

X hit n

Devuelve verdadero si X ha salido n veces consecutivas

X not hit n

Devuelve verdadero si X NO ha salido en las últimas n veces

X hit each

Devuelve verdadero cada vez que sale X

X not hit each

Devuelve verdadero cada vez que NO sale X

X hit more n

Devuelve verdadero si X ha salido más de n veces

X not hit more n

Devuelve verdadero si X no ha salido más de n veces

X hit between n t

Devuelve verdadero si X ha salido el número de veces indicado entre los valores n y t

X not hit between n t

Devuelve verdadero si X NO sale el número de veces indicado entre los valores n y t

El siguiente ejemplo nos muestra el uso de la comparación Hit para comprobar si la Primera Docena ha salido 5 veces seguidas. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador 1st Dozen mientras que la variable n se representa por el valor numérico 5.


34


Comparadores de valores en listas

Comparación

Que hace

X found Y

Devuelve verdadero si X se encuentra en la lista de valores Y

X not found Y

Devuelve verdadero si X NO se encuentra en la lista de valores Y

El siguiente ejemplo nos muestra el uso de la comparación Found para comprobar si el último número que ha salido está en la lista de los últimos 15 números aparecidos. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador Record “last number” Layout, mientras que la variable Y se represent a por el registro de datos Record “last 15 numbers” Layout. La comparación realizada, nos devolverá verdadero, si el número almacenado en el registro de datos last number se encuent ra en la lista de los números almacenados en el registro de datos last 15 numbers.


35


Comparadores de respuesta

Comparación

Que hace

Last answer Yes

Devuelve verdadero si la última respuesta fue Sí (Yes)

Last answer No

Devuelve verdadero si la última respuesta fue No (No)

El siguiente ejemplo nos muestra el uso de la comparación La st Answer para comprobar si la respuesta a la última pregunta ha sido Yes o ha sido No. El valor de last answer es asignado por el comando Ask que nos muestra un diálogo de entrada para que elijamos uno de estos dos valores.


36


Comparadores de distancia entre 2 números en la rueda de la ruleta

Comparación

Que hace

X span n Y

Devuelve verdadero si el número X se encuentra dentro de la distancia de n saltos en la rueda de la ruleta respecto del número Y

El siguiente ejemplo nos muestra el uso de la c omparación Span para comprobar si el número X está dentro de la distancia de n saltos en la rueda de la ruleta respecto del número Y. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador Record “number 1” Layout, mientras que la variable Y se representa por el registro de datos Record “number 2” Layout y por último la variable n se representa por el valor numérico 4. La comparación realizada, nos devolverá verdadero, si el número almac enado en el registro de datos number 1 se encuentra dentro de los 4 saltos de distancia en la rueda de la ruleta partiendo del número almacenado en el registro de datos number 2.


37


Comparadores de distancia entre 2 números en la marquesina de la ruleta

Comparación

Que hace

X distance n Y

Devuelve verdadero si el número X se encuentra dentro de la distancia de n bolas salidas respecto del número Y

El siguiente ejemplo nos muestra el uso de la comparación Di stance para comprobar si el número X está dentro de la distancia de n bolas salidas respecto del número Y. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador Record “number 1” Layout, mientras que la variable Y se representa por el registro de datos Record “number 2” Layout y por último la variable n se representa por el valor numérico 5. La comparación realizada, nos devolverá verdadero, si el número almac enado en el registro de datos number 1 ha salido dentro de las 5 bolas siguientes al lanzamiento en el que salió el número almacenado en el registro de datos number 2.


38


Comparadores de patrones de salida

Comparación

Que hace

X pattern match Y

Devuelve verdadero si la lista de valores de X se presenta exactamente la misma secuencia de valores almacenada en la lista Y

X pattern not match Y

Devuelve verdadero si la lista de valores de X no se presenta exactamente la misma secuencia de valores almacenada en la lista Y

El siguiente ejemplo nos muestra el uso de la comparación Pattern Match para comprobar si la secuencia de las suert es sencillas salidas en las últimas tiradas, ha producido un patrón de Negro, Negro, Rojo, para ello, lo compararemos con el patrón de salida que se ha almacenado en el registro de datos patterns. En la tabla anterior, tenemos que para este caso, la variable X estaría representada por el identificador Li st [Black, Black, Red], mientras que la variable Y se representa por el registro de datos Record “patterns” Layout. La comparación realizada, nos devolverá verdadero, si el contenido del patrón almac enado en el registro de datos patterns coincide con la lista creada de chances simples de Negro, Negro, Rojo.


39


2 - Los Comandos de Condición Antes de empezar a ver como colocar nuestras apuestas sobre la mesa utilizando los comandos de acción, entiendo que deberíamos de hablar de los comandos de condición, saber que son y cómo utilizarlos. Prácticamente todos los sistemas, utilizan algún tipo de respuesta a unas condiciones y por eso creo que es mejor aprender primero esta parte.

Las sentencias de condición son comandos que forman un bloque condicional. La evaluación de la condición, producirá un resultado de salida de verdadero o falso. Si el resultado es verdadero, entonces el bloque condicional se ejecutará. Algunos ejemplos de condición podrían ser, por ejemplo, querer saber si estamos en el comienzo de una nueva sesión o averiguar si la suerte sencilla de Negro ha salido 5 veces seguidas, etc.

La primera parte de una sentencia de condición, será una palabra reservada, que nos indicará la condición que se va a evaluar, seguida por uno o más identificadores que nos darán el det alle necesario para completar la sentencia.

El lenguaje de programación, nos permite la utilización de múltiples sentencias de condición junt as, para poder formar un bloque condicional más complejo. Existen tres identificadores especiales Or, And y XOR que son los que utilizaremos para poder conc atenar las múltiples condiciones y unirlas en una más compleja.

Así pues, vamos a comenzar viendo los tres tipos de comandos de condición que existen y su uso.   

Iniciadores de condición Continuadores de condición Bloques Condicionales


40


Iniciadores de condición Para crear una sentencia de condición, siempre la comenzaremos con la condición de inicio. En la siguiente tabla encontraremos los comandos de iniciación de condiciones que se utilizan a la hora de crear un evento condicional en nuestro sistema de ruleta. Iniciadores

Su significado

While

Proceso inicial de una sentencia de condición

(mientras que…)

While A=B, haz algo...

If

Realiza lo mismo que el comando While

(si se cumple....)

If A=B, haz algo...

El siguiente ejemplo nos muestra el uso de la condición de inicio While.

¿Qué comando usar While o If? Para el ejemplo anterior, hemos usado el comando de inicio While para comprobar si estábamos en el inicio de una nueva sesión. El comando de condición If representa exactamente el mismo tipo de condición como vemos en el siguiente ejemplo


41


Así pues nos podemos preguntar ¿cuál de los dos usamos? Cuando se creó Roulette Xtreme s olamente existía el comando While para el inicio de una condición. Posteriormente se añadió el comando If para realizar lo mismo, de forma que el uso fuera más similar al utilizado en la sintaxis utilizada en el lenguaje Visual Basic. El uso de uno u otro realment e es indiferente y va más ligado a la preferencia pers onal que t engamos cada uno de nosotros.

Condición Loop Until

El comando de condición Loop Until es similar a los comandos While o If, excepto por dos motivos:  

Si la salida que se ha producido, se evalúa como False (Falso), el programa continuará con la ejecución del código que hay en el cuerpo del bloque de condición. Una vez que todos los comandos de acción o condición que hay en el bloque de condición se hayan ejecut ado, la ejecución del programa siempre volverá al comienzo del bloque de condición y se volverá a ejecutar de nuevo el bloque completo. El proceso se repetirá hasta que la salida se evalúe como True (Verdadero), momento en el que se dará por finalizada la condición.

En la tabla siguiente mostramos la condición Loop Until y un diagrama a través del cual podemos ver el proceso de salto. Procesa una y otra v ez el bloque hasta que la condición se ev alúa como True

Comando de Inicio

Su significado

Loop Until

Bloque de condición que procesa las instrucciones en bucle hasta que algún evento detenga el salto

Ev alúa la condición Loop Until

(Repite hasta que...)

Realiza comandos de acción o comandos de condición Cambios en las v ariables que f orman parte de la condición

Loop Until A > B Fin del bloque de condición

Cada vez que el event o lógico s e evalúe como False (Falso), todos los comandos que hay dentro del bloque serán ejecutados, y se repetirá el proces o hasta que la condición se evalúe como True (Verdadero). En ese momento el bloque de condición terminará y el programa continuará la ejecución con las instrucciones que hay después del identificador de final de bloque End. Para aquellos que sean programadores, indicar que el comando Loop Until es similar al comando Do Until que encontramos en la sintaxis de Visual Basic. Por ejemplo, vamos a suponer que tenemos un programa que va sumando una cantidad a un número, pero no queremos que el total sea mayor o igual que 100. Para la sintaxis de Visual Basic el programa sería de la siguiente forma:


42


En este caso, el código RX Scripting que haría este proceso sería el que se muestra a continuación:

En este código, tenemos que la línea Loop Until evalúa el valor del registro de datos sum para comprobar si es menor que 100. Si es así, se ejecutará la línea con el comando de acción que hay dentro del bloque de condición. Si no, la ejecución continuará con el código que haya tras el identificador de final de bloque End. El identificador End, es el que le indica a RX Scripting que tiene regresar hasta la línea Loop Until y evaluar el nuevo valor del registro de datos sum.


43


Continuadores de condición En ocasiones necesitaremos crear eventos de condición en los que tengamos que evaluar varias condiciones lógicas simultáneamente. Para esto, contamos con la ayuda que nos proporciona la concatenación de varios comandos condicionales unidos por alguno de los tres comandos de continuación siguientes: And, Or y Xor

En la siguiente tabla mostramos tres comandos, su significado y su tabla de verdad.

Condición

Su significado

And

Se le conoce como Conjunción Lógica, en la cual el resultado obtenido se evalúa como True (Verdadero) si la combinación de toda s las instrucciones de condición que la forman es verdadera. En caso contrario la salida se evalúa como False (Falso)

(... Y...)

While A=B AND C
Or (... O ...)

Se le conoce como Disyunción Lógica, en la cual el resultado obtenido se evalúa como True (Verdadero) si alguna de las instrucciones de condición que la forman es verdadera. En caso contrario la salida se evalúa como False (Falso)

Tabla de Verdad A

B

A and B

False

False

False

False

True

False

True

False

False

True

True

True

A

B

A or B

False

False

False

False

True

True

True

False

True

True

True

True

A

B

A xor B

False

False

False

False

True

True

True

False

True

True

True

False

While A=B OR C
Xor (O exclusivo)

Se le conoce como Disyunción Exclusiva, en la cual el resultado obtenido se evalúa como True (Verdadero) si cualquiera de las instrucciones de condición que la forman es verdadera, pero no ambas. En caso contrario la salida se evalúa como False (Falso) While A=B XOR C
En el ejemplo que se muestra a continuación, podemos ver cómo concat enar los diferentes comandos continuadores de condiciones.


44


Como vemos, en el ejemplo estamos comprobando tres eventos diferentes. Usando la tabla de verdad mostrada ant eriormente, las instrucciones del ejemplo se leerán de la siguiente manera. 

Cuando el Negro aparezca 3 veces And (y) los números Altos hayan aparecido 2 vec es, colocar 5 unidades en las Columnas A y C

Or (o) 

Cuando la Primera Docena aparezca 1 vez, poner 5 fichas en las Columnas A y C.

Debemos tener en cuent a que cuando combinemos identificadores lógicos And con los identificadores Or o Xor para crear un bloque de condición, el sistema entenderá que hemos colocado paréntesis () alrededor de las instrucciones And. Por ejemplo: 

If Condición 1 And Condición 2 Xor Condición 3 And Condición 4 Or Condición 5 Then...

Se evaluará como: 

If (Condición 1 And Condición 2) Xor (Condición 3 And Condición 4) Or (Condición 5) Then...

En general, tenemos que en primer lugar se evalúan los identificadores And, y el resultado es evaluado con los identificadores Or y Xor para determinar el resultado final.


45


Uso del continuador Else El identific ador El se, se usa junto c on algunos de los identificadores de inicio de condición While o If, así pues, no puede utilizarse de forma independiente. En la tabla siguiente tenemos en identificador Else y su significado: Continuador

Su significado Esta condición se utiliza junto con alguno de los identificadores While o If y se coloca al final del bloque de condición. El programa ejecutará estas instrucciones si no se cumple la condición inicial, es decir, la condición inicial devuelve False

Else (si no…)

While A=B begin hacer algo... end Else begin hacer esto otro... end

Siempre que el comando de la condición inicial sea evaluado como False, el sistema ejecutará el código que aparece entre los identificadores Begin y End que hay a continuación del comando Else. Por ejemplo:

En el ejemplo, tenemos que para cada salida de bola evaluamos si el evento de Negro ha ganado o ha perdido. Si sale Negro, el resultado de la condición de inicio será falso (hay que tener en cuenta que en este caso estamos preguntado por la pérdida de la apuesta y no por el acierto), por lo tanto el p rograma saltará al comando El se y ejecutará el código que aparece tras el identificador Begin. En este caso el sistema debería de colocar una apuesta de 5 unidades a la suerte sencilla de Negro.


46


Condiciones de Bloque

El uso de la condición Group

El comando de condición de bloque es un comando es pecial que principalment e se utiliza para agrupar en un solo cuadro de diálogo información que se quiere mostrar al usuario de forma conjunta. En la tabla siguiente tenemos el identificador Group y su significado: Bloque

Su significado

Group

Esta condición siempre se evalúa siempre como True, por lo tanto, nos permite la ejecución de unos comandos de acción especiales que serán ejecutados conjuntamente dentro de este bloque.

El uso de una condición de bloque, hará que se muestre un cuadro de diálogo de ent rada que podrá contener uno o más controles de entrada, de forma que el sistema los mostrará todos juntos. Cuando utilizamos el comando de condición Group, sólo se permiten algunos comandos de acción. En este caso, no se permite ninguno de los comandos de condición, por lo que si se utilizan el sistema generará un mensaje de error. En la tabla siguiente, presentamos una lista de los comandos de acción que se permiten: Comandos permitidos

Su uso

Display mensaje

Muestra en pantalla el texto escrito en mensaje

Input Data mensaje Y

Realiza una pregunta al usuario mostrando el texto escrito en mensaje y esperando la entrada de un valor numérico que se guardará en Y

Input Dropdown mensaje Y

Realiza una pregunta al usuario mostrando el texto escrito en mensaje y esperando la selección de uno de los valores de la lista desplegable. El valor seleccionado se guardará en Y

Input Checkbox mensaje Y

Realiza una pregunta al usuario mostrando el texto escrito en mensaje y esperando que el usuario marque o no el checkbox. El valor seleccionado se guardará en Y

En la captura de pantalla que mostramos a continuación, podemos ver un ejemplo de los comandos permitidos en el bloque de condición Group. Como podemos ver, estos comandos de acción nos permiten crear una interfaz para el diálogo con el usuario, de forma que nos pueda proporcionar información t anto al comienzo de una sesión o durante el transcurso de la misma. La única excepción es el comando de acción Display, el cual, únicamente muestra información al usuario sin esperar ninguna respuesta.


47


El código en RX Scripting que nos permitirá mostrar el cuadro de diálogo anterior es el siguiente:

Si en el código anterior omitimos el comando de condición Group, el sistema lo que hará será mostrar al usuario un cuadro de diálogo por cada uno de los comandos de acción que aparecen


48


En ocasiones, es posible que queramos esta funcionalidad, como por ejemplo, para indica rle al usuario cuando una sesión ha terminado.


49

RX ScripRX Scripting Para Roulette Xtreme - Castellano - Capitulo 1 y 2ting Para Roulette Xtreme Castellano Capitulo 1 y 2

Recommend Documents