CSC111 Homework 6 Solution Programs 2011
--D. Thiebaut 15:33, 7 November 2011 (EST)
Moving Balls
Program 1
# CSC 111 Thiebaut
# hw6a.py
# 111a-be
# Naomi Long
#
# This program shows two balls moving in the graphics window with three randomly
# placed black rectangles that they can get trapped inside. One white rectangle
# is generated that the balls reflect off of. Balls reverse direction when
# colliding with the window. Both balls are given random colors and
# random sizes.
#
# The initial location and speed of the balls are random, but such
# that the balls appear in the window and are visible. It is possible
# for a ball to have a Y speed of 0, so it only moves horizontally.
#
# If the balls end up inside of the black boxes or the range function runs for
# 1000 cycles, the program ends.
#
# If the balls collide, they reverse motion in the x and y direction. If the
# balls don't collide head-on, the collision looks fake. The balls can also
# get stuck in collision loops where they travel the same path for the rest
# of the program between two collisions, though this is unlikely because of the
# black boxes and the white box.
#
# If a ball starts with 0 speed in the Y axis, when collided with it will
# still keep 0 speed in that axis.
#
# If ball generates inside a box, it will be hidden for the rest of the program.
# A ball can collide with another ball even if theother ball is trapped in a
# box.
from graphics import *
import random
from math import *
def distance( P1, P2 ):
# computes distance for ball-on-ball collisions
x = sqrt(pow(P1.getX() - P2.getX(), 2) + pow(P1.getY() - P2.getY(), 2))
return x
def isInside(c, r, P1, P2, cr):
# calculates whether a ball is inside a black box
xc = c.getCenter().getX()
yc = c.getCenter().getY()
x1 = P1.getX()
y1 = P1.getY()
x2 = P2.getX()
y2 = P2.getY()
if (x1 + cr <= xc <= x2 - cr) and (y1 + cr <= yc <= y2 - cr):
return 0
def bounce(c, r, P1, P2, cr):
# calculates if outside edges of ball are touching white box
xc = c.getCenter().getX()
yc = c.getCenter().getY()
x1 = P1.getX()
y1 = P1.getY()
x2 = P2.getX()
y2 = P2.getY()
if (x1 - cr <= xc <= x2 + cr) and (y1 - cr <= yc <= y2 + cr):
return 0
def main():
# opens a graphics window
W = 600
H = 400
win = GraphWin("111a-be's billiard program", W, H)
win.setBackground(color_rgb(25, 25, 112))
# defines colors balls can be
colors = ["red", "blue", "green", "yellow", "black", "white"]
# draw 1st ball at random place with random velocity and random color
c1r = random.randrange(10, 20)
c1 = Circle(Point(random.randrange(50, W//2 - 50), # random X
random.randrange(50, H//2 - 50)), # random Y
c1r) # random radius
c1color = colors[random.randrange(5)] # random color
c1.setFill(c1color)
c1.setOutline(c1color)
dirX1 = random.randrange(-5, 5) # random X speed
if dirX1 == 0: # X can't be 0
dirX1 = dirX1 + 1
dirY1 = random.randrange(-5, 5) # random Y speed
c1.draw(win)
# draw 2nd ball at random place with random velocity and random color
c2r = random.randrange(10, 20)
c2 = Circle(Point(random.randrange(W//2, W-50), # random X
random.randrange(H//2, H-50)), # random Y
c2r) # random radius
c2color = colors[random.randrange(5)] # random color
c2.setFill(c2color)
c2.setOutline(c2color)
dirX2 = random.randrange(-5, 5) # random X speed
if dirX2 == 0: # X can't be 0
dirX2 = dirX2 + 1
dirY2 = random.randrange(-5, 5) # random Y speed
c2.draw(win)
# define sizes for boxes
s1 = 70
s2 = 80
s3 = 60
# define random coordinates for black boxes
p1a = random.randrange(10, W//3 - (s1 + 20))
p1b = random.randrange(10, H//2 - (s1 + 20))
P1 = Point(p1a, p1b)
P2 = Point(p1a + s1, p1b + s1)
p3a = random.randrange(W//3 + 10, (2 * W // 3) - (s2 + 20))
p3b = random.randrange(H//3 + 10, (2 * H // 3) - (s2 + 20))
P3 = Point(p3a, p3b)
P4 = Point(p3a + s2, p3b + s2)
p5a = random.randrange((2 * W // 3) + 20, W - (s3 + 20))
p5b = random.randrange((2 * H // 3) + 20, H - (s3 + 20))
P5 = Point(p5a, p5b)
P6 = Point(p5a + s3, p5b + s3)
# arranges points in rectangles
boxes = []
r = Rectangle( P1, P2 )
boxes.append(r)
r = Rectangle( P3, P4 )
boxes.append(r)
r = Rectangle( P5, P6 )
boxes.append(r)
# draws black boxes
for i in range(len(boxes)):
boxes[i].setFill("black")
boxes[i].draw(win)
# define size of white box
ws1 = 50
# define random coordinates for white box
wp1a = random.randrange(10, W//3 - (ws1 + 20))
wp1b = random.randrange(H//2 + 40, H - 40)
WP1 = Point(wp1a, wp1b)
WP2 = Point(wp1a + ws1, wp1b + ws1)
# draw white box
wr = Rectangle(WP1, WP2)
wr.setFill("white")
wr.setWidth(3)
wr.draw(win)
# moving balls and collisions
for i in range(1000):
stuck = 0
# moves balls at velocities given
c1.move(dirX1, dirY1)
c2.move(dirX2, dirY2)
# make c1 bounce off of walls
if c1.getCenter().getX() < c1r + 4 or c1.getCenter().getX() > W - c1r:
dirX1 = -dirX1
if c1.getCenter().getY() < c1r + 4 or c1.getCenter().getY() > H - c1r:
dirY1 = -dirY1
# make c2 bounce off of walls
if c2.getCenter().getX() < c2r + 4 or c2.getCenter().getX() > W - c2r:
dirX2 = -dirX2
if c2.getCenter().getY() < c2r + 4 or c2.getCenter().getY() > H - c2r:
dirY2 = -dirY2
# make balls reverse direction when they collide
if distance(c1.getCenter(), c2.getCenter()) <= (c1r + c2r):
dirX1 = -dirX1
dirY1 = -dirY1
dirX2 = -dirX2
dirY2 = -dirY2
# make ball 1 bounce off of white box
if bounce(c1, wr, WP1, WP2, c1r) == 0:
dirX1 = -dirX1
dirY1 = -dirY1
# make ball 2 bounce off of white box
if bounce(c2, wr, WP1, WP2, c2r) == 0:
dirX2 = -dirX2
dirY2 = -dirY2
# make ball 1 catch in black boxes
if isInside(c1, r, P1, P2, c1r) == 0:
dirX1 = 0
dirY1 = 0
if isInside(c1, r, P3, P4, c1r) == 0:
dirX1 = 0
dirY1 = 0
if isInside(c1, r, P5, P6, c1r) == 0:
dirX1 = 0
dirY1 = 0
# make ball 2 catch in black boxes
if isInside(c2, r, P1, P2, c2r) == 0:
dirX2 = 0
dirY2 = 0
if isInside(c2, r, P3, P4, c2r) == 0:
dirX2 = 0
dirY2 = 0
if isInside(c2, r, P5, P6, c2r) == 0:
dirX2 = 0
dirY2 = 0
# end program if both balls are stuck in black boxes
if (dirX1 == 0 and dirY1 == 0) and (dirX2 == 0 and dirY2 == 0):
t = Text(Point(W//2, H//2), "Click me to quit")
t.setFill("white")
t.draw(win)
win.getMouse()
win.close()
stuck = 1
break
# wait for one more click and close up window
if stuck != 1:
t1 = Text(Point(W//2, H//2), "Click me to quit")
t1.setFill("white")
t1.draw(win)
win.getMouse()
win.close()
main()
Program 2
- This version implements fully elastic collision and respects the laws of physics, even giving the two balls a mass proportional to their radii.
#hw6a.py
#111a-ar
#Gavi Levy Haskell
#
#This program is an adaptation of the hw6a Demo Program.
#Two balls, one turquoise and one blue, bounce off the
#walls, each other, and a white box, and stop if they
#completely enter one of three black boxes, or if the
#program goes through 1000 steps.
#
#
#NOTE: The circles bounce "realistically" assuming that:
#
#The speeds never exceed those which Newton's equations
#work for
#
#All collisions occur along the x-y axis (not true for
#virtually any collision, but a fair approximation for
#most blows, less good for glancing blows)
#
#The masses of the circles are relative to each other,
#imagining them to be 2D representations of 3D figures
#(spheres, to be precise)
#
#The world has no friction, either between objects or
#with the ground
#
#The collisions are perfectly elastic
from graphics import *
import random
def distance(P1, P2):
"""distance formula
"""
return (( (P1.getX() - P2.getX())**2 +
(P1.getY() - P2.getY())**2)**.5)
def velocity():
"""picks a random velocity
between -5 and 5, not 0
"""
v = 0
while True:
v = random.randrange(-5, 5)
if v!=0:
return v
def main():
#sets up graphics window
w = 600
h = 300
win = GraphWin("111a-ar: Ten to the Fifteenth", w, h)
win.setBackground("black")
#picks random radii
r1 = random.randrange(10, 20) #radius
r2 = random.randrange(10, 20) #radius
#calls velocity for all four velocities of the
#circle
vx1 = velocity()
vy1 = velocity()
vx2 = velocity()
vy2 = velocity()
#draws circles at random locations
c1 = Circle(Point(random.randrange(r1, w//2),
random.randrange(r1, h//2 - r1)),
r1)
c1.setWidth(0)
c1.setFill("turquoise")
c1.draw(win)
c2 = Circle(Point(random.randrange(r2, w//2),
random.randrange(h//2, h - r2)),
r2)
c2.setWidth(0)
c2.setFill("blue")
c2.draw(win)
#draws white box
rw = Rectangle(Point(400, 200),
Point(500, 250))
rw.setWidth(0)
rw.setFill("white")
rw.draw(win)
#draws three black boxes
boxes = [[10, 240, 80, 290],
[250, 80, 350, 130],
[520, 40, 570, 120]]
for i in range(3):
a, b, c, d = boxes[i]
rb = Rectangle(Point(a,b), Point(c,d))
rb.setOutline("white")
rb.setWidth(2)
rb.draw(win)
#loop to move circles
for i in range(1000):
#assigns locations of circles to variables
x1 = c1.getCenter().getX()
y1 = c1.getCenter().getY()
x2 = c2.getCenter().getX()
y2 = c2.getCenter().getY()
#variable to allow for turning off inter-
#action between circles when in black box
n = 0
#traps circles in black boxes
for j in range(3):
a,b,c,d = boxes[j]
#margin for circle 1
xl1 = a + r1
yu1 = b + r1
xr1 = c - r1
yb1 = d - r1
#if circle is inside box
if xl1 < x1 < xr1 and yu1 < y1 < yb1:
vx1 = 0 #set velocities
vy1 = 0 #to zero
n = 1 #indicates circle is in box
#margin for circle 2
xl2 = a + r2
yu2 = b + r2
xr2 = c - r2
yb2 = d - r2
#if circle is inside box
if xl2 < x2 < xr2 and yu2 < y2 < yb2:
vx2 = 0 #set velocities
vy2 = 0 #to zero
n = 1 #indicates circle is in box
#breaks if circles have been trapped
if vx1 == 0 and vy1 == 0 and vx2 == 0 and vy2 == 0:
break
#lets circles bounce off white box
#FIRST CIRCLE
lb1 = 400 - r1 #left bound for first circle
rb1 = 500 + r1 #right bound
ub1 = 200 - r1 #upper bound
bb1 = 250 + r1 #lower bound
if lb1 < x1 < rb1 and ub1 < y1 < bb1:
if 400 > x1: #on left side
vx1 = -abs(vx1) #bounce left
if 500 < x1: #on right side
vx1 = abs(vx1) #bounce right
if 200 > y1: #above
vy1 = -abs(vy1) #bounce up
if 250 < y1: #below
vy1 = abs(vy1) #bounce down
#SECOND CIRCLE
lb2 = 400 - r2 #left bound for second circle
rb2 = 500 + r2 #right bound
ub2 = 200 - r2 #upper bound
bb2 = 250 + r2 #lower bound
if lb2 < x2 < rb2 and ub2 < y2 < bb2:
if 400 > x2: #on left side
vx2 = -abs(vx2) #bounce left
if 500 < x2: #on right side
vx2 = abs(vx2) #bounce right
if 200 > y2: #above
vy2 = -abs(vy2) #bounce up
if 250 < y2: #below
vy2 = abs(vy2) #bounce down
#lets circles bounce off walls (w/o sticking)
#circle 1
if x1 < r1 + 5: #left side
vx1 = abs(vx1)
if x1 > w - r1: #right side
vx1 = -abs(vx1)
if y1 < r1 + 5: #top
vy1 = abs(vy1)
if y1 > h - r1: #bottom
vy1 = -abs(vy1)
#circle 2
if x2 < r2 + 5: #left side
vx2 = abs(vx2)
if x2 > w - r2: #right side
vx2 = -abs(vx2)
if y2 < r2 + 5: #top
vy2 = abs(vy2)
if y2 > h - r2: #bottom
vy2 = -abs(vy2)
#lets circles bounce off each other
#distance between circles
dc = distance(c1.getCenter(), c2.getCenter())
if dc <= (r1 + r2) and n == 0:
#"masses" of circles (relative, 3D)
m1 = r1*r1*r1
m2 = r2*r2*r2
#elastic collisions
a1 = (vx1*(m1 - m2) + 2*m2*vx2)/(m1 + m2)
a2 = (vx2*(m2 - m1) + 2*m1*vx1)/(m1 + m2)
b1 = (vy1*(m1 - m2) + 2*m2*vy2)/(m1 + m2)
b2 = (vy2*(m2 - m1) + 2*m1*vy1)/(m1 + m2)
vx1 = a1
vx2 = a2
vy1 = b1
vy2 = b2
#moves circles
c1.move(vx1, vy1)
c2.move(vx2, vy2)
text = Text(Point(w//2, h//2), "Click to quit")
text.setFill("white")
text.draw(win)
win.getMouse()
win.close()
main()
