def __init__(self, source):
super(Background, self).__init__()
self.image = Sprite(source=source)
self.add_widget(self.image)
self.size = self.image.size
self.image_dupe = Sprite(source=source, y=self.height)
self.add_widget(self.image_dupe)
def run(self):
players = list()
newp = Sprite(self.laby.screen, self.laby.unit // 2, self.laby.walls)
turtle.RawTurtle.forward(newp, newp.step)
newp.left(90)
turtle.RawTurtle.forward(newp, newp.step)
players.append(newp)
while all(player.pos() in self.laby.border for player in players):
if len(select([
self.socket,
], list(), list())[0]):
order = self.socket.recv(2)
index, order = order[0], order[1:]
while index >= len(players):
newp = Sprite(self.laby.screen, self.laby.unit // 2,
self.laby.walls)
turtle.RawTurtle.forward(newp, newp.step)
newp.left(90)
turtle.RawTurtle.forward(newp, newp.step)
players.append(newp)
if order == b"r":
players[index].setheading(0)
elif order == b"u":
players[index].setheading(90)
elif order == b"l":
players[index].setheading(180)
elif order == b"d":
players[index].setheading(270)
players[index].forward()
players[index].forward()
self.socket.send(b"W")
self.socket.close()
def __init__(self, cfg, position, direction, color, res, pacmans, ghosts, random, game):
self.cfg = cfg
self.position = position
self.direction = direction
self.next_direction = self.direction
self.color = color
self.res = res
self.pacmans = pacmans
self.ghosts = ghosts
self.state = GHOST_STATE_STOPPED
self.frightened = False
self.random = random
self.game = game
self.isdead = False # if the ghost is dead he is show as eyes,
# he is not colliding with anything and he
# returns straight to home
self.target = pacmans[0].position
self.sprite = [ Sprite("ghost-left-"+color, self.res, 0.1),
Sprite("ghost-down-"+color, self.res, 0.1),
Sprite("ghost-right-"+color, self.res, 0.1),
Sprite("ghost-up-"+color, self.res, 0.1),
Sprite("ghost-frightened", self.res, 0.5),
Sprite("ghost-frightened-blink", self.res, 0.5),
Sprite("eyes-left", self.res),
Sprite("eyes-down", self.res),
Sprite("eyes-right", self.res),
Sprite("eyes-up", self.res), ]
self.prev_cell = position_to_cell(self.cfg.grid_cell_size, self.position)
self.curr_cell = self.prev_cell
def __init__(self, world, pos=(0, 0)):
self.body = world.b2world.CreateDynamicBody(
position=pos,
allowSleep=False
)
self.body.CreatePolygonFixture(
box=(0.8, 1.6),
density=1,
friction=0.0,
)
self.body.linearDamping = 0.0
self.body.angularDamping = 0.0
self.sensor = self.body.CreatePolygonFixture(
box=(0.6, 0.2, (0, -1.6), 0),
density=1,
friction=0.0,
isSensor = True
)
self.stand_sprite = Sprite("data/art/stand.png")
self.jump_sprite = Sprite("data/art/jump.png")
self.fall_sprite = Sprite("data/art/fall.png")
walksprite0 = self.stand_sprite
walksprite1 = Sprite("data/art/walk1.png")
walksprite2 = Sprite("data/art/walk2.png")
self.walk_sprite = Animation((
walksprite0, walksprite1, walksprite1,
walksprite0, walksprite2, walksprite2
))
self.sprite = self.stand_sprite
def create_map(self, map):
#карта
#newmap = Map()
#newmap.generate()
#newmap.write()
self.delete_map()
text = open(map)
blocks = [
"", "tiles/block.png", "tiles/grass.png", "tiles/stone.png",
"tiles/decor1.png", "tiles/tree.png", "tiles/decor2.png",
"tiles/decor3.png", "tiles/spikes.png", "tiles/wall.png",
"tiles/backwall.png", "tiles/door.png", "tiles/backblock.png",
"tiles/roof.png"
]
i = 10
for line in text:
j = 0
for block in line:
if block == " ":
continue
elif block in ("1", "2", "3", "9"):
object = CollideObject(BLOCK_SIZE * j,
SCREEN_H - BLOCK_SIZE * i,
blocks[int(block)])
self.collide_ent.append(object)
elif block in ("4", "5", "6", "7"):
decor = Sprite(BLOCK_SIZE * j, SCREEN_H - BLOCK_SIZE * i,
blocks[int(block)])
#self.decor_ent_fore.append(decor)
self.decor_ent_back.append(decor)
elif block in ("8"):
spikes = Spikes(BLOCK_SIZE * j, SCREEN_H - BLOCK_SIZE * i,
blocks[int(block)], self)
self.spikes.append(spikes)
elif block in ("B"):
decor = Sprite(BLOCK_SIZE * j, SCREEN_H - BLOCK_SIZE * i,
blocks[10])
self.decor_ent_back.append(decor)
elif block in ("D"):
decor = Sprite(BLOCK_SIZE * j, SCREEN_H - BLOCK_SIZE * i,
blocks[11])
self.decor_ent_back.append(decor)
elif block in ("C"):
decor = Sprite(BLOCK_SIZE * j, SCREEN_H - BLOCK_SIZE * i,
blocks[12])
self.decor_ent_back.append(decor)
elif block in ("R"):
decor = Sprite(BLOCK_SIZE * j, SCREEN_H - BLOCK_SIZE * i,
blocks[13])
self.decor_ent_back.append(decor)
j += 1
i -= 1 #тк генерируем снизу (зеркально)
text.close()
def init():
for timer in Title_screen.all_timers:
Title_screen.all_timers.replenish_timer(timer)
title_logo_img = [universal_var.misc_images['title']]
width, height = 500, 300
title_logo_sprite = Sprite(universal_var.main_sprite, 0, 0, width,
height, [('title', title_logo_img, 1)])
Title_screen.title_logo = Megaman_object('title_logo',
50,
2000,
sprites=[title_logo_sprite],
width=width,
height=height,
is_active=True)
megaman_face_img = [universal_var.misc_images['megaman_face']]
width, height = 200, 300
megaman_face_sprite = Sprite(universal_var.main_sprite, 0, 0, width,
height, [('world', megaman_face_img, 1)])
Title_screen.megaman_face = Megaman_object(
'megaman_face',
-width * 13,
230,
sprites=[megaman_face_sprite],
width=width,
height=height,
is_active=True)
Title_screen.is_running = True
def collide_ship_sprites(self,
group,
explosion_group,
explosion_image,
explosion_info,
ship=None,
ship_group=None):
group_copy = set([])
aux_copy = group.copy()
for sprite in aux_copy:
if self.physics.collide(sprite) is True:
group_copy.add(sprite)
explosion = Sprite(sprite.get_physics_component().get_pos(),
[0, 0], 0, 0, explosion_image,
explosion_info, self.physics.WIDTH,
self.physics.HEIGHT)
explosion_group.add(explosion)
explosion_group.add(
Sprite(self.physics.get_pos(), [0, 0], 0, 0,
explosion_image, explosion_info, self.physics.WIDTH,
self.physics.HEIGHT))
if self.life <= 0:
self.lives -= 1
if ship is not None:
ship.score += 1
if ship_group is not None:
ship_group.add(self)
group.difference_update(group_copy)
def __init__(self, x, y):
# Listes des sprites pour l'animation
self.sprites = {
'run': Sprite('Assets/Player/run.png', 8, 1),
'blow': Sprite('Assets/Player/joueur_souffle.png', 20, 1),
'idle': Sprite('Assets/Player/idle.png', 4, 1),
'chute': Sprite('Assets/Player/player_chute.png', 4, 1)
}
# Initialisation position
self.setLocation(x, y)
# Vitesse du joueur
self.velocity = 20
self.jumpRange = [-10, -6, -5, -4, 1, 4, 5, 6, 10]
# Flip
self.flip = False
# Current plateforme
self.currentPlatorm = None
self.hitbox = None
self.stream = Stream(self.x, self.y, 0)
self.glissement = False
self.valeurTampon = 0
def load(self, filename):
file = open(Scene.path + filename)
data = file.read().splitlines()
ground_height = 0
self.cursor = Sprite(0, 0, 'cursor.png', False)
self.sprites = []
self.warps = []
self.ui_top = UiGroup()
panel = UiPanel(0, 0, 800, 110)
button = UiButton(10, 10, 90, 90, "banana")
self.ui_top.add_element(panel)
self.ui_top.add_element(button)
for line in data:
cell = line.split(";")
# Ground
if (cell[0] == "ground"):
self.ground = Sprite(0, 0, cell[1] + ".png", False)
_, screen_h = pygame.display.get_surface().get_size()
ground_height = screen_h - self.ground.surface.get_height()
self.ground.y = ground_height
# Background
elif (cell[0] == "background"):
self.background = Sprite(0, 0, cell[1] + ".png", False)
# Player
elif (cell[0] == "player"):
height = 0
if cell[3] == "ground":
height = -1
self.player = SpriteControlled(int(cell[2]), height,
cell[1] + ".png", True,
int(cell[4]))
# Sprites
elif (cell[0] == "sprite"):
height = 0
if cell[3] == "ground":
height = -1
sprite = Sprite(int(cell[2]), height, cell[1] + ".png", True)
self.sprites.append(sprite)
# Warps
elif (cell[0] == "warp"):
height = 0
if cell[3] == "ground":
height = -1
warp = Warp(int(cell[2]), height, cell[1] + ".png", False,
eval(cell[4]))
self.warps.append(warp)
# Set heights
if (self.player.y == -1):
self.player.y = ground_height
for s in self.sprites:
if (s.y == -1):
s.y = ground_height
for w in self.warps:
if (w.y == -1):
w.y = ground_height - w.surface.get_height() / 2
def _load_sprites(self, name):
sprites = {
SpriteComponent.A: Sprite('_'.join((name, 'a'))),
SpriteComponent.B: Sprite('_'.join((name, 'b')))
}
return sprites
def __init__(self, background_picture, last_background_image=None):
super(Background, self).__init__()
self.image = Sprite(picture=background_picture, allow_stretch=True)
self.image_dupe = Sprite(picture=background_picture,
allow_stretch=True)
self.image_dupe.y = Window.height
self.last_background = False
self.last_image_str = last_background_image
def __init__(self, background_file, ground_file):
self.background = Sprite(0, 0, background_file, False)
self.ground = Sprite(0, 0, ground_file, False)
screen_w, screen_h = pygame.display.get_surface().get_size()
ground_height = screen_h - self.ground.surface.get_height()
self.ground.y = ground_height
self.player = SpriteControlled(10, ground_height, 'sprite.png', True, 2)
self.cursor = Sprite(0, 0, 'cursor.png', False)
self.warp = Warp(500, 0, 'warp.png', False, "level01")
self.warp.y = ground_height - self.warp.surface.get_height() / 2
def loadSprites(self):
if not self.spritesLoaded:
for T in self.names:
t = T.lower()
self.sprite["Sphere"].append(Sprite("sphere2_" + t))
self.sprite["Icon"].append(Sprite("sphere1_" + t))
self.sprite["Egg"].append(Sprite("sphere3_" + t))
self.sprite["Bar"].append(Sprite("type_" + t))
self.spritesLoaded = True
def add_type(self,
name,
drawn_type=None,
res_asset_path=None,
full_asset_path=None,
meta_path=None):
# make asset path safe
if res_asset_path is not None:
res_asset_path = res_asset_path.replace('\\', '/')
add_type = DrawnType(name,
start_ext_id=self.curr_ext_resource_id,
start_sub_id=self.curr_sub_resource_id)
# break out for specific node types
if drawn_type is not None and drawn_type in self.TYPES:
if drawn_type == 'sprite':
add_type = Sprite(name,
res_asset_path,
meta_path=meta_path,
start_ext_id=self.curr_ext_resource_id,
start_sub_id=self.curr_sub_resource_id)
elif drawn_type == 'static':
add_type = Static(name,
res_asset_path,
full_asset_path,
self.curr_ext_resource_id,
self.curr_sub_resource_id,
meta_path=meta_path)
elif drawn_type == 'platforms':
add_type = Static(name,
res_asset_path,
full_asset_path,
self.curr_ext_resource_id,
self.curr_sub_resource_id,
meta_path=meta_path,
one_way=True)
elif drawn_type == 'physics' or drawn_type == 'items':
add_type = Physics(name, res_asset_path, meta_path,
self.curr_ext_resource_id,
self.curr_sub_resource_id)
elif res_asset_path is not None:
# use sprites, if asset path exists
add_type = Sprite(name,
res_asset_path,
meta_path=meta_path,
start_ext_id=self.curr_ext_resource_id,
start_sub_id=self.curr_sub_resource_id)
# add node, external, sub content
self.nodes += add_type.get_node_string() + '\n'
self.ext_resources += add_type.get_ext_resources_string()
self.sub_resources += add_type.get_sub_resources_string()
# update id's
self.curr_ext_resource_id = add_type.get_last_ext_id()
self.curr_sub_resource_id = add_type.get_last_sub_id()
def __init__(self, name, background_file, ground_file):
self.name = name
self.background = Sprite(0, 0, background_file, False)
self.ground = Sprite(0, 0, ground_file, False)
screen_w, screen_h = pygame.display.get_surface().get_size()
ground_height = screen_h - self.ground.surface.get_height()
self.ground.y = ground_height
self.player = SpriteControlled(10, ground_height, 'sprite.png', True,
2)
self.cursor = Sprite(0, 0, 'cursor.png', False)
def __init__(self, x, y):
super(Sirene, self).__init__(x, y, 0)
self.sprites = {
'idle': Sprite('Assets/Siren/sirene.png', 10, 1),
'aura': Sprite('Assets/Siren/halo_sirene.png', 8, 1, colorkey=False, scale=1)
}
self.attirance = 250
def __init__(self, x, y, w, h, filename):
UiElement.__init__(self, x, y, w, h)
UiElement.set_event(self, "hover_in", self.on_hover_in)
UiElement.set_event(self, "hover_out", self.on_hover_out)
UiElement.set_event(self, "click", self.on_click)
UiElement.set_event(self, "release", self.on_release)
self.is_hover = False
self.is_clicked = False
self.sprite_idle = Sprite(x, y, filename + "_idle.png", False)
self.sprite_hover = Sprite(x, y, filename + "_hover.png", False)
self.sprite_click = Sprite(x, y, filename + "_click.png", False)
self.current_sprite = self.sprite_idle
def __init__(self, background_file, ground_file):
self.background = Sprite(0, 0, background_file, False)
self.ground = Sprite(0, 0, ground_file, False)
screen_w, screen_h = pygame.display.get_surface().get_size()
ground_height = screen_h - self.ground.surface.get_height()
self.ground.y = ground_height
self.player = SpriteControlled(150, ground_height, 'Sprite.png', True, 2)
self.copain = SpriteControlled(500, ground_height, 'copain.png', True, 0)
self.cursor = Sprite(0, 0, 'cursor.jpg', False)
#self.collision_text = font.render("Oops sorry Mamen", False,(0, 0,0))
self.warp = Warp(700, 0, 'warp.png', False, "level01")
self.warp.y = ground_height - self.warp.surface.get_height() / 2
def main():
# Load
pygame.init()
screen = pygame.display.set_mode((800, 600))
font = pygame.font.Font(None, 24)
quit = False
path = 'H:\\Artfx\\Python\\Abygaelle\\AdventureGame\\'
background = pygame.image.load(path + 'background.png').convert()
hero = Sprite(400, 200, "hero.png")
cursor = Sprite(0, 0, "cursor.png")
pygame.mouse.set_visible(False)
spr_surface = pygame.image.load(path + 'hero.png').convert()
spr_pos = spr_x, spr_y = 100, 400
ground = pygame.image.load(path + 'ground.png').convert()
spr_x, spr_y = 100, 400
spr_is_moving = False
spr_speed = 2
goal_x = 0
#get_rect = 100, 0
while not (quit):
# Inputs
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
quit = True
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_click = pygame.mouse.get_pos()
goal_x = mouse_click[0]
hero.set_position(mouse_click)
spr_is_moving = True
# Update
cursor_pos = pygame.mouse.get_pos()
cursor.set_position(cursor_pos)
if (spr_is_moving):
spr_x = mouse_click[0]
mouse_click = pygame.mouse.get_pos()
goal_x = mouse_click[0]
spr_is_moving = False
#position_Sprite = Sprite.get_rect()
#fenetre.blit(perso, position_perso)
# Draw
screen.fill((0, 0, 0))
screen.blit(background, (0, 0))
screen.blit(ground, (0, 500))
hero.draw(screen)
cursor.draw(screen)
pygame.display.update()
def main():
#Load
pygame.init()
screen = pygame.display.set_mode((800,600))
font = pygame.font.Font(None,24)
background = pygame.image.load('background.png').convert()
ground = pygame.image.load('ground.png').convert()
ground_height = 600 - ground.get_height()
player = SpriteControlled(100, ground_height, 'sprite.png', True, 2)
copain = Sprite(500, ground_height, 'copain.png', True)
mouse_click = (0, 0)
collision_text = font.render("Oops, sorry!", False, (0,0,0))
cursor = Sprite(0,0, 'cursor.png', False)
pygame.mouse.set_visible(False)
quit_game = False
while not quit_game:
#Inputs/
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
quit_game = True
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_click = pygame.mouse.get_pos()
player.move_to(mouse_click[0])
#Update
cursor.set_position(pygame.mouse.get_pos())
player.update()
#Draw
screen.fill((0,0,0))
screen.blit(background,(0,0))
screen.blit(ground,(0, 500))
copain.draw(screen)
player.draw(screen)
if(player.intersects(copain)):
screen.blit(collision_text, (player.x, player.y - 100))
cursor.draw(screen)
pygame.display.update()
def generateWidgets (self, pos_x, pos_y, font_item, font_item_selected):
anchors = {'left': 0, 'center': 0.5, 'right': 1, 'top': 1, 'bottom': 0}
anchor=(anchors[font_item['anchor_x']] * self.image.width,
anchors[font_item['anchor_y']] * self.image.height)
self.item = Sprite(self.image, anchor=anchor, opacity=255,
color=font_item['color'][:3])
self.item.scale = font_item['font_size'] / float(self.item.height )
self.item.position = int(pos_x), int(pos_y)
self.selected_item = Sprite(self.image, anchor=anchor,
color=font_item_selected['color'][:3])
self.selected_item.scale = (font_item_selected['font_size'] /
float(self.selected_item.height))
self.selected_item.position = int(pos_x), int(pos_y)
def __init__(self, x, y, w, h, filename):
UiElement.__init__(self, x, y, w, h)
#self.color = (0, 0, 255)
UiElement.set_event(self, "hover_in", self.on_hover_in)
UiElement.set_event(self, "hover_out", self.on_hover_out)
UiElement.set_event(self, "click", self.on_click)
UiElement.set_event(self, "release", self.on_release)
self.is_hover = False
self.is_clicked = False
self.sprite_idle = Sprite(x, y, 'Button_idle.png', False)
self.sprite_hover = Sprite(x, y, 'Button_hover.png', False)
self.sprite_click = Sprite(x, y, 'Button_click.png', False)
self.current_sprite = self.sprite_idle #defines the current button that will be drawn
def main():
# Load
pygame.init()
screen = pygame.display.set_mode((800, 600))
font = pygame.font.Font(None, 24)
path = 'D:\\Code\\ArtFx\\Python\\python-training\\01.adventure\\07.copain\\'
background = pygame.image.load(path+'background.png').convert()
ground = pygame.image.load(path+'ground.png').convert()
mouse_click = (0, 0)
player = SpriteControlled(100, 400, 'sprite.png', 2)
copain = Sprite(500, 400, 'copain.png')
cursor = Sprite(0, 0, 'cursor.png')
pygame.mouse.set_visible(False)
collision_text = font.render("Oops, sorry.", False, (0, 0, 0))
quit_game = False
while not quit_game:
# Inputs
for event in pygame.event.get():
if event.type == pygame.QUIT:
quit_game = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
quit_game = True
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_click = pygame.mouse.get_pos()
player.move_to(mouse_click[0])
# Update
cursor.set_position(pygame.mouse.get_pos())
player.update()
# Draw
screen.fill((0, 0, 0))
screen.blit(background, (0, 0))
screen.blit(ground, (0, 500))
copain.draw(screen)
player.draw(screen)
if(player.intersects(copain)):
screen.blit(collision_text, (player.x, player.y - 100))
cursor.draw(screen)
pygame.display.update()
def draw_end_screen(self, result: str = 'win', text: str = ''):
score_group = pygame.sprite.Group()
if result not in ['win', 'lose', 'draw']:
raise ValueError(f"result:{result} not in ['win', 'lose', 'draw']")
girl_face = result
girl_img = Setting.sprite_base + Setting.girl_img[girl_face]
image = pygame.image.load(girl_img)
rect = image.get_rect()
rect.right = Setting.win_w // 2 - rect.w
rect.centery = Setting.win_h // 2
girl = pygame.sprite.Sprite()
girl.image = image
girl.rect = rect
score_group.add(girl)
# hand result
file = Setting.sprite_base + text + ".png"
image = pygame.image.load(file)
end_btn = Sprite(image)
end_btn.rect.centerx = Setting.win_w // 2
end_btn.rect.bottom = Setting.win_h // 2 - 100
score_group.add(end_btn)
# winner avatar
if self.winner:
file = Setting.avatar_base + self.winner.nick + ".png"
image = pygame.image.load(file)
avatar = Sprite(image)
avatar.rect.centerx = Setting.win_w // 2
avatar.rect.top = Setting.win_h // 2 + 80
score_group.add(avatar)
# end btn
btn_img = Setting.sprite_base + Setting.btn_img['end']
image = pygame.image.load(btn_img)
rect = image.get_rect()
rect.centerx = Setting.win_w // 2
rect.centery = Setting.win_h // 2
btn = pygame.sprite.Sprite()
btn.image = image
btn.rect = rect
score_group.add(btn)
score_group.draw(self.screen)
# self.draw_background()
pygame.display.update() # 显示
self.waiting_return()
def getPipe(self):
'''获得新水管'''
index = random.randint(0, len(config.ImgRes.pipe) - 1)
key = list(config.ImgRes.pipe)[index]
image = config.ImgRes.pipe[key]
pipeDown = Sprite(
QPixmap.fromImage(image.toImage().mirrored(False, True)))
pipeUp = Sprite(image)
pipeUp.x = self.width()
pipeDown.x = self.width()
pipeUp.y = random.randint(config.pipeLimit + config.pipeInterval,
self.base.y - config.pipeLimit)
pipeDown.y = pipeUp.y - config.pipeInterval - pipeDown.height
self.pipes.clear()
self.pipes.extend((pipeUp, pipeDown))
def __init__(self):
super().__init__()
self.name = "pass"
self.cardsprite = Sprite("card_base.png")
self.artsprite = Sprite("card_art_base.png")
self.basecost = 0
self.range = 0
# head, r-arm, r-torso, r-leg, l-arm, l-torso, l-leg
self.target = [False, False, False, False, False, False, False]
self.defend = [False, False, False, False, False, False, False]
self.power = [0, 0, 0, 0, 0, 0, 0]
self.defense_power = [0, 0, 0, 0, 0, 0, 0]
self.take_initiative = False
self.description = "pass a turn"
self.modifiers = []
def find_sprites(image, background=None):
image_map = np.asarray(image)
rows, cols = image_map.shape[:2]
label_map = np.zeros((rows, cols), dtype=np.int64)
connect = {}
if not background:
if 'A' in image.mode:
background = (0, 0, 0, 0)
else:
background = find_most_common_color(image)
image_segmentation(rows, cols, image_map, label_map, connect, background)
list_key_connect = list(connect.keys())
filter_segmentation(connect, list_key_connect)
connect = combine_segmentation(connect, list_key_connect)
sprites = {}
for label, x in enumerate(connect, 1):
for a in connect[x]:
label_map[label_map == a] = label
label_map[label_map == x] = label
temp_array = np.argwhere(label_map == label)
x_max, y_max = np.amax(temp_array, axis=0)
x_min, y_min = np.amin(temp_array, axis=0)
sprites[label] = Sprite(label, x_min.item(), y_min.item(), x_max.item(), y_max.item())
return sprites, label_map
def main():
pygame.mixer.init()
pygame.init()
window = GameWindow("Tower Defense", 800, 600)
loader = ResourceLoader()
stage = Stage(loader.fetch("test.test"), 2, 2, window)
sprite = Sprite([loader.fetch("test.test")])
sprite.setPosition((0, 0))
sprite2 = Sprite([loader.fetch("test.test")])
sprite2.setPosition((-1, -1))
sprite.lookToward(sprite2)
stage.addSprite(sprite)
stage.addSprite(sprite2)
loader.fetch("test.pop").play()
window.addTickEvent(lambda t: stage.tick(t))
window.run()
def __init__(self):
movement_sprite_sheet = Sprite("Resources/Sprites/player.png")
self.right_walk_images = [
movement_sprite_sheet.get_image(0, 0, 45, 66),
movement_sprite_sheet.get_image(45, 0, 45, 66),
movement_sprite_sheet.get_image(93, 0, 45, 66),
movement_sprite_sheet.get_image(138, 0, 50, 66)
]
self.left_walk_images = [
pygame.transform.flip(image, True, False)
for image in self.right_walk_images
]
self.image = self.right_walk_images[0]
self.image_index = 0
self.image_rate = 0.1
self.rect = self.image.get_rect()
self.moving_left = False
self.moving_right = False
self.move_speed = 5
self.d_y = 0
self.gravity = 0.45
self.jump_height = 8
self.right_limit = public.display_dimensions[0] * 0.6
self.left_limit = public.display_dimensions[0] * 0.4 - self.rect.width
self.bound_exceed = 0
self.blocks = None
def setUp(self):
self.x = 48
self.y = 48
self.grid_num = 4
self.init_dna_mat = numpy.zeros((self.x, self.y))
for n in range(48):
for m in range(48):
if (n - self.x / 2)**2 + (m - self.y / 2)**2 < (
self.x /
2.5)**2: #only generate pixels within this circle
if determine_life(n, m, self.x, self.y):
self.init_dna_mat[n, m] = True
self.grid = Grid(self.grid_num)
self.grid2 = Grid(self.grid_num)
self.grid3 = Grid(self.grid_num)
self.sprites = [
Sprite(self.init_dna_mat) for i in range(self.grid_num**2)
]
self.mutated_sprites = [sprite.mutation() for sprite in self.sprites]
self.grid2.add_sprite(self.sprites[0])
for sprite in self.mutated_sprites:
self.grid3.add_sprite(sprite)
self.mutation_grid = self.grid3.construct_grid()
self.img_grid = mutation_grid[0]
self.dna_grid = mutation_grid[1]
