prev • index • info

code guessing, round #79, stage 2 (guessing)

started at ; stage 2 since . guess by

specification

hello! your challenge is to simulate bodies in orbit. submissions may be written in any language

in the physical world, all objects follow certain laws that govern their behavior. in the 17th century, Sir Isaac Newton published his work, Newton's law of universal gravitation, which describes the gravity as a force and provides a mathematical formulation for its magnitude.

your task is, using Newton's law of universal gravitation, simulate how two (or more) bodies in a 2d or 3d space interact with each other. as any language is allowed, there is no fixed API.

players

  1. *Ada
  2. Dolphy
  3. essaie
  4. hyacinth
  5. kimapr
  6. oleander

entries

you can download all the entries

entry #1

comments 0

post a comment


bodies_in_orbit.wren ASCII text, with CRLF line terminators
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
import "random" for Random

var random = Random.new()

var steps = 100 // change this to alter how many steps the simulation makes

var particles = 2 // change this to alter how many particles are simulated

var gravConstant = 1 // change this to affect the effect of gravity on the particles

var gridSize = 16 // change this to adjust the resolution of the simulation

var particleMasses = []
var Xpos = []
var Ypos = []
var Xvel = []
var Yvel = []

for(i in 0...particles){

	particleMasses.add(random.float(6))
	Xpos.add(random.float(-0.5, gridSize - 0.5))
	Ypos.add(random.float(-0.5, gridSize - 0.5))
	Xvel.add(random.float(-0.5, 0.5))
	Yvel.add(random.float(-0.5, 0.5))

}

for(i in 0...steps){

	// drawing

	var displayChars = "`<*3P#@"

	var outputGrid = []

	for(j in 0...gridSize + 2)outputGrid.add([" "] * (gridSize + 2))

	outputGrid[0][0]="+"
	outputGrid[0][gridSize + 1]="+"
	outputGrid[gridSize + 1][0]="+"
	outputGrid[gridSize + 1][gridSize + 1]="+"

	for(j in 1..gridSize){

		outputGrid[0][j]="-"
		outputGrid[gridSize + 1][j]="-"
		outputGrid[j][0]="|"
		outputGrid[j][gridSize + 1]="|"

	}

	for(j in particles-1..0){ /* loop through in reverse so
	particles earlier in the particle list are rendered
	over particles later in the list */

		var particleChar = displayChars[particleMasses[j].round]
		var rawX = Xpos[j].round
		var renderedX = 1 + ( rawX < 0 ? -1 : rawX > gridSize - 1 ? gridSize : rawX )
		var rawY = Ypos[j].round
		var renderedY = 1 + ( rawY < 0 ? -1 : rawY > gridSize - 1 ? gridSize : rawY )
		outputGrid[renderedY][renderedX] = particleChar

	}

	System.print("Iteration %(i)")
	for(j in 0...gridSize + 2)System.printAll(outputGrid[j])
	System.print()

	// computing

	var xVelDeltas = [0] * particles
	var yVelDeltas = [0] * particles

	for(affectedParticle in 0...particles)for(affectingParticle in 0...particles)if(affectedParticle != affectingParticle){

		var xDelta = Xpos[affectingParticle] - Xpos[affectedParticle] 
		var yDelta = Ypos[affectingParticle] - Ypos[affectedParticle] 

		var radiusSquared = xDelta.pow(2) + yDelta.pow(2)

		var distanceBetween = radiusSquared.sqrt

		var forceMagnitude = gravConstant * particleMasses[affectedParticle] * particleMasses[affectingParticle] / radiusSquared

		var xAccel = xDelta / distanceBetween * forceMagnitude
		var yAccel = yDelta / distanceBetween * forceMagnitude

		xVelDeltas[affectedParticle] = xVelDeltas[affectedParticle] + ( xAccel < -gridSize / 2 ? -gridSize / 2 : xAccel > gridSize / 2 ? gridSize / 2 : xAccel ) 
		yVelDeltas[affectedParticle] = yVelDeltas[affectedParticle] + ( yAccel < -gridSize / 2 ? -gridSize / 2 : yAccel > gridSize / 2 ? gridSize / 2 : yAccel ) 


	}

	for(j in 0...particles){

		Xvel[j] = Xvel[j] + xVelDeltas[j]
		Yvel[j] = Yvel[j] + yVelDeltas[j]

	}

	for(j in 0...particles){

		Xpos[j] = Xpos[j] + Xvel[j]
		Ypos[j] = Ypos[j] + Yvel[j]

	}


}

entry #2

comments 0

post a comment


entry.html ASCII text
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
<!-- best played on computer, sorry phone prisoners -->

<style>

html, body { margin: 0; padding: 0; }
body {
  background-color: black;
  width:100vw; height: 100vh;
  overflow: hidden;
  position: relative;
}
body[paused] {
  background-color: #111;
}
.star {
  background-color: #fff;
}
.fire {
  border: 1px solid red;
}
.sel {
  border: 1px solid cyan;
}
.fire, .star, .sel {
  border-radius: 100%;
  position: absolute;
}

</style>

<body id="body">

<script>

var datakey = "$XDG_CONFIG_DIR/CG79/entry.html.conf";
var config = {
  camX: 0,
  camY: 0,
  zoom: 1,
  speed: 1,
  objects: {},
  pause: false,

  ...(localStorage[datakey]
    ? JSON.parse(localStorage[datakey])
    : {})
};

Object.values(config.objects)
  .forEach(obj => starElement(obj));

function saveConfig() {
  localStorage[datakey] = JSON.stringify({
    ...config,

    objects: Object.fromEntries(
      Object.entries(config.objects)
        .map(([k, v]) => [k, Object.fromEntries(
          Object.entries(v)
            .filter(([k, v]) => k != 'element')
        )])
    )
  });
}

setInterval(_ => saveConfig(), 100);

var newObj = null;
var throwObj = null;
var selObj = null;

function screenToWorld(cx, cy) {
  var    [w,  h ] = [body.clientWidth, body.clientHeight];
  var    [wx, wy] = [cx - w/2,         cy - h/2         ];
         [wx, wy] = [wx / h,           wy / h           ];
         [wx, wy] = [wx / config.zoom, wy / config.zoom ];
         [wx, wy] = [wx + config.camX, wy + config.camY ];
  return [wx, wy]                                        ;
}

function worldToScreen(wx, wy) {
  var    [w,  h ] = [body.clientWidth, body.clientHeight];
  var    [cx, cy] = [wx - config.camX, wy - config.camY ];
         [cx, cy] = [cx * config.zoom, cy * config.zoom ];
         [cx, cy] = [cx * h,           cy * h           ];
         [cx, cy] = [cx + w/2,         cy + h/2         ];
  return [cx, cy]                                        ;
}

function randomID() {
  return [...crypto.getRandomValues(new Uint8Array(2))]
    .map(e => e.toString(16).padStart(2, 0))
    .join('');
}

function reset() {
  localStorage[datakey] = '{}';
  saveConfig = function() {};
  location.reload();
}

randomID = (function(randomID) {
  return function() {
    if (Object.keys(config.objects).length >= (256 ** (randomID().length / 2)) * 0.8) {
      body.remove();
      localStorage[datakey] = '{}';
      document.innerHTML = `<body>You're cringe</body>`;
      throw new Error(document.textContent);
    }
    while (1) {
      var id = randomID();
      if (!(id in config.objects))
        return id;
    }
  }
})(randomID);

function starElement(obj) {
  if ((!obj.element) || obj.element.parentElement != body) {
    obj.element = document.createElement('div');
    obj.element.className = obj.sel ? 'sel' : (obj.obj ? 'fire' : 'star');
    body.append(obj.element);
  }
  var [
    sx, sy
  ] = worldToScreen(obj.x, obj.y);
  var [
    sx2,
    sy2
  ] = worldToScreen(
    obj.x + obj.r,
    obj.y + obj.r,
  );
  obj.element.style.width = '1000px';
  obj.element.style.height = '1000px';
  obj.element.style.top = '-500px';
  obj.element.style.left = '-500px';
  obj.element.style.transform = `translate(${sx}px, ${sy}px) scale(${(sx2 - sx)/500}, ${(sy2 - sy)/500})`;
  return obj;
}

var targetStep = 1/120;
var accumTime = 0;
var maxSteps = 1;
var updateTime = 0;

function draw(dt) {
  dt *= config.speed;
  if (updateTime / dt > 0.8) {
    maxSteps = Math.max(1, maxSteps - 1);
  } else {
    maxSteps = maxSteps + 1;
  }

  accumTime += dt;
  accumTime = Math.min(accumTime, 5);

  var begin = performance.now();
  for (var i = 0; i < maxSteps && accumTime >= targetStep; i++) {
    update(targetStep);
    accumTime -= targetStep;
  }

  updateTime = performance.now() - begin;

  [
    ...(newObj ? [newObj] : []),
    ...(throwObj ? [throwObj] : []),
    ...(selObj ? [selObj] : []),
    ...Object.values(config.objects)
  ]
    .forEach(e => starElement(e));
}

function gravity(dest, src, out) {
  if (dest.mass == 0 || src.mass == 0)
    return;
  var G = 10; // cartoon physics
  var r = Math.hypot(
    dest.x - src.x,
    dest.y - src.y
  );
  if (r < (dest.r + src.r)) {
    G = 0;
    let objs = [dest, src].sort((a, b) => a.mass - b.mass);
    [objs[0].x, objs[0].y, objs[0].vx, objs[0].vy] = [
      (dest.x * dest.mass + src.x * src.mass) / (src.mass + dest.mass),
      (dest.y * dest.mass + src.y * src.mass) / (src.mass + dest.mass),
      (dest.vx * dest.mass + src.vx * src.mass) / (src.mass + dest.mass),
      (dest.vy * dest.mass + src.vy * src.mass) / (src.mass + dest.mass),
    ];
    [objs[0].r, objs[0].mass] = [
      (((4/3)*Math.PI*(src.r**3) + (4/3)*Math.PI*(dest.r**3)) / (4/3*Math.PI)) ** (1/3),
      src.mass + dest.mass
    ];
    [src.anchor, dest.anchor] = [0,0].map(_ => src.anchor && dest.anchor);
    if (!src.anchor) delete src.anchor;
    if (!dest.anchor) delete dest.anchor;
    objs[1].r = 0;
    objs[1].mass = 0;
    delete config.objects[objs[1].id];
    objs[1].element.remove();
  }
  var [dx, dy] = [
    src.x - dest.x,
    src.y - dest.y
  ];
  var d = Math.hypot(dx, dy);
  [dx, dy] = [
    dx / d,
    dy / d
  ];
  out[0] += G * (dest.mass * src.mass) / (r**2) * dx / dest.mass;
  out[1] += G * (dest.mass * src.mass) / (r**2) * dy / dest.mass;
}

function update(dt) {
  if (throwObj || newObj || config.pause) {
    body.setAttribute('paused', '');
    return;
  } else {
    body.removeAttribute('paused');
  }

  // 4th order Yoshida integrator
  var w0 = -(2**(1/3))/(2-(2**(1/3))),
      w1 = 1/(2-(2**(1/3))),
      c1, c2, c3, c4,
      d1, d2, d3, a;
      c1 = c4 = w1 / 2;
      c2 = c3 = (w0 + w1) / 2;
      d1 = d3 = w1;
      d2 = w0;

  var c = [,c1,c2,c3,c4];
  var d = [,d1,d2,d3];

  let objs = Object.values(config.objects)
    .filter(obj => (
      +obj.x == obj.x &&
      +obj.y == obj.y &&
      +obj.r == obj.r &&
      +obj.mass == obj.mass &&
      +obj.vx == obj.vx &&
      +obj.vy == obj.vy
    ));

  for (let k = 1; k <= 4; k++) {
    for (let obj of objs) {
      if (c[k]) {
        [obj.x, obj.y] = [
          obj.x + c[k]*obj.vx*dt,
          obj.y + c[k]*obj.vy*dt,
        ];
      }
      if (d[k]) {
        let a = [0, 0];
        for (let alt of objs) {
          if (alt != obj) {
            gravity(obj, alt, a);
          }
        }
        [obj.vx, obj.vy] = [
          obj.vx + d[k]*a[0]*dt,
          obj.vy + d[k]*a[1]*dt,
        ];
      }
    }
  }

  let objs2 = objs.filter(obj => obj.anchor);

  if(objs2.length == 0) {
    objs2 = objs;
  }

  let av = [0, 0, 0, 0, 0];
  for (let obj of objs2) {
    if (obj.mass > 0) {
      av[0] += obj.vx * obj.mass;
      av[1] += obj.vy * obj.mass;
      av[2] += obj.mass;
      av[3] += obj.x * obj.mass;
      av[4] += obj.y * obj.mass;
    }
  }
  av = [av[0] / av[2], av[1] / av[2], av[3] / av[2], av[4] / av[2]];
  for (let obj of objs) {
    obj.vx -= av[0];
    obj.vy -= av[1];
    obj.x -= av[2];
    obj.y -= av[3];
  }
  config.camX -= av[2];
  config.camY -= av[3];
  if (objs2.length == 0 || !(
    +config.camX == config.camX &&
    +config.camY == config.camY &&
    +config.zoom == config.zoom
  )) {
    config.camX = 0;
    config.camY = 0;
    config.zoom = 1;
  }
}

Object.assign(body, {

  onkeydown(e) {
    if (e.code == 'Space') {
      config.pause = !config.pause;
    }
  },

  oncontextmenu(e) {
    return false;
  },

  onmousedown(e) {
    let [x, y] = screenToWorld(e.clientX, e.clientY);

    if (e.button == 1) {

      selObj = starElement({x, y, r:0, sel:1});
      return false;

    } else if (e.button == 0) {

      for (let obj of Object.values(config.objects)) {
        if (Math.hypot(obj.x - x, obj.y - y) <= obj.r) {
          if (throwObj) {
            throwObj.element.remove();
          }
          throwObj = starElement({x, y, r: 0, dx: 0, dy: 0, obj});
          return false;
        }
      }

      newObj = starElement({
        x, y, r: 0, mass: 0,
        id: randomID(),
        vx: 0, vy: 0,
      });

      return false;

    } else if (e.button == 2) {

      for (let obj of Object.values(config.objects)) {
        if (Math.hypot(obj.x - x, obj.y - y) <= obj.r) {
          obj.element.remove();
          delete config.objects[obj.id];
          return false;
        }
      }

    }
  },

  onmousemove(e) {
    let [x, y] = screenToWorld(e.clientX, e.clientY);

    if (selObj) {
      selObj.r = Math.hypot(x - selObj.x, y - selObj.y);
    }

    if (newObj && !throwObj) {
      newObj.r = Math.hypot(x - newObj.x, y - newObj.y);
      newObj.mass = 4/3 * Math.PI * (newObj.r**3);

      return false;

    } else if (throwObj) {

      Object.assign(throwObj, {
        dx: x - throwObj.x, dy: y - throwObj.y, r: Math.hypot(x - throwObj.x, y - throwObj.y),
      });

      return false;
    }
  },

  onmouseup(e) {
    if (newObj && e.button == 0) {
      if (newObj.r > 0) {
        config.objects[newObj.id] = newObj;
      } else {
        newObj.element.remove();
      }
      newObj = null;

      return false;
    } else if (throwObj && e.button == 0) {
      [throwObj.obj.vx, throwObj.obj.vy] = [
        throwObj.dx,
        throwObj.dy,
      ];
      throwObj.element.remove();
      throwObj = null;
    } else if (selObj && e.button == 1) {
      for (let obj of Object.values(config.objects)) {
        if (Math.hypot(obj.x - selObj.x, obj.y - selObj.y) < (obj.r + selObj.r)) {
          obj.anchor = true;
        } else {
          delete obj.anchor;
        }
      }
      selObj.element.remove();
      selObj = null;
    }
  },

  onwheel(e) {
    let [x, y] = screenToWorld(e.clientX, e.clientY);

    let [dx, dy] = [
      x - config.camX,
      y - config.camY,
    ];

    let oldzoom = config.zoom;
    config.zoom -= (e.deltaY / body.clientHeight) * config.zoom;
    let zch = config.zoom / oldzoom;

    config.camX = x - dx / zch;
    config.camY = y - dy / zch;
  },

});

var prevAniTs;

requestAnimationFrame((fun => fun = (ts) => {
  draw((prevAniTs != null) ? Math.min((ts - prevAniTs) / 1000, 1) : 0);
  prevAniTs = ts;
  requestAnimationFrame(fun);
})());

</script>

entry #3

comments 0

post a comment


main.swift ASCII text
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import Foundation

private let G: Double = 6.6743e-11  // gravity, number found from an apple, update me when we find a graviton
private let T: Double = 21600  // 1 step = this time (in seconds (six hours))

// not using 3rd axis, but we could!
// simd because i cba writing a 2d/3d vector type
typealias Vec3 = SIMD3<Double>

struct Body {
  var name: String
  var mass: Double
  var pos: Vec3
  var vel: Vec3

  public mutating func imp(_ i: Vec3) {
    vel += i * T
    pos += vel * T
  }

  public func mag(_ other: Self) -> Vec3 {
    let r = other.pos - pos  // distance
    let d = sqrt(r.x * r.x + r.y * r.y + r.z * r.z)  // length
    let f = G * ((mass * other.mass) / (d * d))  // newton's headache
    let n = r / d  // normalize
    return f * n  // distance to vector
  }
}

// note: without the sol and jupiter, terra will slowly approach luna
// but i am too lazy to look up the values for other bodies
// also; this doesn't have axis inclination
// so it's going to be inaccurate to real life regardless
// but pretend it's real and earth is slowly going sideways
var bodies = [
  Body(
    name: "terra",
    mass: 5.972e+24,
    pos: Vec3(repeating: 0),
    vel: Vec3(repeating: 0)),
  Body(
    name: "luna",
    mass: 7.348e+22,
    pos: Vec3(3.844e+8, 0, 0),
    vel: Vec3(0, 1022, 0)),
]

// tsv we can plot~
print("index\tbody\tx\ty\tz")
for t in 0..<500 {
  var f = [Vec3](repeating: Vec3(repeating: 0), count: bodies.count)

  for i in 0..<bodies.count {
    let body = bodies[i]
    for j in 0..<bodies.count where i != j {
      f[i] += body.mag(bodies[j]) / body.mass
    }
  }

  for i in 0..<bodies.count {
    bodies[i].imp(f[i])
    print("\(t)\t\(bodies[i].name)\t\(bodies[i].pos.x)\t\(bodies[i].pos.y)\t\(bodies[i].pos.z)")
  }
}

entry #4

comments 0

post a comment


cg79.ipynb JSON text data
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 390,
      "metadata": {
        "id": "Rp3zxALJtc0S"
      },
      "outputs": [],
      "source": [
        "# This should be easy. We've done this before.\n",
        "\n",
        "import numpy as np\n",
        "import scipy.integrate as sc_int\n",
        "import matplotlib.pyplot as gr\n",
        "\n",
        "# Well, the dynamics are straightforward enough. I hadn't considered how to\n",
        "# make a bunch of objects aware of each other's presence. That kind of happens\n",
        "# automatically in the real world.\n",
        "#\n",
        "# Okay. I've got something."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Default title text\n",
        "# Actually, I need to look up how those interactive notebooks work. I mean, like\n",
        "# not interactive in the way that this is an Interactive Python NoteBook but\n",
        "# in how they can ask the user to input values and stuff.\n",
        "#\n",
        "# Yaha! Wow. Technology, huh?\n",
        "\n",
        "i_m_awesome = True # @param {type:\"boolean\"}"
      ],
      "metadata": {
        "id": "urXUFr_HyRAJ"
      },
      "execution_count": 391,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Starting parameters\n",
        "dimensions = 2 # @param [2] {type:\"raw\"}\n",
        "bodies = 3 # @param {type:\"slider\", min:2, max:10, step:1}\n",
        "# @markdown - don't add too many please!\n",
        "mass_spread = 10 # @param {type:\"number\"}\n",
        "# @markdown - how much biger the biggest than the smolst\n",
        "# This is false advertising, but don't tell anyone!\n",
        "initial_velocity_strangeness = 0 # @param {type:\"slider\", min:0, max:10, step:1}\n",
        "# @markdown - depending on how it works out they might try to escape\n",
        "\n",
        "U = 10\n",
        "G = 10\n",
        "# The NIST Reference on Constants, Units, and Uncertainty.\n",
        "# NIST. May 2024. Retrieved 18 May 2024."
      ],
      "metadata": {
        "id": "muoSN486z5ao"
      },
      "execution_count": 392,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "masses = np.ceil(np.random.rand(bodies)*mass_spread)\n",
        "maasse = np.sum(masses)\n",
        "xhomes = np.random.rand(bodies)*U*np.random.choice([2, -2],bodies)\n",
        "yhomes = np.random.rand(bodies)*U*np.random.choice([2, -2],bodies)\n",
        "xelsts = np.random.randn(bodies)*initial_velocity_strangeness\n",
        "yelsts = np.random.randn(bodies)*initial_velocity_strangeness\n",
        "\n",
        "# And that's how you create a universe! I'd better not say more, lest our gourd\n",
        "# blessed be its name make me smitten. There's a lot going on in my life right\n",
        "# now and I don't need those kinds of feelings slowing me down."
      ],
      "metadata": {
        "id": "aJ5NCawJ6Q2N"
      },
      "execution_count": 393,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#ok so you can do the total one and just take out the one one for each yeah\n",
        "#\n",
        "\n",
        "def moment(xposes, yposes, masses=masses):\n",
        "  return (np.sum(xposes*masses), np.sum(yposes*masses))\n",
        "\n",
        "def dGoddt(t, g):\n",
        "  #xs, ys, xv, yv = g\n",
        "  # I'm kind of losing it.\n",
        "  xs = g[:bodies]\n",
        "  ys = g[bodies:2*bodies]\n",
        "  xv = g[2*bodies:3*bodies]\n",
        "  yv = g[3*bodies:]\n",
        "  # I'm really losing it.\n",
        "\n",
        "  mx, my = moment(xs, ys)\n",
        "\n",
        "  opps = [((mx-xs[i]*masses[i])/(maasse-masses[i]),\n",
        "           (my-ys[i]*masses[i])/(maasse-masses[i])) for i in range(bodies)]\n",
        "\n",
        "  seps = [(opps[i][0]-xs[i],opps[i][1]-ys[i]) for i in range(bodies)]\n",
        "\n",
        "  puls = np.transpose(\n",
        "        [G*(maasse-masses[i])/(seps[i][0]**2+seps[i][1]**2) # GM/r^2\n",
        "        *np.array(seps[i])/np.sqrt(seps[i][0]**2+seps[i][1]**2) # direction\n",
        "        for i in range(bodies)])\n",
        "  # Isaac Newton, 1860. Retrieved May 2024.\n",
        "\n",
        "  return np.concatenate((xv, yv, puls[0], puls[1]),axis=None)"
      ],
      "metadata": {
        "id": "up-u37iz990B"
      },
      "execution_count": 394,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "eternity = sc_int.solve_ivp(dGoddt, (0, 1000),\n",
        "                            np.concatenate((xhomes,yhomes,xelsts,yelsts),\n",
        "                                           axis=None),\n",
        "                            dense_output=True)\n",
        "#ok #"
      ],
      "metadata": {
        "id": "TGvDYOb3bLgb"
      },
      "execution_count": 395,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# There's some more stuff we need.\n",
        "import matplotlib.animation as animation\n",
        "\n",
        "fi, ax = gr.subplots()\n",
        "ax.set(xlim=[-2*U,2*U],ylim=[-2*U,2*U])\n",
        "\n",
        "time = eternity.sol(np.arange(0, 1000, 1))\n",
        "xstars = time[:bodies].T\n",
        "ystars = time[bodies:2*bodies].T\n",
        "\"\"\"\n",
        "snapshot = ax.scatter(xhomes,yhomes)\n",
        "\n",
        "def update(f):\n",
        "  xs = xstars[:f]\n",
        "  ys = ystars[:f]\n",
        "  step = np.stack([xs,ys]).T\n",
        "  snapshot.set_offsets(step)\n",
        "  return snapshot\n",
        "\n",
        "_ = animation.FuncAnimation(fig=fi,func=update,frames=100,interval=30)\n",
        "gr.show()\n",
        "#\"\"\"\n",
        "xstars = time[:bodies].T\n",
        "ystars = time[bodies:2*bodies].T\n",
        "\n",
        "artists = []\n",
        "for i in range(len(xstars)):\n",
        "  thing = 2\n",
        "  snapshot = ax.plot(xstars[i],ystars[i])\n",
        "  artists.append(snapshot)\n",
        "\n",
        "_ = animation.ArtistAnimation(fig=fi,artists=artists,interval=400)\n",
        "gr.show()#\"\"\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 435
        },
        "id": "R5jd_Zt-lHgu",
        "outputId": "3652c327-74ca-4d90-b7c8-9970bc73af5f"
      },
      "execution_count": 396,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# what the FUCK how hard can it fucking be to output this shit so i can see if its even workng\n",
        "\n",
        "gr.plot(xstars,ystars)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "id": "1j4WSkaLyzy1",
        "outputId": "05f4abfd-ba46-4f55-fdd8-58cf655b5d9d"
      },
      "execution_count": 397,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7d126abec710>,\n",
              " <matplotlib.lines.Line2D at 0x7d126c7c0dd0>,\n",
              " <matplotlib.lines.Line2D at 0x7d126ae69850>]"
            ]
          },
          "metadata": {},
          "execution_count": 397
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# stupid gourd probably thinks its better than me"
      ],
      "metadata": {
        "id": "f52upBbjpk6O"
      },
      "execution_count": 398,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# I think I'm in love."
      ],
      "metadata": {
        "id": "d0r6i-2iZaKA"
      },
      "execution_count": 399,
      "outputs": []
    }
  ]
}

entry #5

comments 0

post a comment


newton.p8.png PNG image data, 160 x 205, 8-bit/color RGBA, non-interlaced

entry #6

comments 0

post a comment


game.rbxl data
1
cg: couldn't decode file contents
script.lua ASCII text, with CRLF line terminators
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
local folder = script.Parent
local Players = game:GetService("Players")

local vx = nil
local vy = nil
local vz = nil
local mass = nil
local dif = nil
local rad = nil
local move = nil
local cons = 5
	
game:GetService("RunService").Heartbeat:Connect(function(deltaTime)
	for _, myself in pairs(folder:GetChildren()) do
		if myself~=script then
			vx=myself:GetAttribute("vx")
			vy=myself:GetAttribute("vy")
			vz=myself:GetAttribute("vz")
			mass=myself:GetAttribute("mass")	
			for _, other in pairs(folder:GetChildren()) do
				if other~=myself and other~=script then
					dif = other.Position - myself.Position
					rad = math.sqrt(dif.X^2 + dif.Y^2 + dif.Z^2)
					vx = vx + (deltaTime * cons * other:GetAttribute("mass") * dif.X / (rad^3))
					vy = vy + (deltaTime * cons * other:GetAttribute("mass") * dif.Y / (rad^3))
					vz = vz + (deltaTime * cons * other:GetAttribute("mass") * dif.Z / (rad^3))
					
				end
			end
			myself.Position = myself.Position + Vector3.new(vx * deltaTime, vy * deltaTime, vz * deltaTime)
			if myself.Name=="spawn" then
				for _, player in Players:GetPlayers() do
					player.Character:WaitForChild("HumanoidRootPart").Position = myself.position + Vector3.new(0,(myself.Size.Y), 0)
					
				end
			end			
			myself:SetAttribute("vx", vx)
			myself:SetAttribute("vy", vy)
			myself:SetAttribute("vz", vz)
		end
	end

end)