Pixelerkennung, Kreativität gesucht die mir fehlt!

[Neutral General]

Das ist ein interessantes Problem, aber ich werde dir sicher nicht helfen einen Aimbot für Overwatch zu schreiben Das ist gegen die EULA und du kannst dir sicher sein, dass du dir so einen lebenslangen Bann einhandelst (gut so!).

[Pixel]

Zitat von Neutral General:

Das ist ein interessantes Problem, aber ich werde dir sicher nicht helfen einen Aimbot für Overwatch zu schreiben Das ist gegen die EULA und du kannst dir sicher sein, dass du dir so einen lebenslangen Bann einhandelst (gut so!).

Wenn man's genau nimmt, steht mir völlig frei screenshots zu machen und Bilderkennung durchzuführen.
Das verstößt in keiner Form gegen Blizzards EULA und kann davon mal abgesehen auch nicht erkannt werden. Sonst sind bald alle streamer gebannt

Verstoßen würde ich erst, wenn ich Funktionen wie mouse_event() nutze um den cursor virtuell zu bewegen oder anders gesagt: Das Game manipuliere/Bewegungen automatisiere. Auch hier wird es schwer das zu erkennen da mouse_event() direkt in den mouse stream sendet. Man müsste schon NtUserSendInput auf Ring0 hooken um festzustellen ob der input physikalisch oder virtuell war.

Durch heuristische erkennung wirds auch ein Katz und Mausspiel. Klar, man könnte die inputs per second der Maus (die Normal z.B. 1000 ist) nehmen und dann Abweichungen messen die während des Schießens passieren aber naja - ein anderes interessantes Thema.

Ganz ehrlich wie schon gesagt: Mir geht's hier nur ums erkennen "proof-of-concept" ohne mit dem Spiel direkt zu interagieren/modifikationen durchzuführen. Das was ich hier mache verstößt nicht gegen deren EULA und sollte hier somit auch tolleriert werden!

[Medium]

Das Problem ist, dass der Weg vom Proof-of-Concept hin zum funktionsfähigen Aimbot dann fast nur noch eine Formalität ist. Und mal so unter uns: Warum den Aufwand betreiben, um es nachher als "heh, is ja interessant" in die Tonne zu kloppen?

Ich hatte früher mal einen "Fight-Advisor" für WoW geschrieben. Bestand aus einem (völlig zulässigen) In-Game Addon, dass mir Buffs und Debuffs sowie diverse Cooldowns in farbige Felder codiert am Bildrand angezeigt hat. Mit einem externen Programm habe ich dann kontinuierlich Screenshots gemacht, und eine Makro-Taste meiner Tastatur mit den jeweils optimalen Spell-Shortcuts belegt. Dadurch hatte ich ein One-Button-Moonkin, dass immer weit oben im Damage-Meter war bei unseren Raids. (Zu Burnig Crusade Zeiten wohlgemerkt, als Eulen noch als nutzlos galten. In Craftable und Karazhan Gear, während der Rest seit Wochen im Black Temple gefarmt hat. Genug generded.)
Ergo:
- Ingame Addon, dass nur die von Blizzard freigegebenen APIs benutzt hat, wie es die EULA vorschreibt
- Screengrabber, der theoretisch auch ein einfache Recording-Tool hätte sein können
- Echte Tastaturinputs durch meine menschlichen Finger
Ergebnins: 72h Ban nach ein paar Monaten der Nutzung. Obwohl ich "nichts falsch gemacht habe" (ha...ha...). Bedenke auch immer, dass ein Spielebetreiber auf seinen Servern Hausrecht genießt. Er hat das Recht dich jederzeit für wie lange auch immer auszuschließen, und müsste dafür nichtmals einen Grund angeben - geschweige denn sich an seine EULA halten. Sehr dünnes Eis.

[bernhard_LA]

aus Sicht der Bildverarbeitung wäre mein Ansatz :


über NCC / FastNCC kann ich Bilder in anderen Bildern erkennen :


https://sourceforge.net/projects/nccfastncc/


dh. BMP des ersten Kopfes als Vorlage Speichern und dann innerhalb Deines roten Rahmen suchen, bei > 70 % NCC Wert hast du vermutlich dann schon einen Treffer

[Luckie]

Es handelt sich aber um kein Verbrechen, was Strafrechtlich verfolgt wird. Deswegen sehe ich kein Problem hier eine Lösung zu diskutieren. Er wurde auf die möglichen Folgen hingewiesen, die aber letztendlich nur ihn persönlich betreffen.

Wer helfen kann und will, soll es tun, ansonsten bitte diese Diskussion in Klatsch und Tratsch fortsetzen.

[Pixel]

Zitat von bernhard_LA:

aus Sicht der Bildverarbeitung wäre mein Ansatz :


über NCC / FastNCC kann ich Bilder in anderen Bildern erkennen :


https://sourceforge.net/projects/nccfastncc/


dh. BMP des ersten Kopfes als Vorlage Speichern und dann innerhalb Deines roten Rahmen suchen, bei > 70 % NCC Wert hast du vermutlich dann schon einen Treffer

Ja hatte kurze Zeit überlegt openCV zu benutzen, problem ist aber, dass es 20 verschiedene Köpfe gibt, die skallierend von allen Blickwinkeln dann schwer zu erkennen wären..

Also fest steht Die Mitte der HP-Bar ist immer die Mitte des Kopfes, das heißt wenn man die Breite ermitteln könnte wäre die Sache schon getan, denn ich habe festgestellt:

Wenn Breite der HP-Bar >= 70 dann (Breite * 0.6) = ca. Y-Wert Mitte Kopf. Wenn < dann c.a. Y = 43.

Da die HP-Bar ja durchsichtig wird, habe ich den ersten Block der HP-Bar genommen und mit *8 multipliziert um die gesamte Breite zu erhalten. Das hat auch ganz gut funktioniert bis ich dann fesgestellt habe dass die Anzahl Balken ja auch variieren

Ich würde ja einfach versuchen von dem Namen der untendrunter ist die Mitte zu finden (ist ebenfalls Kopf-X-Wert) aber der Rotton variiert einfach sehr stark..

Und dann sieht man noch auf Bild 1a) dass der Kopf beim Laufen durchaus nicht Zentral des Namens liegen kann.

Daher wollte ich durch die Rote Linie das erkennen. Aber da hab ich echt keine Ahnung, denn die Rote Linie hat verschiedene Rottöne die vom Hintergrund beeinflusst werden und wenn man da im Programm dann eine hohe Tolleranz einsetzt hat man schnell falsche Punkte..

Was ich später mal versuche:

Da die Hp Bar ja immer einen Mindestabstand zum Kopf hat versuche ich später mal folgendes:
Ich suche nach den 3 Pixeln in der HP-Bar (die man ja immer findet) und suche dann 80? pixel unterhalb und 20 pixel nach rechts vertikal nach einem passenden Pixel. Von dem Pixel aus könnte ich dann die 8 Aneckenden Pixel scannen und davon müsste es ja mindestens 2 geben (links und Rechts davon). Da ich ja den linken Pixel der HP-Bar als Offset und dieses links neben dem Kopf sein muss kann ich dann ja auch mit Sicherheit sagen dass alle Pixel die von meinem neuen gefunden Pixel aus Rechts liegen zum Kopf führen. Anders gesagt: Ich versuche mal der Linie "zu folgen" und den höchsten Rotpunkt zu finden, oder so :3

Im Anhang noch zwei neue Bilder.

[Zacherl]

Muss die Erkennung wirklich rein visuell sein? Weiß nicht genau, inwiefern sowas vom rechtlichen Standpunkt her in Deutschland erlaubt ist, aber ich würde mir die Koordinaten der Spieler einfach aus dem Arbeitsspeicher des Spiels auslesen.

Andere (aber deutlich kompliziertere) Alternative:
Reverse das Netzwerkprotokoll, schalte deine eigene Anwendung als Proxy dazwischen und lese die Koordinaten einfach aus dem Daten-Stream aus. Das hatten wir damals bei einem bekannten Valve Spiel mal erfolgreich als PoC implementiert.

[Medium]

Zitat von Zacherl:

Muss die Erkennung wirklich rein visuell sein? Weiß nicht genau, inwiefern sowas vom rechtlichen Standpunkt her in Deutschland erlaubt ist, aber ich würde mir die Koordinaten der Spieler einfach aus dem Arbeitsspeicher des Spiels auslesen.

Andere (aber deutlich kompliziertere) Alternative:
Reverse das Netzwerkprotokoll, schalte deine eigene Anwendung als Proxy dazwischen und lese die Koordinaten einfach aus dem Daten-Stream aus. Das hatten wir damals bei einem bekannten Valve Spiel mal erfolgreich als PoC implementiert.

So wie ich Blizzard kenne, wird deren berühmt-berüchtigte Anti-Cheat Software "Warden" teil des Spiels sein. Und auf Gefummel im Prozessraum des Spiels reagiert dieser sofort. Rein rechtlich ist das wohl kein Problem, aber rein rechtlich ist es auch keines, wenn Blizzard dann einem die Nutzung ihrer Server untersagt.

[bitsetter]

Zitat:

Also fest steht Die Mitte der HP-Bar ist immer die Mitte des Kopfes, das heißt wenn man die Breite ermitteln könnte wäre die Sache schon getan, denn ich habe festgestellt:

Es sieht aber auf deinen letzten beiden Bildern so aus, als wenn sich die HP-Bar immer mittig vom Bildschirm befindet. Dann könnte man doch mit Hilfe das ersten linken Pixels der HP-Bar den letzten rechten Pixel und somit die Gesamtbreite berechen.

(rechter Pixel) = (Breite des Bildes) - (linker Pixel)

[hanvas]

Ich würde zunächst ein Array in den Dimensionen des Bildes anlegen, als Datentyp würde ich vermutlich Byte wählen, kann aber sein das Integer, wenn es auf Geschwindigkeit ankommt, ggf. besser wäre.

Anschließend würde ich an allen Positionen die im Bild der Suchfarbe entsprechen eine 1 im Array setzen, an allen anderen Positionen eine 0. Das Ergebnis bis hierhin ist praktisch Binärbild das die zu bearbeitenden Umrisse, die Buchstaben und die Paralellogramme des gesuchten Balkens enthalten.

Anschließend würde ich eine Liste der "verbundenen Komponenten" erstellen. Die nachfolgenden Prozeduren sollten nebenbei auch noch ein Labeling durchführen, das heißt jedem Umriss im erzeugten "Binärbild" eine andere Nummer, beginnend mit 2 zuordnen. Die erzeugte Liste enthält ein Objekt welches die Anzahl der zusammenhängenden Pixel speichert, das Rechteck für jeden Umriss das den Umriss gerade noch umschließt und das Label das mit dem Urisse in unseren Array korrospondiert.

Einfach mal so hingeschrieben, ungetestet, keine Garantie auf Korrektheit, beim dargestellten Problem (und s/w Bild) sollte die rekursive Version funktionieren.

Delphi-Quellcode:

const nr = YYYY; // Dimension in y
      nc = XXXX; // Dimension in x

type  TData : Array[0..nr,0..nc] of byte;     

      // Bitte selbst implementieren
      TObjectInfo = class(TObject) // oder record
      private
       FExtends : TRect;
       FLabel   : Integer;
       FSize    : Integer;
      public
       Constructor Create(aSize, aLabel : Integer; minX,minY,maxX,maxY : Integer );
      property
       Size : Integer
        read FSize;
      property
       R : TRect
         read FExtends 
      property 
       label : Integer
         read FLabel;
      end;

function  ConnectedArea ( var data : TData; y,x : Integer; Searched : Integer= 1; Visited: Integer = 2; var minX,minY,maxX,maxY ) : Integer;
var v : Integer;
begin
  if ( y< nr  ) and
     ( y >= 0 ) and
     ( x < nc ) and
     ( x >= 0 ) then
  begin
   v := Data[y,x];
   if (v=Searched) and // 
      (v<>visited) then
      begin
       if (minX>x) then 
           minX:= x;
       if (minY>y ) then
           minY:= y;
       if (maxX>x) then
           maxX := x;  
       if (maxY>y) then
           maxY := y; 
       result    := 1;
       Data[y,x] := visited;
       result    := result + ConnectedArea ( img, y+1, x  , Value, minx,miny,maxx,maxy );
       result    := result + ConnectedArea ( img, y+1, x+1, Value, minx,miny,maxx,maxy );
       result    := result + ConnectedArea ( img, y+1, x-1, Value, minx,miny,maxx,maxy );
       result    := result + ConnectedArea ( img, y-1, x  , Value, minx,miny,maxx,maxy );
       result    := result + ConnectedArea ( img, y-1, x-1, Value, minx,miny,maxx,maxy );
       result    := result + ConnectedArea ( img, y-1, x+1, Value, minx,miny,maxx,maxy );
       result    := result + ConnectedArea ( img, y  , x+1, Value, minx,miny,maxx,maxy );   
       result    := result + ConnectedArea ( img, y  , x-1, Value, minx,miny,maxx,maxy );
      end else
      result := 0;
  end else result := 0;
end;

function ListConnected
  ( var Data : TData; zx1, zy1, zx2, zy2 : Integer ) : TList;
var i,j          : Integer;
    a, cnt       : LongInt;    
    minx,miny,
    maxx,maxy    : Integer;
begin
 result := TList.Create;
 cnt    := 2;
 minx   := maxInt; 
 miny   := maxInt;
 maxx   := 0;
 maxy   := 0;
 for j  := zy1 to zy2 do
   for i := zx1 to zx2 do
     if ( Data[j,i] = 1 ) then
      begin
       cnt := cnt + 1;
       a := ConnectedArea ( Data, 1, cnt, j,i, minx,miny,maxx,maxy );       
       if ( a > NOISE ) then begin                                  
                               result.Add(TObjectInfo.Create(a,cnt,minx,miny,maxx,maxy);                   
                               minx   := maxInt; 
                               miny   := maxInt;
                               maxx   := 0;
                               maxy   := 0;              
                             end;              
      end;
end;

Wenn man sich deine Beispielbilder ansieht fällt auf das der von dir gesuchte Balken aus nebeneinanderliegenden Paralellogrammen besteht. Die Bilder sind für mich zu klein um erkennen zu können ob sich die Paralellogramme berühren, ich gehe mal von nein aus.

Die einander nicht berührenden Paralellogramme würden in der erzeugten Liste als jeweils eigene Objekte zu finden sein. Die y Koordinate der jeweiligen Grundlinien sollte gleich, oder durch Darstellungsfehler unter Umständen um ein Pixel nach oben oder unten verschoben sein. Die Rechtecke die die Ausmaße beschreiben müssen überlappen. Solange also mindestens zwei Paralellogramme existieren musst Du eigentlich nur nach überlappenden Objekten mit praktisch gleichen Dimensionen an unterschiedlichen X Positionen, aber (nahezu) gleichen Y Positionen suchen und das Rechteck bilden das alle Objekt die Du so findest einschließt.

[1] Wenn Du meine Prozedur von vertikal zuerst auf horizontal umstellst dann werden die Objekte sogar in der richtigen Reihenfolge erzeugt was das suchen und finden noch einfacher macht.

cu Ha-Jö