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

python-pyglet游戏之Minecraft_pyglet 游戏 源代码

作者：繁依Fanyi0 | 2024-04-22 11:13:18

赞

踩

pyglet 游戏 源代码

今天，我要为大家带来的是真实的Minecraft！这次大家可以不用失望了，真的是了！

---------------------------------------------------开始写代码了！---------------------------------------------------------

首先我要提醒大家的是先pip一下：

打开cmd，输入以下代码：

pip install 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
  13.  
  14. TICKS_PER_SEC = 60
  15.  
  16. SECTOR_SIZE = 16
  17.  
  18. GAMETYPES = False # 是否开启冰雪世界
  19.  
  20. SEED = random.randint(10, 1000000)#656795(种子"akioi") # 世界种子
  21.  
  22. GTIME = 0 # 当前世界时间
  23. GDAY = 0.0005
  24. GNIGHT = 0.0015
  25.  
  26. PLAYER_HEIGHT = 2 # 玩家高度
  27.  
  28. WALKING_SPEED =  PLAYER_HEIGHT + 2# 走路速度
  29. RUNNING_SPEED = PLAYER_HEIGHT * 2 # 跑步速度
  30. FLYING_SPEED = 15 # 飞行速度
  31.  
  32. # 35.0
  33. GRAVITY = 35.0 # 重力
  34. MAX_JUMP_HEIGHT = PLAYER_HEIGHT - 0.75 # 最大跳跃速度
  35. JUMP_SPEED = math.sqrt(2 * GRAVITY * MAX_JUMP_HEIGHT)
  36. TERMINAL_VELOCITY = 35 # 终端速度
  37.  
  38. WORLDLEN = 128 # 世界长度
  39.  
  40. TEXTURE_PATH = 'texture2_1.png' # 纹理文件

最后我会奉上图片的

二、主要函数、地图生成和人物设定

为了让大家看得清楚，我这里就不讲解了，直接让大家看代码：

  1. def cube_vertices(x, y, z, n):
  2.     # 返回立方体的顶点，大小为2n。
  3.     return [
  4.         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
  5.         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
  6.         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
  7.         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
  8.         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
  9.         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
  10.     ]
  11.  
  12. def tex_coord(x, y, n=8):
  13.     # 返回纹理的边界顶点。
  14.     m = 1.0 / n
  15.     dx = x * m
  16.     dy = y * m
  17.     return dx, dy, dx + m, dy, dx + m, dy + m, dx, dy + m
  18.  
  19.  
  20. def tex_coords(top, bottom, side):
  21.     # 返回顶部、底部和侧面的纹理列表。
  22.     top = tex_coord(*top)
  23.     bottom = tex_coord(*bottom)
  24.     side = tex_coord(*side)
  25.     result = []
  26.     result.extend(top)
  27.     result.extend(bottom)
  28.     result.extend(side * 4)
  29.     return result
  30.  
  31. if GAMETYPES:
  32.     GRASS = tex_coords((4, 0), (0, 1), (1, 3))
  33. else:
  34.     GRASS = tex_coords((1, 0), (0, 1), (0, 0))
  35. SAND = tex_coords((1, 1), (1, 1), (1, 1))
  36. DIRT = tex_coords((0, 1), (0, 1), (0, 1))
  37. STONE = tex_coords((2, 0), (2, 0), (2, 0))
  38. ENDSTONE = tex_coords((2, 1), (2, 1), (2, 1))
  39. if GAMETYPES:
  40.     WATER = tex_coords((3, 1), (3, 1), (3, 1))
  41. else:
  42.     WATER = tex_coords((0, 4), (0, 4), (0, 4))
  43. WOOD = tex_coords((0, 2), (0, 2), (3, 0))
  44. LEAF = tex_coords((0, 3), (0, 3), (0, 3))
  45. BRICK = tex_coords((1, 2), (1, 2), (1, 2))
  46. PUMKEY = tex_coords((2, 2), (3, 3), (2, 3))
  47. MELON = tex_coords((2, 4), (2, 4), (1, 4))
  48. CLOUD = tex_coords((3, 2), (3, 2), (3, 2))
  49. TNT = tex_coords((4, 2), (4, 3), (4, 1))
  50.  
  51. # 立方体的6个面
  52. FACES = [
  53.     ( 0, 1, 0),
  54.     ( 0,-1, 0),
  55.     (-1, 0, 0),
  56.     ( 1, 0, 0),
  57.     ( 0, 0, 1),
  58.     ( 0, 0,-1),
  59. ]
  60.  
  61. random.seed(SEED)
  62.  
  63.  
  64. def normalize(position):
  65.     # 将三维坐标'position'的x、y、z取近似值
  66.     x, y, z = position
  67.     x, y, z = (round(x), round(y), round(z))
  68.     return (x, y, z)
  69.  
  70.  
  71. def sectorize(position):
  72.     x, y, z = normalize(position)
  73.     x, y, z = x // SECTOR_SIZE, y // SECTOR_SIZE, z // SECTOR_SIZE
  74.     return (x, 0, z)
  75.  
  76.  
  77. persistence = random.uniform(0.01,0.15)
  78. Number_Of_Octaves = random.randint(3,5)
  79.  
  80. def Noise(x, y):
  81.     n = x + y * 57
  82.     n = (n * 8192) ^ n
  83.     return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
  84.  
  85. def SmoothedNoise(x, y):
  86.     corners = ( Noise(x-1, y-1)+Noise(x+1, y-1)+Noise(x-1, y+1)+Noise(x+1, y+1) ) / 16
  87.     sides = ( Noise(x-1, y) +Noise(x+1, y) +Noise(x, y-1) +Noise(x, y+1) ) / 8
  88.     center = Noise(x, y) / 4
  89.     return corners + sides + center
  90.  
  91. def Cosine_Interpolate(a, b, x):
  92.     ft = x * 3.1415927
  93.     f = (1 - math.cos(ft)) * 0.5
  94.     return a*(1-f) + b*f
  95.  
  96. def Linear_Interpolate(a, b, x):
  97.     return a*(1-x) + b*x
  98.  
  99. def InterpolatedNoise(x, y):
  100.     integer_X = int(x)
  101.     fractional_X = x - integer_X
  102.     integer_Y = int(y)
  103.     fractional_Y = y - integer_Y
  104.     v1 = SmoothedNoise(integer_X, integer_Y)
  105.     v2 = SmoothedNoise(integer_X + 1, integer_Y)
  106.     v3 = SmoothedNoise(integer_X, integer_Y + 1)
  107.     v4 = SmoothedNoise(integer_X + 1, integer_Y + 1)
  108.     i1 = Cosine_Interpolate(v1, v2, fractional_X)
  109.     i2 = Cosine_Interpolate(v3, v4, fractional_X)
  110.     return Cosine_Interpolate(i1, i2, fractional_Y)
  111.  
  112. def PerlinNoise(x, y):
  113.     noise = 0
  114.     p = persistence
  115.     n = Number_Of_Octaves
  116.     for i in range(n):
  117.         frequency = pow(2,i)
  118.         amplitude = pow(p,i)
  119.         noise = noise + InterpolatedNoise(x * frequency, y * frequency) * amplitude
  120.     return noise
  121.  
  122.  
  123. class Model(object):
  124.  
  125.     def __init__(self):
  126.  
  127.         self.batch = pyglet.graphics.Batch()
  128.         self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # 纹理列表
  129.         self.world = {} # 地图
  130.         self.shown = {} # 显示的方块
  131.         self._shown = {} # 显示的纹理
  132.         self.sectors = {}
  133.         self.queue = deque()
  134.         self.dfy = self._initialize()
  135.  
  136.     def tree(self, y, x, z):
  137.         # 生成树
  138.         th = random.randint(4, 6)
  139.         ts = random.randint(th // 2, 4)
  140.         for i in range(y, y + th):
  141.             self.add_block((x, i, z), WOOD, immediate=False)
  142.         for dy in range(y + th, y + th + 2):
  143.             for dx in range(x - ts, x + ts + 1):
  144.                 for dz in range(z - ts, z + ts + 1):
  145.                     self.add_block((dx, dy, dz), LEAF, immediate=False)
  146.         for dy in range(y + th + 2, y + th + ts + 2):
  147.             ts -= 1
  148.             for dx in range(x - ts, x + ts + 1):
  149.                 for dz in range(z - ts, z + ts + 1):
  150.                     self.add_block((dx, dy, dz), LEAF, immediate=False)
  151.  
  152.     def _initialize(self):
  153.         # 初始化世界
  154.         hl = WORLDLEN // 2
  155.         mn = 0
  156.         quality = 4
  157.         gmap = [[0 for x in range(0, WORLDLEN)]for z in range(0, WORLDLEN)]
  158.         for x in range(0, WORLDLEN):
  159.             for z in range(0, WORLDLEN):
  160.                 gmap[x - hl][z - hl] += round(PerlinNoise(x / quality, z / quality) * quality)
  161.                 mn = min(mn, gmap[x - hl][z - hl])
  162.         for x in range(-hl, hl):
  163.             for z in range(-hl, hl):
  164.                 gmap[x][z] += abs(mn)
  165.                 if gmap[x][z] < 2:
  166.                     self.add_block((x, -1, z), random.choice([SAND, STONE]))
  167.                     self.add_block((x, 0, z), WATER)
  168.                     self.add_block((x, 1, z), WATER)
  169.                 else:
  170.                     for y in range(-1, gmap[x][z]):
  171.                         self.add_block((x, y, z), STONE)
  172.                     self.add_block((x, gmap[x][z], z), GRASS)
  173.                 self.add_block((x, -2, z), ENDSTONE)
  174.         for x in range(-hl, hl, 4):
  175.             for z in range(-hl, hl, 4):
  176.                 if x == 0 and z == 0:
  177.                     continue
  178.                 if random.randint(0, 3) == 1 and gmap[x][z] > 1:
  179.                     self.tree(gmap[x][z] + 1, x, z)
  180.                     for i in range(x, x + 4):
  181.                         for j in range(z, z + 4):
  182.                             self._show_block((i, 30, j), CLOUD)
  183.                 elif random.randint(0, 4) == 2 and gmap[x][z] > 2:
  184.                     self.add_block((x, gmap[x][z] + 1, z), random.choice([PUMKEY, MELON]))
  185.         return gmap[0][0] + abs(mn) + 2
  186.  
  187.  
  188.     def hit_test(self, position, vector, max_distance=8):
  189.         m = 8
  190.         x, y, z = position
  191.         dx, dy, dz = vector
  192.         previous = None
  193.         for _ in range(max_distance * m):
  194.             key = normalize((x, y, z))
  195.             if key != previous and key in self.world:
  196.                 return key, previous
  197.             previous = key
  198.             x, y, z = x + dx / m, y + dy / m, z + dz / m
  199.         return None, None
  200.  
  201.     def exposed(self, position):
  202.         x, y, z = position
  203.         for dx, dy, dz in FACES:
  204.             if (x + dx, y + dy, z + dz) not in self.world:
  205.                 return True
  206.         return False
  207.  
  208.     def add_block(self, position, texture, immediate=True):
  209.         if position in self.world:
  210.             self.remove_block(position, immediate)
  211.         self.world[position] = texture
  212.         self.sectors.setdefault(sectorize(position), []).append(position)
  213.         if immediate:
  214.             if self.exposed(position):
  215.                 self.show_block(position)
  216.             self.check_neighbors(position)
  217.  
  218.     def remove_block(self, position, immediate=True):
  219.         del self.world[position]
  220.         self.sectors[sectorize(position)].remove(position)
  221.         if immediate:
  222.             if position in self.shown:
  223.                 self.hide_block(position)
  224.             self.check_neighbors(position)
  225.  
  226.     def check_neighbors(self, position):
  227.         x, y, z = position
  228.         for dx, dy, dz in FACES:
  229.             key = (x + dx, y + dy, z + dz)
  230.             if key not in self.world:
  231.                 continue
  232.             if self.exposed(key):
  233.                 if key not in self.shown:
  234.                     self.show_block(key)
  235.             else:
  236.                 if key in self.shown:
  237.                     self.hide_block(key)
  238.  
  239.     def show_block(self, position, immediate=True):
  240.         texture = self.world[position]
  241.         self.shown[position] = texture
  242.         if immediate:
  243.             self._show_block(position, texture)
  244.         else:
  245.             self._enqueue(self._show_block, position, texture)
  246.  
  247.     def _show_block(self, position, texture):
  248.         x, y, z = position
  249.         vertex_data = cube_vertices(x, y, z, 0.5)
  250.         texture_data = list(texture)
  251.         self._shown[position] = self.batch.add(24, GL_QUADS, self.group,
  252.             ('v3f/static', vertex_data),
  253.             ('t2f/static', texture_data))
  254.  
  255.     def hide_block(self, position, immediate=True):
  256.         self.shown.pop(position)
  257.         if immediate:
  258.             self._hide_block(position)
  259.         else:
  260.             self._enqueue(self._hide_block, position)
  261.  
  262.     def _hide_block(self, position):
  263.         self._shown.pop(position).delete()
  264.  
  265.     def show_sector(self, sector):
  266.         for position in self.sectors.get(sector, []):
  267.             if position not in self.shown and self.exposed(position):
  268.                 self.show_block(position, False)
  269.  
  270.     def hide_sector(self, sector):
  271.         for position in self.sectors.get(sector, []):
  272.             if position in self.shown:
  273.                 self.hide_block(position, False)
  274.  
  275.     def change_sectors(self, before, after):
  276.         before_set = set()
  277.         after_set = set()
  278.         pad = 4
  279.         for dx in range(-pad, pad + 1):
  280.             for dy in [0]:
  281.                 for dz in range(-pad, pad + 1):
  282.                     if dx ** 2 + dy ** 2 + dz ** 2 > (pad + 1) ** 2:
  283.                         continue
  284.                     if before:
  285.                         x, y, z = before
  286.                         before_set.add((x + dx, y + dy, z + dz))
  287.                     if after:
  288.                         x, y, z = after
  289.                         after_set.add((x + dx, y + dy, z + dz))
  290.         show = after_set - before_set
  291.         hide = before_set - after_set
  292.         for sector in show:
  293.             self.show_sector(sector)
  294.         for sector in hide:
  295.             self.hide_sector(sector)
  296.  
  297.     def _enqueue(self, func, *args):
  298.         self.queue.append((func, args))
  299.  
  300.     def _dequeue(self):
  301.         func, args = self.queue.popleft()
  302.         func(*args)
  303.  
  304.     def process_queue(self):
  305.         start = time.perf_counter()
  306.         while self.queue and time.perf_counter() - start < 1.0 / TICKS_PER_SEC:
  307.             self._dequeue()
  308.  
  309.     def process_entire_queue(self):
  310.         while self.queue:
  311.             self._dequeue()
  312.  
  313.  
  314. class Window(pyglet.window.Window):
  315.     def __init__(self, *args, **kwargs):
  316.         super(Window, self).__init__(*args, **kwargs)
  317.         self.exclusive = False
  318.         self.flying = False # 是否在飞行
  319.         self.walking = True # 是否在走路
  320.         self.jumping = False # 是否在跳
  321.         self.model = Model()
  322.         self.strafe = [0, 0]
  323.         self.position = (0, self.model.dfy, 0)
  324.         self.rotation = (0, 0)
  325.         self.sector = None
  326.         self.reticle = None
  327.         self.dy = 0
  328.         self.inventory = [GRASS, DIRT, STONE, SAND, WOOD, BRICK, PUMKEY, MELON, TNT]
  329.         self.block = self.inventory[0]
  330.         self.num_keys = [
  331.             key._1, key._2, key._3, key._4, key._5,
  332.             key._6, key._7, key._8, key._9, key._0]
  333.         self.label = pyglet.text.Label('', font_name='Arial', font_size=18,
  334.             x=10, y=self.height - 10, anchor_x='left', anchor_y='top',
  335.             color=(0, 0, 0, 255))
  336.         pyglet.clock.schedule_interval(self.update, 1.0 / TICKS_PER_SEC)
  337.  
  338.     def set_exclusive_mouse(self, exclusive):
  339.         super(Window, self).set_exclusive_mouse(exclusive)
  340.         self.exclusive = exclusive
  341.  
  342.     def get_sight_vector(self):
  343.         x, y = self.rotation
  344.         m = math.cos(math.radians(y))
  345.         dy = math.sin(math.radians(y))
  346.         dx = math.cos(math.radians(x - 90)) * m
  347.         dz = math.sin(math.radians(x - 90)) * m
  348.         return (dx, dy, dz)
  349.  
  350.     def get_motion_vector(self):
  351.         if any(self.strafe):
  352.             x, y = self.rotation
  353.             strafe = math.degrees(math.atan2(*self.strafe))
  354.             y_angle = math.radians(y)
  355.             x_angle = math.radians(x + strafe)
  356.             if self.flying:
  357.                 m = math.cos(y_angle)
  358.                 dy = math.sin(y_angle)
  359.                 if self.strafe[1]:
  360.                     dy = 0.0
  361.                     m = 1
  362.                 if self.strafe[0] > 0:
  363.                     dy *= -1
  364.                 dx = math.cos(x_angle) * m
  365.                 dz = math.sin(x_angle) * m
  366.             else:
  367.                 dy = 0.0
  368.                 dx = math.cos(x_angle)
  369.                 dz = math.sin(x_angle)
  370.         else:
  371.             dy = 0.0
  372.             dx = 0.0
  373.             dz = 0.0
  374.         return (dx, dy, dz)
  375.  
  376.     def update(self, dt):
  377.         # 刷新
  378.         global GTIME
  379.         global GNIGHT
  380.         global GDAY
  381.         glClearColor(0.5 - GTIME * 0.01, 0.69 - GTIME * 0.01, 1.0 - GTIME * 0.01, 1)
  382.         setup_fog()
  383.         GTIME += GDAY if GTIME < 23 else GNIGHT
  384.         if GTIME > 50:
  385.             GTIME = 50
  386.             GNIGHT = -GNIGHT
  387.             GDAY = -GDAY
  388.         elif GTIME < 0:
  389.             GTIME = 0
  390.             GNIGHT = -GNIGHT
  391.             GDAY = -GDAY
  392.         self.model.process_queue()
  393.         sector = sectorize(self.position)
  394.         if sector != self.sector:
  395.             self.model.change_sectors(self.sector, sector)
  396.             if self.sector is None:
  397.                 self.model.process_entire_queue()
  398.             self.sector = sector
  399.         m = 8
  400.         dt = min(dt, 0.2)
  401.         if self.jumping:
  402.             if self.dy == 0:
  403.                 self.dy = JUMP_SPEED
  404.         for _ in range(m):
  405.             self._update(dt / m)
  406.  
  407.     def _update(self, dt):
  408.         speed = FLYING_SPEED if self.flying else WALKING_SPEED if self.walking else RUNNING_SPEED
  409.         d = dt * speed
  410.         dx, dy, dz = self.get_motion_vector()
  411.         dx, dy, dz = dx * d, dy * d, dz * d
  412.         if not self.flying:
  413.             self.dy -= dt * GRAVITY
  414.             self.dy = max(self.dy, -TERMINAL_VELOCITY)
  415.             dy += self.dy * dt
  416.         x, y, z = self.position
  417.         x, y, z = self.collide((x + dx, y + dy, z + dz), PLAYER_HEIGHT)
  418.         self.position = (x, y, z)
  419.  
  420.     def collide(self, position, height):
  421.         pad = 0.25
  422.         p = list(position)
  423.         np = normalize(position)
  424.         for face in FACES:
  425.             for i in range(3):
  426.                 if not face[i]:
  427.                     continue
  428.                 d = (p[i] - np[i]) * face[i]
  429.                 if d < pad:
  430.                     continue
  431.                 for dy in range(height):
  432.                     op = list(np)
  433.                     op[1] -= dy
  434.                     op[i] += face[i]
  435.                     if tuple(op) not in self.model.world:
  436.                         continue
  437.                     p[i] -= (d - pad) * face[i]
  438.                     if face == (0, -1, 0) or face == (0, 1, 0):
  439.                         self.dy = 0
  440.                     break
  441.         return tuple(p)
  442.  
  443.     def TNTboom(self, x, y, z):
  444.         # TNT爆炸
  445.         self.model.remove_block((x, y, z))
  446.         bf = 4
  447.         s = 0
  448.         for dy in range(y - bf, y):
  449.             for i in range(x - s, x + s):
  450.                 for j in range(z - s, z + s):
  451.                     if (i, dy, j) in self.model.world:
  452.                         if j == z-s or j == z+s-1 or i == x-s or i == x+s-1:
  453.                             if random.randint(0, 1):
  454.                                 if self.model.world[(i, dy, j)] == TNT:
  455.                                     self.TNTboom(i, dy, j)
  456.                                     continue
  457.                                 if self.model.world[(i, dy, j)] != ENDSTONE:
  458.                                     self.model.remove_block((i, dy, j))
  459.                         else:
  460.                             if self.model.world[(i, dy, j)] == TNT:
  461.                                 self.TNTboom(i, dy, j)
  462.                                 continue
  463.                             if self.model.world[(i, dy, j)] != ENDSTONE:
  464.                                 self.model.remove_block((i, dy, j))
  465.             s += 1
  466.         s = bf
  467.         for i in range(x - s, x + s):
  468.             for j in range(z - s, z + s):
  469.                 if (i, y, j) in self.model.world:
  470.                     if j == z-s or j == z+s-1 or i == x-s or i == x+s-1:
  471.                         if random.randint(0, 1):
  472.                             if self.model.world[(i, y, j)] == TNT:
  473.                                 self.TNTboom(i, y, j)
  474.                                 continue
  475.                             self.model.remove_block((i, y, j))
  476.                     else:
  477.                         if self.model.world[(i, y, j)] == TNT:
  478.                             self.TNTboom(i, y, j)
  479.                             continue
  480.                         self.model.remove_block((i, y, j))
  481.         for dy in range(y + 1, y + s + 1):
  482.             for i in range(x - s, x + s):
  483.                 for j in range(z - s, z + s):
  484.                     if (i, dy, j) in self.model.world:
  485.                         if j == z-s or j == z+s-1 or i == x-s or i == x+s-1:
  486.                             if random.randint(0, 1):
  487.                                 if self.model.world[(i, dy, j)] == TNT:
  488.                                     self.TNTboom(i, dy, j)
  489.                                     continue
  490.                                 if self.model.world[(i, dy, j)] != ENDSTONE:
  491.                                     self.model.remove_block((i, dy, j))
  492.                         else:
  493.                             if self.model.world[(i, dy, j)] == TNT:
  494.                                 self.TNTboom(i, dy, j)
  495.                                 continue
  496.                             if self.model.world[(i, dy, j)] != ENDSTONE:
  497.                                 self.model.remove_block((i, dy, j))
  498.             s -= 1
  499.  
  500.     def on_mouse_press(self, x, y, button, modifiers):
  501.         if self.exclusive:
  502.             vector = self.get_sight_vector()
  503.             block, previous = self.model.hit_test(self.position, vector)
  504.             if (button == mouse.RIGHT) or \
  505.                     ((button == mouse.LEFT) and (modifiers & key.MOD_CTRL)):
  506.                 if previous:
  507.                     # 鼠标右击
  508.                     x, y, z = self.position
  509.                     flag = True
  510.                     for i in range(0, PLAYER_HEIGHT):
  511.                         if previous == normalize((x, y - i, z)):
  512.                             flag = False
  513.                             break
  514.                     if flag:
  515.                         self.model.add_block(previous, self.block)
  516.             elif button == pyglet.window.mouse.LEFT and block:
  517.                 # 鼠标左击
  518.                 texture = self.model.world[block]
  519.                 if texture == TNT:
  520.                     self.TNTboom(block[0], block[1], block[2])
  521.                 elif texture != ENDSTONE:
  522.                     self.model.remove_block(block)
  523.         else:
  524.             self.set_exclusive_mouse(True)
  525.  
  526.     def on_mouse_motion(self, x, y, dx, dy):
  527.         if self.exclusive:
  528.             m = 0.15
  529.             x, y = self.rotation
  530.             x, y = x + dx * m, y + dy * m
  531.             y = max(-90, min(90, y))
  532.             self.rotation = (x, y)
  533.  
  534.     def on_key_press(self, symbol, modifiers):
  535.         # 键盘按键
  536.         if symbol == key.W:
  537.             self.strafe[0] -= 1
  538.         elif symbol == key.S:
  539.             self.strafe[0] += 1
  540.         elif symbol == key.A:
  541.             self.strafe[1] -= 1
  542.         elif symbol == key.D:
  543.             self.strafe[1] += 1
  544.         elif symbol == key.SPACE:
  545.             self.jumping = True
  546.         elif symbol == key.R:
  547.             self.walking = not self.walking
  548.         elif symbol == key.ESCAPE:
  549.             self.set_exclusive_mouse(False)
  550.         elif symbol == key.E:
  551.             self.set_exclusive_mouse(False)
  552.         elif symbol == key.TAB:
  553.             self.flying = not self.flying
  554.         elif symbol in self.num_keys:
  555.             index = (symbol - self.num_keys[0]) % len(self.inventory)
  556.             self.block = self.inventory[index]
  557.  
  558.     def on_key_release(self, symbol, modifiers):
  559.         # 键盘松键
  560.         if symbol == key.W:
  561.             self.strafe[0] += 1
  562.         elif symbol == key.S:
  563.             self.strafe[0] -= 1
  564.         elif symbol == key.A:
  565.             self.strafe[1] += 1
  566.         elif symbol == key.D:
  567.             self.strafe[1] -= 1
  568.         elif symbol == key.SPACE:
  569.             self.jumping = False
  570.  
  571.     def on_resize(self, width, height):
  572.         # label
  573.         self.label.y = height - 10
  574.         # reticle
  575.         if self.reticle:
  576.             self.reticle.delete()
  577.         x, y = self.width // 2, self.height // 2
  578.         n = 10
  579.         self.reticle = pyglet.graphics.vertex_list(4,
  580.             ('v2i', (x - n, y, x + n, y, x, y - n, x, y + n))
  581.         )
  582.  
  583.     def set_2d(self):
  584.         # 3d模式
  585.         width, height = self.get_size()
  586.         glDisable(GL_DEPTH_TEST)
  587.         viewport = self.get_viewport_size()
  588.         glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1]))
  589.         glMatrixMode(GL_PROJECTION)
  590.         glLoadIdentity()
  591.         glOrtho(0, max(1, width), 0, max(1, height), -1, 1)
  592.         glMatrixMode(GL_MODELVIEW)
  593.         glLoadIdentity()
  594.  
  595.     def set_3d(self):
  596.         # 3d模式
  597.         width, height = self.get_size()
  598.         glEnable(GL_DEPTH_TEST)
  599.         viewport = self.get_viewport_size()
  600.         glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1]))
  601.         glMatrixMode(GL_PROJECTION)
  602.         glLoadIdentity()
  603.         gluPerspective(65.0, width / float(height), 0.1, 60.0)
  604.         glMatrixMode(GL_MODELVIEW)
  605.         glLoadIdentity()
  606.         x, y = self.rotation
  607.         glRotatef(x, 0, 1, 0)
  608.         glRotatef(-y, math.cos(math.radians(x)), 0, math.sin(math.radians(x)))
  609.         x, y, z = self.position
  610.         glTranslatef(-x, -y, -z)
  611.  
  612.     def on_draw(self):
  613.         # 绘制
  614.         self.clear()
  615.         self.set_3d()
  616.         glColor3d(1, 1, 1)
  617.         self.model.batch.draw()
  618.         self.draw_focused_block()
  619.         self.set_2d()
  620.         self.draw_label()
  621.         self.draw_reticle()
  622.  
  623.     def draw_focused_block(self):
  624.         vector = self.get_sight_vector()
  625.         block = self.model.hit_test(self.position, vector)[0]
  626.         if block:
  627.             x, y, z = block
  628.             vertex_data = cube_vertices(x, y, z, 0.51)
  629.             glColor3d(0, 0, 0)
  630.             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
  631.             pyglet.graphics.draw(24, GL_QUADS, ('v3f/static', vertex_data))
  632.             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
  633.  
  634.     def draw_label(self):
  635.         x, y, z = self.position
  636.         self.label.text = '%02d (%.2f, %.2f, %.2f) %d / %d' % (
  637.             pyglet.clock.get_fps(), x, y, z,
  638.             len(self.model._shown), len(self.model.world))
  639.         self.label.draw()
  640.  
  641.     def draw_reticle(self):
  642.         glColor3d(0, 0, 0)
  643.         self.reticle.draw(GL_LINES)
  644.  
  645.  
  646. def setup_fog():
  647.     # 初始化迷雾和光照
  648.     glEnable(GL_FOG)
  649.     glFogfv(GL_FOG_COLOR, (GLfloat * 4)(0.5 - GTIME * 0.01, 0.69 - GTIME * 0.01, 1.0 - GTIME * 0.01, 1))
  650.     glHint(GL_FOG_HINT, GL_DONT_CARE)
  651.     glFogi(GL_FOG_MODE, GL_LINEAR)
  652.     glFogf(GL_FOG_START, 30.0)
  653.     glFogf(GL_FOG_END, 60.0)
  654.     glLightfv(GL_LIGHT0, GL_POSITION, (GLfloat * 4)(0.0, 0.0, 0.0, 0.0))
  655.     setup_light()
  656.  
  657. def setup_light():
  658.     # 初始化光照
  659.     gamelight = 5.0 - GTIME / 10
  660.     glLightfv(GL_LIGHT0, GL_AMBIENT, (GLfloat * 4)(gamelight, gamelight, gamelight, 1.0))
  661.     glLightfv(GL_LIGHT0, GL_DIFFUSE, (GLfloat * 4)(gamelight, gamelight, gamelight, 1.0))
  662.     glLightfv(GL_LIGHT0, GL_SPECULAR, (GLfloat * 4)(1.0, 1.0, 1.0, 1.0))
  663.     glEnable(GL_LIGHTING)
  664.     glEnable(GL_LIGHT0)
  665.  
  666. def setup():
  667.     # 初始化
  668.     glClearColor(0.5 - GTIME * 0.01, 0.69 - GTIME * 0.01, 1.0 - GTIME * 0.01, 1)
  669.     glEnable(GL_CULL_FACE)
  670.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
  671.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
  672.     setup_fog()
  673.  
  674. def main():
  675.     window = Window(width=800, height=600, caption='Minecraft 2.1', resizable=True)
  676.     window.set_exclusive_mouse(True)
  677.     setup()
  678.     pyglet.app.run()

是不是很长呢？

三、主程序运行（其实它是最简单的！）

奉上代码！

  1. if __name__ == '__main__':
  2.     print("Welcome play python Minecraft 2.1")
  3.     print("Snow Word is open:", GAMETYPES)
  4.     print("World Seed:", SEED)
  5.     main()

最后程序简单不简单？

四、效果图

一、一般世界

二、冰雪世界

 是不是很酷？

五、图片资源

注意：命名为texture2_1哦!

 六、知识总结

python非常厉害，非常实用！大家可以来试一试哦！

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

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

  

闽ICP备14008679号