The reason being reports from the topic:

http://betselection.cc/general-discussion/trigger-this/

--That topic really "triggered this" (warnings).

Unfortunately, as long as people don't follow your finely expressed common-sense guidelines, measures must be taken. We really want to foster a clean environment for all members involved in the discussion.

---

Quote from: Bally6354 on February 06, 2013, 12:01:11 AM
However it's also a shame that people just can't get on with one another or just ignore anyone they don't like.

We are all adults.

I too would prefer people not to recur to personal insults in the first place.

Also, the idea of having every user as a proactive watcher is appealing from an administrative point of view.

Remember the mods are the only ones who can issues warns right now.

Our forum now implements an user warning system.

It's point-based.

The warning range is 0-100%

10-30% = Result: User will be added to moderator watch list.

35-55% = Result: All user's posts will be moderated.

60 - 100% = Result: User will not be able to post. (user is Muted)

Warned user gets 10% decremented per day after receiving the warn. This means the warning level slowly fades out of the account, gradually.

All moderators can issue warns right now.

---

The discussion is open regarding the possibility for any regular user to be able to issue warns (i.e. max. 10 points) in order to bring people to mods attention; as well as -in case there is public outrage- for the community to mute an offending user on their own.

Feel free to post your views on this.

Regards.

Wonderful news for those wanting a 0.10 real-life casino bet.

With a sensitive way of betting it shouldn't be too hard to adapt.

Compound locations benefit from those lower limits too with a reasonable itemization.

i.e. Double-Streets have 0.10 - 10, a x100 multiple on base bet which should be enough for most down-to-earth strategies.


[attachimg=1]

You let the first 37 spins pass without betting.

From now on, you use a ROLLING WINDOW comprised by the last 37 spins.

This means on each new spin incoming number is added and number in the 38th position (38 spins back) is discarded. You always consider the latest 37 spins only.

Your bet is comprised by every unhit NEIGHBOR number in the spin window.

This is a Wheel-based bet, hence you need to use wheel layout.

Vic

This is a sensitive topic I wanted to write -at least a little- about.


Lifetime is limited. We can only ever get to make a finite number of things during our time on Earth. It is important for a person to follow his/her vocation and do his/her best to earn a living with something fulfilling.


These days in our internet age there are ways for people to actually make a living in forms which weren't possible only a handful of years ago. if you have a vocation for it, then go ahead!


If you believe you can do great to the world, then by all means transform your life to do it. Now more than ever your work can reach the whole globe.


Don't be a Picasso hired to paint the walls white. Explode your potential, be great.


Vic

Quote from: TwoCatSam on January 31, 2013, 06:59:47 AM
Vic

Is this an EC bet?

Hi Sam,

This is a straight-up bet, originally.

Quote from: TwoCatSam on January 31, 2013, 06:59:47 AMYou have nine 1s.  Is your first bet 9 units?

Each 1 (unit) corresponds to a single straight-up number, hence it's a bet for 9 numbers

Pubic Lice Endangered Due to, Ahem, Habitat Loss

http://www.treehugger.com/natural-sciences/pubic-lice-endangered-due-ahem-habitat-loss.html

What a lovely thing to see you active around here dear GLC 


Thank you very much for your brilliant insight 

"during the course of employment".


"during the [INTER]course of employment".

To clear things up regarding this:

QuoteRRBB = Trigger.
BBRR = Trigger.

I mean really TRUE Series of two, not like:
RRRRRBB or BBBBBRR

Where the RRBB / BBRR forms part of a bigger series.

The correct interpretation is RRBB / BBRR only as two separate series as in:
RRRBRRBB or BRBBRRRRBBRR

The selection is fair simple: Use Decision Before Last (DBL) till 2 separate series of 2 appear, then simply bet for the “clump” or “cluster” of series of two to continue.

As in DBL, the concentration of hits on both the Zig-Zags (as in RBRBRB) and the Long series (  RRRRRR or BBBBB…) is enjoyed.

The 2 has a double special meaning here. 2 series of 2 = trigger to bet for the clump of these series.

RRBB = Trigger.

BBRR = Trigger.

In essence, after 2 series of two you will be betting for RRBBRRBBRRBB…. (The larger the clump of these series the better).

Well, that’s essentially it.

Also, bear in mind when you are betting for the clump after RRBB or BBRR (2 series of 2) and it becomes a series of 3 you return to what DBL says and bet for the continuation as usual.

Enjoy this one. If you consider trying it, you can study it along with Cheating D'Alembert.

Vic

Rules:

-      On a lose we only move the unit up by +1 unit at a time, as in the standard D'alembert..
-      We always reset to base unit when we tie or reach a new bankroll high.
-      On a win, we can lower MORE than -1 unit at a time using the following criterion:

We compare both, the amount if we take -1 from the last winning bet (as in the standard D'alembert) and the amount of units we are below from the bankroll.

Example:

We start with 200 units.
We place 1 unit and lose.

We have this:
-      D'alembert says: 1 + 1 = 2 as next bet.
-      We are -1 unit below: 1 as next bet.

We chose 1 as our next bet since it is the lower.

-------

Another example:

We were up at 230.
We are currently at 220.

In our stream of bets at this given sample time we are placing 4 units.
We lose -4 and are now at 216.

-      D'alembert says: 4 + 1 = 5 as next bet.
-      We do the math (High bankroll – Current): 230 – 216 = 14 units as next bet.

We always pick the lower, so in this case we pick what D'alembert says: 5 units as next bet.

-------

The third possible example is: at times it will be the same value on both, the D'almbert and the loss units. No brainer. Just use that value.

I.e: You start with 200.
Place 1 unit. Loss.
199
You determine 1 unit as next bet and lose.
198
Now D'alembert is 1+1 = 2 as next bet AND you are -2 units below = 2 as next bet.

Same amount, you use it.

===============

Of course, as with everything, you need to back up winners somewhat consistently for this to make a profit. But by the +1 rising only I like this one. Better than the cancellations or martingales which rise quite a lot more.

Vic

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


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


        // List of int to hold numbers
        List<int> numbers = new List<int>();


        /// <summary>
        /// Load text file (then process it)
        /// </summary>
        private void bLoad_Click(object sender, EventArgs e)
        {
            // New stream
            Stream fStream = null;


            // New Open File Dialog
            OpenFileDialog ofdLoad = new OpenFileDialog();


            // Set Open File Dialog properties
            ofdLoad.InitialDirectory = Path.GetDirectoryName(Application.ExecutablePath); ;
            ofdLoad.Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*";
            ofdLoad.FilterIndex = 1;
            ofdLoad.RestoreDirectory = true;


            // Show Open File Dialog
            if (ofdLoad.ShowDialog() == DialogResult.OK)
            {
                // A file was selected
                try
                {
                    // Open file
                    if ((fStream = ofdLoad.OpenFile()) != null)
                    {
                        // Process file
                        using (System.IO.StreamReader file = new System.IO.StreamReader(fStream))
                        {
                            // Declare line
                            string line;


                            // Declare number
                            int number;


                            // Clear numbers list
                            numbers.Clear();


                            // Read each line
                            while ((line = file.ReadLine()) != null)
                            {
                                // Set current number
                                number = Convert.ToInt32(line);


                                // Validate nubmer
                                if (number >= 0 && number <= 36)
                                {
                                    // Add to numbers list
                                    numbers.Add(number);
                                }
                            }
                        }


                        // Set base file name
                        string bfn = Path.GetDirectoryName(ofdLoad.FileName) + "\\" + Path.GetFileNameWithoutExtension(ofdLoad.FileName);


                        // Set default font
                        Font font = new Font("Arial", 18);


                        // Set font by dialog
                        if (cbFont.Checked)
                        {
                            // Show the dialog.
                            DialogResult result = fdFont.ShowDialog();


                            // See if OK was pressed.
                            if (result == DialogResult.OK)
                            {
                                // Get Font.
                                font = fdFont.Font;
                            }
                        }


                        /*
                         * Process each pair
                         */


                        // Handle 3 iterations
                        for (int p = 0; p < 3; ++p)
                        {
                            // Set pair variable
                            string pair = "";


                            // Red/Black
                            if (p == 0)
                            {
                                // Check state
                                if (!cbRB.Checked)
                                {
                                    // Halt iteration
                                    continue;
                                }


                                // Set pair
                                pair = "RB";
                            }


                            // Even/Odd
                            if (p == 1)
                            {
                                // Check state
                                if (!cbEO.Checked)
                                {
                                    // Halt iteration
                                    continue;
                                }


                                // Set pair
                                pair = "EO";
                            }


                            // Low/High
                            if (p == 2)
                            {
                                // Check state
                                if (!cbLH.Checked)
                                {
                                    // Halt iteration
                                    continue;
                                }


                                // Set pair
                                pair = "LH";
                            }


                            // Clear datagridview
                            dgvGen.DataSource = null;


                            //Customize output.
                            dgvGen.RowHeadersVisible = false;
                            dgvGen.ColumnHeadersVisible = false;
                            dgvGen.ScrollBars = ScrollBars.None;
                            dgvGen.AutoSize = true;
                            dgvGen.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;
                            dgvGen.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCells;


                            //Set datasource.
                            dgvGen.DataSource = GetDataTable();


                            // Cell colorization
                            for (int r = 0; r < dgvGen.Rows.Count; ++r)
                            {
                                // Check number
                                for (int c = 0; c < Convert.ToInt32(nudCols.Value); ++c)
                                {
                                    if (c < dgvGen.Rows[r].Cells.Count && !(dgvGen.Rows[r].Cells[c].Value is DBNull))
                                    {
                                        // Formatting
                                        dgvGen.Rows[r].Cells[c].Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
                                        dgvGen.Rows[r].Cells[c].Style.BackColor = getColorMulti(Convert.ToInt32(dgvGen.Rows[r].Cells[c].Value), pair);
                                        dgvGen.Rows[r].Cells[c].Style.ForeColor = Color.White;
                                        dgvGen.Rows[r].Cells[c].Style.Font = font;
                                    }
                                    else
                                    {
                                        // Break loops
                                        goto breaker;
                                    }
                                }
                            }


                            // Breaker label
                        breaker:


                            // Auto-resize
                            int i = 0;
                            foreach (DataGridViewColumn c in dgvGen.Columns)
                            {
                                i += c.Width;
                            }
                            dgvGen.Width = i + dgvGen.RowHeadersWidth;
                            dgvGen.Height = dgvGen.GetRowDisplayRectangle(dgvGen.NewRowIndex, true).Bottom + dgvGen.GetRowDisplayRectangle(dgvGen.NewRowIndex, false).Height;


                            // Bitmap
                            Bitmap bitmap = new Bitmap(dgvGen.Width, dgvGen.Height);
                            dgvGen.DrawToBitmap(bitmap, new Rectangle(Point.Empty, dgvGen.Size));
                            bitmap.Save(bfn + "-" + pair + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                            MemoryStream ms = new MemoryStream();
                            bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
                            bitmap.Dispose();
                        }


                        // Messagebox
                        if (cbRB.Checked || cbEO.Checked || cbLH.Checked)
                        {
                            MessageBox.Show("Generated!", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Error: " + ex.Message);
                }
            }
        }


        /// <summary>
        /// Helper method.
        /// </summary>
        DataTable GetDataTable()
        {
            // DataTable
            DataTable dt = new DataTable();


            // Index for numbers' list
            int index = 0;


            // Columns
            for (int i = 0; i < Convert.ToInt32(nudCols.Value); i++)
            {
                dt.Columns.Add(string.Format("Column{0}", i));
            }


            // Rows
            while (index < (numbers.Count - 1))
            {
                // String array to hold numbers
                string[] row = new string[dt.Columns.Count];


                // Prepare current row
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    // Check for EOL
                    if (index == (numbers.Count - 1))
                    {
                        // Truncate loop
                        break;
                    }


                    // Add to string array
                    row[i] = numbers[index].ToString();


                    // Rise index
                    index++;
                }


                // Add row
                dt.Rows.Add(row);
            }


            // Return DataTable
            return dt;
        }


        /// <summary>
        /// Cleanup code
        /// </summary>
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Open BetSelection.cc
            System.Diagnostics.Process.Start("http://betselection.cc");
        }




        /// <summary>
        /// Determines color of incoming number, acording to pair
        /// </summary>
        /// <param name="num">input number</param>
        /// <param name="pair">Any of: RB, EO, LH</param>
        /// <returns></returns>
        public Color getColorMulti(int num, string pair)
        {
            // Switch pairs
            switch (pair)
            {
                case "RB":
                    // Red-Black pair
                    switch (num)
                    {


                        case 1:
                        case 3:
                        case 5:
                        case 7:
                        case 9:
                        case 12:
                        case 14:
                        case 16:
                        case 18:
                        case 19:
                        case 21:
                        case 23:
                        case 25:
                        case 27:
                        case 30:
                        case 32:
                        case 34:
                        case 36:


                            // Red number
                            return Color.Red;
                        case 2:
                        case 4:
                        case 6:
                        case 8:
                        case 10:
                        case 11:
                        case 13:
                        case 15:
                        case 17:
                        case 20:
                        case 22:
                        case 24:
                        case 26:
                        case 28:
                        case 29:
                        case 31:
                        case 33:
                        case 35:


                            // Black number
                            return Color.Black;
                        default:


                            // Anything else = green
                            return Color.Green;
                    }


                    break;


                case "EO":
                    // Even-Odd pair
                    switch (num)
                    {
                        case 2:
                        case 4:
                        case 6:
                        case 8:
                        case 10:
                        case 12:
                        case 14:
                        case 16:
                        case 18:
                        case 20:
                        case 22:
                        case 24:
                        case 26:
                        case 28:
                        case 30:
                        case 32:
                        case 34:
                        case 36:
                            // Even number
                            return Color.Blue;
                        case 1:
                        case 3:
                        case 5:
                        case 7:
                        case 9:
                        case 11:
                        case 13:
                        case 15:
                        case 17:
                        case 19:
                        case 21:
                        case 23:
                        case 25:
                        case 27:
                        case 29:
                        case 31:
                        case 33:
                        case 35:
                            // Odd number
                            return Color.DarkMagenta ;
                        default:
                            // Anything else = green
                            return Color.Green;
                    }


                    break;


                case "LH":
                    // Low-High pair
                    if (num > 0 && num <= 18)
                    {
                        // Low
                        return Color.Orange;
                    }
                    else if (num <= 36 && num >= 19)
                    {
                        // High
                        return Color.Purple;
                    }
                    else
                    {
                        // Green
                        return Color.Green;
                    }
                    break;
            }


            // Codepaths
            return Color.White;


        }
    }
}



Development version.

Download: [attachmini=2]

[attachimg=1]

Usage is very simple:

Hit "Load file" then select a font.


3 new .JPG images get generated on the same directory as the actuals file.

Still open to color pairs for Even/Odd and Low/High.

Vic

Release here:

http://betselection.cc/free-releases/(release)-last-x-splits-v1-0/