0.0.20a_01

Author: pythonengineer

Makefile

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

README.md

@@ -4,11 +4,11 @@
 
 _**Minecraft: Python Edition**_ is a project that strives to recreate each and every old Minecraft version in Python 3 using the **Pyglet** multimedia library and **Cython** for performance.
 
-This project is currently recreating the **Multiplayer Classic** versions of Minecraft. The latest version is **Classic 0.0.19a_06** as released on _**June 20, 2009**_.
+This project is currently recreating the **Multiplayer Classic** versions of Minecraft. The latest version is **Classic 0.0.20a_01** as released on _**June 20, 2009**_.
 
-Learn more about this version [here](https://minecraft.fandom.com/wiki/Java_Edition_Classic_0.0.19a_06).
+Learn more about this version [here](https://minecraft.fandom.com/wiki/Java_Edition_Classic_0.0.20a_01).
 
-Or the server version [here](https://minecraft.fandom.com/wiki/Java_Edition_Classic_server_1.6).
+Or the server version [here](https://minecraft.fandom.com/wiki/Java_Edition_Classic_server_1.8.2).
 
 This project is organized so that every commit is strictly the completed release of the Python version of the Java game of the same version number.
 This means that you can go back into this repository's commit history and see only the source code changes between versions of Minecraft,
@@ -19,7 +19,7 @@ you can play it just by specifying the Minecraft version you want to play in the
 
 *Pyglet*, *Cython*, and *Pillow* 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==0.0.19a_06`.
+To easily install this version of *Minecraft: Python Edition*, just run `python -m pip install minecraft-python==0.0.20a_01`.
 
 Alternatively, for a manual Cython build, run `python setup.py build_ext --inplace`.
 
@@ -31,8 +31,7 @@ Run with the argument `-fullscreen` to open the window in fullscreen mode.
 
 This version features multiplayer, chat, more advanced terrain (including caves and expanding water tiles), level saving, and human mobs.
 
-Press *Esc* to pause. Press *Enter* to set your spawn position, *R* to teleport to your spawn position, *Y* to invert the mouse, *G* to spawn a mob, and *F* to toggle render distance.
-Use the number keys or the mouse scroll wheel to switch tiles.
+Press *B* to open the inventory menu. Press *Enter* to set your spawn position, *R* to teleport to your spawn position, *Y* to invert the mouse, *G* to spawn a mob, and *F* to toggle render distance.
 
 ### Multiplayer
 

mc/Resources.py

@@ -21,6 +21,7 @@
 from mc.net.minecraft.gui.ChatScreen import ChatScreen
 from mc.net.minecraft.gui.ErrorScreen import ErrorScreen
 from mc.net.minecraft.gui.PauseScreen import PauseScreen
+from mc.net.minecraft.gui.InventoryScreen import InventoryScreen
 from mc.net.minecraft.gui.InGameHud import InGameHud
 from mc.net.minecraft.particle.ParticleEngine import ParticleEngine
 from mc.net.minecraft.renderer.texture.TextureWaterFX import TextureWaterFX
@@ -48,12 +49,11 @@ class StopGameException(Exception):
     pass
 
 class Minecraft(window.Window):
-    VERSION_STRING = '0.0.19a_06'
+    VERSION_STRING = '0.0.20a_01'
     __timer = Timer(20.0)
     level = None
     __levelRenderer = None
     player = None
-    paintTexture = 1
     __particleEngine = None
 
     user = None
@@ -181,15 +181,16 @@ def on_mouse_press(self, x, y, button, modifiers):
                 self.__prevFrameTime = self.__ticksRan
             elif button == window.mouse.RIGHT:
                 self.__editMode = (self.__editMode + 1) % 2
-            elif button == window.mouse.MIDDLE:
-                if self.__hitResult:
-                    tile = self.level.getTile(self.__hitResult.x, self.__hitResult.y, self.__hitResult.z)
-                    if tile == tiles.grass.id:
-                        tile = tiles.dirt.id
-
-                    for t in User.creativeTiles:
-                        if tile == t:
-                            self.paintTexture = t
+            elif button == window.mouse.MIDDLE and self.__hitResult:
+                tile = self.level.getTile(self.__hitResult.x, self.__hitResult.y, self.__hitResult.z)
+                if tile == tiles.grass.id:
+                    tile = tiles.dirt.id
+
+                slot = self.player.inventory.getSlotContainsID(tile)
+                if slot >= 0:
+                    self.player.inventory.selectedSlot = slot
+                elif tile > 0 and tiles.tiles[tile] in User.creativeTiles:
+                    self.player.inventory.getSlotContainsTile(tiles.tiles[tile])
         except Exception as e:
             print(traceback.format_exc())
             self.setScreen(ErrorScreen('Client error', 'The game broke! [' + str(e) + ']'))
@@ -208,18 +209,12 @@ def on_mouse_scroll(self, x, y, dx, dy):
 
             i3 = 0
 
-            for i, tile in enumerate(User.creativeTiles):
-                if tile == self.paintTexture:
-                    i3 = i
+            self.player.inventory.selectedSlot -= dy
+            while self.player.inventory.selectedSlot < 0:
+                self.player.inventory.selectedSlot += len(self.player.inventory.slots)
 
-            i3 += dy
-            while i3 < 0:
-                i3 += len(User.creativeTiles)
-
-            while i3 >= len(User.creativeTiles):
-                i3 -= len(User.creativeTiles)
-
-            self.paintTexture = User.creativeTiles[i3]
+            while self.player.inventory.selectedSlot >= len(self.player.inventory.slots):
+                self.player.inventory.selectedSlot -= len(self.player.inventory.slots)
         except Exception as e:
             self.setScreen(ErrorScreen('Client error', 'The game broke! [' + str(e) + ']'))
 
@@ -255,7 +250,7 @@ def on_key_press(self, symbol, modifiers):
 
             for i in range(9):
                 if symbol == getattr(window.key, '_' + str(i + 1)):
-                    self.paintTexture = User.creativeTiles[i]
+                    self.player.inventory.selectedSlot = i
 
             if symbol == window.key.Y:
                 self.__yMouseAxis = -self.__yMouseAxis
@@ -264,6 +259,8 @@ def on_key_press(self, symbol, modifiers):
             elif symbol == window.key.F:
                 z15 = modifiers & window.key.MOD_SHIFT
                 self.__levelRenderer.drawDistance = self.__levelRenderer.drawDistance + (-1 if z15 else 1) & 3
+            elif symbol == window.key.B:
+                self.setScreen(InventoryScreen())
             elif symbol == window.key.T and self.connectionManager and self.connectionManager.isConnected():
                 self.player.releaseAllKeys()
                 self.setScreen(ChatScreen())
@@ -486,7 +483,8 @@ def __releaseMouse(self):
         self.set_mouse_position(self.width // 2, self.height // 2)
 
     def __pauseGame(self):
-        self.setScreen(PauseScreen())
+        if not isinstance(self.guiScreen, PauseScreen):
+            self.setScreen(PauseScreen())
 
     def __clickMouse(self):
         if self.__hitResult:
@@ -501,24 +499,26 @@ def __clickMouse(self):
                 if self.__hitResult.f == 4: x -= 1
                 if self.__hitResult.f == 5: x += 1
 
+            oldTile = tiles.tiles[self.level.getTile(self.__hitResult.x, self.__hitResult.y, self.__hitResult.z)]
             if self.__editMode == 0:
-                oldTile = tiles.tiles[self.level.getTile(self.__hitResult.x, self.__hitResult.y, self.__hitResult.z)]
-                changed = self.level.netSetTile(self.__hitResult.x, self.__hitResult.y, self.__hitResult.z, 0)
-                if oldTile and changed:
-                    if self.__isMultiplayer():
-                        self.connectionManager.sendBlockChange(x, y, z, self.__editMode, self.paintTexture)
+                if oldTile != tiles.unbreakable or self.player.userType >= 100:
+                    changed = self.level.netSetTile(self.__hitResult.x, self.__hitResult.y, self.__hitResult.z, 0)
+                    if oldTile and changed:
+                        if self.__isMultiplayer():
+                            self.connectionManager.sendBlockChange(x, y, z, self.__editMode, self.player.inventory.getSelected())
 
-                    oldTile.destroy(self.level, self.__hitResult.x, self.__hitResult.y, self.__hitResult.z, self.__particleEngine)
+                        oldTile.destroy(self.level, self.__hitResult.x, self.__hitResult.y, self.__hitResult.z, self.__particleEngine)
             else:
                 tile = tiles.tiles[self.level.getTile(x, y, z)]
-                aabb = tiles.tiles[self.paintTexture].getAABB(x, y, z)
+                texture = self.player.inventory.getSelected()
+                aabb = tiles.tiles[texture].getAABB(x, y, z)
                 if (tile is None or tile == tiles.water or tile == tiles.calmWater or tile == tiles.lava or tile == tiles.calmLava) and \
                    (aabb is None or (False if self.player.bb.intersects(aabb) else self.level.isFree(aabb))):
                     if self.__isMultiplayer():
-                        self.connectionManager.sendBlockChange(x, y, z, self.__editMode, self.paintTexture)
+                        self.connectionManager.sendBlockChange(x, y, z, self.__editMode, texture)
 
-                    self.level.netSetTile(x, y, z, self.paintTexture)
-                    tiles.tiles[self.paintTexture].onBlockAdded(self.level, x, y, z)
+                    self.level.netSetTile(x, y, z, self.player.inventory.getSelected())
+                    tiles.tiles[texture].onBlockAdded(self.level, x, y, z)
 
     def __tick(self):
         for message in self.__hud.messages.copy():
@@ -682,7 +682,10 @@ def __render(self, a):
                         self.__levelRenderer.render(xx, yy, zz)
 
         self.__checkGlError('Rendered level')
+        self.__toggleLight(True)
         self.__levelRenderer.renderEntities(self.__frustum, a)
+        self.__toggleLight(False)
+        self.__setupFog()
         self.__checkGlError('Rendered entities')
         self.__particleEngine.render(self.player, a)
         self.__checkGlError('Rendered particles')
@@ -696,7 +699,7 @@ def __render(self, a):
         if self.__hitResult:
             gl.glDisable(gl.GL_LIGHTING)
             gl.glDisable(gl.GL_ALPHA_TEST)
-            self.__levelRenderer.renderHit(self.player, self.__hitResult, self.__editMode, self.paintTexture)
+            self.__levelRenderer.renderHit(self.player, self.__hitResult, self.__editMode, self.player.inventory.getSelected())
             LevelRenderer.renderHitOutline(self.__hitResult, self.__editMode)
             gl.glEnable(gl.GL_ALPHA_TEST)
             gl.glEnable(gl.GL_LIGHTING)
@@ -723,11 +726,28 @@ def __render(self, a):
         if self.__hitResult:
             gl.glDepthFunc(gl.GL_LESS)
             gl.glDisable(gl.GL_ALPHA_TEST)
-            self.__levelRenderer.renderHit(self.player, self.__hitResult, self.__editMode, self.paintTexture)
+            self.__levelRenderer.renderHit(self.player, self.__hitResult, self.__editMode, self.player.inventory.getSelected())
             LevelRenderer.renderHitOutline(self.__hitResult, self.__editMode)
             gl.glEnable(gl.GL_ALPHA_TEST)
             gl.glDepthFunc(gl.GL_LEQUAL)
 
+    def __toggleLight(self, z1):
+        if not z1:
+            gl.glDisable(gl.GL_LIGHTING)
+            gl.glDisable(gl.GL_LIGHT0)
+        else:
+            gl.glEnable(gl.GL_LIGHTING)
+            gl.glEnable(gl.GL_LIGHT0)
+            gl.glEnable(gl.GL_COLOR_MATERIAL)
+            gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE)
+            f4 = 0.7
+            f2 = 0.3
+            vec = Vec3(0.0, -1.0, 0.5).normalize()
+            gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, self.__getBuffer(vec.x, vec.y, vec.z, 0.0))
+            gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, self.__getBuffer(f2, f2, f2, 1.0))
+            gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, self.__getBuffer(0.0, 0.0, 0.0, 1.0))
+            gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, self.__getBuffer(f4, f4, f4, 1.0))
+
     def initGui(self):
         screenWidth = self.width * 240 // self.height
         screenHeight = self.height * 240 // self.height
@@ -767,7 +787,7 @@ def __setupFog(self):
 
     def __getBuffer(self, a, b, c, d):
         self.__lb.clear()
-        self.__lb.put(a).put(b).put(c).put(1.0)
+        self.__lb.put(a).put(b).put(c).put(d)
         self.__lb.flip()
         return self.__lb
 
@@ -872,7 +892,7 @@ def addChatMessage(self, string):
         elif arg == '-mppass':
             mpPass = sys.argv[i + 1]
 
-    game = Minecraft(fullScreen, width=854, height=480, caption='Minecraft 0.0.19a_06')
+    game = Minecraft(fullScreen, width=854, height=480, caption='Minecraft 0.0.20a_01')
     game.user = User(name, 0, mpPass)
     if server and port:
         game.setServer(server, int(port))

mc/net/minecraft/Minecraft.py

@@ -1,9 +1,14 @@
 from mc.net.minecraft.level.tile.Tiles import tiles
 
 class User:
-    creativeTiles = [tiles.rock.id, tiles.dirt.id, tiles.sponge.id,
-                     tiles.wood.id, tiles.bush.id, tiles.log.id,
-                     tiles.leaf.id, tiles.glass.id, tiles.gravel.id]
+    creativeTiles = [tiles.rock, tiles.wood, tiles.dirt, tiles.stoneBrick,
+                     tiles.log, tiles.leaf, tiles.bush, tiles.plantYellow,
+                     tiles.plantRed, tiles.mushroomBrown, tiles.mushroomRed, tiles.sand,
+                     tiles.gravel, tiles.glass, tiles.sponge, tiles.blockGold,
+                     tiles.clothRed, tiles.clothOrange, tiles.clothYellow, tiles.clothChartreuse,
+                     tiles.clothGreen, tiles.clothSpringGreen, tiles.clothCyan, tiles.clothCapri,
+                     tiles.clothUltramarine, tiles.clothViolet, tiles.clothPurple, tiles.clothMagenta,
+                     tiles.clothRose, tiles.clothDarkGray, tiles.clothGray, tiles.clothWhite]
 
     def __init__(self, name, sessionId, mpPass):
         self.name = name

mc/net/minecraft/User.py

@@ -1,5 +1,6 @@
 from mc.net.minecraft.character.Polygon import Polygon
 from mc.net.minecraft.character.Vertex import Vertex
+from mc.net.minecraft.character.Vec3 import Vec3
 from pyglet import gl
 
 class Cube:
@@ -59,23 +60,30 @@ def setPos(self, x, y, z):
         self.__y = y
         self.__z = 0.0
 
-    def render(self):
+    def render(self, a):
         if not self.__compiled:
             self.__list = gl.glGenLists(1)
             gl.glNewList(self.__list, gl.GL_COMPILE)
             gl.glBegin(gl.GL_QUADS)
             for polygon in self.__polygons:
+                vec37 = polygon.vertices[1].pos.subtract(polygon.vertices[0].pos).normalize()
+                vec38 = polygon.vertices[1].pos.subtract(polygon.vertices[2].pos).normalize()
+                vec37 = Vec3(vec37.y * vec38.z - vec37.z * vec38.y,
+                             vec37.z * vec38.x - vec37.x * vec38.z,
+                             vec37.x * vec38.y - vec37.y * vec38.x).normalize()
+                gl.glNormal3f(vec37.x, vec37.y, vec37.z)
+
                 for i in range(4):
                     v = polygon.vertices[i]
                     gl.glTexCoord2f(v.u / 64.0, v.v / 32.0)
-                    gl.glVertex3f(v.pos.x, v.pos.y, v.pos.z)
+                    gl.glVertex3f(v.pos.x * a, v.pos.y * a, v.pos.z * a)
             gl.glEnd()
             gl.glEndList()
             self.__compiled = True
 
         c = 57.29578
         gl.glPushMatrix()
-        gl.glTranslatef(self.__x, self.__y, self.__z)
+        gl.glTranslatef(self.__x * a, self.__y * a, self.__z * a)
         gl.glRotatef(self.zRot * c, 0.0, 0.0, 1.0)
         gl.glRotatef(self.yRot * c, 0.0, 1.0, 0.0)
         gl.glRotatef(self.xRot * c, 1.0, 0.0, 0.0)

mc/net/minecraft/character/Cube.py

@@ -1,6 +1,15 @@
+import math
+
 class Vec3:
 
     def __init__(self, x, y, z):
         self.x = x
         self.y = y
         self.z = z
+
+    def subtract(self, vec):
+        return Vec3(self.x - vec.x, self.y - vec.y, self.z - vec.z)
+
+    def normalize(self):
+        f1 = math.sqrt(self.x * self.x + self.y * self.y + self.z * self.z)
+        return Vec3(self.x / f1, self.y / f1, self.z / f1)

mc/net/minecraft/character/Vec3.py

@@ -61,10 +61,10 @@ def render(self, textures, a):
         yy = -abs(math.sin(t * 0.6662)) * 5.0 - 23.0
         gl.glTranslatef(self.xo + (self.x - self.xo) * a, self.yo + (self.y - self.yo) * a, self.zo + (self.z - self.zo) * a)
         gl.glScalef(1.0, -1.0, 1.0)
-        gl.glScalef(size, size, size)
-        gl.glTranslatef(0.0, yy, 0.0)
+        gl.glTranslatef(0.0, yy * size, 0.0)
         c = 57.29578
         gl.glRotatef(self.rot * c + 180.0, 0.0, 1.0, 0.0)
-        self.__zombieModel.render(t, 1.0, 0.0, 0.0, 0.0)
+        gl.glScalef(-1.0, 1.0, 1.0)
+        self.__zombieModel.render(t, 1.0, 0.0, 0.0, 0.0, size)
         gl.glPopMatrix()
         gl.glDisable(gl.GL_TEXTURE_2D)

mc/net/minecraft/character/Zombie.py

@@ -26,7 +26,7 @@ def __init__(self):
         self.__leg1.addBox(-2.0, 0.0, -2.0, 4, 12, 4)
         self.__leg1.setPos(2.0, 12.0, 0.0)
 
-    def render(self, a, f2, f3, f4, f5):
+    def render(self, a, f2, f3, f4, f5, f6):
         self.__head.yRot = f4 / 57.29578
         self.__head.xRot = f5 / 57.29578
         self.__arm0.xRot = math.cos(a * 0.6662 + math.pi) * 2.0 * f2
@@ -39,9 +39,9 @@ def render(self, a, f2, f3, f4, f5):
         self.__arm1.zRot -= math.cos(f3 * 0.09) * 0.05 + 0.05
         self.__arm0.xRot += math.sin(f3 * 0.067) * 0.05
         self.__arm1.xRot -= math.sin(f3 * 0.067) * 0.05
-        self.__head.render()
-        self.__body.render()
-        self.__arm0.render()
-        self.__arm1.render()
-        self.__leg0.render()
-        self.__leg1.render()
+        self.__head.render(f6)
+        self.__body.render(f6)
+        self.__arm0.render(f6)
+        self.__arm1.render(f6)
+        self.__leg0.render(f6)
+        self.__leg1.render(f6)

mc/net/minecraft/character/ZombieModel.py

@@ -75,6 +75,7 @@ def processData(self):
                 if packet == Packets.LOGIN:
                     self.manager.minecraft.beginLevelLoading(data[1].decode())
                     self.manager.minecraft.levelLoadUpdate(data[2].decode())
+                    self.manager.minecraft.player.userType = data[3]
                 elif packet == Packets.LEVEL_INITIALIZE:
                     self.manager.minecraft.setLevel(None)
                     self.manager.levelBuffer = ByteArrayOutputStream()