Thread: Pinball bot

Originally Posted by Freaky Chris

Sounds interesting without reading memory you don't really have a choice but to pixel read, but thats not exactly easy and your algorithm must be pretty complex as it is.

Chris

Actually its not as fancy as it sounds, The game claims to be 3d, but isnt. There is a static color of the ball to scan for. The problem is scanning the rigth place at the right time.

Anyways here it is. Comments have just been thrown on there very fast, so bare with me.

import java.awt.AWTException;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;
 
//Class responsible of initializing and setting up the gui.
public class Driver {
 
	public static void main(String[] args) throws AWTException, IOException {
 
		JFrame frame = new JFrame("My Bot");
		JButton button1 = new JButton("Start The Bot");
		final int FIELD_WIDTH = 10;
		final JTextField textfield = new JTextField(FIELD_WIDTH);
 
		button1.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent event){
				textfield.setText("Bot Active");
				try {
					ThreadHandler.getNewThread().start();
				} catch (AWTException e) {
				}
			}
		});
 
		JButton button2 = new JButton("Stop The Bot");
 
		button2.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent event){
				ThreadHandler.getCurrentThread().interrupt();
				textfield.setText("Bot Idle");
			}
		});
 
		frame.setLayout(new FlowLayout());
		frame.add(button1);
		frame.add(button2) ;
		frame.add(textfield);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.pack();
		frame.setVisible(true);
 
	}
}

import java.awt.AWTException;
import java.awt.Color;
import java.awt.Robot;
import java.awt.event.KeyEvent;
 
//Main Class of the bot
public class PinballBotThread extends Thread {
 
	private Robot bot;
	//Color of a certain pixel ball, grayish
	private Color color = new Color(140,140,140);
	//The white that can be found on the ball. Only used for making the bot shoot
	//shoot of start position.
	private Color white = new Color(255,255,255);
	private int x1;
	private int x2;
	private int x3;
	private int x4;
	private int y;
    private int startPosX;
    private int startPosY;
 
	public PinballBotThread() throws AWTException{
		bot = new Robot();
		ScreenSetup ss = new ScreenSetup();
		x1 = ss.getX1();
		x2 = ss.getX2();
		x3 = ss.getX3();
		x4 = ss.getX4();
		y = ss.getY();
		startPosX = ss.getStartPosX();
		startPosY = ss.getStartPosY();
	}
 
	public void run() {
 
		//Main engine of the bot.
		//It takes advantage of fact that the graphics of the ball is static, and there
		//is a place of the ball where 6 adjecent pixels have the same color, Color(140,140,140);
		//It checks for a given color across a belt of pixels near paddles.
		//A lot of the programming could be more pretty, but for optimation purposes, as many
		//calculations as possible have been taken out of the loop, at the expense of clarity.
		try{
			while (true) {
				for (int x = x1; x < x2; x = x+6){
					if (bot.getPixelColor(x, y).equals(color)){
						bot.keyPress(KeyEvent.VK_Z);
						//makes the bot wait before executing more instructions. The game cannot handle
						//inhuman press/release times of keys, that the bot could deliver.
						bot.delay(200);
 
						bot.keyRelease(KeyEvent.VK_Z);
						bot.delay(200);
					}
				}
   	   			for (int j = x3; j < x4; j = j+6){
   	   				if (bot.getPixelColor(j, y).equals(color)){
   	   					bot.keyPress(KeyEvent.VK_QUOTE);
   	   					bot.delay(200);
 
   	   					bot.keyRelease(KeyEvent.VK_QUOTE);
   	   					bot.delay(200);
   	   				}
   	   			}
 
   	   			if (bot.getPixelColor(startPosX, startPosY).equals(white)){
   	   				bot.keyPress(KeyEvent.VK_SPACE);
   	   				bot.delay(2000);
   	   				bot.keyRelease(KeyEvent.VK_SPACE);
   	   				bot.delay(200);
   	   			}
   	   			Thread.sleep(1);
   				} 
			}catch (InterruptedException e){
   			}
	}
}

import java.awt.*;
//Class responsible for analyzing user screen resolution, and calculating which pixels need scanning.
public class ScreenSetup {
    private Toolkit toolkit =  Toolkit.getDefaultToolkit ();
    private Dimension dim = toolkit.getScreenSize();
    private int x1;
    private int x2;
    private int x3;
    private int x4;
    private int y;
    private int startPosX;
    private int startPosY;
 
    public ScreenSetup(){
    	x1 = dim.width / 2 - 150;
    	x2 = dim.width / 2 - 120;
    	x3 = dim.width / 2 - 114;
    	x4 = dim.width / 2 - 84;
    	y = dim.height / 2 + 175;
    	startPosX = dim.width / 2 + 23;
    	startPosY = dim.height / 2 + 165;
    }
 
    public int getX1(){
    	return x1;
    }
 
    public int getX2(){
    	return x2;
    }
 
    public int getX3(){
    	return x3;
    }
 
    public int getX4(){
    	return x4;
    }
 
    public int getY(){
    	return y;
    }
 
    public int getStartPosX(){
    	return startPosX;
    }
 
    public int getStartPosY(){
    	return startPosY;
    }
}

import java.awt.AWTException;
 
public class ThreadHandler {
	private static Thread thread;
 
	public static Thread getNewThread() throws AWTException{
		thread = new PinballBotThread();
		return thread;
	}
 
	public static Thread getCurrentThread(){
		return thread;
	}
}

To make it work:
Start the pinball game. Dont move it from its start position in the middle of the screen, or the pixel reading will go haywire.
Start a new game, let the ball be at the start position.
Start the Bot.
Give focus back to the pinball game.
Watch the bot fail, and laugh.

If you dont have the game, it should be out there for legal download, ill look for a link.