Added files via upload

Author: Code-Bullet

PoolAI/Ball.pde

@@ -0,0 +1,129 @@
+class Ball {
+
+  float radius = 10;
+  Body body;//the body representing the ball in the box2d world
+  boolean isWhite = false;
+  boolean stopped = true; //has the ball stopped or is it still moving
+  Box2DProcessing world;
+  boolean sunk = false;//whether the ball is sunk or not
+  color colour;//colour of the ball
+
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  //constructor
+  Ball(float x, float y, Box2DProcessing box2d, color col) {
+
+    colour = col;
+    world = box2d;
+    Vec2 pos = new Vec2(x, y);
+
+
+    float r = world.scalarPixelsToWorld(radius);//convert the radius to world coordinates
+
+    //CREATE BODY DEFINITION
+    BodyDef df = new BodyDef();
+    df.type = BodyType.DYNAMIC;
+    df.position.set(world.coordPixelsToWorld(pos.x, pos.y));
+
+    //APPPLY IT TO THE BODY
+    body = world.createBody(df);
+
+
+    //CREATE SHAPE AS CIRCLE
+    CircleShape circle = new CircleShape();
+    circle.setRadius(r);
+
+    //CREATE FIXTURE
+    FixtureDef fd = new FixtureDef();
+    fd.shape = circle;
+    fd.density = 0.0000001;//very low density
+    fd.friction = 0.001;//low friction
+    fd.restitution = 0.8;//high bounciness
+
+    //FIX THE SHAPE TO THE BODY;
+    body.createFixture(fd);
+  }
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  void applyFriction() {//called every step to simulate friction between the table and ball
+    Vec2 vel = body.getLinearVelocity(); 
+    vel.mulLocal(0.98);//slow by 2%
+    if (vel.length() < 4) {//increase friction when slower
+      vel.mulLocal(0.98);
+    }
+    if (vel.length() < 0.1) {//stop the ball if the speed is slow enough because without this the speed will never reach 0
+      vel.mulLocal(0);
+    }
+  }
+
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  //whether the ball is in a hole or not
+  boolean isInHole() {
+    if (sunk) {//if ball is already sunk then problem solved
+      return true;
+    }
+    Vec2 pos = world.getBodyPixelCoord(body);//get the position and if its within 15 of a holes center then it is sunk
+    for (int i =0; i < 6; i++) {
+      if (dist(pos.x, pos.y, tables[0].holes[i].pos.x, tables[0].holes[i].pos.y) < 15) {
+        Vec2 vel = body.getLinearVelocity(); 
+        vel.mulLocal(0);//set speed to 0
+        sunk = true;
+        world.destroyBody(body);//remove ball from world
+        return true;
+      }
+    }
+    return false;
+  }
+
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  boolean isStopped() {//is the ball stopped
+
+    if (body.getLinearVelocity().length() == 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  void update() {//update ball (kind of useless but I though I would do more than just apply friction each update)
+    applyFriction();
+  }
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  //draw a circle representing the ball
+  void show() {
+    if (!sunk) {//if sunk then dont bother showing it
+      Vec2 pos = world.getBodyPixelCoord(body); //get position
+
+      pushMatrix();
+      translate(pos.x, pos.y);
+      if (isWhite) {//choose colour
+        fill(255);
+      } else {
+        fill(colour);
+      }
+      noStroke();
+      ellipse(0, 0, 2*radius, 2*radius);//draw ball
+      popMatrix();
+    }
+  }
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  //simulates a shot
+  void applyForce(Vec2 force) {
+    Vec2 scaledForce = new Vec2(force.x, force.y);
+    scaledForce.mulLocal(500000);
+    body.applyForce(scaledForce, body.getWorldCenter());//apply force on ball
+  }
+
+  //---------------------------------------------------------------------------------------------------------------------------------------------------------------
+  //creates and returns a clone of this ball object in the parameter world
+  Ball clone(Box2DProcessing World) {
+
+    Vec2 pos = World.getBodyPixelCoord(body);//get pixel coord
+    Ball clone = new Ball(pos.x, pos.y, World, colour);
+
+    clone.isWhite = isWhite;
+    clone.sunk = sunk;
+    if (sunk) {//if the ball is sunk then remove the body from the world
+      World.destroyBody(clone.body);
+    }
+    return clone;
+  }
+}

PoolAI/Cushion.pde

@@ -0,0 +1,110 @@
+//an object containing all the cushions on the pool table
+class Cushions {
+  Body[] bodies = new Body[6];//the cushions
+  Box2DProcessing world;
+
+//------------------------------------------------------------------------------------------------------------------------------------------------------------------
+   //constructor
+  Cushions ( Box2DProcessing box2d) {
+
+    world = box2d;
+    
+    //Create left top cushion
+    createCushion(0, 200, 0, 20, 0, 385, 20, 380, 20, 50, 0);
+    //Create left bottom cushion
+    createCushion(0, 600, 0, 415, 0, 780, 20, 750, 20, 420, 1);
+    //create top
+    createCushion(200, 0, 20, 0, 50, 20, 350, 20, 380, 0, 2);
+    //right top
+    createCushion(200, 0, 400, 20, 380, 50, 380, 380, 400, 385, 3);
+    //right bottom
+    createCushion(200, 0, 400, 415, 380, 420, 380, 750, 400, 780, 4);
+    //bottom
+    createCushion(200, 0, 20, 800, 380, 800, 350, 780, 50, 780, 5);
+  }
+  
+//------------------------------------------------------------------------------------------------------------------------------------------------------------------  
+ //creates a cushion in the box2d world with input position and dimensions 
+  void createCushion(int posX, int posY, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int bodyNo) {
+    //CREATE BODY DEFITION
+    BodyDef bd = new BodyDef();
+    bd.type = BodyType.STATIC;//STATIC means that the body is fixed 
+    bd.position.set(world.coordPixelsToWorld(posX, posY));
+
+    //CREATE BODY
+    bodies[bodyNo] = world.createBody(bd);//add body to the array
+
+    //CREATE SHAPE 
+    //a polygon with 4 vertices 
+    PolygonShape ps = new PolygonShape();
+    Vec2[] vertices = new Vec2[4];
+    vertices[0] = world.vectorPixelsToWorld(new Vec2(x1-posX, y1-posY));
+    vertices[1] = world.vectorPixelsToWorld(new Vec2(x2-posX, y2-posY));
+    vertices[2] = world.vectorPixelsToWorld(new Vec2(x3-posX, y3-posY));
+    vertices[3] = world.vectorPixelsToWorld(new Vec2(x4-posX, y4-posY));
+
+    ps.set(vertices, vertices.length);
+    //CREATE FIXTURE
+    FixtureDef fd = new FixtureDef();
+    fd.shape = ps;
+    fd.density = 1;
+    fd.friction = 0.0001;
+    fd.restitution  = 0.9;//high restitution or bounciness 
+
+    //ATTACH FIXTURE TO BODY
+    bodies[bodyNo].createFixture(fd);
+  }
+//------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ //draw the cushions as polygons
+  void show() {
+    
+    fill(40);
+    //top left cushion
+    beginShape();
+      vertex(0, 20);
+      vertex(20, 50);
+      vertex(20, 380);
+      vertex(0, 385);
+    endShape(CLOSE);
+    
+    //bottom left
+    beginShape();
+      vertex(0, 415);
+      vertex(20, 420);
+      vertex(20, 750);
+      vertex(0, 780);
+    endShape(CLOSE);
+    
+    //upper cushion
+    beginShape();
+      vertex(20, 0);
+      vertex(380, 0);
+      vertex(350, 20);
+      vertex(50, 20);
+    endShape(CLOSE);
+
+    //top right
+    beginShape();
+      vertex(400, 20);
+      vertex(380, 50);
+      vertex(380, 380);
+      vertex(400, 385);
+    endShape(CLOSE);
+    
+    //bottom right
+    beginShape();
+      vertex(400, 415);
+      vertex(380, 420);
+      vertex(380, 750);
+      vertex(400, 780);
+    endShape(CLOSE);
+
+    //bottom
+    beginShape();
+      vertex(20, 800);
+      vertex(380, 800);
+      vertex(350, 780);
+      vertex(50, 780);
+    endShape(CLOSE);
+  }
+}

PoolAI/Genotype.pde

@@ -0,0 +1,55 @@
+class Genotype { //the encoded form of each players behaviour
+  Vec2[] shots;//each player can be represented by a vector array
+  //using Vec2s because thats what box2d uses
+
+  //-----------------------------------------------------------------------------------------------------------------------------
+  //constructor
+  Genotype() {
+    shots = new Vec2[1];//only starts with a single shot
+    randomize();//set all the shots as random vectors
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  //Mutation function for genetic algorithm
+  void mutate() {
+    int i = shots.length -1; //only mutate the very last shot
+    float mutationRate =0.8; //mutate 80% of the players
+
+    float rand = random(1);
+    if (rand<mutationRate) {//80% of the time mutate the player
+      if (rand<mutationRate/5) {
+        //20% of the time change the vector to a random vector
+        shots[i] = new Vec2(random(-1, 1), random(-1, 1));
+      } else {
+        //80% of the time rotate the vector a small amount
+        PVector temp = new  PVector(shots[i].x, shots[i].y);//convert to PVector because i don't know how to do this with Vec2s
+        temp.rotate(randomGaussian()/30);//rotate it 
+        shots[i] = new Vec2(temp.x, temp.y);//convert it back
+      }
+    }
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  //randomizes all vectors in shots
+  void randomize() {
+    for (int i = 0; i < shots.length; i++) {
+      shots[i] = new Vec2(random(-1, 1), random(-1, 1));
+    }
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+//returns a clone
+  Genotype clone() {
+    Genotype clone = new Genotype();
+    clone.shots = shots.clone();
+    return clone;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  //increases the number of shots by 1
+  void increaseShotLength() {
+    Vec2[] newShots = new Vec2[shots.length  +1];//create a new array which is one bigger than the current shots array
+    for (int i = 0; i < shots.length; i++) {//for each element of shots copy it into newShots
+      newShots[i] = new Vec2(shots[i].x, shots[i].y);
+    }
+    
+    newShots[shots.length] =  new Vec2(random(-1, 1), random(-1, 1));//randomise the last Vec2
+    shots = newShots.clone();//set shots as newShots
+  }
+}

PoolAI/Hole.pde

@@ -0,0 +1,17 @@
+class Hole {
+  Vec2 pos;
+  float radius = 30;
+
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  //constructor
+  Hole(int x, int y) {
+    pos = new Vec2(x, y);
+  }
+  //------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  //draw a black circle representing the hole
+  void show() {
+    fill(0);
+    stroke(0);
+    ellipse(pos.x, pos.y, radius, radius);
+  }
+}