def breed_pop(self):
"""Breed the current population, a better score rank means probably more children."""
pop_size = len(self.goombas)
num_clones = ceil(pop_size * World.CLONE_BEST_FRACTION)
num_bred = ceil(pop_size * World.BREED_FRACTION)
num_rand = ceil(pop_size * World.NEW_RANDOM_FRACTION)
# Order the population by final score
ordered_pop = sorted([gmba for gmba in self.goombas],
key=lambda g: g.score(),
reverse=True)
# The top few will be cloned into the next generation unchanged
top_dogs = ordered_pop[:num_clones]
new_goombas = [Goomba.from_sequences(dog.genome.sequences()) for dog in top_dogs]
# The bottom fraction is thrown out entirely
breeders = ordered_pop[:num_bred]
# The remaining goombas breed, with a higher likelihood as they rank higher
breed_weighted = dict(zip(breeders, linspace(World.REPRO_SUCCESS_RAMP, 1, len(breeders))))
breeding_pairs = weighted_choice(breed_weighted, 2 * (pop_size - (num_clones + num_rand)))
for i in range(0, len(breeding_pairs), 2):
new_goombas.append(breed(breeding_pairs[i], breeding_pairs[i + 1]))
for i in range(num_rand):
new_goombas.append(Goomba(Genome.random_coding(self.seed_meta,
randrange(*self.gen_len_range))))
starts = self.start_locations(len(new_goombas))
for gmba, pos in zip(new_goombas, starts):
gmba.pos = pos
self.goombas = new_goombas
def add_items():
""" Initialize all items to be added to the model"""
# create all instances of goombas
model.items.append(Goomba(model, 700, 300, -0.1, 0))
model.items.append(Goomba(model, 800, 300, -0.1, 0))
model.items.append(Goomba(model, 1000, 300, -0.1, 0))
model.items.append(Goomba(model, 1300, 300, -0.1, 0))
model.items.append(Goomba(model, 1500, 300, -0.1, 0))
model.items.append(Goomba(model, 1700, 300, -0.1, 0))
model.items.append(Goomba(model, 2800, 300, -0.1, 0))
model.items.append(Goomba(model, 3000, 300, -0.1, 0))
# create all instances of pipes
model.items.append(Pipe(model, 800, 425, height=125))
model.items.append(Pipe(model, 2000, 425, height=125))
# create all instances of bricks in the air
model.items.append(Air_Bricks(model, 550, 450))
model.items.append(Air_Bricks(model, 1000, 450))
model.items.append(Air_Bricks(model, 1400, 450))
model.items.append(Air_Bricks(model, 2600, 450))
# create the flag and castle
model.items.append(Flag(model, length - 275, 250))
model.items.append(Castle(model, length - 200, 350))
# add clouds to display
for n in range(1, length, 400):
model.items.append(Cloud(x=n, y=random.randint(50, 250)))
def __init__(self, dimensions, goomba_genomes, seed_meta, gen_len_range, gen_time=200):
self.dimensions = dimensions
width = dimensions[0]
height = dimensions[1]
self.seed_meta = seed_meta
self.gen_len_range = gen_len_range
self.gen_time = gen_time
self.steps = 0
self.generation = 0
distrib = [TileState.Boundary] * 2 + [TileState.Dirty] + [TileState.Clean] * 7
self.state = [[choice(distrib) for _ in range(width)] for _ in range(height)]
for i in range(width):
self.state[i][0] = TileState.Boundary
self.state[i][height - 1] = TileState.Boundary
for j in range(height):
self.state[0][j] = TileState.Boundary
self.state[width - 1][j] = TileState.Boundary
self.init_dirt_distrib = []
for y in range(height):
for x in range(width):
if self.state[x][y] == TileState.Dirty:
self.init_dirt_distrib.append((x, y))
starts = self.start_locations(len(goomba_genomes))
self.goombas = [Goomba.from_sequences(s, p) for s, p in zip(goomba_genomes, starts)]
self.top_five = self.goombas[:5]
self.running = True
def breed_pop(self):
"""Breed the current population, a better score rank means probably more children."""
pop_size = len(self.goombas)
num_clones = ceil(pop_size * World.CLONE_BEST_FRACTION)
num_bred = ceil(pop_size * World.BREED_FRACTION)
num_rand = ceil(pop_size * World.NEW_RANDOM_FRACTION)
# Order the population by final score
ordered_pop = sorted([gmba for gmba in self.goombas], key=lambda g: g.score(), reverse=True)
# The top few will be cloned into the next generation unchanged
top_dogs = ordered_pop[:num_clones]
new_goombas = [Goomba.from_sequences(dog.genome.sequences()) for dog in top_dogs]
# The bottom fraction is thrown out entirely
breeders = ordered_pop[:num_bred]
# The remaining goombas breed, with a higher likelihood as they rank higher
breed_weighted = dict(zip(breeders, linspace(World.REPRO_SUCCESS_RAMP, 1, len(breeders))))
breeding_pairs = weighted_choice(breed_weighted, 2 * (pop_size - (num_clones + num_rand)))
for i in range(0, len(breeding_pairs), 2):
new_goombas.append(breed(breeding_pairs[i], breeding_pairs[i + 1]))
for i in range(num_rand):
new_goombas.append(Goomba(Genome.random_coding(self.seed_meta, randrange(*self.gen_len_range))))
starts = self.start_locations(len(new_goombas))
for gmba, pos in zip(new_goombas, starts):
gmba.pos = pos
self.goombas = new_goombas
def __init__(self, dimensions, goomba_genomes, seed_meta, gen_len_range, gen_time=200):
self.dimensions = dimensions
width = dimensions[0]
height = dimensions[1]
self.seed_meta = seed_meta
self.gen_len_range = gen_len_range
self.gen_time = gen_time
self.steps = 0
self.generation = 0
distrib = [TileState.Boundary]*2 + [TileState.Dirty] + [TileState.Clean]*7
self.state = [[choice(distrib) for _ in range(width)] for _ in range(height)]
for i in range(width):
self.state[i][0] = TileState.Boundary
self.state[i][height-1] = TileState.Boundary
for j in range(height):
self.state[0][j] = TileState.Boundary
self.state[width-1][j] = TileState.Boundary
self.init_dirt_distrib = []
for y in range(height):
for x in range(width):
if self.state[x][y] == TileState.Dirty:
self.init_dirt_distrib.append((x, y))
starts = self.start_locations(len(goomba_genomes))
self.goombas = [Goomba.from_sequences(s, p) for s, p in zip(goomba_genomes, starts)]
self.top_five = self.goombas[:5]
self.running = True
def create_enemy(self, x, y, num):
if num == 0:
self.goomba = Goomba(self.screen, self.settings, self.pipes,
self.bricks, self.ground) # +
self.goomba.x = x
self.goomba.y = y
self.enemies.add(self.goomba)
if num == 1:
self.koopa = Koopa(self.screen, self.settings, self.pipes,
self.bricks, self.enemies, self.mario)
self.koopa.x = x
self.koopa.y = y - 1
self.enemies.add(self.koopa)
def run_game():
pygame.init()
screen_size = (600, 385)
screen = pygame.display.set_mode(screen_size)
mario = Mario(screen)
background = Background(screen, './mario_pics/full_background_no_sky.png',
mario)
question_block = Block(screen, 300)
physics = Physics()
# first_goomba = Goomba(screen)
enemies = Group()
game_on = True
tick = 0
background_color = (93, 148, 251)
# r = randint(0, 255)
# g = randint(0,255)
# b = randint(0,255)
while game_on == True:
# tick += 1
# background_color = (r, g, b)
# if tick % 5 == 0:
# r += 10
# g += 15
# b += 16
# if r > 230:
# r -= 150
# if g > 230:
# g -= 150
# if b > 230:
# b -= 150
# print tick
for i in background.goomba_spawn_points:
if background.x == i:
enemies.add(Goomba(screen))
check_events(background, mario, question_block, screen)
screen.fill(background_color)
background.draw_background(mario)
mario.draw_mario(physics, background)
question_block.draw_block(mario)
print enemies
for enemy in enemies:
enemy.draw_goomba(mario, physics, background)
mario.check_mario_is_alive(background, enemy)
# first_goomba.draw_goomba(mario)
pygame.display.flip()
def run_game():
# Initialize game and create the screen
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Super Mario Bros")
goomba = Goomba(ai_settings, screen)
koopa = Koopa(ai_settings, screen)
# Start the main loop
while True:
gf.check_events()
gf.update_goomba(ai_settings, goomba)
gf.update_koopa(ai_settings, koopa)
gf.update_screen(ai_settings, screen, goomba, koopa)
def enemy_spawn_triggers(self, enemies):
# Screen position should have the position of the left side of the screen saved
if not self.goomba1:
self.goomba1 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.settings.brick_lenth * 25,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba2 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 42:
self.goomba2 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba3 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 56:
self.goomba3 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba4 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 57:
self.goomba4 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba5 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 82:
self.goomba5 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point, self.settings.ground_level -
self.settings.brick_lenth * 8 -
self.settings.goomba_height, 1))
if not self.goomba6 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 84:
self.goomba6 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point, self.settings.ground_level -
self.settings.brick_lenth * 8 -
self.settings.goomba_height, 1))
if not self.goomba7 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 100:
self.goomba7 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba8 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 101:
self.goomba8 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.koopa1 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 109:
self.koopa1 = True
enemies.add(
KoopaTroopa(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.koopa_height,
1))
if not self.goomba9 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 118:
self.goomba9 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba10 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 119:
self.goomba10 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba11 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 128:
self.goomba11 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba12 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 129:
self.goomba12 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba13 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 131:
self.goomba13 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba14 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 175:
self.goomba14 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
if not self.goomba15 and self.settings.screen_pos + self.x_spawn_point > self.settings.brick_lenth * 176:
self.goomba15 = True
enemies.add(
Goomba(
self.settings, self.screen, self.ui, self.timers,
self.x_spawn_point,
self.settings.ground_level - self.settings.goomba_height,
1))
def generate_entities(screen, settings, map_group, enemy_group):
entity_arr = []
# # 23,12 goomba
g = Goomba(screen, settings)
g.x = 22 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 41,12 goomba
g = Goomba(screen, settings)
g.x = 40 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 52,12 goomba
g = Goomba(screen, settings)
g.x = 51 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 54,12 goomba
g = Goomba(screen, settings)
g.x = 53 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 81,4 goomba
g = Goomba(screen, settings)
g.x = 80 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 11)
g.rect.y = g.y
entity_arr.append(g)
# # 83,4 goomba
g = Goomba(screen, settings)
g.x = 82 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 11)
g.rect.y = g.y
entity_arr.append(g)
# # 98,12 goomba
g = Goomba(screen, settings)
g.x = 97 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 100,12 goomba
g = Goomba(screen, settings)
g.x = 99 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 108,12 koopa
k = Koopa(screen, settings)
k.x = 107 * settings.floor_width
k.rect.x = k.x
k.y = settings.screen_height - (settings.floor_height * 3.5)
k.rect.y = k.y
entity_arr.append(k)
# # 115,12 goomba
g = Goomba(screen, settings)
g.x = 114 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 117,12 goomba
g = Goomba(screen, settings)
g.x = 116 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 125,12 goomba
g = Goomba(screen, settings)
g.x = 124 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 127,12 goomba
g = Goomba(screen, settings)
g.x = 126 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 130,12 goomba
g = Goomba(screen, settings)
g.x = 129 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 132,12 goomba
g = Goomba(screen, settings)
g.x = 131 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 175,12 goomba
g = Goomba(screen, settings)
g.x = 174 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
# # 177,12 goomba
g = Goomba(screen, settings)
g.x = 176 * settings.floor_width
g.rect.x = g.x
g.y = settings.screen_height - (settings.floor_height * 3)
g.rect.y = g.y
entity_arr.append(g)
for i in entity_arr:
i.add(map_group, enemy_group)
def __init__(self, screen, file_map, platforms_top, platforms_bottom,
left_walls, right_walls, floor_tiles, brick_tiles,
mystery_tiles, pole, clouds, hills, bushes, pipes,
metal_tiles, castle, enemy_gamemaster, mario,
entity_gamemaster):
file = open(file_map, 'r')
lines = file.readlines()
x = 0
y = 0
# give each mystery box created an id for referencing when it is collided with.
mystery_tile_id = 0
for line in lines:
for p in line:
if p == 'f':
# create a 4 sided rectangle, with top collidable with mario's feet
# bottom collidable with mario head
# and left and right wall collidable with mario right or left
# 4 sided rectangle with independent collidable parts - - - - -
# this will serve as a mask for every game object that needs to be collidable
platform_top = Tiles(screen, x, y + 2, 'platform', 0)
# platform_bottom = Tiles(screen, x, y+34, 'platform')
# wall_left = Tiles(screen, x-17, y+28, 'wall')
# wall_right = Tiles(screen, x+18, y+28, 'wall')
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# game object representation of floor tile
floor_tile = Tiles(screen, x + 1, y + 32, 'floor', 0)
platforms_top.add(platform_top)
# platforms_bottom.add(platform_bottom)
# left_walls.add(wall_left)
# right_walls.add(wall_right)
floor_tiles.add(floor_tile)
# continue adding if statement for objects you
# want to add in the map.txt file
if p == 'b':
platform_top = Tiles(screen, x + 2, y + 5, 'platform', 0)
platform_bottom = Tiles(screen, x + 2, y + 37, 'platform',
0)
wall_left = Tiles(screen, x - 14, y + 31, 'wall', 0)
wall_right = Tiles(screen, x + 16, y + 31, 'wall', 0)
brick_tile = Tiles(screen, x, y + 34, 'brick', 0)
platforms_top.add(platform_top)
platforms_bottom.add(platform_bottom)
left_walls.add(wall_left)
right_walls.add(wall_right)
brick_tiles.add(brick_tile)
if p == '5':
platform_top = Tiles(screen, x + 2, y + 5, 'platform', 0)
platform_bottom = Tiles(screen, x + 2, y + 35, 'platform',
0)
wall_left = Tiles(screen, x - 14, y + 30, 'wall', 0)
wall_right = Tiles(screen, x + 16, y + 30, 'wall', 0)
mystery_tile = Tiles(screen, x, y + 34, 'brick',
mystery_tile_id)
mystery_tile_id += 1
platforms_top.add(platform_top)
platforms_bottom.add(platform_bottom)
left_walls.add(wall_left)
right_walls.add(wall_right)
mystery_tiles.add(mystery_tile)
if p == 'm':
platform_top = Tiles(screen, x + 2, y + 5, 'platform', 0)
platform_bottom = Tiles(screen, x + 2, y + 37, 'platform',
0)
wall_left = Tiles(screen, x - 14, y + 31, 'wall', 0)
wall_right = Tiles(screen, x + 16, y + 31, 'wall', 0)
mystery_tile = Tiles(screen, x, y + 34, 'mystery',
mystery_tile_id)
mystery_tile_id += 1
platforms_top.add(platform_top)
platforms_bottom.add(platform_bottom)
left_walls.add(wall_left)
right_walls.add(wall_right)
mystery_tiles.add(mystery_tile)
if p == 't':
platform_top = Tiles(screen, x + 18, y + 4, 'platform', 0)
platform_top2 = Tiles(screen, x - 18, y + 4, 'platform', 0)
wall_left = Tiles(screen, x - 32, y + 28, 'wall', 0)
wall_right = Tiles(screen, x + 32, y + 28, 'wall', 0)
pipe_top = Tiles(screen, x, y + 32, 'pipetop', 0)
platforms_top.add(platform_top)
platforms_top.add(platform_top2)
left_walls.add(wall_left)
right_walls.add(wall_right)
pipes.add(pipe_top)
if p == 'x':
platform_top = Tiles(screen, x, y + 4, 'platform', 0)
wall_left = Tiles(screen, x - 31, y + 28, 'wall', 0)
wall_right = Tiles(screen, x + 32, y + 28, 'wall', 0)
pipe_extension = Tiles(screen, x, y + 33, 'pipebottom', 0)
platforms_top.add(platform_top)
left_walls.add(wall_left)
right_walls.add(wall_right)
pipes.add(pipe_extension)
if p == 'l':
platform_top = Tiles(screen, x, y + 1, 'platform', 0)
wall_left = Tiles(screen, x - 15, y + 28, 'wall', 0)
wall_right = Tiles(screen, x + 16, y + 28, 'wall', 0)
metal = Tiles(screen, x, y + 32, 'metal', 0)
platforms_top.add(platform_top)
left_walls.add(wall_left)
right_walls.add(wall_right)
metal_tiles.add(metal)
if p == 'p':
flag_pole = Tiles(screen, x, y + 32, 'pole', 0)
pole.add(flag_pole)
if p == 'g':
flag = Tiles(screen, x - 16, y + 36, 'flag', 0)
pole.add(flag)
if p == 'c':
cloud1 = Tiles(screen, x, y + 32, 'cloud1', 0)
clouds.add(cloud1)
if p == 'v':
cloud2 = Tiles(screen, x, y + 32, 'cloud2', 0)
clouds.add(cloud2)
if p == 'd':
cloud3 = Tiles(screen, x, y + 32, 'cloud3', 0)
clouds.add(cloud3)
if p == 'h':
bighill = Tiles(screen, x, y + 32, 'bighill', 0)
hills.add(bighill)
if p == 'j':
smallhill = Tiles(screen, x, y + 32, 'smallhill', 0)
hills.add(smallhill)
if p == 'y':
bush1 = Tiles(screen, x, y + 32, 'bush1', 0)
bushes.add(bush1)
if p == 'u':
bush2 = Tiles(screen, x, y + 32, 'bush2', 0)
bushes.add(bush2)
if p == 'i':
bush3 = Tiles(screen, x, y + 32, 'bush3', 0)
bushes.add(bush3)
if p == 's':
cast = Tiles(screen, x, y + 32, 'castle', 0)
castle.add(cast)
if p == 'G':
goomba = Goomba(screen, mario, platforms_top, left_walls,
right_walls)
goomba.rect.center = (x, y)
goomba.centerx = goomba.rect.centerx
goomba.centery = goomba.rect.centery
goomba.previous_centery = goomba.centery
enemy_gamemaster.goombas.add(goomba)
if p == 'K':
koopa = Koopa(screen, mario, platforms_top, left_walls,
right_walls)
koopa.rect.center = (x, y)
koopa.centerx = koopa.rect.centerx
koopa.centery = koopa.rect.centery
koopa.previous_centery = koopa.centery
enemy_gamemaster.koopas.add(koopa)
if p == '\n':
y += 32
x += 32
x = 32
file.close()
def make_map(self, floors, blocks, pipes, goombas, invis, koopa):
size = self.settings.rectSize
for row in self.lines:
for chars in row:
# Floor
if chars == "F":
new_floor = Floor(self.screen, self.settings)
new_floor.rect.x, new_floor.rect.y = self.xShift, self.yShift
self.xShift += size
floors.add(new_floor)
# Breakable brick
elif chars == "B":
new_brick = Block(self.screen, self.settings, 4)
new_brick.rect.x, new_brick.rect.y = self.xShift + size / 4, self.yShift + size / 4
self.xShift += size
blocks.add(new_brick)
# Unbreakable brick
elif chars == "U":
new_brick = Block(self.screen, self.settings, 0)
new_brick.rect.x, new_brick.rect.y = self.xShift + size / 4, self.yShift + size / 4
self.xShift += size
blocks.add(new_brick)
# Pipe
elif chars == "P":
new_pipe = Pipe(self.screen, self.settings)
new_pipe.rect.x, new_pipe.rect.y = self.xShift + size / 4, self.yShift + size / 4
self.xShift += size
pipes.add(new_pipe)
# Blank space
elif chars == "X":
self.xShift += size
# ? block
elif chars == "?":
new_brick = Block(self.screen, self.settings, 6)
new_brick.rect.x, new_brick.rect.y = self.xShift + size / 4, self.yShift + size / 4
self.xShift += size
blocks.add(new_brick)
# Mushroom blocks (look like ? blocks):
elif chars == "M":
new_brick = Block(self.screen, self.settings, 6, 0, 1)
new_brick.rect.x, new_brick.rect.y = self.xShift + size / 4, self.yShift + size / 4
self.xShift += size
blocks.add(new_brick)
# Invisible walls
elif chars == "I":
new_invis = Block(self.screen, self.settings, 8, 0, 1)
new_invis.rect.x, new_invis.rect.y = self.xShift + size / 4, self.yShift + size / 4
self.xShift += size
invis.add(new_invis)
# Goombas
elif chars == "G":
new_goomba = Goomba(self.screen, self.settings)
new_goomba.rect.x, new_goomba.rect.y = self.xShift + size / 4, self.yShift - size / 10
self.xShift += size
goombas.add(new_goomba)
elif chars == "K":
new_koopa = Koopa(self.screen, self.settings)
new_koopa.rect.x, new_koopa.rect.y = self.xShift + size / 4, self.yShift - size / 10
self.xShift += size
koopa.add(new_koopa)
self.xShift = 0
self.yShift += size
print("Done.")
def run_game():
pygame.init()
screen_size = (600, 385)
screen = pygame.display.set_mode(screen_size)
mario_main_menu_pic_load = pygame.image.load(
'./mario_pics/super_mario_logo.png')
mario_main_menu_pic = pygame.transform.scale(mario_main_menu_pic_load,
[500, 200])
main_menu_x = 50
main_menu_y = 50
mario = Mario(screen)
background = Background(screen, './mario_pics/full_background_no_sky.png',
mario, 0)
main_menu_background = Background(
screen, './mario_pics/full_background_no_sky.png', mario, 300)
question_blocks = Group()
reg_blocks = Group()
physics = Physics()
# first_goomba = Goomba(screen)
enemies = Group()
dead_enemies = Group()
stars = Group()
game_on = True
tick = 0
power_timer = 0
background_color = (93, 148, 251)
main_menu_font = pygame.font.Font('./mario_pics/8_bit_pusab.ttf', 10)
star_game_text = main_menu_font.render('Press SPACE to Start.', False,
(0, 0, 0))
start_text_x = 200
start_text_y = 250
game_over_font = pygame.font.Font('./mario_pics/8_bit_pusab.ttf', 25)
main_menu = True
start_game = False
for i in background.block_locations:
question_blocks.add(QuestionBlock(screen, mario.speed, i))
# for i in background.reg_block_locations:
# reg_blocks.add(RegBlock(screen, mario.speed, i))
# for block in question_blocks:
# stars.add(Star(screen, block.x))
r = randint(150, 255)
g = randint(150, 255)
b = randint(150, 255)
#//////////////////////////////
#////////MUSICnSOUNDS/////////
#////////////////////////////
theme_song_load = pygame.mixer.music.load('./sounds/mario_theme.wav')
theme_song = pygame.mixer.music.play(-1)
# star_power_song_load = pygame.mixer.music.load('./sounds/mario_dubstep.wav')
star_power_song = pygame.mixer.Sound('./sounds/mario_dubstep.wav')
star_power_song.set_volume(.2)
power_up_sound = pygame.mixer.Sound('./sounds/smb_powerup.wav')
death_sound = pygame.mixer.Sound('./sounds/smb_mariodie.wav')
while game_on:
# print main_menu
if main_menu:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == 32:
start_game = True
if start_game:
if main_menu_background.y > 0:
main_menu_background.y -= 1
main_menu_y -= 1
start_text_y -= 1
elif main_menu_background.y == 0:
main_menu = False
screen.fill(background_color)
screen.blit(mario_main_menu_pic, (main_menu_x, main_menu_y))
screen.blit(star_game_text, [start_text_x, start_text_y])
main_menu_background.draw_background(mario)
# pygame.display.flip()
# print tick
elif not main_menu:
for i in background.goomba_spawn_points:
if background.x == i:
enemies.add(Goomba(screen))
if background.x < i:
background.goomba_spawn_points.remove(i)
check_events(background, mario, screen)
screen.fill(background_color)
background.draw_background(mario)
for star in stars:
star.draw_me(background, physics, question_blocks, mario)
for block in question_blocks:
block.draw_block(background)
for blokc in reg_blocks:
block.draw_block(background)
for block in question_blocks:
if block.x <= mario.x + 27 and block.x >= mario.x:
if mario.hit_block and block.power_up_remaining > 0:
stars.add(Star(screen, block.x))
mario.hit_block = False
block.power_up_remaining -= 1
elif block.power_up_remaining <= 0:
mario.hit_block = False
mario.draw_mario(physics, background, question_blocks, stars)
# question_block.draw_block(background)
# print enemies
# print question_block.y
for enemy in enemies:
enemy.draw_goomba(mario, physics, background)
mario.check_mario_is_alive(background, enemy, death_sound)
for enemy in dead_enemies:
enemy.dead = True
enemy.draw_goomba(mario, physics, background)
if mario.star_power:
theme_song = pygame.mixer.music.pause()
star_power_song.play()
power_timer += 1
mario.max_jump_height = 100
if power_timer == 10:
mario.scale += 15
background.floor -= 14
elif power_timer == 20:
mario.scale += 15
background.floor -= 14
elif power_timer == 30:
mario.scale += 15
background.floor -= 14
# star_power_song = pygame.mixer.music.play(-1)
background_color = (r, g, b)
if tick % 5 == 0:
r += 10
g += 15
b += 16
if r > 230:
r -= 150
if g > 230:
g -= 150
if b > 230:
b -= 150
for enemy in enemies:
distance_from_enemy = fabs(mario.x -
enemy.x) + fabs(mario.y -
enemy.y)
if distance_from_enemy < 100:
enemy.dead == True
dead_enemies.add(enemy)
# screen.blit(goomba_smush_load, [200, 150])
enemies.remove(enemy)
# for enemy in dead_enemies:
# screen.blit(goomba_smush_load, [enemy.x,enemy.y])
if power_timer > 600:
mario.star_power = False
power_timer = 0
background.floor = 290
mario.max_jump_height = 163
background_color = (93, 148, 251)
star_power_song.stop()
theme_song = pygame.mixer.music.unpause()
if mario.alive == False:
game_over_text = game_over_font.render("GAME OVER!", False,
(0, 0, 0))
screen.blit(game_over_text, [150, 150])
theme_song = pygame.mixer.music.stop()
# print background.x
# first_goomba.draw_goomba(mario)
pygame.display.flip()
