rd-161348 (161348)

Author: pythonengineer

Makefile

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

README.md

@@ -4,25 +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-160052** as released on _**May 15, 2009**_.
+This project is currently recreating the **Preclassic** versions of Minecraft. The latest version is **Preclassic rd-161348** as released on _**May 16, 2009**_.
 
-Learn more about this version [here](https://minecraft.fandom.com/wiki/Java_Edition_pre-Classic_rd-160052).
+Learn more about this version [here](https://minecraft.fandom.com/wiki/Java_Edition_pre-Classic_rd-161348).
 
 ### 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==160052`.
+To easily install this version of *Minecraft: Python Edition*, just run `python -m pip install minecraft-python==161348`.
 
 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
 
-Basic terrain, early block picking and placing, and human mobs are featured in this version. There are four different blocks you can place.
+Basic terrain, early block picking and placing, and human mobs are featured in this version. There are five different blocks you can place.
 
-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.
+Press *Esc* to exit the game. Press *Return* to save, *R* to reset your position, *G* to spawn a mob, and numbers *1-4* (*6* for saplings) to switch blocks.
 
 ### Additional Notes
 

mc/Resources.py

@@ -61,6 +61,8 @@ def __init__(self, *args, **kwargs):
         gl.glClearDepth(1.0)
         gl.glEnable(gl.GL_DEPTH_TEST)
         gl.glDepthFunc(gl.GL_LEQUAL)
+        gl.glEnable(gl.GL_ALPHA_TEST)
+        gl.glAlphaFunc(gl.GL_GREATER, 0.0)
 
         gl.glMatrixMode(gl.GL_PROJECTION)
         gl.glLoadIdentity()
@@ -89,7 +91,6 @@ def on_mouse_press(self, x, y, button, modifiers):
                 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
@@ -120,6 +121,8 @@ def on_key_press(self, symbol, modifiers):
             self.paintTexture = 4
         elif symbol == window.key._4:
             self.paintTexture = 5
+        elif symbol == window.key._6:
+            self.paintTexture = 6
         elif symbol in (window.key.UP, window.key.W):
             self.player.upPressed = True
         elif symbol in (window.key.DOWN, window.key.S):
@@ -206,14 +209,6 @@ 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
@@ -261,21 +256,32 @@ def render(self, a):
         gl.glDisable(gl.GL_TEXTURE_2D)
         gl.glDisable(gl.GL_FOG)
         if self.hitResult:
+            gl.glDisable(gl.GL_ALPHA_TEST)
             self.levelRenderer.renderHit(self.hitResult)
+            gl.glEnable(gl.GL_ALPHA_TEST)
 
         self.drawGui(a)
 
     def drawGui(self, a):
+        screenWidth = self.width * 240 // self.height
+        screenHeight = self.height * 240 // self.height
+
         gl.glClear(gl.GL_DEPTH_BUFFER_BIT)
-        self.setupOrthoCamera()
+        gl.glMatrixMode(gl.GL_PROJECTION)
+        gl.glLoadIdentity()
+        gl.glOrtho(0.0, screenWidth, screenHeight, 0.0, 100.0, 300.0)
+        gl.glMatrixMode(gl.GL_MODELVIEW)
+        gl.glLoadIdentity()
+        gl.glTranslatef(0.0, 0.0, -200.0)
 
         gl.glPushMatrix()
-        gl.glTranslatef(self.width - 48, 48.0, 0.0)
+        gl.glTranslatef(screenWidth - 16, 16.0, 0.0)
         t = tesselator
-        gl.glScalef(48.0, 48.0, 48.0)
+        gl.glScalef(16.0, 16.0, 16.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)
+        gl.glTranslatef(-1.5, 0.5, -0.5)
+        gl.glScalef(-1.0, -1.0, 1.0)
 
         id_ = Textures.loadTexture('terrain.png', gl.GL_NEAREST)
         gl.glBindTexture(gl.GL_TEXTURE_2D, id_)
@@ -286,19 +292,19 @@ def drawGui(self, a):
         gl.glDisable(gl.GL_TEXTURE_2D)
         gl.glPopMatrix()
 
-        wc = self.width // 2
-        hc = self.height // 2
+        wc = screenWidth // 2
+        hc = screenHeight // 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.vertex(wc + 1, hc - 4, 0.0)
+        t.vertex(wc - 0, hc - 4, 0.0)
+        t.vertex(wc - 0, hc + 5, 0.0)
+        t.vertex(wc + 1, hc + 5, 0.0)
+
+        t.vertex(wc + 5, hc - 0, 0.0)
+        t.vertex(wc - 4, hc - 0, 0.0)
+        t.vertex(wc - 4, hc + 1, 0.0)
+        t.vertex(wc + 5, hc + 1, 0.0)
         t.flush()
 
     def setupFog(self, i):

mc/net/minecraft/Minecraft.py

@@ -45,9 +45,6 @@ def tick(self):
         self.yd *= 0.98
         self.zd *= 0.91
 
-        if self.y > 100.0:
-            self.resetPos()
-
         if self.onGround:
             self.xd *= 0.7
             self.zd *= 0.7

mc/net/minecraft/character/Zombie.py

@@ -175,7 +175,9 @@ cdef class Level:
                 for z in range(z0, z1):
                     tile = tiles.tiles[self.getTile(x, y, z)]
                     if tile:
-                        aABBs.add(tile.getAABB(x, y, z))
+                        aabb = tile.getAABB(x, y, z)
+                        if aabb:
+                            aABBs.add(aabb)
 
         return aABBs
 

mc/net/minecraft/level/Level.pyx

@@ -114,7 +114,7 @@ cdef class Tesselator:
         self.p += 1
 
         self.vertices += 1
-        if self.p >= self.max_floats - self.len:
+        if self.vertices % 4 == 0 and (self.p >= self.max_floats - self.len * 4):
             self.flush()
 
 tesselator = Tesselator()

mc/net/minecraft/level/Tesselator.pyx

@@ -0,0 +1,55 @@
+from mc.net.minecraft.level.tile.Tile import Tile
+
+import math
+
+class Bush(Tile):
+
+    def __init__(self, tiles, id_):
+        super().__init__(tiles, id_)
+        self.tex = 15
+
+    def tick(self, level, x, y, z, random):
+        below = level.getTile(x, y - 1, z)
+        if not level.isLit(x, y, z) or (below != self.tiles.dirt.id and below != self.tiles.grass.id):
+            level.setTile(x, y, z, 0)
+
+    def render(self, t, level, layer, x, y, z):
+        if level.isLit(x, y, z) ^ layer != 1:
+            return
+
+        tex = self.getTexture(15)
+        u0 = tex % 16 / 16.0
+        u1 = u0 + 0.0624375
+        v0 = tex // 16 / 16.0
+        v1 = v0 + 0.0624375
+
+        rots = 2
+        t.color(1.0, 1.0, 1.0)
+        for r in range(rots):
+            xa = math.sin(r * math.pi / rots + 0.7854) * 0.5
+            za = math.cos(r * math.pi / rots + 0.7854) * 0.5
+            x0 = x + 0.5 - xa
+            x1 = x + 0.5 + xa
+            y0 = y + 0.0
+            y1 = y + 1.0
+            z0 = z + 0.5 - za
+            z1 = z + 0.5 + za
+
+            t.vertexUV(x0, y1, z0, u1, v0)
+            t.vertexUV(x1, y1, z1, u0, v0)
+            t.vertexUV(x1, y0, z1, u0, v1)
+            t.vertexUV(x0, y0, z0, u1, v1)
+
+            t.vertexUV(x1, y1, z1, u0, v0)
+            t.vertexUV(x0, y1, z0, u1, v0)
+            t.vertexUV(x0, y0, z0, u1, v1)
+            t.vertexUV(x1, y0, z1, u0, v1)
+
+    def getAABB(self, x, y, z):
+        return None
+
+    def blocksLight(self):
+        return False
+
+    def isSolid(self):
+        return False

mc/net/minecraft/level/tile/Bush.py

@@ -14,6 +14,6 @@ cdef class Tile:
     cpdef int getTexture(self, int face)
     cpdef renderFace(self, Tesselator t, int x, int y, int z, int face)
     cpdef renderFaceNoTexture(self, Tesselator t, int x, int y, int z, int face)
-    cdef bint blocksLight(self)
+    cpdef bint blocksLight(self)
     cpdef bint isSolid(self)
     cpdef void tick(self, level, int x, int y, int z, random) except *

mc/net/minecraft/level/tile/Tile.pxd

@@ -134,10 +134,13 @@ cdef class Tile:
             t.vertex(x1, y1, z0)
             t.vertex(x1, y1, z1)
 
+    def getTileAABB(self, int x, int y, int z):
+        return AABB(x, y, z, x + 1, y + 1, z + 1)
+
     def getAABB(self, int x, int y, int z):
         return AABB(x, y, z, x + 1, y + 1, z + 1)
 
-    cdef bint blocksLight(self):
+    cpdef bint blocksLight(self):
         return True
 
     cpdef bint isSolid(self):

mc/net/minecraft/level/tile/Tile.pyx

@@ -12,3 +12,4 @@ cdef class Tiles:
         public Tile dirt
         public Tile stoneBrick
         public Tile wood
+        public Tile bush

mc/net/minecraft/level/tile/Tiles.pxd

@@ -3,6 +3,7 @@
 from mc.net.minecraft.level.tile.Tile cimport Tile
 from mc.net.minecraft.level.tile.GrassTile import GrassTile
 from mc.net.minecraft.level.tile.DirtTile import DirtTile
+from mc.net.minecraft.level.tile.Bush import Bush
 
 cdef class Tiles:
 
@@ -19,5 +20,7 @@ cdef class Tiles:
         self.tiles[4] = self.stoneBrick
         self.wood = Tile(self, 5, 4)
         self.tiles[5] = self.wood
+        self.bush = Bush(self, 6)
+        self.tiles[6] = self.bush
 
 tiles = Tiles()

mc/net/minecraft/level/tile/Tiles.pyx

@@ -18,22 +18,28 @@ def __init__(self, level, x, y, z, xa, ya, za, tex):
         speed = (random.random() + random.random() + 1.0) * 0.15
 
         dd = math.sqrt(self.xd * self.xd + self.yd * self.yd + self.zd * self.zd)
-        self.xd = self.xd / dd * speed * 0.7
-        self.yd = self.yd / dd * speed
-        self.zd = self.zd / dd * speed * 0.7
+        self.xd = self.xd / dd * speed * 0.4
+        self.yd = self.yd / dd * speed * 0.4 + 0.1
+        self.zd = self.zd / dd * speed * 0.4
 
         self.uo = random.random() * 3.0
         self.vo = random.random() * 3.0
 
+        self.size = random.random() * 0.5 + 0.5
+
+        self.lifetime = 4.0 // (random.random() * 0.9 + 0.1)
+        self.age = 0
+
     def tick(self):
         self.xo = self.x
         self.yo = self.y
         self.zo = self.z
 
-        if random.random() < 0.1:
+        if self.age >= self.lifetime:
             self.remove()
+        self.age += 1
 
-        self.yd -= 0.06
+        self.yd -= 0.04
         self.move(self.xd, self.yd, self.zd)
         self.xd *= 0.98
         self.yd *= 0.98
@@ -43,17 +49,17 @@ def tick(self):
             self.xd *= 0.7
             self.zd *= 0.7
 
-    def render(self, t, a, xa, ya, za):
+    def render(self, t, a, xa, ya, za, xa2, za2):
         u0 = (self.tex % 16 + self.uo / 4.0) / 16.0
         u1 = u0 + 0.01560938
         v0 = (self.tex // 16 + self.vo / 4.0) / 16.0
         v1 = v0 + 0.01560938
-        r = 0.1
+        r = 0.1 * self.size
 
         x = self.xo + (self.x - self.xo) * a
         y = self.yo + (self.y - self.yo) * a
         z = self.zo + (self.z - self.zo) * a
-        t.vertexUV(x - xa * r, y - ya * r, z - za * r, u0, v1)
-        t.vertexUV(x - xa * r, y + ya * r, z - za * r, u0, v0)
-        t.vertexUV(x + xa * r, y + ya * r, z + za * r, u1, v0)
-        t.vertexUV(x + xa * r, y - ya * r, z + za * r, u1, v1)
+        t.vertexUV(x - xa * r - xa2 * r, y - ya * r, z - za * r - za2 * r, u0, v1)
+        t.vertexUV(x - xa * r + xa2 * r, y + ya * r, z - za * r + za2 * r, u0, v0)
+        t.vertexUV(x + xa * r + xa2 * r, y + ya * r, z + za * r + za2 * r, u1, v0)
+        t.vertexUV(x + xa * r - xa2 * r, y - ya * r, z + za * r - za2 * r, u1, v1)

mc/net/minecraft/particle/Particle.py

@@ -25,13 +25,16 @@ def render(self, player, a, layer):
         gl.glBindTexture(gl.GL_TEXTURE_2D, id_)
         xa = -math.cos(player.yRot * math.pi / 180.0)
         za = -math.sin(player.yRot * math.pi / 180.0)
-        ya = 1.0
+
+        xa2 = -za * math.sin(player.xRot * math.pi / 180.0)
+        za2 = xa * math.sin(player.xRot * math.pi / 180.0)
+        ya = math.cos(player.xRot * math.pi / 180.0)
 
         t = tesselator
         gl.glColor4f(0.8, 0.8, 0.8, 1.0)
         t.init()
         for p in self.particles:
             if p.isLit() ^ layer == 1:
-                p.render(t, a, xa, ya, za)
+                p.render(t, a, xa, ya, za, xa2, za2)
         t.flush()
         gl.glDisable(gl.GL_TEXTURE_2D)

mc/net/minecraft/particle/ParticleEngine.py

@@ -20,7 +20,7 @@
 
 setup(
     name='minecraft-python',
-    version='160052-1',
+    version='161348',
     author='pythonengineer',
     description='A project that seeks to recreate every old Minecraft version in Python using Pyglet and Cython.',
     long_description=open('README.md').read(),