def main():
"""
Main starting point for the program
:return: N/A
"""
Graphics.init()
FPS.init()
drawer = Drawer()
key_down_listeners = [drawer.on_key_down]
mouse_down_listeners = [drawer.on_mouse_down]
mouse_up_listeners = [drawer.on_mouse_up]
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
sys.exit()
if event.key == pygame.K_F10:
Graphics.toggle_fullscreen()
for delegate in key_down_listeners:
delegate(event.key, event.mod)
if event.type == pygame.MOUSEBUTTONDOWN or event.type == pygame.MOUSEBUTTONUP:
mouse_position = (event.pos[0] / Graphics.get_scale()[0],
event.pos[1] / Graphics.get_scale()[1])
if event.type == pygame.MOUSEBUTTONDOWN:
for delegate in mouse_down_listeners:
delegate(mouse_position, event.button)
if event.type == pygame.MOUSEBUTTONUP:
for delegate in mouse_up_listeners:
delegate(mouse_position, event.button)
drawer.update()
drawer.draw()
FPS.update()
Graphics.flip()
class Main(object):
def __init__(self):
pygame.init() # Initializes the pygame class.
self.isRunning = True
self.model = Model() #3
self.controller = Controller(self.model) #5
self.drawer = Drawer(self.model) #7
self.clock = pygame.time.Clock()
# Gameloop
def runGame(self):
while self.isRunning:
self.controller.execute()
self.drawer.draw()
bot_racket = Racket((
racket_width, HEIGHT // 2 - racket_height // 2),
racket_width, racket_height)
ball = Ball((WIDTH // 2 - racket_width // 2, HEIGHT // 2 - racket_width // 2),
racket_width, WIDTH // 80)
controller = Controller(WIDTH, HEIGHT, player_racket, bot_racket, ball)
drawer = Drawer(screen, WIDTH, HEIGHT, controller,
player_racket, bot_racket, ball)
# Game loop
running = True
clock = pygame.time.Clock()
framerate = 80
controller.release_ball(time.time())
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
pass
gameplay()
drawer.draw()
clock.tick(framerate)
class MainWindow(Tk.Tk):
WIDTH = 800
HEIGHT = 600
def __init__(self):
Tk.Tk.__init__(self)
self.filechooseoptions = self.getfilechooseoptions()
self.currentFileName = None
self.imageLabel = None
self.photo = None
self.toppanel = None
self.botpanel = None
self.manager = ImageManager()
self.canvas = None
self.raster = None
self.sphere = None
self.drawer = None
self.pixels = None
self.initialize()
def getfilechooseoptions(self):
options = {}
return options
def initialize(self):
self.title = "CGP5"
self.canvas = Tk.Canvas(self.botpanel, width=MainWindow.WIDTH, height=MainWindow.HEIGHT, bg="#F5F1DE")
self.canvas.pack()
self.raster = Tk.PhotoImage(width=MainWindow.WIDTH, height=MainWindow.HEIGHT)
self.canvas.create_image((0, 0), image=self.raster, state="normal", anchor="nw")
self.toppanel = Tk.Frame(self)
self.toppanel.pack(side=Tk.TOP)
self.botpanel = Tk.Frame(self)
self.botpanel.pack()
Tk.Button(self.toppanel, text="Choose an image", command=self.fileselecthandler).pack(side=Tk.LEFT)
Tk.Button(self.toppanel, text="Draw", command=self.draw).pack(side=Tk.LEFT)
self.imageLabel = Tk.Label(self.botpanel)
self.imageLabel.pack()
self.drawer = Drawer(self.raster)
self.mainloop()
def draw(self):
self.drawer.draw(self.photo, self.pixels)
def fileselecthandler(self):
self.currentFileName = tkFileDialog.askopenfilename(**self.filechooseoptions)
if self.currentFileName:
self.loadimage()
def loadimage(self):
self.manager.loadimage(self.currentFileName)
self.photo = self.manager.image
self.pixels = self.manager.raster
def drawimage(self):
if self.photo is None and self.imageLabel is None:
self.photo = ImageTk.PhotoImage(self.manager.image)
self.imageLabel = Tk.Label(self, image=self.photo).pack()
else:
self.photo = ImageTk.PhotoImage(self.manager.image)
self.imageLabel.configure(image=self.photo)
self.imageLabel.image = self.photo
if event.type == pygame.KEYDOWN:
if not moved_in_this_frame and not paused:
if event.key == pygame.K_w or event.key == pygame.K_UP:
set_player_orientation(0)
moved_in_this_frame = True
elif event.key == pygame.K_d or event.key == pygame.K_RIGHT:
set_player_orientation(1)
moved_in_this_frame = True
elif event.key == pygame.K_s or event.key == pygame.K_DOWN:
set_player_orientation(2)
moved_in_this_frame = True
elif event.key == pygame.K_a or event.key == pygame.K_LEFT:
set_player_orientation(3)
moved_in_this_frame = True
if event.key == pygame.K_p:
paused = not paused
elif event.key == pygame.K_g:
grid_on = not grid_on
elif not paused and event.key == pygame.K_h:
head.grow()
if not paused:
next_frame()
drawer.draw(grid_on, paused)
clock.tick(framerate)
class GreeneTree:
def __init__(self, maxN, minN):
self.root = None
self.maxN = maxN
self.minN = minN
self.drawer = Drawer(self)
def draw(self):
self.drawer.draw()
def __repr__(self):
output = str(self.root) + "|"
q = queue.Queue()
q2 = queue.Queue()
q.put(self.root)
while not q.empty():
u = q.get()
if u.depth != 1:
for idx, i in enumerate(u.children):
if (idx + 1) < len(u.children):
output = output + str(i) + ","
elif not q.empty():
output = output + str(i) + ":"
else:
output = output + str(i)
for idx, i in enumerate(u.children):
q2.put(i)
else:
for idx, i in enumerate(u.children):
if (idx + 1) < len(u.children):
output = output + i.val + ","
elif not q.empty():
output = output + i.val + ":"
else:
output = output + i.val
if q.empty():
if not q2.empty():
output = output + "|"
while not q2.empty():
q.put(q2.get())
return output
def insert(self, obj):
'''
insert new object into RTree
:param obj: object to insert
:return:
'''
if self.root is None:
self.root = self.Leaf(MBR.generate(obj.mbr), self.maxN, self.minN,
1)
self.root.children.append(obj)
return
n = self.root
while n.depth is not 1:
for i in n.children:
if i.mbr.contains(obj.mbr):
n = i
break
else:
node = n.find_min(n.children, obj)
node.mbr.resize(obj.mbr)
n = node
break
if len(n.children) < n.maxN:
n.children.append(obj)
while n is not None:
n.mbr.resize(obj.mbr)
n = n.parent
return
if len(n.children) == n.maxN:
n.children.append(obj)
self.overflow(n)
while n is not None:
n.mbr.resize(obj.mbr)
n = n.parent
return
def overflow(self, n):
u, v = n.split()
n.mbr.resize(u.mbr)
n.mbr.resize(v.mbr)
if n == self.root:
self.root = self.Branch(self.root.mbr, self.maxN, self.minN,
n.depth + 1)
self.root.children.extend([u, v])
u.parent = self.root
v.parent = self.root
else:
u.parent = n.parent
v.parent = n.parent
n.parent.children.remove(n)
n.parent.children.extend([u, v])
if len(n.parent.children) > self.maxN:
self.overflow(n.parent)
def search(self, obj):
'''
search for the mbr containing a given object
:param obj: object to search for
:return: mbr containing that object
'''
node = self.root
for i in node.children:
if i.mbr.contains(obj.mbr):
node = i
return node
class Node:
def __init__(self, mbr=None, maxN=None, minN=None, depth=None):
self.parent = None
self.children = list()
self.mbr = mbr
self.maxN = maxN
self.minN = minN
self.depth = depth
def split(self):
return None
@staticmethod
def find_min(nodes, insertion):
"""
Find the node most optimal for insertion
:param rt_nodes:
:param entry:
:return:
"""
e = []
for i in range(len(nodes)):
if nodes[i].mbr.contains(insertion.mbr):
v = 0
else:
v = MBR.generate2(nodes[i].mbr,
insertion.mbr).area - nodes[i].mbr.area
e.append({'node': nodes[i], 'expanded': v})
return min(e, key=lambda x: x['expanded'])['node']
class Leaf(Node):
def __init__(self, mbr=None, maxN=None, minN=None, depth=1):
super().__init__(mbr, maxN, minN, depth)
def split(self):
'''
split node if capacity is reached
:return: node a, b split from original
'''
d, x, y = -1, None, None
for i in range(len(self.children)):
for j in range(len(self.children)):
if i != j:
k = (self.children[i].mbr.euclidian_distance_rect(
self.children[j].mbr))
if k > d:
d = k
x = self.children[i]
y = self.children[j]
left = x.mbr.lower_right.x < y.mbr.upper_left.x
right = x.mbr.upper_left.x < y.mbr.lower_right.x
bottom = x.mbr.upper_left.y < y.mbr.lower_right.y
top = x.mbr.lower_right.y < y.mbr.upper_left.y
if left and bottom:
dist_x = y.mbr.lower_left.x - x.mbr.upper_right.x
dist_y = y.mbr.lower_left.y - x.mbr.upper_right.y
elif right and bottom:
dist_x = x.mbr.lower_left.x - y.mbr.upper_right.x
dist_y = y.mbr.lower_right.y - x.mbr.upper_left.y
elif left and top:
dist_x = y.mbr.lower_left.x - x.mbr.upper_right.x
dist_y = x.mbr.lower_left.y - y.mbr.upper_right.y
else:
dist_x = x.mbr.lower_left.x - y.mbr.upper_right.x
dist_y = x.mbr.lower_left.y - y.mbr.upper_right.y
normalized_x = dist_x / (self.mbr.upper_right.x -
self.mbr.upper_left.x)
normalized_y = dist_y / (self.mbr.upper_right.y -
self.mbr.lower_left.y)
if normalized_x > normalized_y:
sorted_children = sorted(
self.children,
key=lambda i:
(i.mbr.lower_left.x + i.mbr.lower_right.x) / 2)
else:
sorted_children = sorted(
self.children,
key=lambda i:
(i.mbr.upper_left.y + i.mbr.lower_right.y) / 2)
r = self.__class__(MBR.generate(x.mbr), self.maxN, self.minN,
self.depth)
s = self.__class__(MBR.generate(y.mbr), self.maxN, self.minN,
self.depth)
m = math.floor((self.maxN + 1) / 2)
for i in sorted_children[:m]:
r.children.append(i)
for i in sorted_children[-m:]:
s.children.append(i)
if (self.maxN + 1) % 2 != 0:
n = self.find_min([r, s], sorted_children[m])
n.children.append(sorted_children[m])
for i in [r, s]:
for j in range(len(i.children)):
if not i.mbr.contains(i.children[j].mbr):
i.mbr.resize(i.children[j].mbr)
return r, s
class Branch(Node):
def __init__(self, mbr=None, maxN=None, minN=None, depth=None):
super().__init__(mbr, maxN, minN, depth)
def split(self):
'''
split node if capacity is reached
:return: node a, b split from original
'''
d, x, y = -1, None, None
for i in range(len(self.children)):
for j in range(len(self.children)):
if i != j:
k = (self.children[i].mbr.euclidian_distance_rect(
self.children[j].mbr))
if k > d:
d = k
x = self.children[i]
y = self.children[j]
left = x.mbr.lower_right.x < y.mbr.upper_left.x
right = x.mbr.upper_left.x < y.mbr.lower_right.x
bottom = x.mbr.upper_left.y < y.mbr.lower_right.y
top = x.mbr.lower_right.y < y.mbr.upper_left.y
if left and bottom:
dist_x = y.mbr.lower_left.x - x.mbr.upper_right.x
dist_y = y.mbr.lower_left.y - x.mbr.upper_right.y
elif right and bottom:
dist_x = x.mbr.lower_left.x - y.mbr.upper_right.x
dist_y = y.mbr.lower_right.y - x.mbr.upper_left.y
elif left and top:
dist_x = y.mbr.lower_left.x - x.mbr.upper_right.x
dist_y = x.mbr.lower_left.y - y.mbr.upper_right.y
else:
dist_x = x.mbr.lower_left.x - y.mbr.upper_right.x
dist_y = x.mbr.lower_left.y - y.mbr.upper_right.y
normalized_x = dist_x / (self.mbr.upper_right.x -
self.mbr.upper_left.x)
normalized_y = dist_y / (self.mbr.upper_right.y -
self.mbr.lower_left.y)
if normalized_x > normalized_y:
sorted_children = sorted(
self.children,
key=lambda i:
(i.mbr.lower_left.x + i.mbr.lower_right.x) / 2)
else:
sorted_children = sorted(
self.children,
key=lambda i:
(i.mbr.upper_left.y + i.mbr.lower_right.y) / 2)
r = self.__class__(MBR.generate(x.mbr), self.maxN, self.minN,
self.depth)
s = self.__class__(MBR.generate(y.mbr), self.maxN, self.minN,
self.depth)
m = math.floor((self.maxN + 1) / 2)
for i in sorted_children[:m]:
r.children.append(i)
for i in sorted_children[-m:]:
s.children.append(i)
if (self.maxN + 1) % 2 != 0:
n = self.find_min([r, s], sorted_children[m])
n.children.append(sorted_children[m])
for i in [r, s]:
for j in range(len(i.children)):
i.children[j].parent = i
if not i.mbr.contains(i.children[j].mbr):
i.mbr.resize(i.children[j].mbr)
return r, s
class RTree:
def __init__(self, maxN, minN):
self.root = None
self.maxN = maxN
self.minN = minN
self.drawer = Drawer(self)
def draw(self):
self.drawer.draw()
def __repr__(self):
output = str(self.root.mbr) + ","
q = queue.Queue()
q2 = queue.Queue()
q.put(self.root)
while not q.empty():
u = q.get()
for idx, i in enumerate(u.members):
if (idx + 1) < len(u.members):
try:
output = output + i.val + ","
except:
output = output + str(i) + ","
elif not q.empty():
try:
output = output + i.val + ":"
except:
output = output + str(i) + ":"
else:
try:
output = output + i.val
except:
output = output + str(i)
for idx, i in enumerate(u.children):
q2.put(i)
if q.empty():
if not q2.empty():
output = output + "|"
while not q2.empty():
q.put(q2.get())
return output
def insert(self, obj):
'''
insert new object into RTree
:param obj: object to insert
:return:
'''
if self.root is None:
self.root = self.Node(MBR.generate(obj.mbr), self.maxN, self.minN)
self.root.members.append(obj)
return
n = self.root
while len(n.children) != 0:
for i in n.children:
if i.mbr.contains(obj.mbr):
n = i
break
else:
node = n.find_min(n.children, obj)
node.mbr.resize(obj.mbr)
n = node
break
if len(n.members) < n.maxN:
n.members.append(obj)
n.mbr.resize(obj.mbr)
node = n.parent
while node != None:
node.mbr.resize(obj.mbr)
node = node.parent
return
if len(n.members) == n.maxN:
n.members.append(obj)
self.overflow(n)
return
def overflow(self, n):
u, v = n.split()
if n == self.root:
self.root = self.Node(self.root.mbr, self.maxN, self.minN)
self.root.children.extend([u, v])
u.parent = self.root
v.parent = self.root
self.root.mbr.resize(v.mbr)
else:
u.parent = n.parent
v.parent = n.parent
n.parent.children.remove(n)
n.parent.children.extend([u, v])
n.parent.members.extend([u.mbr, v.mbr])
if len(u.parent.members) > self.maxN:
self.overflow(u.parent)
def search(self, obj):
'''
search for the mbr containing a given object
:param obj: object to search for
:return: mbr containing that object
'''
node = self.root
for i in node.children:
if i.mbr.contains(obj.mbr):
node = i
return node
class Node:
def __init__(self, mbr=None, maxN=None, minN=None):
self.parent = None
self.children = list()
self.members = list()
self.mbr = mbr
self.maxN = maxN
self.minN = minN
def insert(self, obj=None):
'''
insert new object into node
:param obj: object to insert
:return:
'''
if len(self.children) == 0:
self.members.append(obj)
if not self.mbr.contains(obj.mbr):
self.mbr.resize(obj.mbr)
if len(self.members) == self.maxN:
node_a, node_b = self.split()
self.children.extend([node_a, node_b])
return
return
def split(self):
'''
split node if capacity is reached
:return: node a, b split from original
'''
d, x, y = -1, None, None
for i in range(len(self.members)):
for j in range(len(self.members)):
if i != j:
k = (self.members[i].mbr.euclidian_distance_rect(
self.members[j].mbr))
if k > d:
d = k
x = self.members[i]
y = self.members[j]
r = self.__class__(MBR.generate(x.mbr), self.maxN, self.minN)
r.insert(x)
s = self.__class__(MBR.generate(y.mbr), self.maxN, self.minN)
s.insert(y)
m = [i for i in self.members if i != x and i != y]
for i in range(len(m)):
count = len(m) - i
rthresh = r.minN - len(r.members)
sthresh = s.minN - len(s.members)
if count == rthresh:
r.insert(m[i])
elif count == sthresh:
s.insert(m[i])
else:
n = self.find_min([r, s], m[i])
n.insert(m[i])
for i in [r, s]:
for j in range(len(i.members)):
if not i.mbr.contains(i.members[j].mbr):
i.mbr.resize(i.members[j].mbr)
return r, s
@staticmethod
def find_min(nodes, insertion):
"""
Find the node most optimal for insertion
:param rt_nodes:
:param entry:
:return:
"""
e = []
for i in range(len(nodes)):
if nodes[i].mbr.contains(insertion.mbr):
v = 0
else:
v = MBR.generate2(nodes[i].mbr,
insertion.mbr).area - nodes[i].mbr.area
e.append({'node': nodes[i], 'expanded': v})
return min(e, key=lambda x: x['expanded'])['node']
