Independent-trial games poll here: are there better or worse methods?

Can we say we have a better system than the next guy / bettor?

...surely every one of us has an opinion regarding this; so... what's yours?

(Feel free to elaborate about your side / opinion at length - So we all can contrast and make the most from the discussion from this interesting -and fundamental- topic).

Target for vMTK is to be the "catch-all" toolkit for our programming languages. These are the points we have in mind:

It defines a cross-platform standard for widgets and core functionality which utilizes native implementations for each platform.

It allows similar widgets to spawn among platforms with matching capabilities, with no extra effort.

When targeting a single platform, vMTK allows full use of that platform's capacities, keeping track of available features and advising about limitations when a port is attempted to a new platform.

Languages using vMTK for graphical user interface are future-proof. While the underlying native implementation changes, vMTK aims to be as backwards-compatible as possible. i.e. A button is a button in windows 3.11 and windows 9. While the native implementation changes in the target platform, the matching vMTK standard for a button remains the same, which means there is stability across years for the programmer using vMTK.

What a joy to hear from you! Really good to know you're fine.

I sincerely want to say I'm really sorry for how things went. We will not have the ads forever. I hope when it happens there can be true mending among us.

I apologize to you again. I don't know if you received my former apologies. Already tried reaching you through old and new channels to no avail. My new email address is betselection﹫gmail.com

My doors and heart are open for you, I hope true mending can arise once we are freed. Time to time as they say.

It is very glad to see you back, alive and healthy, that's what most important.

P.S. Jr. is healthy as an oak too. The world is brighter today.

The in-memory toolkit serves a two-fold purpose.

On the one hand there is efficiency. By being a memory-only representation of a widget, there is no waiting for graphical updates to happen, thus the operations can literally run at the maximum speed two of the fastest components in the computer can deliver (RAM + Processor).

On the other hand there is portability. It acts as a platform-agnostic interface giving access to the widget's internal state to facilitate its graphical representation in any native programming technique the operating system demands.

BetSoftware's getting ready for prime time. Open to peer review.

Feel free to inquiry about the underlying tech, how to interact with it (directly or by custom connector), naming conventions, etc.

- Continue to the thread for 2014-05-05 with download + sources:

http://betselection.cc/development-loader/betsoftware-loader-2014-05-05/

[attachmini=1]

Relevant sources below.

While it's true a quickie fix or very simple feature can be knocked-off in minutes, coding can also become a painstakingly slow endeavor. The more complex the goal, the more time it demands.

If you don't see a feature being coded in your website or forum of choice at a fast-enough pace, remember programmers are people too. This is a word of support to the fellow programmers in the community, I send this "from the trenches" too.

"Code monkeys" => People with family and lives

Vic

If you create a paid digital product for one-shot payments (as opposed to monthly subscription services), you can use vFunding to attract users with an unique offer to differentiate from the competition using the regular model.

It can be applied to any one-time delivery product yet since I'm a programmer it is easier for me to explain the concept with coding.

vFunding goes like this:

1) The user contacts the digital creator (programmer) exposing his idea.

2) The programmer sets a price to code it.

3) On completion, the programmer posts finished program to his online store.

4) The user gets his copy of the program + 50% profit-sharing on all sales at the online store.

Benefits:

- The user gets the program he paid for.

- The programmer gets paid for the coding hours.

- Both the programmer and the user benefit from lifetime residual income thanks to the unlimited sales possible for digital products once created.

---

Extra advantages:

An user who truly believes in the program he wants can show more willingness to support its creation. Especially if he's confident it solves actual problems to deliver solutions to other willing users.

The programmer gets an increasing passive income source the more he uses vFunding with a larger pool of users.

The user can re-use funds from previous profit-sharing revenue to re-invest in new programs, creating a virtuous circle both for him and the programmer.

---

Note:
Step #3 can also be divided as a group, with proportional % split according to the funding provided by each person; with a fixed percentage agreed for the programmer.

---

When given the choice to buy from a regular seller without any further benefit after the download versus a seller applying vFunding who offers money-back or even a profit-making opportunity for the same dollars, which one do you think users will choose? [smiley]cxp/glasses.gif[/smiley]

---

If you are a payware maker, you might want to motivate your users to choose you by becoming part of a profit-sharing endeavor with the product they believe in and are willing to fund.

Vic

Trying here to be as concise as possible. Feel free to add comments in another thread. The thread remains locked since it's the basis of moving forward.
Thanks!

Today is one day dedicated to our mother Earth.

May we all consistently do at least a bit towards our environment and planet. Even with the simple things we all can afford. Not littering here, being a bit more conscious there.

[attach=1]

Do a bit for the planet today. We all share it.

Vic

Happy Easter with a new smiley set for the occasion:

[attach=1]
(Click to expand)

May you and your family enjoy this time gracefully.
Vic

---

[smileys]easter[/smileys]

Literally!

- Discuss a system today. Have some fun

Cheers!

Because a new one is being built from scratch; actually a new forum engine altogether.

No promises made as to when it gets rolled to our usage, but right now the best use of all my web-based coding time is our new engine.

I'm sure other brilliant coders can take the baton of adding new features incrementally to this engine in other sites and do the required maintenance.

To us: "vWeb"!

BetSelection from now on becomes more of a friendly "cafe".

In here we can enjoy the company of similar-minded friends.

We work oriented to make this a fine space for members who abide to our rules and in general have a disposition to discuss openly, calmly and in harmony about the pertinent topics we enjoy.

As our site continues with exploring venues of discussion and hosted projects, chances are positive things we develop here "spill" to other communities and paths of life, but let's all take it easy. We aren't here for proving a point or to be the biggest "XYZ" on the internet, but to have a good time and relish our shared time.

It's better for our collective blood pressure

...If you are good with a relaxed environment aligned with our family-friendly values, as outlined in our rules, then please be free to make BetSelection part of your life.

Thanks for being here.

See you around!

Hi guys,

Just wanted to mention all sub-boards keep on being there. They are just one click away for layout-preservation reasons.

i.e. http://betselection.cc/blogosphere/

All present! 
Vic

Making an effort once and getting benefits forever definitely looks like a great way to conduct your long-term plans.

If you have knowledge about it, with something concrete feel free to use this thread.

Non-gambling propositions only please!

Let's focus in things onto the positive side of the balance.

This topic has been moved to General Discussion.

http://betselection.cc/index.php?topic=3504.0

Is BetSoftware license compatible with PRIVATE coding?

Yes. It is compatible.

BetSoftware is GPL'd, which means any programmer is free to use it as a framework for private coding purposes.

As long as the resulting software is not distributed, it is perfectly in line with the GPL for the programmer to modify, extend and create derivative works from it, with the freedom of them to be charged for (i.e. to be paid works).

The very gist of private coding is clearly having the works being kept from public distribution, so it is perfectly compatible with this use case.

---

You can get some pertinent information right at the GPL faq page.

- Unreleased modifications:

QuoteThe GPL permits anyone to make a modified version and use it without ever distributing it to others. What this company is doing is a special case of that. Therefore, the company does not have to release the modified sources.

It is essential for people to have the freedom to make modifications and use them privately, without ever publishing those modifications.

http://www.gnu.org/licenses/gpl-faq.html#UnreleasedMods

- Changes under Non-disclosure agreement:

Quoteyou can accept a contract to develop changes and agree not to release your changes until the client says ok. This is permitted because in this case no GPL-covered code is being distributed under an NDA.

http://www.gnu.org/licenses/gpl-faq.html#DevelopChangesUnderNDA

This topic has been moved to Off-topic.

http://betselection.cc/index.php?topic=3392.0

Straightforward method, single dozen/column bet:

Track the dozens/columns in 3-spin cycles.

1) Wait until one has been spun for three (3) consecutive cycles (enabling point).

2) Bet on it until it has missed two consecutive cycles (disabling point)

3) Go back to step one.

---

123
-xx
xxx
xx- <- Spun 3 consecutive cycles = Enabling point for Dozen #2
-xx
xx-
-x-
x-x
xx-
xxx
-xx
xxx
x--
-xx
-x-
xx-
x--
--x <- Missed 2 cycles = Disabling point for dozen #2
xxx
x-x <- Spun 3 consecutive cycles = Enabling point for Dozen #3
xx-
-xx

BetSoftware is GPL'd.

---

Viva la libertad! / Long live freedom!

Vic

Series of practical application for felt-based patterns in the accompanying topic:

Felt pattern matching => "Hidden in plain sight"

Going to any casino in the world with nothing but a simple roulette felt layout, and "hitting it" without being noticed.

One of the greatest achievements of a roulette player.

Since s/he's not even watching the wheel spin, s/he can't be accused of playing dealer signatures, bias or anything wheel-based. Just being a player who doesn't draw much attention. Hidden in plain sight.

---

---

Felt pattern matching is playing a different game which happens to be realized in the roulette felt.

This series visits many of those patterns to match.

It is accompanied of the topic: Felt pattern matching => STRATEGIES where applications of these patterns is discussed.

Comm.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Drawing;
using System.Windows.Forms;
using System.Diagnostics;
using System.Threading;
using System.Runtime.InteropServices;
using System.IO;

namespace TextBox_Connector
{
    public static class Comm
    {
        // Set module Type
        private static string type = "display";

        // Set namespace
        private static string nSpace = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName.Substring(0, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName.IndexOf('.'));

        // Declare process
        static Process p = new Process();

        // Declare target handle
        static IntPtr target = IntPtr.Zero;
       
        /// <summary>
        /// Delegate for thread enumeration
        /// </summary>
        delegate bool EnumThreadDelegate(IntPtr hWnd, IntPtr lParam);

        /// <summary>
        /// Delegate for child windows enumeration
        /// </summary>
        public delegate bool EnumWindowProc(IntPtr hWnd, IntPtr parameter);

        /// <summary>
        /// Sends custom message to target handle (hWnd)
        /// </summary>
        [System.Runtime.InteropServices.DllImport("user32.dll", CharSet = CharSet.Auto)]
        static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, int wParam, StringBuilder lParam);
        [System.Runtime.InteropServices.DllImport("user32.dll", SetLastError = true)]
        public static extern IntPtr SendMessage(int hWnd, int Msg, int wparam, int lparam);
        [System.Runtime.InteropServices.DllImport("user32.dll", CharSet = CharSet.Auto)]
        static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, string lParam);

        /// <summary>
        /// Enumerates child windows
        /// </summary>
        [System.Runtime.InteropServices.DllImport("user32")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool EnumChildWindows(IntPtr window, EnumWindowProc callback, IntPtr i);

        // Constant for GETTEXT message
        private const uint WM_GETTEXT = 0x000D;

        // Constant for GETTEXTLENGTH message
        private const int WM_GETTEXTLENGTH = 0x000E;

        // Constant for SETTEXT message
        private const uint WM_SETTEXT = 0x000C;

        /// <summary>
        /// Enumerates windows in the thread
        /// </summary>
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        static extern bool EnumThreadWindows(int dwThreadId, EnumThreadDelegate lpfn, IntPtr lParam);

        /// <summary>
        /// Enumerates Handles from a given process
        /// </summary>
        static IEnumerable<IntPtr> EnumerateProcessWindowHandles(int processId)
        {
            var handles = new List<IntPtr>();

            foreach (ProcessThread thread in Process.GetProcessById(processId).Threads)
            {
                EnumThreadWindows(thread.Id, (hWnd, lParam) => { handles.Add(hWnd); return true; }, IntPtr.Zero);
            }

            return handles;
        }

        /// <summary>
        /// Callback for enumerating windows
        /// </summary>
        private static bool EnumWindow(IntPtr handle, IntPtr pointer)
        {
            // Get handle from garbage collector
            GCHandle gch = GCHandle.FromIntPtr(pointer);

            // Declare list
            List<IntPtr> list = gch.Target as List<IntPtr>;
           
            // Check if there's something
            if (list == null)
            {
                // Throw exception
                throw new InvalidCastException("GCHandle Target could not be cast as List<IntPtr>");
            }
           
            // Add to list
            list.Add(handle);
           
            // Exit with true (null would cancel)
            return true;
        }
       
        /// <summary>
        /// Returns list of IntPtr with child windows
        /// </summary>
        public static List<IntPtr> GetChildWindows(IntPtr parent)
        {
            List<IntPtr> result = new List<IntPtr>();
            GCHandle listHandle = GCHandle.Alloc(result);
            try
            {
                EnumWindowProc childProc = new EnumWindowProc(EnumWindow);
                EnumChildWindows(parent, childProc, GCHandle.ToIntPtr(listHandle));
            }
            finally
            {
                if (listHandle.IsAllocated)
                    listHandle.Free();
            }
            return result;
        }

        /// <summary>
        /// Gets text of control by handle
        /// </summary>
        public static string GetControlText(IntPtr hWnd)
        {
            // String builder for title           
            StringBuilder title = new StringBuilder();

            // Size of string for holding title.
            Int32 size = SendMessage((int)hWnd, WM_GETTEXTLENGTH, 0, 0).ToInt32();

            // 0 = no title.
            if (size > 0)
            {
                title = new StringBuilder(size + 1);

                SendMessage(hWnd, (int)WM_GETTEXT, title.Capacity, title);
            }

            // Give control text back
            return title.ToString();
        }

        /// <summary>
        /// Initialization routine
        /// </summary>
        public static string Init(Icon icon)
        {
            // Start process
            try
            {
                // Start
                p.StartInfo.UseShellExecute = false;
                p.StartInfo.FileName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().Location) + ".exe";
                p.Start();

                // Loop until it's loaded
                while (p.MainWindowHandle == IntPtr.Zero)
                {
                    Thread.Sleep(10);
                    p.Refresh();
                }

                // Check for input
                bool inputSolved = false;

                // Resolve input textbox
                while (!inputSolved)
                {
                    foreach (var handle in EnumerateProcessWindowHandles(p.Id))
                    {
                        // Get child windows
                        List<IntPtr> handles = GetChildWindows(handle);

                        // Hunt for "input"
                        foreach (IntPtr h in handles)
                        {
                            if (GetControlText(h).ToLower() == "input")
                            {
                                // Set target
                                target = h;

                                // Clear it
                                SendMessage(target, WM_SETTEXT, IntPtr.Zero, String.Empty);
                               
                                // Set flag
                                inputSolved = true;
                            }
                        }
                    }

                    // Pause
                    Thread.Sleep(25);
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }

            // Exit
            return string.Empty;
        }

        /// <summary>
        /// Receives message from the framework
        /// </summary>
        public static string Receive(string sender, string type, string msg)
        {
            // Split by new line
            string[] input = msg.Split(Environment.NewLine.ToCharArray());

            /* Discriminate message */

            // Check if OK msg
            if (input[0] == "K")
            {
                // TODO: Process it
            }
            else
            {
                // Clear target
                SendMessage(target, WM_SETTEXT, IntPtr.Zero, String.Empty);

                // Send latest message
                SendMessage(target, WM_SETTEXT, IntPtr.Zero, input[0]);
            }

            // Exit
            return string.Empty;
        }

        /// <summary>
        /// Sends message to the framework
        /// </summary>
        public static string Send(string msg)
        {
            // Try to send message
            try
            {
                // Send
                object ret = Assembly.GetEntryAssembly().GetType("BetSoftware_Loader.Comm").GetMethod("Receive", BindingFlags.Static | BindingFlags.Public).Invoke(null, new object[] { nSpace, type, msg });

                // Return
                return (string)ret;
            }
            catch (Exception)
            {
                // Let it fall through           
            }

            return string.Empty;
        }
    }
}

I'm thinking and rethinking about what's the best way to thwart piracy from day one, and the more I think of it, the more I realize the best movement is to give away the programs in source form to the community. This way -since I have a tradition of not using piracy protections in my programs anyway- we just can't tell who's pirating and who's not.

I respect my users enough not to accuse them of pirating right-up. (But yes, I know the realities of the world).

"El Cheapo" users who think $2.99 is one arm and one leg will go to extremes to get the software for free. I don't think those users are inherently evil, they are just, well, "cheapos".

Other users think everything should be free as it is their god-given right to never pay for anything. Developers should be paupers working for free all day long, and every attempt to monetize is seen with disgust by them... Out of any doubt this group are good to spend time learning how to compile the programs, for a change.

The official fair use of the programs' source code is to enable other developers to learn and contribute their twists/improvements -if so they wish-.

With regular commercial software you get absolutely nothing if you don't pay, so this way of distributing our sources is giving the community an unbelievably higher amount of benefit than purely commercial, the whole program to fiddle with, unrestricted. I can't effectively take any program back once it's source code is published in the open.

The programs as they stand right now were made at the most odd hours at night and aren't formatted any pretty, they just work for me in my development machine, which is perfectly OK for me.

I don't give my project files though, only the raw source code and bare resource files; like I mentioned, those interested in the source code for fair-use purposes will entirely rejoice to see this published online. On the other hand, everyone can rest assured that not having an ordered main project file won't stop "El Cheapo" users from spending the time making their own builds. Hopefully, those users can eventually become program fiddlers themselves, learning in the process. I'm not against that. In fact, I like the prospect of helping others learn.

Hardcore freebie hunters will inevitably find their way too.

In the end, there's something for everyone. Conscious users are going to support and I'm happy to foster the advancement of our community and making something that directly helps me and my family.

I promise not to ask anyone whether his copy has been paid or not, but I hope others will have the decency of not openly telling the world they are skimming off my work.

"Don't ask, don't tell"