用Python写《我的世界》(MC)

《我的世界》这款游戏相信不少人玩过，但是你有没有想过自己编写一个类似的游戏呢？

国外有位叫fogleman的开发这就利用python编写了一款与《我的世界》很相似的游戏，可以说是《我的世界》的简化版。

这个简化版的《我的世界》保留了原版的核心之一：创造。玩法与原版的创造模式基本相同只是没有物品栏与更多的方块

游戏截图:

 操控：

wasd前后移动

space跳跃

数字键选择方块

tab飞行

运行方法：

1.打开命令提示符，输入

pip install pyglet

2.等待pyglet安装完毕

如果出现Successfully installed说明安装成功

3.下载文件

项目源码链接：项目链接

优化过后的链接：优化后链接

提取码：z26e

备注：

这里提供的源码适用于python3

如果出现文件无法下载的情况

这里是源码：

主程序main.py:

--------------------

from __future__ import division

import sys import math import random import time

from collections import deque from pyglet import image from pyglet.gl import * from pyglet.graphics import TextureGroup from pyglet.window import key, mouse

# 每秒帧数 TICKS_PER_SEC = 120

# 你可以走的大小 SECTOR_SIZE =2000

# 行走速度与飞行速度 WALKING_SPEED = 5.5 FLYING_SPEED = 15

# 重力与跳跃高度 GRAVITY = 20 MAX_JUMP_HEIGHT =1

# About the height of a block. # To derive the formula for calculating jump speed, first solve #    v_t = v_0 + a * t # for the time at which you achieve maximum height, where a is the acceleration # due to gravity and v_t = 0. This gives: #    t = - v_0 / a # Use t and the desired MAX_JUMP_HEIGHT to solve for v_0 (jump speed) in #    s = s_0 + v_0 * t + (a * t^2) / 2 JUMP_SPEED = math.sqrt(2 * GRAVITY * MAX_JUMP_HEIGHT) TERMINAL_VELOCITY = 50

PLAYER_HEIGHT = 2

if sys.version_info[0] >= 3:     xrange = range

def cube_vertices(x, y, z, n):     """ Return the vertices of the cube at position x, y, z with size 2*n.

    """     return [         x-n,y+n,z-n, x-n,y+n,z+n, x+n,y+n,z+n, x+n,y+n,z-n,  # top         x-n,y-n,z-n, x+n,y-n,z-n, x+n,y-n,z+n, x-n,y-n,z+n,  # bottom         x-n,y-n,z-n, x-n,y-n,z+n, x-n,y+n,z+n, x-n,y+n,z-n,  # left         x+n,y-n,z+n, x+n,y-n,z-n, x+n,y+n,z-n, x+n,y+n,z+n,  # right         x-n,y-n,z+n, x+n,y-n,z+n, x+n,y+n,z+n, x-n,y+n,z+n,  # front         x+n,y-n,z-n, x-n,y-n,z-n, x-n,y+n,z-n, x+n,y+n,z-n,  # back     ]

def tex_coord(x, y, n=4):     """      Return the bounding vertices of the texture square.

    """     m = 1.0 / n     dx = x * m     dy = y * m     return dx, dy, dx + m, dy, dx + m, dy + m, dx, dy + m

def tex_coords(top, bottom, side):     """      Return a list of the texture squares for the top, bottom and side.

    """     top = tex_coord(*top)     bottom = tex_coord(*bottom)     side = tex_coord(*side)     result = []     result.extend(top)     result.extend(bottom)     result.extend(side * 4)     return result

TEXTURE_PATH = 'texture.png'

GRASS = tex_coords((1, 0), (0, 1), (0, 0)) SAND = tex_coords((1, 1), (1, 1), (1, 1)) BRICK = tex_coords((2, 0), (2, 0), (2, 0)) STONE = tex_coords((2, 1), (2, 1), (2, 1)) PURPLE = tex_coords((3, 1), (3, 1), (3, 1)) RED = tex_coords((3, 0), (3, 0), (3, 0)) GREEN = tex_coords((3, 2), (3, 2), (3, 2)) BLUE = tex_coords((1, 2), (1, 2), (1, 2)) BLACK = tex_coords((2, 2), (2, 2), (2, 2)) ORANGE = tex_coords((3, 2), (3, 2), (3, 2))

FACES = [     ( 0, 1, 0),     ( 0,-1, 0),     (-1, 0, 0),     ( 1, 0, 0),     ( 0, 0, 1),     ( 0, 0,-1), ]

def normalize(position):     """ Accepts `position` of arbitrary precision and returns the block     containing that position.

    Parameters     ----------     position : tuple of len 3

    Returns     -------     block_position : tuple of ints of len 3

    """     x, y, z = position     x, y, z = (int(round(x)), int(round(y)), int(round(z)))     return (x, y, z)

def sectorize(position):     """ Returns a tuple representing the sector for the given `position`.

    Parameters     ----------     position : tuple of len 3

    Returns     -------     sector : tuple of len 3

    """     x, y, z = normalize(position)     x, y, z = x // SECTOR_SIZE, y // SECTOR_SIZE, z // SECTOR_SIZE     return (x, 0, z)

class Model(object):

    def __init__(self):

        # A Batch is a collection of vertex lists for batched rendering.         self.batch = pyglet.graphics.Batch()

        # A TextureGroup manages an OpenGL texture.         self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())

        # A mapping from position to the texture of the block at that position.         # This defines all the blocks that are currently in the world.         self.world = {}

        # Same mapping as `world` but only contains blocks that are shown.         self.shown = {}

        # Mapping from position to a pyglet `VertextList` for all shown blocks.         self._shown = {}

        # Mapping from sector to a list of positions inside that sector.         self.sectors = {}

        # Simple function queue implementation. The queue is populated with         # _show_block() and _hide_block() calls         self.queue = deque()

        self._initialize()

    def _initialize(self):         """ Initialize the world by placing all the blocks.

        """         n = 200 # 1/2 width and height of world         s = 1  # step size         y =0   # initial y height         for x in xrange(-n, n + 1, s):             for z in xrange(-n, n + 1, s):                 # create a layer stone an grass everywhere.                 self.add_block((x, y - 2, z), GRASS, immediate=False)                 self.add_block((x, y - 3, z), STONE, immediate=False)                 if x in (-n, n) or z in (-n, n):                     # create outer walls.                     for dy in xrange(-2, 3):                         self.add_block((x, y + dy, z), STONE, immediate=False)

        # generate the hills randomly         o = n -15         for _ in xrange(120):             a = random.randint(-o, o)  # x position of the hill             b = random.randint(-o, o)  # z