经典方块游戏-贪吃蛇

 1、贪吃蛇类定义

# -*- coding: utf-8 -*-

from base import Base
from point import Point
from utils import *
import random

class Snake(Base):
    __FIRST_LEN = 3
    __FIRST_DIR = Direct.Right
    __SCORE_PER_FOOD = 100
    __FIRST_SPEED = 700
    __MAX_SPEED = 300
    
    def __init__(self):
        Base.__init__(self)
        startX = int(( Base.width() - self.__FIRST_LEN ) / 2)
        startY = int(Base.height() / 2)
        # body [ tail ... head ]
        self._body = [ Point(startX + i, startY) for i in range(self.__FIRST_LEN) ]
        self._dir = self.__FIRST_DIR
        self._food = self._add_food()
        # 速度以前进一步所需时间代替，速度越大，时间越小
        self._speed = self.__FIRST_SPEED
        self._timer_forward = 0
        
    def _add_food(self):
        self._clear_area()
        self._set_body()
        
        randIdx = random.randint(1, Base.width() * Base.height() - len(self._body))
        
        for x in range(Base.width()):
            for y in range(Base.height()):
                if self._area[x][y] != Block.Empty:
                    continue
                randIdx -= 1
                if randIdx == 0:
                    return Point(x, y)
        return None
    
    def _set_body(self):
        for p in self._body:
            self._area[p.x][p.y] = Block.Fill
    
    def _check_point_in_body(self, point):
        return point in self._body
    
    def _update_speed(self):
        self._speed = int(self.__FIRST_SPEED - len(self._body) * (self.__FIRST_SPEED - self.__MAX_SPEED) / (Base.width()*Base.height()/2))
        if self._speed < self.__MAX_SPEED:
            self._speed = self.__MAX_SPEED
            
    def _update_score(self):
        self._score += self.__SCORE_PER_FOOD
        self._update_speed()
        print('score %d'%(self._score))
    
    def _turn_direction(self, dir):
        if dir == self._dir:
            return
        p1 = self._body[-1]
        p2 = self._body[-2]
        if dir == Direct.Left:
            if p1.x == p2.x + 1 and p1.y == p2.y:
                return
        elif dir == Direct.Down:
            if p1.x == p2.x and p1.y == p2.y + 1:
                return
        elif dir == Direct.Right:
            if p1.x == p2.x - 1 and p1.y == p2.y:
                return
        elif dir == Direct.Up:
            if p1.x == p2.x and p1.y == p2.y - 1:
                return
        self._dir = dir
        
    def refresh_area(self):
        self._clear_area()
        self._set_body()
        if self._food:
            self._area[self._food.x][self._food.y] = Block.Fill
    
    def _forward(self):
        if self._status != Status.Running:
            return
        
        nextPoint = Base.forward_from(self._body[-1], self._dir)
        #print('Snake forward, body {0} {1} {2}, dir {3}, nextPoint {4}'.format(self._body[0], self._body[1], self._body[2], self._dir, nextPoint))
        if Base.check_point_in_area(nextPoint) and not self._check_point_in_body(nextPoint):
            if nextPoint == self._food:
                self._update_score()
                self._body.append(nextPoint)
                self._food = self._add_food()
                
                if not self._food:
                    self._status = Status.Passed
            else:
                self._body.append(nextPoint)
                self._body.pop(0)
        else:
            print('Snake over')
            self._status = Status.Over
    
    def press_button(self, btn):
        if btn == Button.Left:
            self._turn_direction(Direct.Left)
        elif btn == Button.Down:
            self._turn_direction(Direct.Down)
        elif btn == Button.Right:
            self._turn_direction(Direct.Right)
        elif btn == Button.Up:
            self._turn_direction(Direct.Up)
        elif btn == Button.Trans:
            self._forward()
        elif btn == Button.Reset:
            self.__init__()
        elif btn == Button.Pause_start:
            if self._status == Status.Running:
                self._status = Status.Pause
            elif self._status == Status.Pause:
                self._status = Status.Running
    
    def pass_time(self, millisecond):
        self._timer_forward += millisecond
        if self._timer_forward > self._speed:
            step = int(self._timer_forward / self._speed)
            for i in range(step):
                self._forward()
            self._timer_forward %= self._speed
    
if __name__ == '__main__':
    print('Snake(): {0}'.format(Snake()))
    snake = Snake()
    snake.refreshArea()
    snake._forward()
    snake.press_button(Button.Down)
    snake.press_button(Button.Trans)
    snake.press_button(Button.Reset)
    print('done')

 2、pygame游戏驱动

# -*- coding: utf-8 -*-

import pygame
from pygame.locals import *
from screen_params import *
from snake import Snake
from base import Base
from utils import *
 
pygame.init()
screen = pygame.display.set_mode(screen_size)
clock = pygame.time.Clock()

color_black = (0, 0, 0)
color_white = (255, 255, 255)
color_gray = (240, 240, 240)

snake = Snake()

while 1:
    for event in pygame.event.get():
        if event.type==pygame.QUIT:
            pygame.quit() 
            exit(0)
        elif event.type == pygame.KEYDOWN:
            if event.key == K_LEFT:
                snake.press_button(Button.Left)
            elif event.key == K_DOWN:
                snake.press_button(Button.Up)
            elif event.key == K_RIGHT:
                snake.press_button(Button.Right)
            elif event.key == K_UP:
                snake.press_button(Button.Down)
            elif event.key == K_SPACE:
                snake.press_button(Button.Pause_start)
            elif event.key == K_r:
                snake.press_button(Button.Reset)
    
    screen.fill(color_white)
    
    time_passed = clock.tick(30)
    snake.pass_time(time_passed)
    
    # 绘制游戏区域边框
    pygame.draw.rect(screen, color_black, Rect(area_point, area_size), 1)
    # 绘制小方块
    snake.refresh_area()
    for x in range(Base.width()):
        for y in range(Base.height()):
            if snake.area(x, y) != Block.Empty:
                pygame.draw.rect(screen, color_black, Rect(block_points[x][y], (block_side, block_side)))
            else:
                pygame.draw.rect(screen, color_gray, Rect(block_points[x][y], (block_side, block_side)))
    
    pygame.display.flip()
    
    fps = clock.get_fps()