def test_mask_access( self ): """ do the set_at, and get_at parts work correctly? """ m = pygame.Mask((10,10)) m.set_at((0,0), 1) self.assertEqual(m.get_at((0,0)), 1) m.set_at((9,0), 1) self.assertEqual(m.get_at((9,0)), 1) #s = pygame.Surface((10,10)) #s.set_at((1,0), (0, 0, 1, 255)) #self.assertEqual(s.get_at((1,0)), (0, 0, 1, 255)) #s.set_at((-1,0), (0, 0, 1, 255)) # out of bounds, should get IndexError self.assertRaises(IndexError, lambda : m.get_at((-1,0)) ) self.assertRaises(IndexError, lambda : m.set_at((-1,0), 1) ) self.assertRaises(IndexError, lambda : m.set_at((10,0), 1) ) self.assertRaises(IndexError, lambda : m.set_at((0,10), 1) )
def drawPlatform(x, y, x2, y2, colour): pygame.draw.rect(gameDisplay, colour, [x, y, x2 - x, y2 - y]) if x2 < x: print( "ERROR YOU HAVE USED THE FUNCTION WRONG THE 1st VALUE CANNOT BE BIGGER THAT THE 3rd - X" ) if y2 < y: print( "ERROR YOU HAVE USED THE FUNCTION WRONG THE 4TH VALUE CANNOT BE BIGGER THAT THE SECCOND - Y" ) platformMask = pygame.Mask((int(x2 - x), int(y2 - y))) player1TopCorner = [ player1Pos[0] - player1SpriteHalfWidth, player1Pos[1] - player1SpriteHalfHeight ] player1_platformOffsetWithVsp = (int(player1TopCorner[0] + player1PosChange[0] - x), int(player1TopCorner[1] + player1PosChange[1] - y)) player1_platformCollide = player1SpriteMask.overlap( platformMask, player1_platformOffsetWithVsp) if player1_platformCollide: print("ya Yeet") player1PosChange[1] = 0 player1_platformOffset = (int(player1Pos[0] - (x2 - x) / 2), int(player1Pos[1] - (y2 - y) / 2) ) #update variable while player1SpriteMask.overlap(platformMask, player1_platformOffset) != True: player1Pos[1] += 1 player1_platformOffset = (int(player1Pos[0] - (x2 - x) / 2), int(player1Pos[1] - (y2 - y) / 2) ) #update variable #if player1Pos[1] == y - playerThickness/2: if player2Pos[1] == y - playerThickness / 2: player2PosChange[1] = 0 return [player1PosChange[1], player2PosChange[1]]
def __init__(self, name, sheet, pos, speed, *groups): coords, size = ENEMY_COORDS[name], prepare.CELL_SIZE tools.BaseSprite.__init__(self, pos, size, *groups) self.frames = tools.strip_coords_from_sheet(sheet, coords, size) self.mask = pg.Mask(prepare.CELL_SIZE) self.mask.fill() self.steps = [0, 0] self.ai = BasicAI(self) self.speed = speed self.direction = None self.anim_directions = prepare.DIRECTIONS[:] self.anim_direction = random.choice(self.anim_directions) self.shadow = shadow.Shadow((40, 20), self.rect) self.image = None self.state = "walk" self.hit_state = False self.knock_state = False self.knock_dir = None self.knock_collide = None self.knock_clear = None self.busy = False self.act_mid_step = False self.drops = [None]
def test_connected_components(self): """ """ m = pygame.Mask((10,10)) self.assertEquals(repr(m.connected_components()), "[]") comp = m.connected_component() self.assertEquals(m.count(), comp.count()) m.set_at((0,0), 1) m.set_at((1,1), 1) comp = m.connected_component() comps = m.connected_components() comps1 = m.connected_components(1) comps2 = m.connected_components(2) comps3 = m.connected_components(3) self.assertEquals(comp.count(), comps[0].count()) self.assertEquals(comps1[0].count(), 2) self.assertEquals(comps2[0].count(), 2) self.assertEquals(repr(comps3), "[]") m.set_at((9, 9), 1) comp = m.connected_component() comp1 = m.connected_component((1, 1)) comp2 = m.connected_component((2, 2)) comps = m.connected_components() comps1 = m.connected_components(1) comps2 = m.connected_components(2) comps3 = m.connected_components(3) self.assertEquals(comp.count(), 2) self.assertEquals(comp1.count(), 2) self.assertEquals(comp2.count(), 0) self.assertEquals(len(comps), 2) self.assertEquals(len(comps1), 2) self.assertEquals(len(comps2), 1) self.assertEquals(len(comps3), 0)
def __init__(self, x=0.0, y=0.0, vx=0.0, vy=0.0, angle=0.0): super().__init__(x=x, y=y, vx=vx, vy=vy, angle=angle) self.name = 'Ship' self.lives = 3 self.score = 0 self.firing = False self.firing_cooldown = 0 self.thrusting = False self.image = pygame.Surface([32, 32], flags=pygame.SRCALPHA) self.rect = pygame.Rect(x, y, 32, 32) self.visible = 1 self.base_images = [ pygame.Surface([32, 32], flags=pygame.SRCALPHA) for i in range(360) ] self.base_images_thrust = [ pygame.Surface([32, 32], flags=pygame.SRCALPHA) for i in range(360) ] self.init_base_image() self.mask = pygame.Mask([32, 32]) self.masks = [ pygame.mask.from_surface(surf) for surf in self.base_images ] self.thrust_sound = pygame.mixer.Sound("sounds/thrust.wav") self.thrust_channel = pygame.mixer.Channel(constants.THRUST_CHANNEL) self.explode_sound = pygame.mixer.Sound("sounds/ship-explode.wav") self.explode_channel = pygame.mixer.Channel( constants.SHIP_EXPLODE_CHANNEL)
def __init__(self, name, pos, duration, chest=False, ident=None, *groups): """ The argument name is the type of item corresponding to the ITEMS dict; pos is the location on the map the item is located; if the item is in a treasure chest, pass chest=True; if the player can only get this item once, pass a unique (to the map) ident string to be stored in the player's identifiers attribute. """ pg.sprite.Sprite.__init__(self, *groups) coords, size = ITEM_COORDS[name], prepare.CELL_SIZE self.frames = tools.strip_coords_from_sheet(ITEM_SHEET, coords, size) self.anim = tools.Anim(self.frames, 7) self.image = self.anim.get_next_frame(pg.time.get_ticks()) # Subtract 1 from y axis to make item drop appear behind death anim. self.rect = pg.Rect((pos[0], pos[1] - 1), prepare.CELL_SIZE) self.exact_position = list(self.rect.topleft) self.old_position = self.exact_position[:] self.mask = pg.Mask(prepare.CELL_SIZE) self.mask.fill() self.timer = tools.Timer(duration * 1000, 1) if duration else None self.from_chest = chest self.identifier = ident # Used to stop respawning of unique items. self.height = 0 # Used when item rises from chest. self.sound_effect = None
def test_get_bounding_rects(self): """ """ m = pygame.Mask((10,10)) m.set_at((0,0), 1) m.set_at((1,0), 1) m.set_at((0,1), 1) m.set_at((0,3), 1) m.set_at((3,3), 1) r = m.get_bounding_rects() self.assertEquals(repr(r), "[<rect(0, 0, 2, 2)>, <rect(0, 3, 1, 1)>, <rect(3, 3, 1, 1)>]") #1100 #1111 m = pygame.Mask((4,2)) m.set_at((0,0), 1) m.set_at((1,0), 1) m.set_at((2,0), 0) m.set_at((3,0), 0) m.set_at((0,1), 1) m.set_at((1,1), 1) m.set_at((2,1), 1) m.set_at((3,1), 1) r = m.get_bounding_rects() self.assertEquals(repr(r), "[<rect(0, 0, 4, 2)>]") #00100 #01110 #00100 m = pygame.Mask((5,3)) m.set_at((0,0), 0) m.set_at((1,0), 0) m.set_at((2,0), 1) m.set_at((3,0), 0) m.set_at((4,0), 0) m.set_at((0,1), 0) m.set_at((1,1), 1) m.set_at((2,1), 1) m.set_at((3,1), 1) m.set_at((4,1), 0) m.set_at((0,2), 0) m.set_at((1,2), 0) m.set_at((2,2), 1) m.set_at((3,2), 0) m.set_at((4,2), 0) r = m.get_bounding_rects() self.assertEquals(repr(r), "[<rect(1, 0, 3, 3)>]") #00010 #00100 #01000 m = pygame.Mask((5,3)) m.set_at((0,0), 0) m.set_at((1,0), 0) m.set_at((2,0), 0) m.set_at((3,0), 1) m.set_at((4,0), 0) m.set_at((0,1), 0) m.set_at((1,1), 0) m.set_at((2,1), 1) m.set_at((3,1), 0) m.set_at((4,1), 0) m.set_at((0,2), 0) m.set_at((1,2), 1) m.set_at((2,2), 0) m.set_at((3,2), 0) m.set_at((4,2), 0) r = m.get_bounding_rects() self.assertEquals(repr(r), "[<rect(1, 0, 3, 3)>]") #00011 #11111 m = pygame.Mask((5,2)) m.set_at((0,0), 0) m.set_at((1,0), 0) m.set_at((2,0), 0) m.set_at((3,0), 1) m.set_at((4,0), 1) m.set_at((0,1), 1) m.set_at((1,1), 1) m.set_at((2,1), 1) m.set_at((3,1), 1) m.set_at((3,1), 1) r = m.get_bounding_rects()
def __init__(self, size): self.size = size self.mask = pygame.Mask(size) self.sightings = {}
def get_mask(self): m = pygame.Mask((32, 32)) m.fill() return m
def main(screen): pygame.display.set_caption('Ball-E') pygame.display.set_icon(pygame.image.load('./data/icon.png')) screen.fill((0, 0, 0)) screen.set_colorkey((0, 0, 0)) ballimg = pygame.image.load('./data/ball.png') ballimg.set_colorkey(ballimg.get_at((0, 0))) # pygame.mixer.music.load('./data/kick.ogg') screen_size = screen.get_size() center = (screen_size[0] / 2, screen_size[1] / 2) score = 0 highscore = 0 paused = False font1 = pygame.font.Font('./data/font.ttf', 40) font2 = pygame.font.Font('./data/font.ttf', 22) font3 = pygame.font.Font('./data/font.ttf', 52) font4 = pygame.font.Font('./data/font.ttf', 16) title = font3.render('Keep the ball in the air!', 1, (255, 255, 255)) info1 = font4.render('Esc - Quit', 1, (255, 255, 255)) info2 = font4.render('P - Pause', 1, (255, 255, 255)) info3 = font3.render('Paused', 1, (255, 255, 255)) score_text = font1.render(str(score), 1, (255, 155, 155)) highscore_text = font2.render(str(highscore), 1, (255, 255, 255)) score_rect = score_text.get_rect() highscore_rect = highscore_text.get_rect() highscore_rect.y = score_rect.bottom + 5 highscore_rect.x = 5 score_rect.x = 20 title_rect = title.get_rect() title_rect.y = score_rect.centery info1_rect = info1.get_rect() info1_rect.right = screen_size[0] - 5 info1_rect.y = 5 info2_rect = info2.get_rect() info2_rect.x = info1_rect.x info2_rect.y = info1_rect.bottom + 5 title_rect.centerx = (screen_size[0] - score_rect.width - info1_rect.width) / 2 info3_rect = info3.get_rect() info3_rect.centerx = center[0] info3_rect.centery = center[1] ball = Ball(ballimg, 1, *center) ball.center() pointer = pygame.Rect(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1], 1, 1) pointer_mask = pygame.Mask((1, 1)) pointer_mask.set_at((0, 0), 1) subrect = ballimg.get_rect() subrect.width = 84 subrect.height = 83 clock = pygame.time.Clock() ball.update() screen.blit(ball.image, ball.rect) screen.blit(score_text, score_rect) screen.blit(highscore_text, highscore_rect) screen.blit(title, title_rect) screen.blit(info1, info1_rect) screen.blit(info2, info2_rect) pygame.display.flip() while 1: clock.tick(60) for event in pygame.event.get(): if event.type == QUIT: return if event.type == KEYDOWN: if event.key == K_ESCAPE: return if event.key == K_p: paused = not paused pointer.x, pointer.y = pygame.mouse.get_pos() if ball.rect.colliderect(pointer) and not paused: if ball.mask.get_at( (int(pointer.x - ball.x), int(pointer.y - ball.y))): # pygame.mixer.music.play(0, 0.14) # there is a small silence right before the sound hit = ball.mask.overlap( pointer_mask, (int(pointer.x - ball.x), int(pointer.y - ball.y))) hit = (hit[0] - ball.rect.width / 2, hit[1] - ball.rect.height / 2) angle = math.degrees(math.atan2( hit[0], hit[1])) # angle at which we hit dx = 30 * math.cos(math.radians(angle + 90)) dy = 30 * math.sin(math.radians(angle - 90)) ball.dx = dx ball.dy = dy ball.on_ground = False ball.spin = -dx / 5 score += 1 score_text = font1.render(str(score), 1, (255, 155, 155)) if ball.x > screen_size[0] - ball.rect.width: ball.x = screen_size[0] - ball.rect.width ball.dx = -ball.dx * ball.friction ball.spin = ball.dy # pygame.mixer.music.play(0,0.14) if ball.y > screen_size[1] - ball.rect.height: score = 0 score_text = font1.render(str(score), 1, (255, 155, 155)) ball.y = screen_size[1] - ball.rect.height if not ball.on_ground: ball.dx *= ball.friction ball.spin = -ball.dx if (ball.dy * ball.bounce) - 5 > 0: ball.dy = -ball.dy * ball.bounce else: ball.dy = 0 ball.on_ground = True # pygame.mixer.music.play(0,0.14) if ball.x < 0: ball.x = 0 ball.dx = -ball.dx * ball.bounce ball.spin = -ball.dy # pygame.mixer.music.play(0,0.14) if score > highscore: highscore = score highscore_text = font2.render(str(highscore), 1, (255, 255, 255)) ball.update() rotated = pygame.transform.rotate(ball.image, ball.angle) size = rotated.get_size() subrect.centerx = size[0] / 2 subrect.centery = size[1] / 2 newimg = rotated.subsurface(subrect) screen.fill((0, 0, 0)) screen.blit(newimg, ball.rect) screen.blit(score_text, score_rect) screen.blit(highscore_text, highscore_rect) screen.blit(title, title_rect) screen.blit(info1, info1_rect) screen.blit(info2, info2_rect) if paused: screen.blit(info3, info3_rect) pygame.display.flip()
if __debug__ and delta > 1/60: self._current_time += 1/60 return 1/60 self._current_time = current_time return delta if __name__ == '__main__': pg.init() screen: pg.Surface = pg.display.set_mode((800, 600)) level = GG2Map("maps/cp_mountainjazz.png") #level_image = pg.surfarray.make_surface(255 - level.mask.swapaxes(0, 1)) level = MapCollider(level) level_image = level._mask.to_surface() player = CharacterClass(pg.Rect(1200, 600, 16, 36), pg.Mask((16, 36)), (0, 0), level) player.mask.fill() player._jump_speed = -318 player.max_x_speed = 300 player.max_y_speed = 800 clock = Clock() running = True camera_rect = pg.Rect((0, 0), screen.get_size()) while running: for event in pg.event.get(): if event.type == pg.KEYDOWN: call_action(player, event.key, True) elif event.type == pg.KEYUP: call_action(player, event.key, False)
def __init__(self): self.mask = pygame.Mask((Util.WINDOW_WIDTH, Util.WINDOW_HEIGHT)) self.bullets = {}
class Sprite(pygame.sprite.DirtySprite): FALL_SPEED = 6 def __init__(self, name, flip_image=False, obey_gravity=False): super(Sprite, self).__init__() # Signals self.moved = Signal() self.direction_changed = Signal() self.reverse_gravity_changed = Signal() # State self.rect = pygame.Rect(0, 0, 0, 0) self.quad_trees = set() self.layer = None self.name = name self.image = None self.visible = 1 self.dirty = 2 self.velocity = (0, 0) self.obey_gravity = obey_gravity self.reverse_gravity = False self.lethal = False self.falling = False self.collidable = True self.grabbed = False self.grabbable = False self.should_check_collisions = False self.use_pixel_collisions = False self.flip_image = flip_image self.collision_rects = [] self.collision_masks = [] self._colliding_objects = set() self._direction = Direction.RIGHT self._flipped_images = {} def __repr__(self): return 'Sprite %s (%s, %s, %s, %s)' % \ (self.name, self.rect.left, self.rect.top, self.rect.width, self.rect.height) def set_reverse_gravity(self, reverse_gravity): if self.reverse_gravity != reverse_gravity: self.reverse_gravity = reverse_gravity self.velocity = (self.velocity[0], -self.velocity[1]) self.update_image() self.reverse_gravity_changed.emit() def _set_direction(self, direction): if self.direction != direction: self._direction = direction self.direction_changed.emit() self.update_image() direction = property(lambda self: self._direction, _set_direction) def show(self): if not self.visible: self.visible = 1 self.dirty = 2 self.layer.update_sprite(self) def hide(self): if self.visible: self.visible = 0 self.dirty = 1 self.layer.update_sprite(self) def remove(self): self.hide() self.layer.remove(self) def fall(self): if self.falling or not self.obey_gravity: return self.falling = True if self.reverse_gravity: self.velocity = (self.velocity[0], -self.FALL_SPEED) else: self.velocity = (self.velocity[0], self.FALL_SPEED) def stop_falling(self): if self.obey_gravity: self.falling = False self.velocity = (self.velocity[0], 0) def update_image(self): self.image = self.generate_image() assert self.image self.rect.size = self.image.get_rect().size def generate_image(self): if not self.name: # Must be a custom sprite. return self.image image = load_image(self.name) if (self.flip_image and (self._direction == Direction.LEFT or self.reverse_gravity)): flip_h = (self.direction == Direction.LEFT) flip_v = self.reverse_gravity key = (self.name, flip_h, flip_v) if key not in self._flipped_images: self._flipped_images[key] = \ pygame.transform.flip(image, flip_h, flip_v) image = self._flipped_images[key] return image def move_to(self, x, y, check_collisions=False): self.move_by(x - self.rect.x, y - self.rect.y, check_collisions) def move_by(self, dx, dy, check_collisions=True): if check_collisions: if dx: self._move(dx=dx) if dy: self._move(dy=dy) else: self.rect.move_ip(dx, dy) self.on_moved(dx, dy) def _move(self, dx=0, dy=0): self.rect.move_ip(dx, dy) self.rect.left = max(self.rect.left, 0) self.rect.right = min(self.rect.right, self.layer.area.size[0]) self.check_collisions(dx, dy) def check_collisions(self, dx=0, dy=0): old_colliding_objects = set(self._colliding_objects) self._colliding_objects = set() for obj, self_rect, obj_rect in self.get_collisions(): if (self_rect == self.rect and self.should_adjust_position_with(obj, dx, dy)): self.position_beside(obj_rect, dx, dy) obj.handle_collision(self, obj_rect, dx, dy) self.on_collision(dx, dy, obj, self_rect, obj_rect) self._colliding_objects.add(obj) for obj in old_colliding_objects.difference(self._colliding_objects): obj.handle_stop_colliding(self) def should_adjust_position_with(self, obj, dx, dy): return True def position_beside(self, rect, dx, dy): if dy < 0: self.rect.top = rect.bottom elif dy > 0: self.rect.bottom = rect.top elif dx < 0: self.rect.left = rect.right elif dx > 0: self.rect.right = rect.left def get_collisions(self, tree=None, ignore_collidable_flag=False): if not self.should_check_collisions and not ignore_collidable_flag: raise StopIteration if tree is None: tree = self.layer.quad_tree num_checks = 0 if self.collision_rects: self_rect = self.collision_rects[0].unionall( self.collision_rects[1:]) else: self_rect = self.rect # We want more detailed collision info, so we use our own logic # instead of calling spritecollide. for obj in tree.get_sprites(self_rect): num_checks += 1 self_rect, obj_rect = \ self._check_collision(self, obj, ignore_collidable_flag) if self_rect and obj_rect: yield obj, self_rect, obj_rect #print 'Performing %s checks' % num_checks def _check_collision(self, left, right, ignore_collidable_flag): if (left == right or left.layer.index != right.layer.index or (not ignore_collidable_flag and ((not left.collidable or not right.collidable) or (not left.should_check_collisions and not right.should_check_collisions)))): return None, None left_rects = left.collision_rects or [left.rect] right_rects = right.collision_rects or [right.rect] for left_index, left_rect in enumerate(left_rects): right_index = left_rect.collidelist(right_rects) if right_index == -1: continue right_rect = right_rects[right_index] if left.use_pixel_collisions or right.use_pixel_collisions: left_mask = left._build_mask(left_rect, left_index) right_mask = right._build_mask(right_rect, right_index) offset = (left_rect.left - right_rect.left, left_rect.top - right_rect.top) pos = right_mask.overlap(left_mask, offset) if not pos: continue mask = right_mask.overlap_mask(left_mask, offset) collision_rect = mask.get_bounding_rects()[0] right_rect = pygame.Rect(right_rect.left + collision_rect.left, right_rect.top + collision_rect.top, *collision_rect.size) return left_rect, right_rect return None, None def _build_mask(self, rect, collision_index): mask = None image = None if self.use_pixel_collisions: if collision_index < len(self.collision_masks): mask = self.collision_masks[collision_index] if not mask: mask = getattr(self, 'mask', None) if not mask: if rect == self.rect: image = self.image else: try: image = self.image.subsurface(rect) except ValueError, e: image = None if image: mask = pygame.sprite.from_surface(image) if not mask: mask = pygame.Mask(rect.size) mask.fill() if self.collision_rects: if not self.collision_masks: self.collision_masks = [None] * len(self.collision_rects) self.collision_masks[collision_index] = mask else: self.mask = mask return mask
def __init__(self, rect: pg.Rect, level): super().__init__(level.all_sprites, level.collided_sprites) self.image = pg.Surface(rect.size, pg.SRCALPHA) self.image.fill((0, 0, 0, 0)) # Делаем невидимым self.rect = rect self.mask = pg.Mask(rect.size, True)
import pygame from pygame.locals import * from utils.mask import Mask mouse_mask = pygame.Mask((2, 2)) mouse_mask.fill() class Event: def __init__(self, data): if "name" not in data: raise KeyError("Event must have a 'name'.") for key, value in data.items(): self.__setattr__(key, value) self.handled = False def set_attr(self, name, value): self.__setattr__(name, value) def post_event(data_dict): event = pygame.event.Event(USEREVENT, data_dict) pygame.event.post(event) def get_mouse_point_mask(mouse_pos): mouse_rect = Rect(mouse_pos[0], mouse_pos[1], 2, 2) return Mask(mouse_rect, mouse_mask)