Multithreading working very well with 30k xp an hour

src/CameraCalibrator.java

@@ -7,9 +7,11 @@ import java.util.ArrayList;
 
 public class CameraCalibrator {
 	
+	int targetNumberOfDetectedObjects;
 	Robot robot;
 	
-	public CameraCalibrator() throws AWTException {
+	public CameraCalibrator(int targetNumberOfDetectedObjects) throws AWTException {
+		this.targetNumberOfDetectedObjects = targetNumberOfDetectedObjects;
 		robot = new Robot();
 	}
 	
@@ -18,7 +20,7 @@ public class CameraCalibrator {
 		
 		ArrayList<DetectedObject> detectedObjects = objectDetector.getObjectsInImage(screenCapture, 0.40);
 		ArrayList<DetectedObject> detectedObjectsToLookFor = objectDetector.getObjectsOfClassInList(detectedObjects, objectNameToLookFor);
-		while (detectedObjectsToLookFor.size() == 0) {
+		while (detectedObjectsToLookFor.size() < targetNumberOfDetectedObjects) {
 			randomlyRotateKeyboard();
 			screenCapture = objectDetector.captureScreenshotGameWindow();
 			detectedObjects = objectDetector.getObjectsInImage(screenCapture, 0.40);

src/Cursor.java

@@ -81,6 +81,7 @@ public class Cursor {
 	// END
 	
 	public void leftClickCursor() throws InterruptedException {
+		Thread.sleep(30, 55);
 		robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
 		Thread.sleep(getRandomClickLength());
 		robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);

src/CursorTask.java

@@ -54,7 +54,7 @@ public class CursorTask {
 		return clickedCoordinates;
 	}
 	
-	private Point leftClickDropOption(Cursor cursor, Point coordinatesToLeftClick, int column) throws Exception {
+	public Point leftClickDropOption(Cursor cursor, Point coordinatesToLeftClick, int column) throws Exception {
 		Point offsetCoordinatesToLeftClick = coordinatesToLeftClick;
 		if (column < 6) {
 			offsetCoordinatesToLeftClick.y += DROP_OFFSET;

src/DropperThread.java

@@ -1,20 +1,20 @@
+import java.awt.Point;
 import java.io.IOException;
 
 public class DropperThread implements Runnable {
 	Thread dropperThread;
-	Inventory inventory;
+	Point clickLocation;
 	Cursor cursor;
 	
-	public DropperThread(Inventory inventory, Cursor cursor) {
-		this.inventory = inventory;
+	public DropperThread(Point clickLocation, Cursor cursor) {
+		this.clickLocation = clickLocation;
 		this.cursor = cursor;
 	}
 	
 	@Override
 	public void run() {
 		try {
-			//inventory.update();
-			cursor.moveAndRightlickAtCoordinatesWithRandomness(inventory.getClickCoordinatesForInventorySlot(0, 0), 15, 15);
+			cursor.moveAndRightlickAtCoordinatesWithRandomness(clickLocation, 15, 15);
 		} catch (IOException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();

src/Inventory.java

@@ -44,6 +44,21 @@ public class Inventory {
 		updateAllInventorySlots(image);
 	}
 	
+	public int getFirstIronOreInInventory() throws IOException {
+		BufferedImage image = robot.createScreenCapture(this.inventoryRectangleToCapture);
+		for (int row = 0; row < Constants.INVENTORY_NUM_ROWS; row++) {
+			for (int column = 0; column < Constants.INVENTORY_NUM_COLUMNS; column++) {
+				inventorySlots[row][column].updateInventorySlot(image);
+				if (!inventorySlots[row][column].isInventorySlotEmpty(items)) {
+					//System.out.println("Not empty!");
+					System.out.println("Returning " + (row * 7 + column));
+					return (row * 7 + column);
+				}
+			}
+		}
+		return -1;
+	}
+	
 	public void updateLastSlot() throws IOException {
 		BufferedImage image = robot.createScreenCapture(this.inventoryRectangleToCapture);
 		updateLastInventorySlot(image);

src/IronMiner.java

@@ -35,108 +35,84 @@ public class IronMiner {
 	CameraCalibrator cameraCalibrator;
 	RandomDetector randomDetector;
 	WorldHopper worldHopper;
+	ObjectDetectionHistory objectDetectionHistory;
 	
 	public IronMiner() throws AWTException, IOException 
 	{
+		int targetNumberOfDetectedOres = 2;
 		cursor = new Cursor();
 		cursorTask = new CursorTask();
 		inventory = new Inventory();
 		objectDetector = new ObjectDetector();
 		robot = new Robot();
 		humanBehavior = new HumanBehavior();
-		cameraCalibrator = new CameraCalibrator();
 		randomDetector = new RandomDetector();
+		worldHopper = new WorldHopper();
+		cameraCalibrator = new CameraCalibrator(targetNumberOfDetectedOres);
+		objectDetectionHistory = new ObjectDetectionHistory(targetNumberOfDetectedOres);
 	}
 	
 	public void run() throws Exception {
 		long startTime = System.currentTimeMillis();
-		int noIronOresDetected = 0;
 		
 		int count = 0;
-		while (((System.currentTimeMillis() - startTime) / 1000.0 / 75) < 37) {
-			count++;
+		while (((System.currentTimeMillis() - startTime) / 1000.0 / 75) < 85) {
 			BufferedImage screenCapture = objectDetector.captureScreenshotGameWindow();
 			
 			ArrayList<DetectedObject> detectedObjects = objectDetector.getObjectsInImage(screenCapture, 0.30);
 			ArrayList<DetectedObject> ironOres = objectDetector.getIronOres(detectedObjects);
 			
-			if (ironOres.size() == 0) {
-				noIronOresDetected++;
-			}
-			else {
-				noIronOresDetected = 0;
-			}
-			if (noIronOresDetected > 80) {
-				cameraCalibrator.rotateUntilObjectFound(objectDetector, "ironOre");
-			}
+			readjustCameraIfObjectsAreNotBeingDetected(detectedObjects.size());
 			
 			DetectedObject closestIronOre = getClosestObjectToCharacter(ironOres);
 			
 			if (closestIronOre != null) {
 				cursor.moveAndLeftClickAtCoordinatesWithRandomness(closestIronOre.getCenterForClicking(), 10, 10);
 				
-				System.out.println("Starting threads!");
-				TrackerThread trackerThread = new TrackerThread(screenCapture, closestIronOre, objectDetector);
-				trackerThread.start();
-				DropperThread dropperThread = new DropperThread(inventory, cursor);
-				dropperThread.start();
+				int ironOreInInventory = inventory.getFirstIronOreInInventory();
 				
-				trackerThread.waitTillDone();
-				dropperThread.waitTillDone();
-								
-				System.out.println("Both threads finished?");
+				if (ironOreInInventory > -1) {
+					int ironOreInInventoryColumn = ironOreInInventory % 7;
+					int ironOreInInventoryRow = ironOreInInventory / 7;
+				
+					Point clickLocation = inventory.getClickCoordinatesForInventorySlot(ironOreInInventoryRow, ironOreInInventoryColumn);
+				
+					TrackerThread trackerThread = new TrackerThread(screenCapture, closestIronOre, objectDetector);
+					trackerThread.start();
+				
+					DropperThread dropperThread = new DropperThread(clickLocation, cursor);
+					dropperThread.start();
+				
+					trackerThread.waitTillDone();
+					dropperThread.waitTillDone();
+					
+					Point rightClickLocation = cursor.getCurrentCursorPoint();
+					cursorTask.leftClickDropOption(cursor, rightClickLocation, 0);
+				}
+				else {
+					TrackerThread trackerThread = new TrackerThread(screenCapture, closestIronOre, objectDetector);
+					trackerThread.start();
+					trackerThread.waitTillDone();
+				}
+				count++;
+				//System.out.println(count + ", time: " + ((System.currentTimeMillis() - startTime) / 1000 / 60));
 			}
-			if (count % 30 == 0) {
-				System.out.println("WAITING #############################################");
-				Thread.sleep(5000);
-			}
-			//humanBehavior.randomlyCheckMiningXP(cursor);
-			//randomDetector.dealWithRandoms(screenCapture, cursor);
-			//dropInventoryIfFull();
+			humanBehavior.randomlyCheckMiningXP(cursor);
+			randomDetector.dealWithRandoms(screenCapture, cursor);
+			dropInventoryIfFull();
 		}
 	}
+
 	
-	/*private void dropOre() throws Exception {
-		inventory.update();
-		System.out.println("Thread 1 [mouse hover] finished!");
-		//cursorTask.dropOre(cursor, inventory);
-	}*/
-	
-	/*private void trackOre(DetectedObject closestIronOre, BufferedImage screenCapture) throws Exception {
-		Rect2d boundingBox = closestIronOre.getBoundingRect2d();
-		ObjectTracker ironOreTracker = new ObjectTracker(screenCapture, boundingBox);
-		
-		long miningStartTime = System.currentTimeMillis();
-		int maxTimeToMine = Randomizer.nextGaussianWithinRange(3400, 4519);
-		
-		boolean objectTrackingFailure = false;
-		boolean oreAvailable = true;
-		int oreLostCount = 0;
-		while (!objectTrackingFailure && oreLostCount < 3 && !isTimeElapsedOverLimit(miningStartTime, maxTimeToMine)) {
-			BufferedImage screenCapture2 = objectDetector.captureScreenshotGameWindow();
-			ArrayList<DetectedObject> detectedObjects = objectDetector.getObjectsInImage(screenCapture2, 0.15);
-			ArrayList<DetectedObject> ironOres = objectDetector.getObjectsOfClassInList(detectedObjects, "ironOre");
-			objectTrackingFailure = ironOreTracker.update(screenCapture, boundingBox);
-			oreAvailable = objectDetector.isObjectPresentInBoundingBoxInImage(ironOres, boundingBox, "ironOre");
-			if (!oreAvailable) {
-				oreLostCount++;
-			}
-			else {
-				oreLostCount = 0;
-			}
+	private void readjustCameraIfObjectsAreNotBeingDetected(int detectedObjectsSize) throws Exception {
+		boolean readjustCamera = objectDetectionHistory.updateHistory(detectedObjectsSize);
+		if (readjustCamera) {
+			cameraCalibrator.rotateUntilObjectFound(objectDetector, "ironOre");
+			objectDetectionHistory.resetQueue();
 		}
-		System.out.println("Thread 2 [track ore] finished!");
-	}*/
-	
-	/*private void dropOre() throws IOException {
-		inventory.update();
-		if (inventory.containsItem("ironOre")) {
-			cursor.moveAndRightlickAtCoordinatesWithRandomness(inventory.getClickCoordinatesForInventorySlot(0, 0), 15, 15);
-			// move cursor down 40 pixels
-			cursor.moveAndLeftClickAtCoordinatesWithRandomness(goalPoint, 20, 5);
-		}
-	}*/
-	
+		
+	}
+
 	private void dropInventoryIfFull() throws Exception {
 		inventory.updateLastSlot();
 		if (inventory.isLastSlotInInventoryFull()) {
@@ -144,10 +120,7 @@ public class IronMiner {
 			Thread.sleep(Randomizer.nextGaussianWithinRange(1104, 1651));
 		}
 	}
-	
-	private boolean isTimeElapsedOverLimit(long startTime, int timeLimit) {
-		return (System.currentTimeMillis() - startTime) > timeLimit;
-	}
+
 	
 	private DetectedObject getClosestObjectToCharacter(ArrayList<DetectedObject> detectedObjects) {
 		int closestDistanceToCharacter = Integer.MAX_VALUE;

src/ObjectDetectionHistory.java

@@ -0,0 +1,53 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class ObjectDetectionHistory {
+
+	int queueSize;
+	int targetNumberOfDetectedObjects;
+	int numberOfTruesInQueue;
+	Queue<Boolean> numberOfDetectedObjectsHistory;
+	
+	public ObjectDetectionHistory(int targetNumberOfDetectedObjects) {
+		queueSize = 150;
+		this.targetNumberOfDetectedObjects = targetNumberOfDetectedObjects;
+		this.numberOfTruesInQueue = queueSize;
+		numberOfDetectedObjectsHistory = new LinkedList<Boolean>();
+		for (int i = 0; i < queueSize; i++) {
+			numberOfDetectedObjectsHistory.add(true);
+		}
+	}
+	
+	public boolean updateHistory(int numberOfDetectedObjects) {
+		updateHistory(numberOfDetectedObjects >= targetNumberOfDetectedObjects);
+		return isObjectDetectionUnsuccessful();
+	}
+	
+	public void updateHistory(boolean success) {
+		System.out.println("Increasing? " + success);
+		numberOfDetectedObjectsHistory.add(success);
+		if (success) { 
+			numberOfTruesInQueue++;
+		}
+		if (numberOfDetectedObjectsHistory.poll()) {
+			numberOfTruesInQueue--;
+		}
+	}
+	
+	private boolean isObjectDetectionUnsuccessful() {
+		return numberOfTruesInQueue < (queueSize * 0.6);
+	}
+	
+	public void resetQueue() {
+		this.numberOfTruesInQueue = queueSize;
+		numberOfDetectedObjectsHistory.clear();
+		for (int i = 0; i < queueSize; i++) {
+			numberOfDetectedObjectsHistory.add(true);
+		}
+	}
+	
+	public void displayStats() {
+		System.out.println("Object detection rate: " + (numberOfTruesInQueue * 1.0 / queueSize));
+	}
+}

src/TrackerThread.java

@@ -43,7 +43,7 @@ public class TrackerThread implements Runnable {
 				else {
 					oreLostCount = 0;
 				}
-				System.out.println("Threaded tracker took " + (System.currentTimeMillis() - frameStartTime) + " milliseconds.");
+				//System.out.println("Threaded tracker took " + (System.currentTimeMillis() - frameStartTime) + " milliseconds.");
 				//System.out.println("trackerThread working...");
 			}
 		} catch (IOException e) {
@@ -57,7 +57,7 @@ public class TrackerThread implements Runnable {
 			e.printStackTrace();
 		}
 		
-		System.out.println("~~~~~~~~~~~~~ trackerThread finished!");
+		//System.out.println("~~~~~~~~~~~~~ trackerThread finished!");
 	}
 	
 	private boolean isTimeElapsedOverLimit(long startTime, int timeLimit) {

src/WorldHopper.java

@@ -5,42 +5,32 @@ import java.util.Queue;
 public class WorldHopper {
 
 	int numberOfOresMined;
-	int numberOfFramesWithOtherPlayers;
-	Queue<Boolean> frames;
+	int queueSize;
+	//int numberOfFramesWithOtherPlayers;
+	//Queue<Boolean> frames;
 	Queue<Boolean> oresMined;
 	
 	public WorldHopper() {
 		numberOfOresMined = 0;
-		numberOfFramesWithOtherPlayers = 0;
-		frames = new LinkedList<Boolean>();
-		for (int i = 0; i < 600; i++) {
+		queueSize = 30;
+		//numberOfFramesWithOtherPlayers = 0;
+		//frames = new LinkedList<Boolean>();
+		/*for (int i = 0; i < 600; i++) {
 			frames.add(false);
-		}
+		}*/
 		oresMined = new LinkedList<Boolean>();
-		for (int i = 0; i < 30; i++) {
+		for (int i = 0; i < queueSize; i++) {
 			oresMined.add(true);
 		}
 	}
 	
-	public void hopWorldsIfOtherPlayersPresent(ArrayList<DetectedObject> players) {
-		updateOtherPlayerTracking(players);
+	public void hopWorldsIfMiningRateLow() {
+		updateOresMinedSuccessTracking();
 		if (areOtherPlayersLikelyPresent()) {
 			hopWorld();
 		}
 	}
 	
-	private void updateOtherPlayerTracking(ArrayList<DetectedObject> players) {
-		if (players.size() > 1) {
-			numberOfFramesWithOtherPlayers++;
-			frames.add(true);
-		}
-		else {
-			frames.add(false);
-		}
-		if (frames.poll()) {
-			numberOfFramesWithOtherPlayers--;
-		}
-	}
 	
 	public void updateOresMinedSuccessTracking(boolean success) {
 		oresMined.add(success);
@@ -53,7 +43,7 @@ public class WorldHopper {
 	}
 	
 	private boolean areOtherPlayersLikelyPresent() {
-		return numberOfFramesWithOtherPlayers > 360 || numberOfOresMined < 18;
+		return  numberOfOresMined < (queueSize * 0.6);
 	}
 	
 	private void hopWorld() {