def update_elements(self):
if self._dirty and self.theme:
background = self.theme['window']['image_background']
title_bar = self.theme['window']['image_title_bar']
font = self.elements['title'].document.get_font()
height = font.ascent - font.descent
h = title_bar.padding_bottom + height + title_bar.padding_top
self.shapes['background'].update(self._gx, self._gy, self.w,
self.h)
self.shapes['title_bar'].update_in(
self._gx - background.padding_left, self._gy + self.h,
self.w + background.padding_left + background.padding_right, h)
self.elements['title'].x = self._gx + self.w / 2
self.topbar = Rect(
-background.padding_left, self.h,
self.w + background.padding_left + background.padding_right, h)
self.elements[
'title'].y = self._gy + self.h + title_bar.padding_bottom - font.descent
SingleContainer.update_elements(self)
def get_hitbox_collisions(self, other):
hitboxes = self.entity.animation_machine.get_hitboxes(key="damage")
hurtboxes = other.animation_machine.get_hitboxes(key="hurtbox")
rects = [other.get_collision_rect()] + hurtboxes
collisions = []
for h in hitboxes:
if "size" in h:
r = Rect(h["size"], h["position"])
collision = any([r.get_rect_collision(o) for o in rects])
if collision:
collisions.append(h)
if "radius" in h:
r = other.get_collision_rect()
radius = h["radius"]
position = h["position"]
collision = any(
[r.get_circle_collision(radius, position) for r in rects])
if collision:
collisions.append(h)
return collisions
def __init__(self, name):
self.name = name
self.model = {}
self._log = MessageLogger()
self.log = self._log.log
self.get_message = self._log.get_message
self.get_log = self._log.get_log
self.clock = Clock(name + " clock")
self.rect = Rect((1, 1), (0, 0))
self.controllers = []
self.control_freeze = False
self.visible = True
self._graphics = None
self._style = {}
self.sounds = {}
self.meters = {}
self.event = None
self.event_handler = EventHandler(self)
self.handle_event = self.event_handler.handle_event
self.queue_events({"name": "on_spawn"})
def update_elements(self):
if self._dirty and self.theme:
patch = self.theme['button'][('image_down'
if self._down else 'image_up')]
label = self.elements['label']
font = label.document.get_font()
height = font.ascent - font.descent
left = 0
if self.halign == 'center':
left = self.w / 2 - self._pref_size[0] / 2
elif self.halign == 'right':
left = self.w - self._pref_size[0]
bottom = 0
if self.valign == 'center':
bottom = self.h / 2 - self._pref_size[1] / 2
elif self.valign == 'top':
bottom = self.h - self._pref_size[1]
label.x = self._gx + left + patch.padding_left
label.y = self._gy + bottom + patch.padding_bottom
self.shapes['frame'].update(
self._gx + left + patch.padding_left,
self._gy + bottom + patch.padding_bottom, label.content_width,
height)
self.active_region = Rect(self._gx + left + patch.padding_left,
self._gy + bottom + patch.padding_bottom,
label.content_width, height)
Widget.update_elements(self)
def __init__(self, name):
self.scale = 1
self.view_rect = Rect((1, 1), (0, 0))
super(CameraLayer, self).__init__(name)
self.target_name = None
self.track_function = None
self.scale_function = None
def get_collision_rect(self):
hitbox = self.animation_machine.get_hitboxes("body")
hitbox = hitbox[0]
rect = Rect(hitbox["size"], hitbox["position"])
last = self.physics_interface.get_instantaneous_velocity()
last.rotate(.5)
rect.center = last.apply_to_point(rect.center)
return rect
def get_vector_image(vector, color, width, scale=1):
w, h = vector.get_value()
w = abs(w)
w *= scale
h = abs(h)
h *= scale
inner = Rect((w, h), (width, width))
w += width * 2
h += width * 2
outer = Rect((w, h), (0, 0))
# PYGAME CHOKE POINT
image = pygame.Surface(outer.size, pygame.SRCALPHA, 32)
q = vector.get_quadrant()
angle = vector.get_angle()
if q == 1 or q == 3:
if not (angle == 0 or angle == .5):
points = inner.bottomleft, inner.topright
else:
points = inner.midleft, inner.midright
if q == 1:
end = points[1]
else:
end = points[0]
else:
if not (angle == .25 or angle == .75):
points = inner.bottomright, inner.topleft
else:
points = inner.midbottom, inner.midtop
if q == 2:
end = points[1]
else:
end = points[0]
p1, p2 = points
p1 = int(p1[0]), int(p1[1])
p2 = int(p2[0]), int(p2[1])
pygame.draw.line(image, color, p1, p2, width)
end = int(end[0]), int(end[1])
pygame.draw.circle(image, color, end, width, 0)
return image
def windowShouldZoom_toFrame_(self, ns_frame):
'''ObjC callback to handle C{NSWindow} events.
'''
# <http://Developer.Apple.com/documentation/appkit/
# nswindowdelegate/1419533-windowshouldzoom>
ok = self.window.windowZoomOK_(Rect(ns_frame))
return YES if ok else NO
def update_elements(self):
if self._dirty and self.theme:
patch = self.theme['button'][('image_down' if self._down else 'image_up')]
label = self.elements['label']
font = label.document.get_font()
height = font.ascent - font.descent
left = 0
if self.halign == 'center':
left = self.w/2 - self._pref_size[0]/2
elif self.halign == 'right':
left = self.w - self._pref_size[0]
bottom = 0
if self.valign == 'center':
bottom = self.h/2 - self._pref_size[1]/2
elif self.valign == 'top':
bottom = self.h - self._pref_size[1]
label.x = self._gx + left + patch.padding_left
label.y = self._gy + bottom + patch.padding_bottom
self.shapes['frame'].update(self._gx + left + patch.padding_left, self._gy + bottom + patch.padding_bottom, label.content_width, height)
self.active_region = Rect(self._gx + left + patch.padding_left, self._gy + bottom + patch.padding_bottom, label.content_width, height)
Widget.update_elements(self)
def update_elements(self):
if self.theme:
patch = self.theme['folding_box'][('image_closed' if
self._collapsed else 'image')]
self.shapes['topbar'].update(
self._gx + patch.padding_left,
self._gy + self.h - patch.padding_top,
self.w - patch.padding_left - patch.padding_right, 1)
self.elements['title'].x = self._gx + patch.padding_left
self.elements[
'title'].y = self._gy + self.h - patch.padding_top / 2 + 1
self.topbar = Rect(0, self.h - patch.padding_top, self.w,
patch.padding_top)
SingleContainer.update_elements(self)
def __init__(self, text, **kwargs):
'''Create a button control
Keyword arguments:
action -- callback to be invoked when the button is clicked
'''
Widget.__init__(self, **kwargs)
self.elements['label'] = BasicLabel(text,
font_size=8,
color=(0, 0, 0, 255),
anchor_x='left',
anchor_y='bottom')
self.shapes['frame'] = Rectangle()
self.active_region = Rect(0, 0, 0, 0)
self.action = kwargs.get('action', None)
self._down = False
def load_screen(self, screen, left, top, right, bottom):
self.screen = screen
self.rect = Rect(left, top, right, bottom)
self.img_obj = Image.open(self.patient.photo)
self.img_obj = self.img_obj.resize((right - left, bottom - top),
Image.ANTIALIAS)
self.img_obj = PhotoImage(self.img_obj)
self.screen.create_image(self.rect.left,
self.rect.top,
image=self.img_obj,
anchor="nw")
def update_elements(self):
if self.theme:
patch = self.theme['folding_box'][('image_closed' if self._collapsed else 'image')]
self.shapes['topbar'].update(self._gx + patch.padding_left, self._gy + self.h - patch.padding_top, self.w - patch.padding_left - patch.padding_right, 1)
self.elements['title'].x = self._gx + patch.padding_left
self.elements['title'].y = self._gy + self.h - patch.padding_top/2 + 1
self.topbar = Rect(0, self.h-patch.padding_top, self.w, patch.padding_top)
SingleContainer.update_elements(self)
def __init__(self, title, **kwargs):
'''Create a dialogue
Keyword arguments:
name -- unique widget identifier
content -- child container
'''
SingleContainer.__init__(self, **kwargs)
self.resizeable = kwargs.get('resizeable', False)
self.shapes['background'] = Rectangle()
self.shapes['title_bar'] = Rectangle()
self.elements['title'] = BasicLabel(title, anchor_x='center')
self.topbar = Rect(0, 0, 0, 15)
self._in_drag = False
self.content = kwargs.get('content', None)
def load_screen(self, screen, left, top, right, bottom, next_point_label):
self.screen = screen
self.rect = Rect(left, top, right, bottom)
self.img_obj = Image.open(self.img)
self.img_obj = self.img_obj.resize((REF_WIDTH, REF_HEIGHT),
Image.ANTIALIAS)
self.img_obj = PhotoImage(self.img_obj)
self.screen.create_image(self.rect.left,
self.rect.top,
image=self.img_obj,
anchor="nw")
self.next_point_label = next_point_label
def __init__(self, planetTypes, settings):
self.pTypes = planetTypes
self.settings = settings
self.uniRect = Config.uniRect
self.wStartArea = Config.startAreaWidth
self.wTargetArea = Config.targetAreaWidth
self.spread = settings.planetSpread
r = self.uniRect
self.planetRect = Rect(r.xmin + self.wStartArea, r.ymin,
r.xmax - self.wTargetArea, r.ymax)
self.planets = None
self.startPlanet = None
self.targetPlanet = None
def draw(self):
for layer in self.space.layers:
scroll_lag = 0.05 * 0.5**layer.depth
parallax_view = view.View(self.view.screen, self.view.scale,
self.view.origin * scroll_lag)
stars = layer.get_stars(
Rect(parallax_view.origin.x, parallax_view.origin.y,
parallax_view.width, parallax_view.height))
for star in stars:
star.draw(parallax_view)
def __init__(self, text, **kwargs):
'''Create a button control
Keyword arguments:
action -- callback to be invoked when the button is clicked
'''
Widget.__init__(self, **kwargs)
self.elements['label'] = BasicLabel(text, font_size=8, color=(0,0,0,255), anchor_x='left', anchor_y='bottom')
self.shapes['frame'] = Rectangle()
self.active_region = Rect(0, 0, 0, 0)
self.action = kwargs.get('action', None)
self._down = False
def update_elements(self):
if self.theme:
patch = self.theme["folding_box"][("image_closed" if self._collapsed else "image")]
self.shapes["topbar"].update(
self._gx + patch.padding_left,
self._gy + self.h - patch.padding_top,
self.w - patch.padding_left - patch.padding_right,
1,
)
self.elements["title"].x = self._gx + patch.padding_left
self.elements["title"].y = self._gy + self.h - patch.padding_top / 2 + 1
self.topbar = Rect(0, self.h - patch.padding_top, self.w, patch.padding_top)
SingleContainer.update_elements(self)
def update_elements(self): if self._dirty and self.theme: background = self.theme['window']['image_background'] title_bar = self.theme['window']['image_title_bar'] font = self.elements['title'].document.get_font() height = font.ascent - font.descent h = title_bar.padding_bottom + height + title_bar.padding_top self.shapes['background'].update(self._gx, self._gy, self.w, self.h) self.shapes['title_bar'].update_in(self._gx - background.padding_left, self._gy + self.h, self.w + background.padding_left + background.padding_right, h) self.elements['title'].x = self._gx + self.w/2 self.topbar = Rect(-background.padding_left, self.h, self.w + background.padding_left + background.padding_right, h) self.elements['title'].y = self._gy + self.h + title_bar.padding_bottom - font.descent SingleContainer.update_elements(self)
def __init__(self, title, **kwargs):
'''Create a dialogue
Keyword arguments:
name -- unique widget identifier
content -- child container
'''
SingleContainer.__init__(self, **kwargs)
self.resizeable = kwargs.get('resizeable', False)
self.shapes['background'] = Rectangle()
self.shapes['title_bar'] = Rectangle()
self.elements['title'] = BasicLabel(title, anchor_x='center')
self.topbar = Rect(0, 0, 0, 15)
self._in_drag = False
self.content = kwargs.get('content', None)
def addPlanets(self, pt):
log(
'PlanetGenerator',
'Creating {n} {s} planets (radius: {r})'.format(n=pt.count,
s=pt.name,
r=pt.radius))
pr = self.planetRect
dr = pt.radius * self.spread
rect = Rect(pr.xmin + dr, pr.ymin + dr, pr.xmax - dr, pr.ymax - dr)
for n in range(pt.count):
pos = self.findPosition(rect, pt.radius)
if pos is not None:
p = Planet(pos, pt, self.randomPlanetRotation())
self.planets.append(p)
log(
'PlanetGenerator', 'Created {} planet at ({}, {})'.format(
pt.name, pos.x, pos.y))
else:
return False
return True
def __init__(self, title='Main', frame=None, excl=0, auto=False, **kwds):
'''Create a new L{Window}.
@keyword title: Window title (C{str}).
@keyword frame: Window frame (L{Rect}, L{NSRect_t}, L{NSRect4_t}, or None).
@keyword excl: Window styles to exclude (L{WindowStyle}C{.attribute}).
@keyword auto: Release window resource when closed (C{bool}).
@keyword kwds: Optional, additional keyword arguments.
@raise WindowError: Unique C{Id} exists.
'''
self._frame = Screen(0.5) if frame is None else Rect(frame)
self._ratio = self._frame.width, self._frame.height
self.NS = NSWindow.alloc(
).initWithContentRect_styleMask_backing_defer_(
self.frame.NS,
WindowStyle.Typical ^ excl, # PYCHOK expected
NSBackingStoreBuffered,
NO)
self.title = bytes2str(title)
self.front(True)
if kwds:
super(Window, self).__init__(**kwds)
# XXX self.NS.setIdentifier_(int2NS(id(self)))
self._NSuniqID = u = self.NS.uniqueID()
if u in _Globals.Windows:
raise WindowError('%s %r exists: %r' %
('.uniqueID', u, _Globals.Windows[u]))
_Globals.Windows[u] = self
if _Globals.App and not self.app:
self.app = _Globals.App
if auto:
self.NS.setReleasedWhenClosed_(YES)
self._auto = True
self.NSdelegate = retain(NSWindowDelegate.alloc().init(self))
def addCitiesPosition( self, cities ):
oldimages = self.listimages.values()
if oldimages:
try: self.windowback.removeControls( oldimages )
except:
for image in oldimages:
try: self.windowback.removeControl( image )
except: pass
oldicons = self.listicons.values()
if oldicons:
try: self.windowback.removeControls( oldicons )
except:
for icon in oldicons:
try: self.windowback.removeControl( icon )
except: pass
self.listimages = {}
self.listicons = {}
showcities = xbmc.getCondVisibility( "StringCompare(Window.Property(showcitieslayout),1)" )
if showcities:
rects = {}
for city in cities:
try:
lat, long = city[ "coords" ][ "lat" ][ 1 ], city[ "coords" ][ "long" ][ 1 ]
posx, posy = self.getPosition( float( lat ), float( long ), self.mapwidth, self.mapheight )
self.listimages[ lat+long ] = xbmcgui.ControlImage( posx-4, posy-4, 8, 8, self.pointer, colorDiffuse="0x"+self.colorDiffuse )
layout = ( posx-10, posy-10, 20, 20 )
rect = Rect( *layout )
if not rect.collidedictall( rects ):
# copy icon to cache, because linux not show icon with http://, on windows it's OK with url !!!
city[ "icon" ] = self.getIconCache( city[ "icon" ] )
self.listicons[ lat+long ] = xbmcgui.ControlImage( *layout, filename=city[ "icon" ] )
rects[ lat+long ] = rect
except:
pass
#print city[ "icon" ]
if self.listicons:
icons = self.listicons.values()
try:
self.windowback.addControls( icons )
for icon in icons:
icon.setVisibleCondition( "StringCompare(Window.Property(showcitiesicons),1)" )
except:
print_exc()
for icon in icons:
try:
self.windowback.addControl( icons )
icon.setVisibleCondition( "StringCompare(Window.Property(showcitiesicons),1)" )
except: print_exc()
if self.listimages:
images = self.listimages.values()
try:
self.windowback.addControls( images )
for image in images:
image.setVisibleCondition( "StringCompare(Window.Property(showcities),1)" )
except:
print_exc()
for image in images:
try:
self.windowback.addControl( image )
image.setVisibleCondition( "StringCompare(Window.Property(showcities),1)" )
except: print_exc()
class FoldingBox(SingleContainer):
"""Collapsible container"""
def __init__(self, title, **kwargs):
'''Create a folding box
Keyword arguments:
name -- unique widget identifier
content -- child container
collapsed -- if true, container folded initially
'''
SingleContainer.__init__(self, **kwargs)
self.shapes['topbar'] = Rectangle()
self.elements['title'] = BasicLabel(title, font_size=8, color=(0,0,0,255), anchor_x='left', anchor_y='center')
self.content = kwargs.get('content', None)
self._last_h = 15
self._collapsed = False
self._top_h = 0
self.collapsed = kwargs.get('collapsed', False)
def _get_title(self):
return self.elements['title'].text
def _set_title(self, title):
self.elements['title'].text = title
title = property(_get_title, _set_title)
def _get_collapsed(self):
return self._collapsed
def _set_collapsed(self, collapsed):
if collapsed != self._collapsed:
self._collapsed = collapsed
self._h, self._last_h = self._last_h, self._h
for c in self.children:
c.visible = not collapsed
if self.theme:
self.shapes['topbar'].patch = self.theme['folding_box'][('image_closed' if collapsed else 'image')]
self.find_root().update_layout()
collapsed = property(_get_collapsed, _set_collapsed)
def update_theme(self, theme):
SingleContainer.update_theme(self, theme)
if theme:
patch = theme['folding_box'][('image_closed' if self._collapsed else 'image')]
self.shapes['topbar'].patch = patch
self.elements['title'].font_name = theme['font']
self.elements['title'].font_size = theme['font_size_small']
self.elements['title'].color = theme['font_color']
if self._collapsed:
self._h = patch.padding_top
else:
self._last_h = patch.padding_top
self._top_h = patch.padding_top
def update_elements(self):
if self.theme:
patch = self.theme['folding_box'][('image_closed' if self._collapsed else 'image')]
self.shapes['topbar'].update(self._gx + patch.padding_left, self._gy + self.h - patch.padding_top, self.w - patch.padding_left - patch.padding_right, 1)
self.elements['title'].x = self._gx + patch.padding_left
self.elements['title'].y = self._gy + self.h - patch.padding_top/2 + 1
self.topbar = Rect(0, self.h-patch.padding_top, self.w, patch.padding_top)
SingleContainer.update_elements(self)
def determine_size(self):
self._content.determine_size()
size = self._content._pref_size
if self.collapsed:
self._pref_size = Size(size[0], self._top_h)
else:
self._pref_size = Size(size[0], size[1] + self._top_h)
def reset_size(self, size):
Widget.reset_size(self, size)
if not self.collapsed:
self._content.reset_size(Size(size.w, size.h - self._top_h))
def on_mouse_press(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and \
self.topbar.hit_test(x - self._gx, y - self._gy):
self.collapsed = not self.collapsed
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def clip_rect(self):
return Rect(self._gx, self._gy, self.w, self.h-15)
class CameraLayer(Layer):
def __init__(self, name):
self.scale = 1
self.view_rect = Rect((1, 1), (0, 0))
super(CameraLayer, self).__init__(name)
self.target_name = None
self.track_function = None
self.scale_function = None
def get_screen_px(self, world_px):
wx, wy = world_px
wx /= self.scale
wy /= self.scale
x, y = self.view_rect.topleft
return wx - x, wy - y
def get_world_px(self, screen_px):
sx, sy = screen_px
sx *= self.scale
sy *= self.scale
x, y = self.view_rect.topleft
sx += x
sy += y
return sx, sy
def get_scale(self):
return self.scale
def set_scale(self, value):
self.scale = value
self.set_view_rect_size()
def set_size(self, w, h):
super(CameraLayer, self).set_size(w, h)
self.set_view_rect_size()
def set_view_rect_size(self):
rect = self.view_rect
cx, cy = rect.center
w, h = self.size
w /= self.scale
h /= self.scale
rect.size = w, h
rect.center = cx, cy
def set_view_position(self, x, y):
self.view_rect.position = x, y
def set_focus(self, fx, fy):
self.view_rect.center = fx, fy
def set_tracking_function(self, obj, method_name):
self.track_function = getattr(obj, method_name)
def set_scale_function(self, obj, method_name, *args):
m = getattr(obj, method_name)
self.scale_function = lambda: m(*args)
def set_target(self, name):
self.target_name = name
def get_view_rect(self):
return self.view_rect.copy()
def get_camera_rects(self):
return [self.get_view_rect()]
def get_camera_surface(self, screen):
sub_rect = self.rect.clip(
screen.get_rect())
w, h = sub_rect.size
w /= self.scale
h /= self.scale
return pygame.Surface((w, h)).convert()
def get_camera_offset(self, offset=(0, 0)):
ox, oy = offset
vx, vy = self.view_rect.topleft
ox -= vx
oy -= vy
return ox, oy
def draw(self, screen, offset=(0, 0), draw_point=(0, 0)):
ox, oy = self.get_camera_offset(offset)
if self.scale != 1:
true_canvas = self.get_canvas(screen)
canvas = self.get_camera_surface(screen)
if self.graphics and self.visible:
true_canvas.blit(self.graphics.get_image(), draw_point)
self.draw_items(canvas, (ox, oy))
self.draw_sub_layers(canvas, (ox, oy), (ox, oy))
pygame.transform.scale(
canvas, true_canvas.get_size(), true_canvas)
else:
super(CameraLayer, self).draw(screen, (ox, oy), (ox, oy))
def draw_items(self, canvas, offset=(0, 0)):
ox, oy = offset
def get_height(i):
ix, iy = i.draw_point
w, h = i.image.get_size()
return iy + h
for g in self.groups:
items = [i for i in g if (i.graphics and i.image and i.visible)]
for item in sorted(items, key=get_height):
x, y = item.draw_point
x += ox
y += oy
canvas.blit(item.image, (x, y))
def update(self):
super(CameraLayer, self).update()
if self.track_function:
fx, fy = self.track_function()
self.set_focus(fx, fy)
if self.scale_function:
self.set_scale(self.scale_function())
def on_spawn(self):
if self.target_name:
obj = self.model[self.target_name]
self.set_tracking_function(obj, "get_position")
if "camera_scale" in obj.meters:
self.set_scale_function(obj, "get_meter_value", "camera_scale")
class Button(Widget):
"""Clickable button"""
def __init__(self, text, **kwargs):
'''Create a button control
Keyword arguments:
action -- callback to be invoked when the button is clicked
'''
Widget.__init__(self, **kwargs)
self.elements['label'] = BasicLabel(text, font_size=8, color=(0,0,0,255), anchor_x='left', anchor_y='bottom')
self.shapes['frame'] = Rectangle()
self.active_region = Rect(0, 0, 0, 0)
self.action = kwargs.get('action', None)
self._down = False
def _get_text(self):
return self.elements['label'].text
def _set_text(self, text):
self.elements['label'].text = text
text = property(_get_text, _set_text)
def update_theme(self, theme):
Widget.update_theme(self, theme)
if theme:
patch = theme['button'][('image_down' if self._down else 'image_up')]
label = self.elements['label']
label.font_name = self.theme['font']
label.font_size = self.theme['font_size']
label.color = theme['font_color']
font = label.document.get_font()
height = font.ascent - font.descent
self._pref_size = Size(patch.padding_left + label.content_width + patch.padding_right, patch.padding_bottom + height + patch.padding_top)
label.x = patch.padding_left + label.content_width/2
label.y = patch.padding_bottom + height/2 - font.descent
self.shapes['frame'].patch = patch
def update_elements(self):
if self._dirty and self.theme:
patch = self.theme['button'][('image_down' if self._down else 'image_up')]
label = self.elements['label']
font = label.document.get_font()
height = font.ascent - font.descent
left = 0
if self.halign == 'center':
left = self.w/2 - self._pref_size[0]/2
elif self.halign == 'right':
left = self.w - self._pref_size[0]
bottom = 0
if self.valign == 'center':
bottom = self.h/2 - self._pref_size[1]/2
elif self.valign == 'top':
bottom = self.h - self._pref_size[1]
label.x = self._gx + left + patch.padding_left
label.y = self._gy + bottom + patch.padding_bottom
self.shapes['frame'].update(self._gx + left + patch.padding_left, self._gy + bottom + patch.padding_bottom, label.content_width, height)
self.active_region = Rect(self._gx + left + patch.padding_left, self._gy + bottom + patch.padding_bottom, label.content_width, height)
Widget.update_elements(self)
def on_mouse_press(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and self.active_region.hit_test(x, y):
self.shapes['frame'].patch = self.theme['button']['image_down']
self._down = True
return pyglet.event.EVENT_HANDLED
Widget.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._down:
if self.active_region.hit_test(x, y):
self.shapes['frame'].patch = self.theme['button']['image_down']
else:
self.shapes['frame'].patch = self.theme['button']['image_up']
return pyglet.event.EVENT_HANDLED
Widget.on_mouse_drag(self, x, y, dx, dy, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_release(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._down:
self.shapes['frame'].patch = self.theme['button']['image_up']
self._down = False
if self.active_region.hit_test(x, y):
if self.action:
self.action(self)
return pyglet.event.EVENT_HANDLED
Widget.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def __str__(self): return '<Room %s %s>' % (Rect.__str__(self),self.connected)
def set_constants(self):
self.screenGamePlay = Rect(
self.getControl(1000).getPosition()[0],
self.getControl(1000).getPosition()[1],
self.getControl(1000).getWidth(),
self.getControl(1000).getHeight())
self.defaultWallRect = Rect(self.screenGamePlay.left,
self.screenGamePlay.top,
self.getControl(100).getWidth(),
self.getControl(100).getHeight())
self.defaultVausRect = Rect(
self.getControl(110).getPosition()[0],
self.getControl(110).getPosition()[1],
self.getControl(110).getWidth(),
self.getControl(110).getHeight())
self.defaultVausBigRect = Rect(
self.getControl(109).getPosition()[0],
self.getControl(109).getPosition()[1],
self.getControl(109).getWidth(),
self.getControl(109).getHeight())
self.ballControl = self.getControl(111)
# self.defaultBallRect.left = offset of self.defaultVausRect.left
self.defaultBallRect = Rect(
self.ballControl.getPosition()[0] - self.defaultVausRect.left,
self.ballControl.getPosition()[1], self.ballControl.getWidth(),
self.ballControl.getHeight())
self.defaultFireRect = Rect(
self.getControl(112).getPosition()[0],
self.getControl(112).getPosition()[1],
self.getControl(112).getWidth(),
self.getControl(112).getHeight())
self.defaultEnemyRect1 = Rect(
self.getControl(106).getPosition()[0],
self.getControl(106).getPosition()[1],
self.getControl(106).getWidth(),
self.getControl(106).getHeight())
self.defaultEnemyRect2 = Rect(
self.getControl(107).getPosition()[0],
self.getControl(107).getPosition()[1],
self.getControl(107).getWidth(),
self.getControl(107).getHeight())
# next level bonus
self.wrapEscape = self.getControl(103)
self.wrapEscape.setVisible(False)
self.labelGetReady = self.getControl(1001)
self.labelGetReady.setVisible(False)
self.wallsContainer = self.getControl(250)
self.vausPlayersContainer = self.getControl(150)
self.vausControl = self.getControl(500)
self.panelControls = self.getControl(10000)
def bounds(self):
return Rect(self._gx, self._gy, self.w, self.h + self.topbar.h)
def __init__(self, x, y, width, height, level=0):
self.left = None
self.right = None
self.level = level
self.color = None
self.rect = Rect(x, x + width - 1, y, y + height - 1)
class Dialogue(SingleContainer):
"""Moveable window, optionally resizeable"""
def __init__(self, title, **kwargs):
'''Create a dialogue
Keyword arguments:
name -- unique widget identifier
content -- child container
'''
SingleContainer.__init__(self, **kwargs)
self.resizeable = kwargs.get('resizeable', False)
self.shapes['background'] = Rectangle()
self.shapes['title_bar'] = Rectangle()
self.elements['title'] = BasicLabel(title, anchor_x='center')
self.topbar = Rect(0, 0, 0, 15)
self._in_drag = False
self.content = kwargs.get('content', None)
def _get_title(self):
return self.elements['title'].text
def _set_title(self, title):
self.elements['title'].text = title
title = property(_get_title, _set_title)
def update_theme(self, theme):
SingleContainer.update_theme(self, theme)
if theme:
background_patch = theme['window']['image_background']
title_patch = theme['window']['image_title_bar']
self.shapes['background'].patch = background_patch
self.shapes['title_bar'].patch = title_patch
self.elements['title'].font_name = theme['font']
self.elements['title'].font_size = theme['font_size_small']
self.elements['title'].color = theme['font_color']
font = self.elements['title'].document.get_font()
height = font.ascent - font.descent
self._pref_size = Size(title_patch.padding_x + self.elements['title'].content_width, background_patch.padding_y + title_patch.padding_y + height)
def update_elements(self):
if self._dirty and self.theme:
background = self.theme['window']['image_background']
title_bar = self.theme['window']['image_title_bar']
font = self.elements['title'].document.get_font()
height = font.ascent - font.descent
h = title_bar.padding_bottom + height + title_bar.padding_top
self.shapes['background'].update(self._gx, self._gy, self.w, self.h)
self.shapes['title_bar'].update_in(self._gx - background.padding_left, self._gy + self.h, self.w + background.padding_left + background.padding_right, h)
self.elements['title'].x = self._gx + self.w/2
self.topbar = Rect(-background.padding_left, self.h, self.w + background.padding_left + background.padding_right, h)
self.elements['title'].y = self._gy + self.h + title_bar.padding_bottom - font.descent
SingleContainer.update_elements(self)
def reset_size(self, size):
self._y += self._h - size.h
SingleContainer.reset_size(self, size)
def bounds(self):
return Rect(self._gx, self._gy, self.w, self.h + self.topbar.h)
def on_mouse_press(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and \
self.topbar.hit_test(x - self.x, y - self.y):
self._in_drag = True
self._offset_x = x - self.x
self._offset_y = y - self.y
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._in_drag:
self._x = x - self._offset_x
self._y = y - self._offset_y
self.find_root().update_layout()
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_drag(self, x, y, dx, dy, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_release(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._in_drag:
self._in_drag = False
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_release(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
class Button(Widget):
"""Clickable button"""
def __init__(self, text, **kwargs):
'''Create a button control
Keyword arguments:
action -- callback to be invoked when the button is clicked
'''
Widget.__init__(self, **kwargs)
self.elements['label'] = BasicLabel(text,
font_size=8,
color=(0, 0, 0, 255),
anchor_x='left',
anchor_y='bottom')
self.shapes['frame'] = Rectangle()
self.active_region = Rect(0, 0, 0, 0)
self.action = kwargs.get('action', None)
self._down = False
def _get_text(self):
return self.elements['label'].text
def _set_text(self, text):
self.elements['label'].text = text
text = property(_get_text, _set_text)
def update_theme(self, theme):
Widget.update_theme(self, theme)
if theme:
patch = theme['button'][('image_down'
if self._down else 'image_up')]
label = self.elements['label']
label.font_name = self.theme['font']
label.font_size = self.theme['font_size']
label.color = theme['font_color']
font = label.document.get_font()
height = font.ascent - font.descent
self._pref_size = Size(
patch.padding_left + label.content_width + patch.padding_right,
patch.padding_bottom + height + patch.padding_top)
label.x = patch.padding_left + label.content_width / 2
label.y = patch.padding_bottom + height / 2 - font.descent
self.shapes['frame'].patch = patch
def update_elements(self):
if self._dirty and self.theme:
patch = self.theme['button'][('image_down'
if self._down else 'image_up')]
label = self.elements['label']
font = label.document.get_font()
height = font.ascent - font.descent
left = 0
if self.halign == 'center':
left = self.w / 2 - self._pref_size[0] / 2
elif self.halign == 'right':
left = self.w - self._pref_size[0]
bottom = 0
if self.valign == 'center':
bottom = self.h / 2 - self._pref_size[1] / 2
elif self.valign == 'top':
bottom = self.h - self._pref_size[1]
label.x = self._gx + left + patch.padding_left
label.y = self._gy + bottom + patch.padding_bottom
self.shapes['frame'].update(
self._gx + left + patch.padding_left,
self._gy + bottom + patch.padding_bottom, label.content_width,
height)
self.active_region = Rect(self._gx + left + patch.padding_left,
self._gy + bottom + patch.padding_bottom,
label.content_width, height)
Widget.update_elements(self)
def on_mouse_press(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and self.active_region.hit_test(
x, y):
self.shapes['frame'].patch = self.theme['button']['image_down']
self._down = True
return pyglet.event.EVENT_HANDLED
Widget.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._down:
if self.active_region.hit_test(x, y):
self.shapes['frame'].patch = self.theme['button']['image_down']
else:
self.shapes['frame'].patch = self.theme['button']['image_up']
return pyglet.event.EVENT_HANDLED
Widget.on_mouse_drag(self, x, y, dx, dy, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_release(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._down:
self.shapes['frame'].patch = self.theme['button']['image_up']
self._down = False
if self.active_region.hit_test(x, y):
if self.action:
self.action(self)
return pyglet.event.EVENT_HANDLED
Widget.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def generate_map(self):
#fill map with "unblocked" tiles
self.tiles = [[Tile(True) for y in range(MAP_HEIGHT)]
for x in range(MAP_WIDTH)]
rooms = []
num_rooms = 0
for r in range(MAX_ROOMS):
#random width and height
w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
#random position without going out of the boundaries of the map
x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1)
y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1)
#"Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
#run through the other rooms and see if they intersect with this one
failed = False
for other_room in rooms:
if new_room.intersect(other_room):
failed = True
break
if not failed:
#this means there are no intersections, so this room is valid
#"paint" it to the map's tiles
create_room(new_room)
place_objects(new_room)
#center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
if num_rooms == 0:
#this is the first room, where the player starts at
player.x = new_x
player.y = new_y
npc.x = new_x + 1
npc.y = new_y + 1
else:
#all rooms after the first:
#connect it to the previous room with a tunnel
#center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
#draw a coin (random number that is either 0 or 1)
if libtcod.random_get_int(0, 0, 1) == 1:
#first move horizontally, then vertically
create_h_tunnel(prev_x, new_x, prev_y)
create_v_tunnel(prev_y, new_y, new_x)
else:
#first move vertically, then horizontally
create_v_tunnel(prev_y, new_y, prev_x)
create_h_tunnel(prev_x, new_x, new_y)
#finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
class Dialogue(SingleContainer):
"""Moveable window, optionally resizeable"""
def __init__(self, title, **kwargs):
'''Create a dialogue
Keyword arguments:
name -- unique widget identifier
content -- child container
'''
SingleContainer.__init__(self, **kwargs)
self.resizeable = kwargs.get('resizeable', False)
self.shapes['background'] = Rectangle()
self.shapes['title_bar'] = Rectangle()
self.elements['title'] = BasicLabel(title, anchor_x='center')
self.topbar = Rect(0, 0, 0, 15)
self._in_drag = False
self.content = kwargs.get('content', None)
def _get_title(self):
return self.elements['title'].text
def _set_title(self, title):
self.elements['title'].text = title
title = property(_get_title, _set_title)
def update_theme(self, theme):
SingleContainer.update_theme(self, theme)
if theme:
background_patch = theme['window']['image_background']
title_patch = theme['window']['image_title_bar']
self.shapes['background'].patch = background_patch
self.shapes['title_bar'].patch = title_patch
self.elements['title'].font_name = theme['font']
self.elements['title'].font_size = theme['font_size_small']
self.elements['title'].color = theme['font_color']
font = self.elements['title'].document.get_font()
height = font.ascent - font.descent
self._pref_size = Size(
title_patch.padding_x + self.elements['title'].content_width,
background_patch.padding_y + title_patch.padding_y + height)
def update_elements(self):
if self._dirty and self.theme:
background = self.theme['window']['image_background']
title_bar = self.theme['window']['image_title_bar']
font = self.elements['title'].document.get_font()
height = font.ascent - font.descent
h = title_bar.padding_bottom + height + title_bar.padding_top
self.shapes['background'].update(self._gx, self._gy, self.w,
self.h)
self.shapes['title_bar'].update_in(
self._gx - background.padding_left, self._gy + self.h,
self.w + background.padding_left + background.padding_right, h)
self.elements['title'].x = self._gx + self.w / 2
self.topbar = Rect(
-background.padding_left, self.h,
self.w + background.padding_left + background.padding_right, h)
self.elements[
'title'].y = self._gy + self.h + title_bar.padding_bottom - font.descent
SingleContainer.update_elements(self)
def reset_size(self, size):
self._y += self._h - size.h
SingleContainer.reset_size(self, size)
def bounds(self):
return Rect(self._gx, self._gy, self.w, self.h + self.topbar.h)
def on_mouse_press(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and \
self.topbar.hit_test(x - self.x, y - self.y):
self._in_drag = True
self._offset_x = x - self.x
self._offset_y = y - self.y
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._in_drag:
self._x = x - self._offset_x
self._y = y - self._offset_y
self.find_root().update_layout()
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_drag(self, x, y, dx, dy, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def on_mouse_release(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and self._in_drag:
self._in_drag = False
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_release(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def setCityProperty( self, id, city, tiles=[] ):
self._stop = xbmc.abortRequested
if self._stop: return
#[u'city', u'outlook', u'temp', u'url', u'country', u'coords', u'time', u'unit', u'icon']
ok = False
try:
b_prop = "weatherworld.city.%i." % id
lat = float( city[ "coords" ][ "lat" ][ 1 ] )
long = float( city[ "coords" ][ "long" ][ 1 ] )
posx, posy = self.getPosition( lat, long, self.mapwidth, self.mapheight )
rect = Rect( posx, posy, self.tilewidth, self.tileheight )
flipx, flipy = 0, 0
offsetx, offsety = 0, 0
if rect.right > self.mapwidth: flipx, offsetx = 1, -self.tilewidth
if rect.bottom > self.mapheight: flipy, offsety = 1, -self.tileheight
if offsetx or offsety: rect.move( posx+offsetx, posy+offsety )
collide = False
for tile in tiles:
collide = rect.colliderect( tile ) is not None
if collide: break
if collide:
self.window.setProperty( b_prop + "name", "" )
return ok, tiles
tiles.append( rect )
self.window.setProperty( b_prop + "flipx", str( flipx ) )
self.window.setProperty( b_prop + "flipy", str( flipy ) )
try: localtime = get_user_time_format( city[ "time" ] )
except: localtime = city[ "time" ]
self.window.setProperty( b_prop + "name", city[ "city" ] + ", " + city[ "country" ] )
self.window.setProperty( b_prop + "outlook", city[ "outlook" ] )
celsius, unit = fahrenheit2celsius( city[ "temp" ], city[ "unit" ] )
self.window.setProperty( b_prop + "temperature", celsius )
self.window.setProperty( b_prop + "unit", unit )
self.window.setProperty( b_prop + "localtime", localtime )
self.window.setProperty( b_prop + "icon", city[ "icon" ] )
self.window.setProperty( b_prop + "latitude", city[ "coords" ][ "lat" ][ 0 ] )
self.window.setProperty( b_prop + "longitude", city[ "coords" ][ "long" ][ 0 ] )
# get old pos
oldx, oldy = self.window.getProperty( b_prop + "posx" ), self.window.getProperty( b_prop + "posy" )
self.window.setProperty( b_prop + "posx", str( posx ) )
self.window.setProperty( b_prop + "posy", str( posy ) )
start = "0,0"
if oldx.isdigit() and oldy.isdigit():
start = "%s,%s" % ( oldx, oldy )
control = self.controls[ 2600 + id ]
if control:
control.setAnimations( [ ( 'conditional', 'condition=true effect=slide start=%s end=%i,%i time=500 easing=inout tween=easing' % ( start, posx, posy ) ) ] )
ok = True
except:
ok = "error"
print_exc()
return ok, tiles
class BSP_Node:
MIN_SIZE = 2
def __init__(self, x, y, width, height, level=0):
self.left = None
self.right = None
self.level = level
self.color = None
self.rect = Rect(x, x + width - 1, y, y + height - 1)
def is_leaf(self):
return not self.left and not self.right
def center(self):
return self.rect.center
def get_points(self):
return self.rect.get_points()
def split(self):
# Already split?
if not self.is_leaf():
return
split_horizontally = random.choice([True, False])
if self.rect.ratio_wh >= 1.25:
split_horizontally = False
elif self.rect.ratio_hw >= 1.25:
split_horizontally = True
if split_horizontally:
max_size = self.rect.height
else:
max_size = self.rect.width
if max_size <= 2 * self.MIN_SIZE:
return
split_at = random.randint(self.MIN_SIZE, max_size - self.MIN_SIZE)
if split_horizontally:
# | |
# -----
# | |
self.left = BSP_Node(
self.rect.xmin,
self.rect.ymin,
self.rect.width,
split_at,
level=self.level + 1,
)
self.right = BSP_Node(
self.rect.xmin,
self.rect.ymin + split_at,
self.rect.width,
self.rect.height - split_at,
level=self.level + 1,
)
else:
# -------
# | | |
# -------
self.left = BSP_Node(
self.rect.xmin,
self.rect.ymin,
split_at,
self.rect.height,
level=self.level + 1,
)
self.right = BSP_Node(
self.rect.xmin + split_at,
self.rect.ymin,
self.rect.width - split_at,
self.rect.height,
level=self.level + 1,
)
self.left.split()
self.right.split()
def bounds(self): return Rect(self._gx, self._gy, self.w, self.h)
class FoldingBox(SingleContainer):
"""Collapsible container"""
def __init__(self, title, **kwargs):
'''Create a folding box
Keyword arguments:
name -- unique widget identifier
content -- child container
collapsed -- if true, container folded initially
'''
SingleContainer.__init__(self, **kwargs)
self.shapes['topbar'] = Rectangle()
self.elements['title'] = BasicLabel(title,
font_size=8,
color=(0, 0, 0, 255),
anchor_x='left',
anchor_y='center')
self.content = kwargs.get('content', None)
self._last_h = 15
self._collapsed = False
self._top_h = 0
self.collapsed = kwargs.get('collapsed', False)
def _get_title(self):
return self.elements['title'].text
def _set_title(self, title):
self.elements['title'].text = title
title = property(_get_title, _set_title)
def _get_collapsed(self):
return self._collapsed
def _set_collapsed(self, collapsed):
if collapsed != self._collapsed:
self._collapsed = collapsed
self._h, self._last_h = self._last_h, self._h
for c in self.children:
c.visible = not collapsed
if self.theme:
self.shapes['topbar'].patch = self.theme['folding_box'][(
'image_closed' if collapsed else 'image')]
self.find_root().update_layout()
collapsed = property(_get_collapsed, _set_collapsed)
def update_theme(self, theme):
SingleContainer.update_theme(self, theme)
if theme:
patch = theme['folding_box'][('image_closed'
if self._collapsed else 'image')]
self.shapes['topbar'].patch = patch
self.elements['title'].font_name = theme['font']
self.elements['title'].font_size = theme['font_size_small']
self.elements['title'].color = theme['font_color']
if self._collapsed:
self._h = patch.padding_top
else:
self._last_h = patch.padding_top
self._top_h = patch.padding_top
def update_elements(self):
if self.theme:
patch = self.theme['folding_box'][('image_closed' if
self._collapsed else 'image')]
self.shapes['topbar'].update(
self._gx + patch.padding_left,
self._gy + self.h - patch.padding_top,
self.w - patch.padding_left - patch.padding_right, 1)
self.elements['title'].x = self._gx + patch.padding_left
self.elements[
'title'].y = self._gy + self.h - patch.padding_top / 2 + 1
self.topbar = Rect(0, self.h - patch.padding_top, self.w,
patch.padding_top)
SingleContainer.update_elements(self)
def determine_size(self):
self._content.determine_size()
size = self._content._pref_size
if self.collapsed:
self._pref_size = Size(size[0], self._top_h)
else:
self._pref_size = Size(size[0], size[1] + self._top_h)
def reset_size(self, size):
Widget.reset_size(self, size)
if not self.collapsed:
self._content.reset_size(Size(size.w, size.h - self._top_h))
def on_mouse_press(self, x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT and \
self.topbar.hit_test(x - self._gx, y - self._gy):
self.collapsed = not self.collapsed
return pyglet.event.EVENT_HANDLED
SingleContainer.on_mouse_press(self, x, y, button, modifiers)
return pyglet.event.EVENT_UNHANDLED
def clip_rect(self):
return Rect(self._gx, self._gy, self.w, self.h - 15)
def clip_rect(self):
return Rect(self._gx, self._gy, self.w, self.h - 15)
def getRect(self, gt):
p = self.u2c(self.ship.positionAt(gt), self.bufPoint)
return Rect(p.x - self.offset,
p.y - self.offset,
p.x + self.offset,
p.y + self.offset)
(-5, -5), # 22
(-6.7, 2.0), # 2
(-3, -7), # 21
(-5.9, 3.8), # 3
(-1, -7), # 20
(-4.6, 5.3), # 4
(-1, -5), # 19
(-2.9, 6.4), # 5
(1, -5), # 18
(-1.0, 6.9), # 6
(3, -7), # 16
(1.0, 6.9), # 7
(5, -5), # 15
(2.9, 6.4), # 8
(7, -7), # 14
(4.6, 5.3), # 9
(7.0, 0.0), # 13
(4.6, 5.3), # 10
(6.7, 2.0), # 12
(5.9, 3.8), # 11
]
black_ghost = Primitive(ghost_contour, Color.black).offset(+200, +105)
orange_ghost = Primitive(ghost_contour, Color.orange).offset(+300, +200)
kapla = Rect(10, 100, 120, 200, Color.white).offset(100, 200)
s = Shape([orange_ghost, black_ghost, kapla])
s2 = Shape([orange_ghost, black_ghost,kapla, \
Rect(10, 100, 120, 200, Color.red).rotate(10).offset(200, 600)])
def __init__(self,params): Rect.__init__(self,params) self.connected=set()
