C# - bewegt die Maus, um realistisch

Bin ich demonstrieren ein Stück software, und bauen wollen, eine Maus "mover" - Funktion, so dass ich im Grunde den Prozess automatisieren. Ich will realistische Bewegungen der Maus, bin aber mit ein bisschen eine mentale Blockade im Denkprozess. Ich kann die Maus bewegen um einfach mit c# aber wollen, dass es ein bisschen realistischer, als nur der cursor erscheint an einer bestimmten x -, y-Koordinaten, und drücken Sie dann eine Taste.

Bekomme ich die aktuelle position der Maus, und dann bekommen Sie den Endpunkt. Berechnung eines Kreisbogens zwischen den beiden Punkten, aber dann muss ich berechnen, Punkte entlang des Bogens, so dass ich fügen Sie ein timer-Ereignis in, dass, so dass ich die Bewegung von einem Punkt zum nächsten, und dann wiederholen Sie das, bis ich am Ziel...

Möchte jemand näher erläutern?

Dank, R.

Sie bewegen Sie die Maus von Punkt A zu Punkt B in einem Bogen? Ich glaube, ich gehe in einer geraden Linie. Das würde Ihr Leben viel einfacher. 🙂
Also, was ist die Frage? Erläutern Sie auf Ihre Idee?
JP: es sei denn, Sie arbeiten mit einem Lineal, sind alle Ihre Maus trails wirklich geraden Linien? 🙂 Ich bin gerade am überlegen von Möglichkeiten, wie sich die Maus bewegen sich in realistischer Weise mit dem code. Ich habe gegoogelt, auf der Suche nach einer code-Basis, aber es ist etwas, das nicht wirklich getan.
Ich denke googeln "spline" würde hier helfen
Könnten Sie mir sagen, wie Sie machen die Maus zu klicken? Ich bin mit C# in Visual Studio 2010

InformationsquelleAutor flavour404 | 2009-05-27

c#mouse

22

Habe ich versucht, den Bogen Berechnungsmethode, stellte sich heraus, viel zu Komplex und, im Ende, ist es nicht realistisch Aussehen. Gerade Linien sehen viel mehr Menschen, als JP schlägt in seinem Kommentar.

Dies ist eine Funktion, die ich schrieb, zu berechnen eine lineare Bewegung der Maus. Sollte ziemlich selbsterklärend. GetCursorPosition() und SetCursorPosition(Punkt) sind Wrapper für die win32-Funktionen GetCursorPos und SetCursorPos.

Soweit die Mathematik geht - technisch, das heißt Lineare Interpolation eines Liniensegments.
```
public void LinearSmoothMove(Point newPosition, int steps) {
    Point start = GetCursorPosition();
    PointF iterPoint = start;

    //Find the slope of the line segment defined by start and newPosition
    PointF slope = new PointF(newPosition.X - start.X, newPosition.Y - start.Y);

    //Divide by the number of steps
    slope.X = slope.X / steps;
    slope.Y = slope.Y / steps;

    //Move the mouse to each iterative point.
    for (int i = 0; i < steps; i++)
    {
        iterPoint = new PointF(iterPoint.X + slope.X, iterPoint.Y + slope.Y);
        SetCursorPosition(Point.Round(iterPoint));
        Thread.Sleep(MouseEventDelayMS);
    }

    //Move the mouse to the final destination.
    SetCursorPosition(newPosition);
}
```
- Ich wusste, dass jemand sein würde der smart mit der Mathematik! 🙂
- Froh, dass ich nicht enttäuschen. =)
- Erik, ich dachte, ich antwortete auf diese Letzte Nacht, aber offensichtlich war ich müder, als ich dachte. Vielen Dank, es ist eine gute Antwort und auf jeden Fall gibt mir a) etwas, das ich verwenden kann, b) etwas, was ich kann erweitern. Tolle Antwort. Ich werde Bedenken, was Sie gesagt haben über die arc.
- Keine Sorge. Froh zu helfen. Ich werde sehen, ob ich kann Graben, bis der alte code, den ich schrieb, dass die verwendeten Bögen und poste es wenn ich es finde.
- Was MouseEventDelayMS?
- Sorry - eine int-Konstante, gibt die Anzahl der Millisekunden, die zwischen move-Ereignisse.
- Tun, verlieren Sie die Genauigkeit wegen der Rundung? Wenn ich eine Linie zeichnen auf dem Bildschirm und versucht die Maus zu bewegen Sie die Maus nicht bewegen, genau auf die Linie.
- Ja, aber ich brauchte keine exakte Lösung.
InformationsquelleAutor Erik Forbes

Konvertierte ich die WindMouse Funktion erwähnt in C# und es ist eigentlich ziemlich realistisch. Beachten Sie, dass dies nur ein grobes Beispiel und keine Wrapper für GetCursorPos und SetCursorPos. Ich werde mich mit der Windows-Simulator Wrapper.

static class SampleMouseMove {

    static Random random = new Random();
    static int mouseSpeed = 15;

    static void Main(string[] args) {
        MoveMouse(0, 0, 0, 0);
    }

    static void MoveMouse(int x, int y, int rx, int ry) {
        Point c = new Point();
        GetCursorPos(out c);

        x += random.Next(rx);
        y += random.Next(ry);

        double randomSpeed = Math.Max((random.Next(mouseSpeed) / 2.0 + mouseSpeed) / 10.0, 0.1);

        WindMouse(c.X, c.Y, x, y, 9.0, 3.0, 10.0 / randomSpeed,
            15.0 / randomSpeed, 10.0 * randomSpeed, 10.0 * randomSpeed); 
    }

    static void WindMouse(double xs, double ys, double xe, double ye,
        double gravity, double wind, double minWait, double maxWait,
        double maxStep, double targetArea) {

        double dist, windX = 0, windY = 0, veloX = 0, veloY = 0, randomDist, veloMag, step;
        int oldX, oldY, newX = (int)Math.Round(xs), newY = (int)Math.Round(ys);

        double waitDiff = maxWait - minWait;
        double sqrt2 = Math.Sqrt(2.0);
        double sqrt3 = Math.Sqrt(3.0);
        double sqrt5 = Math.Sqrt(5.0);

        dist = Hypot(xe - xs, ye - ys);

        while (dist > 1.0) {

            wind = Math.Min(wind, dist);

            if (dist >= targetArea) {
                int w = random.Next((int)Math.Round(wind) * 2 + 1);
                windX = windX / sqrt3 + (w - wind) / sqrt5;
                windY = windY / sqrt3 + (w - wind) / sqrt5;
            }
            else {
                windX = windX / sqrt2;
                windY = windY / sqrt2;
                if (maxStep < 3)
                    maxStep = random.Next(3) + 3.0;
                else
                    maxStep = maxStep / sqrt5;
            }

            veloX += windX;
            veloY += windY;
            veloX = veloX + gravity * (xe - xs) / dist;
            veloY = veloY + gravity * (ye - ys) / dist;

            if (Hypot(veloX, veloY) > maxStep) {
                randomDist = maxStep / 2.0 + random.Next((int)Math.Round(maxStep) / 2);
                veloMag = Hypot(veloX, veloY);
                veloX = (veloX / veloMag) * randomDist;
                veloY = (veloY / veloMag) * randomDist;
            }

            oldX = (int)Math.Round(xs);
            oldY = (int)Math.Round(ys);
            xs += veloX;
            ys += veloY;
            dist = Hypot(xe - xs, ye - ys);
            newX = (int)Math.Round(xs);
            newY = (int)Math.Round(ys);

            if (oldX != newX || oldY != newY)
                SetCursorPos(newX, newY);

            step = Hypot(xs - oldX, ys - oldY);
            int wait = (int)Math.Round(waitDiff * (step / maxStep) + minWait);
            Thread.Sleep(wait);
        }

        int endX = (int)Math.Round(xe);
        int endY = (int)Math.Round(ye);
        if (endX != newX || endY != newY)
            SetCursorPos(endX, endY);
    }

    static double Hypot(double dx, double dy) {
        return Math.Sqrt(dx * dx + dy * dy);
    }

    [DllImport("user32.dll")]
    static extern bool SetCursorPos(int X, int Y);

    [DllImport("user32.dll")]
    public static extern bool GetCursorPos(out Point p);
}

InformationsquelleAutor Coder1095

procedure WindMouse(xs, ys, xe, ye, gravity, wind, minWait, maxWait, maxStep, targetArea: extended);
var
  veloX, veloY, windX, windY, veloMag, dist, randomDist, lastDist, step: extended;
  lastX, lastY: integer;
  sqrt2, sqrt3, sqrt5: extended;
begin
  sqrt2:= sqrt(2);
  sqrt3:= sqrt(3);
  sqrt5:= sqrt(5);
  while hypot(xs - xe, ys - ye) > 1 do
  begin
    dist:= hypot(xs - xe, ys - ye);
    wind:= minE(wind, dist);
    if dist >= targetArea then
    begin
      windX:= windX / sqrt3 + (random(round(wind) * 2 + 1) - wind) / sqrt5;
      windY:= windY / sqrt3 + (random(round(wind) * 2 + 1) - wind) / sqrt5;
    end else
    begin
      windX:= windX / sqrt2;
      windY:= windY / sqrt2;
      if (maxStep < 3) then
      begin
        maxStep:= random(3) + 3.0;
      end else
      begin
        maxStep:= maxStep / sqrt5;
      end;
    end;
    veloX:= veloX + windX;
    veloY:= veloY + windY;
    veloX:= veloX + gravity * (xe - xs) / dist;
    veloY:= veloY + gravity * (ye - ys) / dist;
    if hypot(veloX, veloY) > maxStep then
    begin
      randomDist:= maxStep / 2.0 + random(round(maxStep) / 2);
      veloMag:= sqrt(veloX * veloX + veloY * veloY);
      veloX:= (veloX / veloMag) * randomDist;
      veloY:= (veloY / veloMag) * randomDist;
    end;
    lastX:= Round(xs);
    lastY:= Round(ys);
    xs:= xs + veloX;
    ys:= ys + veloY;
    if (lastX <> Round(xs)) or (lastY <> Round(ys)) then
      MoveMouse(Round(xs), Round(ys));
    step:= hypot(xs - lastX, ys - lastY);
    wait(round((maxWait - minWait) * (step / maxStep) + minWait));
    lastdist:= dist;
  end;
  if (Round(xe) <> Round(xs)) or (Round(ye) <> Round(ys)) then
    MoveMouse(Round(xe), Round(ye));
end;

{*******************************************************************************
procedure MMouse(x, y, rx, ry: integer);
By: Benland100
Description: Moves the mouse.
*******************************************************************************}
//Randomness is just added to the x,y. Might want to change that.
procedure MMouse(x, y, rx, ry: integer);
var
  cx, cy: integer;
  randSpeed: extended;
begin
  randSpeed:= (random(MouseSpeed) / 2.0 + MouseSpeed) / 10.0;
  if randSpeed = 0.0 then
    randSpeed := 0.1;
  getMousePos(cx,cy);
  X := x + random(rx);
  Y := y + random(ry);
  WindMouse(cx,cy,x,y,9.0,3.0,10.0/randSpeed,15.0/randSpeed,10.0*randSpeed,10.0*randSpeed);
end;

Hier sind einige Methoden geschrieben NARBE. Konvertierung in C# sollte nicht allzu schwer sein, diese sind durchaus realistisch.

Dank jemand, ich nehme einen Blick. Interessant moniker! 🙂
Ich habe versucht, herauszufinden, was die minE () - Funktion funktioniert, keine Ahnung?
Gibt den kleineren von zwei Variablen - Math.Min() oder ähnliches. Quelle: forums.freddy1990.com/index.php?topic=4214.0
Nicht sicher, wie zuverlässig die Quelle ist, aber wenn man aus dem obigen code ich denke, es ist richtig.

InformationsquelleAutor

0

Übliche Weg, denke ich, ist, um körperlich bewegen die echte Maus mit Ihrer eigenen hand und haben die software erfassen die (echte) Bewegungen, und diese wiedergeben.

InformationsquelleAutor ChrisW

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.