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 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()