Mouse Drag - C# bot

Question

First time doing this. I am currently building a bot using C# and want my bot to be able to move the mouse to a given point in a way that looks human. By this I am referring to the dragging of the mouse when a human moves the cursor to a point they are trying to click on. Currently my C# bot moves the mouse instantly to the location which doesn't look human.

private static Point[] FindColor(Color color)
{
    int searchValue = color.ToArgb();
    List<Point> result = new List<Point>();
    using (Bitmap bmp = GetScreenShot())
    {
        for (int x = 0; x < bmp.Width; x++)
        {
            for (int y = 0; y < bmp.Height; y++)
            {
                if (searchValue.Equals(bmp.GetPixel(x, y).ToArgb()))
                    result.Add(new Point(x, y));
            }
        }
    }
    return result.ToArray();
}


// FUNCTIONS OCCUR BELOW
// Error message if program could not find bitmap within screenshot show error message

Color myRgbColor = new Color(); // Creates new colour called myRgbColor
myRgbColor = Color.FromArgb(51, 90, 9); // This colour equals the RGB value
Point[] points = FindColor(myRgbColor); // Create an array called points which list all the points found in the screen where the RgB value matches.
if (points.Length > 0)
{
    Cursor.Position = points[2]; // Move mouse cursor to first point (Point 0)
    Thread.Sleep(0200);
    MouseClick();
}
if (points.Length == 0)
{
    MessageBox.Show("No matches!"); // Return error
    goto checkore;
}

Answer 1

You're going to want to use some kind of Timer with a callback, to move the mouse incrementally, step by step. As for the movement itself, you have a world of possibilities, but it's all maths.

So, let's decompose the problem.

What is a natural mouse movement?

Position change rate

It doesn't necessarilly looks like it, but when you move your mouse, you're simply setting its position multiple times per seconds.

The amount of times the position changes per second is equivalent to the polling rate of your mouse. The default polling rate for USB mice is 125Hz (or 125 position changes per second, if you will). This is the value we'll use for our Timer: its callback will be called 125 times per second.

var timer = new Timer(1000 / 125d);
timer.Elapsed += MoveMouse;

void MoveMouse(object sender, ElpasedEventArgs e) { }

Speed and acceleration

When you move your mouse, the distance between two cursor positions is not constant, because you're fast when you start moving your mouse, but you slow down when you get close to the item you want your cursor to be on.

There are also two ways I personally usually move my mouse depending on the context/mood:

1. One fast uniform movement to get close to the destination, then one slow to correct and get on it (I'll usually go past the destination during the first move)
2. One medium-slow movement with a small deceleration, follow by a stronger deceleration at the end

The overall speed of the movement also depends on three factors:

1. The distance between your cursor and the destination
2. The size of the destination area
3. Your personal speed

I have absolutely NO IDEA how to work out the formula based on these factors, that's gonna be a work of trial and error for yourself.

This one is purely math and observation based, and will be tricky to get perfectly right, if ever; every person moves their mouse a different way.

The solution I can offer you is to simply forget about deceleration, correction and so on, and just divide your movement into equal steps. That has the merit of being simple.

using System;
using System.Timers;
using System.Drawing;

public class Program
{
    static int stepCount = 0;
    static int numberOfSteps = 0;
    static float stepDistanceX = 0;
    static float stepDistanceY = 0;
    static PointF destinationPoint;
    static Timer timer;

    public static void Main()   
    {
        int timerStepDurationMs = 1000 / 125;

        PointF currentPoint = Cursor.Position;
        destinationPoint = new PointF(2000, 1800); // or however you select your point

        int movementDurationMs = new Random().Next(900, 1100); // roughly 1 second
        int numberOfSteps = movementDurationMs / timerStepDurationMs;

        stepDistanceX = (destinationPoint.X - currentPoint.X) / (float)numberOfSteps;
        stepDistanceY = (destinationPoint.Y - currentPoint.Y) / (float)numberOfSteps;

        timer = new Timer(timerStepDurationMs);
        timer.Elapsed += MoveMouse;
        timer.Start();

        while (stepCount != numberOfSteps) { }
    }

    static void MoveMouse(object sender, ElapsedEventArgs e)
    {
        stepCount++;

        if (stepCount == numberOfSteps)
        {
            Cursor.Position = destinationPoint;
            timer.Stop();
        }

        Cursor.Position.X += stepDistanceX;
        Cursor.Position.Y += stepDistanceY;
    }
}

Note that I haven't tested with "Cursor", but with some PointF variable instead. It seems to work fine here: dotnetfiddle.