devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python_Game之开心消消乐_python开心消消乐。

作者：Guff_9hys | 2024-06-21 05:02:08

赞

踩

python开心消消乐。

目录

前言

环境要求

项目演示

源码分享

前言

        老少皆宜的儿童8+游戏，历经两年半的沉淀，终于让我在鸽鸽手上薅到了，特此马不停蹄来水一篇博客。(如有侵权，请私信解决！)

环境要求

【软件】

        python3.7

        pycharm专业版

【模块】

        pip install pygame

项目演示

源码分享

Sounds.p

  1. # -*- encoding: utf-8 -*-
  2. '''Game sounds.'''
  3. from enum import Enum
  4. from pygame.mixer import Sound
  5.  
  6. class Sounds(Enum):
  7.     '''Enum for the game's sounds.'''
  8.     GAME_BGM = 'sound/GameSceneBGM.ogg'
  9.     WORLD_BGM = 'sound/WorldSceneBGM.ogg'
  10.     ELIMINATE_FORMAT = 'sound/eliminate/%d.ogg'
  11.     SCORE_LEVEL = ('sound/good.ogg', 'sound/great.ogg', 'sound/amazing.ogg', 'sound/excellent.ogg',\
  12.                    'sound/unbelievable.ogg')
  13.     CLICK = 'sound/click.bubble.ogg'
  14.     BOARD_SOUND = 'sound/board.ogg'
  15.     CLICK_BUTTON = 'sound/click_common_button.ogg'
  16.     MONEY = 'sound/money.ogg'
  17.     ICE_BREAKING = 'sound/ice_break.ogg'
  18.  
  19.     @staticmethod
  20.     def eliminate(idx):
  21.         '''Plays the eliminate sound with given index.'''
  22.         Sound(Sounds.ELIMINATE_FORMAT.value%idx).play()
  23.  
  24.     @staticmethod
  25.     def score_level(idx):
  26.         '''Plays the score level sound with given index.'''
  27.         Sound(Sounds.SCORE_LEVEL.value[idx]).play()
  28.  
  29. def play_sound(sound: Enum):
  30.     '''Play sound with given number of loops.'''
  31.     Sound(sound.value).play()

Manager.py

  1. # -*- encoding: utf-8 -*-
  2. '''Game manager module.'''
  3. # pylint: disable=fixme, line-too-long, invalid-name, undefined-variable
  4. # pylint: disable=too-many-branches, too-many-statements, too-many-arguments
  5. from random import randint
  6. import pygame
  7. from pygame.locals import * # pylint: disable=wildcard-import, unused-wildcard-import
  8. from pygame.time import delay
  9. from sprites import Tree, Board, Element
  10. from sounds import Sounds, play_sound
  11.  
  12. class TreeManager:
  13.     '''Tree manager.'''
  14.     __screen_size = (900, 600)
  15.     screen = pygame.display.set_mode(__screen_size, DOUBLEBUF, 32)
  16.     fruit_list = []
  17.     fruit_image = pygame.image.load(Tree.fruit).convert_alpha()
  18.     fruit_width = fruit_image.get_width()
  19.     fruit_height = fruit_image.get_height()
  20.     type = 0 # 0 Tree, 1 Energy
  21.     energy_full = False # Energy full mark
  22.     money_empty = False # Not any money left?
  23.  
  24.     def display_text(self, text, position, txt_size=25, txt_color=(255, 255, 255)):
  25.         '''Display text with given position, size and color.'''
  26.         my_font = pygame.font.SysFont(None, txt_size)
  27.         text_screen = my_font.render(text, True, txt_color)
  28.         self.screen.blit(text_screen, position)
  29.  
  30.     def draw_tree(self, energy_num, money_num):
  31.         '''Draws the game tree.'''
  32.         Tree(Tree.tree, (0, 600)).draw(self.screen) # Draw tree
  33.         Tree(Tree.energy_num, Tree.energy_num_position).draw(self.screen) # Draw energy num
  34.         if energy_num > 30:
  35.             self.display_text(str(30) + '/30', (22, 55), 21)
  36.         else:
  37.             self.display_text(str(energy_num)+'/30', (22, 55), 21)
  38.         Tree(Tree.money, (15, 135)).draw(self.screen) # Draw money
  39.         self.display_text(str(money_num), (32, 124), 21)
  40.         for i in range(0, 10): # Draw fruits
  41.             Tree(Tree.fruit, Tree.position[i]).draw(self.screen)
  42.             self.display_text(str(i+1), (Tree.position[i][0]+15, Tree.position[i][1]-47))
  43.         if self.type == 1:
  44.             Tree(Tree.energy_buy, Tree.energy_buy_position).draw(self.screen)
  45.             if self.energy_full:
  46.                 self.display_text('energy is full!', (430, 310), 30, (255, 0, 0))
  47.                 pygame.display.flip()
  48.                 delay(500)
  49.                 self.energy_full = False
  50.             if self.money_empty:
  51.                 self.display_text('money is not enough!', (410, 310), 30, (255, 0, 0))
  52.                 pygame.display.flip()
  53.                 delay(500)
  54.                 self.money_empty = False
  55.  
  56.     def mouse_select(self, mgr, mousex, mousey, level, energy_num, money_num):
  57.         '''Handle mouse event.'''
  58.         if self.type == 0: # Tree Scene
  59.             for i in range(0, 10):
  60.                 if Tree.position[i][0] < mousex < Tree.position[i][0] + self.fruit_width \
  61.                         and Tree.position[i][1] - self.fruit_height < mousey < Tree.position[i][1]:
  62.                     if energy_num <= 0:
  63.                         self.type = 1
  64.                     else:
  65.                         level = i + 1
  66.             if Tree.energy_num_position[0] < mousex < Tree.energy_num_position[0] + 60 \
  67.                     and Tree.energy_num_position[1] - 60 < mousey < Tree.energy_num_position[1]: # 精力60*60
  68.                 play_sound(Sounds.CLICK)
  69.                 self.type = 1
  70.         else: # Energy Scene
  71.             if 408 < mousex < 600 and 263 < mousey < 313: # "Buy Energy" button clicked
  72.                 play_sound(Sounds.CLICK_BUTTON)
  73.                 if money_num < 50:
  74.                     self.money_empty = True
  75.                 if energy_num >= 30:
  76.                     self.energy_full = True
  77.                 elif energy_num < 30 and money_num >= 50:
  78.                     energy_num += 5
  79.                     money_num -= 50
  80.             elif 619 < mousex < 638 and 158 < mousey < 177: # "X" clicked
  81.                 self.type = 0
  82.         mgr.level, mgr.energy_num, mgr.money = level, energy_num, money_num
  83.  
  84. # pylint: disable=too-many-public-methods, too-many-instance-attributes, too-many-nested-blocks
  85. class Manager:
  86.     '''Game manager.'''
  87.     __screen_size = (900, 600)
  88.     screen = pygame.display.set_mode(__screen_size, DOUBLEBUF, 32)
  89.     __brick_size = 50
  90.     __bg = pygame.image.load('img/bg.png').convert()
  91.     stop_width = 63
  92.     selected = [-1, -1] # Current selected [row, col]
  93.     swap_sign = -1 # Swap sign
  94.     last_sel = [-1, -1] # Last selected [row, col]
  95.     value_swapped = False # Swapped?
  96.     death_sign = True # Death map sign
  97.     boom_sel = [-1, -1] # Eliminate 4: [row, col]
  98.     level = 0 # Current level, 0 for tree
  99.     money = 100 # Money
  100.     energy_num = 30 # Energy num
  101.     num_sign = True
  102.     type = 2 # (0) Playing, (1) Passed, (-1) Failed, (2) Tree
  103.     reset_mode = True # Reset layout?
  104.     init_step = 15 # Initial steps for each level
  105.     step = init_step # Steps left of the game
  106.     score = 0 # Score
  107.     min = 20 # Medium score 1
  108.     max = 50 # Medium score 2
  109.     animal_num = [0, 0, 0, 0, 0, 0] # Number of eliminated animals
  110.     ice_num = 0 # Number left of required ice
  111.     success_board = Board(Board.success, [200, 0]) # Success board
  112.     fail_board = Board(Board.fail, [200, 0]) # Failure board
  113.     height, width = 9, 9
  114.     row, col = 5, 5
  115.     ice_list = [[-1 for _ in range(21)] for _ in range(21)] # (-1) None, (1) Ice
  116.     animal = [[-1 for _ in range(21)] for _ in range(21)] # (-2) Elimated, (-1) None, (0-4) Animal
  117.     list_x, list_y = (__screen_size[0] - 11 * __brick_size) / 2, (__screen_size[1] - 11 * __brick_size) / 2 # Position of the blocks
  118.  
  119.     def __init__(self, width, height):
  120.         self.height = height
  121.         self.width = width
  122.         self.list_x = (Manager.__screen_size[0] - self.width * Manager.__brick_size) / 2
  123.         self.list_y = (Manager.__screen_size[1] - self.height * Manager.__brick_size) / 2
  124.         self.row, self.col = Manager.xy_rc(self.list_x, self.list_y)
  125.         self.list_x, self.list_y = Manager.rc_xy(self.row, self.col)
  126.         self.ice_list = [[-1 for _ in range(21)] for _ in range(21)]
  127.         self.animal = [[-1 for _ in range(21)] for _ in range(21)]
  128.         self.reset_animals()
  129.  
  130.     def reset_animals(self):
  131.         '''Reset board with random animals.'''
  132.         for row in range(self.row, self.row + self.height):
  133.             for col in range(self.col, self.col + self.width):
  134.                 self.animal[row][col] = randint(0, 5)
  135.  
  136.     @staticmethod
  137.     def rc_xy(row, col):
  138.         '''(row, col) -> (x, y)'''
  139.         return int(Manager.list_x + (col-Manager.col)*Manager.__brick_size), int\
  140.             (Manager.list_y+(row-Manager.row)*Manager.__brick_size)
  141.  
  142.     @staticmethod
  143.     def xy_rc(x, y):
  144.         '''(x, y) -> (row, col)'''
  145.         return int((y-Manager.list_y)/Manager.__brick_size+Manager.row), int\
  146.             ((x-Manager.list_x)/Manager.__brick_size+Manager.col)
  147.  
  148.     @staticmethod
  149.     def draw_brick(x, y):
  150.         '''Draw a brick at (x, y).'''
  151.         brick = Element(Element.brick, (x, y))
  152.         Manager.screen.blit(brick.image, brick.rect)
  153.  
  154.     def draw_task(self, task_animal_num, which_animal, \
  155.                   board_position=(400, 90), animal_position=(430, 35), txt_position=(455, 60)):
  156.         '''Draw task board'''
  157.         txt_size = 24
  158.         txt_color = (0, 0, 0)
  159.         Board(Board.task_board, board_position).draw(self.screen)
  160.         if which_animal == 6:
  161.             task_animal = Element(Element.ice, animal_position)
  162.         else:
  163.             task_animal = Element(Element.animals[which_animal], animal_position)
  164.         task_animal.image = pygame.transform.smoothscale(task_animal.image, (40, 40))
  165.         task_animal.draw(self.screen)
  166.         if which_animal == 6:
  167.             if task_animal_num-self.ice_num <= 0:
  168.                 Board(Board.ok, (txt_position[0], txt_position[1]+15)).draw(self.screen)
  169.             else:
  170.                 self.load_text(str(task_animal_num-self.ice_num), txt_position, txt_size, txt_color)
  171.         else:
  172.             if task_animal_num - self.animal_num[which_animal] <= 0:
  173.                 Board(Board.ok, (txt_position[0], txt_position[1]+15)).draw(self.screen)
  174.             else:
  175.                 self.load_text(str(task_animal_num - self.animal_num[which_animal]), txt_position, txt_size, txt_color)
  176.  
  177.     def draw(self):
  178.         '''Draw background, animals, and so on.'''
  179.         # Draw background
  180.         self.screen.blit(Manager.__bg, (0, 0))
  181.         # Display steps left
  182.         Board(Board.step_board, (0, 142)).draw(self.screen)
  183.         tens, single = divmod(self.step, 10)
  184.         if tens == 0:
  185.             Board(Board.num_format%single, (790, 110)).draw(self.screen)
  186.         else:
  187.             Board(Board.num_format%tens, (775, 110)).draw(self.screen)
  188.             Board(Board.num_format%single, (805, 110)).draw(self.screen)
  189.         # Display level & pause button
  190.         Board(Board.level_format%self.level, (30, 105)).draw(self.screen)
  191.         Element(Element.stop, Element.stop_position).draw(self.screen)
  192.  
  193.         # Draw bricks, ice and animals
  194.         brick_group = pygame.sprite.Group()
  195.         animal_group = pygame.sprite.Group()
  196.         ice_group = pygame.sprite.Group()
  197.         for i in range(0, 21):
  198.             for j in range(0, 21):
  199.                 x, y = Manager.rc_xy(i, j)
  200.                 if self.animal[i][j] != -1:
  201.                     brick_group.add(Element(Element.brick, (x, y)))
  202.                     animal_group.add(Element(Element.animals[self.animal[i][j]], (x, y)))
  203.                 if self.ice_list[i][j] != -1:
  204.                     ice_group.add(Element(Element.ice, (x, y)))
  205.         brick_group.draw(self.screen)
  206.         ice_group.draw(self.screen)
  207.         for animallist in animal_group:
  208.             self.screen.blit(animallist.image, animallist.rect)
  209.         if self.level == 1:
  210.             self.draw_task(10, 4)
  211.         elif self.level == 2:
  212.             self.draw_task(21, 1)
  213.         elif self.level == 3:
  214.             self.draw_task(16, 4, (300, 90), (330, 35), (360, 60))
  215.             self.draw_task(16, 5, (500, 90), (530, 35), (560, 60))
  216.         elif self.level == 4:
  217.             self.draw_task(18, 5, (300, 90), (330, 35), (360, 60))
  218.             self.draw_task(18, 2, (500, 90), (530, 35), (560, 60))
  219.         elif self.level == 5:
  220.             self.draw_task(28, 2, (300, 90), (330, 35), (360, 60))
  221.             self.draw_task(28, 0, (500, 90), (530, 35), (560, 60))
  222.         elif self.level == 6:
  223.             self.draw_task(70, 4)
  224.         elif self.level == 7:
  225.             self.draw_task(36, 1)
  226.             self.draw_task(36, 2, (300, 90), (330, 35), (360, 60))
  227.             self.draw_task(36, 0, (500, 90), (530, 35), (560, 60))
  228.         elif self.level == 8:
  229.             self.draw_task(15, 6)
  230.         elif self.level == 9:
  231.             self.draw_task(49, 6)
  232.         else:
  233.             self.draw_task(39, 6)
  234.  
  235.         # Display selected animal
  236.         if self.selected != [-1, -1]:
  237.             frame_sprite = Element(Element.frame, Manager.rc_xy(self.selected[0], self.selected[1]))
  238.             self.screen.blit(frame_sprite.image, frame_sprite.rect)
  239.  
  240.         # Show score
  241.         self.load_text('Score:' + str(self.score), (300, 550), 30)
  242.         pygame.draw.rect(self.screen, (50, 150, 50, 180), Rect(300, 570, self.score * 2, 25))
  243.         pygame.draw.rect(self.screen, (100, 200, 100, 180), Rect(300, 570, 200, 25), 2)
  244.         return animal_group
  245.  
  246.     def mouse_image(self):
  247.         '''Replace the mouse image with img/mouse.png'''
  248.         mouse_cursor = pygame.image.load('img/mouse.png').convert_alpha()
  249.         mouse_x, mouse_y = pygame.mouse.get_pos()
  250.         # Find the topleft position of the mouse
  251.         mouse_x -= mouse_cursor.get_width() / 2
  252.         mouse_y -= mouse_cursor.get_height() / 2
  253.         self.screen.blit(mouse_cursor, (mouse_x, mouse_y))
  254.  
  255.     def mouse_select(self, mousex, mousey):
  256.         '''Handle mouse click event.'''
  257.         if self.type == 1: # Passed
  258.             if Board.button_position[0][0] < mousex < Board.button_position[0][0]+100 \
  259.                     and Board.button_position[0][1] - 50 < mousey < Board.button_position[0][1]: # Clicked replay button
  260.                 if self.energy_num < 5:
  261.                     self.level = 0
  262.                 self.reset_mode = True
  263.             elif Board.button_position[1][0] < mousex < Board.button_position[1][0]+100 \
  264.                     and Board.button_position[1][1]-50 < mousey < Board.button_position[1][1]: # Clicked next level button
  265.                 if self.level < 10:
  266.                     if self.energy_num < 5:
  267.                         self.level = 0
  268.                     else:
  269.                         self.level += 1
  270.                     self.reset_mode = True
  271.             elif 610 < mousex < 610 + 55 and 205 - 55 < mousey < 205: # x
  272.                 self.level = 0
  273.                 self.reset_mode = True
  274.  
  275.         elif self.type == -1: # Failed
  276.             if Board.button_position[1][0] < mousex < Board.button_position[1][0]+100 \
  277.                     and Board.button_position[1][1]-50 < mousey < Board.button_position[1][1]: # Clicked replay button
  278.                 if self.energy_num < 5:
  279.                     self.level = 0
  280.                 self.reset_mode = True
  281.             elif Board.button_position[0][0] < mousex < Board.button_position[0][0]+100 \
  282.                     and Board.button_position[0][1]-50 < mousey < Board.button_position[0][1]: # Clicked 5 more steps button
  283.                 if self.money < 5:
  284.                     self.level = 0
  285.                 else:
  286.                     self.money -= 5
  287.                     self.step += 5
  288.                     self.type = 0 # Playing game
  289.                     self.fail_board = Board(Board.fail, [200, 0])
  290.             elif 610 < mousex < 610 + 55 and 205 - 55 < mousey < 205:
  291.                 self.level = 0
  292.                 self.reset_mode = True
  293.  
  294.         elif self.type == 0:
  295.             if self.list_x < mousex < self.list_x + Manager.__brick_size * self.width \
  296.                     and self.list_y < mousey < self.list_y + Manager.__brick_size * self.height:
  297.                 mouse_selected = Manager.xy_rc(mousex, mousey)
  298.                 if self.animal[mouse_selected[0]][mouse_selected[1]] != -1:
  299.                     play_sound(Sounds.CLICK)
  300.                     self.selected = mouse_selected
  301.                     if (self.last_sel[0] == self.selected[0] and abs(self.last_sel[1] - self.selected[1]) == 1) \
  302.                             or (self.last_sel[1] == self.selected[1] and abs(self.last_sel[0] - self.selected[0]) == 1):
  303.                         self.swap_sign = 1 # Valid move, swap
  304.             elif Element.stop_position[0] < mousex < Element.stop_position[0]+self.stop_width\
  305.                     and Element.stop_position[1] < mousey < Element.stop_position[1]+self.stop_width: # Exit button clicked
  306.                 play_sound(Sounds.CLICK_BUTTON)
  307.                 self.level = 0
  308.                 self.reset_mode = True
  309.             else:
  310.                 self.selected = [-1, -1]
  311.  
  312.     def swap(self, spritegroup):
  313.         '''Swap two selected animals on the board.'''
  314.         if self.swap_sign == -1: # Not swapped
  315.             self.last_sel = self.selected
  316.         if self.swap_sign == 1:
  317.             last_x, last_y = Manager.rc_xy(self.last_sel[0], self.last_sel[1])
  318.             sel_x, sel_y = Manager.rc_xy(self.selected[0], self.selected[1])
  319.             if self.last_sel[0] == self.selected[0]: # Swap vertically
  320.                 for animallist in spritegroup:
  321.                     if animallist.rect.topleft == (last_x, last_y):
  322.                         last_sprite = animallist
  323.                         last_sprite.speed = [self.selected[1]-self.last_sel[1], 0]
  324.                     elif animallist.rect.topleft == (sel_x, sel_y):
  325.                         selected_sprite = animallist
  326.                         selected_sprite.speed = [self.last_sel[1]-self.selected[1], 0]
  327.             else: # Swap horizontally
  328.                 for animallist in spritegroup:
  329.                     if animallist.rect.topleft == (last_x, last_y):
  330.                         last_sprite = animallist
  331.                         last_sprite.speed = [0, self.selected[0]-self.last_sel[0]]
  332.                     elif animallist.rect.topleft == (sel_x, sel_y):
  333.                         selected_sprite = animallist
  334.                         selected_sprite.speed = [0, self.last_sel[0]-self.selected[0]]
  335.             while last_sprite.speed != [0, 0]:
  336.                 delay(5)
  337.                 self.draw_brick(last_x, last_y)
  338.                 self.draw_brick(sel_x, sel_y)
  339.                 last_sprite.move(last_sprite.speed)
  340.                 selected_sprite.move(selected_sprite.speed)
  341.                 self.screen.blit(last_sprite.image, last_sprite.rect)
  342.                 self.screen.blit(selected_sprite.image, selected_sprite.rect)
  343.                 pygame.display.flip()
  344.  
  345.             self.swap_values()
  346.             if self.eliminate_animals():
  347.                 self.step -= 1
  348.             else:
  349.                 self.swap_values()
  350.             self.value_swapped = False
  351.             self.boom_sel = self.selected
  352.             self.swap_sign = -1
  353.             self.selected = [-1, -1]
  354.  
  355.     def swap_values(self):
  356.         '''Swap values.'''
  357.         (xl, yl), (xc, yc) = self.last_sel, self.selected
  358.         self.animal[xl][yl], self.animal[xc][yc] = self.animal[xc][yc], self.animal[xl][yl]
  359.  
  360.     def load_text(self, text, position, txt_size, txt_color=(255, 255, 255)):
  361.         '''Display text with given position, size and color.'''
  362.         my_font = pygame.font.SysFont(None, txt_size)
  363.         text_screen = my_font.render(text, True, txt_color)
  364.         self.screen.blit(text_screen, position)
  365.  
  366.     def death_map(self):
  367.         '''Checks if there is not a valid move.'''
  368.         for i in range(self.row, self.row + self.height):
  369.             for j in range(self.col, self.col + self.width):
  370.                 if self.animal[i][j] != -1:
  371.                     if self.animal[i][j] == self.animal[i][j+1]:
  372.                         if (self.animal[i][j] in [self.animal[i-1][j-1], self.animal[i+1][j-1]] \
  373.                                     and self.animal[i][j-1] != -1) or \
  374.                                 (self.animal[i][j] in [self.animal[i-1][j+2], self.animal[i+1][j+2]] \
  375.                                          and self.animal[i][j+2] != -1):
  376.                             # a     b
  377.                             #   a a
  378.                             # c     d
  379.                             self.death_sign = False
  380.                             break
  381.                     if self.animal[i][j] == self.animal[i+1][j]:
  382.                         if (self.animal[i][j] in [self.animal[i-1][j-1], self.animal[i-1][j+1]] \
  383.                                     and self.animal[i-1][j] != -1) or \
  384.                                 (self.animal[i][j] in [self.animal[i+2][j - 1], self.animal[i+2][j + 1]] \
  385.                                          and self.animal[i+2][j] != -1):
  386.                             # a   b
  387.                             #   a
  388.                             #   a
  389.                             # c   d
  390.                             self.death_sign = False
  391.                             break
  392.                     else:
  393.                         if self.animal[i-1][j-1] == self.animal[i][j]:
  394.                             if (self.animal[i][j] == self.animal[i-1][j+1] and self.animal[i-1][j] != -1)\
  395.                                     or (self.animal[i][j] == self.animal[i+1][j-1] and self.animal[i][j-1] != -1):
  396.                                 # a   a      a   b
  397.                                 #   a          a
  398.                                 # c          a
  399.                                 self.death_sign = False
  400.                                 break
  401.                         if self.animal[i][j] == self.animal[i+1][j+1]:
  402.                             if (self.animal[i][j] == self.animal[i-1][j+1] and self.animal[i][j+1] != -1)\
  403.                                     or (self.animal[i][j] == self.animal[i+1][j-1] and self.animal[i+1][j] != -1):
  404.                                 #     a          b
  405.                                 #   a          a
  406.                                 # b   a      a   a
  407.                                 self.death_sign = False
  408.                                 break
  409.         if self.death_sign:
  410.             delay(500)
  411.             Element(Element.none_animal, (230, 150)).draw(self.screen)
  412.             pygame.display.flip()
  413.             delay(500)
  414.             temp = [self.step, self.score, self.animal_num, self.ice_num, self.energy_num]
  415.             self.reset_mode = True
  416.             self.set_level_mode(self.level)
  417.             self.step = temp[0]
  418.             self.score = temp[1]
  419.             self.animal_num = temp[2]
  420.             self.ice_num = temp[3]
  421.             self.energy_num = temp[4]
  422.         else:
  423.             self.death_sign = True
  424.  
  425.     # TODO: Merge 4 functions below
  426.     def exists_left(self, i, j, num):
  427.         '''Checks there are at least {num} continous same animals on the left side of (i, j).'''
  428.         for t in range(0, num):
  429.             if self.animal[i][j] != self.animal[i][j - t] or self.animal[i][j] < 0:
  430.                 return False
  431.         return True
  432.  
  433.     def exists_right(self, i, j, num):
  434.         '''Checks there are at least {num} continous same animals on the right side of (i, j).'''
  435.         for t in range(0, num):
  436.             if self.animal[i][j] != self.animal[i][j + t] or self.animal[i][j] < 0:
  437.                 return False
  438.         return True
  439.  
  440.     def exists_up(self, i, j, num):
  441.         '''Checks there are at least {num} continous same animals above (i, j).'''
  442.         for t in range(0, num):
  443.             if self.animal[i][j] != self.animal[i - t][j] or self.animal[i][j] < 0:
  444.                 return False
  445.         return True
  446.  
  447.     def exists_down(self, i, j, num):
  448.         '''Checks there are at least {num} continous same animals below (i, j).'''
  449.         for t in range(0, num):
  450.             if self.animal[i][j] != self.animal[i + t][j] or self.animal[i][j] < 0:
  451.                 return False
  452.         return True
  453.  
  454.     # TODO: Merge 4 functions below
  455.     def change_left(self, i, j, num):
  456.         '''Change the left side of the animal.'''
  457.         self.value_swapped = True
  458.         self.score += num
  459.         for k in range(0, int(num)):
  460.             self.animal[i][j - k] = -2
  461.  
  462.     def change_right(self, i, j, num):
  463.         '''Change the right side of the animal.'''
  464.         self.value_swapped = True
  465.         self.score += num
  466.         for k in range(0, num):
  467.             self.animal[i][j + k] = -2
  468.  
  469.     def change_up(self, i, j, num):
  470.         '''Change above the animal.'''
  471.         self.value_swapped = True
  472.         self.score += num
  473.         for k in range(0, num):
  474.             self.animal[i-k][j] = -2
  475.  
  476.     def change_down(self, i, j, num):
  477.         '''Change below the animal.'''
  478.         self.value_swapped = True
  479.         self.score += num
  480.         for k in range(0, num):
  481.             self.animal[i+k][j] = -2
  482.  
  483.     def eliminate_animals(self):
  484.         '''Eliminate the animals.'''
  485.         score_level = self.score
  486.         self.value_swapped = False
  487.         for i in range(self.row, self.row + self.height):
  488.             for j in range(self.col, self.col + self.width):
  489.                 # TODO: Simplify the if statement below
  490.                 if self.exists_right(i, j, 5):
  491.                     self.value_swapped = True
  492.                     if self.exists_down(i, j+2, 3):
  493.                         self.animal_num[self.animal[i][j]] += 7
  494.                         Sounds.eliminate(5) # Elimination sound 5
  495.                         self.change_right(i, j, 5)
  496.                         self.change_down(i, j+2, 3)
  497.                     else:
  498.                         self.animal_num[self.animal[i][j]] += 5
  499.                         Sounds.eliminate(3) # Elimination sound 3
  500.                         self.change_right(i, j, 5)
  501.                 elif self.exists_right(i, j, 4):
  502.                     self.value_swapped = True
  503.                     if self.exists_down(i, j+1, 3):
  504.                         self.animal_num[self.animal[i][j]] += 6
  505.                         Sounds.eliminate(4) # Elimination sound 4
  506.                         self.change_right(i, j, 4)
  507.                         self.change_down(i, j+1, 3)
  508.                     elif self.exists_down(i, j+2, 3):
  509.                         self.animal_num[self.animal[i][j]] += 6
  510.                         Sounds.eliminate(4) # Elimination sound 4
  511.                         self.change_right(i, j, 4)
  512.                         self.change_down(i, j+2, 3)
  513.                     else:
  514.                         self.animal_num[self.animal[i][j]] += 4
  515.                         Sounds.eliminate(2) # Elimination sound 2
  516.                         self.change_right(i, j, 4)
  517.                 elif self.exists_right(i, j, 3):
  518.                     self.value_swapped = True
  519.                     if self.exists_down(i, j, 3):
  520.                         self.animal_num[self.animal[i][j]] += 5
  521.                         Sounds.eliminate(3) # Elimination sound 3
  522.                         self.change_right(i, j, 3)
  523.                         self.change_down(i, j, 3)
  524.                     elif self.exists_down(i, j+1, 3):
  525.                         self.animal_num[self.animal[i][j]] += 5
  526.                         Sounds.eliminate(3) # Elimination sound 3
  527.                         self.change_right(i, j, 3)
  528.                         self.change_down(i, j+1, 3)
  529.                     elif self.exists_down(i, j+2, 3):
  530.                         self.animal_num[self.animal[i][j]] += 5
  531.                         Sounds.eliminate(3) # Elimination sound 3
  532.                         self.change_right(i, j, 3)
  533.                         self.change_down(i, j + 2, 3)
  534.                     else:
  535.                         self.animal_num[self.animal[i][j]] += 3
  536.                         Sounds.eliminate(1) # Elimination sound 1
  537.                         self.change_right(i, j, 3)
  538.                 elif self.exists_down(i, j, 5):
  539.                     self.value_swapped = True
  540.                     if self.exists_right(i+2, j, 3):
  541.                         self.animal_num[self.animal[i][j]] += 7
  542.                         Sounds.eliminate(5) # Elimination sound 5
  543.                         self.change_down(i, j, 5)
  544.                         self.change_right(i+2, j, 3)
  545.                     elif self.exists_left(i+2, j, 3):
  546.                         self.animal_num[self.animal[i][j]] += 7
  547.                         Sounds.eliminate(5) # Elimination sound 5
  548.                         self.change_down(i, j, 5)
  549.                         self.change_left(i+2, j, 3)
  550.                     else:
  551.                         self.animal_num[self.animal[i][j]] += 5
  552.                         Sounds.eliminate(3) # Elimination sound 3
  553.                         self.change_down(i, j, 5)
  554.                 elif self.exists_down(i, j, 4):
  555.                     self.value_swapped = True
  556.                     if self.exists_left(i+1, j, 3):
  557.                         self.animal_num[self.animal[i][j]] += 6
  558.                         Sounds.eliminate(4) # Elimination sound 4
  559.                         self.change_down(i, j, 4)
  560.                         self.change_left(i+1, j, 3)
  561.                     elif self.exists_right(i+1, j, 3):
  562.                         self.animal_num[self.animal[i][j]] += 6
  563.                         Sounds.eliminate(4) # Elimination sound 4
  564.                         self.change_down(i, j, 4)
  565.                         self.change_right(i+1, j, 3)
  566.                     elif self.exists_left(i+2, j, 3):
  567.                         self.animal_num[self.animal[i][j]] += 6
  568.                         Sounds.eliminate(4) # Elimination sound 4
  569.                         self.change_down(i, j, 4)
  570.                         self.change_left(i+2, j, 3)
  571.                     elif self.exists_right(i+2, j, 3):
  572.                         self.animal_num[self.animal[i][j]] += 6
  573.                         Sounds.eliminate(4) # Elimination sound 4
  574.                         self.change_down(i, j, 4)
  575.                         self.change_right(i+2, j, 3)
  576.                     else:
  577.                         self.animal_num[self.animal[i][j]] += 4
  578.                         Sounds.eliminate(2) # Elimination sound 2
  579.                         self.change_down(i, j, 4)
  580.                 elif self.exists_down(i, j, 3):
  581.                     self.value_swapped = True
  582.                     if self.exists_left(i+1, j, 3):
  583.                         self.animal_num[self.animal[i][j]] += 5
  584.                         Sounds.eliminate(3) # Elimination sound 3
  585.                         self.change_down(i, j, 3)
  586.                         self.change_left(i+1, j, 3)
  587.                     elif self.exists_right(i+1, j, 3):
  588.                         self.animal_num[self.animal[i][j]] += 5
  589.                         Sounds.eliminate(3) # Elimination sound 3
  590.                         self.change_down(i, j, 3)
  591.                         self.change_right(i+1, j, 3)
  592.                     elif self.exists_left(i+2, j, 3):
  593.                         self.animal_num[self.animal[i][j]] += 5
  594.                         Sounds.eliminate(3) # Elimination sound 3
  595.                         self.change_down(i, j, 3)
  596.                         self.change_left(i+2, j, 3)
  597.                     elif self.exists_right(i+2, j, 3):
  598.                         self.animal_num[self.animal[i][j]] += 5
  599.                         Sounds.eliminate(3) # Elimination sound 3
  600.                         self.change_down(i, j, 3)
  601.                         self.change_right(i+2, j, 3)
  602.                     elif self.exists_left(i+2, j, 2) and self.exists_right(i+2, j, 2):
  603.                         self.animal_num[self.animal[i][j]] += 5
  604.                         Sounds.eliminate(3) # Elimination sound 3
  605.                         self.change_down(i, j, 3)
  606.                         self.change_left(i+2, j, 2)
  607.                         self.change_right(i+2, j, 2)
  608.                     elif self.exists_left(i+2, j, 2) and self.exists_right(i+2, j, 3):
  609.                         self.animal_num[self.animal[i][j]] += 6
  610.                         Sounds.eliminate(4) # Elimination sound 4
  611.                         self.change_down(i, j, 3)
  612.                         self.change_left(i+2, j, 2)
  613.                         self.change_right(i+2, j, 3)
  614.                     elif self.exists_left(i+2, j, 3) and self.exists_right(i+2, j, 2):
  615.                         self.animal_num[self.animal[i][j]] += 6
  616.                         Sounds.eliminate(4) # Elimination sound 4
  617.                         self.change_down(i, j, 3)
  618.                         self.change_left(i+2, j, 3)
  619.                         self.change_right(i+2, j, 2)
  620.                     elif self.exists_left(i+2, j, 3) and self.exists_right(i+2, j, 3):
  621.                         self.animal_num[self.animal[i][j]] += 7
  622.                         Sounds.eliminate(5) # Elimination sound 5
  623.                         self.change_down(i, j, 3)
  624.                         self.change_left(i+2, j, 3)
  625.                         self.change_right(i+2, j, 3)
  626.                     else:
  627.                         self.animal_num[self.animal[i][j]] += 3
  628.                         Sounds.eliminate(1) # Elimination sound 1
  629.                         self.change_down(i, j, 3)
  630.  
  631.         self.fall_animal()
  632.         score_level = self.score - score_level # Score level
  633.  
  634.         # Display & speak: good, great, amazing, excellent, unbelievable
  635.         if score_level < 5:
  636.             return self.value_swapped
  637.         if score_level < 8: # 5 good
  638.             Sounds.score_level(0)
  639.             Element(Element.score_level[0], (350, 250)).draw(self.screen)
  640.             pygame.display.flip()
  641.             delay(500)
  642.         elif score_level < 10: # 8 great
  643.             Sounds.score_level(1)
  644.             Element(Element.score_level[1], (350, 250)).draw(self.screen)
  645.             pygame.display.flip()
  646.             delay(500)
  647.         elif score_level < 15: # 10 amazing
  648.             Sounds.score_level(2)
  649.             Element(Element.score_level[2], (350, 250)).draw(self.screen)
  650.             pygame.display.flip()
  651.             delay(500)
  652.         elif score_level < 20: # 15 excellent
  653.             Sounds.score_level(3)
  654.             Element(Element.score_level[3], (350, 250)).draw(self.screen)
  655.             pygame.display.flip()
  656.             delay(500)
  657.         elif score_level >= 20: # 20 unbelievable
  658.             Sounds.score_level(4)
  659.             Element(Element.score_level[4], (350, 250)).draw(self.screen)
  660.             pygame.display.flip()
  661.             delay(500)
  662.  
  663.         return self.value_swapped # Return the swap value sign
  664.  
  665.     def fall_animal(self): # pylint: disable=too-many-locals
  666.         '''Animation of falling animals'''
  667.         clock = pygame.time.Clock()
  668.         position = []
  669.         ice_position = []
  670.         for i in range(self.row, self.row + self.height):
  671.             for j in range(self.col, self.col + self.width):
  672.                 if self.animal[i][j] == -2:
  673.                     x, y = self.rc_xy(i, j)
  674.                     position.append((x, y))
  675.                     if self.ice_list[i][j] == 1:
  676.                         ice_position.append((x, y))
  677.         if position:
  678.             for index in range(0, 9):
  679.                 clock.tick(20)
  680.                 for pos in position:
  681.                     self.draw_brick(pos[0], pos[1])
  682.                     if pos in ice_position:
  683.                         Element(Element.ice_format%index, (pos[0], pos[1])).draw(self.screen)
  684.                     Element(Element.bling_format%index, (pos[0], pos[1])).draw(self.screen)
  685.                     pygame.display.flip()
  686.         for i in range(self.row, self.row + self.height):
  687.             brick_position = []
  688.             fall_animal_list = []
  689.             speed = [0, 1]
  690.             for j in range(self.col, self.col + self.width):
  691.                 if self.animal[i][j] == -2:
  692.                     x, y = self.rc_xy(i, j)
  693.                     if self.ice_list[i][j] == 1:
  694.                         play_sound(Sounds.ICE_BREAKING)
  695.                         self.ice_num += 1
  696.                         self.ice_list[i][j] = -1
  697.  
  698.                     brick_position.append((x, y))
  699.  
  700.                     for m in range(i, self.row - 1, -1):
  701.                         if self.animal[m - 1][j] != -1:
  702.                             x, y = self.rc_xy(m - 1, j)
  703.                             brick_position.append((x, y))
  704.                             animal = Element(Element.animals[self.animal[m - 1][j]], (x, y))
  705.                             fall_animal_list.append(animal)
  706.                             self.animal[m][j] = self.animal[m - 1][j]
  707.                         else:
  708.                             self.animal[m][j] = randint(0, 5)
  709.                             break
  710.             while speed != [0, 0] and fall_animal_list:
  711.                 for position in brick_position:
  712.                     self.draw_brick(position[0], position[1])
  713.                 for animal_sprite in fall_animal_list:
  714.                     animal_sprite.move(speed)
  715.                     animal_sprite.draw(self.screen)
  716.                     speed = animal_sprite.speed
  717.                 pygame.display.flip()
  718.  
  719.     def judge_next(self, tp, score):
  720.         '''Check whether the next level is reached or not'''
  721.         if tp == 1: # Passed
  722.             self.load_fns_window(score)
  723.         elif tp == -1: # Failed
  724.             self.load_fail_window()
  725.  
  726.     def load_fail_window(self):
  727.         '''Display the failure board and buttons'''
  728.         sound_sign = 0
  729.         step_add = Board(Board.step_add, Board.button_position[0]) # L: 5 more steps
  730.         retry = Board(Board.replay, Board.button_position[1]) # R: Replay
  731.         self.screen.blit(self.fail_board.image, self.fail_board.rect) # Failure board
  732.         self.screen.blit(step_add.image, step_add.rect)
  733.         self.screen.blit(retry.image, retry.rect)
  734.         while self.fail_board.speed != [0, 0]:
  735.             self.draw()
  736.             self.screen.blit(self.fail_board.image, self.fail_board.rect)
  737.             self.fail_board.move()
  738.             pygame.display.flip()
  739.             if sound_sign == 0:
  740.                 play_sound(Sounds.BOARD_SOUND)
  741.                 sound_sign = 1
  742.  
  743.     def load_fns_window(self, score):
  744.         '''Display the success board, score and buttons'''
  745.         sound_sign = 0
  746.         replay = Board(Board.replay, Board.button_position[0]) # L: Replay
  747.         self.screen.blit(self.success_board.image, self.success_board.rect) # Successful board
  748.         if self.level < 10: # If not the last level
  749.             next_level = Board(Board.next, Board.button_position[1]) # R: Next level
  750.             self.screen.blit(next_level.image, next_level.rect)
  751.         self.screen.blit(replay.image, replay.rect)
  752.         while self.success_board.speed != [0, 0]:
  753.             self.draw()
  754.             self.screen.blit(self.success_board.image, self.success_board.rect)
  755.             self.success_board.move()
  756.             pygame.display.flip()
  757.             if sound_sign == 0:
  758.                 play_sound(Sounds.BOARD_SOUND)
  759.                 sound_sign = 1
  760.         self.displayStars(score) # Display the stars
  761.         # Money
  762.         self.load_text(str(self.score*2), (Board.starts_position[0][0]+75, Board.starts_position[0][0]+46), 20, (0, 0, 0))
  763.  
  764.     def displayStars(self, score):
  765.         '''Display the stars according to the score.'''
  766.         star1 = Board(Board.stars, Board.starts_position[0])
  767.         star2 = Board(Board.stars, Board.starts_position[1])
  768.         star3 = Board(Board.stars, Board.starts_position[2])
  769.         if 0 <= score < self.min:
  770.             self.load_text('1', (Board.starts_position[1][0]+48, Board.starts_position[1][1]+35), 20, (0, 0, 0))
  771.             self.screen.blit(star1.image, star1.rect)
  772.         elif self.min <= score <= self.max:
  773.             self.load_text('2', (Board.starts_position[1][0] + 48, Board.starts_position[1][1] + 35), 20, (0, 0, 0))
  774.             self.screen.blit(star1.image, star1.rect)
  775.             self.screen.blit(star2.image, star2.rect)
  776.         elif score > self.max:
  777.             self.load_text('5', (Board.starts_position[1][0] + 48, Board.starts_position[1][1] + 35), 20, (0, 0, 0))
  778.             self.screen.blit(star1.image, star1.rect)
  779.             self.screen.blit(star2.image, star2.rect)
  780.             self.screen.blit(star3.image, star3.rect)
  781.         pygame.display.flip()
  782.  
  783.     def set_level_mode(self, level):
  784.         '''Set the level mode and its steps.'''
  785.         self.level = level
  786.         if self.reset_mode: # If it is required to reset the mode
  787.             self.num_sign = True
  788.             if level == 1:
  789.                 self.__init__(7, 7)
  790.                 self.animal[7][9] = self.animal[7][10] = self.animal[7][11] = self.animal[8][10] = self.animal[11][7] = \
  791.                     self.animal[11][13] = self.animal[12][7] = self.animal[12][8] = self.animal[12][12] = self.animal[12][13] = \
  792.                     self.animal[13][7] = self.animal[13][8] = self.animal[13][9] = self.animal[13][11] = self.animal[13][12] = \
  793.                     self.animal[13][13] = -1
  794.                 self.init_step = 17 # 17 initial steps
  795.             elif level == 2:
  796.                 self.__init__(4, 8)
  797.                 self.init_step = 16 # 16 initial steps
  798.             elif level == 3:
  799.                 self.__init__(7, 7)
  800.                 self.init_step = 18 # 18 initial steps
  801.             elif level == 4:
  802.                 self.__init__(9, 7)
  803.                 row, col = self.row, self.col
  804.                 self.animal[row][col] = self.animal[row][col+7] = self.animal[row][col+8] = self.animal[row+1][col+8] = \
  805.                     self.animal[row+5][col] = self.animal[row+6][col] = self.animal[row+6][col+1] = self.animal[row+6][col+8] = -1
  806.                 self.init_step = 20
  807.             elif level == 5:
  808.                 self.__init__(8, 9)
  809.                 row, col = self.row, self.col
  810.                 self.animal[row][col+7] = self.animal[row+2][col] = self.animal[row+5][col] = self.animal[row+3][col+7] = \
  811.                     self.animal[row+6][col+7] = self.animal[row+8][col] = -1
  812.                 self.init_step = 20
  813.             elif level == 6:
  814.                 self.__init__(9, 9)
  815.                 row, col = self.row, self.col
  816.                 self.animal[row][col] = self.animal[row][col+8] = self.animal[row+2][col+4] = self.animal[row+3][col+2] = \
  817.                     self.animal[row+3][col+6] = self.animal[row+8][col] = self.animal[row+8][col+8] = -1
  818.                 for i in range(row+4, row+6):
  819.                     for j in range(col+3, col+6):
  820.                         self.animal[i][j] = -1
  821.                 self.init_step = 28
  822.             elif level == 7:
  823.                 self.__init__(9, 9)
  824.                 row, col = self.row, self.col
  825.                 for i in range(row, row + 9):
  826.                     self.animal[i][col+4] = -1
  827.                 for j in range(col, col+4):
  828.                     self.animal[row+3][j] = -1
  829.                 for j in range(col+5, col+9):
  830.                     self.animal[row+5][j] = -1
  831.                 self.init_step = 25
  832.             elif level == 8:
  833.                 self.__init__(7, 8)
  834.                 row, col = self.row, self.col
  835.                 for i in range(row+2, row+5):
  836.                     for j in range(col+1, col+6):
  837.                         self.ice_list[i][j] = 1
  838.                 self.init_step = 21
  839.             elif level == 9:
  840.                 self.__init__(9, 9)
  841.                 row, col = self.row, self.col
  842.                 self.animal[row][col+4] = self.animal[row+4][col] = self.animal[row+4][col+8] = self.animal[row+8][col+4] = -1
  843.                 for i in range(row+1, row+8):
  844.                     for j in range(col+1, col+8):
  845.                         self.ice_list[i][j] = 1
  846.                 self.init_step = 35
  847.             else:
  848.                 self.__init__(9, 9)
  849.                 row, col = self.row, self.col
  850.                 for i in range(row, row+2):
  851.                     for j in range(col, col+9):
  852.                         self.animal[i][j] = -1
  853.                 self.animal[row][col+4] = randint(0, 5)
  854.                 self.animal[row+1][col+2] = randint(0, 5)
  855.                 self.animal[row+1][col+4] = randint(0, 5)
  856.                 self.animal[row+1][col+6] = randint(0, 5)
  857.                 self.animal[row+2][col+1] = self.animal[row+3][col+1] = self.animal[row+2][col+3] = self.animal[row+3][col+3] =\
  858.                     self.animal[row+2][col+5] = self.animal[row+3][col+5] = self.animal[row+2][col+7] = \
  859.                     self.animal[row+3][col+7] = self.animal[row+8][col] = self.animal[row+8][col+8] = -1
  860.                 for i in range(row+4, row+8):
  861.                     for j in range(col, col+9):
  862.                         self.ice_list[i][j] = 1
  863.                 self.ice_list[row+2][col+4] = self.ice_list[row+3][col+2] = self.ice_list[row+3][col+4] = \
  864.                     self.ice_list[row+3][col+6] = 1
  865.                 self.init_step = 40
  866.             self.type = 0
  867.             self.energy_num -= 5
  868.             self.success_board = Board(Board.success, [200, 0]) # Success board
  869.             self.fail_board = Board(Board.fail, [200, 0]) # Failure board
  870.             self.step = self.init_step
  871.             self.score = 0
  872.             self.animal_num = [0, 0, 0, 0, 0, 0]
  873.             self.ice_num = 0
  874.             self.reset_mode = False
  875.  
  876.     def num_add(self):
  877.         '''Add to score'''
  878.         if self.num_sign:
  879.             self.money += self.score * 2
  880.             if self.score < self.min:
  881.                 self.energy_num += 1
  882.             elif self.score < self.max:
  883.                 self.energy_num += 2
  884.             else:
  885.                 self.energy_num += 5
  886.             self.num_sign = False
  887.  
  888.     def judge_level(self):
  889.         '''Check whether the level was passed'''
  890.         if self.step <= 0:
  891.             self.type = -1 # Game over
  892.         if self.level == 1:
  893.             if self.animal_num[4] >= 10: # L1: 10 frogs
  894.                 self.type = 1 # Level 1 passed
  895.                 self.num_add()
  896.         elif self.level == 2:
  897.             if self.animal_num[1] >= 21: # L2: 21 bears
  898.                 self.type = 1 # Level 2 passed
  899.                 self.num_add()
  900.         elif self.level == 3:
  901.             if self.animal_num[4] >= 16 and self.animal_num[5] >= 16: # L3: 16 frogs and 16 cows
  902.                 self.type = 1 # Level 3 passed
  903.                 self.num_add()
  904.         elif self.level == 4:
  905.             if self.animal_num[5] >= 18 and self.animal_num[2] >= 18: # L4: 18 cows and 18 chicks
  906.                 self.type = 1 # Level 4 passed
  907.                 self.num_add()
  908.         elif self.level == 5:
  909.             if self.animal_num[2] >= 28 and self.animal_num[0] >= 28: # L5: 28 chicks and 28 foxes
  910.                 self.type = 1 # Level 5 passed
  911.                 self.num_add()
  912.         elif self.level == 6:
  913.             if self.animal_num[4] >= 70: # L6: 70 frogs
  914.                 self.type = 1 # Level 6 passed
  915.                 self.num_add()
  916.         elif self.level == 7:
  917.             if self.animal_num[2] >= 36 and self.animal_num[1] >= 36 and self.animal_num[0] >= 36: # L7: 36 chickens, 36 bears and 36 foxes
  918.                 self.type = 1 # Level 7 passed
  919.                 self.num_add()
  920.         elif self.level == 8:
  921.             if self.ice_num >= 15: # L8: 15 ice
  922.                 self.type = 1 # Level 8 passed
  923.                 self.num_add()
  924.         elif self.level == 9:
  925.             if self.ice_num >= 49: # L9: 49 ice
  926.                 self.type = 1 # Level 9 passed
  927.                 self.num_add()
  928.         else:
  929.             if self.ice_num >= 39: # L10: 39 ice
  930.                 self.type = 1 # Level 10 passed
  931.                 self.num_add()
  932.  
  933.         self.judge_next(self.type, self.score)

Main.py

  1. # -*- encoding: utf-8 -*-
  2. '''Main module for the application.'''
  3. # pylint: disable=invalid-name, wrong-import-position
  4.  
  5. # Hide pygame's support prompt.
  6. from os import environ
  7. environ['PYGAME_HIDE_SUPPORT_PROMPT'] = '1'
  8.  
  9. import sys
  10.  
  11. import pygame
  12. from pygame.locals import KEYDOWN, QUIT, K_q, K_ESCAPE, MOUSEBUTTONDOWN # pylint: disable=no-name-in-module
  13. from manager import Manager, TreeManager
  14. from sounds import Sounds
  15.  
  16. # Initialize game
  17. pygame.init() # pylint: disable=no-member
  18. pygame.mixer.init()
  19. pygame.display.set_caption('python开心消消乐')
  20. pygame.mouse.set_visible(False)
  21.  
  22. tree = TreeManager()
  23. m = Manager(0, 0)
  24. sound_sign = 0
  25. world_bgm = pygame.mixer.Sound(Sounds.WORLD_BGM.value)
  26. game_bgm = pygame.mixer.Sound(Sounds.GAME_BGM.value)
  27.  
  28. # This improves the performance of the game
  29. get_events, update_window = pygame.event.get, pygame.display.flip
  30.  
  31. while True:
  32.     if m.level == 0:
  33.         if sound_sign == 0:
  34.             game_bgm.stop()
  35.             world_bgm.play(-1)
  36.             sound_sign = 1
  37.     else:
  38.         if sound_sign == 1:
  39.             world_bgm.stop()
  40.             game_bgm.play(-1)
  41.             sound_sign = 0
  42.     if m.level == 0:
  43.         tree.draw_tree(m.energy_num, m.money)
  44.     else:
  45.         m.set_level_mode(m.level)
  46.         sprite_group = m.draw()
  47.         if m.type == 0:
  48.             m.eliminate_animals()
  49.             m.death_map()
  50.             m.swap(sprite_group)
  51.         m.judge_level()
  52.  
  53.     for event in get_events():
  54.         if event.type == KEYDOWN:
  55.             if event.key in (K_q, K_ESCAPE):
  56.                 sys.exit()
  57.         elif event.type == QUIT:
  58.             sys.exit()
  59.         elif event.type == MOUSEBUTTONDOWN:
  60.             mousex, mousey = event.pos
  61.             if m.level == 0:
  62.                 tree.mouse_select(m, mousex, mousey, m.level, m.energy_num, m.money)
  63.             m.mouse_select(mousex, mousey)
  64.  
  65.     m.mouse_image()
  66.     update_window()

分享下源码地址：

SpiderMedia: 写的一些爬虫脚本 简单好上手icon-default.png?t=N7T8https://gitee.com/wuyan_666/spider-media-s.git

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/742127
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号