0.30

Author: pythonengineer

.github/workflows/wheels.yml

@@ -19,26 +19,28 @@ jobs:
         os: [ubuntu-22.04, windows-2022, macos-11]
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.14.1
+        uses: pypa/cibuildwheel@v2.16.5
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
+          name: dist-${{ matrix.os }}
           path: ./wheelhouse/*.whl
 
   build_sdist:
     name: Build source distribution
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Build sdist
         run: pipx run build --sdist
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
+          name: dist-${{ matrix.os }}
           path: dist/*.tar.gz
 
   upload_pypi:
@@ -49,9 +51,10 @@ jobs:
       id-token: write
     if: github.event_name == 'release' && github.event.action == 'published'
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: artifact
+          pattern: dist-*
+          merge-multiple: true
           path: dist
 
       - uses: pypa/gh-action-pypi-publish@release/v1

Makefile

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

README.md

@@ -1,14 +1,16 @@
 ## Minecraft: Python Edition
 
-![Minecraft](/screenshot.png?raw=true)
+![Minecraft](/creative.png?raw=true)
 
 _**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 **Late Classic** versions of Minecraft. The latest version is **Classic 0.29_02** as released on _**October 30, 2009**_.
+This project has finished recreating the **Classic** versions of Minecraft. The latest version is **Classic 0.30** as released on _**November 10, 2009**_.
 
-Learn more about this version [here](https://minecraft.fandom.com/wiki/Java_Edition_Classic_0.29_02).
+This version comes with both survival and creative modes: to enable survival mode, just run with the argument `-survival`.
 
-Or the server version [here](https://minecraft.fandom.com/wiki/Java_Edition_Classic_server_1.8.3).
+Learn more about this version [here](https://minecraft.wiki/w/Java_Edition_Classic_0.30).
+
+Or the server version [here](https://minecraft.wiki/w/Java_Edition_Classic_server_1.10.1).
 
 This project is organized so that every commit is strictly the finished 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,
@@ -18,34 +20,40 @@ you can play it just by specifying the Minecraft version you want to play in the
 ### General Usage
 
 *Pyglet*, *Cython*, *Pillow*, and *PyOgg* are required dependencies and can easily be installed with *pip*. Use the versions specified in `requirements.txt`.
+*wxPython* is an optional dependency for the level file picker, but if you don't have it then *Tkinter* is used instead.
 
 For audio to work you will either need *PyOgg* which is recommended, or FFmpeg which is installed on the system.
 GStreamer is also supported on Linux through the *gst-python* library. PyOgg requires that your system have one of the *Opus*, *FLAC*, or *Vorbis* codecs. OpenAL is required.
 
-To easily install this version of *Minecraft: Python Edition*, just run `python -m pip install minecraft-python==0.29`.
+To easily install this version of *Minecraft: Python Edition*, just run `python -m pip install minecraft-python==0.30`.
 
 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.
 
 Run with the argument `-fullscreen` to open the window in fullscreen mode.
 
-It is possible to enable a limited survival mode by editing `self.gamemode` in `Minecraft.py`.
+### Creative Gameplay
+
+In creative mode, no mobs exist. All Classic ores and tiles are made available by pressing B to pick blocks.
+
+You can press F5 to toggle rain. Other keys are listed in the regular options menu.
+
+### Survival Gameplay
 
-### Gameplay
+![Minecraft](/survival.png?raw=true)
 
-This is a creative version of Classic, so no mobs exist. All ores and tiles are featured in this version.
+The survival version features early mobs (pigs, creepers, skeletons, zombies, spiders) and basic combat. Press Tab to launch arrows at enemies.
 
-If you enable survival mode, there will be limited functionality.
-Only sheep will spawn, which you can get wool from. Apart from that, no items drop.
+There are pigs that drop brown mushrooms. Sheep also exist. Creepers explode only upon death.
 
-Press B to pick blocks. Press F5 to toggle rain. Other keys are listed in the regular options menu.
+To heal, pick up mushrooms and right click to eat. Red mushrooms are poisonous and will take away health.
 
 ### Multiplayer
 
-To launch the multiplayer game, run `python -m mc.net.minecraft.Minecraft -server <host:port> -user <username> -mppass [password]`.
+To launch the multiplayer game while in creative mode, run `python -m mc.net.minecraft.Minecraft -server <host:port> -user <username> -mppass [password]`.
 
-This client is compatible with any 0.30 server that doesn't use an extended network protocol.
+This client is compatible with any Classic server that doesn't use an extended protocol.
 
 Press *Tab* in-game to view connected players.
 

creative.png

@@ -1,3 +1,4 @@
+from mc.CompatibilityShims import getMillis
 from mc.net.minecraft import StopGameException
 from mc.net.minecraft.renderer.Tesselator import tesselator
 from pyglet import clock, gl
@@ -8,6 +9,7 @@ def __init__(self, minecraft):
         self.__minecraft = minecraft
         self.__title = ''
         self.__desc = ''
+        self.__time = getMillis()
 
     def beginLevelLoading(self, desc):
         if not self.__minecraft.running:
@@ -36,24 +38,30 @@ def setLoadingProgress(self):
         if not self.__minecraft.running:
             raise StopGameException
         else:
-            screenWidth = self.__minecraft.width * 240 // self.__minecraft.height
-            screenHeight = self.__minecraft.height * 240 // self.__minecraft.height
-
-            gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
-
-            t = tesselator
-            id_ = self.__minecraft.textures.loadTexture('dirt.png')
-            gl.glBindTexture(gl.GL_TEXTURE_2D, id_)
-            s = 32.0
-            t.begin()
-            t.color(0x404040)
-            t.vertexUV(0.0, screenHeight, 0.0, 0.0, screenHeight / s)
-            t.vertexUV(screenWidth, screenHeight, 0.0, screenWidth / s, screenHeight / s)
-            t.vertexUV(screenWidth, 0.0, 0.0, screenWidth / s, 0.0)
-            t.vertexUV(0.0, 0.0, 0.0, 0.0, 0.0)
-            t.end()
-
-            self.__minecraft.font.drawShadow(self.__desc, (screenWidth - self.__minecraft.font.width(self.__desc)) // 2, screenHeight // 2 - 4 - 16, 0xFFFFFF)
-            self.__minecraft.font.drawShadow(self.__title, (screenWidth - self.__minecraft.font.width(self.__title)) // 2, screenHeight // 2 - 4 + 8, 0xFFFFFF)
-            clock.tick()
-            self.__minecraft.flip()
+            time = getMillis()
+            if time - self.__time < 0 or time - self.__time >= 20:
+                screenWidth = self.__minecraft.width * 240 // self.__minecraft.height
+                screenHeight = self.__minecraft.height * 240 // self.__minecraft.height
+
+                gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
+
+                t = tesselator
+                id_ = self.__minecraft.textures.loadTexture('dirt.png')
+                gl.glBindTexture(gl.GL_TEXTURE_2D, id_)
+                s = 32.0
+                t.begin()
+                t.color(0x404040)
+                t.vertexUV(0.0, screenHeight, 0.0, 0.0, screenHeight / s)
+                t.vertexUV(screenWidth, screenHeight, 0.0, screenWidth / s, screenHeight / s)
+                t.vertexUV(screenWidth, 0.0, 0.0, screenWidth / s, 0.0)
+                t.vertexUV(0.0, 0.0, 0.0, 0.0, 0.0)
+                t.end()
+
+                self.__minecraft.font.drawShadow(self.__desc,
+                                                 (screenWidth - self.__minecraft.font.width(self.__desc)) // 2,
+                                                 screenHeight // 2 - 4 - 16, 0xFFFFFF)
+                self.__minecraft.font.drawShadow(self.__title,
+                                                 (screenWidth - self.__minecraft.font.width(self.__title)) // 2,
+                                                 screenHeight // 2 - 4 + 8, 0xFFFFFF)
+                clock.tick()
+                self.__minecraft.flip()

mc/net/minecraft/LevelLoaderListener.py

@@ -64,7 +64,7 @@
 GL_DEBUG = False
 
 class Minecraft(window.Window):
-    VERSION_STRING = '0.29_02'
+    VERSION_STRING = '0.30'
     level = None
     levelRenderer = None
     player = None
@@ -87,12 +87,16 @@ class Minecraft(window.Window):
 
     guiScreenChanged = False
 
-    def __init__(self, fullscreen, *args, **kwargs):
+    def __init__(self, fullscreen, survival, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         self.__fullscreen = fullscreen
 
-        self.gamemode = CreativeGameMode(self)
+        if survival:
+            self.gamemode = SurvivalGameMode(self)
+        else:
+            self.gamemode = CreativeGameMode(self)
+
         self.__timer = Timer(20.0)
         self.user = None
         self.guiScreen = None
@@ -207,6 +211,8 @@ def on_mouse_press(self, x, y, button, modifiers):
                         tile = tiles.dirt.id
                     elif tile == tiles.slabFull.id:
                         tile = tiles.slabHalf.id
+                    elif tile == tiles.unbreakable.id:
+                        tile = tiles.rock.id
 
                     self.player.inventory.grabTexture(tile, isinstance(self.gamemode, CreativeGameMode))
         except Exception as e:
@@ -788,7 +794,7 @@ def __pick(self, alpha):
         vec2 = rotVec.add(xy * d, x2 * d, y1 * d)
         self.hitResult = self.level.clip(rotVec, vec2)
         if self.hitResult:
-            d = self.hitResult.vec.distanceTo(rotVec)
+            d = self.hitResult.vec.distanceTo(self.gameRenderer.getPlayerRotVec(alpha))
 
         vec = self.gameRenderer.getPlayerRotVec(alpha)
         if isinstance(self.gamemode, CreativeGameMode):
@@ -1067,6 +1073,7 @@ def loadLevel(self, level):
     port = None
     name = 'guest'
     mpPass = ''
+    survival = False
     for i, arg in enumerate(sys.argv):
         if arg == '-fullscreen':
             fullScreen = True
@@ -1076,8 +1083,10 @@ def loadLevel(self, level):
             name = sys.argv[i + 1]
         elif arg == '-mppass':
             mpPass = sys.argv[i + 1]
+        elif arg == '-survival':
+            survival = True
 
-    game = Minecraft(fullScreen, width=854, height=480, caption='Minecraft')
+    game = Minecraft(fullScreen, survival, width=854, height=480, caption='Minecraft')
     game.user = User(name, 0, mpPass)
     if server and port:
         game.setServer(server, int(port))

mc/net/minecraft/Minecraft.py

@@ -7,9 +7,9 @@ class SurvivalGameMode(GameMode):
 
     def __init__(self, minecraft):
         super().__init__(minecraft)
-        self.__x = 0
-        self.__y = 0
-        self.__z = 0
+        self.__x = -1
+        self.__y = -1
+        self.__z = -1
         self.__oDestroyProgress = 0
         self.__destroyProgress = 0
         self.__delay = 0

mc/net/minecraft/gamemode/SurvivalGameMode.py

@@ -1,30 +1,55 @@
 from mc.net.minecraft.gui.Screen import Screen
 from mc.net.minecraft.gui.Button import Button
 
+try:
+    import wx
+except:
+    import tkinter as tk
+    from tkinter.filedialog import askopenfilename, asksaveasfilename
+
+import gzip
+
 class LoadLevelScreen(Screen):
 
     def __init__(self, screen):
-        self.__parent = screen
+        self._parent = screen
         self.__finished = False
         self.__loaded = False
         self.__levels = []
         self.__status = ''
         self._title = 'Load level'
-        self.__unused = False
+        self.fileLoaded = False
+        self._isSaveScreen = False
+        self._levelFile = ''
 
     def run(self):
-        """
-        This is left incomplete as the original code relies on minecraft.net/listmaps.jsp
-        which no longer exists.
-        """
+        try:
+            title = 'Save mine file' if self._isSaveScreen else 'Open mine file'
+            style = wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT if self._isSaveScreen else wx.FD_OPEN | wx.FD_FILE_MUST_EXIST
+            app = wx.App(False)
+            with wx.FileDialog(None, title, wildcard='MINE files (*.mine)|*.mine',
+                               style=style) as fileDialog:
+                if fileDialog.ShowModal() == wx.ID_CANCEL:
+                    return
 
-        self.__status = 'Failed to load levels'
-        self.__finished = True
+                self._levelFile = fileDialog.GetPath()
+            wx.GetApp().ExitMainLoop()
+            print(self._levelFile)
+        except NameError:
+            root = tk.Tk()
+            root.withdraw()
+            try:
+                fileChooser = asksaveasfilename if self._isSaveScreen else askopenfilename
+                self._levelFile = fileChooser(filetypes=[('Minecraft levels', '*.mine')])
+            finally:
+                root.quit()
+
+        self.fileLoaded = False
 
-    def _setLevels(self, strings):
+    def _setLevels(self, levels):
         for i in range(5):
-            self._buttons[i].enabled = strings[i] != '-'
-            self._buttons[i].msg = strings[i]
+            self._buttons[i].enabled = levels[i] != '-'
+            self._buttons[i].msg = levels[i]
             self._buttons[i].visible = True
 
     def init(self, minecraft, width, height):
@@ -33,20 +58,32 @@ def init(self, minecraft, width, height):
         for i in range(5):
             self._buttons.append(Button(i, self._width // 2 - 100, self._height // 6 + i * 24, '---'))
             self._buttons[i].visible = False
+            self._buttons[i].enabled = False
 
         self._buttons.append(Button(5, self._width // 2 - 100, self._height // 6 + 120 + 12, 'Load file...'))
         self._buttons.append(Button(6, self._width // 2 - 100, self._height // 6 + 168, 'Cancel'))
-        self._buttons[5].visible = False
 
-        self.run()
+        self.__status = 'Failed to load levels'
+        self.__finished = True
 
     def _buttonClicked(self, button):
-        if button.enabled:
-            if self.__loaded and button.id < 5:
-                self._loadLevel(button.id)
+        if self.fileLoaded or not button.enabled:
+            return
+
+        if self.__loaded and button.id < 5:
+            self._loadLevel(button.id)
+        elif self.__finished or self.__loaded and button.id == 5:
+            self.fileLoaded = True
+            self.run()
+        elif self.__finished or self.__loaded and button.id == 6:
+            self._minecraft.setScreen(self._parent)
+
+    def _loadFile(self, fileName):
+        level = self._minecraft.levelIo.load(gzip.open(fileName, 'rb'))
+        if level:
+            self._minecraft.loadLevel(level)
 
-            if self.__finished or self.__loaded and button.id == 6:
-                self._minecraft.setScreen(self.__parent)
+        self._minecraft.setScreen(self._parent)
 
     def _loadLevel(self, id_):
         self._minecraft.loadLevel(self._minecraft.user.name, id_)
@@ -55,8 +92,15 @@ def _loadLevel(self, id_):
 
     def render(self, xm, ym):
         self._fillGradient(0, 0, self._width, self._height, 1610941696, -1607454624)
-        self.drawCenteredString(self._font, self._title, self._width / 2, 20, 0xFFFFFF)
-        if not self.__loaded:
+        self.drawCenteredString(self._font, self._title, self._width // 2, 20, 0xFFFFFF)
+        if self.fileLoaded:
+            self.drawCenteredString(self._font, 'Selecting file..', self._width // 2, self._height // 2 - 4, 0xFFFFFF)
+        elif not self.__loaded:
             self.drawCenteredString(self._font, self.__status, self._width // 2, self._height // 2 - 4, 0xFFFFFF)
+            super().render(xm, ym)
 
-        super().render(xm, ym)
+    def tick(self):
+        super().tick()
+        if self._levelFile:
+            self._loadFile(self._levelFile)
+            self._levelFile = ''