class GUI(object):
def __init__(self, world):
self.ticks = 0
self.world = world
self.width = world.width
self.height = world.height
self.root = Tk()
self.root.title("Mars Explorer")
window_x, window_y = self._compute_window_coords()
self.root.geometry('%dx%d+%d+%d' %
(self.width, self.height, window_x, window_y))
self.canvas = Canvas(self.root, width=self.width, height=self.height)
self.canvas.pack()
self.canvas.after(1, self._tick)
def start(self):
self.root.mainloop()
def _tick(self):
# Stop if done.
if self.world.is_done():
return
self.world.tick()
self._draw()
self.ticks += 1
self.canvas.after(1, self._tick)
def _draw(self):
self.canvas.delete('all')
self.world.draw(self.canvas)
for entity in self.world.entities:
entity.draw(self.canvas)
self.canvas.create_text(self.width - 20, 10, text=str(self.ticks))
self.canvas.create_text(self.width - 70,
30,
text='Rocks in explorers: %d' %
self.world.rocks_in_explorers())
self.canvas.create_text(self.width - 70,
50,
text='Rocks delivered: %d' %
self.world.rocks_collected)
self.canvas.create_text(self.width - 55,
70,
text='Total rocks: %d' % self.world.num_rocks)
def _compute_window_coords(self):
# http://stackoverflow.com/a/14912644/742501
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
window_x = screen_width / 2 - self.width / 2
window_y = screen_height / 2 - self.height / 2
return window_x, window_y
class GUI(object):
def __init__(self, world):
self.ticks = 0
self.world = world
self.width = world.width
self.height = world.height
self.root = Tk()
self.root.title("Mars Explorer")
window_x, window_y = self._compute_window_coords()
self.root.geometry('%dx%d+%d+%d' % (self.width, self.height,
window_x, window_y))
self.canvas = Canvas(self.root, width=self.width, height=self.height)
self.canvas.pack()
self.canvas.after(1, self._tick)
def start(self):
self.root.mainloop()
def _tick(self):
# Stop if done.
if self.world.is_done():
return
self.world.tick()
self._draw()
self.ticks += 1
self.canvas.after(1, self._tick)
def _draw(self):
self.canvas.delete('all')
self.world.draw(self.canvas)
for entity in self.world.entities:
entity.draw(self.canvas)
self.canvas.create_text(self.width - 20, 10, text=str(self.ticks))
self.canvas.create_text(self.width - 70, 30,
text='Rocks in carriers: %d' % self.world.rocks_in_carriers())
self.canvas.create_text(self.width - 70, 50, text='Rocks delivered: %d' % self.world.rocks_collected)
self.canvas.create_text(self.width - 55, 70, text='Total rocks: %d' % self.world.num_rocks)
def _compute_window_coords(self):
# http://stackoverflow.com/a/14912644/742501
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
window_x = screen_width / 2 - self.width / 2
window_y = screen_height / 2 - self.height / 2
return window_x, window_y
class Animation:
def __init__(self):
root = Tk()
self.canvas = Canvas(root, height=500, width=500)
self.canvas.pack()
self.canvas.create_rectangle(0, 0, 500, 500, fill="#0D4566", outline="#0D4566") # space
self.venus = Planet(250, 150, self.canvas, "red")
self.earth = Planet(250, 100, self.canvas, "green")
self.sun = Planet(250, 250, self.canvas, "yellow")
self.start = time.time()
self.ticks = 0
self.done = False
self.timer()
root.mainloop()
def rotate_body(self, body, amount):
theta = math.degrees(amount)
x = body.x - 250
y = body.y - 250
x, y = x * math.cos(theta) - y * math.sin(theta), x * math.sin(theta) + y * math.cos(theta)
x += 250
y += 250
body.move_to(x, y)
self.canvas.update()
def timer(self):
if self.done:
print "Done after %2.2f seconds!" % (time.time() - self.start)
return
self.rotate_body(self.earth, math.pi / 36000 * 13.0)
self.rotate_body(self.venus, math.pi / 36000 * 8.0)
self.ticks += 1
if self.ticks % 2 == 0:
self.canvas.create_line(self.earth.x, self.earth.y, self.venus.x, self.venus.y, fill="white")
if self.ticks > 1250:
self.done = True
self.canvas.after(5, self.timer)
class FrameTk(object):
def __init__(self, height, width, box_size, title = "Tk", bg = None):
self.BOX_SIZE = box_size
self.main = Tk()
self.main.wm_title(title)
self.canvas = Canvas(self.main, height = height, width = width, bg = bg)
self.canvas.pack()
def run(self):
self.main.mainloop()
def repeat(self, end, timeMillis, callback):
def _repeat(end, time, func):
if self.sma.stop:
return
if end > 0:
end -= 1
self.repeat(end, time, func)
func()
self._draw()
self.canvas.after(timeMillis, _repeat, end, timeMillis, callback)
def after(self, timeMillis, callback):
def _callback(time, func):
if self.sma.stop:
return
self.after(time, func)
func()
self._draw()
self.canvas.after(timeMillis, _callback, timeMillis, callback)
def _draw(self):
pass
def drawTkImage(self, x, y, tkimage):
self.canvas.create_image(x, y, anchor = NW, image = tkimage)
def drawText(self, x, y, text, color = 'black', size = 8):
self.canvas.create_text(x, y, anchor = NW, text = text, font = ('Arial', size), width = self.BOX_SIZE, fill = color)
yp = 0.7 * h - 0.7 * h * y / 100.0
canvas.coords(ship, w / 4, yp)
if y >= 0.0:
canvas.after(1, tick)
root = Tk()
canvas = Canvas(root, width=w, height=h, bg='black')
canvas.pack()
img1 = Image.open('earthrise.jpg').resize((w, h))
pmg1 = ImageTk.PhotoImage(img1)
canvas.create_image(w / 2, h / 2, image=pmg1)
img2 = Image.open('eagle.jpg').resize((200, 200))
pmg2 = ImageTk.PhotoImage(img2)
ship = canvas.create_image(w / 4, 0, image=pmg2)
canvas.create_rectangle(w / 4 - 150,
int(0.5 + 0.7 * h) + 100,
w / 4 + 150,
int(0.5 + 0.7 * h) + 125,
outline='green',
fill='green')
print t, y, vy
canvas.after(1000, tick)
root.mainloop()
class PhyUI():
def callback_switcher(self):
""" Callback function for switching status between
'freezed' and 'on going'. """
play_ref = self.button_play
if not self.locked :
play_ref.config(text = "Play")
self.locked = True
else:
play_ref.config(text = "Freeze")
self.locked = False
def keyevent_up_press(self, event):
""" Callback for pressing up key. """
self.mouse_lock = True
self.selected_user_accel_factor[0] = 1
def keyevent_up_release(self, event):
""" Callback for releasing up key. """
self.mouse_lock = False
self.selected_user_accel_factor[0] = 0
def keyevent_down_press(self, event):
""" Callback for pressing down key. """
self.mouse_lock = True
self.selected_user_accel_factor[1] = 1
def keyevent_down_release(self, event):
""" Callback for releasing down key. """
self.mouse_lock = False
self.selected_user_accel_factor[1] = 0
def keyevent_left_press(self, event):
""" Callback for pressing left key. """
self.mouse_lock = True
self.selected_user_accel_factor[2] = 1
def keyevent_left_release(self, event):
""" Callback for releasing left key. """
self.mouse_lock = False
self.selected_user_accel_factor[2] = 0
def keyevent_right_press(self, event):
""" Callback for pressing right key """
self.mouse_lock = True
self.selected_user_accel_factor[3] = 1
def keyevent_right_release(self, event):
""" Callback for releasing right key """
self.mouse_lock = False
self.selected_user_accel_factor[3] = 0
def __init__(self, root_handle, canvas_width, canvas_height):
""" Setup the whole application."""
self.locked = True # True for freeze.
self.mouse_lock = False # True for locking the mouse behavior.
self.selected = None # What ball is selected now?
self.selected_user_accel_factor = [0, 0, 0, 0] # Acceleration from user's keypress event
self.selected_user_accel_val = [Vect2D(0, 15),
Vect2D(0, -5),
Vect2D(-5, 0),
Vect2D(5, 0)]
self.circles = [] # Reference to all the balls.
# Initialize the main variables for the application
self.frm_main = Frame(root_handle)
self.frm_side_top = LabelFrame(root_handle,
text = "Realtime Parameters:")
self.frm_side_bot = Frame(root_handle)
# Setup the frames
self.canv_width = canvas_width
self.canv_height = canvas_height
self.canvas_base = Vect2D(0, self.canv_height)
self.canvas = Canvas(
self.frm_main,
width = self.canv_width, height = self.canv_height,
bg = "#cccccc")
# Setup the canvas
self.canvas.bind_all("<KeyPress-w>", self.keyevent_up_press)
self.canvas.bind_all("<KeyRelease-w>", self.keyevent_up_release)
self.canvas.bind_all("<KeyPress-a>", self.keyevent_left_press)
self.canvas.bind_all("<KeyRelease-a>", self.keyevent_left_release)
self.canvas.bind_all("<KeyPress-d>", self.keyevent_right_press)
self.canvas.bind_all("<KeyRelease-d>", self.keyevent_right_release)
self.canvas.bind_all("<KeyPress-s>", self.keyevent_down_press)
self.canvas.bind_all("<KeyRelease-s>", self.keyevent_down_release)
# Setup all keys
self.button_play = Button(self.frm_side_bot,
text = "Play",
command = self.callback_switcher)
self.button_add = Button(self.frm_side_bot,
text = "Exit",
command = root_handle.quit)
# Setup all the buttons
side_names = ["Mass", "Positioin", "Velocity", "Acceleration"]
self.side_label = []
self.side_entry = []
for name in side_names:
self.side_label.append(Label(self.frm_side_top, text = name + ":"))
self.side_entry.append(Label(self.frm_side_top, width = 20))
# Setup information area located on the sidebar
self.frm_main.grid(row = 0, column = 0, rowspan = 2)
self.frm_side_top.grid(row = 0, column = 1, sticky = "S")
self.frm_side_bot.grid(row = 1, column = 1, sticky = "S")
self.canvas.grid(row = 0, column = 0, columnspan = 2)
self.button_play.grid(row = 1, column = 0, sticky = "E")
self.button_add.grid(row = 1, column = 1, sticky = "W")
for i in xrange(len(self.side_label)):
self.side_label[i].grid(row = i, column = 0)
self.side_entry[i].grid(row = i, column = 1)
# Build up the layout
def set_viewport(self, math_bl, math_tr):
"""
Set the translation rate.
You should call this before calling trans or rev_trans.
"""
self.scale_factor = Vect2D(
self.canv_width / float(math_tr.x - math_bl.x),
-self.canv_height / float(math_tr.y - math_bl.y))
self.math_base = math_bl
def trans(self, pos):
""" Translation (from math coord to canvas coord)."""
return (pos - self.math_base).scale(self.scale_factor) + \
self.canvas_base
def rev_trans(self, pos):
""" Reverse translation (from canvas coord to math coord)."""
return (pos - self.canvas_base).rev_scale(self.scale_factor) + \
self.math_base
def canvas_refresh(self, id, vertexes):
""" Refresh the canvas """
self.canvas.coords(id, vertexes)
def update_side_bot(self):
""" Update the information posted on the side bar."""
if self.selected:
self.side_entry[0].config(text = str(self.selected.mass))
self.side_entry[1].config(text = self.selected.shift.get_str())
self.side_entry[2].config(text = self.selected.velo.get_str())
self.side_entry[3].config(text = self.selected.accel.get_str())
else:
for i in xrange(4):
self.side_entry[i].config(text = "")
def create_circle(self, vertexes):
""" Create a circle graphically and return the id of the object. """
return self.canvas.create_oval(
vertexes,
fill="white"
)
def create_line(self, vertexes):
""" Create a line graphically and return the id of the object."""
return self.canvas.create_line(vertexes)
def register_trigger(self, obj, real_interval, math_interval):
""" Call this for hooking any simulated objects."""
self.canvas.after(
real_interval, obj.refresh, real_interval, math_interval)
class Game:
def __init__(self):
self.root = Tk()
self.frame1 = None
self.frame2 = None
self.w = None
self.scoreC = None
self.score = 0
self.hor = True
self.upid = self.downid = self.rightid = self.leftid = 0
self.head = -1
self.time = 700
def home(self):
self.frame1 = Frame(self.root, width=750, height=350, padx=250, bg="black")
self.frame2 = Frame(self.root, height=250, width=750, bg="black", padx=25)
self.root.wm_minsize(width=750, height=666)
self.root.configure(bg="black")
self.frame1.pack_propagate(0)
self.frame1.update()
self.frame1.configure(pady=self.frame1.cget("height") / 2.5)
logo = PhotoImage(file="Game_Logo.gif")
starth = Button(self.frame1, text="Hard", bg="orange", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(40))
startm = Button(self.frame1, text="Medium", bg="teal", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(60))
starte = Button(self.frame1, text="Easy", bg="orange", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(75))
self.frame2.pack_propagate(0)
exp = """ This is a game in which
the arrow keys are used
to move the snake around
and to get points"""
exf = Font(family="comic sans MS", size=20)
Label(self.frame2, image=logo, bg="black", text=exp, padx=10).pack(side="right")
Label(self.frame2, fg="white", bg="black", text=exp, justify="left", font=exf).pack(side="left")
starte.grid(row=0, columnspan=2)
startm.grid(row=0, columnspan=2, column=4, padx=18)
starth.grid(row=0, columnspan=2, column=8)
head = Font(family="comic sans MS", size=30)
self.H=Label(self.root, text="SNAKES", font=head, fg="orange", bg="black", pady=10)
self.H.pack()
self.frame2.pack(expand=True)
self.frame1.pack(expand=True)
self.root.mainloop()
def callgame(self, time):
self.time = time
self.game()
def calldown(self, key):
if self.hor:
self.w.after_cancel(self.leftid)
self.w.after_cancel(self.rightid)
self.down(0)
def callup(self, key):
if self.hor:
self.w.after_cancel(self.leftid)
self.w.after_cancel(self.rightid)
self.up(0)
def callright(self, key):
if not self.hor:
self.w.after_cancel(self.upid)
self.w.after_cancel(self.downid)
self.right(0)
def callleft(self, key):
if not self.hor:
self.w.after_cancel(self.upid)
self.w.after_cancel(self.downid)
self.left(0)
def game(self):
self.score = 0
self.w = Canvas(self.root, width=750, height=500, relief="flat", highlightbackground="grey",
highlightthickness=10)
self.frame1.destroy()
self.frame2.destroy()
self.root.configure(width=1000, padx=10)
self.root.pack_propagate(0)
self.w.configure(background="black")
self.w.pack(side="left")
self.w.create_line(300, 250, 450, 250, width=10, fill="teal")
self.scoreC = Label(self.root, text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35,
font=Font(family="comic sans MS", size=25))
self.head = self.w.create_line(450, 250, 455, 250, width=10, fill="white")
self.scoreC.pack(side="top")
self.root.bind("<Up>", self.callup)
self.root.bind("<Down>", self.calldown)
self.root.bind("<Right>", self.callright)
self.root.bind("<Left>", self.callleft)
self.createFood()
self.right(0)
def down(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] + 5, width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.downid = self.w.after(self.time, self.down, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def up(self, i):
crd = self.w.coords(1)
if len(crd)>0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] - 5, width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.upid = self.w.after(self.time, self.up, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def right(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] + 5, crd[-1], width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.rightid = self.w.after(self.time, self.right, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def left(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] - 5, crd[-1], width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.leftid = self.w.after(self.time, self.left, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def createFood(self):
# self.w.delete(self.food) #deleting old food.
crd = self.w.coords(1)
ext = []
for i in crd:
ext.append(i)
for j in range(-50, 50):
ext.append(i + j)
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
while randx not in ext and randy not in ext:
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
self.food = self.w.create_line(randx, randy, randx + 12, randy, width=10, fill="yellow")
def checkEaten(self):
headcoords = self.w.coords(self.head)
foodcoords = self.w.coords(self.food)
# self.w.delete(self.food)
flag = False
# print(headcoords[-4])
# print(foodcoords[-4])
# print(foodcoords[-2])
if int(headcoords[-4]) in range(int(foodcoords[-4]) - 7, int(foodcoords[-2]) + 7) and int(
headcoords[-3]) in range(int(foodcoords[-1]) - 10, int(foodcoords[-1] + 10)):
flag = True
if flag:
self.grow()
self.score += 10
self.scoreC.configure(text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35,
font=Font(family="comic sans MS", size=25))
self.w.delete(self.food)
self.createFood()
def grow(self):
crd = self.w.coords(1)
if crd[0] != crd[2]: # horizontal condition
if crd[0] < crd[2]:
crd[0] -= 20
else:
crd[0] += 20
self.w.coords(1, *crd)
else:
if crd[3] < crd[1]:
crd[1] += 20
else:
crd[1] -= 20
self.w.coords(1, *crd)
def end(self):
crd = self.w.coords(1)
h = self.w.coords(self.head)
a = 0
while a < len(crd) - 2:
if crd[a] == crd[a + 2]:
if (h[0] == crd[a] and crd[a + 1] < h[1] < crd[a + 3]) or (
h[0] == crd[a] and crd[a + 1] > h[1] > crd[a + 3]):
return True
else:
if (h[1] == crd[a + 1] and crd[a] < h[0] < crd[a + 2]) or (h[1] == crd[a + 1] and crd[a] > h[0] > crd[a + 2]):
return True
a += 2
if (h[0] == 0 and 0 < h[1] < 500) or (h[1] == 0 and 0 < h[0] < 750) or (h[1] == 510 and 0 < h[0] < 750) or (h[0] == 760 and 0<h[1]<500):
return True
return False
def callhome(self):
self.w.destroy()
self.start.destroy()
self.H.destroy()
self.scoreC.destroy()
self.home()
class FullScreenWindow:
def __init__(self, label_timeout, max_elements):
self.count = 0
self.colors_count = 0
self.tk = Tk()
self.max_elements = max_elements
self.frame = Frame(self.tk)
self.frame.bind("<Key>", self.key_press)
self.frame.focus_set()
self.state = False
self.tk.attributes("-fullscreen", True)
self.label_timeout = label_timeout
self.screen_width = self.tk.winfo_screenwidth()
self.screen_height = self.tk.winfo_screenheight()
screen_resolution = str(self.screen_width) + 'x' + str(self.screen_height)
self.tk.geometry(screen_resolution)
self.canvas = Canvas(self.frame, height=self.screen_height, width=self.screen_width)
self.canvas.pack(fill=BOTH)
self.frame.pack()
self.objects = deque()
def key_press(self, key):
self.draw_triangle()
def draw_triangle(self):
x1 = random.uniform(0, 1) * self.screen_width
y1 = random.uniform(0, 1) * self.screen_height
x2 = random.uniform(0, 1) * self.screen_width
y2 = random.uniform(0, 1) * self.screen_height
x3 = random.uniform(0, 1) * self.screen_width
y3 = random.uniform(0, 1) * self.screen_height
x4 = random.uniform(0, 1) * self.screen_width
y4 = random.uniform(0, 1) * self.screen_height
x5 = random.uniform(0, 1) * self.screen_width
y5 = random.uniform(0, 1) * self.screen_height
colors = ['black', 'red', 'green', 'blue', 'cyan', 'yellow', 'magenta']
if self.colors_count % 7 == 0:
self.colors_count = 0
if self.count == 0:
o = self.canvas.create_line(x1, y1, x2, y2, x3, y3, x1, y1)
self.count = 1
elif self.count == 1:
o = self.canvas.create_rectangle(x1, y1, x2, y2, fill=colors[self.colors_count])
self.colors_count += 1
self.count = 2
elif self.count == 2:
o = self.canvas.create_oval(x1, y1, x2, y2, fill=colors[self.colors_count])
self.colors_count += 1
self.count = 3
elif self.count == 3:
o = self.canvas.create_polygon(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, fill=colors[self.colors_count])
self.colors_count += 1
self.count = 0
if len(self.objects) >= self.max_elements:
obj_to_remove = self.objects.pop()
self.canvas.delete(obj_to_remove)
self.objects.appendleft(o)
self.canvas.after(self.label_timeout,self.canvas.delete, o)
self.frame.pack(fill=BOTH, expand=1)
class Photobooth:
def __init__(self, root):
self.root = root
self.previewing = False
self.camera = picamera.PiCamera()
## the canvas will display the images
self.canv = Canvas(root, width=WIDTH, height=HEIGHT)
self.canv.bind("<Button-1>", self.takePicture)
self.canv.pack()
def start(self):
# Show a psuedo preview while the preview isn't going
if not self.previewing:
self.previewImage()
# need to sleep instead
self.canv.after(100, self.start)
def previewImage(self):
self.camera.capture(RAW_FILENAME, resize=(WIDTH, HEIGHT))
image = Image.open(RAW_FILENAME)
self.displayImage(image)
def displayImage(self, im=None):
'''
display image im in GUI window
'''
#x,y = im.size
#x = int(x / SCALE)
#y = int(y / SCALE)
#im = im.resize((x,y));
#image_tk = ImageTk.PhotoImage(im)
## delete all canvas elements with "image" in the tag
if im is None:
return
self.canv.delete("image")
self.canv.create_image([WIDTH / 2, HEIGHT / 2],
image=im,
tags="image")
def takePicture(self, event):
self.previewing = True
self.camera.start_preview()
#camera.preview_alpha = 230
self.camera.preview_window = (0, 0, WIDTH, HEIGHT)
self.camera.preview_fullscreen = False
self.countdown()
self.camera.capture(RAW_FILENAME, resize=(WIDTH, HEIGHT))
snapshot = Image.open(RAW_FILENAME)
# Show it for a few seconds, then delete it
self.camera.stop_preview()
self.displayImage(snapshot)
time.sleep(10)
self.camera.remove_overlay(o)
self.previewing = False
return snapshot
def countdown(self, countdown1=5):
for i in range(countdown1):
self.camera.annotate_text = str(countdown1 - i)
#self.canv.delete("text")
#self.canv.update()
#self.canv.create_text(WIDTH/2 - 50, 300, text=str(countdown1 - i), font=font, tags="text")
#self.canv.update()
time.sleep(1)
class Game:
def __init__(self):
self.root = Tk()
self.frame1 = None
self.frame2 = None
self.w = None
self.scoreC = None
self.score = 0
self.hor = True
self.upid = self.downid = self.rightid = self.leftid = 0
self.head = -1
self.time = 700
def home(self):
self.frame1 = Frame(self.root,
width=750,
height=350,
padx=250,
bg="black")
self.frame2 = Frame(self.root,
height=250,
width=750,
bg="black",
padx=25)
self.root.wm_minsize(width=750, height=666)
self.root.configure(bg="black")
self.frame1.pack_propagate(0)
self.frame1.update()
self.frame1.configure(pady=self.frame1.cget("height") / 2.5)
logo = PhotoImage(file="logo.gif")
starth = Button(self.frame1,
text="Hard",
bg="orange",
padx=25,
pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(40))
startm = Button(self.frame1,
text="Medium",
bg="teal",
padx=25,
pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(60))
starte = Button(self.frame1,
text="Easy",
bg="orange",
padx=25,
pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(75))
self.frame2.pack_propagate(0)
exp = """ This is a game in which
the arrow keys are used
to move the snake around
and to get points"""
exf = Font(family="comic sans MS", size=20)
Label(self.frame2, image=logo, bg="black", text=exp,
padx=10).pack(side="right")
Label(self.frame2,
fg="white",
bg="black",
text=exp,
justify="left",
font=exf).pack(side="left")
starte.grid(row=0, columnspan=2)
startm.grid(row=0, columnspan=2, column=4, padx=18)
starth.grid(row=0, columnspan=2, column=8)
head = Font(family="comic sans MS", size=30)
self.H = Label(self.root,
text="SNAKES",
font=head,
fg="orange",
bg="black",
pady=10)
self.H.pack()
self.frame2.pack(expand=True)
self.frame1.pack(expand=True)
self.root.mainloop()
def callgame(self, time):
self.time = time
self.game()
def do_after_cancel(self, a, b):
if a != 0:
self.w.after_cancel(a)
if b != 0:
self.w.after_cancel(b)
def calldown(self, key):
if self.hor:
self.do_after_cancel(self.leftid, self.rightid)
self.down(0)
def callup(self, key):
if self.hor:
self.do_after_cancel(self.leftid, self.rightid)
self.up(0)
def callright(self, key):
if not self.hor:
self.do_after_cancel(self.upid, self.downid)
self.right(0)
def callleft(self, key):
if not self.hor:
self.do_after_cancel(self.upid, self.downid)
self.left(0)
def game(self):
self.score = 0
self.w = Canvas(self.root,
width=750,
height=500,
relief="flat",
highlightbackground="grey",
highlightthickness=10)
self.frame1.destroy()
self.frame2.destroy()
self.root.configure(width=1000, padx=10)
self.root.pack_propagate(0)
self.w.configure(background="black")
self.w.pack(side="left")
self.w.create_line(300, 250, 450, 250, width=10, fill="teal")
self.scoreC = Label(self.root,
text="Score\n" + str(self.score),
bg="black",
fg="teal",
padx=25,
pady=35,
font=Font(family="comic sans MS", size=25))
self.head = self.w.create_line(450,
250,
455,
250,
width=10,
fill="white")
self.scoreC.pack(side="top")
self.root.bind("<Up>", self.callup)
self.root.bind("<Down>", self.calldown)
self.root.bind("<Right>", self.callright)
self.root.bind("<Left>", self.callleft)
self.createFood()
self.right(0)
def down(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2],
crd[-1],
crd[-2],
crd[-1] + 5,
width=10,
fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.downid = self.w.after(self.time, self.down, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root,
text="Start",
bg="orange",
padx=25,
pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def up(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2],
crd[-1],
crd[-2],
crd[-1] - 5,
width=10,
fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.upid = self.w.after(self.time, self.up, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root,
text="Start",
bg="orange",
padx=25,
pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def right(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2],
crd[-1],
crd[-2] + 5,
crd[-1],
width=10,
fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.rightid = self.w.after(self.time, self.right, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root,
text="Start",
bg="orange",
padx=25,
pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def left(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2],
crd[-1],
crd[-2] - 5,
crd[-1],
width=10,
fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.leftid = self.w.after(self.time, self.left, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root,
text="Start",
bg="orange",
padx=25,
pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def createFood(self):
# self.w.delete(self.food) #deleting old food.
crd = self.w.coords(1)
ext = []
for i in crd:
ext.append(i)
for j in range(-50, 50):
ext.append(i + j)
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
while randx not in ext and randy not in ext:
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
self.food = self.w.create_line(randx,
randy,
randx + 12,
randy,
width=10,
fill="yellow")
def checkEaten(self):
headcoords = self.w.coords(self.head)
foodcoords = self.w.coords(self.food)
# self.w.delete(self.food)
flag = False
# print(headcoords[-4])
# print(foodcoords[-4])
# print(foodcoords[-2])
if int(headcoords[-4]) in range(
int(foodcoords[-4]) - 7,
int(foodcoords[-2]) + 7) and int(headcoords[-3]) in range(
int(foodcoords[-1]) - 10, int(foodcoords[-1] + 10)):
flag = True
if flag:
self.grow()
self.score += 10
self.scoreC.configure(text="Score\n" + str(self.score),
bg="black",
fg="teal",
padx=25,
pady=35,
font=Font(family="comic sans MS", size=25))
self.w.delete(self.food)
self.createFood()
def grow(self):
crd = self.w.coords(1)
if crd[0] != crd[2]: # horizontal condition
if crd[0] < crd[2]:
crd[0] -= 20
else:
crd[0] += 20
self.w.coords(1, *crd)
else:
if crd[3] < crd[1]:
crd[1] += 20
else:
crd[1] -= 20
self.w.coords(1, *crd)
def end(self):
crd = self.w.coords(1)
h = self.w.coords(self.head)
a = 0
while a < len(crd) - 2:
if crd[a] == crd[a + 2]:
if (h[0] == crd[a] and crd[a + 1] < h[1] < crd[a + 3]) or (
h[0] == crd[a] and crd[a + 1] > h[1] > crd[a + 3]):
return True
else:
if (h[1] == crd[a + 1] and crd[a] < h[0] < crd[a + 2]) or (
h[1] == crd[a + 1] and crd[a] > h[0] > crd[a + 2]):
return True
a += 2
if (h[0] == 0
and 0 < h[1] < 500) or (h[1] == 0 and 0 < h[0] < 750) or (
h[1] == 510 and 0 < h[0] < 750) or (h[0] == 760
and 0 < h[1] < 500):
return True
return False
def callhome(self):
self.w.destroy()
self.start.destroy()
self.H.destroy()
self.scoreC.destroy()
self.home()
class Simulation(object):
# Constructor
# @param duration Duration (in seconds) of the Simulation
# @param dt Time step
# @param height Height of the window
# @param width Width of the window
# @param env_file Path to the file containing Environment data
def __init__(self, duration, dt, height, width, env_file):
self._duration = duration
self._dt = dt
# Create the Canvas onto which everything will be rendered
self._root = Tk()
self._canvas = Canvas(
self._root,
width=width,
height=height)
self._canvas.grid(column=0, row=0, sticky=(N, W, E, S))
# Set the title, and make the Window un-sizable
self._parent = self._root
self._parent.title("Awesome Robot Simulation")
self._parent.resizable(0, 0)
# Determine the window position (centered nicely)
self.center_window(height, width)
# Read in the environment data
self._env = Environment()
self._env.set_dimensions(height, width)
if env_file:
self._env.read_env(env_file)
# Center the window on the screen
# @param wh Height of the window to center
# @param ww Width of the window to center
def center_window(self, wh, ww):
sw = self._parent.winfo_screenwidth()
sh = self._parent.winfo_screenheight()
x, y = (sw - ww) / 2, (sh - wh) / 2
self._parent.geometry('%dx%d+%d+%d' % (ww, wh, x ,y))
# Start the event loop
def start_event_loop(self):
self.timer_triggered()
self._parent.mainloop()
# When the timer goes off, update and redraw everything and reset the timer
def timer_triggered(self):
self.update()
self.redraw()
self._canvas.after(self._dt, self.timer_triggered)
# Update the simulation for the latest time step
def update(self):
sleep(0.05) # sleep so the animation doesn't finish too quickly
self._duration -= self._dt;
if not self._duration > 0:
raw_input("Press <Enter> to stop the simulation...")
# Print the results
print
for robot in self._env.robots():
M, N = robot.slam().M(), robot.slam().N()
for i in range(N):
computed_landmark_pos = np.matrix([0.0, 0.0]).T
for k in range(M):
computed_landmark_pos += robot.slam().particles()[k].features()[i][0]
computed_landmark_pos /= M
computed_landmark_x = computed_landmark_pos.item(0)
computed_landmark_y = computed_landmark_pos.item(1)
(actual_landmark_x, actual_landmark_y) = self._env.landmarks()[i].pos()
print "Landmark %d => actual: (%f, %f), computed: (%f, %f)" % \
(i, actual_landmark_x, actual_landmark_y, computed_landmark_x, computed_landmark_y)
print
# TODO --- maybe just take the particle with the highest weight (maybe top 2 or 3)? [same for landmarks]
actual_robot_x, actual_robot_y, actual_robot_theta = robot.pose()
computed_robot_x, computed_robot_y, computed_robot_theta = (0.0, 0.0, 0.0)
for k in range(M):
(p_x, p_y, p_theta) = robot.slam().particles()[k].pose()
computed_robot_x += p_x
computed_robot_y += p_y
computed_robot_theta += p_theta
print "Robot pose => actual: (%f, %f, %f), computed: (%f, %f, %f)" % \
(actual_robot_x, actual_robot_y, actual_robot_theta,
computed_robot_x / M, computed_robot_y / M, computed_robot_theta / M)
exit()
# Update all of the robots
updated_robots = []
for robot in self._env.robots():
updated_robots.append(robot.update(self._dt))
self._env._robots = updated_robots
# Redraw the canvas
def redraw(self):
self._canvas.delete(ALL)
for wall in self._env.walls():
wall.draw(self._canvas)
for landmark in self._env.landmarks():
landmark.draw(self._canvas)
for robot in self._env.robots():
robot.draw(self._canvas)
# Start the simulation
def start(self):
self.start_event_loop()
class App:
def __init__(self, master, height, width):
from Tkinter import Label, Entry, Canvas, Button
Label(master, text="Initial conditions:").grid(row=0, column=0, columnspan=2)
Label(master, text="q").grid(row=1, column=0)
Label(master, text="p").grid(row=2, column=0)
Label(master, text="t").grid(row=3, column=0)
Label(master, text="v").grid(row=4, column=0)
Label(master, text="b").grid(row=5, column=0)
Label(master, text="l").grid(row=6, column=0)
Label(master, text="g").grid(row=7, column=0)
Button(master, text="Reset", command=self.resetInitialConditions).grid(row=8, column=0, columnspan=2)
self.q = Entry(master)
self.p = Entry(master)
self.t = Entry(master)
self.v = Entry(master)
self.b = Entry(master)
self.l = Entry(master)
self.g = Entry(master)
self.q.grid(row=1, column=1)
self.p.grid(row=2, column=1)
self.t.grid(row=3, column=1)
self.v.grid(row=4, column=1)
self.b.grid(row=5, column=1)
self.l.grid(row=6, column=1)
self.g.grid(row=7, column=1)
self.canv = Canvas(master, height=height, width=width)
self.canv.grid(row=0, column=2, rowspan=8)
self.pendulum = DrivenPendulum()
self.q.insert(0, 2.)
self.p.insert(0, 0.)
self.t.insert(0, 0.)
self.v.insert(0, 2.)
self.b.insert(0, 1.)
self.l.insert(0, 1.5)
self.g.insert(0, -10.)
self.rad = 8
self.scaleFactor = 50
self.shiftPosition = array([width//2, height//2])
self.axes = self.canv.create_line(tuple(self.shiftPosition) + tuple(self.shiftPosition) + tuple(self.shiftPosition))
self.bob1 = self.canv.create_oval(self.getOvalCoords(self.shiftPosition), fill="blue")
self.bob2 = self.canv.create_oval(self.getOvalCoords(self.shiftPosition), fill="red")
self.resetInitialConditions()
self.updatePendulum()
def getOvalCoords(self, position):
return (position[0]-self.rad, position[1]-self.rad, position[0]+self.rad, position[1]+self.rad)
def updatePendulum(self):
pos1 = (self.scaleFactor*self.pendulum.getInnerPosition()*array([1, -1])).astype(int) + self.shiftPosition
pos2 = (self.scaleFactor*self.pendulum.getOuterPosition()*array([1, -1])).astype(int) + self.shiftPosition
self.canv.coords(self.axes, tuple(self.shiftPosition) + tuple(pos1) + tuple(pos2))
self.canv.coords(self.bob1, self.getOvalCoords(pos1))
self.canv.coords(self.bob2, self.getOvalCoords(pos2))
print self.pendulum.getPhaseSpacePoint()
self.pendulum.evolve(0.05)
self.canv.after(20, self.updatePendulum)
def resetInitialConditions(self):
self.pendulum.setInitialConditions(
float(self.q.get()),
float(self.t.get()),
float(self.v.get()),
float(self.p.get()),
float(self.b.get()),
float(self.l.get()),
float(self.g.get()),
)
class Stage(AnimationController, LeapListener):
#objects that will have physics applied to them
world_objects = {}
#place holder for the mouse x and y coordinates
mouse_x, mouse_y = 0, 0
hands = []
def mouseMoved(self, e):
"""
Event handler for moving the mouse on the canvas
This will set the mouse_x and mouse_y to the current mouse
coordinates
"""
self.mouse_x, self.mouse_y = int(e.x), int(e.y)
def startFiringWeapon(self, e):
"""
Creates a new bullet at the tip of the cannon head once
every 30 milliseconds until the Stage.weapon_firing bool
is false. At which time the thread will break out of its loop and die
"""
def keepFiring():
if Cannon.weapon_firing == True:
sound = self.bullet_snd.play()
Bullet(
position = self.world_objects["cannon"].cannon_head,
stage = self,
velocity = (-60, self.world_objects["cannon"].cannon_angle),
)
self.can.after(50, func=keepFiring)
Cannon.weapon_firing = True
keepFiring()
def stopFiringWeapon(self, e):
"""
Stops your gun from firing when you release the mouse button
"""
Cannon.weapon_firing = False
def __init__(self, root, snack):
self.snack = snack
self.click_loop = snack.Sound()
self.click_loop.load('test2_sounds/185768__jobro__click-loop.wav')
self.bullet_snd = snack.Sound()
self.bullet_snd.load('test2_sounds/gun.wav')
#set resolution to screen width
self.width = root.winfo_screenwidth()
self.height = root.winfo_screenheight()
root.wm_attributes('-fullscreen', 1)
#create a canvas to draw on
self.can = Canvas(root, cursor='none', width=self.width, height=self.height, background="black")
self.can.pack()
def playMusic():
self.click_loop.play()
info = self.click_loop.length(units="SECONDS")
self.can.after(int(info) * 1000, playMusic)
#playMusic()
#bind canvas events
self.can.bind("<Motion>", self.mouseMoved)
#create a cannon
c = Cannon(self)
self.world_objects["cannon"] = c
root.bind("a", c.moveLeft)
root.bind("d", c.moveRight)
def exit(e):
pid = os.getpid()
os.kill(pid, 9)
root.bind("<Escape>", exit)
self.can.bind("<ButtonPress-1>", self.startFiringWeapon)
self.can.bind("<ButtonRelease-1>", self.stopFiringWeapon)
#create the ground
self.world_objects["ground"] = Ground(self)
self.world_objects["stats"] = Stats(self)
self.world_objects["cube"] = Cube(self)
self.world_objects["crosshair"] = Crosshair(self)
LeapListener.__init__(self)
self.leap_controller = Leap.Controller()
self.leap_controller.add_listener(self)
#create my draw loop
self.drawLoop()
class Simulator(object):
def __init__(self):
tk=Tk()
tk.title = "T da B's Gravity Simulator"
self.width = 1900
self.height = 1000
self.canvas=Canvas(tk, width=self.width, height=self.height, bg='black')
self.masses = list()
self.new_masses = list()
for _ in range(20):
size = randint(3, 7)
m = MassiveObject(
size * 10**16,
size,
randint(100, self.width - 100),
randint(100, self.height - 100),
randint(-15, 15),
randint(-15, 15),
random_color()
)
m.canvas_id = self.canvas.create_oval(m.x - m.radius,
m.y - m.radius,
m.x + m.radius,
m.y + m.radius,
outline=m.color,
fill=m.color)
self.masses.append(m)
self.canvas.pack()
self.draw()
tk.mainloop()
def draw(self):
"""
Main loop
"""
for m in self.masses:
#if m.is_deleted is True:
# self.masses.remove(m)
# continue
for m2 in self.masses:
if m2 == m:
continue
else:
self.update(m, m2)
#m.draw_accel_vector()
#m.draw_vel_vector()
self.masses += self.new_masses
self.new_masses = list()
self.canvas.after(10, self.draw)
def update(self, m1, m2):
"""
Update MassiveObject m1 with respect to m2
"""
#if ( distance(m1, m2) < m1.radius + m2.radius ):
# logger.info("%s and %s collided!" % (m1.color, m2.color))
# self.canvas.delete(m1.canvas_id, m2.canvas_id)
# text = self.canvas.create_text((m1.x + m2.x) / 2,
# (m1.y + m2.y) / 2,
# text="COLLISION!",
# fill='red')
# self.canvas.after(1000, self.canvas.delete, text)
# m1.is_deleted = True
# m2.is_deleted = True
if ( distance(m1, m2) < m1.radius + m2.radius ):
self.canvas.delete(m1.canvas_id, m2.canvas_id)
'''
text = self.canvas.create_text((m1.x + m2.x) / 2,
(m1.y + m2.y) / 2,
text="COLLISION!",
fill='red')
self.canvas.after(1000, self.canvas.delete, text)
'''
self.masses.remove(m1)
self.masses.remove(m2)
mid_x = (m1.x + m2.x) / 2
mid_y = (m1.y + m2.y) / 2
c1 = m1.mass / (m1.mass + m2.mass)
c2 = m2.mass / (m1.mass + m2.mass)
v_x = c1 * m1.v_x + c2 * m2.v_x
v_y = c1 * m1.v_y + c2 * m2.v_y
new_m = MassiveObject(
m1.mass + m2.mass,
m1.radius + m2.radius,
mid_x,
mid_y,
v_x,
v_y,
avg_color(m1.color, m2.color)
)
new_m.canvas_id = self.canvas.create_oval(new_m.x - new_m.radius,
new_m.y - new_m.radius,
new_m.x + new_m.radius,
new_m.y + new_m.radius,
outline=new_m.color,
fill=new_m.color)
self.new_masses.append(new_m)
return
old_x = m1.x
old_y = m1.y
g_x, g_y = grav_force(m1, m2)
m1.a_x = g_x / m1.mass
m1.a_y = g_y / m1.mass
m1.t += m1.timestep
m1.x += m1.timestep * (m1.v_x + .5*(m1.timestep * m1.a_x))
m1.y += m1.timestep * (m1.v_y + .5*(m1.timestep * m1.a_y))
g_x, g_y = grav_force(m1, m2)
new_a_x, new_a_y = g_x / m1.mass, g_y / m1.mass
m1.v_x += m1.timestep * .5 * (m1.a_x + new_a_x)
m1.v_y += m1.timestep * .5 * (m1.a_y + new_a_y)
self.canvas.move(m1.canvas_id, m1.x - old_x, m1.y - old_y)
logger.info("Updated %s from (%s, %s) to (%s, %s)" % (m1.color, old_x, old_y, m1.x, m1.y))
def draw_accel_vector(self):
m = mag(self.x, self.y, self.x + self.a_x, self.y + self.a_y)
if m > 1:
line = self.canvas.create_line(self.x,
self.y,
self.x + self.a_x,
self.y + self.a_y,
fill='yellow',
arrow='last')
text = self.canvas.create_text(self.x + 1.2 * self.a_x,
self.y + 1.2 * self.a_y,
text=str(int(m)),
fill='yellow')
self.canvas.after(int(self.timestep * 1000), self.canvas.delete, line, text)
def draw_vel_vector(self):
m = mag(self.x, self.y, self.x + self.v_x, self.y + self.v_y)
if m > 1:
line = self.canvas.create_line(self.x,
self.y,
self.x + self.v_x,
self.y + self.v_y,
fill='red',
arrow='last')
text = self.canvas.create_text(self.x + 1.2 * self.v_x,
self.y + 1.2 * self.v_y,
text=str(int(m)),
fill='red')
self.canvas.after(int(self.timestep * 1000), self.canvas.delete, line, text)
