def __init__(self, user, kit, turn):
self.user = user
if kit == 0:
self.kit = hero.Hero("Knight", 6, 1, 12, [1, 1, 1, 1, 1, 1], [0, 0, 0, 0], 12)
elif kit == 1:
self.kit = hero.Hero("Paladin", 4, 2, 17, [0.8, 0.8, 0.8, 0.8, 0.8, 0.8], [0, 0, 0, 0], 17)
elif kit == 2:
self.kit = hero.Hero("Wizard", 2, 5, 10, [1, 1, 1, 1, 1, 1], [0, 0, 0, 0], 10)
elif kit == 3:
self.kit = hero.Hero("Archer", 7, 1, 7, [1, 1, 1, 1, 1, 1], [0, 0, 0, 0], 7)
self.turn = turn
def __init__(self, width=640, height=480):
pygame.init()
self.width = width
self.height = height
self.screen = pygame.display.set_mode((self.width, self.height))
self.background = pygame.Surface(self.screen.get_size()).convert()
"""Load the sprites that we need"""
self.enemies = []
for i in range(3):
x = random.randrange(100, 400)
y = random.randrange(100, 400)
self.enemies.append(hero.Hero("Boogie", x, y, 'enemy.png'))
self.hero = hero.Hero("Conan", 50, 50, "hero.png")
self.sprites = pygame.sprite.Group((self.hero, ) + tuple(self.enemies))
def test_dungeon_move_fight(self):
self.hero = hero.Hero("Bron", 200, 'DragonSlayer')
self.orc = orc.Orc("Grom", 100, 2)
self.weapon = weapon.Weapon("Axe", 10, 0.5)
self.hero.equip_weapon(self.weapon)
self.orc.equip_weapon(self.weapon)
self.dungeon.spawn("player_1", self.hero)
self.dungeon.spawn("player_2", self.orc)
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "down"))
self.assertTrue(self.dungeon.move("player_1", "down"))
self.assertTrue(self.dungeon.move("player_1", "down"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "up"))
self.assertTrue(self.dungeon.move("player_1", "up"))
self.assertTrue(self.dungeon.move("player_1", "up"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "right"))
self.assertTrue(self.dungeon.move("player_1", "down"))
self.assertTrue(self.dungeon.move("player_1", "down"))
self.assertTrue(self.dungeon.move("player_1", "down"))
self.assertTrue(self.dungeon.move("player_1", "down"))
def makeHero(self):
h = hero.Hero(self.heroes,
random.choice(NAMES),
heroclass=random.choice(CLASSES),
race=random.choice(RACES))
self.heroes = self.heroes + 1
return h
def __init_hero(self):
"""
初始化英雄
:return:
"""
self.hero = hero.Hero()
self.add_sprite(self.hero)
def __init__(self):
Game.screen_width = database.Database.screen_width
Game.screen_height = database.Database.screen_height
Game.highscore = database.Database.highscore
self.score = 0
self.run = True
self.pause = False
self.game_over = False
self.frame_counter = 0
self.abilities_recharge = 0
self.difficulty_spawn = database.Database.spawn_rate_on_start
self.window = None
self.background = None
self.bullets = []
self.knights = []
self.copters = []
self.bombs = []
self.player = hero.Hero()
#############
self.window = pygame.display.set_mode(
(Game.screen_width, Game.screen_height))
# self.cop_ai = copterai.AI()
pygame.display.set_caption("Game by Meleron")
images.Images()
self.launch_game()
def __init__(self):
#flagi bohatera - byc moze powinny byc utworzone w bohaterze
self.at_work = False
self.at_rest = False
self.at_adventure = False
self.at_camp = False
#referencja do bohatera
self.bohater = hero.Hero("Qw")
#tablica na przygody i prace aktualne i ukonczone
self.current_adventure = Adventure([Decimal(0),Decimal(0),Decimal(0),Decimal(0)])
self.current_work = Work([Decimal(0),Decimal(0),Decimal(0),Decimal(0)])
self.rest = Rest()
self.camp = Camp()
self.completedAdventures = []
self.completedWorks = []
self.preparedAdventures = []
self.completedWorks = []
#timer
self.clock_started = False
self.continue_clock = False
self.drop_timers = 0
self.seconds = 0
self.gui = Inter(self)
self.gui.mainloop()
def test_spawn_hero(self):
jax = hero.Hero("Jax", 150, "Killer")
self.assertTrue(self.summoners_rift.spawn("Galin", jax))
urgot = orc.Orc("Urgot", 200, 1.6)
self.assertTrue(self.summoners_rift.spawn("Emil", urgot))
sion = orc.Orc("Sion", 432, 2.6)
self.assertFalse(self.summoners_rift.spawn("Sion", sion))
def initialize_world(self):
self.log.info('Adding initial elements to world.')
self.pfm = floor.PlatformManager()
self.add_widget(self.pfm)
self.pfm.add_ground_platform(pos=(0, 0), size=(BLOCK_SIZE*10, BLOCK_SIZE), num_blocks=10, block_type='question_block')
self.pfm.add_hit_block(pos=(BLOCK_SIZE*9, BLOCK_SIZE*3), size=(BLOCK_SIZE, BLOCK_SIZE), block_type='yellow_block')
self.pfm.add_floating_platform(pos=(BLOCK_SIZE*10, BLOCK_SIZE*3), size=(BLOCK_SIZE*5, BLOCK_SIZE*2), uvsize=(5,2), block_type='yellow_block')
self.im = item.ItemManager()
self.add_widget(self.im)
self.im.add_feather(pos=(300, 300), size=(BLOCK_SIZE, BLOCK_SIZE), type='feather')
self.im.add_feather(pos=(600, 500), size=(BLOCK_SIZE, BLOCK_SIZE), type='feather')
mario = hero.Hero(pos=(BLOCK_SIZE, BLOCK_SIZE), size=(BLOCK_SIZE*2, BLOCK_SIZE*2.5))
ground = floor.GroundPlatform(pos=(0, 0), size=(BLOCK_SIZE*10, BLOCK_SIZE), num_blocks=10, block_type='question_block')
hitblock = floor.HitBlock(pos=(BLOCK_SIZE, BLOCK_SIZE), size=(BLOCK_SIZE, BLOCK_SIZE), block_type='yellow_block')
koopa = enemy.Koopa()
pipe = feature.Pipe()
self.add_widget(mario)
self.add_widget(ground)
self.add_widget(hitblock)
self.add_widget(koopa)
self.add_widget(pipe)
self.log.info('Done adding initial elements to world.')
self.input_controller.bring_touchscreen_components_to_front()
def start_the_game():
clock = pygame.time.Clock()
score = Score(display)
rocketa = hero.Hero()
# enemy = rocket.Rocket(rocketa, display, 1000, 700)
# enemy2 = rocket.Rocket(rocketa, display, 100, 100)
coin = bonus.Bonus(display, rocketa, 10)
coin_list = []
enemy_list = []
coin_counter = 0
time_start = pygame.time.get_ticks()
run = True
while run:
if pygame.time.get_ticks() % 1500 == 0:
enemy_list.append(
rocket.Rocket(rocketa, display,
random.randint(-200, const.width_display + 50),
random.randint(-200, const.height_display + 50)))
clock.tick(const.FPS)
rocketa.change_xy()
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
keys = pygame.key.get_pressed()
display.blit(const.bg, (0, 0))
if keys[pygame.K_LEFT]:
rocketa.go_left()
rocketa.rotate_left()
elif keys[pygame.K_RIGHT]:
rocketa.go_right()
rocketa.rotate_right()
else:
rocketa.rect()
if keys[pygame.K_ESCAPE]:
menu.Pause()
if coin.check():
coin_counter += 1
# enemy.is_collision()
# enemy2.is_collision()
for i in enemy_list:
i.enemy_change_xy()
i.is_collision()
coin.update()
score.score_update(coin_counter)
# enemy.enemy_change_xy()
# enemy2.enemy_change_xy()
pygame.display.flip()
def test_simulate_fight(self):
hero1 = hero.Hero("Hero", 100, "WOW")
orc1 = orc.Orc("Orc", 20, 1.5)
sword = entity.Weapon("sword", 20, 0.4)
hero1.equip_weapon(sword)
fight1 = fight.Fight(hero1, orc1)
winner = fight1.simulate_fight()
self.assertEqual("Hero", winner)
def launch(self, audio, settings, summary):
self.hiscores.hiscores_read(settings)
self.player = hero.Hero(self.space_width // 2,
self.space_height // 3 * 2)
self.img_bg = self.pygame.image.load(settings.system['title_img'])
self.img_bg.set_palette(settings.system['palettes'][0])
audio.play_music('menu')
def __init__(self) -> None:
super().__init__()
self.world = World()
self.hero = hero.Hero(self.world)
self.current_level = self.hero.room.level
self.hero.register(self) # Look for the hero status
self._events = []
self.look()
def set_hero(self):
"""Create hero"""
self.hero = hero.Hero()
self.hero.rect.x = self.viewport.x + 110
self.hero.rect.bottom = 560
self.pers = pygame.sprite.Group(self.hero)
self.info_coin = Info_coin()
self.info_hearts = Info_hearts()
self.info = pygame.sprite.Group(self.info_coin, self.info_hearts)
def test_move(self):
jax = hero.Hero("Jax", 150, "Killer")
self.summoners_rift.spawn("Galin", jax)
self.summoners_rift.move("Galin", "right")
self.summoners_rift.move("Galin", "down")
self.summoners_rift.move("Galin", "down")
#self.summoners_rift.move("Galin", "down")
urgot = orc.Orc("Emil", 200, 1.6)
self.summoners_rift.spawn("Emil", urgot)
self.summoners_rift.move("Emil", "up")
def setUp(self):
self.sword = weapon.Weapon("Oathkeeper", 85, 0.1)
self.axe = weapon.Weapon("Mighty Axe", 30, 0.2)
self.crackhag_orc = orc.Orc("Crackhag", 120, True, 120, 1.5)
self.bron_hero = hero.Hero("Bron", 120, "DragonSlayer", True, 120)
self.crackhag_orc.equip_weapon(self.sword)
self.bron_hero.equip_weapon(self.axe)
self.battle = fight.Fight(self.bron_hero, self.crackhag_orc)
def test_fight_in_dungeon(self):
jax = hero.Hero("Jax", 3000, "Killer")
urgot = orc.Orc("Emil", 2000, 1.3)
self.summoners_rift.spawn("Galin", jax)
self.summoners_rift.spawn("Emil", urgot)
self.summoners_rift.move("Galin", "right")
self.summoners_rift.move("Galin", "down")
self.summoners_rift.move("Galin", "down")
self.summoners_rift.move("Emil", "left")
self.summoners_rift.move("Galin", "down")
self.summoners_rift.print_map()
def test_move_hero(self):
good_hero = hero.Hero("Sebastian", 100, "The great")
self.assertTrue(self.my_map.spawn("The Great", good_hero))
# self.my_map.print_map()
bad_orc = orc.Orc("Mudagog", 100, 1.4)
self.assertTrue(self.my_map.spawn("The Badass", bad_orc))
# self.my_map.print_map()
self.assertFalse(self.my_map.move("The Great", "up"))
self.assertFalse(self.my_map.move("The Great", "left"))
self.assertTrue(self.my_map.move("The Badass", "up"))
self.assertFalse(self.my_map.move("The Badass", "right"))
self.my_map.print_map()
def __init__(self, stdscr, name):
self.monsters = []
self.hero = hero.Hero(0, 0, 1)
self.items = []
self.level_num = 0
self.gold = 0
self.title = ""
self.level = []
self.rooms = []
self.hidden = [[True] * 80 for i in range(22)]
self.game_over = False
self.stdscr = stdscr
self.name = name
self.game_over_screen = game_over_screen.game_over_screen(self)
def __init__(self, list_moving, screen):
self.x = 10
self.y = 10
self.figure = hero.Hero(self.x, self.y)
self.list_moving = list_moving
self.state_moving = 0
self.state_part = 0
self.xvel = 0
self.yvel = 0
self.last_time = time.time()
self.dt = 0
self.screen = screen
self.game_loop = True
self.pred_v = 0
self.WIN_WIDTH = screen.get_width()
self.WIN_HEIGHT = screen.get_height()
def __init__(self,width,height):
self.envShop = environment.ShopScene(width,height)
self.envAction = environment.ActionScene(width,height,5,5)
self.mWidth = width
self.mHeight = height
self.GameOver = False
self.HeroWins = False
self.Right = False
self.Left = False
self.walkcount = 0
self.isJump = False
self.jumpCount = 10
self.velocity = 5
self.mX = 50
self.mY = 400
self.mObjWidth = 40
self.mObjHeight = 60
self.mHero = hero.Hero(40,532,1,1,width,height,2)
self.mBullet = []
def main():
""" Le main """
# déclaration du plateau
plateau0 = plateau.Plateau()
# Objets à ramasser
liste_objets_aramass = []
for elt_dict in config.OBJETS_ARAMASSER:
liste_objets_aramass.append(
objramasse.ObjetRamasse(plateau0, elt_dict['nom']))
# déclaration du reste de la structure
hero0 = hero.Hero(plateau0)
sortie0 = sortie.Sortie(plateau0)
gardien0 = gardien.Gardien(plateau0)
mode_console = mgconsole.ModeConsole()
mode_pygame = mgpygame.ModePygame()
# Acceuil du jeu
input_demarrage = input(
" Bienvenu dans McGyver Labyrinthe game \n Entrez 'c' pour "
"jouer en mode console\n Entrez 'p' pour jouer en mode "
"pygame ( recommandé ) \n Entrez 'q' pour quitter\n ")
while (input_demarrage not in ['c', 'p', 'q']):
input_demarrage = input(
" Bienvenu dans McGyver Labyrinthe game \n Entrez 'c' pour "
"jouer en mode console\n Entrez 'p' pour jouer en mode "
"pygame ( recommandé ) \n Entrez 'q' pour quitter\n ")
if input_demarrage == 'c':
mode_console.start(hero0, liste_objets_aramass, gardien0, sortie0,
plateau0)
elif input_demarrage == 'p':
mode_pygame.start(hero0, liste_objets_aramass, gardien0, plateau0)
elif input_demarrage == 'q':
pass
def __init__(self, state):
all_sprites.empty()
ui_sprites.empty()
lobby_sprites.empty()
self.state = state
self.camera = Vector2(0, 0)
self.screen = pygame.display.set_mode([screen_width, screen_height])
self.background_surface = pygame.Surface([screen_width, screen_height])
self.running = True
self.level = "none"
self.GAME_FONT = pygame.freetype.Font("Assets/Fonts/Oswald-Bold.ttf",
128)
self.MENU_FONT = pygame.freetype.Font("Assets/Fonts/Oswald-Bold.ttf",
96)
self.DIAGNOSTICS_FONT = pygame.freetype.Font(
"Assets/Fonts/Oswald-Bold.ttf", 12)
# create a sprite group to hold all sprites
self.forest_level_icon = levelicon.LevelIcon(1500, 1200, "Forest")
self.swamp_level_icon = levelicon.LevelIcon(1300, 1200, "Swamp")
self.mountain_level_icon = levelicon.LevelIcon(1100, 1200, "Mountain")
self.mergamoth_level_icon = levelicon.LevelIcon(1300, 800, "Mergamoth")
lobby_sprites.add(self.forest_level_icon)
lobby_sprites.add(self.swamp_level_icon)
lobby_sprites.add(self.mountain_level_icon)
lobby_sprites.add(self.mergamoth_level_icon)
# create our first game objects/sprites as a test
self.hero = hero.Hero(screen_width, screen_height)
self.hero.is_moving = False
self.hero.is_dead = False
self.time_of_death = 100000000000000000
# add all sprites to the group
lobby_sprites.add(self.hero)
self.forest_level = None
self.mountain_level = None
self.swamp_level = None
self.mergamoth_level = None
def makeHeroes(self, cursor):
heroes = []
for heroID, name, level, exp, stre, agi, con, wis, inte, hp, mana, currenthp, currentmana, meleeEquipment, rangedEquipment, armorEquipment, shieldEquipment, playerID, race, activeClass in cursor:
h = hero.Hero(heroID, name, CLASSES[activeClass], RACES[race])
h.level = level
h.exp = exp
h.strength = stre
h.agi = agi
h.con = con
h.wis = wis
h.inte = inte
h.playerID = playerID
h.maxhp = hp
h.maxMana = mana
h.currenthp = currenthp
h.currentMana = currentmana
h.meleeWeapon = MELEE_WEAPONS[meleeEquipment]
h.rangedWeapon = RANGED_WEAPONS[rangedEquipment]
h.armor = ARMOR[armorEquipment]
h.shield = SHIELDS[shieldEquipment]
h.race = RACES[race]
h.activeHeroClass = CLASSES[activeClass]
heroes.append(h)
return heroes
class Game:
level_of_difficulty = 1
monsters_slayed = 0
rooms_cleared = 0
room_gen = None
actions_taken = 0
hero = hero.Hero()
def __init__(self):
self.set_level_of_difficulty()
self.room_gen = (Room(self.level_of_difficulty) for i in range(5))
def set_level_of_difficulty(self):
lvl = None
while lvl is None:
lvl = input(
'Please select your level of difficulty:\n1: Easy\n2: Normal\n3: Hard\n'
)
if lvl.isdigit():
lvl = int(lvl)
if lvl == 1:
self.level_of_difficulty = 1
elif lvl == 2:
self.level_of_difficulty = 2
elif lvl == 3:
self.level_of_difficulty = 3
else:
lvl = None
else:
lvl = None
def reset_game(self):
self.monsters_slayed = 0
self.rooms_cleared = 0
self.actions_taken = 0
self.hero.hit_points = 50
self.room_gen = (Room(self.level_of_difficulty) for i in range(5))
def game_over(self):
print("Game over!")
self.print_game_stats()
play_again = yes_no_response("Play again? (Y\\n)\n")
if play_again:
self.reset_game()
self.clear_rooms()
else:
sys.exit(0)
def print_game_stats(self):
print('Total monsters slayed: {0}\n'
'Total rooms cleared: {1}\n'
'Total actions taken: {2}'.format(self.monsters_slayed,
self.rooms_cleared,
self.actions_taken))
def kill_monster(self):
self.monsters_slayed += 1
def room_cleared(self):
self.rooms_cleared += 1
def clear_rooms(self):
"""
Moves the player through the rooms of the dungeon. At the beginning of each room it will print the number
of monsters present.
:return: None
"""
room_text()
for room in self.room_gen:
if yes_no_response("Proceed to next room? (Y\\n)\n"):
pass
else:
break
# TODO figure out something better to do if they choose not to go to the next room
if room.num_of_monsters == 0:
print('No monsters here!')
self.room_cleared()
elif room.num_of_monsters == 1:
print(
"There is 1 monster in this room! Looks like it's time to fight!"
)
self.battle(room)
else:
print("Oh no! There are {} monsters in this room! "
"Looks like it's time to fight!".format(
room.num_of_monsters))
self.battle(room)
# TODO add a check_powerups call - also write check_powerups
print("Congratulations! All rooms cleared!")
self.game_over()
def battle(self, room):
"""
Controls the battle between a player and all of the monsters in the room.
:param room: The current room that the player is in
:return: None
"""
for monster in room.monsters:
print("It's a {}!".format(monster))
while self.hero.hit_points > 0 and monster.hit_points > 0:
action = self.get_player_action()
if action == 'attack':
self.resolve_attack(monster)
elif action == 'defend':
print("You blocked the monster's blow.")
if self.hero.hit_points > 0:
print("You've defeated the {}!".format(monster))
self.monsters_slayed += 1
else:
self.game_over()
print("All monsters have been defeated!")
self.room_cleared()
def get_player_action(self):
"""
Get the action that the player wants to perform: attack, defend, or quit
:return: None
"""
action = None
while action is None:
action = input(
"Choose an action:\n1: Hit\n2: Defend\n3: Give up and print game stats\n"
)
if action.isdigit():
action = int(action)
if action == 1:
self.actions_taken += 1
return "attack"
elif action == 2:
self.actions_taken += 1
return "defend"
elif action == 3:
self.game_over()
break
else:
action = None
else:
action = None
def resolve_attack(self, monster):
"""
If the player chooses to attack, determine which creature does damage
:param monster: The current monster the player is battling
:return: None
"""
h_attack = random.randint(1, 6)
m_attack = random.randint(1, 6)
if h_attack >= m_attack:
monster.hit_points -= self.hero.damage()
print("The {} has {} health left.".format(monster,
monster.hit_points))
else:
self.hero.hit_points -= monster.damage()
print("You have {} health left.".format(self.hero.hit_points))
Requirments
Adhere to PEP8 and utilize proper and efficient code
Utilize a __init__()
Ensure variables are correct type (class vs instance variables)
Utilize methods:
Start to format your class using getters and setters
Create an instance of your class. Populate it with data utilzing a init
and/or getters and setters
Additional:
Begin using encapsulation techniques
"""
import hero
import villian
a = hero.Hero()
b = villian.Villian()
c = hero.wol
user_hero = hero.Hero()
user_villian = villian.Villian()
user_created1 = 0
user_created2 = 0
print("Default Hero")
hero.Hero.default(a)
print("Defualt Villian")
villian.Villian.default(b)
c.default()
print("Would you like to create a new hero?")
user_input = raw_input("(Y/N)\n").lower()
create_new = 0
while (create_new == 0):
import hero, scene, locations
Player = hero.Hero()
playerScene = scene.Scene()
print("Welcome, adventurer!")
print("Choose a class to begin the game: ")
print()
Player.chooseClass()
print()
### Game loop
while(True):
print("# # # # # # # #")
cmd = input("NEW TURN --> Enter your next move: ")
cmdList = cmd.split()
### Do stuff
if(cmd == "getStats"):
print("You are a Level " + str(Player.playerLevel) + " " + Player.playerClass)
print()
print("Your current attributes: ")
print(Player.attributes)
elif(cmd == "getInventory"):
print(Player.inventory)
elif(len(cmdList) == 2 and cmdList[0] == "move"):
success = playerScene.navigate(cmdList[1])
if(success):
def main():
pygame.init() # инициация PyGame
screen = pygame.display.set_mode(DISPLAY)
pygame.display.set_caption("Super Mario Boy")
BACKGROUND = pygame.image.load(os.path.join('fon', '0.jpg')).convert()
timer = pygame.time.Clock()
level = [
"--------------------------------------",
"- -",
"- -- - -",
"- -",
"- -- -",
"- - -",
"-- ------ -",
"- Z -",
"- - ---- --- -",
"- -",
"-- -- -- -",
"- -- -",
"- --- -",
"- -- -- -",
"- -- ---",
"- --- * -",
"- * -",
"- ------- ---- -",
"- -",
"- - -",
"-- -- -",
"---- * -",
"- -",
"--------------------------------------"
]
player = hero.Hero(40, 50) # создаем персонажа по (x,y) координатам
left = right = False # по умолчанию — стоим
up = False
player2 = hero.Hero(70, 40)
entities = pygame.sprite.Group() # все объекты
platforms = [] # проверка на поверхность
entities.add(player)
entities.add(player2)
animatedEntities = pygame.sprite.Group(
) # все анимированные объекты, за исключением героя
tp = blocks.BlockTeleport(128, 512, 800, 64)
entities.add(tp)
platforms.append(tp)
animatedEntities.add(tp)
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!#
x = y = 0 # координаты
for row in level: # вся строка
for col in row: # каждый символ
if col == "-":
pf = blocks.Platform(x, y)
entities.add(pf)
platforms.append(pf)
if col == "*":
bd = blocks.BlockDie(x, y)
entities.add(bd)
platforms.append(bd)
if col == "Z":
pr = blocks.Emblem(x, y)
entities.add(pr)
platforms.append(pr)
animatedEntities.add(pr)
x += PLATFORM_WIDTH #блоки платформы ставятся на ширине блоков
y += PLATFORM_HEIGHT #то же самое и с высотой
x = 0
total_level_width = len(
level[0]) * PLATFORM_WIDTH # Высчитываем фактическую ширину уровня
total_level_height = len(level) * PLATFORM_HEIGHT # высоту
camera = Camera(camera_configure, total_level_width, total_level_height)
TimeFor = time.time()
ff = True
running = False
NFOn = 1
Nmonsters = pygame.sprite.Group() # Все передвигающиеся объекты
mn1 = monsters.Monster(190, 200, 2, 2, 150, 15)
mn2 = monsters.Monster(344, 511, 0, 1, 0, 150)
entities.add(mn1)
platforms.append(mn1)
Nmonsters.add(mn1)
entities.add(mn2)
platforms.append(mn2)
Nmonsters.add(mn2)
pygame.joystick.init()
while not player.winner: # основной цикл программы
timer.tick(60)
if time.time() - TimeFor > 5:
if NFOn < 8:
BACKGROUND = RFon(NFOn)
TimeFor = time.time()
NFOn += 1
else:
NFOn = 0
BACKGROUND = RFon(NFOn)
TimeFor = time.time()
for e in pygame.event.get(): # обрабатываем события
if e.type == pygame.QUIT:
sys.exit()
if e.type == pygame.KEYDOWN and e.key == pygame.K_LEFT:
left = True
if e.type == pygame.KEYDOWN and e.key == pygame.K_RIGHT:
right = True
if e.type == pygame.KEYUP and e.key == pygame.K_RIGHT:
right = False
if e.type == pygame.KEYUP and e.key == pygame.K_LEFT:
left = False
if e.type == pygame.KEYDOWN and e.key == pygame.K_UP or e.type == pygame.JOYBUTTONDOWN:
up = True
if e.type == pygame.KEYUP and e.key == pygame.K_UP or e.type == pygame.JOYBUTTONUP:
up = False
if e.type == pygame.KEYDOWN and e.key == pygame.K_LSHIFT:
running = True
if e.type == pygame.KEYUP and e.key == pygame.K_LSHIFT:
running = False
screen.blit(BACKGROUND,
(0, 0)) # каждую итерацию необходимо всё перерисовывать
#на каждой новой строчке начинаем с нуля
camera.update(player)
player.update(left, right, up, running, platforms)
# player2.update(left,right, up, platforms)
#player.draw(screen)
#player.collide(screen)
#entities.draw(screen)
for e in entities:
screen.blit(e.image, camera.apply(e))
animatedEntities.update() # показываем анимацию
Nmonsters.update(platforms) # передвигаем всех монстров
pygame.display.update() # обновление и вывод всех изменений на экран
def setUp(self):
self.hero = hero.Hero('Konan', 100, 'Barbarian')
def setUp(self):
self.bron_hero = hero.Hero("Bron", 100, "DragonSlayer")
