def __init__(self, breadth, status):
if not status._level % 3:
IDENTIFIER['board'] = '\033[1;96m~\033[22;39m'
else:
IDENTIFIER['board'] = ' '
self.board = Board(LENGTH, breadth, status)
self.status = status
self.offset = 0
self.breadth = breadth
# Generate random background
if status._level % 3:
for _ in range(randint(breadth // 20, breadth // 16)):
_ = Cloud(self.board)
for _ in range(randint(breadth // 15, breadth // 10)):
_ = Bush(self.board)
self.display()
self.generate_hurdles()
self.display()
self.mario = Mario(FLOOR - 3, 3, self.board)
self.display()
while True:
self.scheduler()
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Super Mario")
# 创建马里奥
mario = Mario(screen, ai_settings)
# 创建一个用于存储游戏统计信息的实例
status = GameStatus(ai_settings)
# 创建一个蘑菇
mushroom = Mushroom(screen, ai_settings, status)
# 开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(mario)
if status.game_active:
mario.update()
gf.check_mario_mushroom_collisions(mario, mushroom)
mushroom.update(status)
gf.update_screen(ai_settings, screen, mario, mushroom)
def returnMap(posx, posy, mappos, direction, length, height):
grnd = Ground(length, height)
grnd.renderGround(mappos)
mrio = Mario(posx, posy)
if mappos >= 2:
mapMatrix = renderBlocks(grnd.length - (mappos - 2), 7, grnd)
grnd.updateMap(mapMatrix)
mapMatrix = mrio.renderMario(grnd, direction)
return mapMatrix
def test_killing_enemy():
BOARD = Board()
MARIO = Mario()
GLOBALVAR = Globalvar()
movefw(BOARD, GLOBALVAR, MARIO, 38)
jump(BOARD, GLOBALVAR, MARIO)
movefw(BOARD, GLOBALVAR, MARIO, 28)
jump(BOARD, GLOBALVAR, MARIO)
movefw(BOARD, GLOBALVAR, MARIO, 39)
jump(BOARD, GLOBALVAR, MARIO)
movefw(BOARD, GLOBALVAR, MARIO, 51)
jump(BOARD, GLOBALVAR, MARIO)
movefw(BOARD, GLOBALVAR, MARIO, 30)
jump(BOARD, GLOBALVAR, MARIO)
movefw(BOARD, GLOBALVAR, MARIO, 22)
print_board(BOARD)
print('========================================')
print('3 Enemies exist')
print('========================================')
for i in range(9):
if i%3 == 0:
MARIO.shoot()
BOARD.updatebg(GLOBALVAR)
BOARD.updatebricks(GLOBALVAR)
BOARD.updatecoins(GLOBALVAR)
BOARD.updatepipes()
BOARD.updatebullets(MARIO)
BOARD.updatesprings()
BOARD.updatemario(MARIO, GLOBALVAR, 'l')
BOARD.updateenemy(MARIO, GLOBALVAR)
print_board(BOARD)
print('========================================')
print('3 Shots fired')
print('========================================')
for i in range(22):
BOARD.updatebg(GLOBALVAR)
BOARD.updatebricks(GLOBALVAR)
BOARD.updatecoins(GLOBALVAR)
BOARD.updatepipes()
BOARD.updatebullets(MARIO)
BOARD.updatesprings()
BOARD.updatemario(MARIO, GLOBALVAR, 'l')
BOARD.updateenemy(MARIO, GLOBALVAR)
print_board(BOARD)
print('=====================================')
print('One enemy still alive')
print('=====================================')
assert len(BOARD.enemyarr) == 0
def __init__(self):
pygame.display.set_caption(settings.game_title)
self.screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
self.stats = Stats()
self.scoreboard = Scoreboard(settings, self.screen, self.stats)
self.enemies = []
self.map = Map(self.screen, settings, self.enemies)
self.mario = Mario(self.screen, settings, self.map)
self.map.set_mario(self.mario)
self.reset_enemies()
self.bgm = pygame.mixer.Sound("media/sounds/bgm.wav")
def __init__(self):
self.score = 0
self.coins = 0
self.lives = 3
self.gridX = 0
self.board = Board()
self.mario = Mario(self)
self.getch = getInput._getChUnix()
self.speed = 1
self.its = 0
self.lefTime = 300
self.lupd = 0
def hor_decelerating_true(character: Mario):
"""
Changes Mario's position, speed and acceleration when accelerating is true.
"""
if 0 >= character.hor_acceleration > -1:
character.hor_acceleration -= 0.1
elif character.hor_acceleration > 0:
character.hor_acceleration = -0.1
if character.hor_acceleration < 0 and character.hor_speed > -7:
character.hor_speed += character.hor_acceleration
character.move_mario(character.x_cor + character.hor_speed,
character.y_cor)
def __init__(self):
pygame.init()
self.ai_settings = Settings()
self.screen = pygame.display.set_mode((self.ai_settings.screen_width, self.ai_settings.screen_height))
pygame.display.set_caption("Super Mario Bros.")
self.screen_rect = self.screen.get_rect()
self.map = Map(self.screen, 'images/world1-1.txt', 'rock_block', 'metal_block', 'stone_block', 'brick_block',
'question_block', 'pipe-1', 'pipe-2', 'super_coin-1', 'pole', 'flag', 'top', 'castle')
self.mario = Mario(self.ai_settings, self.screen, self.map, self)
self.menu = Menu(self.screen, 'Super Mario Bros', 'TOP - ', 'SCORE', 'COINS', 'TIME', self.ai_settings, self.mario)
self.sb = Scoreboard(self.ai_settings, self.screen)
self.load_data()
def hor_accelerating_true(character: Mario):
"""
Changes Mario's position, speed and acceleration when accelerating is true.
"""
if 0 <= character.hor_acceleration < 1:
character.hor_acceleration += 0.1
elif character.hor_acceleration < 0:
character.hor_acceleration = 0.1
if character.hor_acceleration >= 0 and character.hor_speed < 7:
character.hor_speed += character.hor_acceleration
character.move_mario(character.x_cor + character.hor_speed,
character.y_cor)
def run_game():
'''
运行游戏主程序
:return:
'''
# background_image_filename = 'resources/images/level_1.png' #'/Users/lufan/Python_CODE_03/super_mario_level_01/resources/images/level_1.png'
# 初始化游戏并创建一个屏幕对象
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')
# 背景图片
# background = pygame.image.load(background_image_filename).convert()
# 放置Mario
mario = Mario(ai_settings, screen)
marios = Group()
# mario_shadow = Mario_shadow(ai_settings, screen)
# 敌人
enemy = Enemy(ai_settings, screen)
enemy_shadow = Enemy_shadow(ai_settings, screen)
enemies = Group()
'''有问题'''
enemies.add(enemy)
enemies.add(enemy_shadow)
marios.add(mario)
while True:
#监视键盘和鼠标事件
gf.check_events(ai_settings, screen, mario)
# 将背景图画上去
# screen.blit(background, (0, 577))
centerx = mario.update()
# print(centerx)
# enemy.update()
# enemy_shadow.update()
enemies.update()
gf.handle_state(marios, enemies)
gf.update_screen(ai_settings, screen, mario, enemy, enemy_shadow,
centerx)
def enter():
global mario, map, enemy, object, fire_ball, chimney, mario_life
global mario_life2, mario_life3, mario_life4
global item_box, brick
mario = Mario()
map = Map()
enemy = Enemy()
object = Object()
fire_ball = Ball()
chimney = Chimney()
mario_life = Mario_Life()
mario_life2 = Mario_Life2()
mario_life3 = Mario_Life3()
mario_life4 = Mario_Life4()
item_box = Object_Item()
brick = Brick()
game_world.add_object(map, 0)
game_world.add_object(object, 1)
game_world.add_object(mario, 0)
game_world.add_object(enemy, 1)
game_world.add_object(chimney, 0)
game_world.add_object(mario_life, 1)
game_world.add_object(mario_life2, 0)
game_world.add_object(mario_life3, 1)
game_world.add_object(mario_life4, 0)
game_world.add_object(item_box, 1)
game_world.add_object(brick, 0)
pass
def test_scene_movement():
GLOBALVAR = Globalvar()
BOARD = Board()
MARIO = Mario()
for i in range(5):
BOARD.updatebg(GLOBALVAR)
BOARD.updatebricks(GLOBALVAR)
BOARD.updatecoins(GLOBALVAR)
BOARD.updatepipes()
BOARD.updatebullets(MARIO)
BOARD.updatesprings()
BOARD.updatemario(MARIO, GLOBALVAR, 'd')
BOARD.updateenemy(MARIO, GLOBALVAR)
initial_board = [0 for _ in range(30)]
for i in range(30):
initial_board[i] = BOARD.layout[i][:]
print_board(BOARD)
print('======================================')
print('Initial postion')
print('======================================')
# Forward movement
for i in range(6):
BOARD.updatebg(GLOBALVAR)
BOARD.updatebricks(GLOBALVAR)
BOARD.updatecoins(GLOBALVAR)
BOARD.updatepipes()
BOARD.updatebullets(MARIO)
BOARD.updatesprings()
BOARD.updatemario(MARIO, GLOBALVAR, 'd')
BOARD.updateenemy(MARIO, GLOBALVAR)
print_board(BOARD)
print('========================================')
print('Moving 6 steps forward')
print('========================================')
# Backward movement
for i in range(6):
BOARD.updatebg(GLOBALVAR)
BOARD.updatebricks(GLOBALVAR)
BOARD.updatecoins(GLOBALVAR)
BOARD.updatepipes()
BOARD.updatebullets(MARIO)
BOARD.updatesprings()
BOARD.updatemario(MARIO, GLOBALVAR, 'a')
BOARD.updateenemy(MARIO, GLOBALVAR)
print_board(BOARD)
print('=========================================')
print('Moving 6 steps backward')
print('=========================================')
for i in range(1, 30):
for j in range(90):
assert initial_board[i][j] == BOARD.layout[i][j]
def enter():
global mario, map, enemy, object
mario = Mario()
map = Map()
enemy = Enemy()
object = Object()
pass
def enter():
global mario, map, enemy, object, fire_ball, chimney, mario_life
global mario_life2, mario_life3, mario_life4
global item_box, brick, item, coin_box, turtle, coin, balls
mario = Mario()
map = Map()
enemy = Enemy()
object = Object()
fire_ball = Ball()
chimney = Chimney()
mario_life = Mario_Life()
mario_life2 = Mario_Life2()
mario_life3 = Mario_Life3()
mario_life4 = Mario_Life4()
item_box = Object_Item()
brick = Brick()
item = Item()
coin_box = Coin_Box()
turtle = Turtle()
coin = Coin()
game_world.add_object(map, 0)
game_world.add_object(object, 1)
game_world.add_object(mario, 0)
game_world.add_object(enemy, 1)
#game_world.add_object(chimney, 0)
game_world.add_object(mario_life, 1)
game_world.add_object(mario_life2, 0)
game_world.add_object(mario_life3, 1)
game_world.add_object(mario_life4, 0)
game_world.add_object(item_box, 1)
game_world.add_object(brick, 0)
game_world.add_object(coin_box, 1)
#game_world.add_object(turtle, 0)
pass
def enter():
global mario, map, enemy, object, fire_ball, chimney, mario_life
global mario_life2, mario_life3, mario_life4
mario = Mario()
map = Map()
enemy = Enemy()
object = Object()
fire_ball = Ball()
chimney = Chimney()
mario_life = Mario_Life()
mario_life2 = Mario_Life2()
mario_life3 = Mario_Life3()
mario_life4 = Mario_Life4()
game_world.add_object(map, 0)
game_world.add_object(object, 1)
game_world.add_object(mario, 0)
game_world.add_object(enemy, 1)
game_world.add_object(chimney, 0)
game_world.add_object(mario_life, 1)
game_world.add_object(mario_life2, 0)
game_world.add_object(mario_life3, 1)
game_world.add_object(mario_life4, 0)
pass
def play(self):
while True:
while self.stats.lives > 0:
self.mario_player = Mario(self.ai_settings, self.screen)
self.map = Map(self.ai_settings,
self.screen,
mapfile='Levels/first_level.txt',
blockfile='Images/block_tile.png')
eloop = EventLoop(self.ai_settings,
self.screen,
self.mario_player,
self.map,
self.stats,
self.scoreboard,
finished=False)
self.map.create_level()
while not eloop.finished:
eloop.update_events()
eloop.check_input_events()
eloop.update_screen()
self.clock.tick(60)
print(self.clock.get_fps())
self.stats.lives -= 1
self.stats.score = 0
self.stats.reset_stats()
if self.stats.win:
self.gameover.show_winover()
self.stats.final_score = 0
self.stats.win = False
else:
self.gameover.show_gameover()
pygame.time.wait(3000)
def prep_marios(self):
"""Show how many marios are left."""
self.marios = Group()
for mario_number in range(self.stats.marios_left):
mario = Mario(self.ai_game)
mario.rect.x = 10 + mario_number * (mario.rect.width + 10)
mario.rect.y = 10
self.marios.add(mario)
def test_score_update(): BOARD = Board() MARIO = Mario() GLOBALVAR = Globalvar() movefw(BOARD, GLOBALVAR, MARIO, 38) assert BOARD.score >= 30
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.stats = GameStats(self)
#self.sb = Scoreboard
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.mario = Mario(self)
self.bowser = Bowser(self)
self.iceballs = pygame.sprite.Group()
self.fireballs = pygame.sprite.Group()
# Make the Play button.
self.play_button = Button(self, "Play")
def __init__(self):
pygame.init()
config = ConfigParser() # parse settings file
config.read('settings.ini')
screen_size = (int(config['screen_settings']['width']),
int(config['screen_settings']['height']))
self.screen = pygame.display.set_mode(screen_size)
self.stats = GameStats(self.screen)
pygame.display.set_caption(config['game_settings']['title'])
self.clock = pygame.time.Clock() # clock for limiting fps
self.game_objects = None
self.tmx_data = None
self.map_layer = None
self.map_group = None
self.player_spawn = None
self.mario = None
self.timer = None
self.time_warn = None
self.last_tick = 0
self.score = 0
self.lives = 3
self.coins = 0
self.SFX = {
'1-up': pygame.mixer.Sound('audio/1-Up.wav'),
'warning': pygame.mixer.Sound('audio/Time-Warning.wav')
}
self.init_world()
self.mario = Mario(self.game_objects, self.map_layer, self.map_group,
self.screen)
self.prep_enemies()
self.mario.rect.x, self.mario.rect.y = self.player_spawn.x, self.player_spawn.y
self.map_layer.center(
(self.mario.rect.x, self.mario.rect.y)) # center camera
self.map_layer.zoom = 0.725 # camera zoom
self.map_group.add(self.mario) # add test sprite to map group
self.paused = False
# print(self.map_layer.view_rect.center)
# action map for event loop
self.paused = False
self.game_active = False
self.game_won = False
self.menu = Menu(self.screen)
self.action_map = {pygame.KEYDOWN: self.set_paused}
print(self.map_layer.view_rect.center)
def run_game():
pygame.init()
pygame.display.set_caption("Mario")
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
scores = Scoreboard(ai_settings, screen)
music = Music()
g_blocks = Group()
bg_blocks = Group()
enemies = Group()
chunks = Group()
items = Group()
pygame.mixer.set_reserved(0)
pygame.mixer.set_reserved(1)
pygame.mixer.set_reserved(2)
pygame.mixer.set_reserved(3)
pygame.mixer.set_reserved(4)
pygame.mixer.set_reserved(5)
monitor = Monitor(ai_settings, screen, g_blocks, bg_blocks, chunks,
enemies, items)
mario = Mario(ai_settings, screen, g_blocks, bg_blocks, enemies, monitor,
chunks, items, scores)
while True:
gf.check_events(ai_settings, screen, mario, g_blocks, bg_blocks, items,
music)
mario.update(music, mario)
gf.check_time(ai_settings, scores, mario)
gf.check_lives(ai_settings, scores)
music.check_star(mario)
music.check_dies(mario)
music.check_win(mario)
music.check_win2(mario)
music.change_bg_music()
gf.update_screen(ai_settings, screen, mario, g_blocks, bg_blocks,
enemies, monitor, chunks, items, scores, music)
mainClock.tick(40)
def __init__(self, level):
"""Constructor"""
self.__board = Board(level)
self.__level = level
self.ini_time = time.clock()
if level == 2:
self.__mario = Mario(1, BOARD_HEIGHT - 3 - 3 - 30)
self.__mario.update(0, 0, 0, self.__board, self.__mario)
else:
self.__mario = Mario(0, BOARD_HEIGHT - 3 - 3)
if level == 1:
self.bg_music = subprocess.Popen(
["aplay", "-q", "./Sound/Super Mario Bros. Soundtrack.wav"])
else:
self.bg_music = subprocess.Popen([
"aplay", "-q",
"./Sound/Super Mario Underground Themes 1985 - 2010.wav"
])
self.win = 0
def run_game():
# Initialize pygame, settings, and screen object.
pygame.init()
settings = Settings()
'''
full_screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
screen = pygame.Surface((settings.screen_width, settings.screen_height))
After everything has been blit onto screen use:
full_screen.blit(pygame.transform.scale(screen, (1980, 1080)), (0, 0))
pygame.display.flip()
'''
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
ui = UserInterface(settings, screen)
pygame.display.set_caption("Super Mario Bros")
# Create our timers
timers = Timers()
# Create a group to hold all enemies
enemies = Group()
# Create our Hero
mario_ = Mario(settings, screen, ui, timers)
# Create a group to hold all objects and background
objects = Group()
background = Group()
items = Group()
# Create first level
curlevel = Level1_1(settings, screen, enemies, objects, background, mario_,
ui, timers)
while True:
timers.curtime = pygame.time.get_ticks()
gf.check_events(settings, mario_)
if curlevel.active:
gf.update_pos(settings, timers, enemies, objects, background,
curlevel, items, mario_, ui)
gf.update_animations(enemies, timers, objects, mario_)
gf.update_level_timer(ui, timers, mario_)
gf.update_screen(screen, ui, enemies, timers, objects, background,
curlevel, mario_, items)
if ui.lives == 0:
curlevel.active = False
ui.lives = 3
settings.level_num = 0
else:
objects.empty()
background.empty()
items.empty()
enemies.empty()
curlevel = gf.change_level(settings, screen, enemies, objects,
background, mario_, ui, timers)
def enter():
global mario, map, enemy, object
mario = Mario()
map = Map()
enemy = Enemy()
object = Object()
game_world.add_object(map, 0)
game_world.add_object(object, 1)
game_world.add_object(mario, 2)
game_world.add_object(enemy, 3)
pass
def __init__(self, debug: bool = False) -> None:
super().__init__(fps=FPS)
self.window = Window(b'', dimensions=400 + 400j)
self.renderer = self.window.renderer()
self.mario_texture = self.renderer.load_texture(b'res/mario.png')
self.background = Background(
color=Color(107, 142, 255),
texture=self.renderer.load_texture(b'res/background.png'))
self.mario = Mario(keyboard=self.keyboard,
upper_left=100 + 100j,
texture=self.mario_texture)
self.camera = FollowerCamera(target=self.mario,
view_dimensions=400 + 400j,
window_dimensions=400 + 400j,
renderer=self.renderer)
self.integrator = Integrator(timestep=2,
gravity=300,
horizontal_drag=0.2,
entities=[self.mario],
terrain=MarioGame.create_terrain())
self.debug = debug
def enter():
global mario, map, enemy, object, fire_ball
mario = Mario()
map = Map()
enemy = Enemy()
object = Object()
fire_ball = Ball()
game_world.add_object(map, 0)
game_world.add_object(object, 1)
game_world.add_object(mario, 0)
game_world.add_object(enemy, 1)
pass
def new(self):
# start a new game
self.all_sprites = pg.sprite.Group()
self.fireballs = pg.sprite.Group()
# self.platforms = pg.sprite.Group()
self.player = Mario(game=self)
self.all_sprites.add(self.player)
self.bg = Level1(mario=self.player, screen=self.screen, game=self)
# for plat in PLATFORM_LIST:
# p = Platform(*plat)
# self.all_sprites.add(p)
# self.platforms.add(p)
self.run()
def reset_game(self):
# print("Received reset request")
self.bgm.stop()
# Hard or soft?
if self.stats.lives_left == 0:
reset_type = "Hard"
# print("Reset - Hard")
else:
reset_type = "Soft"
# print("Reset - Soft")
# Soft - Lives remain
# Only score and time are refreshed
if reset_type == "Soft":
self.stats.score = 0
self.stats.time = 400
self.stats.last_time_update = pygame.time.get_ticks()
self.reset_enemies()
self.map = Map(self.screen, settings, self.enemies)
self.mario = Mario(self.screen, settings, self.map)
self.map.set_mario(self.mario)
# Hard - All lives are gone
# All but high score are reset
elif reset_type == "Hard":
self.stats.score = 0
self.stats.time = 400
self.stats.last_time_update = pygame.time.get_ticks()
self.stats.coins = 0
self.stats.lives_left = 3
self.reset_enemies()
self.map = Map(self.screen, settings, self.enemies)
self.mario = Mario(self.screen, settings, self.map)
# The game has been reset, resume gameplay
settings.game_status = "Ready"
settings.game_active = True
self.play()
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption('Alien Invasion')
# Create an instance to store game statistics,
# and create a scoreboard.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.mario = Mario(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Make the play button.
self.play_button = Button(self, 'Play')
def run_game():
pygame.init()
mario_settings = MarioSettings()
screen = pygame.display.set_mode(
(mario_settings.screen_width, mario_settings.screen_height))
pygame.display.set_caption('Mario')
bg_color = mario_settings.bg_color
mario = Mario(screen)
pygame.key.set_repeat(10, 7) #Continious movement function in pygame
while True:
mf.check_events(mario)
mf.update_screen(mario_settings, screen, mario)
def main():
""" Main Program """
pygame.init()
FPS = 60
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
# Set the height and width of the screen
screen = pygame.display.set_mode(config.SIZE, pygame.DOUBLEBUF, 32)
pygame.display.set_caption("Super Mario Bros!")
# Create the player
player = Mario()
# Set the current level
current_level_no = 1
current_level = levels.Level(player)
load_level(current_level)
active_sprite_list = pygame.sprite.Group()
player.level = current_level
player.rect.x = 120
#Player always starts in the same point
player.rect.y = config.SCREEN_HEIGHT - player.rect.height - 64
active_sprite_list.add(player)
#Loop until the user clicks the close button.
done = False
# -------- Main Program Loop -----------
while not done:
#Set Level Physics
milliseconds = clock.tick(FPS)
seconds = milliseconds / 1000.0 # seconds passed since last frame (float)
playtime = current_level.physics_info['play_time'] + seconds
current_level.physics_info['current_time'] = milliseconds
current_level.physics_info['seconds'] = seconds
current_level.physics_info['play_time'] = playtime
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
done = True # Flag that we are done so we exit this loop
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_s:
player.is_running = True
if event.key == pygame.K_a and player.state != config.MARIO_STATE_JUMPING:
player.jump()
if event.type == pygame.KEYUP:
if event.key == pygame.K_s:
player.is_running = False
if event.key == pygame.K_a:
player.fight_gravity = False
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player.go_left()
if keys[pygame.K_RIGHT]:
player.go_right()
if not keys[pygame.K_LEFT] and not keys[pygame.K_RIGHT]:
player.stop()
# Update the player.
active_sprite_list.update()
# Update items in the level
current_level.update()
# If the player gets near the right side, shift the world left (-x)
LIMIT = config.SCREEN_WIDTH - config.SCREEN_PLAYER_OFFSET
if player.rect.x >= LIMIT:
diff = player.rect.x - LIMIT
player.rect.x = LIMIT
current_level.shift_world(-diff)
# If the player gets to the end of the level, go to the next level
current_position = player.rect.x + current_level.world_shift
# ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT
current_level.draw(screen)
active_sprite_list.draw(screen)
#print(current_level.physics_info)
"""
pygame.display.set_caption("Millis({})/Seconds({})/PlayTime({}) limit FPS to {} (now: {:.2f})".format(
milliseconds, seconds, playtime, FPS,clock.get_fps()))
"""
# Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# Be IDLE friendly. If you forget this line, the program will 'hang'
# on exit.
pygame.quit()
from __future__ import division
from mario import Mario
from nn import NeuralNetwork
import cPickle as pickle
emulator = Mario()
with open('./bestNN', 'rb') as file:
nn = pickle.load(file)
print(nn.weights)
emulator.setNeuralNetwork(nn)
emulator.run()
def game():
pygame.init()
FPS = 10
clock = pygame.time.Clock()
size = (600, 850)
screen = pygame.display.set_mode(size) # Main surface
ss = spritesheet.spritesheet('res\sprites\hammer.png')
scale_factor = 4
hammer_img = pygame.transform.scale(ss.image_at((0, 0, 10, 15)), (10*scale_factor, 15*scale_factor))
ss = spritesheet.spritesheet('res\sprites\misc.gif')
scale_factor = 4
platform_img = pygame.transform.scale(ss.image_at((222, 270, 16, 10)), (16*scale_factor, 10*scale_factor))
platforms = []
h = size[1] - platform_img.get_height() - 50
for j in range(6):
l = []
for i in range(0, size[0], platform_img.get_width()):
l.append((i, h))
platforms.append(l)
h -= platform_img.get_height() * 3
platforms.append([(300, 50), (300+platform_img.get_width(), 50)])
#(106, 125)
#Segment platforms
for i in range(len(platforms[0])/2-2, len(platforms[0])):
curr_y = platforms[0][i][1]
curr_y -= 6*(i - (len(platforms[0])/2-2))
platforms[0][i] = (platforms[0][i][0], curr_y)
for i in range(0, len(platforms[1])/2):
curr_y = platforms[1][i][1]
curr_y += 6*(i - (len(platforms[1])/2))
##print i
platforms[1][i] = (platforms[1][i][0], curr_y)
for i in range(len(platforms[2])/2-2, len(platforms[0])):
curr_y = platforms[2][i][1]
curr_y -= 6*(i - (len(platforms[2])/2-2))
platforms[2][i] = (platforms[2][i][0], curr_y)
for i in range(0, len(platforms[3])/2):
curr_y = platforms[3][i][1]
curr_y += 6*(i - (len(platforms[3])/2))
##print i
platforms[3][i] = (platforms[3][i][0], curr_y)
for i in range(len(platforms[4])/2-2, len(platforms[4])):
curr_y = platforms[4][i][1]
curr_y -= 6*(i - (len(platforms[4])/2-2))
##print i
platforms[4][i] = (platforms[4][i][0], curr_y)
barrel_sprite = ss.image_at((95, 260, 16, 10))
barrel_sprite = pygame.transform.scale(barrel_sprite, (16*scale_factor, 10*scale_factor))
rolling_barrel_sprite_arr = [ss.image_at((65, 257, 15, 12)).convert_alpha(), ss.image_at((80, 257, 15, 12)).convert_alpha(), ss.image_at((65, 270, 15, 10)).convert_alpha(), ss.image_at((80, 270, 15, 10)).convert_alpha()]
for b in range(len(rolling_barrel_sprite_arr)):
rolling_barrel_sprite_arr[b] = pygame.transform.scale(rolling_barrel_sprite_arr[b], (10*scale_factor, 10*scale_factor))
## rolling_barrel = RollingBarrel((300,15*scale_factor*2+5), rolling_barrel_sprite_arr, (170, size[0]))
rolling_barrels = []
scale_factor = 3
mario_sprites = []
mario_sprites.append(pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((94, 3, 15, 17)), (15*scale_factor, 17*scale_factor))))
mario_sprites.append(pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((175, 3, 15, 17)), (15*scale_factor, 17*scale_factor))))
mario_sprites.append(pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((160, 3, 15, 17)), (15*scale_factor, 17*scale_factor))))
mario_sprites.append(pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((135, 3, 15, 17)), (15*scale_factor, 17*scale_factor))))
mario_sprites.append(pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((114, 4, 15, 17)), (15*scale_factor, 17*scale_factor))))
mario_sprites.append(pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((196, 3, 15, 17)), (15*scale_factor, 17*scale_factor))))
mario_hammer_sprites = []
mario_hammer_sprites.append(pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((69, 55, 26, 20)), (15*scale_factor, 17*scale_factor))))
mario_sprites.append(pygame.Surface.convert(pygame.transform.scale(ss.image_at((69, 55, 28, 18)), (20*scale_factor, 22*scale_factor))))
mario_sprites.append(pygame.Surface.convert(pygame.transform.scale(ss.image_at((102, 43, 19, 30)), (22*scale_factor, 26*scale_factor))))
mario_sprites.append(pygame.Surface.convert(pygame.transform.scale(ss.image_at((69, 55, 28, 18)), (20*scale_factor, 22*scale_factor))))
mario_sprites.append(pygame.Surface.convert(pygame.transform.scale(ss.image_at((69, 55, 28, 18)), (20*scale_factor, 22*scale_factor))))
mario_sprites.append(pygame.Surface.convert(pygame.transform.scale(ss.image_at((157, 54, 28, 18)), (20*scale_factor, 22*scale_factor))))
mario_sprites.append(pygame.Surface.convert(pygame.transform.scale(ss.image_at((189, 43, 19, 30 )), (22*scale_factor, 26*scale_factor))))
#(69,55)
mario_character = Mario((0, size[1]-mario_sprites[0].get_height()-62), mario_sprites, mario_hammer_sprites)
daisy_sprite = pygame.Surface.convert_alpha(pygame.transform.scale(ss.image_at((106, 125, 15, 17)), (15*scale_factor, 17*scale_factor)))
ss = spritesheet.spritesheet('res\sprites\enemies.png')
dk_sprites = []
dk_sprites.append(ss.image_at((100, 0, 50, 40)))
for i in range(5):
dk_sprites.append(ss.image_at((50*i, 50, 50, 40)))
for i in range(5):
dk_sprites.append(ss.image_at((50*i, 100, 50, 40)))
scale_factor = 2
##print "# of sprites", len(dk_sprites)
for i in range(len(dk_sprites)):
dk_sprites[i] = pygame.transform.scale(dk_sprites[i], (50*scale_factor, 40*scale_factor))
ss = spritesheet.spritesheet('res\sprites\ladder.png')
scale_factor = 2
ladder_sprite = pygame.transform.scale(ss.image_at((0, 0, 20, 50)), (int(20*scale_factor), int(40*scale_factor)))
ladders = [[(500, 660)],[(50, 540)],[(500, 420)],[(70, 300)],[(480, 190)],[(310, 90)],[]]
background = pygame.Surface(size) # BG Surface
background = background.convert()
blank = pygame.Surface(size)
blank.fill(BLACK)
foreground = pygame.Surface(size)
background.fill(BLACK)
dk_sprite_counter = 1
left, right, up, down, jump = False, False, False, False, False
dk_launch_stage = 0
dk_launch = False
game_state = True
items = [(400,300)]
launch_buffer = 0
daisy_call = 0
global begin
## while not begin:
## font = pygame.font.Font(None, 40)
## text = font.render("Donkey Kong", 1, (250, 0, 0))
## font = pygame.font.Font(None, 30)
## subtitle = font.render("Press Space to Start", 1, (250, 0, 0))
## background.blit(text, (int(size[0]/2)-70, int(size[1]/2)))
## screen.blit(background, (0, 0))
## pygame.display.flip()
## if ev.type == pygame.KEYDOWN:
## if ev.key == 32:
## begin = False
while game_state and begin:
global speed
if launch_buffer % speed == 0:
dk_launch = True
launch_buffer += 1
ev = pygame.event.poll()
if ev.type == pygame.QUIT:
##print "Exit"
quit_game()
if dk_launch:
#print dk_launch_stage
if dk_launch_stage == 0:
dk_sprite_counter = 0
elif dk_launch_stage == 4:
dk_sprite_counter = 5
elif dk_launch_stage == 8:
dk_sprite_counter = 1
dk_launch_stage = 0
dk_launch = False
fall = random.randint(0, 1)
if fall == 1:
rolling_barrels.append(RollingBarrel((170,15*scale_factor*2+50), rolling_barrel_sprite_arr, (170, size[0]), True))
else:
rolling_barrels.append(RollingBarrel((170,15*scale_factor*2+50), rolling_barrel_sprite_arr, (170, size[0])))
if dk_launch:
dk_launch_stage += 1
# Keyboard events
if ev.type == pygame.KEYDOWN:
print ev.key
# Cycle sprites for DK
if ev.key == 113:
if dk_sprite_counter == 1:
dk_sprite_counter = 0
elif dk_sprite_counter == 0:
dk_sprite_counter = 5
elif dk_sprite_counter == 5:
dk_sprite_counter = 1
if ev.key == 275:
right = True
if ev.key == 276:
left = True
if ev.key == 273:
up = True
if ev.key == 274:
down = True
if ev.key == 116:
dk_launch = True
if ev.key == 32:
jump = True
if ev.type == pygame.KEYUP:
if ev.key == 275:
right = False
if ev.key == 276:
left = False
if ev.key == 273:
up = False
if ev.key == 274:
down = False
if ev.key == 32:
jump = False
background.blit(blank, (0,0))
for places in platforms:
for pls in places:
background.blit(platform_img, pls)
for levels in ladders:
for points in levels:
background.blit(ladder_sprite, points)
background.blit(dk_sprites[dk_sprite_counter], (80,88))
mario_character.render(background)
## rolling_barrel.update(platforms, platform_img.get_height(), ladders)
## rolling_barrel.render(background)
for rb in rolling_barrels:
rb.update(platforms, platform_img.get_height(), ladders)
rb.render(background)
buffer_height = 5
for i in range(4):
background.blit(barrel_sprite, (0, buffer_height+barrel_sprite.get_height()*i))
background.blit(daisy_sprite, (310, 10))
m_items = []
for i in items:
m_items.append(pygame.Rect(i[0], i[1], hammer_img.get_width(), hammer_img.get_height()))
background.blit(hammer_img, i)
mario_status = mario_character.update(left, right, up, down, jump, platforms, platform_img.get_height(), ladders, rolling_barrels, m_items, pygame.Rect((310,10), (daisy_sprite.get_width(), daisy_sprite.get_height())))
font = pygame.font.Font(None, 20)
text = font.render("Lives: " + str(lives), 1, (250, 250, 250))
background.blit(text, (int(size[0]-70), int(10)))
if daisy_call > 0 and daisy_call < 150:
font = pygame.font.Font(None, 25)
text = font.render("HELP!", 1, (250, 250, 250))
background.blit(text, (360, 10))
daisy_call += 1
if daisy_call >= 300:
daisy_call = 0
if mario_status == False:
font = pygame.font.Font(None, 40)
text = font.render("FAILED", 1, (250, 0, 0))
background.blit(text, (int(size[0]/2), int(size[1]/2)))
game_state = False
global lives
lives -= 1
elif mario_status == 10:
items = []
elif type(mario_status) == tuple:
rolling_barrels.pop(mario_status[1])
elif mario_status == "Done":
font = pygame.font.Font(None, 40)
text = font.render("Level Complete", 1, (0, 250, 0))
background.blit(text, (int(size[0]/2)-60, int(size[1]/2)))
game_state = False
global lives
lives = 3
global speed
speed -= 100
game_state = False
screen.blit(background, (0, 0))
pygame.display.flip()
