我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用pygame.surface()。
def maskFromSurface(surface, threshold = 127): #return pygame.mask.from_surface(surface, threshold) mask = pygame.mask.Mask(surface.get_size()) key = surface.get_colorkey() if key: for y in range(surface.get_height()): for x in range(surface.get_width()): if surface.get_at((x+0.1,y+0.1)) != key: mask.set_at((x,y),1) else: for y in range(surface.get_height()): for x in range (surface.get_width()): if surface.get_at((x,y))[3] > threshold: mask.set_at((x,y),1) return mask
def test_copy(self): # __doc__ (as of 2008-06-25) for pygame.surface.Surface.copy: # Surface.copy(): return Surface # create a new copy of a Surface color = (25, 25, 25, 25) s1 = pygame.Surface((32,32), pygame.SRCALPHA, 32) s1.fill(color) s2 = s1.copy() s1rect = s1.get_rect() s2rect = s2.get_rect() self.assert_(s1rect.size == s2rect.size) self.assert_(s2.get_at((10,10)) == color)
def test_fill_negative_coordinates(self): # negative coordinates should be clipped by fill, and not draw outside the surface. color = (25, 25, 25, 25) color2 = (20, 20, 20, 25) fill_rect = pygame.Rect(-10, -10, 16, 16) s1 = pygame.Surface((32,32), pygame.SRCALPHA, 32) r1 = s1.fill(color, fill_rect) c = s1.get_at((0,0)) self.assertEqual(c, color) # make subsurface in the middle to test it doesn't over write. s2 = s1.subsurface((5, 5, 5, 5)) r2 = s2.fill(color2, (-3, -3, 5, 5)) c2 = s1.get_at((4,4)) self.assertEqual(c, color) # rect returns the area we actually fill. r3 = s2.fill(color2, (-30, -30, 5, 5)) # since we are using negative coords, it should be an zero sized rect. self.assertEqual(tuple(r3), (0, 0, 0, 0))
def test_get_alpha(self): # __doc__ (as of 2008-06-25) for pygame.surface.Surface.get_alpha: # Surface.get_alpha(): return int_value or None # get the current Surface transparency value s1 = pygame.Surface((32,32), pygame.SRCALPHA, 32) self.assert_(s1.get_alpha() == 255) for alpha in (0, 32, 127, 255): s1.set_alpha(alpha) for t in range(4): s1.set_alpha(s1.get_alpha()) self.assert_(s1.get_alpha() == alpha) ########################################################################
def test_set_colorkey(self): # __doc__ (as of 2008-06-25) for pygame.surface.Surface.set_colorkey: # Surface.set_colorkey(Color, flags=0): return None # Surface.set_colorkey(None): return None # Set the transparent colorkey s = pygame.Surface((16,16), pygame.SRCALPHA, 32) colorkeys = ((20,189,20, 255),(128,50,50,255), (23, 21, 255,255)) for colorkey in colorkeys: s.set_colorkey(colorkey) for t in range(4): s.set_colorkey(s.get_colorkey()) self.assertEquals(s.get_colorkey(), colorkey)
def todo_test_convert_alpha(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.convert_alpha: # Surface.convert_alpha(Surface): return Surface # Surface.convert_alpha(): return Surface # change the pixel format of an image including per pixel alphas # # Creates a new copy of the surface with the desired pixel format. The # new surface will be in a format suited for quick blitting to the # given format with per pixel alpha. If no surface is given, the new # surface will be optimized for blitting to the current display. # # Unlike the Surface.convert() method, the pixel format for the new # image will not be exactly the same as the requested source, but it # will be optimized for fast alpha blitting to the destination. # self.fail()
def todo_test_mustlock(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.mustlock: # Surface.mustlock(): return bool # test if the Surface requires locking # # Returns True if the Surface is required to be locked to access pixel # data. Usually pure software Surfaces do not require locking. This # method is rarely needed, since it is safe and quickest to just lock # all Surfaces as needed. # # All pygame functions will automatically lock and unlock the Surface # data as needed. If a section of code is going to make calls that # will repeatedly lock and unlock the Surface many times, it can be # helpful to wrap the block inside a lock and unlock pair. # self.fail()
def test_convert(self): """Ensure method convert() preserves the surface's class When Surface is subclassed, the inherited convert() method will return instances of the subclass. Non Surface fields are omitted, however. This includes instance attributes. """ pygame.display.init() try: ms1 = self.MySurface((32, 32), 0, 24) ms2 = ms1.convert(24) self.assertTrue(ms2 is not ms1) self.assertTrue(isinstance(ms2, self.MySurface)) self.assertTrue(ms1.an_attribute) self.assertRaises(AttributeError, getattr, ms2, "an_attribute") finally: pygame.display.quit()
def test_convert_alpha(self): """Ensure method convert_alpha() preserves the surface's class When Surface is subclassed, the inherited convert_alpha() method will return instances of the subclass. Non Surface fields are omitted, however. This includes instance attributes. """ pygame.display.init() try: pygame.display.set_mode((40, 40)) s = pygame.Surface((32, 32), pygame.SRCALPHA, 16) ms1 = self.MySurface((32, 32), pygame.SRCALPHA, 32) ms2 = ms1.convert_alpha(s) self.assertTrue(ms2 is not ms1) self.assertTrue(isinstance(ms2, self.MySurface)) self.assertTrue(ms1.an_attribute) self.assertRaises(AttributeError, getattr, ms2, "an_attribute") finally: pygame.display.quit()
def test_colorkey(self): # Check a workaround for an SDL 1.2.13 surface self-blit problem # (MotherHamster Bugzilla bug 19). pygame.display.set_mode((100, 50)) # Needed for 8bit surface bitsizes = [8, 16, 24, 32] for bitsize in bitsizes: surf = self._make_surface(bitsize) surf.set_colorkey(self._test_palette[1]) surf.blit(surf, (3, 0)) p = [] for c in self._test_palette: c = surf.unmap_rgb(surf.map_rgb(c)) p.append(c) p[1] = (p[1][0], p[1][1], p[1][2], 0) tmp = self._make_surface(32, srcalpha=True, palette=p) tmp.blit(tmp, (3, 0)) tmp.set_alpha(None) comp = self._make_surface(bitsize) comp.blit(tmp, (0, 0)) self._assert_same(surf, comp)
def test_blanket_alpha(self): # Check a workaround for an SDL 1.2.13 surface self-blit problem # (MotherHamster Bugzilla bug 19). pygame.display.set_mode((100, 50)) # Needed for 8bit surface bitsizes = [8, 16, 24, 32] for bitsize in bitsizes: surf = self._make_surface(bitsize) surf.set_alpha(128) surf.blit(surf, (3, 0)) p = [] for c in self._test_palette: c = surf.unmap_rgb(surf.map_rgb(c)) p.append((c[0], c[1], c[2], 128)) tmp = self._make_surface(32, srcalpha=True, palette=p) tmp.blit(tmp, (3, 0)) tmp.set_alpha(None) comp = self._make_surface(bitsize) comp.blit(tmp, (0, 0)) self._assert_same(surf, comp)
def todo_test_unlock(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.unlock: # Surface.unlock(): return None # unlock the Surface memory from pixel access # # Unlock the Surface pixel data after it has been locked. The unlocked # Surface can once again be drawn and managed by Pygame. See the # Surface.lock() documentation for more details. # # All pygame functions will automatically lock and unlock the Surface # data as needed. If a section of code is going to make calls that # will repeatedly lock and unlock the Surface many times, it can be # helpful to wrap the block inside a lock and unlock pair. # # It is safe to nest locking and unlocking calls. The surface will # only be unlocked after the final lock is released. # self.fail()
def test_colorkey(self): # Check a workaround for an SDL 1.2.13 surface self-blit problem # (MotherHamster Bugzilla bug 19). pygame.display.set_mode((100, 50)) # Needed for 8bit surface bitsizes = [8, 16, 24, 32] for bitsize in bitsizes: surf = self._make_surface(bitsize) surf.set_colorkey(self.test_palette[1]) surf.blit(surf, (3, 0)) p = [] for c in self.test_palette: c = surf.unmap_rgb(surf.map_rgb(c)) p.append(c) p[1] = (p[1][0], p[1][1], p[1][2], 0) tmp = self._make_surface(32, srcalpha=True, palette=p) tmp.blit(tmp, (3, 0)) tmp.set_alpha(None) comp = self._make_surface(bitsize) comp.blit(tmp, (0, 0)) self._assert_same(surf, comp)
def test_subsurface(self): # Blitting a surface to its subsurface is allowed. surf = self._make_surface(32, srcalpha=True) comp = surf.copy() comp.blit(surf, (3, 0)) sub = surf.subsurface((3, 0, 6, 6)) sub.blit(surf, (0, 0)) del sub self._assert_same(surf, comp) # Blitting a subsurface to its owner is forbidden because of # lock conficts. This limitation allows the overlap check # in PySurface_Blit of alphablit.c to be simplified. def do_blit(d, s): d.blit(s, (0, 0)) sub = surf.subsurface((1, 1, 2, 2)) self.failUnlessRaises(pygame.error, do_blit, surf, sub)
def __init__(self, surface, mask = None): self.surface = surface if mask: self.mask = mask else: self.mask = maskFromSurface(self.surface) self.setPos([0,0]) self.setVelocity([0,0])
def test_set_clip( self ): """ see if surface.set_clip(None) works correctly. """ s = pygame.Surface((800, 600)) r = pygame.Rect(10, 10, 10, 10) s.set_clip(r) r.move_ip(10, 0) s.set_clip(None) res = s.get_clip() # this was garbled before. self.assertEqual(res[0], 0) self.assertEqual(res[2], 800)
def test_SRCALPHA(self): # has the flag been passed in ok? surf = pygame.Surface((70,70), SRCALPHA, 32) self.assertEqual(surf.get_flags() & SRCALPHA, SRCALPHA) #24bit surfaces can not have SRCALPHA. self.assertRaises(ValueError, pygame.Surface, (100, 100), pygame.SRCALPHA, 24) # if we have a 32 bit surface, the SRCALPHA should have worked too. surf2 = pygame.Surface((70,70), SRCALPHA) if surf2.get_bitsize() == 32: self.assertEqual(surf2.get_flags() & SRCALPHA, SRCALPHA)
def test_get_bytesize(self): # __doc__ (as of 2008-06-25) for pygame.surface.Surface.get_bytesize: # Surface.get_bytesize(): return int # get the bytes used per Surface pixel s1 = pygame.Surface((32,32), pygame.SRCALPHA, 32) self.assert_(s1.get_bytesize() == 4) self.assert_(s1.get_bitsize() == 32) ########################################################################
def test_get_flags(self): # __doc__ (as of 2008-06-25) for pygame.surface.Surface.get_flags: # Surface.get_flags(): return int # get the additional flags used for the Surface s1 = pygame.Surface((32,32), pygame.SRCALPHA, 32) self.assert_(s1.get_flags() == pygame.SRCALPHA) ########################################################################
def test_get_parent(self): # __doc__ (as of 2008-06-25) for pygame.surface.Surface.get_parent: # Surface.get_parent(): return Surface # find the parent of a subsurface parent = pygame.Surface((16, 16)) child = parent.subsurface((0,0,5,5)) self.assert_(child.get_parent() is parent) ########################################################################
def test_get_width__size_and_height(self): # __doc__ (as of 2008-06-25) for pygame.surface.Surface.get_width: # Surface.get_width(): return width # get the width of the Surface for w in xrange_(0, 255, 32): for h in xrange_(0, 127, 15): s = pygame.Surface((w, h)) self.assertEquals(s.get_width(), w) self.assertEquals(s.get_height(), h) self.assertEquals(s.get_size(), (w, h))
def todo_test_blit(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.blit: # Surface.blit(source, dest, area=None, special_flags = 0): return Rect # draw one image onto another # # Draws a source Surface onto this Surface. The draw can be positioned # with the dest argument. Dest can either be pair of coordinates # representing the upper left corner of the source. A Rect can also be # passed as the destination and the topleft corner of the rectangle # will be used as the position for the blit. The size of the # destination rectangle does not effect the blit. # # An optional area rectangle can be passed as well. This represents a # smaller portion of the source Surface to draw. # # An optional special flags is for passing in new in 1.8.0: BLEND_ADD, # BLEND_SUB, BLEND_MULT, BLEND_MIN, BLEND_MAX new in 1.8.1: # BLEND_RGBA_ADD, BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, # BLEND_RGBA_MAX BLEND_RGB_ADD, BLEND_RGB_SUB, BLEND_RGB_MULT, # BLEND_RGB_MIN, BLEND_RGB_MAX With other special blitting flags # perhaps added in the future. # # The return rectangle is the area of the affected pixels, excluding # any pixels outside the destination Surface, or outside the clipping # area. # # Pixel alphas will be ignored when blitting to an 8 bit Surface. # special_flags new in pygame 1.8. self.fail()
def todo_test_convert(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.convert: # Surface.convert(Surface): return Surface # Surface.convert(depth, flags=0): return Surface # Surface.convert(masks, flags=0): return Surface # Surface.convert(): return Surface # change the pixel format of an image # # Creates a new copy of the Surface with the pixel format changed. The # new pixel format can be determined from another existing Surface. # Otherwise depth, flags, and masks arguments can be used, similar to # the pygame.Surface() call. # # If no arguments are passed the new Surface will have the same pixel # format as the display Surface. This is always the fastest format for # blitting. It is a good idea to convert all Surfaces before they are # blitted many times. # # The converted Surface will have no pixel alphas. They will be # stripped if the original had them. See Surface.convert_alpha() for # preserving or creating per-pixel alphas. # self.fail()
def todo_test_get_abs_parent(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_abs_parent: # Surface.get_abs_parent(): return Surface # find the top level parent of a subsurface # # Returns the parent Surface of a subsurface. If this is not a # subsurface then this surface will be returned. # self.fail()
def todo_test_get_bitsize(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_bitsize: # Surface.get_bitsize(): return int # get the bit depth of the Surface pixel format # # Returns the number of bits used to represent each pixel. This value # may not exactly fill the number of bytes used per pixel. For example # a 15 bit Surface still requires a full 2 bytes. # self.fail()
def todo_test_get_clip(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_clip: # Surface.get_clip(): return Rect # get the current clipping area of the Surface # # Return a rectangle of the current clipping area. The Surface will # always return a valid rectangle that will never be outside the # bounds of the image. If the Surface has had None set for the # clipping area, the Surface will return a rectangle with the full # area of the Surface. # self.fail()
def todo_test_get_colorkey(self): surf = pygame.surface((2, 2), 0, 24) self.failUnless(surf.get_colorykey() is None) colorkey = pygame.Color(20, 40, 60) surf.set_colorkey(colorkey) ck = surf.get_colorkey() self.failUnless(isinstance(ck, pygame.Color)) self.failUnlessEqual(ck, colorkey)
def todo_test_get_height(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_height: # Surface.get_height(): return height # get the height of the Surface # # Return the height of the Surface in pixels. self.fail()
def todo_test_get_locks(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_locks: # Surface.get_locks(): return tuple # Gets the locks for the Surface # # Returns the currently existing locks for the Surface. self.fail()
def todo_test_get_losses(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_losses: # Surface.get_losses(): return (R, G, B, A) # the significant bits used to convert between a color and a mapped integer # # Return the least significant number of bits stripped from each color # in a mapped integer. # # This value is not needed for normal Pygame usage. self.fail()
def todo_test_get_masks(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_masks: # Surface.get_masks(): return (R, G, B, A) # the bitmasks needed to convert between a color and a mapped integer # # Returns the bitmasks used to isolate each color in a mapped integer. # This value is not needed for normal Pygame usage. self.fail()
def todo_test_get_offset(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_offset: # Surface.get_offset(): return (x, y) # find the position of a child subsurface inside a parent # # Get the offset position of a child subsurface inside of a parent. If # the Surface is not a subsurface this will return (0, 0). # self.fail()
def todo_test_get_pitch(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_pitch: # Surface.get_pitch(): return int # get the number of bytes used per Surface row # # Return the number of bytes separating each row in the Surface. # Surfaces in video memory are not always linearly packed. Subsurfaces # will also have a larger pitch than their real width. # # This value is not needed for normal Pygame usage. self.fail()
def todo_test_get_size(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.get_size: # Surface.get_size(): return (width, height) # get the dimensions of the Surface # # Return the width and height of the Surface in pixels. self.fail()
def todo_test_lock(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.lock: # Surface.lock(): return None # lock the Surface memory for pixel access # # Lock the pixel data of a Surface for access. On accelerated # Surfaces, the pixel data may be stored in volatile video memory or # nonlinear compressed forms. When a Surface is locked the pixel # memory becomes available to access by regular software. Code that # reads or writes pixel values will need the Surface to be locked. # # Surfaces should not remain locked for more than necessary. A locked # Surface can often not be displayed or managed by Pygame. # # Not all Surfaces require locking. The Surface.mustlock() method can # determine if it is actually required. There is no performance # penalty for locking and unlocking a Surface that does not need it. # # All pygame functions will automatically lock and unlock the Surface # data as needed. If a section of code is going to make calls that # will repeatedly lock and unlock the Surface many times, it can be # helpful to wrap the block inside a lock and unlock pair. # # It is safe to nest locking and unlocking calls. The surface will # only be unlocked after the final lock is released. # self.fail()
def todo_test_set_alpha(self): # __doc__ (as of 2008-08-02) for pygame.surface.Surface.set_alpha: # Surface.set_alpha(value, flags=0): return None # Surface.set_alpha(None): return None # set the alpha value for the full Surface image # # Set the current alpha value fo r the Surface. When blitting this # Surface onto a destination, the pixels will be drawn slightly # transparent. The alpha value is an integer from 0 to 255, 0 is fully # transparent and 255 is fully opaque. If None is passed for the alpha # value, then the Surface alpha will be disabled. # # This value is different than the per pixel Surface alpha. If the # Surface format contains per pixel alphas, then this alpha value will # be ignored. If the Surface contains per pixel alphas, setting the # alpha value to None will disable the per pixel transparency. # # The optional flags argument can be set to pygame.RLEACCEL to provide # better performance on non accelerated displays. An RLEACCEL Surface # will be slower to modify, but quicker to blit as a source. # s = pygame.Surface((1,1), SRCALHPA, 32) s.fill((1, 2, 3, 4)) s.set_alpha(None) self.failUnlessEqual(s.get_at((0, 0)), (1, 2, 3, 255)) self.fail()
def test_unmap_rgb(self): # Special case, 8 bit-per-pixel surface (has a palette). surf = pygame.Surface((2, 2), 0, 8) c = (1, 1, 1) # Unlikely to be in a default palette. i = 67 pygame.init() try: pygame.display.set_mode((100, 50)) surf.set_palette_at(i, c) unmapped_c = surf.unmap_rgb(i) self.failUnlessEqual(unmapped_c, c) # Confirm it is a Color instance self.failUnless(isinstance(unmapped_c, pygame.Color)) finally: pygame.quit() # Remaining, non-pallete, cases. c = (128, 64, 12, 255) formats = [(0, 16), (0, 24), (0, 32), (SRCALPHA, 16), (SRCALPHA, 32)] for flags, bitsize in formats: surf = pygame.Surface((2, 2), flags, bitsize) unmapped_c = surf.unmap_rgb(surf.map_rgb(c)) surf.fill(c) comparison_c = surf.get_at((0, 0)) self.failUnlessEqual(unmapped_c, comparison_c, "%s != %s, flags: %i, bitsize: %i" % (unmapped_c, comparison_c, flags, bitsize)) # Confirm it is a Color instance self.failUnless(isinstance(unmapped_c, pygame.Color))
def test_copy(self): """Ensure method copy() preserves the surface's class When Surface is subclassed, the inherited copy() method will return instances of the subclass. Non Surface fields are uncopied, however. This includes instance attributes. """ ms1 = self.MySurface((32, 32), pygame.SRCALPHA, 32) ms2 = ms1.copy() self.assertTrue(isinstance(ms2, self.MySurface)) self.assertTrue(ms1.an_attribute) self.assertRaises(AttributeError, getattr, ms2, "an_attribute")
def test_subsurface(self): """Ensure method subsurface() preserves the surface's class When Surface is subclassed, the inherited subsurface() method will return instances of the subclass. Non Surface fields are uncopied, however. This includes instance attributes. """ ms1 = self.MySurface((32, 32), pygame.SRCALPHA, 32) ms2 = ms1.subsurface((4, 5, 10, 12)) self.assertTrue(isinstance(ms2, self.MySurface)) self.assertTrue(ms1.an_attribute) self.assertRaises(AttributeError, getattr, ms2, "an_attribute")
def test_GET_PIXELVALS(self): # surface.h GET_PIXELVALS bug regarding whether of not # a surface has per-pixel alpha. Looking at the Amask # is not enough. The surface's SRCALPHA flag must also # be considered. Fix rev. 1923. src = self._make_surface(32, srcalpha=True) src.fill((0, 0, 0, 128)) src.set_alpha(None) # Clear SRCALPHA flag. dst = self._make_surface(32, srcalpha=True) dst.blit(src, (0, 0), special_flags=BLEND_RGBA_ADD) self.failUnlessEqual(dst.get_at((0, 0)), (0, 0, 0, 255))
def setUp(self): # Needed for 8 bits-per-pixel color palette surface tests. pygame.init()
def test_overlap_check(self): # Ensure overlapping blits are properly detected. There are two # places where this is done, within SoftBlitPyGame() in alphablit.c # and PySurface_Blit() in surface.c. SoftBlitPyGame should catch the # per-pixel alpha surface, PySurface_Blit the colorkey and blanket # alpha surface. per-pixel alpha and blanket alpha self blits are # not properly handled by SDL 1.2.13, so Pygame does them. bgc = (0, 0, 0, 255) rectc_left = (128, 64, 32, 255) rectc_right = (255, 255, 255, 255) colors = [(255, 255, 255, 255), (128, 64, 32, 255)] overlaps = [(0, 0, 1, 0, (50, 0)), (0, 0, 49, 1, (98, 2)), (0, 0, 49, 49, (98, 98)), (49, 0, 0, 1, (0, 2)), (49, 0, 0, 49, (0, 98))] surfs = [pygame.Surface((100, 100), SRCALPHA, 32)] surf = pygame.Surface((100, 100), 0, 32) surf.set_alpha(255) surfs.append(surf) surf = pygame.Surface((100, 100), 0, 32) surf.set_colorkey((0, 1, 0)) surfs.append(surf) for surf in surfs: for s_x, s_y, d_x, d_y, test_posn in overlaps: surf.fill(bgc) surf.fill(rectc_right, (25, 0, 25, 50)) surf.fill(rectc_left, (0, 0, 25, 50)) surf.blit(surf, (d_x, d_y), (s_x, s_y, 50, 50)) self.failUnlessEqual(surf.get_at(test_posn), rectc_right)
def __init__(self, size=(640, 480), xlim=None, ylim=None): pygame.init() screen = pygame.display.set_mode(size) #surface = pygame.surface(size, pygame.SRCALPHA) if xlim is None: xlim = (0, size[0]) if ylim is None: ylim = (0, size[1]) self._screen = screen #self._surface = surface #self.screen.blit(self.surface, (0, 0)) self._xlim = xlim self._ylim = ylim
def rect(self, color, center, size): cx, cy = self.scale_point(center) w, h = self.scale_size(size) if len(color) > 3: s = pygame.Surface((w, h), pygame.SRCALPHA) s.fill(color) self.screen.blit(s, (cx-w/2, cy-h/2)) #pygame.draw.rect(self.surface, color, pygame.Rect(cx-w/2, cy-h/2, w, h)) else: pygame.draw.rect(self.screen, color, pygame.Rect(cx-w/2, cy-h/2, w, h))
