Erster Aimbot

[VastoStyles.]

Hallo liebe epvper Gemeinde,

wie ihr es sicherlich dem Titel entnehmen könnt, versuche ich mich daran, meinen ersten Aimbot zu schreiben. Da ich noch ein Anfänger in Sachen Java bin, habe ich auch den Aimbot fürs Erste einfach gehalten.

Was der Aimbot machen soll:

-Er soll an jedem 10. horiziontalen Pixel die Farbwerte auslesen

- Diese Farbwerte sollen in ein Array gespeichert werden

- Dieses Array soll wiederum in eine ArrayListe
(so das ich für ("Auflösung"/10) Farbwerte eine Liste mit diesen erstellt habe)

- Das Skript sucht nun wieder die Farbwerte in umgekehrter Richtung und soll diese ebenso in eine Arrayliste packen.

- Danach möchte ich überprüfen lassen ob ArrayListe1 ArrayListe2 entspricht
(mit anderen Worten, dass sich in dieser Zeit keine Pixel geändert haben).

- Danach soll wieder eine Schleife laufen, die die farbwerte ausließt.

- Sind diese werte ungleich von ArrayListe1 oder ArrayListe2, soll er auf diese Position klicken.


Mein Problem ist nun, dass:

- Ich nicht weiß, wie man die getPixelColor werte in ein Array speichert

- Ich nicht weiß, ob ich mit "liste.add(0, "FarbArray")" arbeiten kann, oder ob er nur integer Werte in die Liste packen kann

- Ich nicht weiß, ob eine Überprüfung von ArrayListe1 == ArrayListe2 möglich ist

Ich wäre super glücklich, wenn ihr mir helfen könntet !!!

package Robot;

import java.awt.AWTException;
import java.awt.Color;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;
import java.util.*;

public class Test {
	
	public static void main(String[] args) throws AWTException, InterruptedException {
		Robot robot = new Robot();
		Toolkit tk = Toolkit.getDefaultToolkit();
		int array[] = new color [x][y];                                              // <--- hier versuche ich vergeblich ein Arrayzu erzeugen :(
		int x=0;int y=0;int z=0;
		Thread.sleep(1500);
		Point mousePos = MouseInfo.getPointerInfo().getLocation();
		
		Thread.sleep(1500);
		
		long startTime = System.currentTimeMillis();
		int width = tk.getScreenSize().width;
		ArrayList<Integer> liste = new ArrayList<Integer>();					//starten einer Arrayliste
		for(int GrundSchleife=0; GrundSchleife<1; GrundSchleife++){				//Anzahl der Umgebungs überprüfungen
	
		
		for(int i = 0; i<width; i = i + 10) { 
//			robot.delay(100);
			robot.mouseMove(i,mousePos.y);
//			System.out.println(getPixelColor(mousePos.x, i, robot));
			array = getPixelColor(i,mousePos.y, robot);                    // <--hier sollen die Werte für das Array genommen werden
//			liste.add(i, robot); // speichert in arrayliste
			}
		
		for(int i= width; i>0; i = i - 10) { 
//			robot.delay(50);
			robot.mouseMove(i,mousePos.y);
//			System.out.println(getPixelColor(mousePos.x, i, robot));
			getPixelColor(i,mousePos.y, robot);
//			liste.add(i, robot); // speichert in arrayliste
		}
	}
		robot.mouseMove(mousePos.x,mousePos.y);									//Cusor an die ausgangsposition zurück
//		System.out.println(array);
//		System.out.println(liste.toString());									//Liste ausgeben
		long endTime = System.currentTimeMillis();
		
		System.out.println("Time needed: " + ((endTime - startTime)/1000f));
		
	}

	private static Color getPixelColor(int x, int y, Robot robot) {
		Color color = robot.getPixelColor(x, y);
		
		return color;		
	}
	
}

Kleiner Nachtrag:
die variable width werde ich beim fertigen Bot nicht abhängig von der Bildschirmbreite machen, sie wird variierbar sein und wird mit 2 mouse events festgelegt.

[Belur]

int array[] = new color [x][y];

Das wird nicht gehen.
Wenn du ein 2dimensionales Array erzeugen willst, dann musst du schreiben:

int[][] array = new color [x][y];

In deinem Programm würde das aber auch keinen Sinn machen, weil x und y noch garnicht definiert sind.
Außerdem müsste es ja heißen

color [][] array = new color[x][y]

Was möchtest du denn genau in der Liste speichern? Wenn du dir eine Liste vom Typ Integer erstellst, kannste natürlich nur Integer Objekte reinpacken.

Elemente in Arrays speicherst du mit der Angabe, wo du es speichern willst.
also:

array[index] = wert;

Glaube das mit dem Array hast du ein bisschen falsch interpretiert.

color[][] array = new color [x][y];

Das erzeugt dir ein Array mit den Dimension x und y. Und nicht ein Array, dass ein Colorobjekt an einer bestimmten x und y Koordinate speichert.

#edit:
Wenn du zwei Arrays mit "==" vergleichst, wird nur geprüft ob die Referenz gleich ist, also ob sie auf die gleiche Stelle im Speicher zeigen.
Wenn du die inhaltlich auf Gleichheit überprüfen willst gibts dafür eine Standardfunktion:

Arrays.equals(array1,array2)

Ich war eben essen, hab mir deinen Code jetzt nochmal genauer angeguckt.
Gibt da wohl ein paar mehr Probleme

array = getPixelColor(i,mousePos.y, robot);

Nehmen wir jetzt mal an das Array ist vom Typ Color und ist 1dimensional.
Also zB.

Color [] array = new Color[100];

getPixelColor liefert ein Color-Objekt als Rückgabewert. Das könntest du dann so in deinem Array speichern:

array[17]=getPixelColor(x, y, robot);

Wieso hast du dir überhaupt diese statische Methode gebaut.
Wäre doch viel einfacher gewesen das so zu machen:

array[17]=robot.getPixelColor(x, y);

So dann ein anderer Fehler:

liste.add(i, robot);

Deine Liste ist vom Typ Integer, also einen Robot reinstecken kannst du nicht.


Wenn ich das richtig verstanden habe, möchtest du die Farbe in einem bestimmten Punkt speichern.
Also in einem Speicherst du, x-Korrdinate, y-Koordinate und das Color-Objekt.

Dann würde ich mir eine eigene Klasse machen:

public class Koordinate {

	Point point = new Point(); 
	Color color;
	
	public Koordinate(Robot robot, int x, int y){
		this.point.x=x;
		this.point.y=y;
		this.color=robot.getPixelColor(x, y);
	}
	
}

Dann kannst deine Werte entweder in einer Liste vom Typ "Koordinate" oder in einem Array von dem Typ speichern.

[VastoStyles.]

Vielen Dank für die ausführliche Info ! Ich habe mich so schwer getan mit der erfassung des ColorArrays, dass meine Programmzeilen mittlerweile garkeinen Sinn mehr machen :P . Zunächst hatte ich auch ein zweidimensionalles Array[][]. Ich bekam dann aber einen out of bounds error .

Deine Lösung auf das Problem überfordert mich etwas :P Anders gesagt, weiß ich gerade nicht, wie ich den Code in meinen Quellcode richtig integriere. Ich habe mir noch nie eine eigene Klasse gemacht :P.

Wenn du mir allerdings noch ein bisschen dabei helfen könntest, wäre ich dir sehr verbunden. Ich arbeite momentan schon ein bisschen vor, da ich Anfang August mit einem Dualen Studium zum Anwendungsentwickler anfangen werde. Projektorientiertes Arbeiten möchte ich bis dato schonmal drauf haben und diesen "Aimbot" zu konstruieren und zu schauen wie Java arbeitet hilft mir dabei weiter

Edit:
Ja, dass mit den Arrays scheine ich falsch interpretiert zu haben. Ich dachte getpixelColor gibt mir RGB werte aus. Um diese zu speichern bräuchte ich ja drei Int variablen. Ich erinnerte mich, dass Arrays eine Kette von variablen sein können und dachte, dass ich die getPixelColor Werte so abspeichern könnte.

Achja jetzt kommt die blödeste Frage^^ Ich habe nun den code zu diesem abgeändert

package Robot;

import java.awt.AWTException;
import java.awt.Color;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;
import java.util.*;

public class Test {
	
	public static void main(String[] args) throws AWTException, InterruptedException {
		Robot robot = new Robot();
		Toolkit tk = Toolkit.getDefaultToolkit();
		Color[] array = new Color[100];
		int x=0;int y=0;int z=0;
		Thread.sleep(1500);
		Point mousePos = MouseInfo.getPointerInfo().getLocation();
		
		Thread.sleep(1500);
		
		long startTime = System.currentTimeMillis();
		int width = tk.getScreenSize().width;
		ArrayList<Integer> liste = new ArrayList<Integer>();					//starten einer Arrayliste
		for(int GrundSchleife=0; GrundSchleife<1; GrundSchleife++){				//Anzahl der Umgebungs überprüfungen
	
		
		for(int i = 0; i<width; i = i + 10) { 
//			robot.delay(100);
			robot.mouseMove(i,mousePos.y);
//			System.out.println(getPixelColor(mousePos.x, i, robot));
			array[17] = robot.getPixelColor(i,mousePos.y);
//			liste.add(i, robot); // speichert in arrayliste
			}
		
		for(int i= width; i>0; i = i - 10) { 
//			robot.delay(50);
			robot.mouseMove(i,mousePos.y);
//			System.out.println(getPixelColor(mousePos.x, i, robot));
			robot.getPixelColor(i,mousePos.y);
//			liste.add(i, robot); // speichert in arrayliste
		}
	}
		robot.mouseMove(mousePos.x,mousePos.y);									//Cusor an die ausgangsposition zurück
//		System.out.println(array);
//		System.out.println(liste.toString());									//Liste ausgeben
		long endTime = System.currentTimeMillis();
		
		System.out.println("Time needed: " + ((endTime - startTime)/1000f));
		
	}

	private static Color getPixelColor(int x, int y, Robot robot) {
		Color color = robot.getPixelColor(x, y);
		
		return color;		
	}
	
}

Tatsächlich, gibt er mir nun keine Fehler an 0.0 . Nur verstehe ich die Zahlen in new Color[100] und Array[17] nicht. Ich verstehe simpel gesagt immer noch nicht was diese Funktionen machen.

[Belur]

Also das du noch nie eine eigene Klasse gemacht hast stimmt ja nicht
Dein Quelltext ist ja auch eine eigene Klasse. Die haste ja "Test" genannt.

Wenn du jetzt also die Klasse Koordinate von mir kopiert hast, könntest du es so machen:

package test;

import java.awt.AWTException;
import java.awt.Color;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;
import java.util.ArrayList;

public class Test {

	public static void main(String[] args) throws AWTException,
			InterruptedException {
		Robot robot = new Robot();
		Toolkit tk = Toolkit.getDefaultToolkit(); 
		int x = 0;
		int y = 0;
		int z = 0;
		Thread.sleep(1500);
		Point mousePos = MouseInfo.getPointerInfo().getLocation();

		Thread.sleep(1500);

		long startTime = System.currentTimeMillis();
		int width = tk.getScreenSize().width;
		ArrayList<Koordinate> liste = new ArrayList<Koordinate>(); 
																
																
		for (int GrundSchleife = 0; GrundSchleife < 1; GrundSchleife++) { 

			for (int i = 0; i < width; i = i + 10) {
				// robot.delay(100);
				robot.mouseMove(i, mousePos.y);
				// System.out.println(getPixelColor(mousePos.x, i, robot));
				liste.add(new Koordinate(robot, mousePos.x, i));

			}

			for (int i = width; i > 0; i = i - 10) {
				// robot.delay(50);
				robot.mouseMove(i, mousePos.y);
				// System.out.println(getPixelColor(mousePos.x, i, robot));
				liste.add(new Koordinate(robot, i, mousePos.y));

			}
		}
		robot.mouseMove(mousePos.x, mousePos.y);
		// System.out.println(array);
		// System.out.println(liste.toString()); //Liste ausgeben
		long endTime = System.currentTimeMillis();

		System.out.println("Time needed: " + ((endTime - startTime) / 1000f));

	}

}

Hab jetzt nur deinen Code genommen und die Liste leicht angepasst.

ArrayList<Koordinate> liste = new ArrayList<Koordinate>();

und

liste.add(new Koordinate(robot, mousePos.x, i));
liste.add(new Koordinate(robot, i, mousePos.y));

sind die Änderungen, die ich gemacht habe.

Kann natürlich nichts testen etc, da ich nicht weiß für welches Spiel und so weiter. Warscheinlich musste das noch an deine Bedürfnisse anpassen


#edit:

Nur verstehe ich die Zahlen in new Color[100] und Array[17] nicht. Ich verstehe simpel gesagt immer noch nicht was diese Funktionen machen.

Ein Array ist ein Feld. mit "Color[] array = new Color[100]" erstelle ich mir ein Feld, mit 100 Einträgen. In diesen Feldern kannst du nur Color Objekte ablegen. Bzw Unterklassen davon.

Also:
[ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]...

Wenn du dir jetzt ein Color Objekt erstellt mit dem Namen "x" und schreibst:
array[17]=x;

dann sieht das so aus:

[ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][x][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]...

Du musst also immer den Index angeben, auf welchen zu zugreifen willst.


Bevor du einen Aimbot schreibst, solltest du dich vielleicht erst mit den elementaren Datenstrukturen befassen ;p


Der Code, den du jetzt hast hat keinen Fehler, das stimmt.
Aber er macht ja auch nicht richtiges. Du speicherst das Color Objekt in einem Array, speicherst aber nicht die dazugehörigen x und y-Werte.
Und die Sachen, die Fehler werfen würden sind auskommentiert

[VastoStyles.]

Vielen Dank du bist der Beste !!
Die neue Klasse habe ich denn einfach in einer separaten Datei, die im gleichen Verzeichnis liegt ?

[Belur]

Mit welcher Entwicklungsumgebung arbeitest du?

Bei so einem kleinen Projekt würd ich die einfach ins gleiche Package packen ja

[VastoStyles.]

Originally Posted by Belur

Mit welcher Entwicklungsumgebung arbeitest du?

Bei so einem kleinen Projekt würd ich die einfach ins gleiche Package packen ja

Mit JCreator. Btw: danke für die Erklärung der Arrays, jetzt ist mir ein Licht aufgegangen

[Belur]

Mit JCreator hab ich jetzt keine Erfahrung (benutze persönlich Eclipse), aber eine neue Klasse in deinem Package zu erstellen wird wohl kein Problem sein

Würde als Anfänger vllt doch mit etwas anderem Anfangen. Ein textbasiertes Hangman haben wir zB früher gemacht

[VastoStyles.]

Ich möchte dich ein wenig auf dem Laufenden halten Es funktioniert nun alles wie geplant das Skript ist soweit, das mann einen horiziontalen bereich des Desktops abgrenzen kann und der bot diesen Teil auf Pixelveränderungen abscannt. Dabei kann er feststellen, welche Pixel sich verändert haben und wie viele Pixel in Prozent sich im Gesammten verändert haben (eher unwichtig XD). Nun muss ich nur noch das Programm startklar machen (Hotkeys etc.). Das schaffe ich auch bestens alleine.
Vielen Dank nochmal für deine Hilfe !! In den nächsten Tagen werde ich das fertige script hier hochladen.

PS: Ich bin etwas geschafft weil ich bis gerade gearbeitet habe, also verzeih mir bitte die furchtbare Textstrucktur und die Rechtschreibfehler.

[Belur]

Freut mich. Ich bin gespannt

[VastoStyles.]

So....schuldigung, dass ich mich so lange nicht gemeldet habe, aber ich stecke momentan in den Abitur vorbereitungen.
Ich bin nun sogut wie fertig. Allerdings gibt es noch ein gravierendes Problem, von dem ich ehrlich gesagt keine Ahnung habe , die Performance.

Hier einmal das Hauptscript:

import java.awt.AWTException;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.awt.event.InputEvent;


public class PixelBot {
	
	private boolean debug = false;
	private boolean output = false;
	private boolean running;
	private int precision = 2;
	Koordinate ScannedPixel;

	
	private ArrayList<Koordinate> liste = new ArrayList<Koordinate>();
	private ArrayList<Koordinate> liste2 = new ArrayList<Koordinate>();
	private ArrayList<Koordinate> liste3 = new ArrayList<Koordinate>();
	private ArrayList<Koordinate> liste4 = new ArrayList<Koordinate>();
	
	private Point mousePos;
	private int width;
	private Robot robot;
	private Toolkit tk;

	public PixelBot(boolean debug, boolean output) {
		tk = Toolkit.getDefaultToolkit();
		width = tk.getScreenSize().width;
		width = 200;
		this.output = output;
		this.debug = debug;
		running = true;
		try {
			robot = new Robot();
		} catch (AWTException e) {
			e.printStackTrace();
			System.err.println("Fehler! " + e.toString());
		}
	}

	public void start() throws AWTException, InterruptedException {

		Thread.sleep(1500);

		Thread.sleep(1500);

		mousePos = MouseInfo.getPointerInfo().getLocation();

		if(areaIsUseable()) { // feststellen ob sich in dem Bereich etwas verändert
			System.out.println("Keine Veränderung");
			
		} else {
			System.out.println("Nicht geeignet aufgrund von Veränderung der Pixel");
			System.exit(0);
		}
		
		liste3 = getPixelList(); //Basisliste
		System.out.println("Bereit!");
		[B]while(running) {
			for (int x = 0 + mousePos.x; x < width + mousePos.x; x += precision) {
				robot.mouseMove(x, mousePos.y);
				for (int i = 0; i < liste3.size(); i += precision) {
						while (!liste3.get(i).color.equals(robot.getPixelColor(x,mousePos.y))) {
						//System.out.println("Unterschied!");
						 //Thread.sleep(50);
						// robot.mouseMove(mousePos.x +i, mousePos.y);
						 //Thread.sleep(50);
						//robot.mousePress(InputEvent.BUTTON1_MASK);
						 //robot.mouseRelease(InputEvent.BUTTON1_MASK);
						//Thread.sleep(2500);
						//robot.getPixelColor(x,mousePos.y);
					}
			}	
		//	System.out.println("Test erfolgreich!");
	}
}	
}	[/B]

	ArrayList<Koordinate> getPixelList() {
		ArrayList<Koordinate> liste = new ArrayList<Koordinate>();
		for (int i = 0 + mousePos.x; i < width + mousePos.x; i += precision) {
			// robot.delay(100);
			// robot.mouseMove(i, mousePos.y);
			// System.out.println(getPixelColor(mousePos.x, i, robot));
			liste.add(new Koordinate(robot.getPixelColor(i, mousePos.y),mousePos.y, i));
		} // 
		return liste;
	}
	
	private void printListe(ArrayList<Koordinate> liste) {

		for (Koordinate k : liste) {
			System.out.println(k.color + " " + k.point);
		}
			System.out.println(liste.size());
		
	}

	private void printListe(ArrayList<Koordinate> liste, ArrayList<Koordinate> liste2) {

		for (int i = 0; i < liste.size(); i++) {
			System.out.println(liste.get(i).color + " " + liste2.get(i).color);
		}
			System.out.println(liste.size());
	}
	
	private boolean listsAreSame(ArrayList<Koordinate> liste, ArrayList<Koordinate> liste2) {

		float gleich = 0;
		int unterschiedlich = 0;

		for (int i = 0; i < liste.size(); i++) {
			if (liste.get(i).color.equals(liste2.get(i).color)) {
				gleich++;
			} else
				unterschiedlich++;
		}
		if(output == true) {
		System.out.println("Größe: " + liste.size());
		System.out.println(gleich + " Gleiche und " + unterschiedlich
				+ " Unterschiedliche!");
		}
		
		float länge = liste.size();
		if (länge == gleich) {
//			alle Pixel gleich geblieben
			if(debug == true) {
				System.out.println("Gleich!");
			}
			return true;
		} else {
//			Pixel haben sich geändert
			if(output == true) {
				System.out.println(gleich / länge * 100f + "% sind gleich!");
			}
			return false;
		}
	}

	private boolean areaIsUseable() {

		for (int GrundSchleife = 0; GrundSchleife < 3; GrundSchleife++) {
			for (int i = 0 + mousePos.x; i < width + mousePos.x; i += precision) {
				// robot.delay(100);
				// robot.mouseMove(i, mousePos.y);
				// System.out.println(getPixelColor(mousePos.x, i, robot));
				liste.add(new Koordinate(robot.getPixelColor(i, mousePos.y),mousePos.y, i));
			} //1. For-Schleife
			// int i = width; i > 0; i = i - 10
			for (int i = 0 + mousePos.x; i < width + mousePos.x; i += precision) {
				// robot.delay(50);
				// robot.mouseMove(i, mousePos.y);
				// System.out.println(getPixelColor(mousePos.x, i, robot));
				liste2.add(new Koordinate(robot.getPixelColor(i, mousePos.y), mousePos.y,i));
			} // 2. For-Schleife

			if(debug == true) {
				printListe(liste, liste2);
			}
			
			if(listsAreSame(liste, liste2)) {
				
			} else {
				return false;
			}
			liste.clear();
			liste2.clear();
		}
		return true;
	}

}

Das Problem befindet sich in Zeile 65-83:

while(running) {
			for (int x = 0 + mousePos.x; x < width + mousePos.x; x += precision) {
				robot.mouseMove(x, mousePos.y);
				for (int i = 0; i < liste3.size(); i += precision) {
						while (!liste3.get(i).color.equals(robot.getPixelColor(x,mousePos.y))) {
						//System.out.println("Unterschied!");
						 //Thread.sleep(50);
						// robot.mouseMove(mousePos.x +i, mousePos.y);
						 //Thread.sleep(50);
						//robot.mousePress(InputEvent.BUTTON1_MASK);
						 //robot.mouseRelease(InputEvent.BUTTON1_MASK);
						//Thread.sleep(2500);
						//robot.getPixelColor(x,mousePos.y);
					}
			}	
		//	System.out.println("Test erfolgreich!");
	}
}	
}

Zur Verdeutlichung lasse ich die Maus beim scannen mal mitbewegen. Allerdings wird nur gut jede Sekunde ein Wert abgetastet. Kommentiert man aber die While-Schleife aus, bewegt sich die Maus in einer enormen Geschwindigkeit, die man mit dem Auge nicht einmal erfassen kann.

Die Frage ist nun, wie kann ich die Color-Werte abgleichen(wie in der While-Schleife) ohne aber zuviel Performance einzubußen?
Ich habe bereits an so etwas wie hyperthreading gedacht, bin aber zu unerfahren um es vernünftig umzusetzen.

Um das Ganze einmal zu Testen brauchst du noch die Beiden anderen Klassen:

import java.awt.Color;
import java.awt.Point;

public class Koordinate {
	Point point = new Point();
	Color color;

	public Koordinate(Color color, int y, int x) {
		this.point.x = x;
		this.point.y = y;
		this.color = color;
	}
}

import java.awt.AWTException;


public class Main {
	
	static PixelBot pixelBot;
	
	
	
	public static void main(String[] args) {
		boolean debug = false;
		boolean output = true;
		
		pixelBot = new PixelBot(debug, output);
		try {
			pixelBot.start();
		} catch (AWTException | InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

Btw. Eclipse ist wirklich viel besser, als das Programm, welches ich vorher nutzte

PS: Ich habe allerdings schon viel dazugelernt und bin offen gesagt ziemlich zufrieden mit mir
PPS: Ja ich weiß, Liste1 und Liste2 könnte ich auch einfach mit meiner getPixelList() Methode erstellen. Ich war bisher nur zu faul das abzuändern :P

[Belur]

Kannste mal etwas erläutern, wie das Aimbot überhaupt arbeiten soll?

Warum dürfen sich am Anfang keine Pixel verändern? Was wird gescannt, worauf soll die Maus bewegt werden. Einfach mal erklären wie du dir das vorgestellt hat, dann kann man den Code vllt auch etwas besser verstehen.

Vllt auch angeben für welches Spiel oÄ, dann kann ich auch mal etwas testen.

Hab noch ein paar Tage Semesterferien und mir ist eh mega langweilig ;p

[VastoStyles.]

Originally Posted by Belur

Kannste mal etwas erläutern, wie das Aimbot überhaupt arbeiten soll?

Warum dürfen sich am Anfang keine Pixel verändern? Was wird gescannt, worauf soll die Maus bewegt werden. Einfach mal erklären wie du dir das vorgestellt hat, dann kann man den Code vllt auch etwas besser verstehen.

Vllt auch angeben für welches Spiel oÄ, dann kann ich auch mal etwas testen.

Hab noch ein paar Tage Semesterferien und mir ist eh mega langweilig ;p

1. Die AreaIsUsable Methode brauche ich für den Fall, dass die Umgebung des Spiels nicht für den Bot geeignet ist. Beispielsweise würden Partikel vom Rauch oder ähnlichen den Bot verwirren. Wäre etwas beim scannen der Basisliste verändert, würden permanent veränderte Pixel gefunden werden :P

2. Nachdem die AreaIsUsable Methode durch ist und festgestellt wurde, das dieser Bildausschnit sich nicht verändert, wird eine Liste mit Hilfe von getPixelList angelegt. Diese Liste stellt sozusagen die Basiswerte der unveränderten Umgebung dar.

3. Nun soll der Bot die Color-Werte des Bildausschnittes mit den Basiseinträgen der Liste abgleichen. Hat sich beim scannen ein Pixel verändert gilt gescannterPixel(i) =! get.Liste(i). Hierbei geht er logischerweise Pixel für Pixel vor. Allerdings liegt hier das Problem, dass das einscannen des color-wertes und das abgleichen dieses Wertes mit dem Listeneintrag fast eine Sekunde dauert! Das ist VIEL zu langsam.

4. ist diese Bedingung erüllt, soll er die Maus zu der Position mousepos.x+i bewegen (also an die Stelle des veränderten Pixels) und auch einmal darauf klicken.

5. Um aus der whileschleife wieder herraus zu kommen, wird nocheinmal der Pixel an der Stelle i gescannt. Entspricht dieser nun wieder den basiswerten, werden wieder neue Pixel geprüft und mit den Listeneinträgen verglichen. Ist der Eintrag nach dem klick immernoch ungleich dem Listeneintrag, wird die while_schleie wiederholt.

Das Ganze sollte in jedem Spiel unktionieren, indem man nicht zu viele Partikeleffekte hat. Wenn man das Ganze in eine shooter nutzen wollte, wäre es ratsam, lediglich eine kleine Fläche zu überwachen, wie z.B ein Türbogen.
Natürlich dürfte man sich wärent der Bot läuft nicht bewegen. Ausserdem muss der Bot nach der while-Schleife auf die Ausgangs Position (mousePos.x/mousePos.y) zurückspringen, weil sich sonst alle Pixel nach einem abschuss verändern würden XDD

[Belur]

Es ist schwer deinen Code nachzuvollziehen, weil du viel auskommentiert hast.
Die innere while-Schleife ist zum Beispiel komplett auskommentiert und somit nutzlos.

Aber wenn ich das wieder einkommentiere, also:

while (!liste3.get(i).color.equals(robot.getPixelColor(x, mousePos.y))) {
						counter++;
						System.out.println("Unterschied "+ counter);
						Thread.sleep(50);
						robot.mouseMove(mousePos.x + i, mousePos.y);
						Thread.sleep(50);
						robot.mousePress(InputEvent.BUTTON1_MASK);
						robot.mouseRelease(InputEvent.BUTTON1_MASK);
						//Thread.sleep(2500);
						robot.getPixelColor(x, mousePos.y);
					}

mit einem neuen Attribut "counter", dann sieht man wie oft die Schleife durchgeht. In deinem Beispiel haste extrem lange Thread.sleep() drin.

Ich hab den Thread.sleep(2500) mal rausgenommen. Sehe nicht welche Operation da so unnormal lange dauern soll

[VastoStyles.]

Ohh sorry, ich hätte dir schreiben sollen, dass ich die Schleife auskommentiert habe um heraus zu finden, was denn so langsam läuft 0.0
Das Problem liegt allerdings nicht innerhalb der schleife.
kommentiert man den sleep.threat aus, läuft die while-schleife auch ziemlich oft durch.
Das Problem liegt in der Bedingung der Schleife:

while (!liste3.get(i).color.equals(robot.getPixelColor(x, mousePos.y)))

das dauert leider ewig. Die Frage ist nun, dauert das abgleichen der Colorwerte so lange ? Oder ist es das "robot.getPixelColor"? Oder sogar Beides?
Damit der Bot unktionsfähig ist, muss die übergeordnete for-Schleife:

for (int x = 0 + mousePos.x; x < width + mousePos.x; x += precision)

möglichst schnell durchlaufen.

Das Threat.sleep(2500) hab ich übrigen nur zu Testzwecken drinnen. Ansonsten wäre die Maus auf einem Pixel gefangen, ich hatte vorher das Problem, dass der Pixel sich nicht zum Basiswert zurückgeändert hat. Nichtmal der Taskmanager konnte helfen das Programm zu beenden XD