贪吃蛇

    1. '''
    2. MiniSnake.py
    4. A game of snake in one .py file
    7. This program by Daniel Westbrook
    8. website: www.pixelatedawesome.com
    9. email: thepixelator72@gmail.com
    10.        (or whatever email I list on my site, if I stop using that one)
    12. Legal shit:
    13.     Copyright (C) 2008 Daniel Westbrook
    15.     This program is free software: you can redistribute it and/or modify
    16.     it under the terms of the GNU Lesser General Public License as published by
    17.     the Free Software Foundation, either version 3 of the License, or
    18.     (at your option) any later version.
    20.     This program is distributed in the hope that it will be useful,
    21.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    22.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    23.     GNU Lesser General Public License for more details.
    25.     You should have received a copy of the GNU Lesser General Public License
    26.     along with this program.  If not, see <http://www.gnu.org/licenses/>.
    27. '''
    28. import pygame
    29. from pygame.locals import *
    30. import random
    32. # ---------- constants ---------- #
    33. SCREENSIZE = (800, 600)
    34. SCREENRECT = pygame.Rect(0, 0, SCREENSIZE[0], SCREENSIZE[1])
    35. CAPTION = 'MiniSnake'
    36. FPS = 40
    38. START_TILE = (20, 20)
    39. START_SEGMENTS = 7
    41. MOVE_RATE = 2
    42. DIFFICULTY_INCREASE_RATE = .05
    43. MOVE_THRESHOLD = 5 # when moverate counts up to this the snake moves
    44. BLOCK_SPAWN_RATE = 2
    46. TILE_SIZE = (10, 10)
    47. TILE_RECT = pygame.Rect(0, 0, TILE_SIZE[0], TILE_SIZE[1])
    49. SCREENTILES = ((SCREENSIZE[0] / TILE_SIZE[0]) - 1, (SCREENSIZE[1] / TILE_SIZE[1]) - 1)
    51. SNAKE_HEAD_RADIUS = 5
    52. SNAKE_SEGMENT_RADIUS = 4
    53. FOOD_RADIUS = 4
    55. BACKGROUND_COLOR = (255, 255, 255)
    56. SNAKE_HEAD_COLOR = (150, 0, 0)
    57. SNAKE_SEGMENT_COLOR = (255, 0, 0)
    58. FOOD_COLOR = (0, 255, 0)
    59. BLOCK_COLOR = (0, 0, 150)
    60. COLORKEY_COLOR = (255, 255, 0)
    62. SCORE_COLOR = (0, 0, 0)
    63. SCORE_POS = (20, 20)
    64. SCORE_PREFIX = 'Score: '
    66. MOVE_VECTORS = {'left' : (-1, 0),
    67.                 'right' : (1, 0),
    68.                 'up' : (0, -1),
    69.                 'down' : (0, 1)
    70.                 }
    71. MOVE_VECTORS_PIXELS = {'left' : (-TILE_SIZE[0], 0),
    72.                        'right' : (TILE_SIZE[0], 0),
    73.                        'up' : (0, -TILE_SIZE[1]),
    74.                        'down' : (0, TILE_SIZE[1])
    75.                        }
    78. # ----------- game objects ----------- #
    79. class snake_segment(pygame.sprite.Sprite):
    80.     def __init__(self, tilepos, segment_groups, color = SNAKE_SEGMENT_COLOR, radius = SNAKE_SEGMENT_RADIUS):
    81.         pygame.sprite.Sprite.__init__(self)
    82.         self.image = self.image = pygame.Surface(TILE_SIZE).convert()
    83.         self.image.fill(COLORKEY_COLOR)
    84.         self.image.set_colorkey(COLORKEY_COLOR)
    85.         pygame.draw.circle(self.image, color, TILE_RECT.center, radius)
    87.         self.tilepos = tilepos
    89.         self.rect = self.image.get_rect()
    90.         self.rect.topleft = (tilepos[0] * TILE_SIZE[0], tilepos[1] * TILE_SIZE[1])
    92.         self.segment_groups = segment_groups
    93.         for group in segment_groups:
    94.             group.add(self)
    96.         self.behind_segment = None
    98.         self.movedir = 'left'
    100.     def add_segment(self):
    101.         seg = self
    102.         while True:
    103.             if seg.behind_segment == None:
    104.                 x = seg.tilepos[0]
    105.                 y = seg.tilepos[1]
    106.                 if seg.movedir == 'left':
    107.                     x += 1
    108.                 elif seg.movedir == 'right':
    109.                     x -= 1
    110.                 elif seg.movedir == 'up':
    111.                     y += 1
    112.                 elif seg.movedir == 'down':
    113.                     y -= 1
    114.                 seg.behind_segment = snake_segment((x, y), seg.segment_groups)
    115.                 seg.behind_segment.movedir = seg.movedir
    116.                 break
    117.             else:
    118.                 seg = seg.behind_segment
    120.     def update(self):
    121.         pass
    123.     def move(self):
    124.         self.tilepos = (self.tilepos[0] + MOVE_VECTORS[self.movedir][0], self.tilepos[1] + MOVE_VECTORS[self.movedir][1])
    125.         self.rect.move_ip(MOVE_VECTORS_PIXELS[self.movedir])
    126.         if self.behind_segment != None:
    127.             self.behind_segment.move()
    128.             self.behind_segment.movedir = self.movedir
    130. class snake_head(snake_segment):
    131.     def __init__(self, tilepos, movedir, segment_groups):
    132.         snake_segment.__init__(self, tilepos, segment_groups, color = SNAKE_HEAD_COLOR, radius = SNAKE_HEAD_RADIUS)
    133.         self.movedir = movedir
    134.         self.movecount = 0
    136.     def update(self):
    137.         self.movecount += MOVE_RATE
    138.         if self.movecount > MOVE_THRESHOLD:
    139.             self.move()
    140.             self.movecount = 0
    142. class food(pygame.sprite.Sprite):
    143.     def __init__(self, takenupgroup):
    144.         pygame.sprite.Sprite.__init__(self)
    145.         self.image = self.image = pygame.Surface(TILE_SIZE).convert()
    146.         self.image.fill(COLORKEY_COLOR)
    147.         self.image.set_colorkey(COLORKEY_COLOR)
    148.         pygame.draw.circle(self.image, FOOD_COLOR, TILE_RECT.center, FOOD_RADIUS)
    150.         self.rect = self.image.get_rect()
    151.         while True:
    152.             self.rect.topleft = (random.randint(0, SCREENTILES[0]) * TILE_SIZE[0], random.randint(0, SCREENTILES[1]) * TILE_SIZE[1])
    153.             for sprt in takenupgroup:
    154.                 if self.rect.colliderect(sprt):
    155.                     continue # collision, food cant go here
    156.             break # no collision, food can go here
    158. class block(pygame.sprite.Sprite):
    159.     def __init__(self, takenupgroup):
    160.         pygame.sprite.Sprite.__init__(self)
    161.         self.image = self.image = pygame.Surface(TILE_SIZE).convert()
    162.         self.image.fill(BLOCK_COLOR)
    164.         self.rect = self.image.get_rect()
    165.         while True:
    166.             self.rect.topleft = (random.randint(0, SCREENTILES[0]) * TILE_SIZE[0], random.randint(0, SCREENTILES[1]) * TILE_SIZE[1])
    167.             for sprt in takenupgroup:
    168.                 if self.rect.colliderect(sprt):
    169.                     continue # collision, food cant go here
    170.             break # no collision, food can go here
    173. # -------------- game logic ------------ #
    174. def main():
    175.     pygame.init()
    176.     screen = pygame.display.set_mode(SCREENSIZE)
    177.     pygame.display.set_caption(CAPTION)
    178.     bg = pygame.Surface(SCREENSIZE).convert()
    179.     bg.fill(BACKGROUND_COLOR)
    180.     screen.blit(bg, (0, 0))
    182.     snakegroup = pygame.sprite.Group()
    183.     snakeheadgroup = pygame.sprite.Group()
    184.     foodgroup = pygame.sprite.Group()
    185.     blockgroup = pygame.sprite.Group()
    186.     takenupgroup = pygame.sprite.Group()
    187.     all = pygame.sprite.RenderUpdates()
    189.     snake = snake_head(START_TILE, 'right', [snakegroup, all, takenupgroup])
    190.     snakeheadgroup.add(snake)
    191.     for index in range(START_SEGMENTS):
    192.         snake.add_segment()
    194.     currentfood = 'no food'
    196.     block_frame = 0
    198.     currentscore = 0
    200.     pygame.display.flip()
    202.     # mainloop
    203.     quit = False
    204.     clock = pygame.time.Clock()
    205.     lose = False
    206.     while not quit:
    207.         # events
    208.         for event in pygame.event.get():
    209.             if event.type == QUIT:
    210.                 quit = True
    211.             elif event.type == KEYDOWN:
    212.                 currentmovedir = snake.movedir
    213.                 if event.key == K_UP:
    214.                     tomove = 'up'
    215.                     dontmove = 'down'
    216.                 elif event.key == K_DOWN:
    217.                     tomove = 'down'
    218.                     dontmove = 'up'
    219.                 elif event.key == K_LEFT:
    220.                     tomove = 'left'
    221.                     dontmove = 'right'
    222.                 elif event.key == K_RIGHT:
    223.                     tomove = 'right'
    224.                     dontmove = 'left'
    225.                 else:
    226.                     raise 'RuntimeError, not expected'
    227.                 if not currentmovedir == dontmove:
    228.                     snake.movedir = tomove
    230.         # clearing
    231.         all.clear(screen, bg)
    233.         # updates
    234.         all.update()
    236.         if currentfood == 'no food':
    237.             currentfood = food(takenupgroup)
    238.             foodgroup.add(currentfood)
    239.             takenupgroup.add(currentfood)
    240.             all.add(currentfood)
    242.         pos = snake.rect.topleft
    243.         if pos[0] < 0:
    244.             quit = True
    245.             lose = True
    246.         if pos[0] >= SCREENSIZE[0]:
    247.             quit = True
    248.             lose = True
    249.         if pos[1] < 0:
    250.             quit = True
    251.             lose = True
    252.         if pos[1] >= SCREENSIZE[1]:
    253.             quit = True
    254.             lose = True
    256.         # collisions
    257.         # head -> tail
    258.         col = pygame.sprite.groupcollide(snakeheadgroup, snakegroup, False, False)
    259.         for head in col:
    260.             for tail in col[head]:
    261.                 if not tail is snake:
    262.                     quit = True
    263.                     lose = True
    264.         # head -> food
    265.         col = pygame.sprite.groupcollide(snakeheadgroup, foodgroup, False, True)
    266.         for head in col:
    267.             for tail in col[head]:
    268.                 currentfood = 'no food'
    269.                 snake.add_segment()
    270.                 currentscore += 1
    271.                 global MOVE_RATE, DIFFICULTY_INCREASE_RATE
    272.                 MOVE_RATE += DIFFICULTY_INCREASE_RATE
    273.                 block_frame += 1
    274.                 if block_frame >= BLOCK_SPAWN_RATE:
    275.                     block_frame = 0
    276.                     b = block(takenupgroup)
    277.                     blockgroup.add(b)
    278.                     takenupgroup.add(b)
    279.                     all.add(b)
    280.         # head -> blocks
    281.         col = pygame.sprite.groupcollide(snakeheadgroup, blockgroup, False, False)
    282.         for head in col:
    283.             for collidedblock in col[head]:
    284.                 quit = True
    285.                 lose = True
    287.         # score
    288.         d = screen.blit(bg, SCORE_POS, pygame.Rect(SCORE_POS, (50, 100)))
    289.         f = pygame.font.Font(None, 12)
    290.         scoreimage = f.render(SCORE_PREFIX + str(currentscore), True, SCORE_COLOR)
    291.         d2 = screen.blit(scoreimage, SCORE_POS)
    293.         # drawing
    294.         dirty = all.draw(screen)
    295.         dirty.append(d)
    296.         dirty.append(d2)
    298.         # updating
    299.         pygame.display.update(dirty)
    301.         # waiting
    302.         clock.tick(FPS)
    304.     # game over
    305.     if lose == True:
    306.         f = pygame.font.Font(None, 300)
    307.         failmessage = f.render('FAIL', True, (0, 0, 0))
    308.         failrect = failmessage.get_rect()
    309.         failrect.center = SCREENRECT.center
    310.         screen.blit(failmessage, failrect)
    311.         pygame.display.flip()
    312.         pygame.time.wait(2000)
    315. if __name__ == "__main__":
    316.     main()