コード例 #1
0
class MathPower(MultiItem):
    """Container for inline maths"""
    def __init__(self):
        MultiItem.__init__(self)
        self.style = 'math-var', 1
        
    def resizePDF(self, pdf, x = 0, y = 0):
        if len(self.items) < 2 or not self.items[0] or not self.items[1]:
            raise Exception('MathPower must have two items.')

        self.rect = Rect(x,y,x,y)
        dx = pdf.get_string_width(' ') * self.style[1]
        
        base = self.items[0] 
        if hasattr(base,'style'):
            setFontPDF(pdf, base.style, self.styles)
        base.resizePDF(pdf,x,y)

        index = self.items[1] 
        index.scaleFont(0.8)
        if hasattr(index,'style'):
            setFontPDF(pdf, index.style, self.styles)
        index.resizePDF(pdf, base.rect.x1() + dx, y - base.rect.height() * 0.4)

        self.rect.unite(base.rect)
        self.rect.unite(index.rect)
        self.refit()
コード例 #2
0
class InlineMathBlock(MultiItem):
    """Container for inline maths"""
    def __init__(self, *items):
        MultiItem.__init__(self)
        self.style = ('math-var',1)
        for item in items:
            self.appendItem(item)
        
    def resizePDF(self, pdf, x = 0, y = 0):
        self.rect = Rect(x,y,x,y)
        dx = pdf.get_string_width(' ')
        dx *= self.style[1]
        rectList = []
        width = 0.0
        style = ''
        for item in self.items:
            if item:
                if hasattr(item,'style') and item.style != style:
                    setFontPDF(pdf, item.style, self.styles)
                item.resizePDF(pdf,x,y)
                rectList.append(item.rect)
                width += item.rect.width() + dx
                
        rect.alignLeft(rectList, x, x+width, dx)
        for r in rectList:
            self.rect.unite(r)
        self.refit()
コード例 #3
0
ファイル: room.py プロジェクト: hakuji/game3
 def __init__(self, x, y, w, h, objects = [], creatures = [],
              start  = False):
     self.inner_rect = Rect.from_dimensions(x + WALL_WIDTH, y + int(WALL_WIDTH * 1.25),
                                            w + WALL_WIDTH, h + int(WALL_WIDTH * 1.5))
     self.outer_rect = Rect.from_dimensions(x, y,
                                            2 * WALL_WIDTH + w,
                                            2 * WALL_WIDTH + h)
コード例 #4
0
def dredgeRiverSingle(nature,direction,CX,CY):
	rivert=[]

	# This is the start coordinate of the river, perpendicular to the
	# axis of the river.  N/S rivers choose positions on the E/W axis, 
	# and vice-versa
	axis_size = CX if direction else CY
	line_pos=random.randint(0, axis_size)

	#river width, no more than half the map
	river_size=min(random.randint(3,120), axis_size//2) 

	for i in range(0,axis_size):
		if direction:
			element=Rect(Point(i,line_pos),Point(i,line_pos+river_size))
		else:
			element=Rect(Point(line_pos,i),Point(line_pos+river_size,i))

		element.set_name('RIVER')
		rivert.append(element)

	prev=0;
	for f in rivert:
		prev=prev+random.randint(-1,1)
		f.move(direction+2,prev) # in rect, 1=up, 2=right
	nature.extend(rivert)
コード例 #5
0
ファイル: grid.py プロジェクト: ajhinsvark/2048
    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        
        self.moving = False
        self.teleport = False
        self.to_x = self.x
        self.to_y = self.y

        if ( random.random() < 0.1):
            self.value = 4
        else:
            self.value = 2

        self.color = COLORS[self.value]
        self.child = None
        self.font_size = math.floor(72/96 * (self.width / len(str(self.value)) *.95))

        self.rect = Rect(self.x, self.y, self.width, self.height)
        self.label = pyglet.text.Label(str(self.value),
                                       font_name='Calibri',
                                       font_size=self.font_size,
                                       color=(0,0,0,255),
                                       x=self.x + self.width // 2,
                                       y=self.y + self.height // 2,
                                       anchor_x='center',
                                       anchor_y='center')

        print(self.label.width)
コード例 #6
0
ファイル: surface.py プロジェクト: PembrokeRobotics/Keys
 def fill(self, color=(0, 0, 0), rect=None):
     """
     Fill surface with color.
     """
     try:
         g2d = self._g2d
         surface_graphics = True
     except AttributeError:
         g2d = self.createGraphics()
         surface_graphics = False
     color = Color(color)  #0.23
     g2d.setColor(color)
     if not rect:
         rect = Rect(0, 0, self.width, self.height)
         x, y, w, h = rect.x, rect.y, rect.width, rect.height
     else:
         try:
             x, y, w, h = rect.x, rect.y, rect.width, rect.height
         except AttributeError:
             rect = Rect(rect[0], rect[1], rect[2], rect[3])
             x, y, w, h = rect.x, rect.y, rect.width, rect.height
     g2d.fillRect(x, y, w, h)
     if not surface_graphics:
         g2d.dispose()
     return rect
コード例 #7
0
 def circle(self, surface, color, position, radius, width=0):
     """
     Draw circular shape, and returns bounding Rect.
     Argument include surface to draw, color, position and radius.
     Optional width argument of outline, which defaults to 0 for filled shape.
     """
     surface.beginPath()
     surface.arc(position[0], position[1], radius, 0, 2 * pi, False)
     if width:
         surface.setLineWidth(width)
         if hasattr(color, 'a'):
             surface.setStrokeStyle(color)
         else:
             surface.setStrokeStyle(Color(color))
         surface.stroke()
     else:
         if hasattr(color, 'a'):
             surface.setFillStyle(color)
         else:
             surface.setFillStyle(Color(color))
         surface.fill()
     if surface._display:
         return surface._display._surface_rect.clip(
             Rect(position[0] - radius, position[1] - radius, 2 * radius,
                  2 * radius))
     else:
         return surface.get_rect().clip(
             Rect(position[0] - radius, position[1] - radius, 2 * radius,
                  2 * radius))
コード例 #8
0
ファイル: game.py プロジェクト: JayThirtySeven/NNLAF-PYGAME
    def __init__(self, game, zone):
        self.game = game
        self.zone = zone

        self.screen = self.game.screen

        self.battles = [x for x in game.battles if x.zone == self.zone]
        self.targets = [x for x in game.targets if x.zone == self.zone]
        self.terrain = [x for x in game.terrain if x.zone == self.zone]

        # Determine the size required for the map surface
        map_size_rect = Rect()
        for ter in self.terrain:
            map_size_rect.union(ter.rect)

        self.map_surface = pygame.Surface(map_size_rect.size)

        # Draw all static terrain and targets to the map surface
        for ter in self.terrain:
            if ter.static:
                self.map_surface.fill((255, 0, 0), ter)
                ter.draw(self.map_surface)

        for tar in self.targets:
            if tar.static:
                tar.draw(self.map_surface)
コード例 #9
0
    def update(self):
        last = Rect(*(self.pos + self.size))

        dx = 0
        if keys.get(Keyboard.keycodes['left']):
            dx -= 2 * params.scale
        if keys.get(Keyboard.keycodes['right']):
            dx += 2 * params.scale
        if keys.get(Keyboard.keycodes['spacebar']) and self.resting:
            self.dy = 9 * params.scale
            self.resting = False

        self.dy = max(-8 * params.scale, self.dy - .5 * params.scale)

        self.x += dx
        self.y += self.dy

        new = Rect(*(self.pos + self.size))
        for cell in self.map.layers['objects'].collide(new, 'blocker'):
            blocker = cell['blocker']
            if 'l' in blocker and last.right <= cell.left and new.right > cell.left:
                new.right = cell.left
            if 'r' in blocker and last.left >= cell.right and new.left < cell.right:
                new.left = cell.right
            if 't' in blocker and last.bottom >= cell.top and new.bottom < cell.top:
                self.resting = True
                new.bottom = cell.top
                self.dy = 0
            if 'b' in blocker and last.top <= cell.bottom and new.top > cell.bottom:
                new.top = cell.bottom
                self.dy = 0
        self.pos = new.bottomleft
コード例 #10
0
 def lines(self, surface, color, closed, pointlist, width=1):
     """
     Draw interconnected lines, and returns Rect bound.
     Argument include surface to draw, color, closed, and pointlist.
     Optional width argument of line.
     """
     surface.beginPath()
     surface.moveTo(*pointlist[0])
     for point in pointlist[1:]:
         surface.lineTo(*point)
     if closed:
         surface.closePath()
     surface.setLineWidth(width)
     if hasattr(color, 'a'):
         surface.setStrokeStyle(color)
     else:
         surface.setStrokeStyle(Color(color))
     surface.stroke()
     xpts = [pt[0] for pt in pointlist]
     ypts = [pt[1] for pt in pointlist]
     xmin, xmax = min(xpts), max(xpts)
     ymin, ymax = min(ypts), max(ypts)
     if surface._display:
         return surface._display._surface_rect.clip(
             Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
     else:
         return surface.get_rect().clip(
             Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
コード例 #11
0
def test_center():
    r = Rect(0, 0, 2, 2)
    Hb = Hitbox(r)
    t = CollideTransformable()
    t.set_hit_box(Hb)
    assert t.get_hit_box().get_world_rect() == Rect(0, 0, 2, 2)
    assert t.get_position() == Vector(1, 1)
コード例 #12
0
ファイル: surface.py プロジェクト: PembrokeRobotics/Keys
 def subarea(self, *rect):
     """
     Return Surface and Rect that represents a subsurface that shares data with this surface.
     The rect argument is the area of the subsurface.
     """
     try:
         x, y, w, h = rect[0].x, rect[0].y, rect[0].width, rect[0].height
     except AttributeError:
         try:
             x, y, w, h = rect[0]
         except ValueError:
             x, y = rect[0]
             w, h = rect[1]
     rect = Rect(x, y, w, h)
     try:
         subsurf = self.getSubimage(rect.x, rect.y, rect.width, rect.height)
     except RasterFormatException:
         try:
             clip = self.get_rect().createIntersection(rect)
             rect = Rect(clip.x, clip.y, clip.width, clip.height)
             subsurf = self.getSubimage(rect.x, rect.y, rect.width,
                                        rect.height)
         except:  #rect outside surface
             subsurf = None
     return subsurf, rect
コード例 #13
0
class MathSubSuperscript(MultiItem):
    """An item with a subscript"""
    def __init__(self, base, subscript = None, superscript = None):
        MultiItem.__init__(self)
        self.appendItem(base)
        self.base = base  
        self.subscript = subscript
        self.superscript = superscript
        if subscript:
            subscript.scaleFont(0.8)
            self.appendItem(subscript)
        if superscript:
            superscript.scaleFont(0.8)
            self.appendItem(superscript)
        
    def resizePDF(self, pdf, x = 0, y = 0):
        self.resizeItemsPDF(pdf, x, y)
        dx = pdf.get_string_width(' ') * self.style[1]
        self.rect = Rect(x,y,x,y)
         
        h = self.base.rect.height()
        w = self.base.rect.width() + dx
        
        if self.subscript:
            self.subscript.rect.translate(w, h*0.5)
            self.rect.unite(self.subscript.rect)
        if self.superscript:
            self.superscript.rect.translate(w, - h*0.5)
            self.rect.unite(self.superscript.rect)
        
        self.refit()
コード例 #14
0
def test_class_rect():
    r1 = Rect(10, 10, 50, 50)
    r2 = eval(repr(r1))
    print(r1, str(r1.area()), sep=':')
    print(r2, str(r2.area()), sep=':')
    r1.draw()
    r2.draw()
コード例 #15
0
 def __init__(self, matrix, fertile_symbol):
     self.matrix = matrix
     self.active_rects = []
     self.largest_rect = Rect(1, 0)
     self.active_row = 0
     self.fertile_symbol = fertile_symbol
     self.all_rects = [self.largest_rect]
コード例 #16
0
 def fill(self, color=None, rect=None):
     """
     Fill surface with color.
     """
     if color is None:
         HTML5Canvas.fill(self)
         return
     self.beginPath()
     if color:
         if hasattr(color, 'a'):
             self.setFillStyle(color)
         else:
             self.setFillStyle(Color(color))
         if not rect:
             _rect = Rect(0, 0, self.width, self.height)
         else:
             if self._display:
                 surface_rect = self._display._surface_rect
             else:
                 surface_rect = self.get_rect()
             if hasattr(rect, 'width'):
                 _rect = surface_rect.clip(rect)
             else:
                 _rect = surface_rect.clip(Rect(rect))
             if not _rect.width or not _rect.height:
                 return _rect
         self.fillRect(_rect.x, _rect.y, _rect.width, _rect.height)
     else:
         _rect = Rect(0, 0, self.width, self.height)
         self.clear()
     return _rect
コード例 #17
0
    def resizePDF(self, pdf, x = 0, y = 0):
        if len(self.items) == 0:
            raise Exception('MathAboveAndBelow must have at least one item.')
        self.rect = Rect(x,y,x,y)
        base = self.items[0]
        self.setFontPDF(pdf, base)
        base.resizePDF(pdf,x,y)
        self.rect.unite(base.rect)

        if len(self.items) > 1 and self.items[1]:
            below = self.items[1]
            self.setFontPDF(pdf, below)
            below.resizePDF(pdf,x,y)
            below.rect.translate(0, base.rect.height())
            below.rect.alignXCenter( base.rect )
            self.rect.unite(below.rect)
            
        if len(self.items) > 2 and self.items[2]:
            above = self.items[2]
            self.setFontPDF(pdf, above)
            above.resizePDF(pdf,x,y)
            above.rect.translate(0, - above.rect.height())
            above.rect.alignXCenter( base.rect )
            self.rect.unite(above.rect)
            
        self.refit()
コード例 #18
0
    def resizePDF(self, pdf, x = 0, y = 0):
        if len(self.items) < 2 or not self.items[0] or not self.items[1]:
            raise Exception('MathFrac must have two items.')

        self.rect = Rect(x,y,x,y)
        dx = pdf.get_string_width(' ') * self.style[1]
        self.margins.set(dx, 0.0)
        setFontPDF(pdf, self.style, self.styles)
        lineHeight = pdf.font_size_pt / pdf.k
        
        numerator = self.items[0] 
        if hasattr(numerator,'style'):
            setFontPDF(pdf, numerator.style, self.styles)
        numerator.resizePDF(pdf,x + dx, y - lineHeight * 0.5)

        denominator = self.items[1] 
        if hasattr(denominator,'style'):
            setFontPDF(pdf, denominator.style, self.styles)
        denominator.resizePDF(pdf, x + dx, numerator.rect.y1())
        
        if numerator.rect.width() > denominator.rect.width():
            denominator.rect.alignXCenter(numerator.rect)
        else:
            numerator.rect.alignXCenter(denominator.rect)

        self.rect.unite(numerator.rect)
        self.rect.unite(denominator.rect)
        self.rect.adjust(rect.Point(0,0),rect.Point(dx,0))
コード例 #19
0
 def polygon(self, surface, color, pointlist, width=0):
     """
     Draw polygon shape, and returns bounding Rect.
     Argument include surface to draw, color, and pointlist.
     Optional width argument of outline, which defaults to 0 for filled shape.
     """
     surface.beginPath()
     surface.moveTo(*pointlist[0])
     for point in pointlist[1:]:
         surface.lineTo(*point)
     surface.closePath()
     if width:
         surface.setLineWidth(width)
         if hasattr(color, 'a'):
             surface.setStrokeStyle(color)
         else:
             surface.setStrokeStyle(Color(color))
         surface.stroke()
     else:
         if hasattr(color, 'a'):
             surface.setFillStyle(color)
         else:
             surface.setFillStyle(Color(color))
         surface.fill()
     xpts = [pt[0] for pt in pointlist]
     ypts = [pt[1] for pt in pointlist]
     xmin, xmax = min(xpts), max(xpts)
     ymin, ymax = min(ypts), max(ypts)
     if surface._display:
         return surface._display._surface_rect.clip(
             Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
     else:
         return surface.get_rect().clip(
             Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
コード例 #20
0
ファイル: simulation.py プロジェクト: eporat/Project-BBRA
    def run(self, iterations=1):
        self.done = False

        for _ in range(iterations):
            if self.done:
                break

            self.handle_events()
            if self.draw:
                self.screen.fill(pygame.Color('white'))
                self.table.draw(self.screen)

            self.puck.vel = self.camera.puck['pos'] - self.puck.pos
            self.puck.pos = self.camera.puck['pos']
            print(self.puck.vel)
            self.striker.pos = self.camera.striker['pos']
            self.table = Rect(self.camera.table['min_x'], self.camera.table['min_y'],
                                self.camera.table['max_x'], self.camera.table['max_y'])
            self.puck.update(self)
            #self.striker.update(self)

            if self.draw:
                pygame.display.flip()

        return self.striker.vel
コード例 #21
0
 def line(self, surface, color, point1, point2, width=1):
     """
     Draw line, and returns bounding Rect.
     Argument include surface to draw, color, point1, point2.
     Optional width argument of line.
     """
     surface.beginPath()
     surface.moveTo(*point1)
     surface.lineTo(*point2)
     surface.setLineWidth(width)
     if hasattr(color, 'a'):
         surface.setStrokeStyle(color)
     else:
         surface.setStrokeStyle(Color(color))
     surface.stroke()
     xpts = [pt[0] for pt in (point1, point2)]
     ypts = [pt[1] for pt in (point1, point2)]
     xmin, xmax = min(xpts), max(xpts)
     ymin, ymax = min(ypts), max(ypts)
     if surface._display:
         return surface._display._surface_rect.clip(
             Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
     else:
         return surface.get_rect().clip(
             Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
コード例 #22
0
def test_collision_box():
    for a, b, c in intersection_pairs:
        assert a.collision_box(b) == c, f'{a}.collision_box({b} != {c}'
        assert b.collision_box(a) == c, f'{a}.collision_box({b} != {c}'

    r = Rect(0, 0, 2, 2)
    assert r.collision_box(r) == r
コード例 #23
0
    def set_crop_area(self):
        r = Rect(self.croprect_start, self.croprect_end)

        # adjust dimensions
        r.clip_to(self.image_thumb_rect)

        # ignore rects smaller than this size
        if min(r.h, r.w) < 10:
            return

        ra = r
        ra = ra.scale_rect(self.scale)
        ra = ra.move_rect(self.x0, self.y0)
        ra = ra.valid_rect(self.w, self.h)
        if self.zoommode:
            self.canvas.delete(tk.ALL)
            self.x0 = ra.left
            self.y0 = ra.top
            self.region_rect = ra
            self.displayimage()
            self.zoommode = False
            self.zoomButton.deselect()
            self.zooming = True
        else:
            self.drawrect(r)
            self.crop_rects.append(ra)
            self.n = self.n + 1
        self.set_button_state()
コード例 #24
0
ファイル: sheetimage.py プロジェクト: jahodfra/spritesticker
 def getOuterRect(self):
     r = Rect()
     r.size = (
         self.marginLeft + self.image.size[0] + self.marginRight,
         self.marginTop + self.image.size[1] + self.marginBottom,
     )
     return r
コード例 #25
0
ファイル: surface.py プロジェクト: PembrokeRobotics/Keys
 def blit(self, surface, position, area=None):
     """
     Draw given surface on this surface at position.
     Optional area delimitates the region of given surface to draw.
     """
     try:
         x, y = position.x, position.y
     except AttributeError:
         x, y = position[0], position[1]
     try:
         if not area:
             rect = self.get_rect().createIntersection(
                 Rect(x, y, surface.width, surface.height))
             surface_rect = Rect(rect.x, rect.y, rect.width, rect.height)
         else:
             surface, surface_rect = surface.subarea(area)
     except AttributeError:
         return Rect(0, 0, 0, 0)
     try:
         g2d = self._g2d
         surface_graphics = True
     except AttributeError:
         g2d = self.createGraphics()
         surface_graphics = False
     try:
         g2d.drawImage(surface, x, y, None)
     except TypeError:
         g2d.drawImage(surface, int(x), int(y), None)
     if not surface_graphics:
         g2d.dispose()
     return surface_rect
コード例 #26
0
ファイル: reconstructPickle.py プロジェクト: tgrossb/Tingley
def main():
    # First thing is to read the source image and grayscale it
    pickleFile = sys.argv[1]

    with open(pickleFile, 'rb') as file:
        rawImg, scaleFactor, rangedNotes = pickle.load(file)

    if scaleFactor < 1.0:
        img = cv2.resize(rawImg,
                         None,
                         fx=scaleFactor,
                         fy=scaleFactor,
                         interpolation=cv2.INTER_CUBIC)
    else:
        img = rawImg

    lniName = "Labeled notes"
    noteImg = img.copy()
    drawParams = DrawParams()
    for note in rangedNotes:
        rect = Rect(note.rect.x, note.rect.y, note.rect.w, note.rect.h,
                    str(note.noteLine) + " " + str(note.duration))
        rect.draw(noteImg, drawParams, lniName, allInfo=False)
    cv2.namedWindow(lniName)
    cv2.setMouseCallback(lniName, Rect.onClick, lniName)
    cv2.imshow(lniName, noteImg)

    print("\t\tPress space to continue...")
    while True:
        if cv2.waitKey(30) == 32:
            break

    cv2.destroyAllWindows()
コード例 #27
0
ファイル: game.py プロジェクト: robertojrdev/tf_fundamentos
    def __init__(self, screen, rows=0, columns=0):
        super().__init__()
        self.cards = []
        self.screen = screen
        self.cards_offset = 10
        self.card_size = vector2(70, 100)
        self.selected_cards = []
        self.on_exit = None
        self.score = 0
        self.wrong_attempts = 0

        # SCORE TEXT
        self.score_text = Text(Rect(vector2(20, 20), vector2(150, 50)),
                               Game.defaultScoreText + str(self.score))
        self.score_text.justify = Text.justify_up
        self.score_text.align = Text.align_left
        self.childs.append(self.score_text)

        # EXIT BUTTON
        x, y = screen.get_size()
        exit_button = TextButton(vector2(20, y - 70), vector2(150, 50), "Exit")
        exit_button.on_click = lambda game=self: game.on_exit_game()
        self.childs.append(exit_button)

        # WIN TEXT
        self.win_text = Text(Rect(vector2(0, 0), vector2(x, y)),
                             "Congratulations!")
        self.childs.append(self.win_text)

        if rows != 0 and columns != 0:
            self.new_game(rows, columns)
        else:
            self.is_visible = False
コード例 #28
0
class TextItem(DocItem):
    """Prints some form of text"""
    def __init__(self, text = '', style = 'body'):
        DocItem.__init__(self)
        self.text = text
        self.style = style

    def writePDF(self, pdf = None):
        """Write itself to a FPDF object.
        
        Args:
            pdf (FPDF): the FPDF object to write to.
        """
        return self.getText()
    
    def resizePDF(self, pdf, x = 0, y = 0):
        """Resize internal Rect according to current settings of pdf"""
        width = pdf.get_string_width( self.getText() )
        height = pdf.font_size_pt / pdf.k
        self.rect = Rect( x, y, x + width, y + height )
    
    def cellPDF(self, pdf, r = None):
        if r:
            x_shift = r.x0()
            y_shift = r.y0()
        else:
            x_shift = 0.0
            y_shift = 0.0
        pdf.set_y( self.rect.y0() - y_shift )
        pdf.set_x( self.rect.x0() - x_shift )
        pdf.cell( self.rect.width(), self.rect.height(), self.getText() )
        
    def refit(self):
        """Doesn't need to do anything as cellPDF uses self.rect to output the content"""
        pass
コード例 #29
0
def test_08():
    # Problem: get_rect gibt immer 0, 0
    t1 = TextBox("0123456789")
    t2 = TextBox("0123456789")
    p1 = Paragraph([Row([t1, t2, NewlineBox(defaultstyle)])])

    assert p1.get_rect(0, 0, 0) == Rect(0, 0.0, 1, 1.0)
    assert p1.get_rect(10, 0, 0) == Rect(10, 0.0, 11, 1.0)
コード例 #30
0
ファイル: tilemap.py プロジェクト: spinningD20/kivy_rpg
 def aggro_check(self, size):
     aggro_range = self.map.tile_width * size
     offset = (self.map.tile_width * (size / 2))
     collided = []
     for player in self.player_characters:
         rect = Rect(player.x - offset, player.y - offset, aggro_range, aggro_range)
         collided += [e for e in self.entities if rect.intersect(Rect(*e.pos + e.size)) and e.data.type == 'enemy']
     return collided
コード例 #31
0
    def generate_map(self, height, width):
        """Initialize the map"""
        self.height = height
        self.width = width

        #Set map to all empty tiles
        self.floor = [[0 for y1 in range(height)] for x1 in range(width)]
        for x in range(self.width):
            for y in range(self.height):
                self.floor[x][y] = Tile.get_new_tile()

        # Create some rooms
        rooms = []
        num_rooms = 0

        for r in range(settings.MAX_ROOMS):
            # random width and height
            w = random.randint(settings.ROOM_MIN_SIZE, settings.ROOM_MAX_SIZE)
            h = random.randint(settings.ROOM_MIN_SIZE, settings.ROOM_MAX_SIZE)
            # random position without going out of the boundaries of the map
            x = random.randint(0, self.width - w - 1)
            y = random.randint(0, self.height - h - 1)

            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
                self.create_room(new_room)
                # center coordinates of new room, will be useful later
                (new_x, new_y) = new_room.center()

                if not num_rooms == 0:
                    # 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 random.randint(0, 1) == 1:
                        # first move horizontally, then vertically
                        self.create_h_tunnel(prev_x, new_x, prev_y)
                        self.create_v_tunnel(prev_y, new_y, new_x)
                    else:
                        # first move vertically, then horizontally
                        self.create_v_tunnel(prev_y, new_y, prev_x)
                        self.create_h_tunnel(prev_x, new_x, new_y)

                # finally, append the new room to the list
                rooms.append(new_room)
                num_rooms += 1
コード例 #32
0
def map_all_and_work(zone, duty):
    workers = []
    pool = Pool()
    nw = Rect(Point(0, 0), Point(CITY_SIZE_X / 2, CITY_SIZE_Y / 2))
    ne = Rect(Point(CITY_SIZE_X / 2, 0), Point(CITY_SIZE_X, CITY_SIZE_Y / 2))
    sw = Rect(Point(0, CITY_SIZE_Y / 2), Point(CITY_SIZE_X / 2, CITY_SIZE_Y))
    se = Rect(Point(CITY_SIZE_X / 2, CITY_SIZE_Y / 2),
              Point(CITY_SIZE_X, CITY_SIZE_Y))
    workers.append(
        pool.apply_async(conflictSolver, [(0, 0), zone[0][0], nw, duty]))
    workers.append(
        pool.apply_async(conflictSolver, [(0, 1), zone[0][1], ne, duty]))
    workers.append(
        pool.apply_async(conflictSolver, [(1, 0), zone[1][0], sw, duty]))
    workers.append(
        pool.apply_async(conflictSolver, [(1, 1), zone[1][1], se, duty]))

    pool.close()
    pool.join()
    zone = [[[], []], [[], []]]
    scambi = False
    bimbi_perduti = 0
    for w in workers:
        res = w.get()
        #print(res)
        #print("index x:" +str(res[0][0]))
        #print("index y:" +str(res[0][1]))
        zone[res[0][0]][res[0][1]].extend(res[1])
        YY = res[0][0]
        XX = res[0][1]
        if ((YY - 1) >= 0):  #top
            if (len(res[2]) > 0):
                scambi = True
            zone[YY - 1][XX].extend(res[2])
        else:
            bimbi_perduti = bimbi_perduti + len(res[2])
        if ((XX - 1) >= 0):  #left
            if (len(res[3]) > 0):
                scambi = True
            zone[YY][XX - 1].extend(res[3])
        else:
            bimbi_perduti = bimbi_perduti + len(res[3])
        if ((XX + 1) <= 1):  #right
            if (len(res[4]) > 0):
                scambi = True
            zone[YY][XX + 1].extend(res[4])
        else:
            bimbi_perduti = bimbi_perduti + len(res[4])
        if ((YY + 1) <= 1):  #bottom
            if (len(res[5]) > 0):
                scambi = True
            zone[YY + 1][XX].extend(res[5])
        else:
            bimbi_perduti = bimbi_perduti + len(res[5])

    #print('abbiamo perso n '+str(bimbi_perduti))
    return (zone, scambi)
コード例 #33
0
 def resizePDF(self, pdf, x = 0, y = 0):
     self.rect = Rect(x,y,x,y)
     for item in self.items:
         self.setFontPDF(pdf, item)
         item.resizePDF(pdf,x,y)
         item.rect.translate(0,self.rect.height())
         self.rect.unite(item.rect)
             
     self.refit()
コード例 #34
0
ファイル: rect_test.py プロジェクト: gracejpw/play
 def test_intersect_of_non_overlapping_rects(self):
     r1 = Rect(10, 20, 20, 30)
     r2 = Rect(10, 30, 20,
               40)  # abuts the bottom of r1 without intersecting
     r3 = Rect(20, 20, 30, 40)  # abuts the right of r1 without intersecting
     self.assertIsNone(r1.intersect(r2))
     self.assertIsNone(r2.intersect(r1))
     self.assertIsNone(r1.intersect(r3))
     self.assertIsNone(r3.intersect(r1))
コード例 #35
0
    def loadimage(self):
        self.image_rect = Rect(self.image.size)
        self.w = self.image_rect.w
        self.h = self.image_rect.h
        self.region_rect = Rect((0, 0), (self.w, self.h))

        self.edited_img = self.image.copy().convert('RGB')

        self.displayimage()
コード例 #36
0
 def get_rect(self, **attr):
     """
     Return rect of the surface.
     An optional keyword argument of the rect position.
     """
     rect = Rect(0, 0, self.width, self.height)
     for key in attr:
         rect.__setattr__(key, attr[key])
     return rect
コード例 #37
0
ファイル: surface.py プロジェクト: YuliReiri/WinLifeGame
 def get_rect(self, **attr):
     """
     Return rect of the surface.
     An optional keyword argument of the rect position.
     """
     rect = Rect(0, 0, self.width, self.height)
     for key in attr:
         rect.__setattr__(key,attr[key])
     return rect
コード例 #38
0
ファイル: map.py プロジェクト: CalvinRodo/Crogue
  def make_map(self):
    #fill map with "blocked" tiles
    self.map = [[ Tile(True)
      for y in range(self.height) ]
        for x in range(self.width) ]

    #create two rooms
    rooms = []
    num_rooms = 0

    for r in range(self.max_rooms):
      #random width and height
      w = libtcod.random_get_int(0, self.room_min_size, self.room_max_size)
      h = libtcod.random_get_int(0, self.room_min_size, self.room_max_size)
      #random position without going out of the boundaries of the map
      x = libtcod.random_get_int(0, 0, self.width - w - 1)
      y = libtcod.random_get_int(0, 0, self.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
      #if we find an intersection we need to generate a new room

#      if len(list(filter(new_room.intersect, rooms))) > 0:
#        continue

      #"paint" it to the map's tiles
      self.create_room(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
        self.starting_pos = (new_x, new_y)
      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
          self.create_h_tunnel(prev_x, new_x, prev_y)
          self.create_v_tunnel(prev_y, new_y, new_x)
        else:
          #first move vertically, then horizontally
          self.create_v_tunnel(prev_y, new_y, prev_x)
          self.create_h_tunnel(prev_x, new_x, new_y)

      #finally, append the new room to the list
      rooms.append(new_room)
      num_rooms += 1
コード例 #39
0
 def create_leaf(cls, rooto, leaf_obj, leaf_rect):
     rect = Rect(leaf_rect.x, leaf_rect.y, leaf_rect.xx, leaf_rect.yy)
     rect.swapped_x = True  # Mark as leaf by setting the xswap flag.
     res = _NodeCursor.create(rooto, rect)
     idx = res.index
     res.first_child = rooto.leaf_count
     rooto.leaf_count += 1
     res.next_sibling = 0
     rooto.leaf_pool.append(leaf_obj)
     res._save_back()
     res._become(idx)
     assert (res.is_leaf())
     return res
コード例 #40
0
ファイル: back_ground.py プロジェクト: bellettif/smartCams
def generate_background(pict, bbxes, min_height, min_width):
    for i in xrange(N_TRIALS):
        rand_bbx = Rect(pict.shape[0], pict.shape[1])
        intersects = True
        if rand_bbx.height < min_height or rand_bbx.width < min_width:
            continue
        intersects = False
        for bbx in bbxes:
            intersects = intersects or rand_bbx.intersects(bbx)
        if not intersects:
            break
    if not intersects: 
        return pict[rand_bbx.ymin:rand_bbx.ymax,rand_bbx.xmin:rand_bbx.xmax]
    else:
        return None
コード例 #41
0
ファイル: tilemap.py プロジェクト: shilrobot/ld28
    def rectOverlaps(self, rect):
        minX,minY,maxX,maxY = self.getTileBoundsInclusive(rect)
        tw = self.tileWidth
        th = self.tileHeight

        for layer in self.collideLayers:

            for y in range(minY,maxY+1):
                for x in range(minX,maxX+1):
                    idx = x + y*layer.width
                    if layer.tileGIDs[idx] != 0:
                        r = Rect(x*tw, y*th, tw,th)
                        if r.intersects(rect):
                            return True
        return False
コード例 #42
0
ファイル: packer.py プロジェクト: jonmaur/draggin-framework
class PackNode(object):
    """
    Creates an area which can recursively pack smaller areas into itself.
    """
    def __init__(self, xywh):
        self.rect = Rect(xywh)

    def __repr__(self):
        return "<%s %s>" % (self.__class__.__name__, self.rect)

    def insert(self, xywh):
        """
        Insert an rect into the current rect. Returns a new Node representing
        the new rect.
        Returns None if no space is available for the new rect.
        """
        if hasattr(self, 'children'):
            for child in self.children:
                r = child.insert(xywh)
                if r is not None:
                    return r
            return None

        rect = Rect(xywh)
        if self.rect.fits(rect):
            a = PackNode((self.rect.left+rect.width, self.rect.bottom, self.rect.width-rect.width, rect.height))
            b = PackNode((self.rect.left, self.rect.bottom+rect.height, self.rect.width, self.rect.height-rect.height))
            self.children = [a,b]
            return PackNode((self.rect.left, self.rect.bottom, rect.width, rect.height))
コード例 #43
0
ファイル: test_two_dee.py プロジェクト: iver56/it3105
    def test_border_tiles(self):
        rect = Rect(0, 0, 3, 3)
        border_tiles = rect.get_border_tiles()
        self.assertTrue((0, 0) in border_tiles)
        self.assertTrue((1, 0) in border_tiles)
        self.assertTrue((2, 0) in border_tiles)
        self.assertTrue((1, 0) in border_tiles)
        self.assertTrue((1, 2) in border_tiles)
        self.assertTrue((2, 0) in border_tiles)
        self.assertTrue((2, 1) in border_tiles)
        self.assertTrue((2, 2) in border_tiles)
        self.assertFalse((1, 1) in border_tiles)  # middle
        self.assertFalse((3, 1) in border_tiles)  # out of bounds

        rect = Rect(1, 7, 1, 2)
        border_tiles = rect.get_border_tiles()
        self.assertEqual(len(border_tiles), 2)
コード例 #44
0
ファイル: document_pdf.py プロジェクト: rrnntt/document
class MathColumn(MultiItem):
    """Container for inline maths"""
    def __init__(self, *items):
        MultiItem.__init__(self)
        self.style = ('math-var',1)
        for item in items:
            self.appendItem(item)
        
    def resizePDF(self, pdf, x = 0, y = 0):
        self.rect = Rect(x,y,x,y)
        for item in self.items:
            self.setFontPDF(pdf, item)
            item.resizePDF(pdf,x,y)
            item.rect.translate(0,self.rect.height())
            self.rect.unite(item.rect)
                
        self.refit()
コード例 #45
0
ファイル: room.py プロジェクト: hakuji/game3
 def __init__(self, horizontal, x, y, length):
     if horizontal:
         w = length
         h = self.thickness()
         self.outer_rect = Rect.from_dimensions(
             x + self.thickness() / 2,
             y - WALL_WIDTH,
             w - int(1.08 * self.thickness()),
             h + WALL_WIDTH)
     else:
         w = self.thickness()
         h = length
         self.outer_rect = Rect.from_dimensions(
             x - WALL_WIDTH,
             y + self.thickness() / 2,
             w + WALL_WIDTH,
             h - int(1.45 * self.thickness()))
     self.inner_rect = Rect.from_dimensions(x, y, w, h)
コード例 #46
0
ファイル: document_pdf.py プロジェクト: rrnntt/document
class MathFrac(MultiItem):
    """Container for inline maths"""
    def __init__(self, num = None, denom = None):
        MultiItem.__init__(self)
        self.style = 'math-var', 1
        if num:
            if not denom:
                denom = MathNumber('1')
            self.appendItem(num)
            self.appendItem(denom)
        
    def resizePDF(self, pdf, x = 0, y = 0):
        if len(self.items) < 2 or not self.items[0] or not self.items[1]:
            raise Exception('MathFrac must have two items.')

        self.rect = Rect(x,y,x,y)
        dx = pdf.get_string_width(' ') * self.style[1]
        self.margins.set(dx, 0.0)
        setFontPDF(pdf, self.style, self.styles)
        lineHeight = pdf.font_size_pt / pdf.k
        
        numerator = self.items[0] 
        if hasattr(numerator,'style'):
            setFontPDF(pdf, numerator.style, self.styles)
        numerator.resizePDF(pdf,x + dx, y - lineHeight * 0.5)

        denominator = self.items[1] 
        if hasattr(denominator,'style'):
            setFontPDF(pdf, denominator.style, self.styles)
        denominator.resizePDF(pdf, x + dx, numerator.rect.y1())
        
        if numerator.rect.width() > denominator.rect.width():
            denominator.rect.alignXCenter(numerator.rect)
        else:
            numerator.rect.alignXCenter(denominator.rect)

        self.rect.unite(numerator.rect)
        self.rect.unite(denominator.rect)
        self.rect.adjust(rect.Point(0,0),rect.Point(dx,0))

    def cellPDF(self, pdf, r = None):
        MultiItem.cellPDF(self, pdf, r)
        y = self.items[0].rect.y1()
        pdf.set_line_width(0.2)
        if r:
            x_shift = r.x0()
            y_shift = r.y0()
        else:
            x_shift = 0.0
            y_shift = 0.0
        pdf.line(self.rect.x0() - x_shift, y - y_shift, self.rect.x1() - x_shift, y - y_shift)
コード例 #47
0
class TreeNode:
    def __init__(self, label=""):
        self.rect = Rect(0, 0, *SIZE)
        self.label = label

    def is_suitable(self):
        """ Testing if this instance is suitable. Wraps is_suitable() from Rect """

        return self.rect.is_suitable()

    def __str__(self):
        return u"<{}> {}".format(self.label, self.rect)
コード例 #48
0
ファイル: create_map.py プロジェクト: phegan/dungeongenerator
def main():
    dungeon_map = [['_' for x in xrange(MAP_HEIGHT)] for x in xrange(MAP_WIDTH)]
    rooms = []
    num_rooms = 0

    for r in xrange(MAX_ROOMS):
        width = random.randrange(ROOM_MIN_SIZE, ROOM_MAX_SIZE)
        height = random.randrange(ROOM_MIN_SIZE, ROOM_MAX_SIZE)
        xcorner = random.randrange(0, MAP_WIDTH - width - 1)
        ycorner = random.randrange(0, MAP_HEIGHT - height - 1)
        new_room = Rect(xcorner, ycorner, width, height)
        # new_room.print_rect()

        if num_rooms > 0:
            for other_room in rooms:
                if new_room.intersect(other_room):
                    break

                dungeon_map = create_room(new_room, dungeon_map)
                (new_x, new_y) = new_room.center()
                (prev_x, prev_y) = rooms[num_rooms-1].center()

                if random.randrange(0, 1) == 1:
                    #first move horizontally, then vertically
                    dungeon_map = create_h_tunnel(prev_x, new_x, prev_y, dungeon_map)
                    dungeon_map = create_v_tunnel(prev_y, new_y, new_x, dungeon_map)
                else:
                    #first move vertically, then horizontally
                    dungeon_map = create_v_tunnel(prev_y, new_y, prev_x, dungeon_map)
                    dungeon_map = create_h_tunnel(prev_x, new_x, new_y, dungeon_map)

                rooms.append(new_room)
                num_rooms = num_rooms + 1

        else:
            dungeon_map = create_room(new_room, dungeon_map)
            rooms.append(new_room)
            num_rooms = num_rooms + 1

    print_dungeon_map(dungeon_map)
コード例 #49
0
def digCave(nature):
	caves = RESOURCES.count('CAVE')
	print('Digging %d cave%s' % ( caves, 's' if caves > 1 else ''))
	for p in range(0,RESOURCES.count('CAVE')):
		CX  = config['CITY_SIZE_X']
		CY  = config['CITY_SIZE_Y']
		CX2 = config['CITY_SIZE_X']//2
		CY2 = config['CITY_SIZE_Y']//2
		CX3 = config['CITY_SIZE_X']//3
		CY3 = config['CITY_SIZE_Y']//3
		p=Point(CX2,CY2)
		MPS=200
		mps=30
		if(random.randint(0,1)==0):
			p1=Point(random.randint(0,CX3),random.randint(0,CY))
		else:
			p1=Point(random.randint(0,CX),random.randint(0,CY3))

		p2=Point(random.randint(p1.x+mps,p1.x+MPS), random.randint(p1.y+mps,p1.y+MPS))
		place=Rect(p1,p2)
		place.set_name('CAVE')
		nature.append(place)
コード例 #50
0
    def __init__(self, items=None, depth=8, bounding_rect=None):
        """Creates a quad-tree.

        @param items:
            A sequence of items to store in the quad-tree.
            Note that these items must be of SimObject.

        @param depth:
            The maximum recursion depth.

        @param bounding_rect:
            The bounding rectangle of all of the items in the quad-tree.
            Type of Rect or (x,y,w,h) of the rectangle
            For internal use only.
        """

        # The sub-quadrants are empty to start with.
        self.nw = self.ne = self.se = self.sw = None
        self.depth = depth

        # Find this quadrant's centre.
        if bounding_rect:
            bounding_rect = Rect(bounding_rect)
        else:
            # If there isn't a bounding rect, then calculate it from the items.
            if items:
                bounding_rect = Rect(items[0].get_bounding_rect())
                for item in items[1:]:
                    bounding_rect.add(Rect(item.get_bounding_rect()))
            else:
                # in case there are no items, assume a big rect (100x100
                # meters)
                bounding_rect = Rect((0.0, 0.0, 100.0, 100.0))

        self.rect = bounding_rect
        self.items = []

        # Insert items
        self.insert_items(items)
コード例 #51
0
ファイル: fcp.py プロジェクト: uneekone/fantasy-city-planner
def test_temp(yy,xx,place):
    nw=Rect(Point(0,0),Point(CITY_SIZE_X/2,CITY_SIZE_Y/2))
    ne=Rect(Point(CITY_SIZE_X/2,0),Point(CITY_SIZE_X,CITY_SIZE_Y/2))
    sw=Rect(Point(0,CITY_SIZE_Y/2),Point(CITY_SIZE_X/2,CITY_SIZE_Y))
    se=Rect(Point(CITY_SIZE_X/2,CITY_SIZE_Y/2),Point(CITY_SIZE_X,CITY_SIZE_Y))
    if(xx==0)and(yy==0):
        if(not nw.overlaps(place)):
            print('errore micidiale 1');
    if(xx==0)and(yy==1):
        if(not ne.overlaps(place)):
            print('errore micidiale 2');
    if(xx==1)and(yy==0):
        if(not sw.overlaps(place)):
            print('errore micidiale 3');
    if(xx==1)and(yy==1):
        if(not se.overlaps(place)):
            print('errore micidiale 4');
コード例 #52
0
ファイル: document_pdf.py プロジェクト: rrnntt/document
 def resizePDF(self, pdf, x = 0, y = 0):
     self.resizeItemsPDF(pdf, x, y)
     dx = pdf.get_string_width(' ') * self.style[1]
     self.rect = Rect(x,y,x,y)
      
     h = self.base.rect.height()
     w = self.base.rect.width() + dx
     
     if self.subscript:
         self.subscript.rect.translate(w, h*0.5)
         self.rect.unite(self.subscript.rect)
     if self.superscript:
         self.superscript.rect.translate(w, - h*0.5)
         self.rect.unite(self.superscript.rect)
     
     self.refit()
コード例 #53
0
ファイル: folding_box.py プロジェクト: pborky/pyneuro
	def update_layout(self):
		SingleContainer.update_layout(self)
		
		if self.theme:
			patch = self.theme['folding_box'][('image_closed' if self._collapsed else 'image')]
			
			if self.content:
				self._w = self.content.w + patch.padding_left + patch.padding_right
				if not self._collapsed:
					self._h = self.content.h + patch.padding_bottom + patch.padding_top
			
			self.elements['topbar'].update(patch.padding_left, self.h - patch.padding_top, self.w - patch.padding_left - patch.padding_right, 1)
			self.elements['title'].x = patch.padding_left
			self.elements['title'].y = self.h - patch.padding_top/2 + 1
			
			self.topbar = Rect(0, self.h-patch.padding_top, self.w, patch.padding_top)