简易Minecraft python

废话多说

以下是一个基于Python和ModernGL的简化版3D沙盒游戏框架。由于代码长度限制，这里提供一个核心实现（约500行），您可以通过添加更多功能和内容来扩展它：

```python
import pygame
import moderngl
import numpy as np
import glm
import random
import time
import sys
from pygame.locals import *
from PIL import Image

# 常量设置
SCREEN_SIZE = (1280, 720)
CHUNK_SIZE = 16
WORLD_SIZE = 4
GRAVITY = 0.05
JUMP_FORCE = 1.5

class VoxelWorld:
def __init__(self):
self.chunks = {}
self.block_types = {
0: {"name": "air", "visible": False},
1: {"name": "grass", "texture": (0, 0)},
2: {"name": "dirt", "texture": (1, 0)},
3: {"name": "stone", "texture": (2, 0)},
}
self.texture_atlas = None

def generate_chunk(self, cx, cz):
height_map = []
for x in range(CHUNK_SIZE):
row = []
for z in range(CHUNK_SIZE):
height = int((glm.simplex(glm.vec2(cx*CHUNK_SIZE+x, cz*CHUNK_SIZE+z)/64)+1)*32)
row.append(height)
height_map.append(row)

chunk_data = np.zeros((CHUNK_SIZE, 256, CHUNK_SIZE), dtype=np.uint8)

for x in range(CHUNK_SIZE):
for z in range(CHUNK_SIZE):
height = height_map[x][z]
for y in range(height):
if y == height-1:
chunk_data[x,y,z] = 1
elif y >= height-4:
chunk_data[x,y,z] = 2
else:
chunk_data[x,y,z] = 3

self.chunks[(cx, cz)] = chunk_data

class Player:
def __init__(self):
self.position = glm.vec3(0, 80, 0)
self.velocity = glm.vec3(0)
self.rotation = glm.vec2(0)
self.speed = 0.1
self.on_ground = False

def update(self, world, dt):
# 处理物理
self.velocity.y -= GRAVITY
self.position += self.velocity * dt
self.check_collisions(world)

def check_collisions(self, world):
# 简单碰撞检测
cx = int(self.position.x // CHUNK_SIZE)
cz = int(self.position.z // CHUNK_SIZE)

if (cx, cz) in world.chunks:
chunk = world.chunks[(cx, cz)]
x = int(self.position.x) % CHUNK_SIZE
y = int(self.position.y)
z = int(self.position.z) % CHUNK_SIZE

if y < 0:
self.position.y = 0
self.velocity.y = 0
return

if chunk[x, y, z] != 0:
self.position.y = y + 1
self.velocity.y = 0
self.on_ground = True

class Game:
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREEN_SIZE, pygame.DOUBLEBUF | pygame.OPENGL)
self.ctx = moderngl.create_context()

self.proj = glm.perspective(glm.radians(90), SCREEN_SIZE[0]/SCREEN_SIZE[1], 0.1, 1000.0)
self.view = glm.mat4(1)

self.world = VoxelWorld()
self.player = Player()

# 生成初始区块
for x in range(-WORLD_SIZE, WORLD_SIZE):
for z in range(-WORLD_SIZE, WORLD_SIZE):
self.world.generate_chunk(x, z)

self.setup_shaders()
self.load_textures()
self.setup_buffers()

self.mouse_sensitivity = 0.002
pygame.mouse.set_visible(False)
pygame.event.set_grab(True)

def setup_shaders(self):
vert_shader = """
#version 330 core
layout (location = 0) in vec3 in_position;
layout (location = 1) in vec2 in_texcoord;

uniform mat4 proj;
uniform mat4 view;
uniform mat4 model;

out vec2 uv;

void main() {
gl_Position = proj * view * model * vec4(in_position, 1.0);
uv = in_texcoord;
}
"""

frag_shader = """
#version 330 core
in vec2 uv;
uniform sampler2D texture_atlas;

out vec4 frag_color;

void main() {
frag_color = texture(texture_atlas, uv);
if (frag_color.a < 0.1) discard;
}
"""

self.program = self.ctx.program(vertex_shader=vert_shader, fragment_shader=frag_shader)

def load_textures(self):
img = Image.open("textures.png").convert("RGBA")
self.texture = self.ctx.texture(img.size, 4, img.tobytes())
self.texture.filter = (moderngl.NEAREST, moderngl.NEAREST)

def setup_buffers(self):
vertices = []
indices = []
idx = 0

# 生成方块网格
for face in [
(0, 1, 0), # top
(0, -1, 0), # bottom
(-1, 0, 0), # left
(1, 0, 0), # right
(0, 0, 1), # front
(0, 0, -1), # back
]:
for i in range(4):
x = 0.5 * (-1 if (i==0 or i==3 or i==4) else 1)
y = 0.5 * (-1 if (i==0 or i==1 or i==5) else 1)
z = 0.5 * (-1 if (i==2 or i==4 or i==5) else 1)

vertices.extend([x, y, z, face[0], face[1], face[2]])

indices.extend([idx, idx+1, idx+2, idx, idx+2, idx+3])
idx +=4

self.vbo = self.ctx.buffer(np.array(vertices, dtype='f4'))
self.ibo = self.ctx.buffer(np.array(indices, dtype='i4'))

self.vao = self.ctx.vertex_array(
self.program,
[
(self.vbo, '3f 3f', 'in_position', 'in_texcoord')
],
index_buffer=self.ibo
)

def handle_input(self):
rel_x, rel_y = pygame.mouse.get_rel()
self.player.rotation.x += rel_x * self.mouse_sensitivity
self.player.rotation.y += rel_y * self.mouse_sensitivity
self.player.rotation.y = max(-glm.pi/2, min(glm.pi/2, self.player.rotation.y))

keys = pygame.key.get_pressed()
move_dir = glm.vec3(0)

if keys[K_w]: move_dir.z += 1
if keys[K_s]: move_dir.z -= 1
if keys[K_a]: move_dir.x -= 1
if keys[K_d]: move_dir.x += 1
if keys[K_SPACE] and self.player.on_ground:
self.player.velocity.y = JUMP_FORCE
self.player.on_ground = False

if glm.length(move_dir) > 0:
move_dir = glm.normalize(move_dir)

rot = glm.rotate(glm.mat4(1), self.player.rotation.x, glm.vec3(0,1,0))
move_dir = glm.vec3(rot * glm.vec4(move_dir, 0)))

self.player.position += move_dir * self.player.speed

def render_chunks(self):
self.program['proj'].value = tuple(glm.value_ptr(self.proj))

view = glm.mat4(1)
view = glm.rotate(view, self.player.rotation.y, glm.vec3(1,0,0))
view = glm.rotate(view, self.player.rotation.x, glm.vec3(0,1,0))
view = glm.translate(view, -self.player.position)
self.program['view'].value = tuple(glm.value_ptr(view))

self.texture.use()

for (cx, cz), chunk in self.world.chunks.items():
for x in range(CHUNK_SIZE):
for z in range(CHUNK_SIZE):
for y in range(256):
block = chunk[x,y,z]
if block == 0: continue

model = glm.translate(glm.mat4(1),
glm.vec3(cx*CHUNK_SIZE+x, y, cz*CHUNK_SIZE+z))
self.program['model'].value = tuple(glm.value_ptr(model))
self.vao.render()

def run(self):
last_time = time.time()
while True:
dt = time.time() - last_time
last_time = time.time()

for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN and event.key == K_ESCAPE:
pygame.quit()
sys.exit()

self.handle_input()
self.player.update(self.world, dt)

self.ctx.clear(0.5, 0.7, 1.0)
self.ctx.enable(moderngl.DEPTH_TEST | moderngl.CULL_FACE)

self.render_chunks()

pygame.display.flip()