这篇文章主要介绍了计算机编程语言实现我的世界小游戏源代码，代码简单易懂，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

我的世界小游戏使用方法：

移动

前进：W，后退：S，向左：A，向右：D，环顾四周：鼠标，跳起：空格键，切换飞行模式：制表符

选择建筑材料

砖：1,草：2,沙子：3,删除建筑：鼠标左键单击，创建建筑块：鼠标右键单击

经济社会委员会退出程序。

完整程序包请通过文末地址下载，程序运行截图如下：

从__未来_ _进口部门

导入系统

导入数学

随机导入

导入时间

从集合导入队列

从皮格莱特导入图像

从pyglet.gl导入*

从pyglet.graphics导入纹理组

从pyglet . windows导入键，鼠标

每秒滴答数=60

#用于减轻块加载的扇区大小。

扇区大小=16

WALKING_SPEED=5

飞行速度=15

重力=20.0

最大跳跃高度=1.0 #大约一个街区的高度。

#要推导计算跳跃速度的公式，首先求解

# v_t=v_0 a * t

#表示达到最大高度的时间，其中a是加速度

#由于重力和v_t=0 .这给出了：

# t=- v_0/a

#使用t和所需的最大跳跃高度求解v_0(跳跃速度)

# s=s_0 v_0 * t (a * t^2)/2

JUMP_SPEED=math.sqrt(2 *重力* MAX_JUMP_HEIGHT)

终端速度=50

玩家高度=2

如果sys.version_info[0]=3:

xrange=范围

定义立方体顶点(x，y，z，n):

'''返回位于位置x，y，z的立方体的顶点，大小为2*n .

'''

返回[

x-n，y n，z-n，x-n，y n，z n，x n，y n，z n，x n，y n，z-n，# top

x-n，y-n，z-n，x n，y-n，z-n，x n，y-n，z n，x-n，y-n，z n，# bottom

x-n，y-n，z-n，x-n，y-n，z n，x-n，y n，z n，x-n，y n，z-n，#左

x n，y-n，z n，x n，y-n，z-n，x n，y n，z-n，x n，y n，z n，#右

x-n，y-n，z n，x n，y-n，z n，x n，y n，z n，x-n，y n，z n，# front

x n，y-n，z-n，x-n，y-n，z-n，x-n，y n，z-n，x n，y n，z-n，#返回

]

def tex_coord(x，y，n=4):

''返回纹理正方形的边界顶点。

'''

m=1.0/n

dx=x * m

dy=y * m

返回dx，dy，dx m，dy，dx m，dy m，dx，dy m

定义纹理坐标(顶部、底部、侧面):

''返回顶部、底部和侧面的纹理方块列表。

'''

top=tex_coord(*top)

bottom=tex_coord(*bottom)

side=tex_coord(*side)

结果=[]

结果。扩展（顶部)

结果.扩展(底部)

结果.扩展(边* 4)

回送结果

TEXTURE_PATH='texture.png '

GRASS=tex_coords((1，0)，(0，1)，(0，0))

SAND=tex_coords((1，1)，(1，1)，(1，1))

BRICK=tex_coords((2，0)，(2，0)，(2，0))

STONE=tex_coords((2，1)，(2，1)，(2，1))

FACES=[

( 0, 1, 0),

( 0,-1, 0),

(-1, 0, 0),

( 1, 0, 0),

( 0, 0, 1),

( 0, 0,-1),

]

定义正常化（位置):

""接受任意精度的"位置",并返回块

包含那个位置。

因素

-

位置：透镜3元组

返回

-

块_位置：镜头3的整数元组

'''

x，y，z=位置

x，y，z=(int(round(x))，int(round(y))，int(round(z))

返回(x，y，z)

定义分区（位置):

''返回表示给定"位置"的扇区的元组。

因素

-

位置：透镜3元组

返回

-

扇区：长度为3元组

'''

x，y，z=规格化（位置)

x，y，z=x //扇区大小，y //扇区大小，z //扇区大小

return (x，0，z)

类别模型（对象):

def __init__(self):

#批处理是用于批处理渲染的顶点列表的集合。

自我。batch=pyglet。图形。批处理()

#纹理组管理一个OpenGL纹理。

自我。group=纹理组(图像。load(纹理路径)).get_texture())

#从位置到该位置的块的纹理的映射。

#这定义了当前世界上的所有块。

self.world={}

#与“世界”的映射相同，但只包含显示的块。

self.shown={ }

#从位置映射到所有显示块的pyglet“顶点列表”.

自我. showed _ showed={ }

#从扇区映射到该扇区内的位置列表。

self.sectors={}

#简单的函数队列实现。队列中填充了

# _show_block()和_hide_block()调用

self.queue=deque()

自我. initialize()

def _initialize(自我):

''通过放置所有方块来初始化世界。

'''

n=80 # 1/2世界的宽度和高度

s=1 #步长

y=0 #初始y高度

对于xrange(-n，n ^ 1，s)中的x:

对于xrange中的z(-n，n ^ 1，s):

#到处创造一层石头一层草。

self.add_block((x，y - 2，z)，GRASS，immediate=False)

self.add_block((x，y - 3，z)，STONE，immediate=False)

如果x在(-n，n)或z在(-n，n):

#创建外墙。

对于xrange(-2，3)中的dy:

self.add_block((x，y dy，z)，STONE，immediate=False)

#随机生成山丘

o=n - 10

for _ in xrange(120):

a=random.randint(-o，o) # x山的位置

b=山的random.randint(-o，o) # z位置

c=-1 #山脚下

h=random.randint(1，6) #山的高度

s=random.randint(4，8) # 2 * s是山的边长

d=1 #从山上逐渐变细的速度

t=随机。选择([草、沙、砖])

对于xrange(c，c h)中的y:

对于xrange中的x(a-s，a s 1):

对于xrange(b - s，b s 1)中的z:

if (x - a) ** 2 (z - b) ** 2 (s 1) ** 2:

继续

if (x - 0) ** 2 (z - 0) ** 2 5 ** 2:

继续

self.add_block((x，y，z)，t，immediate=False)

s -=d #减少侧边长度，使山坡逐渐变细

def hit_test(self，position，vector，max_distance=8):

''从当前位置开始视线搜索。如果一个块被

返回与它相交的块，以及该行中先前的块

看不见。如果没有找到块，则返回没有，没有.

因素

-

位置：透镜3元组

检查可见性的(x，y，z)位置。

向量：透镜3元组

视线向量。

最大距离：整数

有几个街区远才能找到目标？

'''

m=8

x，y，z=位置

dx，dy，dz=矢量

先前=无

对于x范围内的距离（最大距离*米):

密钥=正常化((x，y，z))

如果键！=自我世界中的上一个和关键点：

返回键，上一个

前一个=键

x，y，z=x dx/m，y dy/m，z dz/m

不返回，不返回

暴露的定义(自身，位置):

给定"位置",返回假的，所有6个边都被包围

块，否则为真。

'''

x，y，z=位置

对于面中的dx、dy、dz:

如果(x dx，y dy，z dz)不在自我世界中：

返回真实的

返回错误的

def add_block(self，position，texture，immediate=True):

''将具有给定"纹理"和"位置"的块添加到世界中。

因素

-

位置：透镜3元组

要添加的块的(x，y，z)位置。

纹理：镜头3列表

纹理方块的坐标。使用` tex_coords()'可以

生成。

立即：布尔

是否立即抽块。

'''

如果在自我世界中的位置：

self.remove_block(位置，立即)

自我世界[位置]=纹理

自我。部门。设置默认值(扇区化(位置)，[]).追加（位置)

如果立即：

如果自我暴露（位置):

self.show_block(位置)

self.check _ neighbors(位置)

def remove_block(self，position，immediate=True):

'''移除给定"位置"处的块。

因素

-

位置：透镜3元组

要移除的块的(x，y，z)位置。

立即：布尔

是否立即从画布上移除块。

'''

德尔赛尔夫。世界[位置]

自我。部门[划分（位置)]。移除（位置)

如果立即：

如果位置在自显示中：

self.hide_block(位置)

self.check _ neighbors(位置)

定义检查_邻居（自身，位置):

"检查'位置'周围的所有区块，并确保其可见

状态是当前的。这意味着隐藏未曝光的块

确保显示所有暴露的模块。通常用于街区之后

被添加或移除。

'''

x，y，z=位置

对于面中的dx、dy、dz:

key=(x dx，y dy，z dz)

如果密钥不在自己的世界中：

继续

如果自我暴露（关键):

如果钥匙不在显示屏上：

self.show_block(键)

否则：

如果键入自显示：

self.hide_block(key)

def show_block(self，position，immediate=True):

'''显示给定"位置"处的块。此方法假定

已经使用add_block()添加了块

因素

-

位置：透镜3元组

要显示的块的(x，y，z)位置。

立即：布尔

是否立即显示该块。

'''

质感=自我。世界[位置]

自显示[位置]=纹理

如果立即：

自我. show_block(位置、纹理)

否则：

自我。_入队（自身. show_block，position，texture)

定义_显示_块(自身，位置，纹理):

" " show_block()"方法的私有实现。

因素

-

位置：透镜3元组

要显示的块的(x，y，z)位置。

纹理：镜头3列表

纹理方块的坐标。使用` tex_coords()'可以

生成。

'''

x，y，z=位置

顶点数据=立方体顶点(x，y，z，0.5)

texture_data=list(纹理)

#创建顶点列表

# FIXME也许应该改用" add_indexed()"

自我.显示了[位置]=自己。批量。add(24，GL_QUADS，self.group，

(' v3f/static '，vertex_data)，

(' t2f/static '，texture_data))

def hide_block(self，position，immediate=True):

''在给定的"位置"隐藏块。隐藏不会移除

与世隔绝。

因素

-

位置：透镜3元组

要隐藏的块的(x，y，z)位置。

立即：布尔

是否立即从画布中移除该块。

'''

自我。显示。波普(位置)

如果立即：

自我. hide_block(位置)

否则：

自我。_入队（自身. hide_block，position)

def _hide_block(self，position):

" " hide_block()"方法的私有实现。

'''

自我. shown.pop(位置)。删除()

定义显示_扇区(自身，部门):

''确保给定扇区中应显示的所有块都

被吸引到画布上。

'''

对于self.sectors.get(sector，[])中的位置：

如果位置不在自显示和自暴露（位置):

self.show_block(position，False)

def hide_sector(自身，扇区):

''确保给定扇区中所有应隐藏的块

从画布上移除。

'''

对于self.sectors.get(sector，[])中的位置：

如果位置在自显示中：

self.hide_block(position，False)

定义更改_扇区(自身、之前、之后):

从"之前"区移到"之后"区。扇区是一个

世界上相邻的x，y次区域。扇区用于加速

世界渲染。

'''

before_set=set()

after_set=set()

pad=4

对于xrange中的dx(-pad，pad 1):

对于[0]中的dy:# x范围(-pad，pad 1):

对于xrange中的dz(-pad，pad 1):

如果dx ** 2 dy ** 2 dz ** 2(焊盘1) ** 2:

继续

如果在之前：

x，y，z=之前

before_set.add((x dx，y dy，z dz))

如果之后：

x，y，z=之后

after_set.add((x dx，y dy，z dz))

显示=后设置-前设置

hide=before_set - after_set

对于展会中的部门：

self.show_sector(部门)

对于隐藏的扇区：

self.hide_sector(扇区)

def _enqueue(self，func，*args):

'''将“功能”添加到内部队列。

'''

self.queue.append((func，args))

def _dequeue(self):

''从内部队列中弹出顶层函数并调用它。

'''

func，args=self.queue.popleft()

func(*args)

定义进程_队列（自身):

''处理整个队列，同时定期休息。这允许

游戏循环流畅运行。队列包含对的调用

_show_block()和_hide_block()，因此在以下情况下应调用此方法

使用立即=假调用了add_block()或remove_block()

'''

start=time.perf_counter()

自我排队时和时间。time()-start 1.0/TICKS _ PER _ SEC:

自我。_出列()

定义进程整体队列(自身):

""不间断地处理整个队列。

'''

当自我队列：

自我。_出列()

类窗口(pyglet.window.Window):

def __init__(self，*args，**kwargs):

超级（窗口，自己)。__init__(*args，**kwargs)

#窗口是否独占捕获鼠标。

self.exclusive=False

#当飞行重力不起作用，速度增加时。

self.flying=False

#扫射是横向移动到你面对的方向，

#例如，向左或向右移动，同时继续面向前方。

#

#第一个元素向前移动时为-1,向后移动时为1,为0

#否则。第二个元素向左移动时为-1,移动时为一

#右，否则为0。

self.strafe=[0，0]

#当前(x，y，z)在世界上的位置，用浮点数指定。注意

#可能不像数学课，y轴是纵轴。

自我定位=(0,0,0)

#第一个元素是球员在x-z平面的旋转（地面

#平面)从z轴向下测量。第二是轮换

#从地平面向上的角度。旋转以度为单位。

#

#垂直平面旋转范围从-90 (向下看)到

# 90(直视上方)。水平旋转范围是无限的。

自旋转=(0,0)

#玩家当前所在的区域。

自我部门=无

#屏幕中央的十字准线。

self .十字线=无

# y(向上)方向的速度。

self.dy=0

#玩家可以放置的方块列表。按数字键循环。

自我。库存=[砖、草、沙]

#用户可以放置的当前块。按数字键循环。

self.block=self.inventory[0]

#便捷的数字键列表。

self.num_keys=[

钥匙。_1,键。_2,键。_3,键。_4,键。_5,

钥匙。_6,关键。_7,键。_8,键。_9,键。_0]

#处理世界的模型的实例。

self.model=Model()

#显示在画布左上角的标签。

self.label=pyglet.text.Label(' '，font_name='Arial '，font_size=18，

x=10，y=self.height - 10，anchor_x='left '，anchor_y='top '，

color=(0，0，0，255))

#此调用安排要调用的"更新()"方法

每秒滴答数。这是主游戏事件循环。

皮格莱特。时钟。schedule _ interval(自身。更新，1.0次/秒)

定义set_exclusive_mouse(自身，独占):

''如果'独占'为真，游戏将捕捉鼠标，如果为假

游戏会忽略鼠标。

'''

超级（窗口，自己)。设置_独占_鼠标（独占)

独家的

def获取_视线_矢量(自身):

''返回当前视线向量，指示方向

玩家在看。

'''

x，y=自旋转

# y的范围从-90到90,或-/2到/2，因此m的范围从0到1,并且

#平行于地面向前看时为1,向前看时为0

#直上直下。

m=math.cos(数学弧度(y))

# dy的范围从-1到1,向下看时为-1,向下看时为一

#抬头仰望。

dy=math.sin(数学弧度(y))

dx=math.cos(数学弧度(x - 90)) * m

dz=math.sin(数学弧度(x - 90)) * m

返回(dx，dy，dz)

极好的获取_运动_矢量（自身):

''返回当前运动向量，指示

玩家。

返回

-

向量：透镜3元组

分别包含x、y和z方向速度的元组。

'''

如果有（自我扫射):

x，y=自旋转

strafe=数学。学位(数学。atan2(*自我。扫射))

y _角度=数学弧度(y)

x _角度=数学弧度(十扫射)

如果自我飞翔：

m=math.cos(y_angle)

dy=math.sin(y_angle)

if self.strafe[1]:

#向左或向右移动。

dy=0.0

m=1

if self.strafe[0] 0:

#向后移动。

dy *=-1

#当你向上或向下飞行时，你的左和右就变少了

#运动。

dx=math.cos(x_angle) * m

dz=math.sin(x_angle) * m

否则：

dy=0.0

dx=math.cos(x_angle)

dz=math.sin(x_angle)

否则：

dy=0.0

dx=0.0

dz=0.0

返回(dx，dy，dz)

定义更新（自身，dt):

' ' ' '此方法计划由皮格莱特重复调用

时钟。

因素

-

dt:浮动

上次通话后的时间变化。

'''

self.model.process_queue()

扇形=扇形化（自我定位)

如果扇区！=自身部门：

自我。模型。改变_部门(自我。扇区，扇区)

如果自我部门为无：

自我。模型。process _ entire _ queue()

自我部门=部门

m=8

dt=min(dt，0.2)

对于xrange中的_ m:

自我。_更新（日/月)

def _update(self，dt):

" " "更新()"方法的私有实现。这是大多数人

运动逻辑的生命，以及重力和碰撞检测。

因素

-

dt:浮动

上次通话后的时间变化。

'''

#散步

速度=飞行_速度如果自己。飞行否则行走_速度

d=dt *速度#该滴答走过的距离。

dx，dy，dz=self.get_motion_vector()

#空间中的新位置，未考虑重力。

dx，dy，dz=dx * d，dy * d，dz * d

#重力

如果不是自动飞行：

#更新你的垂直速度：如果你正在下降，加速直到你

#命中终端速度；如果你正在跳跃，放慢速度直到你

#开始坠落。

self.dy -=dt *重力

self.dy=max(self.dy，-终端速度)

dy=self.dy * dt

冲突数量

x，y，z=自我位置

x，y，z=self.collide((x dx，y dy，z dz)，PLAYER_HEIGHT)

自我定位=(x，y，z)

定义碰撞（自身，位置，高度):

''检查给定"位置"和"高度"的玩家是否

与世界上的任何街区相撞。

因素

-

位置：透镜3元组

要检查碰撞的(x，y，z)位置。

高度：int或漂浮物

球员的身高。

返回

-

位置：透镜3元组

考虑到碰撞的玩家的新位置。

'''

#您需要与周围块的尺寸重叠多少

#不得不算一次碰撞。如果为0,触摸地形将被视为

#一次碰撞。如果是点49,你就沉入地下，仿佛穿行而过

#高高的草。如果=0.5,你会掉到地上。

pad=0.25

p=列表（位置)

np=标准化（位置)

对于面中的面：#检查所有周围的块

对于xrange(3)中的我：#独立检查每个维度

如果不是脸[我]:

继续

#您与此维度有多少重叠。

d=(p[i] - np[i]) * face[i]

如果d垫：

继续

对于xrange(高度)中的dy:#检查每个高度

op=列表(np)

op[1] -=dy

面[我]

如果元组(op)不在自我.模型.世界中：

继续

p[i] -=(d - pad) * face[i]

如果face==(0，-1，0)或face==(0，1，0):

#你碰到了地面或天花板，所以停下来

#下降/上升。

self.dy=0

破裂

返回元组(p)

定义on_mouse_press(自身，x，y，按钮，修改器):

''当按下鼠标按钮时调用。查看按钮的皮格莱特文档

超微半导体公司修改器贴图。

我的世界小游戏python源代码包下载地址：

链接: https://pan.baidu.com/s/1gKAheRzAeNmRXgSU-A4PPg

提取码: rya9

到此这篇关于Python实现我的世界小游戏源代码的文章就介绍到这了,更多相关Python小游戏源代码内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。