def run_game():
#Initialization of game and creation of object = screen
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
screen_rect = screen.get_rect()
pygame.display.set_caption("DraGame")
#Creating button Game
play_button = Button(ai_settings, screen, "Play Game")
#Creating an object to capture statistical data
stats = GameStats(ai_settings)
#Creating a scoreboard
points_txt = str(ai_settings.points)
dragons_left_txt = str(stats.dragons_left)
score_board = Score(ai_settings, screen, "lifes: " + dragons_left_txt,
"Score: " + points_txt)
#Creating the dragon.
dragon = Dragon(ai_settings, screen)
#Creating a group dedicated to store fireballs
fireballs = Group()
#creating a freezers group
freezers = Group()
#Starting the main loop of the game.
while True:
gf.check_events(ai_settings, screen, stats, play_button, dragon,
fireballs)
points_txt = str(ai_settings.points)
dragons_left_txt = str(stats.dragons_left)
if stats.game_active:
dragon.update()
time_1 = pygame.time.get_ticks()
time_2 = int(time_1 / 10)
if time_2 % 100 in range(0, 3):
new_freezer = Freezer(ai_settings, screen)
freezers.add(new_freezer)
gf.update_freezers(ai_settings, stats, screen, dragon, freezers,
fireballs, score_board)
gf.update_fireballs(ai_settings, screen, dragon, freezers,
fireballs)
gf.update_screen(ai_settings, screen, stats, dragon, freezers,
fireballs, play_button, score_board)
class StateFight(State, ButtonListener):
ATTACK_BUTTON = 1
DEFENSE_BUTTON = 2
SPELL_BUTTON = 3
CHARGE_BUTTON = 4
CONTINUE_BUTTON = 5
RUN_BUTTON = 10
def __init__(self, screen, inputManager, character):
State.__init__(self, screen, inputManager)
self.character = character;
self.character.reset()
pygame.display.set_caption("StepFight - Dragon Fight")
self.background = pygame.image.load(Consts.FIGHT_BACKGROUND)
#Create buttons
self._createButtons()
#Create characters
#self.character = Character()
self.dragon = Dragon(character.level)
self.is_in_resolution = False
self.text_character_attack = ""
self.text_dragon_attack = ""
self.font_object = pygame.font.Font('freesansbold.ttf', 20)
self.fight_ended = False
self.next_state = Consts.STATE_CONTINUE
def destroy(self):
self.inputManager.detach(self.attack_button)
self.inputManager.detach(self.defense_button)
self.inputManager.detach(self.spell_button)
self.inputManager.detach(self.charge_button)
self.inputManager.detach(self.run_button)
self.inputManager.detach(self.continue_button)
def _createButtons(self):
#Attack button
self.attack_button = self._createButton(self.ATTACK_BUTTON, "Attack", (80,510,150,50))
#Defense button
self.defense_button = self._createButton(self.DEFENSE_BUTTON, "Defense", (280,510,150,50))
#Spell button
self.spell_button = self._createButton(self.SPELL_BUTTON, "Spell", (480,510,150,50))
if(self.character.magic == 0):
self.spell_button.is_activated = False
#Charge button
self.charge_button = self._createButton(self.CHARGE_BUTTON, "Charge", (680,510,150,50))
#Run button
self.run_button = self._createButton(self.RUN_BUTTON, "Run!", (50,50,60,30))
self.run_button._setPadding(7, 8)
self.run_button._setColors(Consts.RED_COLOR, Consts.HOVER_RED_COLOR, Consts.PRESSED_RED_COLOR)
self.run_button.text_color = Consts.WHITE_COLOR
self.continue_button = self._createButton(self.CONTINUE_BUTTON, "Continue", (700,510,150,50))
self.continue_button.is_activated = False
def _createButton(self, button_id, message, rect):
button = Button(button_id, self, message, Consts.GRAY_COLOR, rect)
self.inputManager.attach(button)
button.border_color = Consts.WHITE_COLOR
button._setColors(Consts.GRAY_COLOR, Consts.HOVER_GRAY_COLOR, Consts.PRESSED_GRAY_COLOR)
return button
def receiveInput(self, event):
State.receiveInput(self, event)
def _update(self):
State._update(self)
if(not self.fight_ended and (self.character.isDead() or self.dragon.isDead()) ):
self.fight_ended = True
self.enterResolutionMode()
if(not self.character.isDead()):
self.character.level += 1
Consts.MONEY += 150
#buttons
if(self.is_in_resolution):
self.continue_button._update()
else:
self.attack_button._update()
self.defense_button._update()
self.spell_button._update()
self.charge_button._update()
self.run_button._update()
#characters
self.character.update()
self.dragon.update()
return self.next_state
def _render(self):
State._render(self)
#background
self.screen.fill(Consts.BLACK_COLOR)
self.screen.blit(self.background, self.background.get_rect())
#buttons
if(self.is_in_resolution):
self.continue_button._render(self.screen)
if(self.fight_ended):
self.font_object = pygame.font.Font('freesansbold.ttf', 30)
if(self.character.isDead()):
self.screen.blit(self.font_object.render("YOU LOST...", False, Consts.RED_COLOR), (270,520))
else:
self.screen.blit(self.font_object.render("YOU WON!!!!!", False, Consts.GOLD_COLOR), (270,520))
else:
message = "You"+self.text_character_attack
self.screen.blit(self.font_object.render(message, False, Consts.WHITE_COLOR), (50,510))
message = "Dragon"+self.text_dragon_attack
self.screen.blit(self.font_object.render(message, False, Consts.WHITE_COLOR), (50,550))
else:
self.attack_button._render(self.screen)
self.defense_button._render(self.screen)
self.spell_button._render(self.screen)
self.charge_button._render(self.screen)
self.run_button._render(self.screen)
#characters
self.dragon.render(self.screen)
self.character.render(self.screen)
self.print_level()
def print_level(self):
msg_surface_object = self.font_object.render("Lvl "+str(self.character.level), False, Consts.BLACK_COLOR)
msg_rect_object = msg_surface_object.get_rect()
msg_rect_object.topleft = (50, 20)
self.screen.blit(msg_surface_object, msg_rect_object)
def clickPerformed(self, button_id):
#character movement
character_movement = 0
if(button_id == self.ATTACK_BUTTON):
character_movement = Consts.ATTACK
elif(button_id == self.DEFENSE_BUTTON):
character_movement = Consts.DEFENSE
elif(button_id == self.SPELL_BUTTON):
character_movement = Consts.SPELL
elif(button_id == self.CHARGE_BUTTON):
character_movement = Consts.CHARGE
elif(button_id == self.CONTINUE_BUTTON):
if(self.fight_ended):
self.next_state = Consts.STATE_ITEMS_BOARD
self.enterBattleMode()
character_movement = 0
elif(button_id == self.RUN_BUTTON):
self.next_state = Consts.STATE_ITEMS_BOARD
if(character_movement != 0):
self.resolveFight(character_movement)
def resolveFight(self, character_movement):
#dragons movement
dragon_movement = self.dragon.getMovement()
character_def = dragon_def = 0
character_atk = dragon_atk = 0
#character
if(character_movement == Consts.DEFENSE):
self.character.defense()
character_def = self.character.defence
elif(character_movement == Consts.ATTACK):
self.character.attack()
character_atk = self.character.strength*self.character.unCharge()
elif(character_movement == Consts.SPELL):
self.character.spell()
character_atk = self.character.magic*self.character.unCharge()
elif(character_movement == Consts.CHARGE):
self.character.charge()
#dragon
if(dragon_movement == Consts.DEFENSE):
self.dragon.defense()
dragon_def = self.dragon.defence
elif(dragon_movement == Consts.ATTACK):
self.dragon.attack()
dragon_atk = self.dragon.strength*self.dragon.unCharge()
elif(dragon_movement == Consts.SPELL):
self.dragon.spell()
self.character.receive_spell()
dragon_atk = self.dragon.magic*self.dragon.unCharge()
elif(dragon_movement == Consts.CHARGE):
self.dragon.charge()
#resolve the damage
self.dragon.beHitted(character_atk - dragon_def)
self.character.beHitted(dragon_atk - character_def)
#set in resolution mode
self.enterResolutionMode()
self.text_character_attack = self.getAttackText(character_movement, character_atk - dragon_def)
self.text_dragon_attack = self.getAttackText(dragon_movement, dragon_atk - character_def)
#DEBUG
#print("character move: "+str(character_movement)+" dragon move: "+str(dragon_movement))
#print("character atk: "+str(character_atk)+" dragon atk: "+str(dragon_atk))
#print("character def: "+str(character_def)+" dragon def: "+str(dragon_def))
#print("character life: "+str(self.character.life)+" dragon life: "+str(self.dragon.life))
def getAttackText(self, move, damage):
text = ""
if(move == Consts.ATTACK):
text = " attacked - Damage: "+str(damage)
elif(move == Consts.DEFENSE):
text = " defended"
elif(move == Consts.SPELL):
text = " used a spell - Damage: "+str(damage)
elif(move == Consts.CHARGE):
text = " charged!! "
return text
def enterResolutionMode(self):
self.is_in_resolution = True
self.continue_button.is_activated = True
self.attack_button.is_activated = False
self.defense_button.is_activated = False
self.spell_button.is_activated = False
self.charge_button.is_activated = False
def enterBattleMode(self):
self.is_in_resolution = False
self.continue_button.is_activated = False
self.attack_button.is_activated = True
self.defense_button.is_activated = True
self.spell_button.is_activated = True
if(self.character.magic == 0):
self.spell_button.is_activated = False
self.charge_button.is_activated = True
# elif x>= board.get_current_pos()+board.get_window_size()[1]-5:
# break
for coin in coins:
x,y = coin.get_pos()
if x>=board.get_current_pos() and x< board.get_current_pos()+board.get_window_size()[1]-5:
coin.display(board.get_current_pos())
elif x<board.get_current_pos():
coins.pop(coins.index(coin))
elif x>= board.get_current_pos()+board.get_window_size()[1]-5:
break
if board.get_current_pos() >= board.get_bg_size()[1] - board.get_window_size()[1]-5:
din.end()
ret = dragon.update(board.get_current_pos())
if ret is not None:
bullets.append(ret)
check_collisions(board,din,coins,bullets,beams,dragon)
if magnet.get_pos()-magnet.get_affect() < din.get_pos()[0]+board.get_current_pos() and magnet.get_pos()>din.get_pos()[0]+board.get_current_pos():
din.set_xacc(8)
print(pos(0,120)+"Magnet Front")
elif magnet.get_pos()+magnet.get_affect() > din.get_pos()[0]+board.get_current_pos() and magnet.get_pos()<din.get_pos()[0]+board.get_current_pos():
din.set_xacc(-8)
print(pos(0,120)+"Magnet Back ")
else:
din.set_xacc(0)
print(pos(0,120)+' ')
class DungeonAndDragons:
def __init__(self):
pygame.init()
pygame.display.set_caption('Dungeon and Dragons')
self.settings = Settings()
self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
self.stats = GameStats(self) # Создание экземпляра для хранения игровой статистики
self.hero = Hero(self)
self.dragon = Dragon(self)
self.fireballs = pygame.sprite.Group()
self.snowballs = pygame.sprite.Group()
self.crystals = pygame.sprite.Group()
self.dragons = pygame.sprite.Group()
self._create_crystals() # TODO Сделать так, чтобы повялялись новые кристаллы когда все пять фаерболов будет
# выпущено в дракона
# Создание кнопки Play
self.play_button = Button(self, 'Play')
self.scoreboard = Scoreboard(self)
def run_game(self):
"""
Запуск основного цикла игры
"""
while True:
self._check_events()
# Отделим части игры, которые должны выподлняться только при активной игре (game_active = True)
if self.stats.game_active:
self.hero.update()
self._update_snowballs()
self._update_fireballs()
self._update_dragon()
self._update_crystals()
self._update_screen()
def _check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_play_button(self, mouse_pos):
"""
Запускает новую игру при нажатии кнопки Play
"""
# Проверяет находится ли точка щелчка в пределах прямоугольника
# и отмена реакции клика по квадрату, если игра активна
mouse_on_play = self.play_button.rect.collidepoint(mouse_pos)
if mouse_on_play and not self.stats.game_active:
# Сброс игровой статистики
self.stats.reset_stats()
self.stats.game_active = True
# Очистка всех списков спрайтов
self.fireballs.empty()
self.snowballs.empty()
self.crystals.empty()
# Создание и центрирование объектов заного
self._create_crystals()
self.dragon.center_dragon()
self.hero.center_hero()
self.scoreboard.prep_score()
self.scoreboard.prep_lives()
def _check_keydown_events(self, event):
"""
Реагирует на нажатие клавиш.
"""
if event.key == pygame.K_RIGHT:
self.hero.moving_right = True
elif event.key == pygame.K_LEFT:
self.hero.moving_left = True
elif event.key == pygame.K_UP:
self.hero.moving_up = True
elif event.key == pygame.K_DOWN:
self.hero.moving_down = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self.release_snowball()
def _check_keyup_events(self, event):
"""
Реагирует на отпускание клавиш.
"""
if event.key == pygame.K_RIGHT:
self.hero.moving_right = False
elif event.key == pygame.K_LEFT:
self.hero.moving_left = False
elif event.key == pygame.K_UP:
self.hero.moving_up = False
elif event.key == pygame.K_DOWN:
self.hero.moving_down = False
def release_snowball(self):
if len(self.snowballs) < self.settings.snowball_allowed and self.settings.crystals_stack == 3:
new_snowball = Snowball(self)
self.snowballs.add(new_snowball)
self.settings.crystals_stack = 0
def _update_snowballs(self):
self.snowballs.update()
for snowball in self.snowballs.copy():
if snowball.rect.right >= self.screen.get_rect().right:
self.snowballs.remove(snowball)
self._check_snowball_dragon_collision()
def _check_snowball_dragon_collision(self):
"""
Обработка коллизий снежных шаров и дракона
"""
collision = pygame.sprite.spritecollideany(self.dragon, self.snowballs)
if collision:
self._dragon_hit()
def release_fireball(self):
if len(self.fireballs) < self.settings.fireballs_allowed:
new_fireball = Fireball(self)
self.fireballs.add(new_fireball)
def _update_fireballs(self):
self.fireballs.update()
for fireball in self.fireballs.copy():
if fireball.rect.right <= 0:
self.fireballs.remove(fireball)
self._check_fireball_snowball_collision()
self._check_fireball_hero_collision()
def _check_fireball_snowball_collision(self):
"""
Обработка коллизий огненных и снежных шаров
"""
# Проверка попадений в героя (коллизий) с помощью sprite.groupcollide()
# True, True обозначает, что нужно удалять каждый объект после столкновения
collision_fireball_hero = pygame.sprite.groupcollide(self.fireballs, self.snowballs, True, True)
def _check_fireball_hero_collision(self):
"""
Обработка коллизий огненных и героя
"""
if pygame.sprite.spritecollideany(self.hero, self.fireballs):
self._hero_hit()
def _update_crystals(self):
self.crystals.update()
self._check_hero_crystal_collision()
if not self.crystals and self.settings.crystals_stack == 0:
self._create_crystals()
def _create_crystals(self):
for row_number in range(1):
for crystal_number in range(self.settings.crystals_allowed):
self._create_crystal()
def _create_crystal(self):
crystal = Crystal(self)
crystal.rect.x = randint(50, 1200)
crystal.rect.y = randint(50, 800)
if pygame.sprite.collide_rect(self.hero, crystal):
crystal.rect.x = randint(50, 1200)
crystal.rect.y = randint(50, 800)
self.crystals.add(crystal)
def _check_hero_crystal_collision(self):
"""
Обработка коллизий героя и кристаллов
"""
for crystal in self.crystals:
hero_got_crystal = pygame.sprite.collide_rect(self.hero, crystal)
if hero_got_crystal:
self.settings.crystals_stack += 1
self.crystals.remove(crystal)
def _check_dragon_edges(self):
if self.dragon.check_edges():
self.dragon.x -= self.settings.dragon_drop_speed
self.settings.dragon_direction *= -1
def _update_dragon(self):
self._check_dragon_edges()
self.dragon.update()
self._check_dragon_left() # Проверяет добрался ли дракон до левого края экрана
self._check_dragon_hero_collision()
for i in range(3):
self.release_fireball()
def _check_dragon_left(self):
"""
Проверяет добрался ли дракон до левого края экрана
"""
if self.stats.lives_left > 0:
screen_rect = self.screen.get_rect()
for dragon in self.dragons.sprites():
if dragon.rect.left >= screen_rect.left:
# Происхоит тоже, что при столкновении с кораблем
self._hero_hit()
break
else:
self.stats.game_active = False
def _check_dragon_hero_collision(self):
if pygame.sprite.spritecollideany(self.hero, self.dragons):
self._hero_hit()
def _hero_hit(self):
"""
Обрабатывает столкнокение дракона с героем
"""
if self.stats.lives_left > 0:
# Уменьшение количества жизней на 1
self.stats.lives_left -= 1
self.scoreboard.prep_lives()
# Очистка окна от объектов
self.fireballs.empty()
self.snowballs.empty()
self.dragons.empty()
self.crystals.empty()
self.settings.crystals_stack = 0
# Обновление расположения персонажей учитывая -1 жизнь героя
self.dragon.center_dragon()
self.hero.center_hero()
self._create_crystals()
# Пауза
sleep(1)
else:
self.stats.game_active = False
def _dragon_hit(self):
self.stats.score += 1
pass
def _update_screen(self):
self.screen.fill(self.settings.background_color)
self.hero.blit_hero()
self.dragon.blit_dragon()
for fireball in self.fireballs.sprites():
fireball.blit_fireball()
for snowball in self.snowballs.sprites():
snowball.blit_snowball()
self.crystals.draw(self.screen)
# Вывод инфолрмации о счете
self.scoreboard.show_score()
# Кнопка Play отображается только когда игра не активна
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
