Everything finally concludes, nothing can escape, everything has an end, everything ends


This goes for good and bad streaks.


If you're in a bad streak it is best to lose as little as possible for the duration of it or stop playing until it changes, and if it returns stop playing altogether


If we take it in a good streak take advantage of it, but do not make the mistake of letting all the gains go at the first loss.


Manrique, the wise

You can't be killed in Beirut if you left Beirut.


Soldier who flees is good for another war.


So what you lose by not playing you do not really lose because you can not lose what you don't have. What I didn't lose in any case will help me in other circumstances


Manrique

It is best not to ride any train if we know any one comes full of thieves.


Unless we like being robbed or think "It isn't going to happen to me".


So many believe in waiting away as a form of skipping the negative event, which will occur as we know it (All that can happen will happen)


Many dreamers believe in passing a series of balls in order to cut their violent progressions does something.


Blunder, what is wrong is precisely the violent progressions.


Manrique, the cautious

Triple-felt matrix selection:


Bet for the occurrence of the second appearance of a 3-number line (trio) aligned on the same direction, regardless of placement.


Illustration with tomorrow's actuals from first open wiesbaden table.

Steady locations are those who are appearing once or more in consecutive cycles.


When you tabulate your data in cycles, you can see the steady locations of the sessions as those which CURRENTLY have the longest vertical lines, having showed consistently during the most amount of cycles.


Try tabulating your data this way and you'll see the steady locations show naturally in the game.


This is the number of spins per cycle you should use:


- Even chance: 2 spins
- Dozen/Column: 3 spins
- Double-street: 6 spins.
- Corner/quad: 9 spins.
- Street: 12 spins.
- Split: 18 spins.
- Single number: 36 spins.


Proper programs can help too.

1) A method is posted.

2) Tester is made.

3) We reach conclusions.

---

Ideally, we end up having a library of systems/methods to test

It is up to fellow members to discuss upon the methods and test them.

Coders in the community would ideally provide the programs for their analysis to be done (myself included).

We end up enjoying the process from the first posting of an idea to the conclusion after testing them, perhaps making some tweaks on the way, and some would even ed up playing the method if it suits them.

Well, that's how I think the site should work 

This thread is devoted to the "ultimate" bet of roulette: only one number.


Feel free to suggest your way.

The short term imagined himself in the future, when he would be old and tried... at that time he would have a long career and be called the long term.

"If I get a bit richer every day, in the end of my days when I get old, I'll be a lot rich". It's simple math.

The short term said to himself: "I'm good to focusing in beating the "now" because if I 'beat' every day those profits will amount on each other, and the only possible outcome from this happening is to grow my balance in the bank, even if I don't make it every time -I can be wrong at times-, as long as I'm right with a good-enough rate".

...As much as days are the building blocks of weeks, weeks are the building blocks of months and months are the building blocks of years; many short-term sessions are the building blocks of the player's long term.

As much as you get absolute long-term certainty from uberly random events, you can be 100% certain if you beat the many short-term sessions, you are positively beating your long term.

This is the short-term/long-term paradox. People want to beat the long term without any respect or understanding for the short term.

They are trying to beat the "casino picture": all the hands and all bets from all players combined to give a certain total ...when this picture isn't accurate to what a single player experiences.

The isolated player experiences only chunks of the whole, named sessions, and this is exclusively what s/he should focus in beating.

"Beat your short terms and you are beating your long-term."

After all, -given the true long term is infinity- a man's lifetime *IS* a short term on itself.

Regards.

In order to create your clicker in VB.NET you must do the following:

1) Get the handle of the target (casino) window.
2) Create a RECT structure with the coordinates.
3) Move the mouse to the coordinates within the casino window.
4) Perform the actual click operation.

Let's go at it step by step.

---

NOTE: since we'll use external DLL imports, you must add the line:

Imports System.Runtime.InteropServices

To the very top of your VB.NET file.

---

1) Get the handle of the target (casino) window:

In order to get the handle of the casino window you must use a function that returns this handle based on either the process id OR the window's title. We will use a title-based one, in our case: findWindow.

The declaration is this:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function FindWindow( _
    ByVal lpClassName As String, _
    ByVal lpWindowName As String) As System.IntPtr
End Function

Now we must get the handle into a variable of type intPtr

Dim casinoHwnd As IntPtr
casinoHwnd = FindWindow(vbNullString, "Exact casino window title here")

vbNullString means you don't pass the class name of the casino and are only using the title.

---

2) Create a RECT structure with the coordinates.

First create your RECT structure:


'RECT structure
    Structure RECT
        Public Left As Integer
        Public Top As Integer
        Public Right As Integer
        Public Bottom As Integer
    End Structure

Now set a variable with it, passing the casino handle (casinoHwnd) to the GetWindowRect() function.


<System.Runtime.InteropServices.DllImport("user32")> _
    Private Shared Function GetWindowRect(ByVal hwnd As IntPtr, ByRef lpRect As Rectangle) As IntPtr
    End Function

And set a variable with it:

        Dim stRect As RECT
        GetWindowRect(casinoHwnd, stRect)

We are halfway there!

---

3) Move the mouse to the coordinates within the casino window.

In order to move the mouse you have to use the  SetCursorPos(x, y) function.

It is declared like this:

Public Declare Function SetCursorPos Lib "user32" (ByVal X As Integer, ByVal why As Integer) As Integer

And you simply use the coordinates of the number to click + the coordinates of the casino window, like this:

Let's suppose the #1 is at coordinates x:188, y:352 in the casino window.

In order to move the cursor there you use the .left and .top propierties of the stRect structure and add the coordinates:

SetCursorPos(stRect.Left + 188, strRect.Top + 352)

And the cursor is right there focused on the exact number.

---

4) Perform the actual click operation.

In order to perform the actual click, we must invoke the mouse_event function.

It is declared like this, including the two constants for the down/up event combo to recreate the click:


Public Declare Sub mouse_event Lib "user32" Alias "mouse_event" (ByVal dwFlags As Integer, ByVal dx As Integer, ByVal dy As Integer, ByVal cButtons As Integer, ByVal dwExtraInfo As Integer)

    Public Const MOUSEEVENTF_LEFTDOWN = &H2
    Public Const MOUSEEVENTF_LEFTUP = &H4

And now simply use:


        mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0)
        mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0)


Voilá

YOU JUST DID YOUR CLICKER MODULE IN VISUAL BASIC.NET!

Victor

First published development version.

Please provide feedback on core functionality.

Download: [attachmini=1]

[attachimg=2]

---

Coded in Cross-platform C#

Works on windows (with .NET), Linux/Mac via Mono.


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;


namespace LastXSplits_0_1
{
    public partial class Form1 : Form
    {
        /// <summary>
        /// Constructor
        /// </summary>
        public Form1()
        {
            // Initialization
            InitializeComponent();
        }


        // History implemented as stack (LIFO)
        Stack<int> history = new Stack<int>();


        // Splits as List of Split class
        List<Split> Splits = new List<Split>() { new Split(1, 0), new Split(2, 0), new Split(3, 0), new Split(1, 2), new Split(1, 4), new Split(2, 3), new Split(2, 5), new Split(3, 6), new Split(4, 5), new Split(4, 7), new Split(5, 6), new Split(5,, new Split(6, 9), new Split(7,, new Split(7, 10), new Split(8, 9), new Split(8, 11), new Split(9, 12), new Split(10, 11), new Split(10, 13), new Split(11, 12), new Split(11, 14), new Split(12, 15), new Split(13, 14), new Split(13, 16), new Split(14, 15), new Split(14, 17), new Split(15, 18), new Split(16, 17), new Split(16, 19), new Split(17, 18), new Split(17, 20), new Split(18, 21), new Split(19, 20), new Split(19, 22), new Split(20, 21), new Split(20, 23), new Split(21, 24), new Split(22, 23), new Split(22, 25), new Split(23, 24), new Split(23, 26), new Split(24, 27), new Split(25, 26), new Split(25, 28), new Split(26, 27), new Split(26, 29), new Split(27, 30), new Split(28, 29), new Split(28, 31), new Split(29, 30), new Split(29, 32), new Split(30, 33), new Split(31, 32), new Split(31, 34), new Split(32, 33), new Split(32, 35), new Split(33, 36), new Split(34, 35), new Split(35, 36) };


        // Counter as BindingList of SplitCount (bound to DataGridView in FormCount)
        BindingList<SplitCount> Counter = new BindingList<SplitCount>();


        // Instantiate history form
        Form fHistory = new FormHistory();


        // Instantiate counter form
        Form fCount = new FormCount();


        // Reference to DataGridView
        DataGridView dgvCount;


        // Reference to History ListBox
        ListBox lbHistory;


        /// <summary>
        /// Program's entrypoint
        /// </summary>
        private void Form1_Load(object sender, EventArgs e)
        {
            // Declare control array
            PictureBox[] pbCtrl = { pb0, pb1, pb2, pb3, pb4, pb5, pb6, pb7, pb8, pb9, pb10, pb11, pb12, pb13, pb14, pb15, pb16, pb17, pb18, pb19, pb20, pb21, pb22, pb23, pb24, pb25, pb26, pb27, pb28, pb29, pb30, pb31, pb32, pb33, pb34, pb35, pb36 };


            // Attach events to each control
            foreach (PictureBox ctrl in pbCtrl)
            {
                // MouseLeave
                ctrl.MouseLeave += new EventHandler(PictureBox_MouseLeave);


                // MouseEnter
                ctrl.MouseEnter += new EventHandler(PictureBox_MouseEnter);


                // MouseDown
                ctrl.MouseDown += new MouseEventHandler(PictureBox_MouseDown);


                // MouseUp
                ctrl.MouseUp += new MouseEventHandler(PictureBox_MouseUp);


                // MouseClick
                ctrl.MouseClick += new MouseEventHandler(PictureBox_MouseClick);
            }


            // Set dgvCount
            dgvCount = (DataGridView)fCount.Controls["dgvCount"];


            // Prevent automatic generation of columns
            dgvCount.AutoGenerateColumns = false;


            // Add shows column
            DataGridViewTextBoxColumn showsColumn = new DataGridViewTextBoxColumn();
            showsColumn.DataPropertyName = "Shows";
            showsColumn.HeaderText = "Shows";
            showsColumn.Width = 50;
            showsColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            showsColumn.DefaultCellStyle.Font = new Font(fileToolStripMenuItem.Font, fileToolStripMenuItem.Font.Style ^ FontStyle.Italic);
            dgvCount.Columns.Add(showsColumn);


            // Add splits column
            DataGridViewTextBoxColumn splitsColumn = new DataGridViewTextBoxColumn();
            splitsColumn.DataPropertyName = "Splits";
            splitsColumn.HeaderText = "Splits";
            showsColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            splitsColumn.DefaultCellStyle.Font = new Font(fileToolStripMenuItem.Font, fileToolStripMenuItem.Font.Style ^ FontStyle.Italic);
            splitsColumn.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
            dgvCount.Columns.Add(splitsColumn);


            // Set dgvCount DataSource
            dgvCount.DataSource = Counter;


            // Set lbHistory
            lbHistory = (ListBox)fHistory.Controls["lbHistory"];


            // Show history form
            fHistory.Show();


            // Show counters form
            fCount.Show();
        }


        /// <summary>
        /// MouseEnter handler
        /// </summary>
        private void PictureBox_MouseEnter(object sender, System.EventArgs e)
        {
            // Show alpha-blended image
            ((PictureBox)sender).BackgroundImage = Properties.Resources.yellow_highlight_alpha_38x47;
        }


        /// <summary>
        /// MouseLeave handler
        /// </summary>
        private void PictureBox_MouseLeave(object sender, System.EventArgs e)
        {
            // Remove image
            ((PictureBox)sender).BackgroundImage = null;
        }


        /// <summary>
        /// MouseDown Handler
        /// </summary>
        private void PictureBox_MouseDown(object sender, MouseEventArgs e)
        {
            // Check for left button
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                // Change cursor to hand
                ((PictureBox)sender).Cursor = Cursors.Hand;


                // Show blue alpha-blended image
                ((PictureBox)sender).BackgroundImage = Properties.Resources.blue_highlight_alpha_38x47;
            }
        }


        /// <summary>
        /// MouseUp Handler
        /// </summary>
        private void PictureBox_MouseUp(object sender, MouseEventArgs e)
        {
            // Show yellow alpha-blended image
            ((PictureBox)sender).BackgroundImage = Properties.Resources.yellow_highlight_alpha_38x47;


            // Change cursor back
            ((PictureBox)sender).Cursor = Cursors.Default;
        }


        /// <summary>
        /// MouseClick handler
        /// </summary>
        private void PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            /* Right click = UNDO */


            if (e.Button == System.Windows.Forms.MouseButtons.Right)
            {
                // Check there's something
                if (history.Count > 0)
                {
                    // Pop last one
                    history.Pop();


                    // Remove from history ListBox
                    lbHistory.Items.RemoveAt(0);
                }


                // Update
                update();


                // Halt flow
                return;
            }


            // Check sender
            if (!(sender is PictureBox))
            {
                // Halt flow too
                return;
            }


            /* Left click = add to history */


            // Snip number
            int number = Convert.ToInt32(((PictureBox)sender).Name.ToString().Substring(2));


            // Push onto history stack
            history.Push(number);


            // Add to history ListBox
            lbHistory.Items.Insert(0, number);


            // Update
            update();
        }


        /// <summary>
        /// Update procedure
        /// </summary>
        private void update()
        {
            // Set dictionary of int, List<Split>
            Dictionary<int, List<Split>> SpD = new Dictionary<int, List<Split>>();


            // Reset every split counter
            foreach (Split sp in Splits)
            {
                // Zero it
                sp.count = 0;
            }


            // Set a count for iterations
            int iteration = 0;


            // Update X times
            foreach (int currentNumber in history)
            {
                // Rise iteration count
                ++iteration;


                // Update Splits list count
                foreach (Split sp in Splits)
                {
                    // If number in split matches input one
                    if (sp.n1 == currentNumber || sp.n2 == currentNumber)
                    {
                        // Rise one in .count
                        sp.count += 1;
                    }
                }


                // Check if must halt
                if (iteration == nudX.Value)
                {
                    // Time to break
                    break;
                }
            }


            // Set dictionary values
            foreach (Split sp in Splits)
            {
                // Account (or not) for unhit splits
                if (sp.count == 0 && !showUnhitSplitsToolStripMenuItem.Checked)
                {
                    // Unchecked, skip iteration
                    continue;
                }


                // Create dictionary entry if not present
                if (!SpD.ContainsKey(sp.count))
                {
                    // Add new list
                    SpD.Add(sp.count, new List<Split>() { sp });
                }
                else
                {
                    // Add split to index
                    SpD[sp.count].Add(sp);
                }
            }


            // Clear counter
            Counter.Clear();


            // Declare new int list
            List<int> intList = new List<int>();


            // Populate with dictionary keys
            foreach (KeyValuePair<int, List<Split>> kvp in SpD)
            {
                // Add key to list
                intList.Add(kvp.Key);
            }


            // Sort list
            intList.Sort();


            // Sync counter with dictionary using list
            for (int i = 0; i < intList.Count; ++i)
            {
                // Add to Counter
                Counter.Add(new SplitCount(intList[i], SpD[intList[i]]));
            }


            // Update status strip count
            tsslHistory.Text = history.Count.ToString();
        }


        /// <summary>
        /// Launch website in default browser
        /// </summary>
        private void websiteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Open web
            LaunchSite();
        }


        /// <summary>
        /// Open website in default browser
        /// </summary>
        private void LaunchSite()
        {
            // Launch BetSelection.cc
            System.Diagnostics.Process.Start("http://betselection.cc");
        }


        /// <summary>
        /// Show about box
        /// </summary>
        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Message
            MessageBox.Show("Created for the BetSelection.cc community by: Victor/VLS" + Environment.NewLine + Environment.NewLine + "Point your browser to [url=http://www.BetSelection.cc]www.BetSelection.cc[/url] for more releases!" + Environment.NewLine + Environment.NewLine + "(Nov. 2012)", "About Last X Splits", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
        }


        /// <summary>
        /// Account for unhit splits
        /// </summary>
        private void showUnhitSplitsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Reverse checked status
            showUnhitSplitsToolStripMenuItem.Checked = !showUnhitSplitsToolStripMenuItem.Checked;
        }


        /// <summary>
        /// Act upon change of X
        /// </summary>
        private void nudX_ValueChanged(object sender, EventArgs e)
        {
            // Trigger update
            update();
        }


        /// <summary>
        /// Launch website when form is closed
        /// </summary>
        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Open web
            LaunchSite();
        }
    }


    /// <summary>
    /// Split class
    /// </summary>
    public class Split
    {
        // Count, First and second splits
        public int count, n1, n2;


        // Overloaded constructor
        public Split(int first, int second)
        {
            // Set first number
            n1 = first;


            // Set second number
            n2 = second;
        }
    }


    /// <summary>
    /// SplitCount Class
    /// </summary>
    public class SplitCount
    {
        // Shows
        public int _shows;


        // Splits
        public List<Split> _splits;


        /// <summary>
        /// Overloaded constructor
        /// </summary>
        /// <param name="shows">int for shows</param>
        /// <param name="splits">List of Split</param>
        public SplitCount(int shows, List<Split> splits)
        {
            _shows = shows;
            _splits = splits;
        }


        /// <summary>
        /// Shows property
        /// </summary>
        public int Shows
        {
            get { return _shows; }
            set { _shows = value; }
        }


        /// <summary>
        /// Splits property
        /// </summary>
        public string Splits
        {
            get
            {
                // Splits string
                string splits = "";


                // Populate splits string
                foreach (Split sp in _splits)
                {
                    // First number + second number + comma and space (added after every split for speed)
                    splits += sp.n1 + "-" + sp.n2 + ", ";
                }


                // Strip last comma and space
                splits = splits.Substring(0, splits.Length - 2);


                // Return processed string
                return splits;
            }
        }
    }
}

Using the Triple-Felt Matrix.

Remember the "Dozen Twins"? They were bound to the dozens, these ones are "Felt Twins" or better expressed "Free Twins" (in any direction).

Bet is this: You bet to complete three (3) Felt Twins to be symmetrically distanced from each other. Example to follow.

This one:


[attachimg=1]


Several interesting approaches such as "Felt Twins" Evolution are based on it.

Recently I answered a message regarding the free and paid membership levels:

Quotehow can you reconcile the two different groups?

It's mostly a matter of conscience. We aren't making difference in the treatments to each group other than content access. You have most certainly already interacted with both types of members.

Should we treat paying users differently? In the interactions with people we all should be treated the same.

If you would, we currently have not two, but several categories of members:

- Guests: only gets teaser posts and can't access certain areas (i.e. can't even know or see such areas as the private general board and soon the extra software by Ophis or me).

- Registered non-paying member: Can post around but still can't access private sections in full.

- Paying member: access to everything earned by means of the provided financial support.

- Full free member: a member that we'd be honored to have in our ranks offering their quality interactions and bringing activity that pushes the forum forward.

So, there is space for all in our forum. There are no special stars or distinctions under their name for paying or full members. I know for a fact that when such distinctions are in place there are immediate cracks in the group's cohesion and this is why we avoid them, in order to not even have a need to reconcile, because we all understand the most important thing is to support the place together. Technically (features/software), with financial support (subscription price) or with the quality interactions (that keep the forum in good flow).

Receive a big, heartfelt hug.

Victor

Hello dear friends,

Some threads will be pruned under the question: is this constructive?

Many of them were "not matching our site's light-hearted and productive spirit." (excerpt from forum rules).

Today was a heated day, non-productive things were said; it's time to move on.

...So if you have the chance please support us by spreading the word.

As simple as mentioning us when you are discussing with your gambling fellows.

Or if you have a website, facebook page or blog, posting a link to us will help.

Thank you

The first decision of the council is: ROLL IT ALL BACK:

This is a most-pertinent quote from a saavy mod:

Quote
[...] sometimes we simply have to accept a via media -- a compromise position --  is a sensible course of action. As in this case.

Otherwise we will have dissension, disruption and uncertainty that will drive members away. It happened before, didn't it, when SH flexed his muscles?

Just accept his conditions.

Then we can move forward from there  with a stable platform for the future.

So the forum goes back to exactly where we were, Steve's ads are going to be run "Ad perpetuum" here.

An oldie requested by Sam:

[attachimg=2]

This is a legacy program based off an oldie codebase, hence should be taken "as is".

Download: [attachmini=1]

Cheers!
Vic

As title says: topic starters are moderators of their own topics now 

With everyone being a "Topic moderator" taking care of their own started threads, the work of Global Moderators should be easier from now on.

This thread is accompanying my previous Millioneighbors topic.


In the spirit of improving our personal game as time goes by, I ended up improving my millioneighbors bet to use less numbers, in exchange of a longer wait and required spin-window in between placed bets.


Our goal formation for TRILLIONEIGHBORS consists in looking for three (3) contiguous formations of zone 2 (or above) regardless of the space in between them.


Better to explain by example. Let's consider the following numerical sequence:


[attachimg=1]


We evaluate the situation and determine which numbers could generate the formation of three (3) realized zones, contiguously.


We have it. Numbers 26 and 24 are the ones:


[attachimg=2]


Since either 26:


[attachimg=4]


or 24 make three (3) consecutive Zones realized:


[attachimg=3]


In this case they were all Zone 2's, but Trillioneighbors's bet selection is not limited to considering only Zones of 2.


Let's see some more examples.

This bet selection is simple but can prove effective in the correct applications/frameworks.

Disc-based. The bet goes like this:

When we have a neighbor or "zone of 2" formed, we bet:

- Both neighbors of the realized zone of 2.
- Both neighbors of the next number to the RIGHT of the zone.
- Both neighbors of the next number to the LEFT of the zone.

e.g. we have the following sequence: 1 . 17 . 8 . 30:

[attachimg=1]

We must bet:

- Both neighbors of the realized zone of 2: 23 . 11, neighbors of realized Zone 2 made by by 8 . 30.
- Both neighbors of the next number to the RIGHT of the zone: 25 . 34. Neighbors of 17.
- Both neighbors of the next number to the LEFT of the zone: 33 . 20, neighbors of 1.

[attachimg=2]

---

The underlying principle is the continuous clumping of realized neighbors (zone 2) formations, regardless of the distance in between.

There's an exception or particularity on this bet: Zone of 3 by definition falls into millioneighbors, with space zero (0) in between neighbors. So when we have two numbers separated by one space, we must bet the common neighbor (I.e. the center); given a sequence including 12 . 3, we identify and bet 35 as eligible, like this:

[attachimg=3]

Vic

Collection zone: 1 full cycle / 37 spins.

Attack Zone: Spin 38 up to spin 55.

---

After 37 spins (one full cycle) you take note of the largest realized contiguous zone in the disc and any number which will form a larger zone than this is bet.

Let's see it by example.

In the next case, the largest realized zone after 37 spins is a <ZONE 4>, by numbers 19,4,21,2:

[attachimg=1]

You bet whatever number which would rise the ZONE to a new MAXIMUM, in this case, anything that makes <ZONE 5> or above:

[attachimg=2]

You bet looking for this event for half a cycle (18 spins), up to spin 55. Looking for a larger zone to be formed, if during the 18 attack spin any other number would form a <ZONE 5> or above, you include it in your bets.

It is quite a regular event for Zones to grow within this range, and thus provide hits. This is how it ended by spin 55, Zone Maximum @ <ZONE 11> in the arc from number 32 to 27, a nice jump from <Zone 4>:

[attachimg=3]

---

On a hit you retrack last 37 spins and note the largest realized zone, to attack any number that forms a larger zone for the next 18 spins, in a loop.

---

Sessions from hell arise when the 37-spin sessions have large contiguous areas already hit, and the best thing is that in such cases you bet the lesser numbers! So those type of sessions are actually easier on the progression and hence on the bank.

Vic

This one is a progression in RISK, meaning you keep the same 1 unit amount each bet but vary the location, reducing covered amount of numbers looking for more payout without having to rise.

[attachimg=#]

Vic

This is a repository for definitions/views regarding hot numbers.

   
• TwoCatSam.
• Gizmotron.
• RWD

The "boom" positive progression is intended to exploit the common happening of a location showing multiple times within a cycle.

This is entirely cycle-based, which means you should never deviate from the max. spin that closes it.

You assign the amount of units of a payout to face the cycle.

The basis is that you will re-invest the units won, divided by the number of spins left to cycle-end.

Example: You are betting a single number and get a hit at spin 15.

Cycle = 36
Hit at = 15

36 - 15 = 21

21 is the amount of spins left to sustain the bet.

How much to rise for those spins?

You rise by the result of payout divided by spins left.

In the case of a straight-up number, it is:

(36 * 1) / 21 = 1.71

So you add +1.71 units to your base bet for the rest of the cycle (tops).

1 + 1.71 = 2,71 units on the number now.

Shall you get another hit at -say- spin 23, your accounting will be:

36 - 23 = 13

13 spins to sustain the new bet.

(36 * 2.71) / 13 = 7,50 units on the number.

To be held for the next 13 spins tops.

---

Of course, there is a point in which you must take your wins, so it is advisable to take profits when on the plus, especially when playing several numbers this way at the same time.

At all times you know you are risking EXACTLY one payout of your base unit.

In the case of a single number it is 36 units, but in the event of having concatenated wins in the cycle, the ROI can rise handsomely.

This can be extrapolated to nice-paying locations such as splits or streets. Lower-paying locations do not offer enough for it to really go “boom!”, so you better stick to the higher-paying betting locations when considering this.

Regards.
Vic

Hello dear friends,

Just wanted to mention the fine fellows in the forum's software section aren't in direct competition with what I envision and aim for our software offering here.

I aim to create a roulette framework to enable the everyday user to create their own trackers, testers, clickers and bots. A true "do it yourself" set, where the user has pre-set modules at their disposal (the $5.99 part) and they can code the very minimum to achieve by extending it.

This means that I am working hard to *CREATE* able people like nOrMy or Ophis with the least learning curve. If I succeed you'll be able to simply hire the framework for $5.99 and code against it to serve your own needs; without me, Normy nor any other person in between    That's what I aim to attain. To create a product that let users deliver value to themselves; the realization of my motto: "Making a living by helping others achieve".

As far as I know there isn't anything quite like it on the market, not even RX, since while it's true that RX has a scripting language, you are "jailed" with it because you are limited to what RX offers and can't really extend the core feature-set by yourself.

Under the way I'm structuring the framework, you are OPEN to re-using modules from other people, whatever their favorite programming language might be. It's a common API.

So, please let's receive the fellows bringing in their programming skills to our place with arms wide open: we aren't competing. Fellow coders are offering their fine programs; we are ultimately aiming to offer a framework which people can code on their own to become self-sufficient.

Regards.
Vic