rd-160052 (160052)

Author: pythonengineer

Makefile

@@ -12,7 +12,7 @@ install:
 	CYTHONIZE=1 pip install .
 
 install-from-source: dist
-	pip install dist/minecraft-python-132328.tar.gz
+	pip install dist/minecraft-python-160052.tar.gz
 
 clean:
 	$(RM) -r build dist src/*.egg-info

README.md

@@ -4,27 +4,25 @@
 
 _**Minecraft: Python Edition**_ is a project that strives to recreate each and every old Minecraft version in Python using the **Pyglet** multimedia library and **Cython** for performance.
 
-This project is currently recreating the **Preclassic** versions of Minecraft. The latest version is **Preclassic rd-132328** as released on _**May 13, 2009**_.
+This project is currently recreating the **Preclassic** versions of Minecraft. The latest version is **Preclassic rd-160052** as released on _**May 15, 2009**_.
 
-Learn more about this version [here](https://minecraft.fandom.com/wiki/Java_Edition_pre-Classic_rd-132328).
+Learn more about this version [here](https://minecraft.fandom.com/wiki/Java_Edition_pre-Classic_rd-160052).
 
 ### General Usage
 
 *Pyglet* and *Cython* are required dependencies and can easily be installed with *pip*. Use the versions specified in `requirements.txt`.
 
-To easily install this version of *Minecraft: Python Edition*, just run `python -m pip install minecraft-python==132328`.
+To easily install this version of *Minecraft: Python Edition*, just run `python -m pip install minecraft-python==160052`.
 
 Alternatively, for a manual Cython build, run `python setup.py build_ext --inplace`.
 
 Run `python -m mc.net.minecraft.Minecraft` to launch the game. *Minecraft: Python Edition* should be compatible with any modern platform that supports OpenGL and Cython.
 
 ### Gameplay
 
-Very basic block picking and placing are featured in this version. You can only place stone tiles, except at exact ground level where it is only grass.
+Basic terrain, early block picking and placing, and human mobs are featured in this version. There are four different blocks you can place.
 
-Human mobs are featured in this version, but they are all spawned at game start as opposed to on key press.
-
-Press *Esc* to exit the game.
+Press *Esc* to exit the game. Press *Return* to save, *R* to reset your position, *G* to spawn a mob, and numbers *1-4* to switch blocks.
 
 ### Additional Notes
 

mc/Resources.py

@@ -16,8 +16,12 @@ class Entity:
     xRotO = 0.0
     onGround = False
 
+    removed = False
     heightOffset = 0.0
 
+    bbWidth = 0.6
+    bbHeight = 1.8
+
     def __init__(self, level):
         self.level = level
         self.resetPos()
@@ -28,12 +32,19 @@ def resetPos(self):
         z = random.random() * self.level.height
         self.setPos(x, y, z)
 
+    def remove(self):
+        self.removed = True
+
+    def setSize(self, w, h):
+        self.bbWidth = w
+        self.bbHeight = h
+
     def setPos(self, x, y, z):
         self.x = x
         self.y = y
         self.z = z
-        w = 0.3
-        h = 0.9
+        w = self.bbWidth / 2.0
+        h = self.bbHeight / 2.0
         self.bb = AABB(x - w, y - h, z - w, x + w, y + h, z + w)
 
     def turn(self, xo, yo):
@@ -83,6 +94,7 @@ def move(self, xa, ya, za):
             self.yd = 0.0
         if zaOrg != za:
             self.zd = 0.0
+
         self.x = (self.bb.x0 + self.bb.x1) / 2.0
         self.y = self.bb.y0 + self.heightOffset
         self.z = (self.bb.z0 + self.bb.z1) / 2.0
@@ -101,3 +113,6 @@ def moveRelative(self, xa, za, speed):
 
         self.xd += xa * cos - za * sin
         self.zd += za * cos + xa * sin
+
+    def isLit(self):
+        return self.level.isLit(self.x, self.y, self.z)

mc/net/minecraft/Entity.py

@@ -3,34 +3,58 @@
 
 from mc.net.minecraft.Timer import Timer
 from mc.net.minecraft.Player import Player
+from mc.net.minecraft.Textures import Textures
 from mc.net.minecraft.HitResult import HitResult
 from mc.net.minecraft.character.Vec3 import Vec3
-from mc.net.minecraft.character.Cube import Cube
 from mc.net.minecraft.character.Zombie import Zombie
+from mc.net.minecraft.level.tile.Tile import Tile
+from mc.net.minecraft.level.tile.Tiles import tiles
+from mc.net.minecraft.level.Tesselator import tesselator
+from mc.net.minecraft.level.Frustum import Frustum
 from mc.net.minecraft.level.Chunk import Chunk
 from mc.net.minecraft.level.Level import Level
 from mc.net.minecraft.level.LevelRenderer import LevelRenderer
+from mc.net.minecraft.particle.ParticleEngine import ParticleEngine
 from mc.CompatibilityShims import BufferUtils, gluPerspective, getMillis
 from pyglet import window, canvas, clock, gl, compat_platform
 
 import math
 
 class Minecraft(window.Window):
     FULLSCREEN_MODE = False
-    col = 920330
-    fogColor = ((col >> 16 & 0xFF) / 255.0, (col >> 8 & 0xFF) / 255.0, (col & 0xFF) / 255.0, (col & 0xFF) / 255.0, 1.0)
-    timer = Timer(60.0)
+    timer = Timer(20.0)
+    running = True
+    paintTexture = 1
+
     zombies = set()
+
     hitResult = None
-    running = True
+
+    lb = BufferUtils.createFloatBuffer(16)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+        col0 = 16710650
+        col1 = 920330
+
+        self.fogColor0 = ((col0 >> 16 & 0xFF) / 255.0, (col0 >> 8 & 0xFF) / 255.0, (col0 & 0xFF) / 255.0, (col0 & 0xFF) / 255.0, 1.0)
+        self.fogColor1 = ((col1 >> 16 & 0xFF) / 255.0, (col1 >> 8 & 0xFF) / 255.0, (col1 & 0xFF) / 255.0, (col1 & 0xFF) / 255.0, 1.0)
+
         fr = 0.5
         fg = 0.8
         fb = 1.0
 
+        self.set_fullscreen(self.FULLSCREEN_MODE)
+        self.set_exclusive_mouse(True)
+
+        display = canvas.Display()
+        screen = display.get_default_screen()
+        locationX = screen.width // 2 - self.width // 2
+        locationY = screen.height // 2 - self.height // 2
+        self.set_location(locationX, locationY)
+        self.set_visible(True)
+
         gl.glEnable(gl.GL_TEXTURE_2D)
         gl.glShadeModel(gl.GL_SMOOTH)
         gl.glClearColor(fr, fg, fb, 0.0)
@@ -42,22 +66,30 @@ def __init__(self, *args, **kwargs):
         gl.glLoadIdentity()
         gl.glMatrixMode(gl.GL_MODELVIEW)
 
+        self.__chunk = Chunk(None, 0, 0, 0, 0, 0, 0, True)
+
+        self.frustum = Frustum()
         self.level = Level(256, 256, 64)
         self.levelRenderer = LevelRenderer(self.level)
         self.player = Player(self.level)
+        self.particleEngine = ParticleEngine(self.level)
 
-        for i in range(100):
-            self.zombies.add(Zombie(self.level, 128.0, 0.0, 128.0))
-
-        self.set_exclusive_mouse(True)
+        for i in range(10):
+            zombie = Zombie(self.level, 128.0, 0.0, 128.0)
+            zombie.resetPos()
+            self.zombies.add(zombie)
 
     def destroy(self):
         self.level.save()
 
     def on_mouse_press(self, x, y, button, modifiers):
         if button == window.mouse.RIGHT:
             if self.hitResult:
-                self.level.setTile(self.hitResult.x, self.hitResult.y, self.hitResult.z, 0)
+                oldTile = tiles.tiles[self.level.getTile(self.hitResult.x, self.hitResult.y, self.hitResult.z)]
+                changed = self.level.setTile(self.hitResult.x, self.hitResult.y, self.hitResult.z, 0)
+                if oldTile and changed:
+                    oldTile.destroy(self.level, self.hitResult.x, self.hitResult.y, self.hitResult.z, self.particleEngine)
+                    self.level.setTile(self.hitResult.x, self.hitResult.y, self.hitResult.z, 0)
         elif button == window.mouse.LEFT:
             if self.hitResult:
                 x = self.hitResult.x
@@ -70,14 +102,24 @@ def on_mouse_press(self, x, y, button, modifiers):
                 if self.hitResult.f == 3: z += 1
                 if self.hitResult.f == 4: x -= 1
                 if self.hitResult.f == 5: x += 1
-                self.level.setTile(x, y, z, 1)
+                self.level.setTile(x, y, z, self.paintTexture)
 
     def on_mouse_motion(self, x, y, dx, dy):
         self.player.turn(dx, dy)
 
     def on_key_press(self, symbol, modifiers):
         if symbol == window.key.R:
             self.player.resetPos()
+        elif symbol == window.key.G:
+            self.zombies.add(Zombie(self.level, self.player.x, self.player.y, self.player.z))
+        elif symbol == window.key._1:
+            self.paintTexture = 1
+        elif symbol == window.key._2:
+            self.paintTexture = 3
+        elif symbol == window.key._3:
+            self.paintTexture = 4
+        elif symbol == window.key._4:
+            self.paintTexture = 5
         elif symbol in (window.key.UP, window.key.W):
             self.player.upPressed = True
         elif symbol in (window.key.DOWN, window.key.S):
@@ -118,15 +160,6 @@ def on_draw(self):
         self.render(self.timer.a)
 
     def run(self):
-        self.__chunk = Chunk(None, 0, 0, 0, 0, 0, 0, True)
-
-        display = canvas.Display()
-        screen = display.get_default_screen()
-        locationX = screen.width // 2 - self.width // 2
-        locationY = screen.height // 2 - self.height // 2
-        self.set_location(locationX, locationY)
-        self.set_visible(True)
-
         lastTime = getMillis()
         frames = 0
         while self.running:
@@ -145,8 +178,13 @@ def run(self):
         self.destroy()
 
     def tick(self):
-        for zombie in self.zombies:
+        self.level.tick()
+        self.particleEngine.tick()
+
+        for zombie in self.zombies.copy():
             zombie.tick()
+            if zombie.removed:
+                self.zombies.remove(zombie)
 
         self.player.tick()
 
@@ -168,6 +206,14 @@ def setupCamera(self, a):
         gl.glLoadIdentity()
         self.moveCameraToPlayer(a)
 
+    def setupOrthoCamera(self):
+        gl.glMatrixMode(gl.GL_PROJECTION)
+        gl.glLoadIdentity()
+        gl.glOrtho(0.0, self.width, self.height, 0.0, 100.0, 300.0)
+        gl.glMatrixMode(gl.GL_MODELVIEW)
+        gl.glLoadIdentity()
+        gl.glTranslatef(0.0, 0.0, -200.0)
+
     def pick(self, a):
         xRot = self.player.xRotO + (self.player.xRot - self.player.xRotO) * a
         yRot = self.player.yRotO + (self.player.yRot - self.player.yRotO) * a
@@ -191,28 +237,93 @@ def render(self, a):
 
         gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
         self.setupCamera(a)
-
         gl.glEnable(gl.GL_CULL_FACE)
-        gl.glEnable(gl.GL_FOG)
-        gl.glFogi(gl.GL_FOG_MODE, gl.GL_VIEWPORT_BIT)
-        gl.glFogf(gl.GL_FOG_DENSITY, 0.2)
-        gl.glFogfv(gl.GL_FOG_COLOR, (gl.GLfloat * 4)(self.fogColor[0], self.fogColor[1],
-                                                     self.fogColor[2], self.fogColor[3]))
 
-        gl.glDisable(gl.GL_FOG)
-        self.levelRenderer.render(self.player, 0)
+        self.frustum.calculateFrustum()
+        self.levelRenderer.updateDirtyChunks(self.player)
 
+        self.setupFog(0)
+        gl.glEnable(gl.GL_FOG)
+        self.levelRenderer.render(self.player, 0)
         for zombie in self.zombies:
-            zombie.render(a)
+            if zombie.isLit() and self.frustum.isVisible(zombie.bb):
+                zombie.render(a)
 
-        gl.glEnable(gl.GL_FOG)
+        self.particleEngine.render(self.player, a, 0)
+        self.setupFog(1)
         self.levelRenderer.render(self.player, 1)
-        gl.glDisable(gl.GL_TEXTURE_2D)
+        for zombie in self.zombies:
+            if not zombie.isLit() and self.frustum.isVisible(zombie.bb):
+                zombie.render(a)
 
+        self.particleEngine.render(self.player, a, 1)
+        gl.glDisable(gl.GL_LIGHTING)
+        gl.glDisable(gl.GL_TEXTURE_2D)
+        gl.glDisable(gl.GL_FOG)
         if self.hitResult:
             self.levelRenderer.renderHit(self.hitResult)
 
-        gl.glDisable(gl.GL_FOG)
+        self.drawGui(a)
+
+    def drawGui(self, a):
+        gl.glClear(gl.GL_DEPTH_BUFFER_BIT)
+        self.setupOrthoCamera()
+
+        gl.glPushMatrix()
+        gl.glTranslatef(self.width - 48, 48.0, 0.0)
+        t = tesselator
+        gl.glScalef(48.0, 48.0, 48.0)
+        gl.glRotatef(30.0, 1.0, 0.0, 0.0)
+        gl.glRotatef(45.0, 0.0, 1.0, 0.0)
+        gl.glTranslatef(1.5, -0.5, -0.5)
+
+        id_ = Textures.loadTexture('terrain.png', gl.GL_NEAREST)
+        gl.glBindTexture(gl.GL_TEXTURE_2D, id_)
+        gl.glEnable(gl.GL_TEXTURE_2D)
+        t.init()
+        tiles.tiles[self.paintTexture].render(t, self.level, 0, -2, 0, 0)
+        t.flush()
+        gl.glDisable(gl.GL_TEXTURE_2D)
+        gl.glPopMatrix()
+
+        wc = self.width // 2
+        hc = self.height // 2
+        gl.glColor4f(1.0, 1.0, 1.0, 1.0)
+        t.init()
+        t.vertex(wc + 1, hc - 8, 0.0)
+        t.vertex(wc - 0, hc - 8, 0.0)
+        t.vertex(wc - 0, hc + 9, 0.0)
+        t.vertex(wc + 1, hc + 9, 0.0)
+
+        t.vertex(wc + 9, hc - 0, 0.0)
+        t.vertex(wc - 8, hc - 0, 0.0)
+        t.vertex(wc - 8, hc + 1, 0.0)
+        t.vertex(wc + 9, hc + 1, 0.0)
+        t.flush()
+
+    def setupFog(self, i):
+        if i == 0:
+            gl.glFogi(gl.GL_FOG_MODE, gl.GL_VIEWPORT_BIT)
+            gl.glFogf(gl.GL_FOG_DENSITY, 0.001)
+            gl.glFogfv(gl.GL_FOG_COLOR, (gl.GLfloat * 4)(self.fogColor0[0], self.fogColor0[1],
+                                                         self.fogColor0[2], self.fogColor0[3]))
+            gl.glDisable(gl.GL_LIGHTING)
+        elif i == 1:
+            gl.glFogi(gl.GL_FOG_MODE, gl.GL_VIEWPORT_BIT)
+            gl.glFogf(gl.GL_FOG_DENSITY, 0.06)
+            gl.glFogfv(gl.GL_FOG_COLOR, (gl.GLfloat * 4)(self.fogColor1[0], self.fogColor1[1],
+                                                         self.fogColor1[2], self.fogColor1[3]))
+            gl.glEnable(gl.GL_LIGHTING)
+            gl.glEnable(gl.GL_COLOR_MATERIAL)
+
+            br = 0.6
+            gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, self.getBuffer(br, br, br, 1.0))
+
+    def getBuffer(self, a, b, c, d):
+        self.lb.clear()
+        self.lb.put(a).put(b).put(c).put(d)
+        self.lb.flip()
+        return self.lb
 
 if __name__ == '__main__':
     Minecraft(width=1024, height=768, caption='Game', vsync=False, visible=False).run()

mc/net/minecraft/Minecraft.py

@@ -24,16 +24,16 @@ def tick(self):
         if self.rightPressed: xa += 1.0
         if self.spacePressed:
             if self.onGround:
-                self.yd = 0.12
+                self.yd = 0.5
 
-        self.moveRelative(xa, ya, 0.02 if self.onGround else 0.005)
+        self.moveRelative(xa, ya, 0.1 if self.onGround else 0.02)
 
-        self.yd -= 0.005
+        self.yd -= 0.08
         self.move(self.xd, self.yd, self.zd)
         self.xd *= 0.91
         self.yd *= 0.98
         self.zd *= 0.91
 
         if self.onGround:
-            self.xd *= 0.8
-            self.zd *= 0.8
+            self.xd *= 0.7
+            self.zd *= 0.7