def test_is_intersect(self):
bodyA = Body(BodyGeometry(15, 15, 10, 10)) #10,10 20,20
bodyB = Body(BodyGeometry(15, 15, 10, 10))
bodyC = Body(BodyGeometry(15, 5, 10, 10)) #10,0 20,10
bodyD = Body(BodyGeometry(15, 25, 10, 10)) #10,20 20,30
bodyE = Body(BodyGeometry(5, 15, 10, 10)) #0,10 10,20
bodyF = Body(BodyGeometry(25, 15, 10, 10)) #20,10 30,20
bodyG = Body(BodyGeometry(15, 6, 10, 10)) #10,1 20,11
bodyH = Body(BodyGeometry(15, 24, 10, 10)) #10,19 20,29
bodyI = Body(BodyGeometry(6, 15, 10, 10)) #1,10 11,20
bodyJ = Body(BodyGeometry(24, 15, 10, 10)) #19,10 29,20
self.assertTrue(bodyA.is_intersect(bodyB))
self.assertFalse(bodyA.is_intersect(bodyC))
self.assertFalse(bodyA.is_intersect(bodyD))
self.assertFalse(bodyA.is_intersect(bodyE))
self.assertFalse(bodyA.is_intersect(bodyF))
self.assertTrue(bodyA.is_intersect(bodyG))
self.assertTrue(bodyA.is_intersect(bodyH))
self.assertTrue(bodyA.is_intersect(bodyI))
self.assertTrue(bodyA.is_intersect(bodyJ))
def __init__(self):
self.body = [Body(0, 0), Body(-1, 0), Body(-2, 0)]
self.body_sprites = pg.sprite.Group()
self.body_sprites.add(self.body)
# momentum inicial eh pra esquerda
self.momentum = [1, 0]
def __init__(self): n=2 fpos = 500000000 fvel = 100 self.bodies = [] self.bodies.append(Body([-0.97000436, 0.24308753], [-0.93240737/2.0, -0.86473146/2.0], 1.0, '#FF0000', '1')) self.bodies.append(Body([0.97000436, -0.24308753], [-0.93240737/2.0, -0.86473146/2.0], 1.0, '#00FF00', '2')) self.bodies.append(Body([0.0, 0.0], [0.93240737, 0.86473146], 1.0, '#0000FF', '3')) self.gravitationalConstant = 1 self.minDist = 0 self.skipFrames = 0 self.timeStep = 0.001 self.plotSize = 2.0 self.annotationShift = self.plotSize/25.0 self.markSizes = [50,200] self.lockedBody = -1
def processEvents(self):
for event in pg.event.get():
if event.type == pg.KEYDOWN:
if event.key == pg.K_SPACE:
self.paused = not self.paused
if event.key == pg.K_a:
self.display[
'acceleration'] = not self.display['acceleration']
if event.key == pg.K_n:
pos = pg.mouse.get_pos()
body = Body(self.color['body'], 10**6, 10, Vector(*pos),
Vector(0, 0), Vector(0, 0))
self.spawn(body)
if event.key == pg.K_s:
mouse_pos = Vector(*pg.mouse.get_pos())
body = Body(self.color['white'], 10**9, 10, mouse_pos,
Vector(0, 0), Vector(0, 0))
self.spawn(body)
if event.key == pg.K_q:
self.running = False
if event.key == pg.K_v:
self.display['velocity'] = not self.display['velocity']
if event.key == pg.K_x:
mouse_pos = Vector(*pg.mouse.get_pos())
for position, body in self.bodies.copy().items():
if mouse_pos.distance(position) < body.radius:
self.kill(position)
def main():
sun = Body(SUN_MASS, 0, 0, 0, 0, 24, 1, 1, 0,) # Yellow Sun
earth = Body(EARTH_MASS, SUN_EARTH, 0, 0, 30000, 8, 0, 0, 1) # blue earth
mercury = Body(MERCURY_MASS, SUN_MERCURY, 0, 0, 48000, 3, 1, 0.6, 0) # Brown Mercury
venus = Body(VENUS_MASS, SUN_VENUS, 0, 0, 35000, 6.5, 0, 1, 0) # Green Venus
mars = Body(MARS_MASS, SUN_MARS, 0, 0, 24000, 5, 1, 0, 0) # Red Mars
solar = System([sun, mercury, venus, earth, mars]) # Create the system
set_clear_color(0, 0, 0) # black background
enable_smoothing()
while not window_closed():
clear()
# Draw the system in its current state.
solar.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER)
# Update the system for its next state.
solar.update(TIMESTEP * TIME_SCALE)
# Draw the frame and take a brief nap.
request_redraw()
sleep(TIMESTEP)
def setUp(self) -> None:
self.mars = Body(M_MASS, M_COLOR, M_INIT_POS, M_INIT_VEL, M_INIT_ACC,
M_INIT_FORCE)
self.phobos = Body(P_MASS, P_COLOR, P_INIT_POS, P_INIT_VEL, P_INIT_ACC,
P_INIT_FORCE)
self.deimos = Body(D_MASS, D_COLOR, D_INIT_POS, D_INIT_VEL, D_INIT_ACC,
D_INIT_FORCE)
def example():
windows = tkinter.Tk()
windows.title('snake')
windows.geometry('320x240')
canvas = tkinter.Canvas(windows, bg='black', width=320, height=240)
canvas.pack()
snake = GuiSnake(canvas)
bodyA = Body(BodyGeometry(15, 5, 10, 10)) #10,0
bodyB = Body(BodyGeometry(25, 5, 10, 10)) #20,0
bodyC = Body(BodyGeometry(35, 5, 10, 10)) #30,0
bodyD = Body(BodyGeometry(45, 5, 10, 10)) #40,0
snake.add_head(bodyA)
snake.add_head(bodyB)
snake.add_head(bodyC)
snake.add_head(bodyD)
def move(event):
print(event.keysym)
if 'Up' == event.keysym:
snake.move_up(10)
elif 'Down' == event.keysym:
snake.move_down(10)
elif 'Left' == event.keysym:
snake.move_left(10)
elif 'Right' == event.keysym:
snake.move_right(10)
windows.bind('<Up>', move)
windows.bind('<Down>', move)
windows.bind('<Left>', move)
windows.bind('<Right>', move)
windows.mainloop()
def start_the_bodies(self, n: int):
"""
Initialize N bodies with random positions and circular velocities
"""
# Put something heavy into the center
self.bodies.append(Body(0, 0, 0, 0, 1e6 * self.solar_mass))
# Put some bodies around it
for i in range(n):
px = (self.radius + 1e8) * exp(-1.8) * (.5 - random())
py = (self.radius + 1e8) * exp(-1.8) * (.5 - random())
magv = self.circular_velocity(px, py) * (0.7 + random() * 0.5)
absangle = atan(abs(py / px))
thetav = pi / 2 - absangle
# https://finnaarupnielsen.wordpress.com/2011/05/18/where-is-the-sign-function-in-python/
vx = -1 * copysign(1, py) * cos(thetav) * magv
vy = copysign(1, px) * sin(thetav) * magv
# Most objects should orbit in one direction, but there may be exceptions
if random() <= 0.8:
vx = -vx
vy = -vy
mass = random() * self.solar_mass * 30 + 1e20
self.bodies.append(Body(px, py, vx, vy, mass))
def main():
# Solar system data comes from
# http://hyperphysics.phy-astr.gsu.edu/hbase/solar/soldata2.html
sun = Body(1.98892e30, 0, 0, 0, 0, 15, 1, 1, 0)
mercury = Body(.06 * EM, -.3871 * AU, 0, 0, 47890, 3, 1, .4, 0)
venus = Body(.82 * EM, -.7233 * AU, 0, 0, 35040, 6, 0, .6, .2)
earth = Body(1.0 * EM, -1.0 * AU, 0, 0, 29790, 7, 0, .4, 1)
mars = Body(.11 * EM, -1.524 * AU, 0, 0, 24140, 4, .8, .2, 0)
solar_system = System([sun, mercury, venus, earth, mars])
set_clear_color(0, 0, 0) # black background
enable_smoothing()
while not window_closed():
clear()
# Draw the system in its current state.
solar_system.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2,
PIXELS_PER_METER)
# Update the system for its next state.
solar_system.update(TIMESTEP * TIME_SCALE)
# Draw the frame and take a brief nap.
request_redraw()
sleep(TIMESTEP)
def main():
earth = Body(5.9736e24, 0, 0, 0, 0, 24, 0, 0, 1) # blue earth
moon = Body(7.3477e22, 3.84403e8, 0, 0, 1022, 4, 1, 1, 1) # white moon
earth_moon = System([earth, moon])
set_clear_color(0, 0, 0) # black background
enable_smoothing()
while not window_closed():
clear()
moon.update_velocity(
-0.25, -0.00004, TIMESTEP * TIME_SCALE
) # This is my new addition. I update the moon's velocity and position
moon.update_position(
TIMESTEP * TIME_SCALE
) # so that the moon moves and I can check the body class' methods
# Draw the system in its current state.
earth_moon.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER)
# Update the system for its next state.
# earth_moon.update(TIMESTEP * TIME_SCALE)
# Draw the frame and take a brief nap.
request_redraw()
sleep(TIMESTEP)
def generate_bullets(self, x, y, target, gamma):
angle = calculate_angle(x, y, *target)
pos_0 = (x + 20 * cos(angle + 0.74*pi), y - 20 * sin(angle + 0.74*pi))
pos_1 = (x + 20 * cos(angle - 0.74*pi), y - 20 * sin(angle - 0.74*pi))
return [(RegularBullet(*pos_0, self.bul_dmg, self.bul_vel, angle, Body(self.bul_body))),
(RegularBullet(*pos_1, self.bul_dmg, self.bul_vel, angle, Body(self.bul_body)))]
def __init__(self, position, rotation=90, scale=1, size=50, speed=300, turn_speed=5):
Creature.__init__(self, position, rotation, scale, size, speed, turn_speed)
self.head = Body(self, self.position, self.rotation, self.size, self.size, Categories.PLAYER, head=True, speed=speed)
self.bodies.append(self.head)
for i in range(0):
size = self.size
b = Body(self, self.position, self.rotation, size, size, Categories.PLAYER, speed=10)
b.attach_to(self.bodies[i])
self.bodies.append(b)
#arm1 = Leg(self.head, 10, 90, 30, offset=(self.head.width/2, 0), foot_size=10, walk=False)
#self.head.add_leg(arm1)
#arm2 = Leg(self.head, 10, -90, 30, offset=(-self.head.width/2, 0), foot_size=10, walk=False)
#self.head.add_leg(arm2)
#self.arms.append(arm1)
#self.arms.append(arm2)
for body in self.bodies:
body.add_leg(Leg(body, self.size*2, 15, 15, offset=(body.width/2 + 1, 0), foot_size=3))
body.add_leg(Leg(body, self.size*2, -15, 15, offset=(-body.width/2 - 1, 0), foot_size=3))
self.arm_counter = 0
def handle_event():
for event in pygame.event.get():
if event.type == QUIT:
Game.done = True
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
Game.done = True
elif event.key == K_LEFT:
o = Game.seasaw.orient - 0.1
Game.seasaw.setOrient(o)
elif event.key == K_RIGHT:
o = Game.seasaw.orient + 0.1
Game.seasaw.setOrient(o)
#elif event.type == MOUSEBUTTONDOWN:
b1, b2, b3 = pygame.mouse.get_pressed()
if b1:
Game.counter += 1
if Game.counter % 7 == 0:
mouseX, mouseY = pygame.mouse.get_pos()
#size = randint(10,40)
#b = Body(Circle(size), mouseX, Game.screen_size[1]-mouseY)
#verts = []
#vertCount = randint(3, Polygon.MAX_POLY_VERTEX_COUNT)
#for i in range(vertCount):
# verts.append(Vec2(randrange(-40,40), randrange(-40,40)))
hw = randrange(10, 40)
hh = randrange(10, 40)
#b = Body(Polygon(verts=verts), mouseX, Game.screen_size[1]-mouseY)
b = Body(Polygon(boxHw=hw, boxHh=hh), mouseX, mouseY)
#b.setOrient(1.5)
Game.bodies.append(b)
#print("vertices:",b.shape.vertices)
#print("normals:", b.shape.normals)
elif b2:
Game.counter += 1
if Game.counter % 7 == 0:
mouseX, mouseY = pygame.mouse.get_pos()
verts = []
vertCount = randint(3, Polygon.MAX_POLY_VERTEX_COUNT)
for i in range(vertCount):
verts.append(Vec2(randrange(-40, 40), randrange(-40, 40)))
b = Body(Polygon(verts=verts), mouseX, mouseY)
Game.bodies.append(b)
#print("vertices:",b.shape.vertices)
#print("normals:", b.shape.normals)
elif b3:
Game.counter += 1
if Game.counter % 7 == 0:
mouseX, mouseY = pygame.mouse.get_pos()
size = randint(10, 40)
b = Body(Circle(size), mouseX, mouseY)
Game.bodies.append(b)
def generate_bullets_auto(x, y, target, gamma):
pos_0 = (x + 96 * cos(gamma + 0.25*pi), y - 96 * sin(gamma + 0.25*pi))
pos_1 = (x + 96 * cos(gamma - 0.25*pi), y - 96 * sin(gamma - 0.25*pi))
angle_0 = calculate_angle(*pos_0, *target)
angle_1 = calculate_angle(*pos_1, *target)
return [RegularBullet(*pos_0, -1, 1.5, angle_0, Body(SMALL_BUL_BODY_1)),
RegularBullet(*pos_1, -1, 1.5, angle_1, Body(SMALL_BUL_BODY_1))]
def setUp(self) -> None:
mars = Body(M_MASS, M_COLOR, M_INIT_POS, M_INIT_VEL, M_INIT_ACC,
M_INIT_FORCE)
phobos = Body(P_MASS, P_COLOR, P_INIT_POS, P_INIT_VEL, P_INIT_ACC,
P_INIT_FORCE)
deimos = Body(D_MASS, D_COLOR, D_INIT_POS, D_INIT_VEL, D_INIT_ACC,
D_INIT_FORCE)
self.system = SimulatedSystem(mars, phobos, deimos)
def generate_bullets(self, x, y, target, gamma):
angle = calculate_angle(x, y, *target)
xo, yo = self.get_reference_point(x, y, angle)
pos_0 = xo + 6 * sin(angle), yo + 6 * cos(angle)
pos_1 = xo - 6 * sin(angle), yo - 6 * cos(angle)
return [RegularBullet(*pos_0, self.bul_dmg, self.bul_vel, angle, Body(self.bul_body)),
RegularBullet(*pos_1, self.bul_dmg, self.bul_vel, angle, Body(self.bul_body))]
def generate_bullets(self, x, y, target, gamma):
angle = calculate_angle(x, y, *target)
xo, yo = self.get_reference_point(x, y, angle)
pos_0 = (xo, yo)
pos_1 = (xo + 53 * cos(angle + 0.48*pi), yo - 53 * sin(angle + 0.48*pi))
pos_2 = (xo + 53 * cos(angle - 0.48*pi), yo - 53 * sin(angle - 0.48*pi))
return [(RegularBullet(*pos_0, -5, 0.75, angle, Body(BIG_BUL_BODY_1))),
(RegularBullet(*pos_1, -1, 0.1, angle, Body(SMALL_BUL_BODY_1))),
(RegularBullet(*pos_2, -1, 0.1, angle, Body(SMALL_BUL_BODY_1)))]
def test_count(self):
body = Body(BodyGeometry(15, 15, 10, 10))
baseSnake = BaseSnake(body)
count = 1
self.assertEqual(count, baseSnake.count())
body2 = Body(BodyGeometry(15, 15, 10, 10))
baseSnake.add_head(body2)
count += 1
self.assertEqual(count, baseSnake.count())
def main() -> None:
"""Initialize celestial bodies and display their simulation."""
mars = Body(M_MASS, M_COLOR, M_INIT_POS, M_INIT_VEL, M_INIT_ACC,
M_INIT_FORCE)
phobos = Body(P_MASS, P_COLOR, P_INIT_POS, P_INIT_VEL, P_INIT_ACC,
P_INIT_FORCE)
deimos = Body(D_MASS, D_COLOR, D_INIT_POS, D_INIT_VEL, D_INIT_ACC,
D_INIT_FORCE)
display_simulation(mars, phobos, deimos)
def generate_bullets(self, x, y, target, gamma):
angle = calculate_angle(x, y, *target)
xo, yo = self.get_reference_point(x, y, angle)
pos_0 = (xo, yo)
pos_1 = (xo + 15 * sin(angle - 0.17*pi), yo + 15 * cos(angle - 0.17*pi))
pos_2 = (xo - 15 * sin(angle + 0.17*pi), yo - 15 * cos(angle + 0.17*pi))
return [RegularBullet(*pos_0, self.bul_dmg, self.bul_vel, angle, Body(self.bul_body)),
RegularBullet(*pos_1, self.bul_dmg, self.bul_vel, angle - 0.17 * pi, Body(self.bul_body)),
RegularBullet(*pos_2, self.bul_dmg, self.bul_vel, angle + 0.17 * pi, Body(self.bul_body))]
def reset(self):
print("resetting bodies")
for planet in self.planets:
self.game.del_game_object(planet)
self.planets.clear()
self.planets = [
Body(self.game, "Sun", 1.9891e30, np.array([0, 0]),
np.array([0, 0]), 5, (255, 0, 0), False),
Body(self.game, "Mercury", 0.330e24, np.array([0, -57.9e9]),
np.array([47.4e3, 0]), 3, (255, 255, 0), self.TRACE_ENABLED),
Body(self.game, "Venus", 4.87e24, np.array([0, -108.2e9]),
np.array([35e3, 0]), 3, (0, 255, 255), self.TRACE_ENABLED),
Body(self.game, "Earth", 5.97219e24, np.array([0, -149.6e9]),
np.array([29.78e3, 0]), 3, (0, 0, 255), self.TRACE_ENABLED),
Body(self.game, "Mars", 0.642e24, np.array([0, -227.9e9]),
np.array([24.1e3, 0]), 3, (150, 0, 0), self.TRACE_ENABLED),
Body(self.game, "Jupiter", 1.89813e27, np.array([0, -778.5e9]),
np.array([13.06e3, 0]), 3, (0, 255, 0), self.TRACE_ENABLED),
Body(self.game, "Saturn", 568e24, np.array([0, -1433.5e9]),
np.array([9.7e3, 0]), 3, (0, 150, 150), self.TRACE_ENABLED),
Body(self.game, "Uranus", 86.8e24, np.array([0, -2872.5e9]),
np.array([6.8e3, 0]), 3, (150, 150, 0), self.TRACE_ENABLED),
Body(self.game, "Neptune", 102e24, np.array([0, -4495.1e9]),
np.array([5.4e3, 0]), 3, (150, 150, 150), self.TRACE_ENABLED),
]
def build_level(self):
# there's 7 levels
self.level %= 7
# get configuration of level:
this_level = self.levels[self.level]['map'] # get the map
# start positions of the first brick
start_x, start_y = self.levels[self.level]['cnf'][0:2]
# thikness of drawables stuffs
this_thikness = self.levels[self.level]['cnf'][2]
this_pad_w = self.levels[self.level]['cnf'][3]
this_pad_vel = self.levels[self.level]['cnf'][4]
this_ball_vel = self.levels[self.level]['cnf'][5]
self.level_title = self.levels[self.level]['cnf'][6]
# 1 - create the pad
for i in range(PAD_SIZE):
x_pos = self.boundary.w / 2 - (PAD_W / 2)
y_pos = self.boundary.h - (PAD_H + 5)
self.pad.append(Body(TYPE_PADDLE, x_pos, y_pos, BAL_COL))
self.pad[i].shape.w = this_pad_w
self.pad[i].thikness = this_thikness
self.pad[i].xvel = this_pad_vel
# 2 - create ball and let make it start from the center of the pad
for i in range(BALL_SIZE):
x_pos = self.pad[0].shape.x + (PAD_W / 2)
y_pos = self.pad[0].shape.y - (CIRCLE_RADIUS + 1)
self.ball.append(Body(TYPE_CIRCLE, x_pos, y_pos, BAL_COL))
self.ball[i].xvel = self.ball[i].yvel = -this_ball_vel
self.ball[i].thikness = this_thikness
del x_pos, y_pos
# 3 - build the level
x_pos = start_x
y_pos = start_y
i = 0
for row in this_level:
for brick in row:
if brick == 'n': # normal
self.color = NORMAL_BRICK
elif brick == 's': # solid
self.color = SOLID_BRICK
elif brick == 'r': # rock
self.color = ROCK_BRICK
elif brick == 'b': # bonus
self.color = BONUS_BRICK
elif brick == ' ': # empty space
x_pos += BRICK_W + 3
continue
self.brick.append(Body(TYPE_BRICK, x_pos, y_pos, self.color))
self.brick[i].thikness = this_thikness
i += 1
x_pos += BRICK_W + 3
y_pos += BRICK_H + 1
x_pos = start_x
def generate_bullets(self, x, y, target, gamma):
xo, yo = x + 90 * cos(gamma + 0.75*pi), y - 90 * sin(gamma + 0.75*pi)
angle_0 = calculate_angle(xo, yo, *target)
pos_0 = (xo + 40 * cos(angle_0), yo - 40 * sin(angle_0))
xo, yo = x + 90 * cos(gamma - 0.75*pi), y - 90 * sin(gamma - 0.75*pi)
angle_1 = calculate_angle(xo, yo, *target)
pos_1 = (xo + 40 * cos(angle_1), yo - 40 * sin(angle_1))
return [RegularBullet(*pos_0, self.bul_dmg, self.bul_vel, angle_0, Body(self.bul_body)),
RegularBullet(*pos_1, self.bul_dmg, self.bul_vel, angle_1, Body(self.bul_body))]
def main():
logger = get_logger(__name__)
print("Earth + Sun")
body1 = Body(id='a',
mass=1,
position=[0, 0, 0],
v0=[0, 0, 0],
color='yellow',
logger=logger)
body2 = Body(id='b',
mass=1,
position=[1, 0, 0],
v0=[0, 10, 0],
color='blue',
logger=logger)
# body3 = Body(id='c', mass=1*CONST_M_EARTH, position=[-1*CONST_AU, 0, 0], v0=[0,0,0], color='blue', logger=logger)
bodies = [body1, body2]
# calculate relative positions between all the bodies
# relpos_success = physics.relative_positions(bodies, logger=logger)
# net_gravity_success = physics.net_gravity(bodies, logger=logger)
# calc_acceleration_success = physics.calc_acceleration(bodies, logger=logger)
# net_force_success = system_net_force_check(bodies, logger=logger)
dt = 86400
t0 = 0
tf = dt * 300
times = np.arange(t0, tf + 1, dt)
fig, ax = plt.subplots(1, 1)
fig.set_size_inches(8, 5)
for t in times:
relpos_success = physics.relative_positions(bodies, logger=logger)
net_gravity_success = physics.net_gravity(bodies, logger=logger)
calc_acceleration_success = physics.calc_acceleration(bodies,
logger=logger)
calc_velocity_success = physics.calc_velocity(bodies,
dt,
logger=logger)
calv_position_success = physics.calc_position(bodies,
dt,
logger=logger)
for body in bodies:
ax.scatter(body.position[0],
body.position[1],
label=body.name,
color=body.color)
fig.savefig("./fig.png")
def __init__(self, pos1, vel1, pos2, vel2):
self.bodies = [
Body(color=(255, 0, 0)),
Body(color=(0, 255, 0),
pos=np.array([*pos1]),
vel=np.array([*vel1])),
Body(color=(0, 0, 255),
pos=np.array([*pos2]),
vel=np.array([*vel2]))
]
self.cur_body = self.bodies[0]
self.v3 = np.array([0.0, 0.0, 0.0])
def setUp(self):
body1 = Body(BodyGeometry(1, 1, 0, 0))
body2 = Body(BodyGeometry(2, 1, 0, 0))
body3 = Body(BodyGeometry(3, 1, 0, 0))
body4 = Body(BodyGeometry(4, 1, 0, 0))
self._bodys = [body4, body3, body2, body1]
self._baseSnake = BaseSnake()
index = len(self._bodys) - 1
while index >= 0:
# self._baseSnake.add_head(self._bodys[index]) 这样添加到_baseSnake的body跟_bodys里面的body是相同的对象
self._baseSnake.add_head(copy.deepcopy(self._bodys[index]))
index -= 1
def demo_1() -> World:
world = World(gravity=GRAVITY, iterations=IMPULSE_ITERATIONS)
body_1 = Body([100.0, 20.0])
body_1.position = np.array([0.0, 0.5 * body_1.width[1]])
world.add_body(body_1)
body_2 = Body([5.0, 5.0], 200.0)
body_2.position = np.array([0.0, 40.0])
world.add_body(body_2)
return world
def init():
pygame.init()
Game.screen = pygame.display.set_mode(Game.screen_size)
pygame.display.set_caption("physics engine 2d")
Game.done = False
Game.clock = pygame.time.Clock()
#b = Body( Circle(20), 140, 50)
#b = Body( Circle(100), 300, 600)
#b.setStatic()
#Game.bodies.append(b)
b = Body(Circle(100), 100, 600)
b.setStatic()
Game.bodies.append(b)
b = Body(Circle(20), 200, 350)
b.setStatic()
Game.bodies.append(b)
#Game.target = b
#b2 = Body( Circle(70), 100, 300)
#b2 = Body( Circle(90), 50, 150)
#b2.setStatic()
#Game.bodies.append(b2)
#b3 = Body( Circle(70), 200, 400)
#b3 = Body( Circle(100), 220, 50)
#b3.setStatic()
#Game.bodies.append(b3)
#b4 = Body( Circle(70), 350, 400)
#b4 = Body( Circle(200), 600, 0)
#b4.setStatic()
#Game.bodies.append(b4)
#verts = [Vec2(-17,10),Vec2(-33,-28),Vec2(-30,50),Vec2(10,20),Vec2(20,40),Vec2(17,-12), Vec2(-30,-10),Vec2(13,44)]
#b5 = Body( Polygon(verts=verts), 300, 400, math.pi/3 )
#b5 = Body( Polygon(boxHw=50, boxHh=100), 300, 400, math.pi/3 )
#b5.shape.setBox(50, 100)
#b5.setStatic()
#Game.bodies.append(b5)
b6 = Body(Polygon(boxHw=260, boxHh=10), 500, 300)
b6.setOrient(0)
b6.setStatic()
Game.bodies.append(b6)
Game.seasaw = b6
def test_will_dead_loop(self):
"""
12345
1 +++
2 + +
3 +o+
"""
body1 = Body(BodyGeometry(3, 3, 1, 1))
body2 = Body(BodyGeometry(3, 2, 1, 1))
body3 = Body(BodyGeometry(3, 1, 1, 1))
body4 = Body(BodyGeometry(4, 1, 1, 1))
body5 = Body(BodyGeometry(5, 1, 1, 1))
body6 = Body(BodyGeometry(5, 2, 1, 1))
body7 = Body(BodyGeometry(5, 3, 1, 1))
body8 = Body(BodyGeometry(4, 3, 1, 1))
snake = BaseSnake()
snake.add_head(body1)
snake.add_head(body2)
snake.add_head(body3)
snake.add_head(body4)
snake.add_head(body5)
snake.add_head(body6)
snake.add_head(body7)
snake.add_head(body8)
self.assertFalse(snake.is_will_dead_loop(Direction.DOWN))
self.assertTrue(snake.is_will_dead_loop(Direction.UP))
def main():
global total
print("--- ADVENT OF CODE 2019 DAY 6 ---")
f = open(args.input, 'r')
input = f.read()
orbitList = input.split('\n')
bodies = {}
bodies["COM"] = Body()
for orbit in orbitList:
name = orbit.split(')')[1]
bodies[name] = Body()
for orbit in orbitList:
o = orbit.split(')')
outer = o[1]
inner = o[0]
bodies[outer].parent = bodies[inner]
bodies[inner].addChild(bodies[outer])
# Start counting the orbits from the COM, then output the reults
countOrbits(bodies["COM"], 1)
print("PART1: Total number of direct and indirect orbits is %d!" % total)
# Part 2
start = bodies["YOU"].parent
end = bodies["SAN"].parent
# Find the bodies between santa and the COM
santaPath = [end]
current = end
while current != bodies["COM"]:
current = current.parent
santaPath.append(current)
# Find the first body in santa's path to the COM, climbing up from YOU
currentLength = 0
current = start
while not current in santaPath:
current = current.parent
currentLength += 1
# Print the distance
total = currentLength + santaPath.index(current)
print(
"PART2: Minimal required orbital transfers to get from YOU to SAN is {}!"
.format(total))