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)
