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

用Python实现简易版《Minecraft》_python编程制作mc

作者：Guff_9hys | 2024-07-07 22:52:30

赞

踩

python编程制作mc

导语

        《我的世界》（Minecraft）别称《麦块》《我的作品》《当个创世神》，是一款沙盒建造游戏，该游戏基于Java平台，最初由马库斯·诺奇·佩尔松单独开发，后由Mojang制作发行。网易则是中国大陆地区的独家运营商。于2014年9月4日在PS4、XboxOne发布，于2017年5月12日在Switch发布，于2017年8月8日在PC发布。

        玩家可以独自一人或与朋友们一起，探索随机生成的世界。在Minecraft的创造模式中，玩家将拥有无限的资源；而在生存模式中，玩家需要尽可能收集利用资源，打造武器和盔甲，去抵御危险的怪物。

        而今天我们要做的简易版《Minecraft》，则负责了地形生成，人物移动，破坏、放置方块等内容的开发。

        废话不多说，开始吧！

开始创作

前期准备

        我的Python 3.10.9，pyglet 1.5.27。

        pyglet是python的一个第三方库，下载方法也很简单，在Windows的cmd下输入：

pip install pyglet

        即可。

方块图像

        拿走不谢~

Minecraft方块图

        将图像重命名为 texture.png

正式开始创作之旅

引入一些库

        首先，我们需要用到刚刚下的pyglet库中的一些程序，以及关于系统，数学运算，时间，随机数等的自带库。

        引用如下：

  1. from __future__ import division
  2.  
  3. import sys
  4. import math
  5. import random
  6. import time
  7.  
  8. from collections import deque
  9. from pyglet import image
  10. from pyglet.gl import *
  11. from pyglet.graphics import TextureGroup
  12. from pyglet.window import key, mouse

会用到的函数与变量（常量）

        设计一个游戏，自然会涉及到的一些变量或常量就是人物的坐标、走路的大小、人物的大小、移动速度、重力、帧数等。在这一模块中，还会引用到一些方块的设定、一些常用的函数等。

        代码如下，写了注释，自己研究吧。

  1. # 每秒帧数
  2. TICKS_PER_SEC = 120
  3.  
  4. # 你可以走的大小
  5. SECTOR_SIZE =2000
  6.  
  7. # 行走速度与飞行速度
  8. WALKING_SPEED = 5.5
  9. FLYING_SPEED = 15
  10.  
  11. # 重力与跳跃高度
  12. GRAVITY = 20
  13. MAX_JUMP_HEIGHT =1
  14.  
  15. # About the height of a block.
  16. # To derive the formula for calculating jump speed, first solve
  17. #    v_t = v_0 + a * t
  18. # for the time at which you achieve maximum height, where a is the acceleration
  19. # due to gravity and v_t = 0. This gives:
  20. #    t = - v_0 / a
  21. # Use t and the desired MAX_JUMP_HEIGHT to solve for v_0 (jump speed) in
  22. #    s = s_0 + v_0 * t + (a * t^2) / 2
  23. JUMP_SPEED = math.sqrt(2 * GRAVITY * MAX_JUMP_HEIGHT)
  24. TERMINAL_VELOCITY = 50
  25.  
  26. PLAYER_HEIGHT = 2
  27.  
  28. if sys.version_info[0] >= 3:
  29.     xrange = range
  30.  
  31. def cube_vertices(x, y, z, n):
  32.     """ Return the vertices of the cube at position x, y, z with size 2*n.
  34.     """
  35.     return [
  36.         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
  37.         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
  38.         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
  39.         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
  40.         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
  41.         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
  42.     ]
  43.  
  44.  
  45. def tex_coord(x, y, n=4):
  46.     """ 
  47.     Return the bounding vertices of the texture square.
  49.     """
  50.     m = 1.0 / n
  51.     dx = x * m
  52.     dy = y * m
  53.     return dx, dy, dx + m, dy, dx + m, dy + m, dx, dy + m
  54.  
  55.  
  56. def tex_coords(top, bottom, side):
  57.     """ 
  58.     Return a list of the texture squares for the top, bottom and side.
  60.     """
  61.     top = tex_coord(*top)
  62.     bottom = tex_coord(*bottom)
  63.     side = tex_coord(*side)
  64.     result = []
  65.     result.extend(top)
  66.     result.extend(bottom)
  67.     result.extend(side * 4)
  68.     return result
  69.  
  70.  
  71. TEXTURE_PATH = 'Minecraft(1)/texture.png'
  72.  
  73. GRASS = tex_coords((1, 0), (0, 1), (0, 0))
  74. SAND = tex_coords((1, 1), (1, 1), (1, 1))
  75. BRICK = tex_coords((2, 0), (2, 0), (2, 0))
  76. STONE = tex_coords((2, 1), (2, 1), (2, 1))
  77. PURPLE = tex_coords((3, 1), (3, 1), (3, 1))
  78. RED = tex_coords((3, 0), (3, 0), (3, 0))
  79. GREEN = tex_coords((3, 2), (3, 2), (3, 2))
  80. BLUE = tex_coords((1, 2), (1, 2), (1, 2))
  81. BLACK = tex_coords((2, 2), (2, 2), (2, 2))
  82. ORANGE = tex_coords((3, 2), (3, 2), (3, 2))
  83.  
  84. FACES = [
  85.     ( 0, 1, 0),
  86.     ( 0,-1, 0),
  87.     (-1, 0, 0),
  88.     ( 1, 0, 0),
  89.     ( 0, 0, 1),
  90.     ( 0, 0,-1),
  91. ]
  92.  
  93.  
  94. def normalize(position):
  95.     """ Accepts `position` of arbitrary precision and returns the block
  96.     containing that position.
  98.     Parameters
  99.     ----------
  100.     position : tuple of len 3
  102.     Returns
  103.     -------
  104.     block_position : tuple of ints of len 3
  106.     """
  107.     x, y, z = position
  108.     x, y, z = (int(round(x)), int(round(y)), int(round(z)))
  109.     return (x, y, z)
  110.  
  111.  
  112. def sectorize(position):
  113.     """ Returns a tuple representing the sector for the given `position`.
  115.     Parameters
  116.     ----------
  117.     position : tuple of len 3
  119.     Returns
  120.     -------
  121.     sector : tuple of len 3
  123.     """
  124.     x, y, z = normalize(position)
  125.     x, y, z = x // SECTOR_SIZE, y // SECTOR_SIZE, z // SECTOR_SIZE
  126.     return (x, 0, z)

生成世界的类

        生成一个世界，首先要做到的是用很多个数组、字典、列表、集合等来存储一些必要的信息，比如每个方块的位置等。

  1. class Model(object):
  2.  
  3.     def __init__(self):
  4.  
  5.         # A Batch is a collection of vertex lists for batched rendering.
  6.         self.batch = pyglet.graphics.Batch()
  7.  
  8.         # A TextureGroup manages an OpenGL texture.
  9.         self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())
  10.  
  11.         # A mapping from position to the texture of the block at that position.
  12.         # This defines all the blocks that are currently in the world.
  13.         self.world = {}
  14.  
  15.         # Same mapping as `world` but only contains blocks that are shown.
  16.         self.shown = {}
  17.  
  18.         # Mapping from position to a pyglet `VertextList` for all shown blocks.
  19.         self._shown = {}
  20.  
  21.         # Mapping from sector to a list of positions inside that sector.
  22.         self.sectors = {}
  23.  
  24.         # Simple function queue implementation. The queue is populated with
  25.         # _show_block() and _hide_block() calls
  26.         self.queue = deque()
  27.  
  28.         self._initialize()
  29.  
  30.     def _initialize(self):
  31.         """ Initialize the world by placing all the blocks.
  33.         """
  34.         n = 200 # 1/2 width and height of world
  35.         s = 1  # step size
  36.         y =0   # initial y height
  37.         for x in xrange(-n, n + 1, s):
  38.             for z in xrange(-n, n + 1, s):
  39.                 # create a layer stone an grass everywhere.
  40.                 self.add_block((x, y - 2, z), GRASS, immediate=False)
  41.                 self.add_block((x, y - 3, z), STONE, immediate=False)
  42.                 self.add_block((x, y - 4, z), STONE, immediate=False)
  43.                 if x in (-n, n) or z in (-n, n):
  44.                     # create outer walls.
  45.                     for dy in xrange(-2, 3):
  46.                         self.add_block((x, y + dy, z), STONE, immediate=False)
  47.  
  48.         # generate the hills randomly
  49.         o = n -15
  50.         for _ in xrange(120):
  51.             a = random.randint(-o, o)  # x position of the hill
  52.             b = random.randint(-o, o)  # z position of the hill
  53.             c = -1  # base of the hill
  54.             h = random.randint(2,6) # height of the hill
  55.             s = random.randint(4,12)  # 2 * s is the side length of the hill
  56.             d = 1  # how quickly to taper off the hills
  57.             t = random.choice([GRASS, SAND,STONE])
  58.             for y in xrange(c, c + h):
  59.                 for x in xrange(a - s, a + s + 1):
  60.                     for z in xrange(b - s, b + s + 1):
  61.                         if (x - a) ** 2 + (z - b) ** 2 > (s + 1) ** 2:
  62.                             continue
  63.                         if (x - 0) ** 2 + (z - 0) ** 2 < 5 ** 2:
  64.                             continue
  65.                         self.add_block((x, y, z), t, immediate=False)
  66.                 s -= d  # decrement side lenth so hills taper off
  67.  
  68.     def hit_test(self, position, vector, max_distance=8):
  69.         """ Line of sight search from current position. If a block is
  70.         intersected it is returned, along with the block previously in the line
  71.         of sight. If no block is found, return None, None.
  73.         Parameters
  74.         ----------
  75.         position : tuple of len 3
  76.             The (x, y, z) position to check visibility from.
  77.         vector : tuple of len 3
  78.             The line of sight vector.
  79.         max_distance : int
  80.             How many blocks away to search for a hit.
  82.         """
  83.         m = 8
  84.         x, y, z = position
  85.         dx, dy, dz = vector
  86.         previous = None
  87.         for _ in xrange(max_distance * m):
  88.             key = normalize((x, y, z))
  89.             if key != previous and key in self.world:
  90.                 return key, previous
  91.             previous = key
  92.             x, y, z = x + dx / m, y + dy / m, z + dz / m
  93.         return None, None
  94.  
  95.     def exposed(self, position):
  96.         """ Returns False is given `position` is surrounded on all 6 sides by
  97.         blocks, True otherwise.
  99.         """
  100.         x, y, z = position
  101.         for dx, dy, dz in FACES:
  102.             if (x + dx, y + dy, z + dz) not in self.world:
  103.                 return True
  104.         return False
  105.  
  106.     def add_block(self, position, texture, immediate=True):
  107.         """ Add a block with the given `texture` and `position` to the world.
  109.         Parameters
  110.         ----------
  111.         position : tuple of len 3
  112.             The (x, y, z) position of the block to add.
  113.         texture : list of len 3
  114.             The coordinates of the texture squares. Use `tex_coords()` to
  115.             generate.
  116.         immediate : bool
  117.             Whether or not to draw the block immediately.
  119.         """
  120.         if position in self.world:
  121.             self.remove_block(position, immediate)
  122.         self.world[position] = texture
  123.         self.sectors.setdefault(sectorize(position), []).append(position)
  124.         if immediate:
  125.             if self.exposed(position):
  126.                 self.show_block(position)
  127.             self.check_neighbors(position)
  128.  
  129.     def remove_block(self, position, immediate=True):
  130.         """ Remove the block at the given `position`.
  132.         Parameters
  133.         ----------
  134.         position : tuple of len 3
  135.             The (x, y, z) position of the block to remove.
  136.         immediate : bool
  137.             Whether or not to immediately remove block from canvas.
  139.         """
  140.         del self.world[position]
  141.         self.sectors[sectorize(position)].remove(position)
  142.         if immediate:
  143.             if position in self.shown:
  144.                 self.hide_block(position)
  145.             self.check_neighbors(position)
  146.  
  147.     def check_neighbors(self, position):
  148.         """ Check all blocks surrounding `position` and ensure their visual
  149.         state is current. This means hiding blocks that are not exposed and
  150.         ensuring that all exposed blocks are shown. Usually used after a block
  151.         is added or removed.
  153.         """
  154.         x, y, z = position
  155.         for dx, dy, dz in FACES:
  156.             key = (x + dx, y + dy, z + dz)
  157.             if key not in self.world:
  158.                 continue
  159.             if self.exposed(key):
  160.                 if key not in self.shown:
  161.                     self.show_block(key)
  162.             else:
  163.                 if key in self.shown:
  164.                     self.hide_block(key)
  165.  
  166.     def show_block(self, position, immediate=True):
  167.         """ Show the block at the given `position`. This method assumes the
  168.         block has already been added with add_block()
  170.         Parameters
  171.         ----------
  172.         position : tuple of len 3
  173.             The (x, y, z) position of the block to show.
  174.         immediate : bool
  175.             Whether or not to show the block immediately.
  177.         """
  178.         texture = self.world[position]
  179.         self.shown[position] = texture
  180.         if immediate:
  181.             self._show_block(position, texture)
  182.         else:
  183.             self._enqueue(self._show_block, position, texture)
  184.  
  185.     def _show_block(self, position, texture):
  186.         """ Private implementation of the `show_block()` method.
  188.         Parameters
  189.         ----------
  190.         position : tuple of len 3
  191.             The (x, y, z) position of the block to show.
  192.         texture : list of len 3
  193.             The coordinates of the texture squares. Use `tex_coords()` to
  194.             generate.
  196.         """
  197.         x, y, z = position
  198.         vertex_data = cube_vertices(x, y, z, 0.5)
  199.         texture_data = list(texture)
  200.         # create vertex list
  201.         # FIXME Maybe `add_indexed()` should be used instead
  202.         self._shown[position] = self.batch.add(24, GL_QUADS, self.group,
  203.             ('v3f/static', vertex_data),
  204.             ('t2f/static', texture_data))
  205.  
  206.     def hide_block(self, position, immediate=True):
  207.         """ Hide the block at the given `position`. Hiding does not remove the
  208.         block from the world.
  210.         Parameters
  211.         ----------
  212.         position : tuple of len 3
  213.             The (x, y, z) position of the block to hide.
  214.         immediate : bool
  215.             Whether or not to immediately remove the block from the canvas.
  217.         """
  218.         self.shown.pop(position)
  219.         if immediate:
  220.             self._hide_block(position)
  221.         else:
  222.             self._enqueue(self._hide_block, position)
  223.  
  224.     def _hide_block(self, position):
  225.         """ Private implementation of the 'hide_block()` method.
  227.         """
  228.         self._shown.pop(position).delete()
  229.  
  230.     def show_sector(self, sector):
  231.         """ Ensure all blocks in the given sector that should be shown are
  232.         drawn to the canvas.
  234.         """
  235.         for position in self.sectors.get(sector, []):
  236.             if position not in self.shown and self.exposed(position):
  237.                 self.show_block(position, False)
  238.  
  239.     def hide_sector(self, sector):
  240.         """ Ensure all blocks in the given sector that should be hidden are
  241.         removed from the canvas.
  243.         """
  244.         for position in self.sectors.get(sector, []):
  245.             if position in self.shown:
  246.                 self.hide_block(position, False)
  247.  
  248.     def change_sectors(self, before, after):
  249.         """ Move from sector `before` to sector `after`. A sector is a
  250.         contiguous x, y sub-region of world. Sectors are used to speed up
  251.         world rendering.
  253.         """
  254.         before_set = set()
  255.         after_set = set()
  256.         pad = 4
  257.         for dx in xrange(-pad, pad + 1):
  258.             for dy in [0]:  # xrange(-pad, pad + 1):
  259.                 for dz in xrange(-pad, pad + 1):
  260.                     if dx ** 2 + dy ** 2 + dz ** 2 > (pad + 1) ** 2:
  261.                         continue
  262.                     if before:
  263.                         x, y, z = before
  264.                         before_set.add((x + dx, y + dy, z + dz))
  265.                     if after:
  266.                         x, y, z = after
  267.                         after_set.add((x + dx, y + dy, z + dz))
  268.         show = after_set - before_set
  269.         hide = before_set - after_set
  270.         for sector in show:
  271.             self.show_sector(sector)
  272.         for sector in hide:
  273.             self.hide_sector(sector)
  274.  
  275.     def _enqueue(self, func, *args):
  276.         """ Add `func` to the internal queue.
  278.         """
  279.         self.queue.append((func, args))
  280.  
  281.     def _dequeue(self):
  282.         """ Pop the top function from the internal queue and call it.
  284.         """
  285.         func, args = self.queue.popleft()
  286.         func(*args)
  287.  
  288.     def process_queue(self):
  289.         """ Process the entire queue while taking periodic breaks. This allows
  290.         the game loop to run smoothly. The queue contains calls to
  291.         _show_block() and _hide_block() so this method should be called if
  292.         add_block() or remove_block() was called with immediate=False
  294.         """
  295.         start = time.time
  296.         while self.queue and time.time < 1 / TICKS_PER_SEC:
  297.             self._dequeue()
  298.  
  299.     def process_entire_queue(self):
  300.         """ Process the entire queue with no breaks.
  302.         """
  303.         while self.queue:
  304.             self._dequeue()
'
运行

窗口类

        已经接近尾声啦！下面定义一个窗口：

  1. class Window(pyglet.window.Window):
  2.  
  3.     def __init__(self, *args, **kwargs):
  4.         super(Window, self).__init__(*args, **kwargs)
  5.  
  6.         # Whether or not the window exclusively captures the mouse.
  7.         self.exclusive = False
  8.  
  9.         # When flying gravity has no effect and speed is increased.
  10.         self.flying = False
  11.  
  12.         # Strafing is moving lateral to the direction you are facing,
  13.         # e.g. moving to the left or right while continuing to face forward.
  14.         #
  15.         # First element is -1 when moving forward, 1 when moving back, and 0
  16.         # otherwise. The second element is -1 when moving left, 1 when moving
  17.         # right, and 0 otherwise.
  18.         self.strafe = [0, 0]
  19.  
  20.         # Current (x, y, z) position in the world, specified with floats. Note
  21.         # that, perhaps unlike in math class, the y-axis is the vertical axis.
  22.         self.position = (0, 0, 0)
  23.  
  24.         # First element is rotation of the player in the x-z plane (ground
  25.         # plane) measured from the z-axis down. The second is the rotation
  26.         # angle from the ground plane up. Rotation is in degrees.
  27.         #
  28.         # The vertical plane rotation ranges from -90 (looking straight down) to
  29.         # 90 (looking straight up). The horizontal rotation range is unbounded.
  30.         self.rotation = (0, 0)
  31.  
  32.         # Which sector the player is currently in.
  33.         self.sector = None
  34.  
  35.         # The crosshairs at the center of the screen.
  36.         self.reticle = None
  37.  
  38.         # Velocity in the y (upward) direction.
  39.         self.dy = 0
  40.  
  41.         # A list of blocks the player can place. Hit num keys to cycle.
  42.         self.inventory = [BRICK, GRASS, SAND,STONE,RED,PURPLE,GREEN,BLUE,BLACK,ORANGE]
  43.  
  44.         # The current block the user can place. Hit num keys to cycle.
  45.         self.block = self.inventory[0]
  46.  
  47.         # Convenience list of num keys.
  48.         self.num_keys = [
  49.             key._1, key._2, key._3, key._4, key._5,
  50.             key._6, key._7, key._8, key._9, key._0,key.E,key.R]
  51.  
  52.         # Instance of the model that handles the world.
  53.         self.model = Model()
  54.  
  55.         # The label that is displayed in the top left of the canvas.
  56.         self.label = pyglet.text.Label('', font_name='Arial', font_size=18,
  57.             x=10, y=self.height - 10, anchor_x='left', anchor_y='top',
  58.             color=(0, 0, 0, 255))
  59.  
  60.         # This call schedules the `update()` method to be called
  61.         # TICKS_PER_SEC. This is the main game event loop.
  62.         pyglet.clock.schedule_interval(self.update, 1.0 / TICKS_PER_SEC)
  63.  
  64.     def set_exclusive_mouse(self, exclusive):
  65.         """ If `exclusive` is True, the game will capture the mouse, if False
  66.         the game will ignore the mouse.
  68.         """
  69.         super(Window, self).set_exclusive_mouse(exclusive)
  70.         self.exclusive = exclusive
  71.  
  72.     def get_sight_vector(self):
  73.         """ Returns the current line of sight vector indicating the direction
  74.         the player is looking.
  76.         """
  77.         x, y = self.rotation
  78.         # y ranges from -90 to 90, or -pi/2 to pi/2, so m ranges from 0 to 1 and
  79.         # is 1 when looking ahead parallel to the ground and 0 when looking
  80.         # straight up or down.
  81.         m = math.cos(math.radians(y))
  82.         # dy ranges from -1 to 1 and is -1 when looking straight down and 1 when
  83.         # looking straight up.
  84.         dy = math.sin(math.radians(y))
  85.         dx = math.cos(math.radians(x - 90)) * m
  86.         dz = math.sin(math.radians(x - 90)) * m
  87.         return (dx, dy, dz)
  88.  
  89.     def get_motion_vector(self):
  90.         """ Returns the current motion vector indicating the velocity of the
  91.         player.
  93.         Returns
  94.         -------
  95.         vector : tuple of len 3
  96.             Tuple containing the velocity in x, y, and z respectively.
  98.         """
  99.         if any(self.strafe):
  100.             x, y = self.rotation
  101.             strafe = math.degrees(math.atan2(*self.strafe))
  102.             y_angle = math.radians(y)
  103.             x_angle = math.radians(x + strafe)
  104.             if self.flying:
  105.                 m = math.cos(y_angle)
  106.                 dy = math.sin(y_angle)
  107.                 if self.strafe[1]:
  108.                     # Moving left or right.
  109.                     dy = 0.0
  110.                     m = 1
  111.                 if self.strafe[0] > 0:
  112.                     # Moving backwards.
  113.                     dy *= -1
  114.                 # When you are flying up or down, you have less left and right
  115.                 # motion.
  116.                 dx = math.cos(x_angle) * m
  117.                 dz = math.sin(x_angle) * m
  118.             else:
  119.                 dy = 0.0
  120.                 dx = math.cos(x_angle)
  121.                 dz = math.sin(x_angle)
  122.         else:
  123.             dy = 0.0
  124.             dx = 0.0
  125.             dz = 0.0
  126.         return (dx, dy, dz)
  127.  
  128.     def update(self, dt):
  129.         """ This method is scheduled to be called repeatedly by the pyglet
  130.         clock.
  132.         Parameters
  133.         ----------
  134.         dt : float
  135.             The change in time since the last call.
  137.         """
  138.         self.model.process_queue()
  139.         sector = sectorize(self.position)
  140.         if sector != self.sector:
  141.             self.model.change_sectors(self.sector, sector)
  142.             if self.sector is None:
  143.                 self.model.process_entire_queue()
  144.             self.sector = sector
  145.         m = 8
  146.         dt = min(dt, 0.2)
  147.         for _ in xrange(m):
  148.             self._update(dt / m)
  149.  
  150.     def _update(self, dt):
  151.         """ Private implementation of the `update()` method. This is where most
  152.         of the motion logic lives, along with gravity and collision detection.
  154.         Parameters
  155.         ----------
  156.         dt : float
  157.             The change in time since the last call.
  159.         """
  160.         # walking
  161.         speed = FLYING_SPEED if self.flying else WALKING_SPEED
  162.         d = dt * speed # distance covered this tick.
  163.         dx, dy, dz = self.get_motion_vector()
  164.         # New position in space, before accounting for gravity.
  165.         dx, dy, dz = dx * d, dy * d, dz * d
  166.         # gravity
  167.         if not self.flying:
  168.             # Update your vertical speed: if you are falling, speed up until you
  169.             # hit terminal velocity; if you are jumping, slow down until you
  170.             # start falling.
  171.             self.dy -= dt * GRAVITY
  172.             self.dy = max(self.dy, -TERMINAL_VELOCITY)
  173.             dy += self.dy * dt
  174.         # collisions
  175.         x, y, z = self.position
  176.         x, y, z = self.collide((x + dx, y + dy, z + dz), PLAYER_HEIGHT)
  177.         self.position = (x, y, z)
  178.  
  179.     def collide(self, position, height):
  180.         """ Checks to see if the player at the given `position` and `height`
  181.         is colliding with any blocks in the world.
  183.         Parameters
  184.         ----------
  185.         position : tuple of len 3
  186.             The (x, y, z) position to check for collisions at.
  187.         height : int or float
  188.             The height of the player.
  190.         Returns
  191.         -------
  192.         position : tuple of len 3
  193.             The new position of the player taking into account collisions.
  195.         """
  196.         # How much overlap with a dimension of a surrounding block you need to
  197.         # have to count as a collision. If 0, touching terrain at all counts as
  198.         # a collision. If .49, you sink into the ground, as if walking through
  199.         # tall grass. If >= .5, you'll fall through the ground.
  200.         pad = 0
  201.         p = list(position)
  202.         np = normalize(position)
  203.         for face in FACES:  # check all surrounding blocks
  204.             for i in xrange(3):  # check each dimension independently
  205.                 if not face[i]:
  206.                     continue
  207.                 # How much overlap you have with this dimension.
  208.                 d = (p[i] - np[i]) * face[i]
  209.                 if d < pad:
  210.                     continue
  211.                 for dy in xrange(height):  # check each height
  212.                     op = list(np)
  213.                     op[1] -= dy
  214.                     op[i] += face[i]
  215.                     if tuple(op) not in self.model.world:
  216.                         continue
  217.                     p[i] -= (d - pad) * face[i]
  218.                     if face == (0, -1, 0) or face == (0, 1, 0):
  219.                         # You are colliding with the ground or ceiling, so stop
  220.                         # falling / rising.
  221.                         self.dy = 0
  222.                     break
  223.         return tuple(p)
  224.  
  225.     def on_mouse_press(self, x, y, button, modifiers):
  226.         """ Called when a mouse button is pressed. See pyglet docs for button
  227.         amd modifier mappings.
  229.         Parameters
  230.         ----------
  231.         x, y : int
  232.             The coordinates of the mouse click. Always center of the screen if
  233.             the mouse is captured.
  234.         button : int
  235.             Number representing mouse button that was clicked. 1 = left button,
  236.             4 = right button.
  237.         modifiers : int
  238.             Number representing any modifying keys that were pressed when the
  239.             mouse button was clicked.
  241.         """
  242.         if self.exclusive:
  243.             vector = self.get_sight_vector()
  244.             block, previous = self.model.hit_test(self.position, vector)
  245.             if (button == mouse.RIGHT) or \
  246.                     ((button == mouse.LEFT) and (modifiers & key.MOD_CTRL)):
  247.                 # ON OSX, control + left click = right click.
  248.                 if previous:
  249.                     self.model.add_block(previous, self.block)
  250.             elif button == pyglet.window.mouse.LEFT and block:
  251.                 texture = self.model.world[block]
  252.                 self.model.remove_block(block)
  253.         else:
  254.             self.set_exclusive_mouse(True)
  255.  
  256.     def on_mouse_motion(self, x, y, dx, dy):
  257.         """ Called when the player moves the mouse.
  259.         Parameters
  260.         ----------
  261.         x, y : int
  262.             The coordinates of the mouse click. Always center of the screen if
  263.             the mouse is captured.
  264.         dx, dy : float
  265.             The movement of the mouse.
  267.         """
  268.         if self.exclusive:
  269.             m = 0.15
  270.             x, y = self.rotation
  271.             x, y = x + dx * m, y + dy * m
  272.             y = max(-90, min(90, y))
  273.             self.rotation = (x, y)
  274.  
  275.     def on_key_press(self, symbol, modifiers):
  276.         """ Called when the player presses a key. See pyglet docs for key
  277.         mappings.
  279.         Parameters
  280.         ----------
  281.         symbol : int
  282.             Number representing the key that was pressed.
  283.         modifiers : int
  284.             Number representing any modifying keys that were pressed.
  286.         """
  287.         if symbol == key.W:
  288.             self.strafe[0] -= 1
  289.         elif symbol == key.S:
  290.             self.strafe[0] += 1
  291.         elif symbol == key.A:
  292.             self.strafe[1] -= 1
  293.         elif symbol == key.D:
  294.             self.strafe[1] += 1
  295.         elif symbol == key.SPACE:
  296.             if self.dy == 0:
  297.                 self.dy = JUMP_SPEED
  298.         elif symbol == key.ESCAPE:
  299.             self.set_exclusive_mouse(False)
  300.         elif symbol == key.TAB:
  301.             self.flying = not self.flying
  302.         elif symbol in self.num_keys:
  303.             index = (symbol - self.num_keys[0]) % len(self.inventory)
  304.             self.block = self.inventory[index]
  305.  
  306.     def on_key_release(self, symbol, modifiers):
  307.         """ Called when the player releases a key. See pyglet docs for key
  308.         mappings.
  310.         Parameters
  311.         ----------
  312.         symbol : int
  313.             Number representing the key that was pressed.
  314.         modifiers : int
  315.             Number representing any modifying keys that were pressed.
  317.         """
  318.         if symbol == key.W:
  319.             self.strafe[0] += 1
  320.         elif symbol == key.S:
  321.             self.strafe[0] -= 1
  322.         elif symbol == key.A:
  323.             self.strafe[1] += 1
  324.         elif symbol == key.D:
  325.             self.strafe[1] -= 1
  326.  
  327.  
  328.     def on_resize(self, width, height):
  329.         """ Called when the window is resized to a new `width` and `height`.
  331.         """
  332.         # label
  333.         self.label.y = height - 10
  334.         # reticle
  335.         if self.reticle:
  336.             self.reticle.delete()
  337.         x, y = self.width // 2, self.height // 2
  338.         n = 10
  339.         self.reticle = pyglet.graphics.vertex_list(4,
  340.             ('v2i', (x - n, y, x + n, y, x, y - n, x, y + n))
  341.         )
  342.  
  343.     def set_2d(self):
  344.         """ Configure OpenGL to draw in 2d.
  346.         """
  347.         width, height = self.get_size()
  348.         glDisable(GL_DEPTH_TEST)
  349.         viewport = self.get_viewport_size()
  350.         glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1]))
  351.         glMatrixMode(GL_PROJECTION)
  352.         glLoadIdentity()
  353.         glOrtho(0, max(1, width), 0, max(1, height), -1, 1)
  354.         glMatrixMode(GL_MODELVIEW)
  355.         glLoadIdentity()
  356.  
  357.     def set_3d(self):
  358.         """ Configure OpenGL to draw in 3d.
  360.         """
  361.         width, height = self.get_size()
  362.         glEnable(GL_DEPTH_TEST)
  363.         viewport = self.get_viewport_size()
  364.         glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1]))
  365.         glMatrixMode(GL_PROJECTION)
  366.         glLoadIdentity()
  367.         gluPerspective(65.0, width / float(height), 0.1, 60.0)
  368.         glMatrixMode(GL_MODELVIEW)
  369.         glLoadIdentity()
  370.         x, y = self.rotation
  371.         glRotatef(x, 0, 1, 0)
  372.         glRotatef(-y, math.cos(math.radians(x)), 0, math.sin(math.radians(x)))
  373.         x, y, z = self.position
  374.         glTranslatef(-x, -y, -z)
  375.  
  376.     def on_draw(self):
  377.         """ Called by pyglet to draw the canvas.
  379.         """
  380.         self.clear()
  381.         self.set_3d()
  382.         glColor3d(1, 1, 1)
  383.         self.model.batch.draw()
  384.         self.draw_focused_block()
  385.         self.set_2d()
  386.         self.draw_label()
  387.         self.draw_reticle()
  388.  
  389.     def draw_focused_block(self):
  390.         """ Draw black edges around the block that is currently under the
  391.         crosshairs.
  393.         """
  394.         vector = self.get_sight_vector()
  395.         block = self.model.hit_test(self.position, vector)[0]
  396.         if block:
  397.             x, y, z = block
  398.             vertex_data = cube_vertices(x, y, z, 0.51)
  399.             glColor3d(0, 0, 0)
  400.             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
  401.             pyglet.graphics.draw(24, GL_QUADS, ('v3f/static', vertex_data))
  402.             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
  403.  
  404.     def draw_label(self):
  405.         """ Draw the label in the top left of the screen.
  407.         """
  408.         x, y, z = self.position
  409.         self.label.text = '%02d (%.2f, %.2f, %.2f) %d / %d' % (
  410.             pyglet.clock.get_fps(), x, y, z,
  411.             len(self.model._shown), len(self.model.world))
  412.         self.label.draw()
  413.  
  414.     def draw_reticle(self):
  415.         """ Draw the crosshairs in the center of the screen.
  417.         """
  418.         glColor3d(0, 0, 0)
  419.         self.reticle.draw(GL_LINES)

最后，一些生成的函数

  1. def setup_fog():
  2.     """ Configure the OpenGL fog properties.
  4.     """
  5.     # Enable fog. Fog "blends a fog color with each rasterized pixel fragment's
  6.     # post-texturing color."
  7.     glEnable(GL_FOG)
  8.     # Set the fog color.
  9.     glFogfv(GL_FOG_COLOR, (GLfloat * 4)(0.5, 0.69, 1.0, 0))
  10.     # Say we have no preference between rendering speed and quality.
  11.     glHint(GL_FOG_HINT, GL_DONT_CARE)
  12.     # Specify the equation used to compute the blending factor.
  13.     glFogi(GL_FOG_MODE, GL_LINEAR)
  14.     # How close and far away fog starts and ends. The closer the start and end,
  15.     # the denser the fog in the fog range.
  16.     glFogf(GL_FOG_START, 20.0)
  17.     glFogf(GL_FOG_END, 60.0)
  18.  
  19.  
  20. def setup():
  21.     """ Basic OpenGL configuration.
  23.     """
  24.     # Set the color of "clear", i.e. the sky, in rgba.
  25.     glClearColor(0.5, 0.69, 1.0, 1)
  26.     # Enable culling (not rendering) of back-facing facets -- facets that aren't
  27.     # visible to you.
  28.     glEnable(GL_CULL_FACE)
  29.     # Set the texture minification/magnification function to GL_NEAREST (nearest
  30.     # in Manhattan distance) to the specified texture coordinates. GL_NEAREST
  31.     # "is generally faster than GL_LINEAR, but it can produce textured images
  32.     # with sharper edges because the transition between texture elements is not
  33.     # as smooth."
  34.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
  35.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
  36.     setup_fog()
'
运行

最最后，主函数

  1. def main():
  2.     window = Window(width=800, height=450, caption='Pyglet', resizable=True)
  3.     # Hide the mouse cursor and prevent the mouse from leaving the window.
  4.     window.set_exclusive_mouse(True)
  5.     setup()
  6.     pyglet.app.run()
  7.  
  8.  
  9. if __name__ == '__main__':
  10.     main()

最最最后，我很了解你，全部的源码

  1. from __future__ import division
  2.  
  3. import sys
  4. import math
  5. import random
  6. import time
  7.  
  8. from collections import deque
  9. from pyglet import image
  10. from pyglet.gl import *
  11. from pyglet.graphics import TextureGroup
  12. from pyglet.window import key, mouse
  13.  
  14. # 每秒帧数
  15. TICKS_PER_SEC = 120
  16.  
  17. # 你可以走的大小
  18. SECTOR_SIZE =2000
  19.  
  20. # 行走速度与飞行速度
  21. WALKING_SPEED = 5.5
  22. FLYING_SPEED = 15
  23.  
  24. # 重力与跳跃高度
  25. GRAVITY = 20
  26. MAX_JUMP_HEIGHT =1
  27.  
  28. # About the height of a block.
  29. # To derive the formula for calculating jump speed, first solve
  30. #    v_t = v_0 + a * t
  31. # for the time at which you achieve maximum height, where a is the acceleration
  32. # due to gravity and v_t = 0. This gives:
  33. #    t = - v_0 / a
  34. # Use t and the desired MAX_JUMP_HEIGHT to solve for v_0 (jump speed) in
  35. #    s = s_0 + v_0 * t + (a * t^2) / 2
  36. JUMP_SPEED = math.sqrt(2 * GRAVITY * MAX_JUMP_HEIGHT)
  37. TERMINAL_VELOCITY = 50
  38.  
  39. PLAYER_HEIGHT = 2
  40.  
  41. if sys.version_info[0] >= 3:
  42.     xrange = range
  43.  
  44. def cube_vertices(x, y, z, n):
  45.     """ Return the vertices of the cube at position x, y, z with size 2*n.
  47.     """
  48.     return [
  49.         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
  50.         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
  51.         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
  52.         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
  53.         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
  54.         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
  55.     ]
  56.  
  57.  
  58. def tex_coord(x, y, n=4):
  59.     """ 
  60.     Return the bounding vertices of the texture square.
  62.     """
  63.     m = 1.0 / n
  64.     dx = x * m
  65.     dy = y * m
  66.     return dx, dy, dx + m, dy, dx + m, dy + m, dx, dy + m
  67.  
  68.  
  69. def tex_coords(top, bottom, side):
  70.     """ 
  71.     Return a list of the texture squares for the top, bottom and side.
  73.     """
  74.     top = tex_coord(*top)
  75.     bottom = tex_coord(*bottom)
  76.     side = tex_coord(*side)
  77.     result = []
  78.     result.extend(top)
  79.     result.extend(bottom)
  80.     result.extend(side * 4)
  81.     return result
  82.  
  83.  
  84. TEXTURE_PATH = 'Minecraft(1)/texture.png'
  85.  
  86. GRASS = tex_coords((1, 0), (0, 1), (0, 0))
  87. SAND = tex_coords((1, 1), (1, 1), (1, 1))
  88. BRICK = tex_coords((2, 0), (2, 0), (2, 0))
  89. STONE = tex_coords((2, 1), (2, 1), (2, 1))
  90. PURPLE = tex_coords((3, 1), (3, 1), (3, 1))
  91. RED = tex_coords((3, 0), (3, 0), (3, 0))
  92. GREEN = tex_coords((3, 2), (3, 2), (3, 2))
  93. BLUE = tex_coords((1, 2), (1, 2), (1, 2))
  94. BLACK = tex_coords((2, 2), (2, 2), (2, 2))
  95. ORANGE = tex_coords((3, 2), (3, 2), (3, 2))
  96.  
  97. FACES = [
  98.     ( 0, 1, 0),
  99.     ( 0,-1, 0),
  100.     (-1, 0, 0),
  101.     ( 1, 0, 0),
  102.     ( 0, 0, 1),
  103.     ( 0, 0,-1),
  104. ]
  105.  
  106.  
  107. def normalize(position):
  108.     """ Accepts `position` of arbitrary precision and returns the block
  109.     containing that position.
  111.     Parameters
  112.     ----------
  113.     position : tuple of len 3
  115.     Returns
  116.     -------
  117.     block_position : tuple of ints of len 3
  119.     """
  120.     x, y, z = position
  121.     x, y, z = (int(round(x)), int(round(y)), int(round(z)))
  122.     return (x, y, z)
  123.  
  124.  
  125. def sectorize(position):
  126.     """ Returns a tuple representing the sector for the given `position`.
  128.     Parameters
  129.     ----------
  130.     position : tuple of len 3
  132.     Returns
  133.     -------
  134.     sector : tuple of len 3
  136.     """
  137.     x, y, z = normalize(position)
  138.     x, y, z = x // SECTOR_SIZE, y // SECTOR_SIZE, z // SECTOR_SIZE
  139.     return (x, 0, z)
  140.  
  141.  
  142. class Model(object):
  143.  
  144.     def __init__(self):
  145.  
  146.         # A Batch is a collection of vertex lists for batched rendering.
  147.         self.batch = pyglet.graphics.Batch()
  148.  
  149.         # A TextureGroup manages an OpenGL texture.
  150.         self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())
  151.  
  152.         # A mapping from position to the texture of the block at that position.
  153.         # This defines all the blocks that are currently in the world.
  154.         self.world = {}
  155.  
  156.         # Same mapping as `world` but only contains blocks that are shown.
  157.         self.shown = {}
  158.  
  159.         # Mapping from position to a pyglet `VertextList` for all shown blocks.
  160.         self._shown = {}
  161.  
  162.         # Mapping from sector to a list of positions inside that sector.
  163.         self.sectors = {}
  164.  
  165.         # Simple function queue implementation. The queue is populated with
  166.         # _show_block() and _hide_block() calls
  167.         self.queue = deque()
  168.  
  169.         self._initialize()
  170.  
  171.     def _initialize(self):
  172.         """ Initialize the world by placing all the blocks.
  174.         """
  175.         n = 200 # 1/2 width and height of world
  176.         s = 1  # step size
  177.         y =0   # initial y height
  178.         for x in xrange(-n, n + 1, s):
  179.             for z in xrange(-n, n + 1, s):
  180.                 # create a layer stone an grass everywhere.
  181.                 self.add_block((x, y - 2, z), GRASS, immediate=False)
  182.                 self.add_block((x, y - 3, z), STONE, immediate=False)
  183.                 self.add_block((x, y - 4, z), STONE, immediate=False)
  184.                 if x in (-n, n) or z in (-n, n):
  185.                     # create outer walls.
  186.                     for dy in xrange(-2, 3):
  187.                         self.add_block((x, y + dy, z), STONE, immediate=False)
  188.  
  189.         # generate the hills randomly
  190.         o = n -15
  191.         for _ in xrange(120):
  192.             a = random.randint(-o, o)  # x position of the hill
  193.             b = random.randint(-o, o)  # z position of the hill
  194.             c = -1  # base of the hill
  195.             h = random.randint(2,6) # height of the hill
  196.             s = random.randint(4,12)  # 2 * s is the side length of the hill
  197.             d = 1  # how quickly to taper off the hills
  198.             t = random.choice([GRASS, SAND,STONE])
  199.             for y in xrange(c, c + h):
  200.                 for x in xrange(a - s, a + s + 1):
  201.                     for z in xrange(b - s, b + s + 1):
  202.                         if (x - a) ** 2 + (z - b) ** 2 > (s + 1) ** 2:
  203.                             continue
  204.                         if (x - 0) ** 2 + (z - 0) ** 2 < 5 ** 2:
  205.                             continue
  206.                         self.add_block((x, y, z), t, immediate=False)
  207.                 s -= d  # decrement side lenth so hills taper off
  208.  
  209.     def hit_test(self, position, vector, max_distance=8):
  210.         """ Line of sight search from current position. If a block is
  211.         intersected it is returned, along with the block previously in the line
  212.         of sight. If no block is found, return None, None.
  214.         Parameters
  215.         ----------
  216.         position : tuple of len 3
  217.             The (x, y, z) position to check visibility from.
  218.         vector : tuple of len 3
  219.             The line of sight vector.
  220.         max_distance : int
  221.             How many blocks away to search for a hit.
  223.         """
  224.         m = 8
  225.         x, y, z = position
  226.         dx, dy, dz = vector
  227.         previous = None
  228.         for _ in xrange(max_distance * m):
  229.             key = normalize((x, y, z))
  230.             if key != previous and key in self.world:
  231.                 return key, previous
  232.             previous = key
  233.             x, y, z = x + dx / m, y + dy / m, z + dz / m
  234.         return None, None
  235.  
  236.     def exposed(self, position):
  237.         """ Returns False is given `position` is surrounded on all 6 sides by
  238.         blocks, True otherwise.
  240.         """
  241.         x, y, z = position
  242.         for dx, dy, dz in FACES:
  243.             if (x + dx, y + dy, z + dz) not in self.world:
  244.                 return True
  245.         return False
  246.  
  247.     def add_block(self, position, texture, immediate=True):
  248.         """ Add a block with the given `texture` and `position` to the world.
  250.         Parameters
  251.         ----------
  252.         position : tuple of len 3
  253.             The (x, y, z) position of the block to add.
  254.         texture : list of len 3
  255.             The coordinates of the texture squares. Use `tex_coords()` to
  256.             generate.
  257.         immediate : bool
  258.             Whether or not to draw the block immediately.
  260.         """
  261.         if position in self.world:
  262.             self.remove_block(position, immediate)
  263.         self.world[position] = texture
  264.         self.sectors.setdefault(sectorize(position), []).append(position)
  265.         if immediate:
  266.             if self.exposed(position):
  267.                 self.show_block(position)
  268.             self.check_neighbors(position)
  269.  
  270.     def remove_block(self, position, immediate=True):
  271.         """ Remove the block at the given `position`.
  273.         Parameters
  274.         ----------
  275.         position : tuple of len 3
  276.             The (x, y, z) position of the block to remove.
  277.         immediate : bool
  278.             Whether or not to immediately remove block from canvas.
  280.         """
  281.         del self.world[position]
  282.         self.sectors[sectorize(position)].remove(position)
  283.         if immediate:
  284.             if position in self.shown:
  285.                 self.hide_block(position)
  286.             self.check_neighbors(position)
  287.  
  288.     def check_neighbors(self, position):
  289.         """ Check all blocks surrounding `position` and ensure their visual
  290.         state is current. This means hiding blocks that are not exposed and
  291.         ensuring that all exposed blocks are shown. Usually used after a block
  292.         is added or removed.
  294.         """
  295.         x, y, z = position
  296.         for dx, dy, dz in FACES:
  297.             key = (x + dx, y + dy, z + dz)
  298.             if key not in self.world:
  299.                 continue
  300.             if self.exposed(key):
  301.                 if key not in self.shown:
  302.                     self.show_block(key)
  303.             else:
  304.                 if key in self.shown:
  305.                     self.hide_block(key)
  306.  
  307.     def show_block(self, position, immediate=True):
  308.         """ Show the block at the given `position`. This method assumes the
  309.         block has already been added with add_block()
  311.         Parameters
  312.         ----------
  313.         position : tuple of len 3
  314.             The (x, y, z) position of the block to show.
  315.         immediate : bool
  316.             Whether or not to show the block immediately.
  318.         """
  319.         texture = self.world[position]
  320.         self.shown[position] = texture
  321.         if immediate:
  322.             self._show_block(position, texture)
  323.         else:
  324.             self._enqueue(self._show_block, position, texture)
  325.  
  326.     def _show_block(self, position, texture):
  327.         """ Private implementation of the `show_block()` method.
  329.         Parameters
  330.         ----------
  331.         position : tuple of len 3
  332.             The (x, y, z) position of the block to show.
  333.         texture : list of len 3
  334.             The coordinates of the texture squares. Use `tex_coords()` to
  335.             generate.
  337.         """
  338.         x, y, z = position
  339.         vertex_data = cube_vertices(x, y, z, 0.5)
  340.         texture_data = list(texture)
  341.         # create vertex list
  342.         # FIXME Maybe `add_indexed()` should be used instead
  343.         self._shown[position] = self.batch.add(24, GL_QUADS, self.group,
  344.             ('v3f/static', vertex_data),
  345.             ('t2f/static', texture_data))
  346.  
  347.     def hide_block(self, position, immediate=True):
  348.         """ Hide the block at the given `position`. Hiding does not remove the
  349.         block from the world.
  351.         Parameters
  352.         ----------
  353.         position : tuple of len 3
  354.             The (x, y, z) position of the block to hide.
  355.         immediate : bool
  356.             Whether or not to immediately remove the block from the canvas.
  358.         """
  359.         self.shown.pop(position)
  360.         if immediate:
  361.             self._hide_block(position)
  362.         else:
  363.             self._enqueue(self._hide_block, position)
  364.  
  365.     def _hide_block(self, position):
  366.         """ Private implementation of the 'hide_block()` method.
  368.         """
  369.         self._shown.pop(position).delete()
  370.  
  371.     def show_sector(self, sector):
  372.         """ Ensure all blocks in the given sector that should be shown are
  373.         drawn to the canvas.
  375.         """
  376.         for position in self.sectors.get(sector, []):
  377.             if position not in self.shown and self.exposed(position):
  378.                 self.show_block(position, False)
  379.  
  380.     def hide_sector(self, sector):
  381.         """ Ensure all blocks in the given sector that should be hidden are
  382.         removed from the canvas.
  384.         """
  385.         for position in self.sectors.get(sector, []):
  386.             if position in self.shown:
  387.                 self.hide_block(position, False)
  388.  
  389.     def change_sectors(self, before, after):
  390.         """ Move from sector `before` to sector `after`. A sector is a
  391.         contiguous x, y sub-region of world. Sectors are used to speed up
  392.         world rendering.
  394.         """
  395.         before_set = set()
  396.         after_set = set()
  397.         pad = 4
  398.         for dx in xrange(-pad, pad + 1):
  399.             for dy in [0]:  # xrange(-pad, pad + 1):
  400.                 for dz in xrange(-pad, pad + 1):
  401.                     if dx ** 2 + dy ** 2 + dz ** 2 > (pad + 1) ** 2:
  402.                         continue
  403.                     if before:
  404.                         x, y, z = before
  405.                         before_set.add((x + dx, y + dy, z + dz))
  406.                     if after:
  407.                         x, y, z = after
  408.                         after_set.add((x + dx, y + dy, z + dz))
  409.         show = after_set - before_set
  410.         hide = before_set - after_set
  411.         for sector in show:
  412.             self.show_sector(sector)
  413.         for sector in hide:
  414.             self.hide_sector(sector)
  415.  
  416.     def _enqueue(self, func, *args):
  417.         """ Add `func` to the internal queue.
  419.         """
  420.         self.queue.append((func, args))
  421.  
  422.     def _dequeue(self):
  423.         """ Pop the top function from the internal queue and call it.
  425.         """
  426.         func, args = self.queue.popleft()
  427.         func(*args)
  428.  
  429.     def process_queue(self):
  430.         """ Process the entire queue while taking periodic breaks. This allows
  431.         the game loop to run smoothly. The queue contains calls to
  432.         _show_block() and _hide_block() so this method should be called if
  433.         add_block() or remove_block() was called with immediate=False
  435.         """
  436.         start = time.time
  437.         while self.queue and time.time < 1 / TICKS_PER_SEC:
  438.             self._dequeue()
  439.  
  440.     def process_entire_queue(self):
  441.         """ Process the entire queue with no breaks.
  443.         """
  444.         while self.queue:
  445.             self._dequeue()
  446.  
  447.  
  448. class Window(pyglet.window.Window):
  449.  
  450.     def __init__(self, *args, **kwargs):
  451.         super(Window, self).__init__(*args, **kwargs)
  452.  
  453.         # Whether or not the window exclusively captures the mouse.
  454.         self.exclusive = False
  455.  
  456.         # When flying gravity has no effect and speed is increased.
  457.         self.flying = False
  458.  
  459.         # Strafing is moving lateral to the direction you are facing,
  460.         # e.g. moving to the left or right while continuing to face forward.
  461.         #
  462.         # First element is -1 when moving forward, 1 when moving back, and 0
  463.         # otherwise. The second element is -1 when moving left, 1 when moving
  464.         # right, and 0 otherwise.
  465.         self.strafe = [0, 0]
  466.  
  467.         # Current (x, y, z) position in the world, specified with floats. Note
  468.         # that, perhaps unlike in math class, the y-axis is the vertical axis.
  469.         self.position = (0, 0, 0)
  470.  
  471.         # First element is rotation of the player in the x-z plane (ground
  472.         # plane) measured from the z-axis down. The second is the rotation
  473.         # angle from the ground plane up. Rotation is in degrees.
  474.         #
  475.         # The vertical plane rotation ranges from -90 (looking straight down) to
  476.         # 90 (looking straight up). The horizontal rotation range is unbounded.
  477.         self.rotation = (0, 0)
  478.  
  479.         # Which sector the player is currently in.
  480.         self.sector = None
  481.  
  482.         # The crosshairs at the center of the screen.
  483.         self.reticle = None
  484.  
  485.         # Velocity in the y (upward) direction.
  486.         self.dy = 0
  487.  
  488.         # A list of blocks the player can place. Hit num keys to cycle.
  489.         self.inventory = [BRICK, GRASS, SAND,STONE,RED,PURPLE,GREEN,BLUE,BLACK,ORANGE]
  490.  
  491.         # The current block the user can place. Hit num keys to cycle.
  492.         self.block = self.inventory[0]
  493.  
  494.         # Convenience list of num keys.
  495.         self.num_keys = [
  496.             key._1, key._2, key._3, key._4, key._5,
  497.             key._6, key._7, key._8, key._9, key._0,key.E,key.R]
  498.  
  499.         # Instance of the model that handles the world.
  500.         self.model = Model()
  501.  
  502.         # The label that is displayed in the top left of the canvas.
  503.         self.label = pyglet.text.Label('', font_name='Arial', font_size=18,
  504.             x=10, y=self.height - 10, anchor_x='left', anchor_y='top',
  505.             color=(0, 0, 0, 255))
  506.  
  507.         # This call schedules the `update()` method to be called
  508.         # TICKS_PER_SEC. This is the main game event loop.
  509.         pyglet.clock.schedule_interval(self.update, 1.0 / TICKS_PER_SEC)
  510.  
  511.     def set_exclusive_mouse(self, exclusive):
  512.         """ If `exclusive` is True, the game will capture the mouse, if False
  513.         the game will ignore the mouse.
  515.         """
  516.         super(Window, self).set_exclusive_mouse(exclusive)
  517.         self.exclusive = exclusive
  518.  
  519.     def get_sight_vector(self):
  520.         """ Returns the current line of sight vector indicating the direction
  521.         the player is looking.
  523.         """
  524.         x, y = self.rotation
  525.         # y ranges from -90 to 90, or -pi/2 to pi/2, so m ranges from 0 to 1 and
  526.         # is 1 when looking ahead parallel to the ground and 0 when looking
  527.         # straight up or down.
  528.         m = math.cos(math.radians(y))
  529.         # dy ranges from -1 to 1 and is -1 when looking straight down and 1 when
  530.         # looking straight up.
  531.         dy = math.sin(math.radians(y))
  532.         dx = math.cos(math.radians(x - 90)) * m
  533.         dz = math.sin(math.radians(x - 90)) * m
  534.         return (dx, dy, dz)
  535.  
  536.     def get_motion_vector(self):
  537.         """ Returns the current motion vector indicating the velocity of the
  538.         player.
  540.         Returns
  541.         -------
  542.         vector : tuple of len 3
  543.             Tuple containing the velocity in x, y, and z respectively.
  545.         """
  546.         if any(self.strafe):
  547.             x, y = self.rotation
  548.             strafe = math.degrees(math.atan2(*self.strafe))
  549.             y_angle = math.radians(y)
  550.             x_angle = math.radians(x + strafe)
  551.             if self.flying:
  552.                 m = math.cos(y_angle)
  553.                 dy = math.sin(y_angle)
  554.                 if self.strafe[1]:
  555.                     # Moving left or right.
  556.                     dy = 0.0
  557.                     m = 1
  558.                 if self.strafe[0] > 0:
  559.                     # Moving backwards.
  560.                     dy *= -1
  561.                 # When you are flying up or down, you have less left and right
  562.                 # motion.
  563.                 dx = math.cos(x_angle) * m
  564.                 dz = math.sin(x_angle) * m
  565.             else:
  566.                 dy = 0.0
  567.                 dx = math.cos(x_angle)
  568.                 dz = math.sin(x_angle)
  569.         else:
  570.             dy = 0.0
  571.             dx = 0.0
  572.             dz = 0.0
  573.         return (dx, dy, dz)
  574.  
  575.     def update(self, dt):
  576.         """ This method is scheduled to be called repeatedly by the pyglet
  577.         clock.
  579.         Parameters
  580.         ----------
  581.         dt : float
  582.             The change in time since the last call.
  584.         """
  585.         self.model.process_queue()
  586.         sector = sectorize(self.position)
  587.         if sector != self.sector:
  588.             self.model.change_sectors(self.sector, sector)
  589.             if self.sector is None:
  590.                 self.model.process_entire_queue()
  591.             self.sector = sector
  592.         m = 8
  593.         dt = min(dt, 0.2)
  594.         for _ in xrange(m):
  595.             self._update(dt / m)
  596.  
  597.     def _update(self, dt):
  598.         """ Private implementation of the `update()` method. This is where most
  599.         of the motion logic lives, along with gravity and collision detection.
  601.         Parameters
  602.         ----------
  603.         dt : float
  604.             The change in time since the last call.
  606.         """
  607.         # walking
  608.         speed = FLYING_SPEED if self.flying else WALKING_SPEED
  609.         d = dt * speed # distance covered this tick.
  610.         dx, dy, dz = self.get_motion_vector()
  611.         # New position in space, before accounting for gravity.
  612.         dx, dy, dz = dx * d, dy * d, dz * d
  613.         # gravity
  614.         if not self.flying:
  615.             # Update your vertical speed: if you are falling, speed up until you
  616.             # hit terminal velocity; if you are jumping, slow down until you
  617.             # start falling.
  618.             self.dy -= dt * GRAVITY
  619.             self.dy = max(self.dy, -TERMINAL_VELOCITY)
  620.             dy += self.dy * dt
  621.         # collisions
  622.         x, y, z = self.position
  623.         x, y, z = self.collide((x + dx, y + dy, z + dz), PLAYER_HEIGHT)
  624.         self.position = (x, y, z)
  625.  
  626.     def collide(self, position, height):
  627.         """ Checks to see if the player at the given `position` and `height`
  628.         is colliding with any blocks in the world.
  630.         Parameters
  631.         ----------
  632.         position : tuple of len 3
  633.             The (x, y, z) position to check for collisions at.
  634.         height : int or float
  635.             The height of the player.
  637.         Returns
  638.         -------
  639.         position : tuple of len 3
  640.             The new position of the player taking into account collisions.
  642.         """
  643.         # How much overlap with a dimension of a surrounding block you need to
  644.         # have to count as a collision. If 0, touching terrain at all counts as
  645.         # a collision. If .49, you sink into the ground, as if walking through
  646.         # tall grass. If >= .5, you'll fall through the ground.
  647.         pad = 0
  648.         p = list(position)
  649.         np = normalize(position)
  650.         for face in FACES:  # check all surrounding blocks
  651.             for i in xrange(3):  # check each dimension independently
  652.                 if not face[i]:
  653.                     continue
  654.                 # How much overlap you have with this dimension.
  655.                 d = (p[i] - np[i]) * face[i]
  656.                 if d < pad:
  657.                     continue
  658.                 for dy in xrange(height):  # check each height
  659.                     op = list(np)
  660.                     op[1] -= dy
  661.                     op[i] += face[i]
  662.                     if tuple(op) not in self.model.world:
  663.                         continue
  664.                     p[i] -= (d - pad) * face[i]
  665.                     if face == (0, -1, 0) or face == (0, 1, 0):
  666.                         # You are colliding with the ground or ceiling, so stop
  667.                         # falling / rising.
  668.                         self.dy = 0
  669.                     break
  670.         return tuple(p)
  671.  
  672.     def on_mouse_press(self, x, y, button, modifiers):
  673.         """ Called when a mouse button is pressed. See pyglet docs for button
  674.         amd modifier mappings.
  676.         Parameters
  677.         ----------
  678.         x, y : int
  679.             The coordinates of the mouse click. Always center of the screen if
  680.             the mouse is captured.
  681.         button : int
  682.             Number representing mouse button that was clicked. 1 = left button,
  683.             4 = right button.
  684.         modifiers : int
  685.             Number representing any modifying keys that were pressed when the
  686.             mouse button was clicked.
  688.         """
  689.         if self.exclusive:
  690.             vector = self.get_sight_vector()
  691.             block, previous = self.model.hit_test(self.position, vector)
  692.             if (button == mouse.RIGHT) or \
  693.                     ((button == mouse.LEFT) and (modifiers & key.MOD_CTRL)):
  694.                 # ON OSX, control + left click = right click.
  695.                 if previous:
  696.                     self.model.add_block(previous, self.block)
  697.             elif button == pyglet.window.mouse.LEFT and block:
  698.                 texture = self.model.world[block]
  699.                 self.model.remove_block(block)
  700.         else:
  701.             self.set_exclusive_mouse(True)
  702.  
  703.     def on_mouse_motion(self, x, y, dx, dy):
  704.         """ Called when the player moves the mouse.
  706.         Parameters
  707.         ----------
  708.         x, y : int
  709.             The coordinates of the mouse click. Always center of the screen if
  710.             the mouse is captured.
  711.         dx, dy : float
  712.             The movement of the mouse.
  714.         """
  715.         if self.exclusive:
  716.             m = 0.15
  717.             x, y = self.rotation
  718.             x, y = x + dx * m, y + dy * m
  719.             y = max(-90, min(90, y))
  720.             self.rotation = (x, y)
  721.  
  722.     def on_key_press(self, symbol, modifiers):
  723.         """ Called when the player presses a key. See pyglet docs for key
  724.         mappings.
  726.         Parameters
  727.         ----------
  728.         symbol : int
  729.             Number representing the key that was pressed.
  730.         modifiers : int
  731.             Number representing any modifying keys that were pressed.
  733.         """
  734.         if symbol == key.W:
  735.             self.strafe[0] -= 1
  736.         elif symbol == key.S:
  737.             self.strafe[0] += 1
  738.         elif symbol == key.A:
  739.             self.strafe[1] -= 1
  740.         elif symbol == key.D:
  741.             self.strafe[1] += 1
  742.         elif symbol == key.SPACE:
  743.             if self.dy == 0:
  744.                 self.dy = JUMP_SPEED
  745.         elif symbol == key.ESCAPE:
  746.             self.set_exclusive_mouse(False)
  747.         elif symbol == key.TAB:
  748.             self.flying = not self.flying
  749.         elif symbol in self.num_keys:
  750.             index = (symbol - self.num_keys[0]) % len(self.inventory)
  751.             self.block = self.inventory[index]
  752.  
  753.     def on_key_release(self, symbol, modifiers):
  754.         """ Called when the player releases a key. See pyglet docs for key
  755.         mappings.
  757.         Parameters
  758.         ----------
  759.         symbol : int
  760.             Number representing the key that was pressed.
  761.         modifiers : int
  762.             Number representing any modifying keys that were pressed.
  764.         """
  765.         if symbol == key.W:
  766.             self.strafe[0] += 1
  767.         elif symbol == key.S:
  768.             self.strafe[0] -= 1
  769.         elif symbol == key.A:
  770.             self.strafe[1] += 1
  771.         elif symbol == key.D:
  772.             self.strafe[1] -= 1
  773.  
  774.  
  775.     def on_resize(self, width, height):
  776.         """ Called when the window is resized to a new `width` and `height`.
  778.         """
  779.         # label
  780.         self.label.y = height - 10
  781.         # reticle
  782.         if self.reticle:
  783.             self.reticle.delete()
  784.         x, y = self.width // 2, self.height // 2
  785.         n = 10
  786.         self.reticle = pyglet.graphics.vertex_list(4,
  787.             ('v2i', (x - n, y, x + n, y, x, y - n, x, y + n))
  788.         )
  789.  
  790.     def set_2d(self):
  791.         """ Configure OpenGL to draw in 2d.
  793.         """
  794.         width, height = self.get_size()
  795.         glDisable(GL_DEPTH_TEST)
  796.         viewport = self.get_viewport_size()
  797.         glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1]))
  798.         glMatrixMode(GL_PROJECTION)
  799.         glLoadIdentity()
  800.         glOrtho(0, max(1, width), 0, max(1, height), -1, 1)
  801.         glMatrixMode(GL_MODELVIEW)
  802.         glLoadIdentity()
  803.  
  804.     def set_3d(self):
  805.         """ Configure OpenGL to draw in 3d.
  807.         """
  808.         width, height = self.get_size()
  809.         glEnable(GL_DEPTH_TEST)
  810.         viewport = self.get_viewport_size()
  811.         glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1]))
  812.         glMatrixMode(GL_PROJECTION)
  813.         glLoadIdentity()
  814.         gluPerspective(65.0, width / float(height), 0.1, 60.0)
  815.         glMatrixMode(GL_MODELVIEW)
  816.         glLoadIdentity()
  817.         x, y = self.rotation
  818.         glRotatef(x, 0, 1, 0)
  819.         glRotatef(-y, math.cos(math.radians(x)), 0, math.sin(math.radians(x)))
  820.         x, y, z = self.position
  821.         glTranslatef(-x, -y, -z)
  822.  
  823.     def on_draw(self):
  824.         """ Called by pyglet to draw the canvas.
  826.         """
  827.         self.clear()
  828.         self.set_3d()
  829.         glColor3d(1, 1, 1)
  830.         self.model.batch.draw()
  831.         self.draw_focused_block()
  832.         self.set_2d()
  833.         self.draw_label()
  834.         self.draw_reticle()
  835.  
  836.     def draw_focused_block(self):
  837.         """ Draw black edges around the block that is currently under the
  838.         crosshairs.
  840.         """
  841.         vector = self.get_sight_vector()
  842.         block = self.model.hit_test(self.position, vector)[0]
  843.         if block:
  844.             x, y, z = block
  845.             vertex_data = cube_vertices(x, y, z, 0.51)
  846.             glColor3d(0, 0, 0)
  847.             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
  848.             pyglet.graphics.draw(24, GL_QUADS, ('v3f/static', vertex_data))
  849.             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
  850.  
  851.     def draw_label(self):
  852.         """ Draw the label in the top left of the screen.
  854.         """
  855.         x, y, z = self.position
  856.         self.label.text = '%02d (%.2f, %.2f, %.2f) %d / %d' % (
  857.             pyglet.clock.get_fps(), x, y, z,
  858.             len(self.model._shown), len(self.model.world))
  859.         self.label.draw()
  860.  
  861.     def draw_reticle(self):
  862.         """ Draw the crosshairs in the center of the screen.
  864.         """
  865.         glColor3d(0, 0, 0)
  866.         self.reticle.draw(GL_LINES)
  867.  
  868.  
  869. def setup_fog():
  870.     """ Configure the OpenGL fog properties.
  872.     """
  873.     # Enable fog. Fog "blends a fog color with each rasterized pixel fragment's
  874.     # post-texturing color."
  875.     glEnable(GL_FOG)
  876.     # Set the fog color.
  877.     glFogfv(GL_FOG_COLOR, (GLfloat * 4)(0.5, 0.69, 1.0, 0))
  878.     # Say we have no preference between rendering speed and quality.
  879.     glHint(GL_FOG_HINT, GL_DONT_CARE)
  880.     # Specify the equation used to compute the blending factor.
  881.     glFogi(GL_FOG_MODE, GL_LINEAR)
  882.     # How close and far away fog starts and ends. The closer the start and end,
  883.     # the denser the fog in the fog range.
  884.     glFogf(GL_FOG_START, 20.0)
  885.     glFogf(GL_FOG_END, 60.0)
  886.  
  887.  
  888. def setup():
  889.     """ Basic OpenGL configuration.
  891.     """
  892.     # Set the color of "clear", i.e. the sky, in rgba.
  893.     glClearColor(0.5, 0.69, 1.0, 1)
  894.     # Enable culling (not rendering) of back-facing facets -- facets that aren't
  895.     # visible to you.
  896.     glEnable(GL_CULL_FACE)
  897.     # Set the texture minification/magnification function to GL_NEAREST (nearest
  898.     # in Manhattan distance) to the specified texture coordinates. GL_NEAREST
  899.     # "is generally faster than GL_LINEAR, but it can produce textured images
  900.     # with sharper edges because the transition between texture elements is not
  901.     # as smooth."
  902.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
  903.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
  904.     setup_fog()
  905.  
  906.  
  907. def main():
  908.     window = Window(width=800, height=450, caption='Pyglet', resizable=True)
  909.     # Hide the mouse cursor and prevent the mouse from leaving the window.
  910.     window.set_exclusive_mouse(True)
  911.     setup()
  912.     pyglet.app.run()
  913.  
  914.  
  915. if __name__ == '__main__':
  916.     main()

最最最最后，效果

最最最最最后的结语

        作者：Unbeatable-NGU from NortH

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

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

  

闽ICP备14008679号