Viewing Program

Program Data

Program thumbnail for "{props.program.title}"

Title	guys i did a collide
ID	5987945576611840
Created	5 years ago, 1606787672265
Updated	5 years ago, 1607846506988
Code	/** * Jentacular Gent * guys i did a collide */ var DEBUG = !true, BODY_SIZE = 60, SLOP = 0.1, SLOP_PERCENT = 0.8, ITERATIONS = 5, // xacer recommended recalculating collision impulse multiple times to prevent jittering PENETRATION_ERROR = 1, // the leeway for multiple contact points having the same penetration depth MAX_BODIES = Math.min(width height / BODY_SIZE / 2 / BODY_SIZE / 2, 50); // so that you don't crash your computer /** * Left click to make rigid bodies * Right click and hold to black hole magnet attraction telekinesis magic * * Thanks to David for fixing the rotations * * I read https://gamedevelopment.tutsplus.com/tutorials/how-to-create-a-custom-2d-physics-engine-the-basics-and-impulse-resolution--gamedev-6331 * * Of course, this engine is far from quality because it makes lots of assumptions and approximations and also I don't know physics * Anyone know how to fix the jiterring? I think it's caused by rotation making objects switch between contact points over and over and having too strong of a reaction to them, but I don't know how to remedy that. * * In short, * Check for a pair of objects that are colliding (SAT) * If a collision occurs: * Change the positions of the objects (such that after the collision, they are not intersecting anymore) The goal is to find a penetration depth and a collision normal. That's the direction the edge an object is colliding with is facing. We will move an object one direction (and the other object in the opposite direction) until they aren't intersecting anymore. The distance to move is the penetration depth. We want the smallest penetration depth possible, so that the positions are resolved in the way that makes the least movement. Otherwise, the engine will unrealistically have objects move farther away than they should, and things would go awry. To find a penetration depth, we want support points. To find the support point of an edge on a polygon, loop through all the vertices of the other polygon and find the one which is farthest in the direction opposite to the edge's normal. From there, you also want to project said point back onto the edge to find the contact point, something we'll need later. Just go through all the edges of both polygons and find the support point with the least distance to its corresponding edge. Then use the distance as the penetration depth, and use the normal of the edge as the collision normal. (Note: If there are multiple support points with the same minimum penetration depth, average the coordinates, or else your contact points will be inaccurate.) * Change the linear velocities of the objects realistically To do this, we must use the collision normal. Calculate the magnitude of the impulse vector (how powerful and in what direction the rebound should be). Call this f. f = elasticity * -dot(normal, velocity2 - velocity1) / (1/mass1 + 1/mass2) velocity1 and mass1 are the velocity and mass of polygon 1. velocity2 and mass2 are the velocity and mass of polygon 2. elasticity is the minimum of the two elasticities, and normal is the surface normal of the edge on polygon 2 (not polygon 1). If two objects are moving towards each other, you want the rebound to be much stronger than, say, if they were moving along in the same general direction and happened to touch. That's where that dot product comes in. For example, if you have two (axis-aligned) boxes coming at each other horizontally (their velocities are (5, 0) and (-5, 0)), the dot product will be: dot((1, 0), (5, 0) - (-5, 0)) dot((1, 0), (10, 0)) 1 * 10 + 0 * 0 = 10 whereas if the velocities are (1, -5) and (-1, -5) (only slightly moving toward each other): dot((1, 0), (1, -5) - (-1, -5)) dot((1, 0), (2, 0)) 1 * 2 + 0 * 0 = 2 The multiplication by elasticity is just that; for a more elastic material, you want a greater impulse, so you multiply it. TBH I'm not sure how the mass works because I don't know physics, but it's probably some equation Newton thunked up back in the day. Just add f to velocity2 and subtract it from velocity1 and the rebound is done. (to make it more realistic, you might also want to interpolate f based on their masses; more massive objects shouldn't be pushed around a lot by tiny weakling objects) * Change the rotational velocities of the objects realistically To do this, we need the impulse vector (calculated in the previous step) and the contact point - That's the point at which the two objects collided. Find the vector from the center of mass (COM) of the polygon to the contact point. Call this v, or the contact vector. Then add to the polygon's angular velocity: cross(v, impulse) / inertia (inertia is a predefined property of the polygon; its moment of inertia, which says how hard something is to rotate about an axis) The reason this works is because of the way the cross product works; simply put, if the first vector is to the right of the second vector, the resulting magnitude becomes positive, and if it's to the left, it becomes negative. Also, if the two vectors are facing the same direction or are facing directly opposite directions, the magnitude becomes 0, and if they are at right angles, the magnitude is maximized. That's very much an oversimplification of what the cross product is, but it's all you need to know about it to see why it works. If the contact vector's direction is right of the impulse vector, the object spins right, and if it's to the left, the object spins left. Basically, depending on what side the impact was on, the cross product changes direction and magnitude. The division by inertia is some physics thingy, idk. * Note: When David told me how to fix the rotations, he said that the subtraction of velocities in the linear velocity step should change to account for rotational velocity. After all, the velocity of a specific point on an object is not only the object's general linear velocity, but also the tangential motion resulting from its angular velocity. He suggested changing velocity to velocity + cross(angularVelocity, contactVector) to find the actual velocity of the point. Additionally, he said to add in some moment of inertia stuff into the impulse force formula. I don't know what it is, but removing it makes everything that's rotating bounce and move really out of control and all over the place. I'm assuming it's correcting the extra velocity that's added from the angular velocity correction above: f = elasticity * -dot(normal, velocity2 + cross(angularVelocity2, contactVector2) - velocity1 - cross(angularVelocity1, contactVector1)) / (1 / mass1 + 1 / mass2 + sq(cross(contactVector1, normal)) / inertia1 + sq(cross(contactVector2, normal)) / inertia2) */ angleMode = "radians"; var D2R = PI/180; // { function vNew(x, y) { if(x instanceof Array) { return { x: x[0], y: x[1] }; } return { x: x \|\| 0, y: y \|\| 0 }; } function vDot(v1, v2) { return v1.x v2.x + v1.y * v2.y; } function vLen(v1) { return Math.hypot(v1.x, v1.y); } function vAdd(v1, v2) { return vNew(v1.x + v2.x, v1.y + v2.y); } function vSub(v1, v2) { return vNew(v1.x - v2.x, v1.y - v2.y); } function vMul(v1, v2) { if(v2 * 1 === v2) { return vNew(v1.x * v2, v1.y * v2); } return vNew(v1.x * v2.x, v1.y * v2.y); } function vDiv(v1, v2) { if(v2 * 1 === v2) { return vNew(v1.x / v2, v1.y / v2); } return vNew(v1.x / v2.x, v1.y / v2.y); } function vNor(v1) { var l = vLen(v1); if(l === 0) { return v1; } return vNew(v1.x / l, v1.y / l); } function iAdd(v1, v2) { v1.x += v2.x; v1.y += v2.y; return v1; } function iSub(v1, v2) { v1.x -= v2.x; v1.y -= v2.y; return v1; } function iMul(v1, v2) { if(v2 * 1 === v2) { v1.x = v2; v1.y = v2; return v1; } v1.x = v2.x; v1.y = v2.y; return v1; } function iDiv(v1, v2) { if(v2 * 1 === v2) { v1.x /= v2; v1.y /= v2; return v1; } v1.x /= v2.x; v1.y /= v2.y; return v1; } function iNor(v1) { var l = vLen(v1); if(l !== 0) { v1.x /= l; v1.y /= l; } return v1; } function vCross(v1, v2) { if(v1 * 1 === v1) { return vNew(-v1 * v2.y, v1 * v2.x); } if(v2 * 1 === v2) { return vNew(v2 * v1.y, -v2 * v1.x); } return v1.x * v2.y - v1.y * v2.x; } // } Vector // Deep copy array (of arrays) function deepCopyArray(arr) { var newArr = []; for(var i = 0; i < arr.length; i += 1) { var item = arr[i]; if(item instanceof Array) { newArr.push(deepCopyArray(item)); continue; } newArr.push(item); } return newArr; } // SAT for one axis var SAT = function(x, y, x2, y2, pol1, pol2) { if(x2 === x) { x2 += 0.001; } var m = (y2-y)/(x2-x); var b = y - x * m; var side = -1; for(var i = 0; i < pol1.length; i ++) { var p = pol1[i]; if((abs(p[0] - x) < 1 && abs(p[1] - y) < 1) \|\| (abs(p[0] - x2) < 1 && abs(p[1] - y2) < 1)) { continue; } side = (p[1] < m * p[0] + b) ? 0 : 1; break; } for(var i = 0; i < pol2.length; i ++) { var p = pol2[i]; if((side === 0 && p[1] > m * p[0] + b) \|\| (side === 1 && p[1] < m * p[0] + b)) { continue; } return true; } return false; }; // SAT for all sides of polygons function polyPoly(p1, p2) { for(var i = 0; i < p1.length; i ++) { var v1 = p1[i]; var v2 = p1[(i + 1) % (p1.length)]; if(i >= p1.length - 1) { v2 = p1[0]; } var s = SAT(v1[0], v1[1], v2[0], v2[1], p1, p2); if(!s) { return false; } } for(var i = 0; i < p2.length; i ++) { var v1 = p2[i]; var v2 = p2[(i + 1) % (p2.length)]; var s = SAT(v1[0], v1[1], v2[0], v2[1], p2, p1); if(!s) { return false; } } return true; } /** * SAT is separating axis theorem * It states that if there exists a line such that all vertices of one polygon are on one side and all vertices of the other polygon are on the other side, then the two polygons are not intersecting. * Additionally, if both polygons are convex, then if there does not exist such a line, then the polygons are intersecting. * This is how we test whether or not a collision is happening. */ // Default value function dv(a, b) { return (a === undefined) ? b : a; } // For detecting and resolving the position when collisions occur function projectOntoLine(v1, v2, v) { var d = vSub(v2, v1), dot = vDot(d, d); var pLength = vDot(vSub(v, v1), d) / dot; return vNew(v1.x + pLength d.x, v1.y + pLength * d.y); } // The "support" of an edge of a polygon is the vertex of the other polygon which is farthest in the direction opposite of the edge's normal. function findSupport(v1, v2, normal, verts) { var maxDepth = -Infinity, supported = []; for(var i = 0; i < verts.length; i += 1) { var v = vNew(verts[i]); var projected = projectOntoLine(v1, v2, v); var sqDist = sq(projected.x - v.x) + sq(projected.y - v.y); if(vDot(vSub(v, projected), normal) > 0) { sqDist = -1; } if(sqDist < maxDepth) { continue; } if(Math.abs(sqDist - maxDepth) < PENETRATION_ERROR) { maxDepth = sqDist; supported.push(projected); continue; } maxDepth = sqDist; supported = []; supported.push(projected); } var sx = 0, sy = 0; for(var i = 0; i < supported.length; i += 1) { sx += supported[i].x; sy += supported[i].y; } sx /= supported.length; sy /= supported.length; return [maxDepth, vNew(sx, sy)]; } // This just loops through all the edges of both polygons and finds the support which has the minimum distance to the edge. function leastPenetration(poly1, poly2) { var maxDepth = Infinity, contactPoint, normal; for(var i = 0; i < poly2.length; i += 1) { var p1 = vNew(poly2[i]), p2 = vNew(poly2[(i + 1) % poly2.length]), nor = poly2[i][2]; var support = findSupport(p1, p2, nor, poly1); if(Math.abs(support[0] - maxDepth) < PENETRATION_ERROR) { if(maxDepth 1 === maxDepth) { maxDepth = []; contactPoint = []; normal = []; } maxDepth.push(support[0]); contactPoint.push(support[1]); normal.push(nor); continue; } if(support[0] > maxDepth) { continue; } maxDepth = support[0]; contactPoint = support[1]; normal = nor; } if(maxDepth instanceof Array) { var md = 0, cp = vNew(), nm = vNew(); for(var i = 0; i < maxDepth.length; i += 1) { md += maxDepth[i]; iAdd(cp, contactPoint[i]); iAdd(nm, normal[i]); } maxDepth = md / i; contactPoint = iDiv(cp, i); normal = iNor(nm); } return [normal, maxDepth, contactPoint]; } // Calculate the area of a polygon // The idea is to find the area of the trapezoid ABCD, where A and B are two connected vertices of the polygon, and C and D are A and B projected onto the y axis. // If A is lower than B, multiply the area by -1. // If you do this for all edges and add the areas up, it will result in the area of the polygon and everything to the side of it minus the area of everything to the side of it. // (i actually don't know if this code works) // area of trapezoid is h(a+b)/2, where h is the altitude and a and b are the bases // The negative area can come from leaving out the absolute value when calculating altitude. function polyArea(verts) { var area = 0; for(var i = 0; i < verts.length; i += 1) { var j = (i \|\| verts.length) - 1; area += (verts[j][1] - verts[i][1]) * (verts[i][0] + verts[j][0]); } return Math.abs(area / 2); } // (Convex) Polygon body function Polygon(p) { this.position = p.position \|\| vNew(); this.shape = p.shape \|\| [[-50, -50], [50, -50], [50, 50], [-50, 50]]; var area = polyArea(this.shape); this.mass = dv(p.mass, Math.sqrt(area) / 20); // this.mass = dv(p.mass, 1); this.inertia = dv(p.inertia, area / 2); this.linAcc = vNew(); this.linVel = p.linVel \|\| vNew(); this.ang = dv(p.ang, 0); this.angAcc = 0; this.angVel = dv(p.angVel, 0); this.elasticity = dv(p.elasticity, 0.5); this.staticFriction = dv(p.staticFriction, 0.5); this.dynamicFriction = dv(p.dynamicFriction, 0.5); // I use a bounding circle so I don't have to use a lot of SAT every frame for hundreds of edges (very expensive) // I use circle instead of rect or square because you don't need to adjust for rotation (rotation would make it require more complex intersection formulas and would probably also require trigonometric functions) this.boundingCircle = 0; for(var i = 0; i < this.shape.length; i += 1) { var v = this.shape[i]; var d = sq(v[0]) + sq(v[1]); if(d < this.boundingCircle) { continue; } this.boundingCircle = d; } this.boundingCircle = Math.sqrt(this.boundingCircle); } // Use SAT (or the bounding circles) to see if polygons are colliding Polygon.prototype.checkCollision = function(body) { if(body instanceof Polygon) { var d = dist(this.position.x, this.position.y, body.position.x, body.position.y); if(d > this.boundingCircle + body.boundingCircle) { return false; } var poly1 = deepCopyArray(this.shape); var poly2 = deepCopyArray(body.shape); var c = Math.cos(this.ang), s = Math.sin(this.ang); for(var i = 0; i < poly1.length; i += 1) { var p = poly1[i]; var x = p[0] * 1; p[0] = x * c - p[1] * s; p[1] = p[1] * c + x * s; p[0] += this.position.x; p[1] += this.position.y; } var c = Math.cos(body.ang), s = Math.sin(body.ang); for(var i = 0; i < poly2.length; i += 1) { var p = poly2[i]; var x = p[0] * 1; p[0] = x * c - p[1] * s; p[1] = p[1] * c + x * s; p[0] += body.position.x; p[1] += body.position.y; } return polyPoly(poly1, poly2); } }; // Find the collision normal, penetration depth, and contact point if there is a collision Polygon.prototype.getCollisionData = function(body) { if(body instanceof Polygon) { // Generate polygon vertices and rotate them var poly1 = deepCopyArray(this.shape); var poly2 = deepCopyArray(body.shape); var c = Math.cos(this.ang), s = Math.sin(this.ang); for(var i = 0; i < poly1.length; i += 1) { var p = poly1[i]; var x = p[0] * 1; p[0] = x * c - p[1] * s; p[1] = p[1] * c + x * s; p[2] = { x: p[2].x * c - p[2].y * s, y: p[2].y * c + p[2].x * s }; p[0] += this.position.x; p[1] += this.position.y; } var c = Math.cos(body.ang), s = Math.sin(body.ang); for(var i = 0; i < poly2.length; i += 1) { var p = poly2[i]; var x = p[0] * 1; p[0] = x * c - p[1] * s; p[1] = p[1] * c + x * s; p[2] = { x: p[2].x * c - p[2].y * s, y: p[2].y * c + p[2].x * s }; p[0] += body.position.x; p[1] += body.position.y; } var maxDepth, contactPoint, normal; var data1 = leastPenetration(poly1, poly2); var data2 = leastPenetration(poly2, poly1); if(Math.abs(data2[1] - data1[1]) < PENETRATION_ERROR) { normal = iNor(vAdd(data2[0], vMul(data1[0], -1))); maxDepth = Math.max(data2[1], data1[1]); contactPoint = iDiv(vAdd(data2[2], data1[2]), 2); } else { if(data2[1] < data1[1]) { normal = iMul(data2[0], 1); maxDepth = data2[1]; contactPoint = data2[2]; } else { normal = vMul(data1[0], -1); maxDepth = data1[1]; contactPoint = data1[2]; } } maxDepth = Math.sqrt(maxDepth); if(DEBUG) { ellipse(contactPoint.x, contactPoint.y, 10, 10); line(contactPoint.x, contactPoint.y, contactPoint.x + normal.x * 10, contactPoint.y + normal.y * 10); stroke(0, 0, 255); line(contactPoint.x, contactPoint.y, contactPoint.x + normal.x * maxDepth, contactPoint.y + normal.y * maxDepth); stroke(0); } return [normal, maxDepth, contactPoint]; } }; // Draw graphics Polygon.prototype.display = function() { pushMatrix(); translate(this.position.x, this.position.y); rotate(this.ang); beginShape(); for(var i = 0; i < this.shape.length; i += 1) { vertex(this.shape[i][0], this.shape[i][1]); } endShape(CLOSE); if(DEBUG) { stroke(200); ellipse(0, 0, this.boundingCircle * 2, this.boundingCircle * 2); stroke(0); } popMatrix(); }; // So that I don't have to write out the vertices function Rect(p) { p.shape = [[-p.size.x / 2, -p.size.y / 2, vNew(0, -1)], [p.size.x / 2, -p.size.y / 2, vNew(1, 0)], [p.size.x / 2, p.size.y / 2, vNew(0, 1)], [-p.size.x / 2, p.size.y / 2, vNew(-1, 0)]]; return new Polygon(p); } // World var world = { gravity: vNew(0, 0.2), rotationFriction: 0.95, layers: [], // objects from different layers don't interact with each other // Apply a force to all objects globalForce: function(v, v2) { for(var variablename = 0; variablename < this.layers.length; variablename += 1) { var l = this.layers[variablename]; for(var i = 0; i < l.rigids.length; i += 1) { var b = l.rigids[i]; iAdd(b.linAcc, v); if(v2) { b.angAcc += v2; } } } }, runPhysics: function() { for(var variablename = 0; variablename < this.layers.length; variablename += 1) { var l = this.layers[variablename]; // I think in physics we call this integration? It's adding acceleration and velocity and position, which I guess is a sort of discrete integral for(var i = 0; i < l.rigids.length; i += 1) { var b = l.rigids[i]; iAdd(b.linVel, this.gravity); iAdd(b.linVel, iDiv(b.linAcc, b.mass)); iAdd(b.position, b.linVel); // b.position = iDiv(vAdd(b.position, vAdd(b.position, b.linVel)), 2); b.linAcc.x = b.linAcc.y = 0; b.angVel += b.angAcc / b.inertia; b.ang += b.angVel; b.angAcc = 0; b.angVel = this.rotationFriction; } // Here is where I resolve collisions for(var n = 1; n <= ITERATIONS; n += 1) { for(var i = 0; i < l.rigids.length; i += 1) { var b = l.rigids[i]; for(var j = 0; j < l.rigids.length; j += 1) { if(j === i) { continue; } var b2 = l.rigids[j]; // Check for collision if(!b.checkCollision(b2)) { continue; } // Get normal, penetration depth, and contact point var collisionData = b.getCollisionData(b2); var normal = collisionData[0], depth = collisionData[1], contactPoint = collisionData[2]; var contactVector1 = vSub(contactPoint, b.position), contactVector2 = vSub(contactPoint, b2.position); // Calculate and apply impulse (explained on lines 34-52) var velDiff = vSub(vAdd(b2.linVel, vCross(b2.angVel, contactVector2)), vAdd(b.linVel, vCross(b.angVel, contactVector1))); var steepness = -vDot(normal, velDiff); var elasticity = min(b.elasticity, b2.elasticity) + 1; var impulseForce = elasticity steepness / ( 1 / b.mass + 1 / b2.mass + sq(vCross(contactVector1, normal)) / b.inertia + sq(vCross(contactVector2, normal)) / b2.inertia ); var impulse = vMul(normal, impulseForce); if(n === 1) { iSub(b.linVel, vMul(impulse, 1 / b.mass / n)); iAdd(b2.linVel, vMul(impulse, 1 / b2.mass / n)); } // Resolve position; move objects along normal until they aren't touching var resolution = vMul(normal, max(depth - SLOP, 0) / (1 / b.mass + 1 / b2.mass) * SLOP_PERCENT); iSub(b.position, iMul(resolution, 1 / b.mass / n)); iAdd(b2.position, iMul(resolution, 1 / b2.mass / n)); // Here I apply friction; I didn't talk about it in the description in the comments at the top of the code, but it's the same as the impulse except replace the collision normal with the tangent if(n === 1) { var friction = iNor(vSub(velDiff, vMul(normal, vDot(velDiff, normal)))); var frictionForce = -vDot(velDiff, friction) / ( 1 / b.mass + 1 / b2.mass + sq(vCross(contactVector1, friction)) / b.inertia + sq(vCross(contactVector2, friction)) / b2.inertia ); var u = Math.hypot(b.staticFriction, b2.staticFriction); if(Math.abs(frictionForce) < impulseForce * u) { iMul(friction, frictionForce * u); } else { iMul(friction, -impulseForce * Math.hypot(b.dynamicFriction, b2.dynamicFriction)); } iSub(b.linVel, vMul(friction, 1 / b.mass / n)); iAdd(b2.linVel, vMul(friction, 1 / b2.mass / n)); } // Angular velocity (explained on lines 53-62) b.angVel -= vCross(contactVector1, impulse) / b.inertia / n; b2.angVel += vCross(contactVector2, impulse) / b2.inertia / n; } // Do the same thing but for static bodies for(var j = 0; j < l.statics.length; j += 1) { var b2 = l.statics[j]; if(!b.checkCollision(b2)) { continue; } var collisionData = b.getCollisionData(b2); var normal = collisionData[0], depth = collisionData[1], contactPoint = collisionData[2]; var contactVector1 = vSub(contactPoint, b.position), contactVector2 = vSub(contactPoint, b2.position); var velDiff = vSub(b2.linVel, vAdd(b.linVel, vCross(b.angVel, contactVector1))); var steepness = -vDot(normal, velDiff); var elasticity = min(b.elasticity, b2.elasticity) + 1; var impulseForce = elasticity * steepness / ( 1 / b.mass + sq(vCross(contactVector1, normal)) / b.inertia ); var impulse = vMul(normal, impulseForce); if(n === 1) { // var totalMass = b.mass + b2.mass; iSub(b.linVel, vMul(impulse, 1 / b.mass / n)); } var resolution = vMul(normal, max(depth - SLOP, 0) / (1 / b.mass + 1 / b2.mass) * SLOP_PERCENT); // var resolution = vMul(normal, depth); iSub(b.position, iMul(resolution, 1 / b.mass / n)); // iAdd(b2.position, iMul(resolution, 1 / b2.mass / n)); if(n === 1) { var friction = iNor(vSub(velDiff, vMul(normal, vDot(velDiff, normal)))); var frictionForce = -vDot(velDiff, friction) / ( 1 / b.mass + sq(vCross(contactVector1, friction)) / b.inertia ); var u = Math.hypot(b.staticFriction, b2.staticFriction); if(Math.abs(frictionForce) < impulseForce * u) { iMul(friction, frictionForce * u); } else { iMul(friction, -impulseForce * Math.hypot(b.dynamicFriction, b2.dynamicFriction)); } iSub(b.linVel, vMul(friction, 1 / b.mass / n)); // iAdd(b2.linVel, vMul(friction, 1 / b2.mass / n)); } b.angVel -= vCross(contactVector1, impulse) / b.inertia / n; // b2.angVel += vCross(contactVector2, impulse) / b2.inertia / n; } } } } }, // Draw everything runGraphics: function() { for(var variablename = 0; variablename < this.layers.length; variablename += 1) { var l = this.layers[variablename]; for(var i = 0; i < l.rigids.length; i += 1) { var b = l.rigids[i]; b.display(); if(DEBUG) { stroke(255, 0, 0); line(b.position.x, b.position.y, b.position.x + b.linVel.x, b.position.y + b.linVel.y); stroke(0); } } for(var i = 0; i < l.statics.length; i += 1) { var b = l.statics[i]; b.display(); } } }, }; var layer = { rigids: [], statics: [ new Polygon({position: vNew(width / 2, height * 2 / 3), shape: [[-100, 100/3, iNor(vNew(-1, -1))], [0, -1002/3, iNor(vNew(1, -1))], [100, 100/3, vNew(0, 1)]] }), Rect({ position: vNew(width / 4, height / 3), size: vNew(200, 50), ang: 0.5 }), // Rect({ position: vNew(width / 2, -50), size: vNew(width, 100) }), // Rect({ position: vNew(-50, height / 2), size: vNew(100, height) }), // Rect({ position: vNew(width + 49, height / 2), size: vNew(100, height) }), Rect({ position: vNew(width / 2, height + 49), size: vNew(width, 100) }), ] }; function randomShape(x, y) { var poly = []; var j = 0; var d = BODY_SIZE + random(10); while(j < 360) { poly.push([cos(j D2R) * d, sin(j * D2R) * d]); if(j > 0) { var t = iSub(vNew(poly[poly.length - 1]), vNew(poly[poly.length - 2])); var c = cos(-90 * D2R), s = sin(-90 * D2R); t = { x: t.x * c - t.y * s, y: t.y * c + t.x * s }; iNor(t); poly[poly.length - 2][2] = t; } j += random(60, 120); } var t = iSub(vNew(poly[0]), vNew(poly[poly.length - 1])); var c = Math.cos(-90 * D2R), s = Math.sin(-90 * D2R); t = { x: t.x * c - t.y * s, y: t.y * c + t.x * s }; iNor(t); poly[poly.length - 1][2] = t; return new Polygon({ position: vNew(x, y), shape: poly }); } layer.rigids.push(Rect({ position: vNew(width / 2, height / 4), size: vNew(20, 50) })); layer.rigids.push(Rect({ position: vNew(width / 2, height / 4 - 25 - 25 / 2), size: vNew(25, 25) })); layer.rigids.push(Rect({ position: vNew(width / 2, height / 4 - 25 - 25 / 2 - 50), size: vNew(100, 50) })); // for(var i = 0; i < 10; i += 1) { // for(var j = 0; j < 10; j += 1) { // layer.rigids.push(Rect({ position: vNew(i * 21 + 100, j * 21 + 100), size: vNew(20, 20) })); // } // } world.layers.push(layer); // Mouse var pm = millis(), balanced = true; function mousePressed() { if(mouseButton === LEFT && world.layers[0].rigids.length < MAX_BODIES) { balanced = false; world.layers[0].rigids.push(randomShape(mouseX, mouseY)); for(var i = 0; i < layer.rigids.length; i += 1) { if(layer.rigids[i].position.y > height * 2) { layer.rigids.splice(i, 1); i -= 1; } } } } // Draw var draw = function() { try{ background(255); // while(pm < millis()) { world.runPhysics(); // pm += 1000/60; // } noFill(); // fill(255); world.runGraphics(); for(var i = world.layers[0].rigids.length - 1; i >= 0; i -= 1) { if(world.layers[0].rigids[i].position.y > height + BODY_SIZE) { world.layers[0].rigids.splice(i, 1); } } if(mouseIsPressed && mouseButton === RIGHT) { balanced = false; for(var i = 0; i < world.layers[0].rigids.length; i += 1) { var b = world.layers[0].rigids[i]; var v = vSub(vNew(mouseX, mouseY), b.position); iAdd(b.linVel, iDiv(v, vLen(v) * 2)); } } if(world.layers[0].rigids.length < MAX_BODIES && frameCount % 100 === 0) { var poly = []; var j = 0; var d = BODY_SIZE + random(10); while(j < 360) { poly.push([cos(j * D2R) * d, sin(j * D2R) * d]); if(j > 0) { var t = iSub(vNew(poly[poly.length - 1]), vNew(poly[poly.length - 2])); var c = Math.cos(-90 * D2R), s = Math.sin(-90 * D2R); t = { x: t.x * c - t.y * s, y: t.y * c + t.x * s }; iNor(t); poly[poly.length - 2][2] = t; } j += random(60, 120); } var t = iSub(vNew(poly[0]), vNew(poly[poly.length - 1])); var c = Math.cos(-90 * D2R), s = Math.sin(-90 * D2R); t = { x: t.x * c - t.y * s, y: t.y * c + t.x * s }; iNor(t); poly[poly.length - 1][2] = t; world.layers[0].rigids.push(new Polygon({ position: vNew(-100, height * 3 / 4), shape: poly, linVel: vNew(10, random(-15, -5)), angVel: random(-0.3, 0.3) })); var poly = []; var j = 0; var d = BODY_SIZE + random(10); while(j < 360) { poly.push([cos(j * D2R) * d, sin(j * D2R) * d]); if(j > 0) { var t = iSub(vNew(poly[poly.length - 1]), vNew(poly[poly.length - 2])); var c = Math.cos(-90 * D2R), s = Math.sin(-90 * D2R); t = { x: t.x * c - t.y * s, y: t.y * c + t.x * s }; iNor(t); poly[poly.length - 2][2] = t; } j += random(60, 120); } var t = iSub(vNew(poly[0]), vNew(poly[poly.length - 1])); var c = Math.cos(-90 * D2R), s = Math.sin(-90 * D2R); t = { x: t.x * c - t.y * s, y: t.y * c + t.x * s }; iNor(t); poly[poly.length - 1][2] = t; world.layers[0].rigids.push(new Polygon({ position: vNew(width + 100, height * 3 / 4), shape: poly, linVel: vMul(world.layers[0].rigids[world.layers[0].rigids.length - 1].linVel, vNew(-1, 1)), angVel: random(-0.3, 0.3) })); } }catch(e){println(e.stack);noLoop();} };
Folds	74,162,179,202,204,225,234,236,239,243,320,327,360,392,458,473
Fork	false
Key	ag5zfmtoYW4tYWNhZGVteXIXCxIKU2NyYXRjaHBhZBiAgJ3Ik8DRCgw
Votes	169
Spin-Offs	8
Type	PJS
Width	600
Height	600
User Flagged	false
Origin Scratchpad	null
Hidden From Hotlist	false
Restricted Posting	false
By Child	false
Author Nick	JentGent
Author Name	JentacularGent
Author ID	kaid_1111444645373975142506044
Author Profile Access	COACH

Archive Data

Added	10 months ago, 1739452081926
Updated	10 months ago, 1739452090106
Source Deleted	unknown