def test_start_position(self):
choice1 = "1"
choice2 = "2"
choice3 = "3"
choice4 = "4"
grid_size = 4
expected_result1 = (0, 0)
expected_result2 = (0, grid_size - 1)
expected_result3 = (grid_size - 1, 0)
expected_result4 = (grid_size - 1, grid_size - 1)
room = classes.Rooms()
room_list = [room]
hero = classes.Hero("Orvar", "Riddare")
actual_result1 = main.start_position(choice1, grid_size, room_list,
hero)
actual_result2 = main.start_position(choice2, grid_size, room_list,
hero)
actual_result3 = main.start_position(choice3, grid_size, room_list,
hero)
actual_result4 = main.start_position(choice4, grid_size, room_list,
hero)
self.assertEqual(expected_result1, actual_result1)
self.assertEqual(expected_result2, actual_result2)
self.assertEqual(expected_result3, actual_result3)
self.assertEqual(expected_result4, actual_result4)
def test_update_player_coordinates(self):
test_character = classes.Hero('Orvar', 'Knight')
old_coordinates = (0, 0)
new_coordinates = (0, 3)
self.assertEqual(old_coordinates, test_character.coordinates)
test_character.update_coordinates(new_coordinates)
self.assertEqual(new_coordinates, test_character.coordinates)
def test_wizard_initiation(self):
test_character = classes.Hero('Orvar', 'Wizard')
expected_result = 0
self.assertEqual(expected_result, test_character.initiative)
test_character.add_wizard()
expected_result_1 = 6
expected_result_2 = 4
expected_result_3 = 9
expected_result_4 = 5
self.assertEqual(expected_result_1, test_character.initiative)
self.assertEqual(expected_result_2, test_character.resistance)
self.assertEqual(expected_result_3, test_character.attack)
self.assertEqual(expected_result_4, test_character.agility)
def test_thief_initiation(self):
test_character = classes.Hero('Orvar', 'Thief')
expected_result = 0
self.assertEqual(expected_result, test_character.initiative)
test_character.add_thief()
expected_result_1 = 7
expected_result_2 = 5
expected_result_3 = 5
expected_result_4 = 7
self.assertEqual(expected_result_1, test_character.initiative)
self.assertEqual(expected_result_2, test_character.resistance)
self.assertEqual(expected_result_3, test_character.attack)
self.assertEqual(expected_result_4, test_character.agility)
def test_knight_initiation(self):
test_character = classes.Hero('Orvar', 'Knight')
expected_result = 0
self.assertEqual(expected_result, test_character.initiative)
test_character.add_knight()
expected_result_1 = 5
expected_result_2 = 9
expected_result_3 = 6
expected_result_4 = 4
self.assertEqual(expected_result_1, test_character.initiative)
self.assertEqual(expected_result_2, test_character.resistance)
self.assertEqual(expected_result_3, test_character.attack)
self.assertEqual(expected_result_4, test_character.agility)
def choose_character(character_name):
while True:
clear_screen()
new_game_text(character_name)
print("\n[1] - Riddaren\n" "[2] - Trollkarlen\n" "[3] - Tjuven")
character_choice = input("\nVälj karaktär: ")
if character_choice == "1":
hero = classes.Hero(character_name, "Riddare")
hero.add_knight()
return hero
elif character_choice == "2":
hero = classes.Hero(character_name, "Trollkarl")
hero.add_wizard()
return hero
elif character_choice == "3":
hero = classes.Hero(character_name, "Tjuv")
hero.add_thief()
return hero
else:
print("\n-- Felaktig input, ange en siffra från menyn. --")
input('-- Tyck på enter för att fortsätta --')
count_tutorial = 0 count_menu = 0 count_rastart_mode = '' count_rastart = 0 # данные, нужные для более универсального # представления персонажей на разных мониторах width_mob = x_mobs = width // 45 y_mobs = height // 2 height_mob = height // 5 speed_mob = 700 # объекты движующиеся enemy = classes.Enemy(x_mobs, y_mobs, width_mob, height_mob, speed_mob) hero = classes.Hero(width - x_mobs * 2, y_mobs, width_mob, height_mob, speed_mob) hero_2 = classes.Hero(x_mobs, y_mobs, width_mob, height_mob, speed_mob) ball = classes.Ball((400, 560), screen, 35, hero, enemy, hero_2) enemy.add_ball(ball) # объекты дисплейные background = classes.DrawBackground() sprite_tutorial = classes.tutorial_sprite() sprite_menu = classes.menu_sprite() restart_sprite = classes.restart_sprite() # подравнивание меню под экран classes.transforms(sprite_tutorial, width, height) classes.transforms(sprite_menu, width, height) for i in restart_sprite:
def go(match):
game = classes.Game()
game.properties = {
"seed": match[2],
"block": match[0],
"recipient": match[3],
"amount": match[4],
"league": match[11]
}
game.start_block = game.properties["block"]
game.recipient = game.properties["recipient"]
game.bet = game.properties["amount"]
game.current_block = game.start_block
game.seed = game.properties["seed"]
game.hash = blake2b(
(game.properties["seed"] + str(game.properties["block"])).encode(),
digest_size=10).hexdigest()
if game.recipient == coordinator and game.bet >= league_requirement:
game.league = game.properties["league"]
else:
game.league = "casual"
game.filename_temp = "static/replays/unfinished/" + str(game.hash +
".json")
game.filename = "static/replays/" + str(game.hash + ".json")
def db_output():
if not game.finished:
scores_db.c.execute("DELETE FROM unfinished WHERE hash = ?",
(game.hash, )) # remove temp entry if exists
scores_db.c.execute(
"INSERT INTO unfinished VALUES (?,?,?,?,?,?,?)", (
game.properties["block"],
game.hash,
game.seed,
hero.experience,
json.dumps(hero.inventory),
game.league,
game.bet,
))
scores_db.conn.commit()
elif game.finished and not game.replay_exists:
scores_db.c.execute("DELETE FROM unfinished WHERE hash = ?",
(game.hash, )) # remove temp entry if exists
scores_db.c.execute("INSERT INTO scores VALUES (?,?,?,?,?,?,?)", (
game.properties["block"],
game.hash,
game.seed,
hero.experience,
json.dumps(hero.inventory),
game.league,
game.bet,
))
scores_db.conn.commit()
def output(entry):
game.step += 1
print(entry)
game.story[game.step] = entry
def replay_save():
if not os.path.exists("static"):
os.mkdir("static")
if not os.path.exists("static/replays"):
os.mkdir("static/replays")
if not os.path.exists("static/replays/unfinished"):
os.mkdir("static/replays/unfinished")
if game.finished and not game.replay_exists:
if os.path.exists(game.filename_temp):
os.remove(game.filename_temp)
with open(game.filename, "w") as file:
file.write(json.dumps(game.story))
elif not game.finished:
with open(game.filename_temp, "w") as file:
file.write(json.dumps(game.story))
if os.path.exists(game.filename):
game.finished = True
game.quit = True
game.replay_exists = True
output(f"Replay for {game.hash} already present, skipping match")
hero = classes.Hero()
#trigger is followed by events affected by modifiers
#define events
EVENTS = {
game.properties["seed"][2:4]: "attack",
game.properties["seed"][4:6]: "attacked",
game.properties["seed"][6:8]: "attack_critical"
}
#define triggers
triggers_combat = {
"4f": "troll",
"df": "goblin",
"5a": "berserker",
"61a": "dragon"
}
triggers_peaceful = {"3d": "health_potion", "69a": "armor", "70b": "sword"}
triggers_human_individual = {"item:chaos_ring": "chaos_ring"}
triggers_human_global = {"event:rangarok": "ragnarok"}
def enemy_dead_check():
if enemy.health < 1:
hero.in_combat = False
enemy.alive = False
output(f"{enemy.name} died")
output(f"You now have {hero.experience} experience")
def hero_dead_check():
if hero.health < 1:
hero.alive = False
game.finished = True
output(f"You died with {hero.experience} experience")
def enemy_define(event):
if event == "troll":
enemy = classes.Troll()
elif event == "goblin":
enemy = classes.Goblin()
elif event == "berserker":
enemy = classes.Berserker()
elif event == "dragon":
enemy = classes.Dragon()
elif event == "fenrir": #only triggers on ragnarok
enemy = classes.Fenrir()
elif event == "dwarf": #only triggers on ragnarok
enemy = classes.Dwarf()
else:
enemy = None
return enemy
def chaos_ring():
if not hero.inventory["ring"]:
output(
f'You see a chaos ring, the engraving says {subcycle["cycle_hash"][0:5]}'
)
if subcycle["cycle_hash"][0] in [
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
]:
hero.inventory["ring"] = "ring_perseverance"
hero.full_hp = 650
if hero.health < hero.full_hp:
hero.health = hero.full_hp
output(
f"You slide the ring on your finger and immediately feel stronger"
)
else:
hero.inventory["ring"] = "ring_blight"
hero.full_hp = 350
if hero.health > hero.full_hp:
hero.health = hero.full_hp
output(
f"You slide the ring on your finger and your hands start to tremble"
)
def ragnarok():
output(f"Ragnarök begins")
# add new monsters to the world
triggers_combat["53b"] = "fenrir"
triggers_combat["4c"] = "dwarf"
def sword_get():
if not hero.inventory["weapon"]:
hero.inventory["weapon"] = "sword"
output(f"You obtained a sword")
def armor_get():
if not hero.inventory["armor"]:
hero.inventory["armor"] = "armor"
output(f"You obtained armor")
def attack():
hero.experience += 1
damage = hero.power
if hero.inventory["weapon"] == "sword":
damage += 10
enemy.health -= hero.power
output(
f"{enemy.name} suffers {damage} damage and is left with {enemy.health} HP"
)
enemy_dead_check()
def attack_critical():
hero.experience += 1
damage = hero.power + hero.experience
enemy.health -= damage
output(
f"{enemy.name} suffers {damage} *critical* damage and is left with {enemy.health} HP"
)
enemy_dead_check()
def cycle():
db.c.execute(
"SELECT * FROM transactions WHERE block_height = ? ORDER BY block_height",
(game.current_block, ))
result = db.c.fetchall()
position = 0
game.cycle = {} #remove previous cycle if exists
for tx in result:
position = position + 1
block_height = tx[0]
timestamp = tx[1]
address = tx[2]
recipient = tx[3]
amount = tx[4]
block_hash = tx[7]
operation = tx[10]
data = tx[11]
cycle_hash = blake2b((str(tx)).encode(),
digest_size=60).hexdigest()
game.cycle[position] = {
"block_height": block_height,
"timestamp": timestamp,
"address": address,
"recipient": recipient,
":amount": amount,
"block_hash": block_hash,
"operation": operation,
"data": data,
"cycle_hash": cycle_hash
}
def heal():
if hero.in_combat:
hero.health = hero.health + 5
output(f"You drink a potion and heal to {hero.health} HP...")
if hero.health > hero.full_hp:
hero.health = hero.full_hp
elif not hero.in_combat:
hero.health = hero.health + 15
if hero.health > hero.full_hp:
hero.health = hero.full_hp
output(f"You rest and heal well to {hero.health} HP...")
def attacked():
damage_taken = enemy.power
if hero.inventory["armor"] == "armor":
damage_taken -= 5
hero.health = hero.health - damage_taken
output(
f"{enemy.name} hits you for {enemy.power} HP, you now have {hero.health} HP"
)
hero_dead_check()
while hero.alive and not game.quit:
cycle()
if not game.cycle:
output("The game is still running")
game.quit = True
break
for subposition, subcycle in game.cycle.items(): #for tx in block
print(subcycle)
# human interaction
for trigger_key in triggers_human_individual:
trigger = triggers_human_individual[trigger_key]
if trigger_key == subcycle["data"] and subcycle[
"address"] == game.seed and subcycle[
"operation"] == "autogame:add":
if trigger == "chaos_ring":
chaos_ring()
for trigger_key in triggers_human_global:
trigger = triggers_human_global[trigger_key]
if trigger_key == subcycle["data"] and subcycle[
"operation"] == "autogame:add":
if trigger == "ragnarok":
ragnarok()
# human interaction
for trigger_key in triggers_peaceful:
if not hero.in_combat:
trigger = triggers_peaceful[trigger_key]
if trigger_key in subcycle["cycle_hash"]:
if trigger == "health_potion" and hero.health < hero.full_hp:
heal()
elif trigger == "armor":
armor_get()
elif trigger == "sword":
sword_get()
for trigger_key in triggers_combat:
if trigger_key in subcycle[
"cycle_hash"] and hero.alive and not hero.in_combat:
trigger = triggers_combat[trigger_key]
enemy = enemy_define(trigger)
output(
f"You meet {enemy.name} on transaction {subposition} of block {game.current_block}"
)
hero.in_combat = True
for event_key in EVENTS: #check what happened
if hero.in_combat and hero.alive and not game.quit:
if event_key in subcycle["cycle_hash"] and enemy.alive:
event = EVENTS[event_key]
output(f"Event: {event}")
if event == "attack":
attack()
elif event == "attack_critical":
attack_critical()
elif event == "attacked":
attacked()
game.current_block = game.current_block + 1
replay_save()
db_output()
return game, hero
def draw_sprites():
screen.fill(CONSTS.GREY)
cl.heros.draw(screen)
cl.plats.draw(screen)
cl.borders.draw(screen)
pg.display.flip()
running = True
pg.init()
width, height = size = [1080, 720]
screen = pg.display.set_mode(size)
hero = cl.Hero([0, 0], cl.heros)
platform = cl.Platform([0, 640], CONSTS.plat, cl.plats)
ADDEVENT = 10
pg.time.set_timer(ADDEVENT, 40)
pg.mouse.set_visible(True)
screen.fill(CONSTS.WHITE)
pg.display.flip()
clock = pg.time.Clock()
speed = 10
def go(match, iterator, coordinator, league_requirement=0):
game = classes.Game()
def game_saved():
try:
scores_db.c.execute(
"SELECT * FROM scores WHERE hash = ? AND saved = ? ", (
game.hash,
1,
))
result = scores_db.c.fetchone()[0]
return True
except:
return False
def game_finished():
try:
scores_db.c.execute(
"SELECT * FROM scores WHERE hash = ? AND finished = ? ", (
game.hash,
1,
))
result = scores_db.c.fetchone()[0]
return True
except:
return False
def db_output():
try:
output_weapon = hero.weapon.name
except:
output_weapon = None
try:
output_armor = hero.armor.name
except:
output_armor = None
try:
output_ring = hero.ring.name
except:
output_ring = None
if not game_finished():
scores_db.c.execute("DELETE FROM scores WHERE hash = ?",
(game.hash, ))
scores_db.c.execute(
"INSERT INTO scores VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",
(game.properties["block"], game.hash, game.seed,
hero.experience,
json.dumps({
"weapon": output_weapon,
"armor": output_armor,
"ring": output_ring
}), game.league, game.bet, json.dumps(
hero.damage_table), json.dumps(hero.defense_table),
game.current_block, game.finished, game.saved))
scores_db.conn.commit()
def output(entry):
game.step += 1
print(entry)
game.story[game.step] = entry
def replay_save():
if not os.path.exists("static"):
os.mkdir("static")
if not os.path.exists("static/replays"):
os.mkdir("static/replays")
if not game_saved() or not game_finished():
with open(game.filename, "w") as file:
file.write(json.dumps(game.story))
scores_db.c.execute(
"UPDATE scores SET saved = 1 WHERE hash = ?",
(game.hash, ))
scores_db.conn.commit()
game.saved = True
if not hero.alive:
game.finished = True
scores_db.c.execute(
"UPDATE scores SET finished = 1 WHERE hash = ?", (game.hash, ))
scores_db.conn.commit()
try:
assert ":" in match[11]
recipient = match[11].split(":")[1]
league = match[11].split(":")[0]
except:
recipient = match[2]
league = match[11]
try:
assert essentials.address_validate(recipient)
except:
recipient = match[2]
game.properties = {
"seed": recipient,
"block": match[0],
"recipient": match[3],
"amount": match[4],
"league": league
}
game.start_block = game.properties["block"]
game.recipient = game.properties["recipient"]
game.bet = game.properties["amount"]
game.current_block = game.start_block
game.seed = game.properties["seed"]
game.hash = blake2b(
(game.properties["seed"] + str(game.properties["block"])).encode(),
digest_size=10).hexdigest()
game.enemies = game.enemies
if game.recipient == coordinator and game.bet >= league_requirement:
game.league = game.properties["league"]
else:
game.league = "casual"
game.filename = "static/replays/" + str(game.hash + ".json")
hero = classes.Hero()
if game_finished():
game.quit = True
print(f"Game {game.hash} tagged as finished, skipping")
#trigger is followed by events affected by modifiers
#define events
EVENTS = {
game.properties["seed"][2:4]: "attack",
game.properties["seed"][4:6]: "attacked",
game.properties["seed"][6:8]: "attack_critical"
}
#define triggers
def enemy_dead_check():
if enemy.health < 1:
hero.in_combat = False
enemy.alive = False
output(f"{enemy.name} died")
output(f"You now have {hero.experience} experience")
def hero_dead_check():
if hero.health < 1:
hero.alive = False
output(f"You died with {hero.experience} experience")
def chaos_ring():
if not hero.ring:
output(
f'You see a chaos ring, the engraving says {subcycle["cycle_hash"][0:5]}'
)
if subcycle["cycle_hash"][0] in ["0", "1", "2", "3", "4"]:
hero.ring = classes.ChaosRing().roll_good()
else:
hero.ring = classes.ChaosRing().roll_bad()
hero.full_hp += hero.ring.health_modifier
if hero.health > hero.full_hp:
hero.health = hero.full_hp
output(hero.ring.string)
def ragnarok():
output(f"Ragnarök begins")
# add new monsters to the world
for enemy in classes.Game().enemies_ragnarok:
game.enemies.append(enemy)
def attack():
hero.experience += 1
damage = hero.damage
enemy.health -= hero.damage
output(
f"{enemy.name} suffers {damage} damage and is left with {enemy.health} HP"
)
enemy_dead_check()
def attack_critical():
hero.experience += 1
damage = hero.damage + hero.experience
enemy.health -= damage
output(
f"{enemy.name} suffers {damage} *critical* damage and is left with {enemy.health} HP"
)
enemy_dead_check()
def cycle():
db.c.execute(
"SELECT * FROM transactions WHERE block_height = ? ORDER BY block_height",
(game.current_block, ))
result = db.c.fetchall()
position = 0
game.cycle = {} #remove previous cycle if exists
for tx in result:
position = position + 1
block_height = tx[0]
timestamp = tx[1]
address = tx[2]
recipient = tx[3]
amount = tx[4]
block_hash = tx[7]
operation = tx[10]
data = tx[11]
cycle_hash = blake2b((str(tx)).encode(),
digest_size=60).hexdigest()
game.cycle[position] = {
"block_height": block_height,
"timestamp": timestamp,
"address": address,
"recipient": recipient,
":amount": amount,
"block_hash": block_hash,
"operation": operation,
"data": data,
"cycle_hash": cycle_hash
}
def attacked():
damage_taken = enemy.damage
if hero.armor:
damage_taken -= hero.defense
hero.health = hero.health - damage_taken
output(
f"{enemy.name} hits you for {enemy.damage} HP, you now have {hero.health} HP"
)
hero_dead_check()
while hero.alive and not game.quit:
cycle()
if not game.cycle:
output("The game is still running")
game.quit = True
break
for subposition, subcycle in game.cycle.items(): #for tx in block
#print (subcycle)
# human interaction
for item_interactive_class in classes.items_interactive:
if item_interactive_class(
).trigger == subcycle["data"] and subcycle[
"address"] == game.seed and subcycle[
"operation"] == game.interaction_string:
if item_interactive_class == classes.ChaosRing:
chaos_ring()
for events_interactive_global_class in classes.events_interactive_global:
if events_interactive_global_class(
).trigger == subcycle["data"] and subcycle[
"operation"] == game.interaction_string:
if events_interactive_global_class == classes.Ragnarok:
ragnarok()
# human interaction
if iterator == 2:
for pvp_class in game.pvp:
if pvp_class().trigger == subcycle["data"] and subcycle[
"operation"] == game.interaction_string and subcycle[
"recipient"] == game.seed and hero.pvp_interactions > 0:
attacker = subcycle["address"]
try:
scores_db.c.execute(
"SELECT damage FROM scores WHERE seed = ? AND block_start <= ? AND block_end >= ? ORDER BY block_start DESC LIMIT 1",
(
attacker,
game.current_block,
game.current_block,
))
enemy_damage_table = json.loads(
scores_db.c.fetchone()[0])
for enemy_damage_block, enemy_damage_value in enemy_damage_table.items(
):
if int(enemy_damage_block
) <= game.current_block:
enemy_damage = int(enemy_damage_value)
hero.health = hero.health - (enemy_damage -
hero.defense)
hero.pvp_interactions -= 1
hero_dead_check()
output(
f"Player {attacker} hits you and you lose {enemy_damage - hero.defense} health down to {hero.health}"
)
except Exception:
output(
f"Player {attacker} tried to attack you, but they failed"
)
for potion_class in game.potions:
if potion_class(
).trigger in subcycle["cycle_hash"] and not hero.in_combat:
if potion_class == classes.HealthPotion and hero.health < hero.full_hp:
if hero.in_combat:
hero.health = hero.health + classes.HealthPotion(
).heal_in_combat
output(
f"You drink a potion and heal to {hero.health} HP..."
)
elif not hero.in_combat:
hero.health = hero.health + classes.HealthPotion(
).heal_not_in_combat
output(
f"You rest and heal well to {hero.health} HP..."
)
if hero.health > hero.full_hp:
hero.health = hero.full_hp
for armor_class in game.armors:
if armor_class(
).trigger in subcycle["cycle_hash"] and not hero.in_combat:
if not hero.armor:
hero.armor = armor_class()
hero.defense += hero.armor.defense
hero.defense_table[game.current_block] = hero.defense
output(f"You obtained {armor_class().name}")
for weapon_class in game.weapons:
if weapon_class(
).trigger in subcycle["cycle_hash"] and not hero.in_combat:
if not hero.weapon:
hero.weapon = weapon_class()
hero.damage += hero.weapon.damage
hero.damage_table[game.current_block] = hero.damage
output(f"You obtained {weapon_class().name}")
for enemy_class in game.enemies:
if enemy_class().trigger in subcycle[
"cycle_hash"] and hero.alive and not hero.in_combat:
enemy = enemy_class()
output(
f"You meet {enemy.name} on transaction {subposition} of block {game.current_block}"
)
hero.in_combat = True
for event_key in EVENTS: #check what happened
if hero.in_combat and hero.alive and not game.quit:
if event_key in subcycle["cycle_hash"] and enemy.alive:
event = EVENTS[event_key]
output(f"Event: {event}")
if event == "attack":
attack()
elif event == "attack_critical":
attack_critical()
elif event == "attacked":
attacked()
game.current_block = game.current_block + 1
if iterator == 2: # db iteration finished, now save the story (player interactions serial, based on db)
replay_save()
db_output()
return game, hero
show_ether = True
# Initialize items count
count_item = 3
# Repeat move while arrow key is pressed
pygame.key.set_repeat(200, 200)
# Generate labyrinth by the file
show_game = cl.GameBoard('labyrinth')
show_game.generate_board()
show_game.display_board(game_window)
pygame.display.flip()
# Generate MacGyver and items
MAC = cl.Hero(cst.MACGYVER_PIC, show_game) # Create MacGyver
NEEDLE = cl.Items(cst.NEEDLE_PIC, show_game) # Create Item
NEEDLE.display_random(cst.NEEDLE_PIC, game_window) # Init random position
PIPE = cl.Items(cst.PIPE_PIC, show_game)
PIPE.display_random(cst.PIPE_PIC, game_window)
ETHER = cl.Items(cst.ETHER_PIC, show_game)
ETHER.display_random(cst.ETHER_PIC, game_window)
SYRINGUE = cl.Items(cst.SYRINGUE_PIC, show_game)
run_window_loop = True
while run_window_loop:
# 30 FPS limit
pygame.time.Clock().tick(30)
window_background = pygame.image.load(cst.BKG_PIC).convert_alpha()
#sprite_hero = classes.Sprites_hero()
"_____________________________________________"
width_window = 1000
height_window = 500
background = classes.Background(width_window, height_window, 0, 0) #все фоны
"_____________________________________________"
bullets = []
enemys = []
"_____________________________________________"
width_h = 50
height_h = 50
speed = 10
is_jump = False
xy = [1, height_window - int(height_h + 110)] #320
hero = classes.Hero(xy, width_h, height_h, speed)
"_____________________________________________"
def enemy_add(width_en):
width_enemy = 60
height_enemy = 70
xy = [random.randint(1, width_en), 410 - height_enemy]
speed = 5
enemys.append(classes.Enemy(xy, width_enemy, height_enemy, speed))
"_____________________________________________"
def attack_ball(): # выстрел
speed_ball = 20
x_ball = hero.xy[0] + hero.width//2
y_ball = hero.xy[1] + hero.height//2