init

Author: RugbugRedfern

.gitignore

@@ -0,0 +1 @@
+*.class

BoxCollider.java

@@ -0,0 +1,138 @@
+import java.awt.*;
+
+public class BoxCollider extends Collider
+{
+	// amount to overshoot for determining the collision direction
+	final int DIRECTION_FORGIVENESS = 2;
+
+	double width;
+	double height;
+	double degrees;
+	
+	// local points
+	Point localTL;
+	Point localTR;
+	Point localBL;
+	Point localBR;
+
+	// create a new box collider
+	public BoxCollider(double x, double y, double width, double height, double degrees)
+	{
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		this.degrees = degrees;
+		
+		calculateBounds();
+	}
+
+	// calculate the local points for each vertex
+	public void calculateBounds()
+	{
+		localTL = PointMath.transformPoint(x, y, (x - width / 2), (y + height / 2), degrees);
+		localTR = PointMath.transformPoint(x, y, (x + width / 2), (y + height / 2), degrees);
+		localBL = PointMath.transformPoint(x, y, (x - width / 2), (y - height / 2), degrees);
+		localBR = PointMath.transformPoint(x, y, (x + width / 2), (y - height / 2), degrees);
+	}
+
+	// draw the box collider on the screen
+	public void draw(Graphics g)
+	{
+		g.drawLine(localTL.getIntX(), localTL.getIntY(), localTR.getIntX(), localTR.getIntY());
+		g.drawLine(localTR.getIntX(), localTR.getIntY(), localBR.getIntX(), localBR.getIntY());
+		g.drawLine(localBR.getIntX(), localBR.getIntY(), localBL.getIntX(), localBL.getIntY());
+		g.drawLine(localBL.getIntX(), localBL.getIntY(), localTL.getIntX(), localTL.getIntY());
+	}
+	
+	// returns whether or not a point exists inside the collider bounds
+	public boolean intersect(double x, double y)
+	{
+		Point localPoint = worldToLocal(x, y);
+		return localPoint.x < this.x + width / 2 &&
+			localPoint.x > this.x - width / 2 &&
+			localPoint.y < this.y + height / 2 &&
+			localPoint.y > this.y - height / 2;
+	}
+	
+	// this means a node has collided with the collider, so now we have to rebound it,
+	// basically bouncing it off of the surface of this collider
+	@Override
+	public void rebound(Node node)
+	{
+		if(listener != null)
+		{
+			listener.onCollisionTriggered(this, node);
+			return;
+		}
+
+		// convert the node's position and oldPosition from world space
+		// to local space, which will make calculations easier
+		Point pos = worldToLocal(node.x, node.y);
+		Point oldPos = worldToLocal(node.oldX, node.oldY);
+		
+		double velX = pos.x - oldPos.x;
+		double velY = pos.y - oldPos.y;
+		
+		// if it's rebounding, it means the node has intersected THIS TICK.
+		// meaning the old position will still be outside this collider.
+		// therefore, we can use the old position to check which direction it entered from.
+		
+		// calculate the bounds of this collider
+		double top = this.y - height / 2;
+		double bottom = this.y + height / 2;
+		double left = this.x - width / 2;
+		double right = this.x + width / 2;
+		
+		// store the position variables to modify later
+		double newX = pos.x;
+		double newY = pos.y;
+		
+		double newOldX = oldPos.x;
+		double newOldY = oldPos.y;
+		
+		// check all potential collision directions, and apply force as needed to rebound the node
+		if(oldPos.y > bottom - DIRECTION_FORGIVENESS) // below
+		{
+			newY = bottom;
+			newOldY = bottom + velY * Simulation.COLLISION_DAMP;
+		}
+		else if(oldPos.y < top + DIRECTION_FORGIVENESS) // above
+		{
+			newY = top;
+			newOldY = top + velY * Simulation.COLLISION_DAMP;
+		}
+		else if(oldPos.x > right - DIRECTION_FORGIVENESS) // right
+		{
+			newX = right;
+			newOldX = right + velX * Simulation.COLLISION_DAMP;
+		}
+		else if(oldPos.x < left + DIRECTION_FORGIVENESS) // left
+		{
+			newX = left;
+			newOldX = left + velX * Simulation.COLLISION_DAMP;
+		}
+		
+		// convert positions from local space to world space so we can apply them to the node
+		Point newPos = localToWorld(newX, newY);
+		Point newOldPos = localToWorld(newOldX, newOldY);
+
+		// apply the new positions to the node
+		node.x = newPos.x;
+		node.y = newPos.y;
+		node.oldX = newOldPos.x;
+		node.oldY = newOldPos.y;
+	}
+	
+	// convert a point from world to local space
+	Point worldToLocal(double x, double y)
+	{
+		return PointMath.transformPoint(this.x, this.y, x, y, -degrees);
+	}
+	
+	// convert a point from local to world space
+	Point localToWorld(double x, double y)
+	{
+		return PointMath.transformPoint(this.x, this.y, x, y, degrees);
+	}
+}

CircleCollider.java

@@ -0,0 +1,75 @@
+import java.awt.*;
+
+public class CircleCollider extends Collider
+{
+	int radius;
+
+	// create a new circle collider
+	public CircleCollider(double x, double y, int radius)
+	{
+		this.x = x;
+		this.y = y;
+		this.radius = radius;
+	}
+
+	// draw the box collider on the screen
+	public void draw(Graphics g)
+	{
+		g.setColor(Color.BLUE);
+		g.drawOval(getIntX() - radius, getIntY() - radius, radius * 2, radius * 2);
+		g.fillOval(getIntX() - 2, getIntY() - 2, 4, 4);
+	}
+	
+	// returns whether or not a point exists inside the collider bounds
+	public boolean intersect(double x, double y)
+	{
+		return PointMath.distance(this.x, this.y, x, y) <= radius;
+	}
+	
+	// this means a node has collided with the collider, so now we have to rebound it,
+	// basically bouncing it off of the surface of this collider
+	@Override
+	public void rebound(Node node)
+	{
+		if(listener != null)
+		{
+			listener.onCollisionTriggered(this, node);
+			return;
+		}
+		
+		// get the direction the node is coming from
+		double dirX = node.x - x;
+		double dirY = node.y - y;
+		
+		// get the velocityu of the node
+		double velX = node.x - node.oldX;
+		double velY = node.y - node.oldY;
+		
+		// get the magnitude of the velocity
+		double velocityMagnitude = PointMath.magnitude(velX, velY);
+		
+		// get the magnitude of the direction (which in this case is just the distance to the node)
+		double magnitude = PointMath.magnitude(dirX, dirY);
+
+		// normalize the x and y of the distance to the node, which gives us a direction vector
+		double normalizedX = dirX / magnitude;
+		double normalizedY = dirY / magnitude;
+		
+		// move the node to the edge of the collider based on the direction vector
+		double pushedX = normalizedX * radius;
+		double pushedY = normalizedY * radius;
+		
+		// add force to the node by setting the old position further towards the center of
+		// the collider depending on the node's current velocity. this essentially inverts the
+		// velocity of the node (while taking some for collision dampening)
+		double pushedOldX = normalizedX * (radius - velocityMagnitude * Simulation.COLLISION_DAMP);
+		double pushedOldY = normalizedY * (radius - velocityMagnitude * Simulation.COLLISION_DAMP);
+		
+		// apply the new positions
+		node.x = x + pushedX;
+		node.y = y + pushedY;
+		
+		node.oldX = x + pushedOldX;
+		node.oldY = y + pushedOldY;
+	}
+}

Collider.java

@@ -0,0 +1,37 @@
+import java.awt.*;
+
+public abstract class Collider
+{
+	// the position of the collider
+	public double x;
+	public double y;
+
+	// returns whether or not a point exists inside the collider bounds
+	abstract boolean intersect(double x, double y);
+
+	// draw the box collider on the screen
+	abstract void draw(Graphics g);
+
+	// this means a node has collided with the collider, so now we have to rebound it,
+	// basically bouncing it off of the surface of this collider
+	abstract void rebound(Node node);
+
+	// get a rounded version of the x
+	public int getIntX()
+	{
+		return (int)Math.round(x);
+	}
+
+	// get a rounded version of the y
+	public int getIntY()
+	{
+		return (int)Math.round(y);
+	}
+
+	CollisionTriggerListener listener;
+
+	public void addTriggerListener(CollisionTriggerListener listener)
+	{
+		this.listener = listener;
+	}
+}

CollisionTriggerListener.java

@@ -0,0 +1,4 @@
+public interface CollisionTriggerListener
+{
+	public void onCollisionTriggered(Collider col, Node node);
+}

Constraint.java

@@ -0,0 +1,44 @@
+import java.awt.*;
+
+public class Constraint
+{
+	// the nodes that the constraint is attached to
+	public Node nodeA;
+	public Node nodeB;
+
+	// the initial length of the constraint
+	public double length;
+	
+	// create a new constraint
+	public Constraint(Node a, Node b)
+	{
+		this.nodeA = a;
+		this.nodeB = b;
+		
+		// initialize the length to the distance between the nodes
+		length = PointMath.distance(a.x, a.y, b.x, b.y);
+	}
+
+	// draw the constraint on the screen
+	public void draw(Graphics g)
+	{
+		g.drawLine((int)Math.round(nodeA.x), (int)Math.round(nodeA.y), (int)Math.round(nodeB.x), (int)Math.round(nodeB.y));
+	}
+	
+	// Get a color corresponding to a stress percentage (0-1)
+	/*Color getStressColor(double percent)
+	{
+		double inversePercent = 1 - percent;
+		
+		Color a = Color.RED;
+		Color b = Color.GREEN;
+		
+		double red = a.getRed() * percent + b.getRed() * inversePercent;
+		double green = a.getGreen() * percent + b.getGreen() * inversePercent;
+		double blue = a.getBlue() * percent + b.getBlue() * inversePercent;
+		
+		Color result = new Color((int)Math.round(red), (int)Math.round(green), (int)Math.round(blue));
+		
+		return result;
+	}*/
+}

Game.java

@@ -0,0 +1,59 @@
+import java.util.*;
+
+public class Game extends Simulation implements CollisionTriggerListener
+{
+	static final int WIDTH = 1500;
+	static final int HEIGHT = 750;
+
+	public static void main(String[] args) throws InterruptedException
+	{
+		Game app = new Game();
+	}
+
+	public Game() throws InterruptedException
+	{
+		super(WIDTH, HEIGHT);
+
+		Random random = new Random();
+
+		for(int x = 100; x < WIDTH - 100; x += 1)
+		{
+			Node node = new Node(x + randomInt(random, -10, 10), 100 + randomInt(random, -90, 0));
+			nodes.add(node);
+		}
+
+		for(int x = 0; x < WIDTH; x += 25)
+		{
+			for(int y = 200; y < HEIGHT - 100; y += 25)
+			{
+				Collider col = new CircleCollider(x + (y % 2 == 0 ? 0 : 12) + randomInt(random, -5, 5), y, randomInt(random, 3, 14));
+				colliders.add(col);
+			}
+		}
+
+		Collider bottom = new BoxCollider(WIDTH / 2, HEIGHT - 5, WIDTH, 10, 0);
+		bottom.addTriggerListener(this);
+		colliders.add(bottom);
+
+		// main simulation loop
+		while(true)
+		{
+			simulate();
+			repaint();
+			Thread.sleep(5);
+		}
+	}
+
+	public void onCollisionTriggered(Collider col, Node node)
+	{
+		double vel = node.oldY - node.y;
+		node.y = 5;
+		node.oldY = node.y + vel;
+	}
+
+	// returns a random integer between the min and the max based on a seed (exclusive)
+	public static int randomInt(Random random, int min, int max)
+	{
+		return random.nextInt(max - min) + min;
+	}
+}