Merge branch 'main' of https://gitea.sffempire.ru/Kolyah35/minecraft-pe-0.6.1

Reviewed-on: https://192.168.0.2:3000/Kolyah35/minecraft-pe-0.6.1/pulls/10

.github/actions/setup-cache/action.yml

@@ -0,0 +1,27 @@
+name: Setup cache
+description: Sets up sccache, CPM cache, etc.
+
+inputs:
+  host:
+    description: 'Host platform: win or linux'
+    required: true
+  target:
+    description: 'Target platform: win, linux'
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+  - name: Setup sccache
+    uses: hendrikmuhs/ccache-action@v1.2.13
+    with:
+      variant: sccache
+      key: ${{ inputs.target }}-v1
+
+  - name: Setup CPM Cache
+    uses: actions/cache@v4
+    with:
+      path: cpm-cache
+      key: cpm-${{ inputs.target }}-v1-${{ hashFiles('**/CMakeLists.txt', '**/*.cmake') }}
+      restore-keys: |
+        cpm-${{ inputs.target }}-v1-

.github/actions/setup-ninja/action.yml

@@ -0,0 +1,17 @@
+name: Setup Ninja
+description: Sets up Ninja
+
+inputs:
+  host:
+    description: 'Host platform: win, mac or linux'
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+  - name: Setup
+    shell: bash
+    run: |
+      curl -L https://github.com/ninja-build/ninja/releases/latest/download/ninja-${{ inputs.host }}.zip -o ninja.zip
+      7z x ninja.zip -o"$GITHUB_WORKSPACE/ninja"
+      echo "$GITHUB_WORKSPACE/ninja" >> $GITHUB_PATH

.github/workflows/android.yml

@@ -1,36 +0,0 @@
-name: Android Build
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-
-jobs:
-  build:
-    runs-on: windows-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Download Android NDK r14b
-        shell: powershell
-        run: |
-          Invoke-WebRequest `
-            -Uri "http://dl.google.com/android/repository/android-ndk-r14b-windows-x86_64.zip" `
-            -OutFile "ndk.zip"
-
-      - name: Extract NDK
-        shell: powershell
-        run: |
-          Expand-Archive ndk.zip C:\
-
-      - name: Verify NDK path
-        shell: powershell
-        run: |
-          Test-Path "C:\android-ndk-r14b"
-
-      - name: Run build script
-        shell: powershell
-        run: |
-          ./build.ps1

.github/workflows/build.yml

@@ -0,0 +1,280 @@
+name: Build Game
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+    - '**'              # every branch
+    - '!no-build-**'    # unless marked as no-build
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+  CPM_SOURCE_CACHE: ${{ github.workspace }}/cpm-cache
+
+permissions:
+  contents: write
+
+jobs:
+  build-windows:
+    name: Windows Build
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup caches
+        uses: ./.github/actions/setup-cache
+        with:
+          host: linux
+          target: win
+      
+      - name: Setup Ninja
+        uses: ./.github/actions/setup-ninja
+        with:
+          host: linux
+
+      - name: Download llvm-mingw
+        run: |
+          curl -L https://github.com/mstorsjo/llvm-mingw/releases/download/20260311/llvm-mingw-20260311-msvcrt-ubuntu-22.04-x86_64.tar.xz -o llvm-mingw.tar.xz
+          tar -xf llvm-mingw.tar.xz
+          mv llvm-mingw-* llvm-mingw
+    
+      - name: Create Build Environment
+        # Some projects don't allow in-source building, so create a separate build directory
+        # We'll use this as our working directory for all subsequent commands
+        run: cmake -E make_directory ${{github.workspace}}/build
+
+      - name: Configure CMake
+        working-directory: ${{github.workspace}}/build
+        run: |
+          cmake $GITHUB_WORKSPACE \
+            -G Ninja \
+            -DCMAKE_SYSTEM_NAME=Windows \
+            -DCMAKE_C_COMPILER=$GITHUB_WORKSPACE/llvm-mingw/bin/x86_64-w64-mingw32-clang \
+            -DCMAKE_CXX_COMPILER=$GITHUB_WORKSPACE/llvm-mingw/bin/x86_64-w64-mingw32-clang++ \
+            -DCMAKE_RC_COMPILER=$GITHUB_WORKSPACE/llvm-mingw/bin/x86_64-w64-mingw32-windres \
+            -DALSOFT_BACKEND_PIPEWIRE=OFF \
+            -DCMAKE_BUILD_TYPE=$BUILD_TYPE
+
+      - name: Build
+        working-directory: ${{github.workspace}}/build
+        run: cmake --build . --config $BUILD_TYPE --target MinecraftPE --parallel
+      
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: mcpe-windows
+          path: |
+            ${{github.workspace}}/build/MinecraftPE.exe
+            ${{github.workspace}}/build/glfw3.dll
+            ${{github.workspace}}/build/libpng16.dll
+            ${{github.workspace}}/build/OpenAL32.dll
+            ${{github.workspace}}/build/z.dll
+
+  build-linux:
+    name: Linux Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup caches
+        uses: ./.github/actions/setup-cache
+        with:
+          host: linux
+          target: linux
+
+      - name: Create Build Environment
+        # Some projects don't allow in-source building, so create a separate build directory
+        # We'll use this as our working directory for all subsequent commands
+        run: cmake -E make_directory ${{github.workspace}}/build
+
+      - name: Setup Environment
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install gcc-multilib
+          sudo apt-get install -y --no-install-recommends build-essential libgl-dev libwayland-dev xorg-dev libxkbcommon-dev
+      
+      - name: Configure CMake
+        # Use a bash shell so we can use the same syntax for environment variable
+        # access regardless of the host operating system
+        shell: bash
+        working-directory: ${{github.workspace}}/build
+        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
+
+      - name: Build
+        working-directory: ${{github.workspace}}/build
+        shell: bash
+        run: |
+          cmake --build . --config $BUILD_TYPE --target MinecraftPE --parallel
+          cmake --build . --config $BUILD_TYPE --target MinecraftPE-server --parallel
+      
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: mcpe-linux
+          path: |
+            ${{github.workspace}}/build/MinecraftPE
+            ${{github.workspace}}/build/MinecraftPE-server
+
+  build-android: # pray to god
+    name: Build Android APK (${{ matrix.abi }})
+    runs-on: ubuntu-latest
+
+    strategy:
+      # keep going with the other ABI if one fails so you at least get something useful
+      fail-fast: false
+      matrix:
+        abi: [ arm64-v8a, armeabi-v7a ]
+
+    env:
+      ANDROID_SDK_ROOT: ${{ github.workspace }}/android-sdk
+      ANDROID_NDK_PATH: ${{ github.workspace }}/android-ndk-r14b
+      ANDROID_PLATFORM_API: 36
+      ANDROID_BUILD_TOOLS_VERSION: 36.0.0
+      ADB: /bin/true
+      # build.sh reads MATRIX_ABI to decide which ABI to build when no --abi flag is passed
+      MATRIX_ABI: ${{ matrix.abi }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Cache Android command-line tools
+        id: cache-android-tools
+        uses: actions/cache@v3
+        with:
+          path: ${{ env.ANDROID_SDK_ROOT }}
+          key: android-cmdline-tools-v36
+
+      - name: Setup Android command line tools
+        if: steps.cache-android-tools.outputs.cache-hit != 'true'
+        run: |
+          if [ ! -d "$ANDROID_SDK_ROOT/cmdline-tools/latest" ]; then
+            mkdir -p "$ANDROID_SDK_ROOT/cmdline-tools"
+            curl -o cmdline-tools.zip -L "https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip"
+            unzip -q cmdline-tools.zip -d "$ANDROID_SDK_ROOT/cmdline-tools"
+            mv "$ANDROID_SDK_ROOT/cmdline-tools/cmdline-tools" "$ANDROID_SDK_ROOT/cmdline-tools/latest"
+          fi
+          yes | "$ANDROID_SDK_ROOT/cmdline-tools/latest/bin/sdkmanager" --sdk_root="$ANDROID_SDK_ROOT" "platform-tools" "platforms;android-${ANDROID_PLATFORM_API}" "build-tools;${ANDROID_BUILD_TOOLS_VERSION}"
+
+
+      - name: Cache Android NDK r14b
+        id: cache-android-ndk
+        uses: actions/cache@v3
+        with:
+          path: ${{ github.workspace }}/android-ndk-r14b
+          key: android-ndk-r14b
+
+      - name: Install Android NDK r14b
+        if: steps.cache-android-ndk.outputs.cache-hit != 'true'
+        run: |
+          if [ ! -d "$ANDROID_NDK_PATH" ]; then
+            curl -L -o ndk.zip "https://dl.google.com/android/repository/android-ndk-r14b-linux-x86_64.zip"
+            unzip -q ndk.zip -d "$GITHUB_WORKSPACE"
+          fi
+
+      - name: Install system prerequisites
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y --no-install-recommends wget unzip curl git python3 libncurses6 libtinfo6
+          if ! ldconfig -p | grep -q "libncurses.so.5"; then
+            sudo ln -sf /lib/x86_64-linux-gnu/libncurses.so.6 /usr/lib/x86_64-linux-gnu/libncurses.so.5 || true
+          fi
+          if ! ldconfig -p | grep -q "libtinfo.so.5"; then
+            sudo ln -sf /lib/x86_64-linux-gnu/libtinfo.so.6 /usr/lib/x86_64-linux-gnu/libtinfo.so.5 || true
+          fi
+
+      - name: Setup Java 25
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 25
+
+      - name: Validate environment
+        run: |
+          echo "ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT"
+          echo "ANDROID_NDK_PATH=$ANDROID_NDK_PATH"
+          echo "JAVA_HOME=$JAVA_HOME"
+          echo "MATRIX_ABI=$MATRIX_ABI"
+          $ANDROID_SDK_ROOT/platform-tools/adb version || true
+          java -version
+          javac -version
+
+      - name: Run Android build script
+        run: |
+          chmod +x ./build.sh
+          ./build.sh
+
+      - name: Upload APK
+        uses: actions/upload-artifact@v4
+        with:
+          # artifact name is ABI-specific so both matrix legs can upload without clobbering each other
+          name: minecraftpe-apk-${{ matrix.abi }}
+          path: ${{ github.workspace }}/build-apk/minecraftpe-*-debug.apk
+
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    needs: [ build-windows, build-linux, build-android ]
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Declare Version Variables
+        id: ref
+        run: |
+          echo "version=$(cat VERSION | xargs)" >> $GITHUB_OUTPUT
+          echo "hash=$(git rev-parse --short "$GITHUB_SHA")" >> $GITHUB_OUTPUT
+
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+
+      - name: Zip Windows Artifacts
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: data mcpe-windows/MinecraftPE.exe mcpe-windows/glfw3.dll mcpe-windows/libpng16.dll mcpe-windows/OpenAL32.dll mcpe-windows/z.dll
+          dest: minecraftpe-${{ steps.ref.outputs.hash }}-windows.zip
+
+      - name: Zip Linux Artifacts
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: data mcpe-linux/MinecraftPE
+          dest: minecraftpe-${{ steps.ref.outputs.hash }}-linux.zip
+
+      - name: Zip Linux Server Artifacts
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: mcpe-linux/MinecraftPE-server
+          dest: minecraftpe-server-${{ steps.ref.outputs.hash }}.zip
+
+      - name: Zip Android arm64-v8a Artifact
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: minecraftpe-apk-arm64-v8a/minecraftpe-v8a-debug.apk
+          dest: minecraftpe-${{ steps.ref.outputs.hash }}-android-arm64-v8a.zip
+
+      - name: Zip Android armeabi-v7a Artifact
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: minecraftpe-apk-armeabi-v7a/minecraftpe-v7a-debug.apk
+          dest: minecraftpe-${{ steps.ref.outputs.hash }}-android-armeabi-v7a.zip
+
+      - name: Update Development Release
+        uses: andelf/nightly-release@main
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: dev
+          name: 'Development Release'
+          body: |
+            MinecraftPE development release for commit ${{ github.sha }}.
+          files: |
+            ./minecraftpe-${{ steps.ref.outputs.hash }}-windows.zip
+            ./minecraftpe-${{ steps.ref.outputs.hash }}-linux.zip
+            ./minecraftpe-server-${{ steps.ref.outputs.hash }}.zip
+            ./minecraftpe-${{ steps.ref.outputs.hash }}-android-arm64-v8a.zip
+            ./minecraftpe-${{ steps.ref.outputs.hash }}-android-armeabi-v7a.zip

.github/workflows/cmake-multiplatform.yml

@@ -1,75 +0,0 @@
-name: CMake multiplatform
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-  
-permissions:
-  contents: write
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-        build_type: [Release]
-        include:
-          - os: windows-latest
-            c_compiler: clang
-            cpp_compiler: clang++
-          - os: ubuntu-latest
-            c_compiler: clang
-            cpp_compiler: clang++
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set reusable strings
-      # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file.
-      id: strings
-      shell: bash
-      run: |
-        echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
-
-    - name: Setup Environment
-      if: ${{ matrix.os == 'ubuntu-latest' }}
-      run: |
-        sudo apt-get update -qq
-        sudo apt-get install gcc-multilib
-        sudo apt-get install -y --no-install-recommends build-essential libgl-dev libwayland-dev xorg-dev libxkbcommon-dev
-    
-    - name: Configure CMake
-      run: >
-        cmake -B ${{ steps.strings.outputs.build-output-dir }}
-        -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
-        -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
-        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-        -S ${{ github.workspace }}
-
-    - name: Build
-      run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
-      
-    - name: Install
-      run: cmake --install ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
-
-    - name: Pack
-      run: |
-        cd ${{ steps.strings.outputs.build-output-dir }}
-        cpack -C ${{ matrix.build_type }}
-
-    - name: Create or Update Development Release
-      uses: softprops/action-gh-release@v1
-      with:
-        name: Development Build
-        tag_name: dev
-        body: |
-          ${{ github.event.head_commit.timestamp }}
-        draft: false
-        prerelease: true
-        generate_release_notes: false
-        files: 'build/package/*.zip'
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -3,13 +3,12 @@ build/
 out/
 bin/
 lib/
+build-apk/
 cmake-build-*/
 CMakeFiles/
 CMakeCache.txt
 cmake_install.cmake
 Makefile
-*.cmake
-!cmake/CPM.cmake
 
 # Compiled object files
 *.o

CMakeLists.txt

@@ -6,53 +6,102 @@ include(cmake/CPM.cmake)
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_POLICY_VERSION_MINIMUM 3.10)
+
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     set(CMAKE_CXX_FLAGS "-Wno-c++11-narrowing -Wno-narrowing -Wno-invalid-source-encoding -Wno-reserved-user-defined-literal")
 endif()
 
-find_package(Threads REQUIRED)
+include(cmake/EnumOption.cmake)
 
-find_package(OpenSSL)
+if(EMSCRIPTEN)
-if (OpenSSL_FOUND)
+    # When configuring web builds with "emcmake cmake -B build -S .", set PLATFORM to Web by default
-    message(STATUS "found openssl ${OPENSSL_VERSION}")
+    set(PLATFORM Web CACHE STRING "Platform to build for.")
 endif()
 
-CPMAddPackage("gh:madler/zlib@1.3.2")
+enum_option(PLATFORM "Desktop;Web" "Platform to build for.")
-CPMAddPackage(
+
-    NAME "libpng"
+find_package(Threads REQUIRED)
-    GIT_REPOSITORY "https://github.com/pnggroup/libpng.git"
+find_package(OpenSSL)
-    GIT_TAG "v1.6.55"
+
-    EXCLUDE_FROM_ALL TRUE
+if (${PLATFORM} STREQUAL "Desktop")
-    OPTIONS
+    set(PLATFORM_CPP "PLATFORM_DESKTOP")
-        "ZLIB_ROOT ${zlib_SOURCE_DIR}"
+
-        "ZLIB_INCLUDE_DIRS ${zlib_SOURCE_DIR}"
+    if (WIN32)
-        "PNG_TOOLS OFF"
+        add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-        "PNG_TESTS OFF"
+        include_directories(misc/windows)
-        "BUILD_SHARED_LIBS ON"
+        set(EXTRA_LIBS ws2_32 winhttp)
-)
+    elseif(UNIX)
+        find_library(pthread NAMES pthread)
+        set(EXTRA_LIBS pthread m)
+    endif()
+
+elseif (${PLATFORM} STREQUAL "Web")
+    set(PLATFORM_CPP "PLATFORM_WEB")
+    set(EXTRA_LIBS "idbfs.js")
+endif()
+
+# I totally shocked
+if(${PLATFORM} MATCHES "Web")
+    set(PNG_LIB png)
+    set(AL_LIBTYPE "STATIC")
+
+    add_library(zlib INTERFACE IMPORTED)
+    set_target_properties(zlib PROPERTIES
+        INTERFACE_LINK_OPTIONS "-sUSE_ZLIB=1"
+    )
+
+    add_library(png INTERFACE IMPORTED)
+    set_target_properties(png PROPERTIES
+        INTERFACE_LINK_OPTIONS "-sUSE_LIBPNG=1"
+    )
+
+    add_library(glfw INTERFACE IMPORTED)
+    set_target_properties(glfw PROPERTIES
+        INTERFACE_LINK_OPTIONS "-sUSE_GLFW=3"
+    )
+else()
+    set(PNG_LIB png_shared)
+    set(AL_LIBTYPE "SHARED")
+
+    CPMAddPackage(
+        NAME "zlib"
+        GIT_REPOSITORY "https://github.com/madler/zlib"
+        GIT_TAG "v1.3.2"
+    )
+
+    CPMAddPackage(
+        NAME "libpng"
+        GIT_REPOSITORY "https://github.com/pnggroup/libpng.git"
+        GIT_TAG "v1.6.55"
+        OPTIONS
+            "ZLIB_ROOT ${zlib_SOURCE_DIR}"
+            "ZLIB_INCLUDE_DIRS ${zlib_SOURCE_DIR}"
+            "PNG_TOOLS OFF"
+            "PNG_TESTS OFF"
+    )
+
+    CPMAddPackage(
+        NAME "glfw"
+        GIT_REPOSITORY "https://github.com/glfw/glfw.git"
+        GIT_TAG "3.4"
+        EXCLUDE_FROM_ALL TRUE
+        OPTIONS
+            "GLFW_BUILD_EXAMPLES OFF"
+            "GLFW_BUILD_TESTS OFF"
+            "GLFW_BUILD_DOCS OFF"
+    )
+endif()
 
 CPMAddPackage(
     NAME "openal"
     GIT_REPOSITORY "https://github.com/kcat/openal-soft.git"
     GIT_TAG "1.25.1"
-    EXCLUDE_FROM_ALL TRUE
     OPTIONS
         "ALSOFT_EXAMPLES OFF"
         "ALSOFT_TESTS OFF"
         "ALSOFT_UTILS OFF"
-        "BUILD_SHARED_LIBS ON"
+        "LIBTYPE ${AL_LIBTYPE}"
-)
+        "ALSOFT_ENABLE_MODULES OFF"
-
-CPMAddPackage(
-    NAME "glfw"
-    GIT_REPOSITORY "https://github.com/glfw/glfw.git"
-    GIT_TAG "3.4"
-    EXCLUDE_FROM_ALL TRUE
-    OPTIONS
-        "GLFW_BUILD_EXAMPLES OFF"
-        "GLFW_BUILD_TESTS OFF"
-        "GLFW_BUILD_DOCS OFF"
-        "BUILD_SHARED_LIBS ON"
 )
 
 # TODO: Clear this paths with *
@@ -234,50 +283,32 @@ file(GLOB CLIENT_SOURCES
     "src/SharedConstants.cpp"
     "src/main.cpp"
     "src/NinecraftApp.cpp"
+
+    "src/AppPlatform_glfw.cpp"
+    "src/main.cpp"
 )
 
-if(NOT DEFINED PLATFORM)
+if (${PLATFORM} STREQUAL "Desktop")
-    set(PLATFORM "PLATFORM_GLFW")
+    list(APPEND CLIENT_SOURCES glad/src/glad.c)
-endif()
-
-
-if(PLATFORM STREQUAL "PLATFORM_WIN32")
-    list(APPEND CLIENT_SOURCES "src/AppPlatform_win32.cpp")
-endif()
-
-if(PLATFORM STREQUAL "PLATFORM_GLFW")
-    list(APPEND CLIENT_SOURCES "src/AppPlatform_glfw.cpp")
 endif()
 
 # Server
 if(UNIX)
-add_executable("${PROJECT_NAME}-server" ${SERVER_SOURCES})
+    add_executable("${PROJECT_NAME}-server" ${SERVER_SOURCES})
 
-target_compile_definitions("${PROJECT_NAME}-server" PUBLIC "STANDALONE_SERVER" "SERVER_PROFILER")
+    target_compile_definitions("${PROJECT_NAME}-server" PUBLIC "STANDALONE_SERVER" "SERVER_PROFILER")
 
-target_include_directories("${PROJECT_NAME}-server" PUBLIC 
+    target_include_directories("${PROJECT_NAME}-server" PUBLIC 
-   "${CMAKE_SOURCE_DIR}/src/"
+        "${CMAKE_SOURCE_DIR}/src/"
-   "project/lib_projects/raknet/jni/RaknetSources"
+        "project/lib_projects/raknet/jni/RaknetSources"
-)
+    )
 
-target_link_libraries("${PROJECT_NAME}-server" ${CMAKE_THREAD_LIBS_INIT} png_shared)
+    target_link_libraries("${PROJECT_NAME}-server" ${CMAKE_THREAD_LIBS_INIT})
-endif()
-
-add_executable(${PROJECT_NAME} 
-    ${CLIENT_SOURCES}
-    "glad/src/glad.c"
-)
-
-if(WIN32)
-    set(EXTRA_LIBS "ws2_32")
-    target_compile_definitions(${PROJECT_NAME} PUBLIC "_CRT_SECURE_NO_WARNINGS")
-endif()
-
-if(PLATFORM STREQUAL "PLATFORM_WIN32" OR PLATFORM STREQUAL "PLATFORM_GLFW")
-    target_compile_definitions(${PROJECT_NAME} PUBLIC "PLATFORM_DESKTOP")
 endif()
 
+add_executable(${PROJECT_NAME} ${CLIENT_SOURCES})
 
+target_compile_definitions(${PROJECT_NAME} PUBLIC ${PLATFORM_CPP})
 
 target_include_directories(${PROJECT_NAME} PUBLIC 
     "${CMAKE_SOURCE_DIR}/glad/include/"
@@ -287,9 +318,52 @@ target_include_directories(${PROJECT_NAME} PUBLIC
     "lib/include"
 )
 
+if(${PLATFORM} MATCHES "Web")
+    set(CMAKE_CXX_STANDARD 11)
+    # uuuh i hate it
+    set(EM_FLAGS "-pthread -sUSE_PTHREADS=1 -sSHARED_MEMORY=1")
+    
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EM_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EM_FLAGS}")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${EM_FLAGS} --preload-file ${CMAKE_SOURCE_DIR}/data@/data -sPROXY_TO_PTHREAD")
+
+    target_compile_options(${PROJECT_NAME} PUBLIC
+        "-Os"
+        "-Wno-invalid-source-encoding"
+        "-Wno-narrowing"
+        "-Wno-deprecated-register"
+        "-Wno-reserved-user-defined-literal"
+    )
+
+    target_link_options(${PROJECT_NAME} PUBLIC
+        "-Os"
+        "-sALLOW_MEMORY_GROWTH=1"
+        "-sFORCE_FILESYSTEM=1"
+        "-sLEGACY_GL_EMULATION=1"
+        "-sGL_UNSAFE_OPTS=0"
+        "-sEMULATE_FUNCTION_POINTER_CASTS=1"
+        "-sALLOW_TABLE_GROWTH=1"
+        "-sEXPORTED_RUNTIME_METHODS=['FS','stringToUTF8','UTF8ToString','cwrap','ccall','HEAP8','HEAPU8','HEAP32','HEAPU32']"
+        "-sEXPORTED_FUNCTIONS=['_main']"
+    )
+
+    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+        message("DEBUG MODE")
+
+        target_link_options(${PROJECT_NAME} PUBLIC
+            "-sASSERTIONS=2"
+            "-sSTACK_OVERFLOW_CHECK=2"
+            "-sSTACK_SIZE=5242880"
+            "-sGL_DEBUG=1"
+        )
+    endif()
+
+    target_compile_definitions(${PROJECT_NAME} PUBLIC "__EMSCRIPTEN__" "NO_SOUND" "NO_NETWORK")
+endif()
+
 # Client
 target_compile_definitions(${PROJECT_NAME} PUBLIC "OPENGL_ES" "NO_EGL" ${PLATFORM})
-target_link_libraries(${PROJECT_NAME} zlib png_shared alsoft.common OpenAL::OpenAL glfw ${EXTRA_LIBS})
+target_link_libraries(${PROJECT_NAME} zlib ${PNG_LIB} OpenAL::OpenAL glfw ${EXTRA_LIBS})
 
 if (OpenSSL_FOUND)
     target_link_libraries(${PROJECT_NAME} OpenSSL::SSL OpenSSL::Crypto)
@@ -297,72 +371,27 @@ if (OpenSSL_FOUND)
 endif()
 
 if (NOT UNIX)
-add_custom_command(
+    add_custom_command(
-    TARGET ${PROJECT_NAME} 
+        TARGET ${PROJECT_NAME} 
-    POST_BUILD
+        POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:${PROJECT_NAME}> $<TARGET_FILE_DIR:${PROJECT_NAME}> 
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:${PROJECT_NAME}> $<TARGET_FILE_DIR:${PROJECT_NAME}> 
-        COMMAND_EXPAND_LISTS
+            COMMAND_EXPAND_LISTS
-)
+    )
 endif()
 
-add_custom_command(
+if(NOT ${PLATFORM} MATCHES "Web")
-    TARGET ${PROJECT_NAME} 
+    add_custom_command(
-    POST_BUILD
+        TARGET ${PROJECT_NAME} 
-        COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_SOURCE_DIR}/data" $<TARGET_FILE_DIR:${PROJECT_NAME}>/data
+        POST_BUILD
-)
+            COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_SOURCE_DIR}/data" $<TARGET_FILE_DIR:${PROJECT_NAME}>/data
-
+    )
-# Installing and packing
+else()
-
+    add_custom_command(
-find_package(Git REQUIRED)
+        TARGET ${PROJECT_NAME} 
-
+        POST_BUILD
-execute_process(
+            COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/misc/web/index.html" $<TARGET_FILE_DIR:${PROJECT_NAME}>
-    COMMAND ${GIT_EXECUTABLE} log -1 --format=%h
+    )
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_SHORTSHA
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-string(TOLOWER ${CMAKE_SYSTEM_NAME} SYSTEM_NAME)
-set(CPACK_PACKAGE_NAME "MCPE-0.6.1-for-all")
-set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${SYSTEM_NAME})
-set(CPACK_PACKAGE_VENDOR "MCPE-0.6.1-for-all")
-set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
-set(CPACK_PACKAGE_DIRECTORY "${CMAKE_BINARY_DIR}/package")
-set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install")
-set(CPACK_GENERATOR "ZIP")
-
-set(GIT_REPO "https://gitea.sffempire.ru/Kolyah35/minecraft-pe-0.6.1")
-
-install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION .)
-
-if(NOT UNIX)
-install(FILES
-        $<TARGET_RUNTIME_DLLS:${PROJECT_NAME}>
-        DESTINATION .
-)
 endif()
 
-install(DIRECTORY "${CMAKE_SOURCE_DIR}/data" DESTINATION .)
+message(STATUS "Compiling with the flags:")
-
+message(STATUS "  PLATFORM=" ${PLATFORM_CPP})
-string(TIMESTAMP CURRENT_DATE "%Y-%m-%d")
-string(TIMESTAMP CURRENT_TIME "%H:%M:%S")
-
-set(VERSION_STR "${PROJECT_VERSION}")
-
-if(CMAKE_BUILD_TYPE STREQUAL "Debug") 
-    set(VERSION_STR "${VERSION_STR} - Development Build")
-endif()
-
-file(WRITE "${CMAKE_BINARY_DIR}/version.txt"
-"Minecraft PE 0.6.1
-
-Autogenerated file by cmake-${CMAKE_VERSION}
-Report issues ${GIT_REPO}/issues
-
-Build date: ${CURRENT_DATE} ${CURRENT_TIME}
-Build configuration: ${CMAKE_BUILD_TYPE}
-Git commit: ${GIT_SHORTSHA}
-Platform: ${CMAKE_SYSTEM_NAME}")
-
-install(FILES "${CMAKE_BINARY_DIR}/version.txt" DESTINATION .) 
-
-include(CPack)

README.md

@@ -17,9 +17,9 @@ This project aims to preserve and improve this early version of Minecraft PE.
     - [ ] Screen fixes
 - [ ] Rewrite platform logic
 - [x] Fix sound
-- [ ] Do a server connection GUI
+- [x] Do a server connection GUI
 - [ ] Controller support
-- [ ] Minecraft server hosting
+- [x] Minecraft server hosting
 - [x] Screen fixess
 - [x] Fix fog
 - [x] Add sprinting
@@ -70,7 +70,7 @@ cmake --build .
 4. Press **Run** (or F5) to build and launch the game.
 
 ## Android
-
+### Windows
 1. Download **Android NDK r14b**:  
    http://dl.google.com/android/repository/android-ndk-r14b-windows-x86_64.zip
 
@@ -95,3 +95,106 @@ cmake --build .
 # Only repackage + install (no compilation)
 .\build.ps1 -NoBuild
 ```
+
+### Linux
+1. Download **Command line tools**:  
+   https://developer.android.com/studio#command-line-tools-only
+
+2. Unzip it into a folder, e.g.:
+
+   ```bash
+   mkdir -p "$HOME/Android/Sdk/"
+   unzip commandlinetools-linux-*.zip -d "$HOME/Android/Sdk/"
+   ```
+
+3. Your structure should look like
+
+   ```bash
+   $HOME/Android/Sdk/cmdline-tools/bin/sdkmanager
+   ```
+
+   > [!Note] 
+   > `sdkmanager` expects the SDK to include a `cmdline-tools/latest/` folder.
+   > If you only have `cmdline-tools/bin`, create the required layout:
+   >
+   > ```bash
+   > mkdir -p "$HOME/Android/Sdk/cmdline-tools/latest"
+   > ln -snf ../bin  "$HOME/Android/Sdk/cmdline-tools/latest/bin"
+   > ln -snf ../lib  "$HOME/Android/Sdk/cmdline-tools/latest/lib"
+   > ln -snf ../source.properties "$HOME/Android/Sdk/cmdline-tools/latest/source.properties"
+   > ln -snf ../NOTICE.txt        "$HOME/Android/Sdk/cmdline-tools/latest/NOTICE.txt"
+   > ```
+
+4. Install the build tools (and platform) using `sdkmanager`
+   
+   ```bash
+   export ANDROID_SDK_ROOT="$HOME/Android/Sdk"
+   export PATH="$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$PATH"
+
+   sdkmanager --install "platform-tools" "platforms;android-35" "build-tools;35.0.0"
+   ```
+
+   > [!Note]
+   > if you want build.sh to always find the SDK,
+   > Set ANDROID_SDK_ROOT in your shell config (~/.bashrc / ~/.profile / ~/.config/fish/config.fish), for example:
+   >
+   > ```bash
+   > export ANDROID_SDK_ROOT="$HOME/Android/Sdk"
+   > ```
+   >
+   > Then restart your shell (or `source` the file)
+
+5. Verify the install
+
+   ```bash
+   ls "$ANDROID_SDK_ROOT/build-tools"
+   ```
+
+   You should see a version folder like:
+
+   ```bash
+   35.0.0
+   33.0.2
+   ```
+
+6. Download **Android NDK r14b**:  
+   https://dl.google.com/android/repository/android-ndk-r14b-linux-x86_64.zip
+
+7. Extract the archive to `/home/username/`, so that the final directory path is `/home/username/android-ndk-r14b/` 
+   
+   > [!Warning]
+   > Make sure you don’t end up with a nested folder like `/home/username/android-ndk-r14b/android-ndk-r14b/`.
+
+8. Re run `build.sh`
+
+## Web
+1. Download and install **emsdk**: https://emscripten.org/docs/getting_started/downloads.html
+   > [!Note]
+   > On arch linux you can use AUR:
+   > `yay -Sy emsdk`
+   
+2. Configure and build project:
+   ```
+   mkdir build && cd build
+   cmake .. -B . -G Ninja "-DCMAKE_TOOLCHAIN_FILE=$EMSDK/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
+   cmake --build . --target MinecraftPE
+   ```
+   > [!Note]
+   > If you are using VSCode with CMake plugin, you can add Emscripten kit
+   > 1. Press Ctrl + Shift + P
+   > 2. Type `CMake: Edit User-Local CMake Kits` and hit Enter
+   > 3. Add this:
+      ```json
+      {
+         "name": "Emscripten",
+         "compilers": {
+            "C": "/usr/lib/emsdk/upstream/bin/clang",
+            "CXX": "/usr/lib/emsdk/upstream/bin/clang++"
+         },
+         "toolchainFile": "/usr/lib/emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
+      }
+      ```
+3. Run game:
+   ```
+   emrun --port 8080 .
+   ```

build.ps1

@@ -1,18 +1,16 @@
 # ============================================================
-#  MCPE 0.6.1 Android Build Script  —  from-scratch capable
-#  Works on a clean machine; creates all dirs, keystore and
-#  stub Java files automatically.
-#
 #  Usage:
-#    .\build.ps1          # full build (NDK + Java + APK + install)
+#    .\build.ps1              # full build (NDK + Java + APK + install)
-#    .\build.ps1 -NoCpp   # skip NDK rebuild (Java/assets changed)
+#    .\build.ps1 -NoCpp       # skip NDK rebuild (Java/assets changed)
-#    .\build.ps1 -NoJava  # skip Java recompile (C++ changed only)
+#    .\build.ps1 -NoJava      # skip Java recompile (C++ changed only)
-#    .\build.ps1 -NoBuild # repackage + install only (no recompile)
+#    .\build.ps1 -NoBuild     # repackage + install only (no recompile)
+#    .\build.ps1 -Clean       # remove build output before building
 # ============================================================
 param(
     [switch]$NoCpp,
     [switch]$NoJava,
-    [switch]$NoBuild
+    [switch]$NoBuild,
+    [switch]$Clean
 )
 
 Set-StrictMode -Version Latest
@@ -66,7 +64,13 @@ function Write-Stub([string]$rel, [string]$content) {
     if (-not (Test-Path $full)) { [System.IO.File]::WriteAllText($full, $content); Write-Host "  stub: $rel" }
 }
 
-# ── 0. Bootstrap ─────────────────────────────────────────────
+# ── 0. Clean (optional) ───────────────────────────────────────
+if ($Clean) {
+    Write-Step "Cleaning build output"
+    Remove-Item -Recurse -Force $apkbuild -ErrorAction SilentlyContinue
+}
+
+# ── 1. Bootstrap ─────────────────────────────────────────────
 Write-Step "Bootstrap"
 
 New-Dir $apkbuild
@@ -227,16 +231,16 @@ if (-not $NoCpp -and -not $NoBuild) {
     }
     Push-Location "$junctionBase/project/android/jni"
     $env:NDK_MODULE_PATH = "$junctionBase/project/lib_projects"
-    # run ndk-build and capture everything; let user see full output for debugging
+    # run ndk-build and stream output directly to the console
-    $ndkOutput = & "$ndk\ndk-build.cmd" NDK_PROJECT_PATH="$junctionBase/project/android" APP_BUILD_SCRIPT="$junctionBase/project/android/jni/Android.mk" 2>&1 | Tee-Object -Variable ndkOutput
+    $ndkCmd = Join-Path $ndk 'ndk-build.cmd'
-    # dump entire output for diagnosis
+    $ndkArgs = "NDK_PROJECT_PATH=`"$junctionBase/project/android`" APP_BUILD_SCRIPT=`"$junctionBase/project/android/jni/Android.mk`""
-    Write-Host "---- NDK BUILD OUTPUT BEGIN ----"
+
-    $ndkOutput | ForEach-Object { Write-Host $_ }
+    $proc = Start-Process -FilePath $ndkCmd -ArgumentList $ndkArgs -NoNewWindow -Wait -PassThru
-    Write-Host "---- NDK BUILD OUTPUT END ----"
-    # optionally highlight errors/warnings afterwards
-    $ndkOutput | Where-Object { $_ -match "error:|warning:|libminecraftpe|In file included" }
     Pop-Location
-    Assert-ExitCode "ndk-build"
+    if ($proc.ExitCode -ne 0) {
+        Write-Host "ndk-build failed (exit $($proc.ExitCode))" -ForegroundColor Red
+        exit 1
+    }
     Copy-Item $libSrc $libDst -Force
     Write-Host "  .so  ->  $libDst"
 }
@@ -246,7 +250,7 @@ if (-not $NoJava -and -not $NoBuild) {
     Write-Step "Java compile"
 
     New-Dir (Split-Path $rJava -Parent)
-    & "$sdkTools\aapt.exe" package -f -M $manifest -S $res -I $androidJar -J "$apkbuild\gen" -F "$apkbuild\_rgen.apk" 2>&1 | Out-Null
+    & "$sdkTools\aapt.exe" package -f -M $manifest -S $res -I $androidJar -J "$apkbuild\gen" -F "$apkbuild\_rgen.apk"
     Assert-ExitCode "aapt R.java"
     Remove-Item "$apkbuild\_rgen.apk" -ea SilentlyContinue
 
@@ -258,11 +262,9 @@ if (-not $NoJava -and -not $NoBuild) {
 
     Remove-Item $classesDir -Recurse -Force -ea SilentlyContinue
     New-Dir $classesDir
-    $eap = $ErrorActionPreference; $ErrorActionPreference = "Continue"
+
-    $errors = & javac --release 8 -cp $androidJar -d $classesDir @srcs 2>&1 |
+    & javac --release 8 -cp $androidJar -d $classesDir @srcs
-              Where-Object { $_ -match "error:" }
+    if ($LASTEXITCODE -ne 0) { Write-Host 'javac failed' -ForegroundColor Red; exit 1 }
-    $ErrorActionPreference = $eap
-    if ($errors) { Write-Host $errors -ForegroundColor Red; exit 1 }
     Write-Host "  javac OK"
 
     $classFiles = Get-ChildItem $classesDir -Recurse -Filter "*.class" | Select-Object -Exp FullName

build.sh

@@ -0,0 +1,455 @@
+#!/usr/bin/env bash
+# ============================================================
+# Usage:
+#   ./build.sh           # full build (NDK + Java + APK + install)
+#   ./build.sh --no-cpp  # skip NDK rebuild (Java/assets changed)
+#   ./build.sh --no-java # skip Java recompile (C++ changed only)
+#   ./build.sh --no-build # repackage + install only (no recompile)
+#
+# ABI targeting:
+#   ./build.sh --abi arm64-v8a    # build for arm64 only (default)
+#   ./build.sh --abi armeabi-v7a  # build for ARMv7 only
+#   ./build.sh --abi all          # build for both ABIs (fat APK)
+# ============================================================
+
+# lets be strict cuz we are safe like that
+# *thanos snap*
+set -euo pipefail
+IFS=$'\n\t'
+
+########################################
+# configuration
+########################################
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$SCRIPT_DIR"
+
+# build output directory (similar to apkbuild in the PS script)
+# maybe doing this in build.ps1 would be cleaner, than putting the apkbuild in C:
+BUILD_DIR="$REPO_ROOT/build-apk"
+
+# default Android/NDK/SDK paths (can be overridden by env vars)
+ANDROID_NDK_PATH="${ANDROID_NDK_PATH:-$HOME/android-ndk-r14b}"
+ANDROID_SDK_ROOT="${ANDROID_SDK_ROOT:-${ANDROID_HOME:-$HOME/Android/Sdk}}"
+ANDROID_BUILD_TOOLS_VERSION="${ANDROID_BUILD_TOOLS_VERSION:-}"
+ANDROID_PLATFORM_API="${ANDROID_PLATFORM_API:-}"
+
+# ABI selection: can be set via --abi flag or MATRIX_ABI env var.
+# Supported values: arm64-v8a, armeabi-v7a, all
+# MATRIX_ABI takes precedence over the default but is overridden by --abi on the CLI.
+TARGET_ABI="${MATRIX_ABI:-arm64-v8a}"
+
+function fail() {
+  echo "ERROR: $1" >&2
+  exit 1
+}
+
+function find_build_tools_dir() {
+  if [[ -n "$ANDROID_BUILD_TOOLS_VERSION" ]]; then
+    local candidate="$ANDROID_SDK_ROOT/build-tools/$ANDROID_BUILD_TOOLS_VERSION"
+    [[ -d "$candidate" ]] && echo "$candidate" && return
+  fi
+
+  if [[ ! -d "$ANDROID_SDK_ROOT/build-tools" ]]; then
+    fail "Android build-tools not found under $ANDROID_SDK_ROOT/build-tools. Set ANDROID_SDK_ROOT or install Android SDK build-tools."
+  fi
+
+  # picking the highest build tools version because its the easiest way rn
+  # i guess if it breaks then fuck you
+  local best
+  best=$(ls -1 "$ANDROID_SDK_ROOT/build-tools" | sort -V | tail -n 1)
+  [[ -n "$best" && -d "$ANDROID_SDK_ROOT/build-tools/$best" ]] || \
+    fail "No Android build-tools versions found under $ANDROID_SDK_ROOT/build-tools."
+  echo "$ANDROID_SDK_ROOT/build-tools/$best"
+}
+
+function find_android_platform_dir() {
+  if [[ -n "$ANDROID_PLATFORM_API" ]]; then
+    local candidate="$ANDROID_SDK_ROOT/platforms/android-$ANDROID_PLATFORM_API"
+    [[ -d "$candidate" ]] && echo "$candidate" && return
+  fi
+
+  if [[ ! -d "$ANDROID_SDK_ROOT/platforms" ]]; then
+    fail "Android platforms not found under $ANDROID_SDK_ROOT/platforms. Install an Android platform."
+  fi
+
+  # pick the highest api level installed for now
+  # ideally we should be able to build to any api level, but lets keep it simple for now and 
+  # just pick the highest one available
+  local best
+  best=$(ls -1 "$ANDROID_SDK_ROOT/platforms" | grep -E '^android-[0-9]+' | sed 's/android-//' | sort -n | tail -n 1)
+  [[ -n "$best" ]] || fail "No Android platforms found under $ANDROID_SDK_ROOT/platforms."
+  echo "$ANDROID_SDK_ROOT/platforms/android-$best"
+}
+
+ANDROID_BUILD_TOOLS_DIR="$(find_build_tools_dir)"
+ANDROID_PLATFORM_DIR="$(find_android_platform_dir)"
+
+KEYSTORE_FILE="$BUILD_DIR/debug.keystore"
+PACKAGE_NAME="com.mojang.minecraftpe"
+
+# android tool binaries
+AAPT="$ANDROID_BUILD_TOOLS_DIR/aapt"
+ZIPALIGN="$ANDROID_BUILD_TOOLS_DIR/zipalign"
+APKSIGNER="$ANDROID_BUILD_TOOLS_DIR/apksigner"
+DEX_TOOL="$ANDROID_BUILD_TOOLS_DIR/d8"
+ADB="${ADB:-$ANDROID_SDK_ROOT/platform-tools/adb}"
+
+# java tool binaries
+JAVA_HOME_DEFAULT="${JAVA_HOME:-}"  # may be empty
+
+# prefer javac from the jdk; 
+# on some systems /usr/lib/jvm/default points to a JRE only.
+# If javac is missing, try to locate a JDK installation.
+JAVAC_CMD=""
+if command -v javac >/dev/null 2>&1; then
+  JAVAC_CMD="$(command -v javac)"
+elif [[ -n "$JAVA_HOME_DEFAULT" && -x "$JAVA_HOME_DEFAULT/bin/javac" ]]; then
+  JAVAC_CMD="$JAVA_HOME_DEFAULT/bin/javac"
+elif [[ -x "/usr/lib/jvm/java-8-openjdk/bin/javac" ]]; then
+  JAVAC_CMD="/usr/lib/jvm/java-8-openjdk/bin/javac"
+elif [[ -x "/usr/lib/jvm/default/bin/javac" ]]; then
+  JAVAC_CMD="/usr/lib/jvm/default/bin/javac"
+fi
+
+if [[ -z "$JAVAC_CMD" ]]; then
+  fail "javac not found; install a JDK and ensure javac is on PATH"
+fi
+
+KEYTOOL=""  # will be detected later
+
+# swource directories
+JNI_DIR="$REPO_ROOT/project/android/jni"
+JAVA_SRC_DIR="$REPO_ROOT/project/android_java/src"
+ANDROID_MANIFEST="$REPO_ROOT/project/android_java/AndroidManifest.xml"
+ANDROID_RES_DIR="$REPO_ROOT/project/android_java/res"
+DATA_DIR="$REPO_ROOT/data"
+
+# output files: APK names are derived after argument parsing once TARGET_ABI is final.
+# see the "resolve APK output filenames" block below.
+APK_UNSIGNED=""
+APK_ALIGNED=""
+APK_SIGNED=""
+DEX_OUTPUT="$BUILD_DIR/classes.dex"
+
+# flags parsed from CLI args
+NO_CPP=false
+NO_JAVA=false
+NO_BUILD=false
+
+########################################
+# helpers
+########################################
+function usage() {
+  cat <<EOF
+Usage: $0 [--no-cpp] [--no-java] [--no-build] [--abi <abi>]
+
+Options:
+  --no-cpp         Skip the NDK (C++) build step
+  --no-java        Skip the Java build step
+  --no-build       Skip the compile steps; just package + install
+  --abi <abi>      Target ABI: arm64-v8a (default), armeabi-v7a, or all
+                   Can also be set via MATRIX_ABI env var for CI matrix builds.
+EOF
+  exit 1
+}
+
+function log_step() {
+  echo -e "\n==> $1"
+}
+
+function fail() {
+  echo "ERROR: $1" >&2
+  exit 1
+}
+
+function require_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    fail "$1 not found; install it (e.g. 'sudo pacman -S $1')"
+  fi
+}
+
+# ensure required tools are available early
+require_cmd zip
+require_cmd unzip
+
+function ensure_dir() {
+  mkdir -p "$1"
+}
+
+function find_keytool() {
+  # first try JAVA_HOME if set
+  if [[ -n "$JAVA_HOME_DEFAULT" && -x "$JAVA_HOME_DEFAULT/bin/keytool" ]]; then
+    echo "$JAVA_HOME_DEFAULT/bin/keytool"
+    return
+  fi
+
+  # try common install locations
+  if [[ -n "${JAVA_HOME:-}" && -x "${JAVA_HOME}/bin/keytool" ]]; then
+    echo "${JAVA_HOME}/bin/keytool"
+    return
+  fi
+
+  if command -v keytool >/dev/null 2>&1; then
+    command -v keytool
+    return
+  fi
+
+  fail "keytool not found. Set JAVA_HOME or install a JDK."
+}
+
+function write_stub_file() {
+  local rel_path="$1"
+  local content="$2"
+  local full_path="$BUILD_DIR/stubs/$rel_path"
+
+  ensure_dir "$(dirname "$full_path")"
+  if [[ ! -f "$full_path" ]]; then
+    echo -e "$content" > "$full_path"
+    echo "  stub: $rel_path"
+  fi
+}
+
+function build_ndk_abi() {
+  local abi="$1"
+
+  # armeabi-v7a needs a few extra NDK flags to get hardware FPU support
+  # without APP_ABI the default would be whatever Android.mk says, so we
+  # always pass it explicitly so the same Android.mk works for both targets
+  local -a extra_flags=( "APP_ABI=$abi" )
+  if [[ "$abi" == "armeabi-v7a" ]]; then
+    # enable hardware FPU + NEON like the old Minecraft ARMv7 builds used to
+    extra_flags+=( "APP_ARM_MODE=arm" "APP_ARM_NEON=true" )
+  fi
+
+  echo "  ndk-build for $abi..."
+  if ! "$ANDROID_NDK_PATH/ndk-build" \
+      NDK_PROJECT_PATH="$REPO_ROOT/project/android" \
+      APP_BUILD_SCRIPT="$JNI_DIR/Android.mk" \
+      "${extra_flags[@]}" \
+      2>&1 | tee "$BUILD_DIR/ndk-build-${abi}.log"; then
+    echo "NDK build failed for $abi. See $BUILD_DIR/ndk-build-${abi}.log" >&2
+    exit 1
+  fi
+
+  ensure_dir "$BUILD_DIR/lib/$abi"
+  cp -v "$REPO_ROOT/project/android/libs/$abi/libminecraftpe.so" "$BUILD_DIR/lib/$abi/"
+  echo "  .so -> $BUILD_DIR/lib/$abi/libminecraftpe.so"
+}
+
+########################################
+# argument parsing
+########################################
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --no-cpp) NO_CPP=true ;;
+    --no-java) NO_JAVA=true ;;
+    --no-build) NO_BUILD=true ;;
+    --abi)
+      shift
+      [[ $# -gt 0 ]] || fail "--abi requires a value (arm64-v8a, armeabi-v7a, all)"
+      TARGET_ABI="$1"
+      ;;
+    -h|--help) usage ;;
+    *)
+      echo "Unknown option: $1" >&2
+      usage
+      ;;
+  esac
+  shift
+done
+
+# validate the ABI value now that all args are parsed
+case "$TARGET_ABI" in
+  arm64-v8a|armeabi-v7a|all) ;;
+  *) fail "Unknown ABI '$TARGET_ABI'. Supported values: arm64-v8a, armeabi-v7a, all" ;;
+esac
+
+echo "  TARGET_ABI=$TARGET_ABI"
+
+# resolve APK output filenames now that TARGET_ABI is final.
+# arm64-v8a -> minecraftpe-v8a-debug.apk
+# armeabi-v7a -> minecraftpe-v7a-debug.apk
+# all -> minecraftpe-all-debug.apk  (fat APK containing both ABIs)
+case "$TARGET_ABI" in
+  arm64-v8a)   APK_SUFFIX="v8a" ;;
+  armeabi-v7a) APK_SUFFIX="v7a" ;;
+  *)           APK_SUFFIX="$TARGET_ABI" ;;
+esac
+APK_UNSIGNED="$BUILD_DIR/minecraftpe-${APK_SUFFIX}-unsigned.apk"
+APK_ALIGNED="$BUILD_DIR/minecraftpe-${APK_SUFFIX}-aligned.apk"
+APK_SIGNED="$BUILD_DIR/minecraftpe-${APK_SUFFIX}-debug.apk"
+
+########################################
+# validate required tools
+########################################
+KEYTOOL="$(find_keytool)"
+
+if [[ ! -x "$AAPT" ]]; then
+  fail "aapt not found at $AAPT"
+fi
+
+if [[ ! -x "$ZIPALIGN" ]]; then
+  fail "zipalign not found at $ZIPALIGN"
+fi
+
+if [[ ! -x "$APKSIGNER" ]]; then
+  fail "apksigner not found at $APKSIGNER"
+fi
+
+if [[ ! -x "$DEX_TOOL" ]]; then
+  fail "d8 not found at $DEX_TOOL"
+fi
+
+if [[ ! -x "$ADB" ]]; then
+  fail "adb not found at $ADB"
+fi
+
+########################################
+# bootstrap
+########################################
+log_step "Bootstrap"
+
+ensure_dir "$BUILD_DIR"
+ensure_dir "$BUILD_DIR/lib/arm64-v8a"
+ensure_dir "$BUILD_DIR/lib/armeabi-v7a"
+ensure_dir "$BUILD_DIR/gen"
+ensure_dir "$BUILD_DIR/stubs"
+
+# create a debug keystore if it doesn't exist
+if [[ ! -f "$KEYSTORE_FILE" ]]; then
+  echo "  generating debug.keystore..."
+  "$KEYTOOL" -genkeypair \
+    -keystore "$KEYSTORE_FILE" -storepass android -keypass android \
+    -alias androiddebugkey -keyalg RSA -keysize 2048 -validity 10000 \
+    -dname "CN=Android Debug,O=Android,C=US" >/dev/null 2>&1
+  echo "  keystore created"
+else
+  echo "  keystore OK"
+fi
+
+# why dont we just include the stubs lol
+write_stub_file "com/mojang/android/StringValue.java" "package com.mojang.android;\npublic interface StringValue { String getStringValue(); }\n"
+
+write_stub_file "com/mojang/android/licensing/LicenseCodes.java" "package com.mojang.android.licensing;\npublic class LicenseCodes { public static final int LICENSE_OK = 0; }\n"
+
+write_stub_file "com/mojang/android/EditTextAscii.java" "package com.mojang.android;\nimport android.content.Context;\nimport android.text.Editable;\nimport android.text.TextWatcher;\nimport android.util.AttributeSet;\nimport android.widget.EditText;\npublic class EditTextAscii extends EditText implements TextWatcher {\n    public EditTextAscii(Context c) { super(c); addTextChangedListener(this); }\n    public EditTextAscii(Context c, AttributeSet a) { super(c,a); addTextChangedListener(this); }\n    public EditTextAscii(Context c, AttributeSet a, int d) { super(c,a,d); addTextChangedListener(this); }\n    @Override public void onTextChanged(CharSequence s,int st,int b,int co){}\n    public void beforeTextChanged(CharSequence s,int st,int co,int aft){}\n    public void afterTextChanged(Editable e){\n        String s=e.toString(),san=sanitize(s);\n        if(!s.equals(san))e.replace(0,e.length(),san);\n    }\n    static public String sanitize(String s){\n        StringBuilder sb=new StringBuilder();\n        for(int i=0;i<s.length();i++){char c=s.charAt(i);if(c<128)sb.append(c);}\n        return sb.toString();\n    }\n}\n"
+
+write_stub_file "com/mojang/android/preferences/SliderPreference.java" "package com.mojang.android.preferences;\nimport android.content.Context;\nimport android.content.res.Resources;\nimport android.preference.DialogPreference;\nimport android.util.AttributeSet;\nimport android.view.Gravity;\nimport android.view.View;\nimport android.widget.LinearLayout;\nimport android.widget.SeekBar;\nimport android.widget.TextView;\npublic class SliderPreference extends DialogPreference implements SeekBar.OnSeekBarChangeListener {\n    private static final String NS=\"http://schemas.android.com/apk/res/android\";\n    private Context _ctx; private TextView _tv; private SeekBar _sb;\n    private String _suf; private int _def,_max,_val,_min;\n    public SliderPreference(Context ctx,AttributeSet a){\n        super(ctx,a); _ctx=ctx;\n        _suf=gStr(a,NS,\"text\",\"\"); _def=gInt(a,NS,\"defaultValue\",0);\n        _max=gInt(a,NS,\"max\",100); _min=gInt(a,null,\"min\",0);\n        setDefaultValue(_def);\n    }\n    @Override protected View onCreateDialogView(){\n        LinearLayout l=new LinearLayout(_ctx); l.setOrientation(LinearLayout.VERTICAL); l.setPadding(6,6,6,6);\n        _tv=new TextView(_ctx); _tv.setGravity(Gravity.CENTER_HORIZONTAL); _tv.setTextSize(32);\n        l.addView(_tv,new LinearLayout.LayoutParams(-1,-2));\n        _sb=new SeekBar(_ctx); _sb.setOnSeekBarChangeListener(this);\n        l.addView(_sb,new LinearLayout.LayoutParams(-1,-2));\n        if(shouldPersist())_val=getPersistedInt(_def);\n        _sb.setMax(_max); _sb.setProgress(_val); return l;\n    }\n    @Override protected void onSetInitialValue(boolean r,Object d){\n        super.onSetInitialValue(r,d);\n        _val=r?(shouldPersist()?getPersistedInt(_def):0):(Integer)d;\n    }\n    public void onProgressChanged(SeekBar s,int v,boolean f){\n        _val=v+_min; _tv.setText(_val+_suf);\n        if(shouldPersist())persistInt(_val); callChangeListener(Integer.valueOf(_val));\n    }\n    public void onStartTrackingTouch(SeekBar s){}\n    public void onStopTrackingTouch(SeekBar s){}\n    private int gInt(AttributeSet a,String ns,String n,int d){int id=a.getAttributeResourceValue(ns,n,0);return id!=0?getContext().getResources().getInteger(id):a.getAttributeIntValue(ns,n,d);}\n    private String gStr(AttributeSet a,String ns,String n,String d){int id=a.getAttributeResourceValue(ns,n,0);if(id!=0)return getContext().getResources().getString(id);String v=a.getAttributeValue(ns,n);return v!=null?v:d;}\n}\n"
+
+write_stub_file "com/mojang/minecraftpe/MainMenuOptionsActivity.java" "package com.mojang.minecraftpe;\nimport android.app.Activity;\npublic class MainMenuOptionsActivity extends Activity {\n    public static final String Internal_Game_DifficultyPeaceful=\"internal_game_difficulty_peaceful\";\n    public static final String Game_DifficultyLevel=\"game_difficulty\";\n    public static final String Controls_Sensitivity=\"controls_sensitivity\";\n}\n"
+
+write_stub_file "com/mojang/minecraftpe/Minecraft_Market.java" "package com.mojang.minecraftpe;\nimport android.app.Activity; import android.content.Intent; import android.os.Bundle;\npublic class Minecraft_Market extends Activity {\n    @Override protected void onCreate(Bundle s){super.onCreate(s);startActivity(new Intent(this,MainActivity.class));finish();}\n}\n"
+
+write_stub_file "com/mojang/minecraftpe/Minecraft_Market_Demo.java" "package com.mojang.minecraftpe;\nimport android.content.Intent; import android.net.Uri;\npublic class Minecraft_Market_Demo extends MainActivity {\n    @Override public void buyGame(){startActivity(new Intent(Intent.ACTION_VIEW,Uri.parse(\"market://details?id=com.mojang.minecraftpe\")));}\n    @Override protected boolean isDemo(){return true;}\n}\n"
+
+write_stub_file "com/mojang/minecraftpe/GameModeButton.java" "package com.mojang.minecraftpe;\nimport com.mojang.android.StringValue;\nimport android.content.Context; import android.util.AttributeSet;\nimport android.view.View; import android.view.View.OnClickListener;\nimport android.widget.TextView; import android.widget.ToggleButton;\npublic class GameModeButton extends ToggleButton implements OnClickListener,StringValue {\n    static final int Creative=0,Survival=1;\n    private int _type=0; private boolean _attached=false;\n    public GameModeButton(Context c,AttributeSet a){super(c,a);setOnClickListener(this);}\n    public void onClick(View v){_update();}\n    @Override protected void onFinishInflate(){super.onFinishInflate();_update();}\n    @Override protected void onAttachedToWindow(){if(!_attached){_update();_attached=true;}}\n    private void _update(){_set(isChecked()?Survival:Creative);}\n    private void _set(int i){\n        _type=i<Creative?Creative:(i>Survival?Survival:i);\n        int id=_type==Survival?R.string.gamemode_survival_summary:R.string.gamemode_creative_summary;\n        String desc=getContext().getString(id);\n        View v=getRootView().findViewById(R.id.labelGameModeDesc);\n        if(desc!=null&&v instanceof TextView)((TextView)v).setText(desc);\n    }\n    public String getStringValue(){return new String[]{\"creative\",\"survival\"}[_type];}\n    static public String getStringForType(int i){int c=i<Creative?Creative:(i>Survival?Survival:i);return new String[]{\"creative\",\"survival\"}[c];}\n}\n"
+
+echo "  stubs OK"
+
+########################################
+# ndk build
+########################################
+if [[ "$NO_CPP" == false && "$NO_BUILD" == false ]]; then
+  log_step "NDK build ($TARGET_ABI)"
+
+  # the original windows build script used a junction to avoid long paths here
+  # on linux, path lengths are *usually* fine, but we still keep things simple
+  pushd "$JNI_DIR" >/dev/null
+
+  export NDK_MODULE_PATH="$REPO_ROOT/project/lib_projects"
+
+  # build each requested ABI by delegating to build_ndk_abi()
+  if [[ "$TARGET_ABI" == "all" ]]; then
+    build_ndk_abi "arm64-v8a"
+    build_ndk_abi "armeabi-v7a"
+  else
+    build_ndk_abi "$TARGET_ABI"
+  fi
+
+  popd >/dev/null
+fi
+
+########################################
+# java compile
+########################################
+if [[ "$NO_JAVA" == false && "$NO_BUILD" == false ]]; then
+  log_step "Java compile"
+
+  ensure_dir "$(dirname "$BUILD_DIR/gen/R.java")"
+
+  # generate R.java
+  "$AAPT" package -f -M "$ANDROID_MANIFEST" -S "$ANDROID_RES_DIR" -I "$ANDROID_PLATFORM_DIR/android.jar" -J "$BUILD_DIR/gen" -F "$BUILD_DIR/_rgen.apk"
+  rm -f "$BUILD_DIR/_rgen.apk"
+
+  # collect all source files (project + stubs + generated R.java)
+  JAVA_SOURCES=(
+    $(find "$JAVA_SRC_DIR" -name "*.java" -print)
+    $(find "$BUILD_DIR/stubs" -name "*.java" -print)
+    "$BUILD_DIR/gen/R.java"
+  )
+
+  rm -rf "$BUILD_DIR/classes"
+  ensure_dir "$BUILD_DIR/classes"
+
+  # Some JDK versions (<=8) don't support --release.
+  JAVAC_ARGS=(--release 8)
+  if "$JAVAC_CMD" -version 2>&1 | grep -qE '^javac 1\.'; then
+    JAVAC_ARGS=(-source 1.8 -target 1.8)
+  fi
+
+  "$JAVAC_CMD" "${JAVAC_ARGS[@]}" -cp "$ANDROID_PLATFORM_DIR/android.jar" -d "$BUILD_DIR/classes" "${JAVA_SOURCES[@]}"
+  echo "  javac OK"
+
+  # convert class files into dex
+  JAVA_CLASS_FILES=( $(find "$BUILD_DIR/classes" -name "*.class" -print) )
+  "$DEX_TOOL" --min-api 21 --output "$BUILD_DIR" "${JAVA_CLASS_FILES[@]}"
+  echo "  d8 -> $DEX_OUTPUT"
+fi
+
+########################################
+# package apk
+########################################
+log_step "Package APK"
+
+rm -f "$APK_UNSIGNED" "$APK_ALIGNED" "$APK_SIGNED"
+
+"$AAPT" package -f -M "$ANDROID_MANIFEST" -S "$ANDROID_RES_DIR" -I "$ANDROID_PLATFORM_DIR/android.jar" -F "$APK_UNSIGNED"
+
+# add classes.dex and native library/libraries into apk.
+# when building for "all" we pack both ABIs into the same APK so Android can
+# pick the right one at install time (fat APK). for a single-ABI build we
+# only include the one .so that was actually compiled.
+pushd "$BUILD_DIR" >/dev/null
+zip -q "$APK_UNSIGNED" "classes.dex"
+if [[ "$TARGET_ABI" == "all" ]]; then
+  zip -q "$APK_UNSIGNED" "lib/arm64-v8a/libminecraftpe.so"
+  zip -q "$APK_UNSIGNED" "lib/armeabi-v7a/libminecraftpe.so"
+else
+  zip -q "$APK_UNSIGNED" "lib/$TARGET_ABI/libminecraftpe.so"
+fi
+popd >/dev/null
+
+# add assets from data/ directory into the apk under assets/
+TMP_ASSETS_DIR="$(mktemp -d)"
+mkdir -p "$TMP_ASSETS_DIR/assets"
+cp -r "$DATA_DIR/." "$TMP_ASSETS_DIR/assets/"
+pushd "$TMP_ASSETS_DIR" >/dev/null
+zip -q -r "$APK_UNSIGNED" assets
+popd >/dev/null
+rm -rf "$TMP_ASSETS_DIR"
+
+"$ZIPALIGN" -p 4 "$APK_UNSIGNED" "$APK_ALIGNED"
+"$APKSIGNER" sign --ks "$KEYSTORE_FILE" --ks-pass pass:android --key-pass pass:android --out "$APK_SIGNED" "$APK_ALIGNED"
+
+echo "  signed -> $APK_SIGNED"
+
+########################################
+# install
+########################################
+log_step "Install"
+
+"$ADB" shell am force-stop "$PACKAGE_NAME" || true
+"$ADB" uninstall "$PACKAGE_NAME" || true
+"$ADB" install --no-incremental "$APK_SIGNED"
+
+echo -e "\nDone. Enjoy MCPE 0.6.1 on your device!"

cmake/EnumOption.cmake

@@ -0,0 +1,9 @@
+macro(enum_option var values description)
+  set(${var}_VALUES ${values})
+  list(GET ${var}_VALUES 0 default)
+  set(${var} "${default}" CACHE STRING "${description}")
+  set_property(CACHE ${var} PROPERTY STRINGS ${${var}_VALUES})
+  if (NOT ";${${var}_VALUES};" MATCHES ";${${var}};")
+    message(FATAL_ERROR "Unknown value ${${var}}. Only -D${var}=${${var}_VALUES} allowed.")
+  endif()
+endmacro()

data/lang/en_US.lang

@@ -152,6 +152,7 @@ options.group.graphics=Graphics
 options.group.tweaks=Tweaks
 options.allowSprint=Allow sprint
 options.barOnTop=HUD above inventory
+options.rpiCursor=Show Raspberry PI cursor
 options.autojump=Auto Jump
 options.thirdperson=Third Person
 options.servervisible=Server Visible
@@ -181,9 +182,10 @@ options.graphics.fast=Fast
 options.guiScale=GUI Scale
 options.guiScale.auto=Auto
 options.guiScale.small=Small
-options.guiScale.normal=Normal
+options.guiScale.medium=Medium
 options.guiScale.large=Large
 options.guiScale.larger=Larger
+options.guiScale.largest=Largest
 options.advancedOpengl=Advanced OpenGL
 options.renderClouds=Clouds
 options.farWarning1=A 64 bit Java installation is recommended

misc/web/index.html

@@ -0,0 +1,143 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <title>Emscripten-Generated Code</title>
+    <style>
+      .emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; }
+      textarea.emscripten { font-family: monospace; width: 80%; }
+      div.emscripten { text-align: center; }
+      div.emscripten_border { border: 1px solid black; }
+      /* the canvas *must not* have any border or padding, or mouse coords will be wrong */
+      canvas.emscripten { border: 0px none; background-color: black; }
+
+      .spinner {
+        height: 50px;
+        width: 50px;
+        margin: 0px auto;
+        -webkit-animation: rotation .8s linear infinite;
+        -moz-animation: rotation .8s linear infinite;
+        -o-animation: rotation .8s linear infinite;
+        animation: rotation 0.8s linear infinite;
+        border-left: 10px solid rgb(0,150,240);
+        border-right: 10px solid rgb(0,150,240);
+        border-bottom: 10px solid rgb(0,150,240);
+        border-top: 10px solid rgb(100,0,200);
+        border-radius: 100%;
+        background-color: rgb(200,100,250);
+      }
+      @-webkit-keyframes rotation {
+        from {-webkit-transform: rotate(0deg);}
+        to {-webkit-transform: rotate(360deg);}
+      }
+      @-moz-keyframes rotation {
+        from {-moz-transform: rotate(0deg);}
+        to {-moz-transform: rotate(360deg);}
+      }
+      @-o-keyframes rotation {
+        from {-o-transform: rotate(0deg);}
+        to {-o-transform: rotate(360deg);}
+      }
+      @keyframes rotation {
+        from {transform: rotate(0deg);}
+        to {transform: rotate(360deg);}
+      }
+
+    </style>
+  </head>
+  <body>
+    <hr/>
+    <figure style="overflow:visible;" id="spinner"><div class="spinner"></div><center style="margin-top:0.5em"><strong>emscripten</strong></center></figure>
+    <div class="emscripten" id="status">Downloading...</div>
+    <div class="emscripten">
+      <progress value="0" max="100" id="progress" hidden=1></progress>
+    </div>
+    <div class="emscripten_border">
+      <canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()" tabindex=-1></canvas>
+    </div>
+    <hr/>
+    <div class="emscripten">
+      <input type="checkbox" id="resize">Resize canvas
+      <input type="checkbox" id="pointerLock" checked>Lock/hide mouse pointer
+      &nbsp;&nbsp;&nbsp;
+      <input type="button" value="Fullscreen" onclick="Module.requestFullscreen(document.getElementById('pointerLock').checked,
+                                                                                document.getElementById('resize').checked)">
+    </div>
+
+    <hr/>
+    <textarea class="emscripten" id="output" rows="8"></textarea>
+    <hr>
+    <script type='text/javascript'>
+      var statusElement = document.getElementById('status');
+      var progressElement = document.getElementById('progress');
+      var spinnerElement = document.getElementById('spinner');
+      var canvasElement = document.getElementById('canvas');
+      var outputElement = document.getElementById('output');
+      if (outputElement) outputElement.value = ''; // clear browser cache
+
+      // As a default initial behavior, pop up an alert when webgl context is lost. To make your
+      // application robust, you may want to override this behavior before shipping!
+      // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
+      canvasElement.addEventListener("webglcontextlost", (e) => {
+        alert('WebGL context lost. You will need to reload the page.');
+        e.preventDefault();
+      }, false);
+
+      function setStatus(text) {
+        if (!setStatus.last) setStatus.last = { time: Date.now(), text: '' };
+        if (text === setStatus.last.text) return;
+        var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
+        var now = Date.now();
+        if (m && now - setStatus.last.time < 30) return; // if this is a progress update, skip it if too soon
+        setStatus.last.time = now;
+        setStatus.last.text = text;
+        if (m) {
+          text = m[1];
+          progressElement.value = parseInt(m[2])*100;
+          progressElement.max = parseInt(m[4])*100;
+          progressElement.hidden = false;
+          spinnerElement.hidden = false;
+        } else {
+          progressElement.value = null;
+          progressElement.max = null;
+          progressElement.hidden = true;
+          if (!text) spinnerElement.hidden = true;
+        }
+        statusElement.innerHTML = text;
+      }
+
+      var Module = {
+        print(...args) {
+          // These replacements are necessary if you render to raw HTML
+          //text = text.replace(/&/g, "&amp;");
+          //text = text.replace(/</g, "&lt;");
+          //text = text.replace(/>/g, "&gt;");
+          //text = text.replace('\n', '<br>', 'g');
+          console.log(...args);
+          if (outputElement) {
+            var text = args.join(' ');
+            outputElement.value += text + "\n";
+            outputElement.scrollTop = outputElement.scrollHeight; // focus on bottom
+          }
+        },
+        canvas: canvasElement,
+        setStatus: setStatus,
+        totalDependencies: 0,
+        monitorRunDependencies(left) {
+          this.totalDependencies = Math.max(this.totalDependencies, left);
+          setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.');
+        }
+      };
+      setStatus('Downloading...');
+      window.onerror = () => {
+        setStatus('Exception thrown, see JavaScript console');
+        spinnerElement.style.display = 'none';
+        setStatus = (text) => {
+          if (text) console.error('[post-exception status] ' + text);
+        };
+      };
+    </script>
+    <script src="MinecraftPE.js"></script>
+  </body>
+</html>

project/android/AndroidManifest.xml

@@ -6,8 +6,8 @@
       android:installLocation="preferExternal">
 
     <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk   android:minSdkVersion="24"
+    <uses-sdk   android:minSdkVersion="19"
-                android:targetSdkVersion="24" />
+                android:targetSdkVersion="30" />
                 
     <!-- uses-feature android:name="android.hardware.touchscreen.multitouch" android:required="true"/ -->
 

project/android/assets/lang/en_US.lang

@@ -168,9 +168,10 @@ options.graphics.fast=Fast
 options.guiScale=GUI Scale
 options.guiScale.auto=Auto
 options.guiScale.small=Small
-options.guiScale.normal=Normal
+options.guiScale.medium=Medium
 options.guiScale.large=Large
 options.guiScale.larger=Larger
+options.guiScale.largest=Largest
 options.advancedOpengl=Advanced OpenGL
 options.renderClouds=Clouds
 options.farWarning1=A 64 bit Java installation is recommended

project/android/jni/Android.mk

@@ -24,6 +24,7 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/client/Options.cpp \
 ../../../src/client/OptionsFile.cpp \
 ../../../src/client/OptionStrings.cpp \
+../../../src/client/Option.cpp \
 ../../../src/client/gamemode/GameMode.cpp \
 ../../../src/client/gamemode/CreativeMode.cpp \
 ../../../src/client/gamemode/SurvivalMode.cpp \
@@ -37,14 +38,14 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/client/gui/components/NinePatch.cpp \
 ../../../src/client/gui/components/OptionsGroup.cpp \
 ../../../src/client/gui/components/OptionsItem.cpp \
-../../../src/client/gui/components/OptionsPane.cpp \
+../../../src/client/gui/components/KeyOption.cpp \
+../../../src/client/gui/components/TextOption.cpp \
 ../../../src/client/gui/components/RolledSelectionListH.cpp \
 ../../../src/client/gui/components/RolledSelectionListV.cpp \
 ../../../src/client/gui/components/ScrolledSelectionList.cpp \
 ../../../src/client/gui/components/ScrollingPane.cpp \
 ../../../src/client/gui/components/Slider.cpp \
 ../../../src/client/gui/components/TextBox.cpp \
-../../../src/client/gui/components/SmallButton.cpp \
 ../../../src/client/gui/Font.cpp \
 ../../../src/client/gui/Gui.cpp \
 ../../../src/client/gui/GuiComponent.cpp \
@@ -256,7 +257,8 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/world/phys/HitResult.cpp
 
 LOCAL_CFLAGS := -DPLATFORM_ANDROID -DPRE_ANDROID23 -Wno-narrowing $(LOCAL_CFLAGS)
-LOCAL_CPPFLAGS := -std=c++11
+LOCAL_CPPFLAGS := -std=c++14 -frtti
+LOCAL_CPPFLAGS += -frtti
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../src
 
 #LOCAL_CFLAGS := -DANDROID_PUBLISH -DDEMO_MODE $(LOCAL_CFLAGS)

project/android/jni/Application.mk

@@ -1,6 +1,7 @@
-APP_PLATFORM := android-21
+APP_PLATFORM := android-19
 APP_STL := gnustl_static
 APP_OPTIM        := release
 APP_ABI          := arm64-v8a
 APP_SHORT_COMMANDS := true
+APP_CPPFLAGS += -frtti -fexceptions
 #APP_ABI          := armeabi-v7a x86

project/android_java/AndroidManifest.xml

@@ -5,8 +5,8 @@
       android:versionName="0.6.1-alpha-0.0.3">
 
     <uses-sdk
-        android:minSdkVersion="24"
+        android:minSdkVersion="19"
-        android:targetSdkVersion="28"/>
+        android:targetSdkVersion="30"/>
 
     <uses-feature
         android:name="android.hardware.touchscreen.multitouch"

project/android_java/assets/lang/en_US.lang

@@ -168,8 +168,10 @@ options.graphics.fast=Fast
 options.guiScale=GUI Scale
 options.guiScale.auto=Auto
 options.guiScale.small=Small
-options.guiScale.normal=Normal
+options.guiScale.medium=Medium
 options.guiScale.large=Large
+options.guiScale.larger=Larger
+options.guiScale.largest=Largest
 options.advancedOpengl=Advanced OpenGL
 options.renderClouds=Clouds
 options.farWarning1=A 64 bit Java installation is recommended

project/android_java/jni/Application.mk

@@ -1,4 +1,4 @@
-APP_PLATFORM := android-9
+APP_PLATFORM := android-19
 APP_STL := gnustl_static
 APP_OPTIM        := release
 APP_ABI          := armeabi-v7a

project/android_java/src/com/mojang/minecraftpe/MainActivity.java

@@ -59,6 +59,7 @@ public class MainActivity extends Activity {
     private static final int PERMISSION_REQUEST_CODE = 123;
 
     private GLView _glView;
+    private boolean _nativeInitialized = false;
     public float invScale = 1.0f;// / 1.5f;
     private int _screenWidth = 0;
     private int _screenHeight = 0;
@@ -77,63 +78,48 @@ public class MainActivity extends Activity {
         _screenWidth = Math.max(_dm.widthPixels, _dm.heightPixels);
         _screenHeight = Math.min(_dm.widthPixels, _dm.heightPixels);
 
-        nativeOnCreate(_screenWidth, _screenHeight);
-
         _glView = new GLView(getApplication(), this);
         //_glView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
+
         _glView.setEGLConfigChooser(true);
         //_glView
 
-//        _glView.setEGLConfigChooser(
-//        	new GLSurfaceView.EGLConfigChooser() {
-//			
-//			@Override
-//			public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
-//				// TODO Auto-generated method stub
-//				
-//		        // Specify a configuration for our opengl session 
-//		         // and grab the first configuration that matches is 
-//		         int[] configSpec = { 
-//		                 EGL10.EGL_DEPTH_SIZE,   24, 
-//		                 EGL10.EGL_NONE 
-//		         }; 
-//		         EGLConfig[] configs = new EGLConfig[1]; 
-//		         int[] num_config = new int[1]; 
-//		         egl.eglChooseConfig(display, configSpec, configs, 1, num_config); 
-//		         EGLConfig config = configs[0];
-//		         return config;
-//				
-//				//return null;
-//			}
-//		} );
-
         _glView.commit();
-    	setContentView(_glView);
+        setContentView(_glView);
 
-    	_soundPlayer = new SoundPlayer(this, AudioManager.STREAM_MUSIC);
+        _soundPlayer = new SoundPlayer(this, AudioManager.STREAM_MUSIC);
 
-        // request dangerous permissions at runtime if necessary
         checkAndRequestPermissions();
+        initNative();
     }
 
-    private void checkAndRequestPermissions() {
+    private void initNative() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        if (_nativeInitialized) {
-            boolean needRequest = false;
+            return;
-            if (checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
-                    != PackageManager.PERMISSION_GRANTED) {
-                needRequest = true;
-            }
-            if (checkSelfPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE)
-                    != PackageManager.PERMISSION_GRANTED) {
-                needRequest = true;
-            }
-            if (needRequest) {
-                requestPermissions(new String[] {
-                        android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
-                        android.Manifest.permission.READ_EXTERNAL_STORAGE
-                }, PERMISSION_REQUEST_CODE);
-            }
         }
+        _nativeInitialized = true;
+        nativeOnCreate(_screenWidth, _screenHeight);
+    }
+
+    // request dangerous permissions at runtime if necessary
+    private boolean checkAndRequestPermissions() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            return true;
+        }
+
+        boolean writeGranted = checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
+        boolean readGranted = checkSelfPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
+
+        if (writeGranted && readGranted) {
+            return true;
+        }
+
+        requestPermissions(new String[] {
+            android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
+            android.Manifest.permission.READ_EXTERNAL_STORAGE
+        }, PERMISSION_REQUEST_CODE);
+
+        return false;
     }
 
     @Override
@@ -146,8 +132,18 @@ public class MainActivity extends Activity {
                     break;
                 }
             }
-            if (!granted) {
+            if (granted) {
-                // user denied; you might want to warn or close the app
+                initNative();
+            } else {
+                // We can still run using app-specific external files in scoped-storage,
+                // so allow startup while warning the user.
+                initNative();
+                new AlertDialog.Builder(this)
+                    .setTitle("Storage permission recommended")
+                    .setMessage("MinecraftPE can still run with app-private storage, but public external save/load may require permission.")
+                    .setPositiveButton("OK", null)
+                    .setCancelable(true)
+                    .show();
             }
         }
         super.onRequestPermissionsResult(requestCode, permissions, grantResults);

project/lib_projects/raknet/jni/Android.mk

@@ -4,10 +4,11 @@ include $(CLEAR_VARS)
 
 LOCAL_MODULE    := RakNet
 
-MY_PREFIX := $(LOCAL_PATH)/RakNetSources/
+MY_PREFIX := $(LOCAL_PATH)/RaknetSources/
 MY_SOURCES := $(wildcard $(MY_PREFIX)*.cpp)
-LOCAL_SRC_FILES += $(MY_SOURCES:$(MY_PREFIX)%=RakNetSources/%)
+LOCAL_SRC_FILES += $(MY_SOURCES:$(MY_PREFIX)%=RaknetSources/%)
 
 LOCAL_CFLAGS := -Wno-psabi $(LOCAL_CFLAGS)
+LOCAL_CPPFLAGS += -frtti
 
 include $(BUILD_STATIC_LIBRARY)

project/lib_projects/raknet/jni/RaknetSources/WindowsIncludes.h

@@ -1,8 +1,8 @@
 #if defined(X360__) 
 #elif defined (_WIN32)
-#include <WinSock2.h>
+#include <winsock2.h>
 #include <windows.h>
-#include <Ws2tcpip.h>
+#include <ws2tcpip.h>
 
 // Must always include Winsock2.h before windows.h
 // or else:

src/AppPlatform.h

@@ -75,6 +75,8 @@ public:
 
     virtual void playSound(const std::string& fn, float volume, float pitch) {}
 	
+	virtual void hideCursor(bool hide) {}
+
 	virtual void showDialog(int dialogId) {}
     virtual void createUserInput() {}
 	

src/AppPlatform_android.h

@@ -202,6 +202,8 @@ public:
         LOGI("initConsts: screenWidth=%d, calling getScreenHeight\n", _screenWidth);
         _screenHeight = env->CallIntMethod(instance, fHeight);
         LOGI("initConsts: screenHeight=%d, done\n", _screenHeight);
+
+        return 1;
     }
 
     void tick() {
@@ -536,7 +538,7 @@ public:
 
     static __inline bool isSquare(int n) {
         int L = n & 0xf;
-        if ((1 << L) & 0x213 == 0) return false;
+        if (((1 << L) & 0x213) == 0) return false;
 
         int t = (int) sqrt((double) n) + 0.5;
         return t*t == n;

src/AppPlatform_glfw.h

@@ -31,7 +31,7 @@ public:
     {
     }
 
-	BinaryBlob readAssetFile(const std::string& filename) {
+	BinaryBlob readAssetFile(const std::string& filename) override {
 		FILE* fp = fopen(("data/" + filename).c_str(), "r");
 		if (!fp)
 			return BinaryBlob();
@@ -48,7 +48,7 @@ public:
 		return blob;
 	}
 
-    void saveScreenshot(const std::string& filename, int glWidth, int glHeight) {
+    void saveScreenshot(const std::string& filename, int glWidth, int glHeight) override {
         //@todo
     }
 
@@ -56,7 +56,7 @@ public:
         return (p & 0xff00ff00) | ((p >> 16) & 0xff) | ((p << 16) & 0xff0000);
     }
 
-    TextureData loadTexture(const std::string& filename_, bool textureFolder)
+    TextureData loadTexture(const std::string& filename_, bool textureFolder) override
 	{
 		// Support fetching PNG textures via HTTP/HTTPS (for skins, etc)
 		if (Util::startsWith(filename_, "http://") || Util::startsWith(filename_, "https://")) {
@@ -73,50 +73,20 @@ public:
 								: filename_;
 		std::ifstream source(filename.c_str(), std::ios::binary);
 
-		if (source) {
+		if (!source) {
-			png_structp pngPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-
-			if (!pngPtr)
-				return out;
-
-			png_infop infoPtr = png_create_info_struct(pngPtr);
-
-			if (!infoPtr) {
-				png_destroy_read_struct(&pngPtr, NULL, NULL);
-				return out;
-			}
-
-			// Hack to get around the broken libpng for windows
-			png_set_read_fn(pngPtr,(void*)&source, png_funcReadFile);
-
-			png_read_info(pngPtr, infoPtr);
-
-			// Set up the texdata properties
-			out.w = png_get_image_width(pngPtr, infoPtr);
-			out.h = png_get_image_height(pngPtr, infoPtr);
-
-			png_bytep* rowPtrs = new png_bytep[out.h];
-			out.data = new unsigned char[4 * out.w * out.h];
-			out.memoryHandledExternally = false;
-
-			int rowStrideBytes = 4 * out.w;
-			for (int i = 0; i < out.h; i++) {
-				rowPtrs[i] = (png_bytep)&out.data[i*rowStrideBytes];
-			}
-			png_read_image(pngPtr, rowPtrs);
-
-			// Teardown and return
-			png_destroy_read_struct(&pngPtr, &infoPtr,(png_infopp)0);
-			delete[] (png_bytep)rowPtrs;
-			source.close();
-
-			return out;
-		}
-		else
-		{
 			LOGI("Couldn't find file: %s\n", filename.c_str());
 			return out;
 		}
+
+		std::vector<unsigned char> fileData((std::istreambuf_iterator<char>(source)), std::istreambuf_iterator<char>());
+		source.close();
+
+		if (fileData.empty()) {
+			LOGI("Couldn't read file: %s\n", filename.c_str());
+			return out;
+		}
+
+		return loadTextureFromMemory(fileData.data(), fileData.size());
     }
 
 	TextureData loadTextureFromMemory(const unsigned char* data, size_t size) override {
@@ -132,13 +102,18 @@ public:
 		return std::string(mbstr);
 	}
 
-	virtual int getScreenWidth() { return 854; };
+	virtual int getScreenWidth() override { return 854; };
-	virtual int getScreenHeight() { return 480; };
+	virtual int getScreenHeight() override { return 480; };
 
-	virtual float getPixelsPerMillimeter();
+	virtual float getPixelsPerMillimeter() override;
 
 	virtual bool supportsTouchscreen() override { return true; }
 
+	virtual void hideCursor(bool hide) override {
+		int isHide = hide ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN;
+		glfwSetInputMode(window, GLFW_CURSOR, isHide);
+	}
+
 	virtual void openURL(const std::string& url) override {
 #ifdef _WIN32
 		ShellExecuteA(NULL, "open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);
@@ -148,6 +123,8 @@ public:
 #endif
 	}
 
+	GLFWwindow* window;
+
 private:
 };
 #endif /*APPPLATFORM_GLFW_H__*/

src/NinecraftApp.cpp

@@ -99,6 +99,9 @@ void NinecraftApp::init()
 	I18n::loadLanguage(platform(), "en_US");
 #endif
 
+	if (!externalStoragePath.empty()) {
+		options.setOptionsFilePath(externalStoragePath);
+	}
 	Minecraft::init();
 
 #if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION) && !defined(NO_STORAGE)
@@ -117,7 +120,6 @@ void NinecraftApp::init()
 		setScreen(new UsernameScreen());
 	}
 #else
-	user->name = "Server";
 	hostMultiplayer();
 #endif
 }
@@ -246,8 +248,9 @@ void NinecraftApp::initGLStates()
 	glCullFace(GL_BACK);
 
 	glEnable2(GL_TEXTURE_2D);
+#ifndef _EMSCRIPTEN_
 	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
-
+#endif
 	// Both updates isPowerVR flag in java and returns if the graphics chip is PowerVR SGX or not
 	_powerVr = platform()->isPowerVR();
 #ifdef __APPLE__

src/client/Minecraft.cpp

@@ -23,6 +23,8 @@
 #include "../world/level/storage/LevelStorageSource.h"
 #include "../world/level/storage/LevelStorage.h"
 #include "player/input/KeyboardInput.h"
+#include "player/input/ControllerTurnInput.h"
+#include "player/input/XperiaPlayInput.h"
 #include "world/level/chunk/ChunkSource.h"
 
 #ifndef STANDALONE_SERVER
@@ -114,8 +116,7 @@ int Minecraft::customDebugId = Minecraft::CDI_NONE;
 
 bool Minecraft::useAmbientOcclusion = false;
 
-Minecraft::Minecraft()
+Minecraft::Minecraft() :	
-:	user(NULL),
 	level(NULL),
 	player(NULL),
 	cameraTargetPlayer(NULL),
@@ -220,7 +221,6 @@ Minecraft::~Minecraft()
 	}
 
 	//delete player;
-	delete user;
 	delete inputHolder;
 
 	delete storageSource;
@@ -1143,10 +1143,10 @@ void Minecraft::init()
 	checkGlError("Init complete");
 #endif
 
-	user = new User(options.getStringValue(OPTIONS_USERNAME), "");
+	options.load();
+
 	setIsCreativeMode(false); // false means it's Survival Mode
 	reloadOptions();
-
 }
 
 void Minecraft::setSize(int w, int h) {
@@ -1160,12 +1160,13 @@ void Minecraft::setSize(int w, int h) {
 
 	// determine gui scale, optionally overriding auto
 	if (guiScale != 0) {
-		// manual selection: 1->small, 2->normal, 3->large, 4->larger
+		// manual selection: 1->small, 2->medium, 3->large, 4->larger, 5->largest
 		switch (guiScale) {
 		case 1: Gui::GuiScale = 2.0f; break;
 		case 2: Gui::GuiScale = 3.0f; break;
 		case 3: Gui::GuiScale = 4.0f; break;
-		case 4: Gui::GuiScale = 5.0f; break; // bigger than large
+		case 4: Gui::GuiScale = 5.0f; break;
+		case 5: Gui::GuiScale = 6.0f; break;
 		default: Gui::GuiScale = 1.0f; break; // auto
 		}
 	} else {
@@ -1332,9 +1333,9 @@ void Minecraft::hostMultiplayer(int port) {
 #if !defined(NO_NETWORK)
 	netCallback = new ServerSideNetworkHandler(this, raknetInstance);
     #ifdef STANDALONE_SERVER
-        raknetInstance->host(user->name, port, 16);
+        raknetInstance->host("Server", port, 16);
     #else
-        raknetInstance->host(user->name, port);
+        raknetInstance->host(options.getStringValue(OPTIONS_USERNAME), port);
     #endif
 #endif
 }
@@ -1391,8 +1392,10 @@ void Minecraft::_levelGenerated()
 
 	this->cameraTargetPlayer = player;
 
+	std::string serverName = options.getStringValue(OPTIONS_USERNAME) + " - " + level->getLevelData()->levelName;
+
 	if (raknetInstance->isServer())
-		raknetInstance->announceServer(user->name);
+		raknetInstance->announceServer(serverName);
 
 	if (netCallback) {
 		netCallback->levelGenerated(level);

src/client/Minecraft.h

@@ -13,7 +13,6 @@
 //#include "../network/RakNetInstance.h"
 #include "../world/phys/HitResult.h"
 
-class User;
 class Level;
 class LocalPlayer;
 class IInputHolder;
@@ -165,7 +164,6 @@ public:
 	int lastTickTime;
 	float ticksSinceLastUpdate;
 
-	User*  user;
 	Level* level;
 
 	LocalPlayer*	player;

src/client/MouseHandler.cpp

@@ -5,7 +5,7 @@
 #include <SDL/SDL.h>
 #endif
 
-#ifdef PLATFORM_GLFW
+#ifdef PLATFORM_DESKTOP
 #include <GLFW/glfw3.h>
 #endif
 
@@ -34,7 +34,7 @@ void MouseHandler::grab() {
 	SDL_ShowCursor(0);
 #endif
 
-#ifdef PLATFORM_GLFW
+#ifdef PLATFORM_DESKTOP
 	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_DISABLED);
 #endif
 }
@@ -46,7 +46,7 @@ void MouseHandler::release() {
 	SDL_ShowCursor(1);
 #endif
 
-#ifdef PLATFORM_GLFW
+#ifdef PLATFORM_DESKTOP
 	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
 #endif
 }

src/client/Option.cpp

@@ -1,5 +1,8 @@
 #include "Option.h"
 #include <sstream>
+#include <cstdio>
+
+Option::~Option() {}
 
 bool Option::parse_bool_like(const std::string& value, bool& out) {
     if (value == "true" || value == "YES") {
@@ -23,7 +26,7 @@ bool OptionFloat::parse(const std::string& value) {
         return true;
     }
 
-    return std::sscanf(value.c_str(), "%f", &m_value) == 1;
+    return sscanf(value.c_str(), "%f", &m_value) == 1;
 }
 bool OptionInt::parse(const std::string& value) {
     bool b;
@@ -32,7 +35,7 @@ bool OptionInt::parse(const std::string& value) {
         return true;
     }
 
-    return std::sscanf(value.c_str(), "%d", &m_value) == 1;
+    return sscanf(value.c_str(), "%d", &m_value) == 1;
 }
 bool OptionBool::parse(const std::string& value) {
     if (value == "0") {

src/client/Option.h

@@ -21,7 +21,7 @@ template<> struct is_min_max_option<float> : std::true_type {};
 class Option {
 public:
     Option(const std::string& key) : m_key("options." + key) {}
-    virtual ~Option() = default;
+    virtual ~Option();
 
     const std::string& getStringId() { return m_key; }
 

src/client/Options.cpp

@@ -20,6 +20,7 @@ OptionBool fixedCamera("fixedCamera", false);
 OptionBool isFlying("isflying", false);
 OptionBool barOnTop("barOnTop", false);
 OptionBool allowSprint("allowSprint", true);
+OptionBool rpiCursor("rpiCursor", false);
 OptionBool autoJump("autoJump", true);
 
 
@@ -158,6 +159,7 @@ void Options::initTable() {
 
 	m_options[OPTIONS_BAR_ON_TOP] = &barOnTop;
 	m_options[OPTIONS_ALLOW_SPRINT] = &allowSprint;
+	m_options[OPTIONS_RPI_CURSOR] = &rpiCursor;
 
 	m_options[OPTIONS_AUTOJUMP] = &autoJump;
 	m_options[OPTIONS_LAST_IP] = &lastIp;
@@ -168,9 +170,7 @@ void Options::set(OptionId key, const std::string& value) {
 
 	if (option) {
 		option->set(value);
-
 		notifyOptionUpdate(key, value);
-		save();
 	}
 }
 
@@ -179,9 +179,7 @@ void Options::set(OptionId key, float value) {
 
 	if (option) {
 		option->set(value);
-
 		notifyOptionUpdate(key, value);
-		save();
 	}
 }
 
@@ -190,9 +188,7 @@ void Options::set(OptionId key, int value) {
 
 	if (option) {
 		option->set(value);
-
 		notifyOptionUpdate(key, value);
-		save();
 	}
 }
 
@@ -201,9 +197,7 @@ void Options::toggle(OptionId key) {
 
 	if (option) {
 		option->toggle();
-
 		notifyOptionUpdate(key, option->get());
-		save();
 	}
 }
 
@@ -291,6 +285,10 @@ void Options::save() {
 	optionsFile.save(stringVec);
 }
 
+void Options::setOptionsFilePath(const std::string& path) {
+	optionsFile.setOptionsPath(path + "/options.txt");
+}
+
 void Options::notifyOptionUpdate(OptionId key, bool value) {
 	minecraft->optionUpdated(key, value);
 }

src/client/Options.h

@@ -83,6 +83,7 @@ enum OptionId {
     OPTIONS_FIRST_LAUNCH,
     OPTIONS_LAST_IP,
 
+    OPTIONS_RPI_CURSOR,
 	// Should be last!
 	OPTIONS_COUNT
 };
@@ -100,15 +101,10 @@ public:
         // elements werent initialized so i was getting a garbage pointer and a crash
         m_options.fill(nullptr);
         initTable();
-		load();
+	    // load() is deferred to init() where path is configured correctly
     }
 
-	void initTable();
+    void initTable();
-
-    void set(OptionId key, int value);
-    void set(OptionId key, float value);
-    void set(OptionId key, const std::string& value);
-    void toggle(OptionId key);
 
     int getIntValue(OptionId key) {
         auto option = opt<OptionInt>(key);
@@ -144,6 +140,11 @@ public:
 
     void load();
     void save();
+    void set(OptionId key, int value);
+    void set(OptionId key, float value);
+    void set(OptionId key, const std::string& value);
+	void setOptionsFilePath(const std::string& path);
+	void toggle(OptionId key);
 
 	void notifyOptionUpdate(OptionId key, bool value);
 	void notifyOptionUpdate(OptionId key, float value);

src/client/OptionsFile.cpp

@@ -1,8 +1,16 @@
 #include "OptionsFile.h"
 #include <stdio.h>
 #include <string.h>
+#include <errno.h>
 #include <platform/log.h>
 
+#if defined(_WIN32)
+    #include <direct.h>
+#else
+    #include <sys/stat.h>
+    #include <sys/types.h>
+#endif
+
 OptionsFile::OptionsFile() {
 #ifdef __APPLE__
 	settingsPath = "./Documents/options.txt";
@@ -13,18 +21,54 @@ OptionsFile::OptionsFile() {
 #endif
 }
 
-void OptionsFile::save(const StringVector& settings) {
+void OptionsFile::setOptionsPath(const std::string& path) {
-	FILE* pFile = fopen(settingsPath.c_str(), "w");
+	settingsPath = path;
-	if(pFile != NULL) {
-		for(StringVector::const_iterator it = settings.begin(); it != settings.end(); ++it) {
-			fprintf(pFile, "%s\n", it->c_str());
-		}
-		fclose(pFile);
-	} else {
-		LOGI("OptionsFile::save failed to open '%s' for writing: %s", settingsPath.c_str(), strerror(errno));
-	}
 }
 
+std::string OptionsFile::getOptionsPath() const {
+	return settingsPath;
+}
+void OptionsFile::save(const StringVector& settings) {
+    FILE* pFile = fopen(settingsPath.c_str(), "w");
+
+    if (!pFile && errno == ENOENT) {
+        std::string dir = settingsPath;
+        size_t fpos = dir.find_last_of("/\\");
+        if (fpos != std::string::npos) {
+            dir.resize(fpos);
+
+            std::string toCreate;
+            for (size_t i = 0; i <= dir.size(); ++i) {
+                if (i == dir.size() || dir[i] == '/' || dir[i] == '\\') {
+                    if (!toCreate.empty()) {
+#if defined(_WIN32)
+                        _mkdir(toCreate.c_str());
+#else
+                        mkdir(toCreate.c_str(), 0755);
+#endif
+                    }
+                }
+                if (i < dir.size())
+                    toCreate.push_back(dir[i]);
+            }
+        }
+
+        pFile = fopen(settingsPath.c_str(), "w");
+    }
+
+    if (!pFile) {
+        LOGI("OptionsFile::save failed: %s", strerror(errno));
+        return;
+    }
+
+    for (const auto& s : settings) {
+        fprintf(pFile, "%s\n", s.c_str());
+    }
+
+    fclose(pFile);
+}
+
+
 StringVector OptionsFile::getOptionStrings() {
 	StringVector returnVector;
 	FILE* pFile = fopen(settingsPath.c_str(), "r");
@@ -45,7 +89,8 @@ StringVector OptionsFile::getOptionStrings() {
 		}
 		fclose(pFile);
 	} else {
-		LOGI("OptionsFile::getOptionStrings failed to open '%s' for reading: %s", settingsPath.c_str(), strerror(errno));
+		if (errno != ENOENT)
+			LOGI("OptionsFile::getOptionStrings failed to open '%s' for reading: %s", settingsPath.c_str(), strerror(errno));
 	}
 	return returnVector;
 }

src/client/OptionsFile.h

@@ -11,6 +11,8 @@ public:
 	OptionsFile();
     void save(const StringVector& settings);
 	StringVector getOptionStrings();
+	void setOptionsPath(const std::string& path);
+	std::string getOptionsPath() const;
 
 private:
 	std::string settingsPath;

src/client/User.h

@@ -1,62 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT__User_H__
-#define NET_MINECRAFT_CLIENT__User_H__
-
-//package net.minecraft.client;
-
-#include "../world/level/tile/Tile.h"
-
-class User
-{
-public:
-    //static List<Tile> allowedTiles = /*new*/ ArrayList<Tile>();
-
-    //static {
-    //    allowedTiles.push_back(Tile::rock);
-    //    allowedTiles.push_back(Tile::stoneBrick);
-    //    allowedTiles.push_back(Tile::redBrick);
-    //    allowedTiles.push_back(Tile::dirt);
-    //    allowedTiles.push_back(Tile::wood);
-    //    allowedTiles.push_back(Tile::treeTrunk);
-    //    allowedTiles.push_back(Tile::leaves);
-    //    allowedTiles.push_back(Tile::torch);
-    //    allowedTiles.push_back(Tile::stoneSlabHalf);
-
-    //    allowedTiles.push_back(Tile::glass);
-    //    allowedTiles.push_back(Tile::mossStone);
-    //    allowedTiles.push_back(Tile::sapling);
-    //    allowedTiles.push_back(Tile::flower);
-    //    allowedTiles.push_back(Tile::rose);
-    //    allowedTiles.push_back(Tile::mushroom1);
-    //    allowedTiles.push_back(Tile::mushroom2);
-    //    allowedTiles.push_back(Tile::sand);
-    //    allowedTiles.push_back(Tile::gravel);
-    //    allowedTiles.push_back(Tile::sponge);
-
-    //    allowedTiles.push_back(Tile::cloth);
-    //    allowedTiles.push_back(Tile::coalOre);
-    //    allowedTiles.push_back(Tile::ironOre);
-    //    allowedTiles.push_back(Tile::goldOre);
-    //    allowedTiles.push_back(Tile::ironBlock);
-    //    allowedTiles.push_back(Tile::goldBlock);
-    //    allowedTiles.push_back(Tile::bookshelf);
-    //    allowedTiles.push_back(Tile::tnt);
-    //    allowedTiles.push_back(Tile::obsidian);
-
-    //    // System.out.println(allowedTiles.size());
-    //}
-
-	static bool isTileAllowed(const Tile& tile) {
-		return true;
-	}
-
-    std::string name;
-    std::string sessionId;
-    //std::string mpPassword;
-
-    User(const std::string& name, const std::string& sessionId) {
-        this->name = name;
-        this->sessionId = sessionId;
-    }
-};
-
-#endif /*NET_MINECRAFT_CLIENT__User_H__*/

src/client/gamemode/GameMode.cpp

@@ -5,6 +5,7 @@
 #include "../../world/level/Level.h"
 #include "../../world/item/ItemInstance.h"
 #include "../player/LocalPlayer.h"
+#include "client/Options.h"
 #ifndef STANDALONE_SERVER
 #include "../sound/SoundEngine.h"
 #include "../particle/ParticleEngine.h"
@@ -27,7 +28,7 @@ GameMode::GameMode( Minecraft* minecraft)
 
 /*virtual*/
 Player* GameMode::createPlayer(Level* level) {
-    return new LocalPlayer(minecraft, level, minecraft->user, level->dimension->id, isCreativeType());
+    return new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreativeType());
 }
 
 /*virtual*/

src/client/gui/Font.cpp

@@ -186,7 +186,7 @@ void Font::draw( const std::string& str, float x, float y, int color, bool darke
 	glPushMatrix2();
 	glTranslatef2((GLfloat)x, (GLfloat)y, 0.0f);
 	for (unsigned int i = 0; i < str.length(); i++) {
-		while (str.length() > i + 1 && str[i] == '<EFBFBD>') {
+		while (str.length() > i + 1 && str[i] == '\xa7') {
 			int cc = hex.find((char)tolower(str[i + 1]));
 			if (cc < 0 || cc > 15) cc = 15;
 			lists[index++] = listPos + 256 + cc + (darken ? 16 : 0);
@@ -235,7 +235,7 @@ int Font::width( const std::string& str )
 	int len = 0;
 
 	for (unsigned int i = 0; i < str.length(); i++) {
-		if (str[i] == '<EFBFBD>') {
+		if (str[i] == '\xa7') {
 			i++;
 		} else {
 			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
@@ -274,7 +274,7 @@ std::string Font::sanitize( const std::string& str )
 	int j = 0;
 
 	for (unsigned int i = 0; i < str.length(); i++) {
-		if (str[i] == '<EFBFBD>') {
+		if (str[i] == '\xa7') {
 			i++;
 			//} else if (SharedConstants.acceptableLetters.indexOf(str.charAt(i)) >= 0) {
 		} else {

src/client/gui/Gui.cpp

@@ -27,6 +27,7 @@
 #include "../../platform/time.h"
 #include <cmath>
 #include <algorithm>
+#include <sstream>
 
 float Gui::InvGuiScale = 1.0f / 3.0f;
 float Gui::GuiScale = 1.0f / Gui::InvGuiScale;
@@ -429,9 +430,9 @@ void Gui::onConfigChanged( const Config& c ) {
 	// Create outer feedback circle
 	//
 #ifdef ANDROID
-	const float mm = 12;
+	const float mm = 50; //20
 #else
-	const float mm = 12;
+	const float mm = 50; //20
 #endif
 	const float maxRadius = minecraft->pixelCalcUi.millimetersToPixels(mm);
 	const float radius = Mth::Min(80.0f/2, maxRadius);
@@ -841,7 +842,9 @@ void Gui::renderPlayerList(Font* font, int screenWidth, int screenHeight) {
 	}
 
 	// player count title
-	std::string titleText = "Players (" + std::to_string(playerNames.size()) + ")";
+	std::ostringstream titleStream;
+	titleStream << "Players (" << playerNames.size() << ")";
+	std::string titleText = titleStream.str();
 	float titleWidth = font->width(titleText);
 
 	if (titleWidth > maxNameWidth)

src/client/gui/components/OptionsGroup.cpp

@@ -65,7 +65,7 @@ void OptionsGroup::createToggle(OptionId optId, Minecraft* minecraft ) {
 	
 	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
 	
-	OptionsItem* item = new OptionsItem(itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
 	
 	addChild(item);
 	setupPositions();
@@ -77,7 +77,7 @@ void OptionsGroup::createProgressSlider(OptionId optId, Minecraft* minecraft ) {
 	element->height = 20;
 
 	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
 	addChild(item);
 	setupPositions();
 }
@@ -87,7 +87,7 @@ void OptionsGroup::createStepSlider(OptionId optId, Minecraft* minecraft ) {
 	element->width = 100;
 	element->height = 20;
 	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
 	addChild(item);
 	setupPositions();
 }
@@ -98,7 +98,7 @@ void OptionsGroup::createTextbox(OptionId optId, Minecraft* minecraft) {
 	element->height = 20;
 
 	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
 	addChild(item);
 	setupPositions();
 }
@@ -109,7 +109,7 @@ void OptionsGroup::createKey(OptionId optId, Minecraft* minecraft) {
 	element->height = 20;
 
 	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
 	addChild(item);
 	setupPositions();
 }

src/client/gui/components/OptionsItem.cpp

@@ -1,9 +1,11 @@
 #include "OptionsItem.h"
 #include "../../Minecraft.h"
+#include "../../../locale/I18n.h"
 #include "../../../util/Mth.h"
-OptionsItem::OptionsItem( std::string label, GuiElement* element )
+OptionsItem::OptionsItem( OptionId optionId, std::string label, GuiElement* element )
 : GuiElementContainer(false, true, 0, 0, 24, 12),
-  label(label) {
+  m_optionId(optionId),
+  m_label(label) {
 	  addChild(element);
 }
 
@@ -19,6 +21,22 @@ void OptionsItem::setupPositions() {
 
 void OptionsItem::render( Minecraft* minecraft, int xm, int ym ) {
 	int yOffset = (height - 8) / 2;
-	minecraft->font->draw(label, (float)x, (float)y + yOffset, 0x909090, false);
+	std::string text = m_label;
+	if (m_optionId == OPTIONS_GUI_SCALE) {
+		int value = minecraft->options.getIntValue(OPTIONS_GUI_SCALE);
+		std::string scaleText;
+		switch (value) {
+		case 0: scaleText = I18n::get("options.guiScale.auto"); break;
+		case 1: scaleText = I18n::get("options.guiScale.small"); break;
+		case 2: scaleText = I18n::get("options.guiScale.medium"); break;
+		case 3: scaleText = I18n::get("options.guiScale.large"); break;
+		case 4: scaleText = I18n::get("options.guiScale.larger"); break;
+		case 5: scaleText = I18n::get("options.guiScale.largest"); break;
+		default: scaleText = I18n::get("options.guiScale.auto"); break;
+		}
+		text += ": " + scaleText;
+	}
+
+	minecraft->font->draw(text, (float)x, (float)y + yOffset, 0x909090, false);
 	super::render(minecraft, xm, ym);
 }

src/client/gui/components/OptionsItem.h

@@ -15,12 +15,13 @@ class OptionsItem: public GuiElementContainer
 {
 	typedef GuiElementContainer super;
 public:
-	OptionsItem(std::string label, GuiElement* element);
+	OptionsItem(OptionId optionId, std::string label, GuiElement* element);
 	virtual void render(Minecraft* minecraft, int xm, int ym);
 	void setupPositions();
 
 private:
-	std::string label;
+	OptionId m_optionId;
+	std::string m_label;
 };
 
 #endif /*NET_MINECRAFT_CLIENT_GUI_COMPONENTS__OptionsItem_H__*/

src/client/gui/components/Slider.cpp

@@ -2,6 +2,7 @@
 #include "../../Minecraft.h"
 #include "../../renderer/Textures.h"
 #include "../Screen.h"
+#include "../../../locale/I18n.h"
 #include "../../../util/Mth.h"
 #include <algorithm>
 #include <assert.h>
@@ -21,7 +22,7 @@ void Slider::render( Minecraft* minecraft, int xm, int ym ) {
 
 	if (m_numSteps > 2) {
 		int stepDistance = barWidth / (m_numSteps-1);
-		for(int a = 0; a <= m_numSteps; ++a) {
+		for(int a = 0; a < m_numSteps; ++a) {
 			int renderSliderStepPosX = xSliderStart + a * stepDistance + 1;
 			fill(renderSliderStepPosX - 1, ySliderStart - 2, renderSliderStepPosX + 1, ySliderEnd + 2, 0xff606060);
 		}
@@ -64,15 +65,20 @@ SliderFloat::SliderFloat(Minecraft* minecraft, OptionId option)
 SliderInt::SliderInt(Minecraft* minecraft, OptionId option) 
 : Slider(option), m_option(dynamic_cast<OptionInt*>(minecraft->options.getOpt(option)))
 {
-	m_numSteps = m_option->getMax() - m_option->getMin();
+	m_numSteps = m_option->getMax() - m_option->getMin() + 1;
 	m_percentage = float(m_option->get() - m_option->getMin()) / (m_numSteps-1);
 }
 
+void SliderInt::render( Minecraft* minecraft, int xm, int ym ) {
+	Slider::render(minecraft, xm, ym);
+}
+
 void SliderInt::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
 	Slider::mouseReleased(minecraft, x, y, buttonNum);
 
 	if (pointInside(x, y)) {
-		int curStep = Mth::floor(m_percentage * (m_numSteps-1));
+		int curStep = int(m_percentage * (m_numSteps-1) + 0.5f);
+		curStep = Mth::clamp(curStep + m_option->getMin(), m_option->getMin(), m_option->getMax());
 		m_percentage = float(curStep - m_option->getMin()) / (m_numSteps-1);
 
 		minecraft->options.set(m_optId, curStep);

src/client/gui/components/Slider.h

@@ -38,6 +38,7 @@ class SliderInt : public Slider {
 public:
 	SliderInt(Minecraft* minecraft, OptionId option);
 
+	virtual void render( Minecraft* minecraft, int xm, int ym ) override;
 	virtual void mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) override;
 
 protected:

src/client/gui/screens/ConsoleScreen.cpp

@@ -216,8 +216,5 @@ void ConsoleScreen::render(int /*xm*/, int /*ym*/, float /*a*/)
         displayed += '_';
 
     // Placeholder hint when empty
-    if (_input.empty() && (_cursorBlink / 10) % 2 != 0)
+    font->drawShadow(displayed, (float)(boxX0 + 2), (float)(boxY + 2), 0xffffffff);
-        font->drawShadow("Type a message or /command", (float)(boxX0 + 2), (float)(boxY + 2), 0xff606060);
-    else
-        font->drawShadow(displayed, (float)(boxX0 + 2), (float)(boxY + 2), 0xffffffff);
 }

src/client/gui/screens/CreditsScreen.cpp

@@ -37,6 +37,8 @@ void CreditsScreen::init() {
     _lines.push_back("mschiller890");
     _lines.push_back("InviseDivine");
     _lines.push_back("Kolyah35");
+    _lines.push_back("karson");
+    _lines.push_back("deepfriedwaffles");
     _lines.push_back("");
     // avoid color tags around the URL so it isn't mangled by the parser please
     _lines.push_back("Join our Discord server: https://discord.gg/c58YesBxve");

src/client/gui/screens/OptionsScreen.cpp

@@ -9,6 +9,7 @@
 
 #include "../components/ImageButton.h"
 #include "../components/OptionsGroup.h"
+#include "platform/input/Keyboard.h"
 
 OptionsScreen::OptionsScreen()
 	: btnClose(NULL),
@@ -153,18 +154,13 @@ void OptionsScreen::buttonClicked(Button* button) {
 	if (button == btnClose) {
 		minecraft->options.save();
 		minecraft->screenChooser.setScreen(SCREEN_STARTMENU);
-
 	}
 	else if (button->id > 1 && button->id < 7) {
-
 		int categoryButton = button->id - categoryButtons[0]->id;
 		selectCategory(categoryButton);
-
 	}
 	else if (button == btnCredits) {
-
 		minecraft->setScreen(new CreditsScreen());
-
 	}
 }
 
@@ -221,9 +217,6 @@ void OptionsScreen::generateOptionScreens() {
 
 	// // Graphics Pane
 	optionPanes[3]->addOptionItem(OPTIONS_FANCY_GRAPHICS, minecraft)
-		// .addOptionItem(&Options::Option::VIEW_BOBBING, minecraft)
-		// .addOptionItem(&Options::Option::AMBIENT_OCCLUSION, minecraft)
-		// .addOptionItem(&Options::Option::ANAGLYPH, minecraft)
 		.addOptionItem(OPTIONS_LIMIT_FRAMERATE, minecraft)
 		.addOptionItem(OPTIONS_VSYNC, minecraft)
 		.addOptionItem(OPTIONS_RENDER_DEBUG, minecraft)
@@ -232,7 +225,8 @@ void OptionsScreen::generateOptionScreens() {
 		.addOptionItem(OPTIONS_AMBIENT_OCCLUSION, minecraft);
 	
 	optionPanes[4]->addOptionItem(OPTIONS_ALLOW_SPRINT, minecraft)
-		.addOptionItem(OPTIONS_BAR_ON_TOP, minecraft);
+		.addOptionItem(OPTIONS_BAR_ON_TOP, minecraft)
+		.addOptionItem(OPTIONS_RPI_CURSOR, minecraft);
 }
 
 void OptionsScreen::mouseClicked(int x, int y, int buttonNum) {
@@ -254,6 +248,8 @@ void OptionsScreen::mouseReleased(int x, int y, int buttonNum) {
 void OptionsScreen::keyPressed(int eventKey) {
 	if (currentOptionsGroup != NULL)
 		currentOptionsGroup->keyPressed(minecraft, eventKey);
+	if (eventKey == Keyboard::KEY_ESCAPE) 
+		minecraft->options.save();
 	
 	super::keyPressed(eventKey);
 }

src/client/gui/screens/ScreenChooser.cpp

@@ -4,6 +4,7 @@
 #include "JoinGameScreen.h"
 #include "PauseScreen.h"
 #include "RenameMPLevelScreen.h"
+#include "ConsoleScreen.h"
 #include "IngameBlockSelectionScreen.h"
 #include "JoinByIPScreen.h"
 #include "touch/TouchStartMenuScreen.h"
@@ -19,6 +20,7 @@ Screen* ScreenChooser::createScreen( ScreenId id )
 {
 	Screen* screen = NULL;
 
+	// :sob:
 	if (_mc->useTouchscreen()) {
 		switch (id) {
 		case SCREEN_STARTMENU:	     screen = new Touch::StartMenuScreen();	break;
@@ -28,6 +30,7 @@ Screen* ScreenChooser::createScreen( ScreenId id )
 		case SCREEN_PAUSEPREV:	     screen = new PauseScreen(true);	 break;
 		case SCREEN_BLOCKSELECTION:	 screen = new Touch::IngameBlockSelectionScreen();	break;
 		case SCREEN_JOINBYIP:        screen = new JoinByIPScreen(); break;
+		case SCREEN_CONSOLE:		 screen = new ConsoleScreen(); break;
 		case SCREEN_NONE:
 		default:
 			// Do nothing
@@ -42,7 +45,7 @@ Screen* ScreenChooser::createScreen( ScreenId id )
 		case SCREEN_PAUSEPREV:	     screen = new PauseScreen(true);	 break;
 		case SCREEN_BLOCKSELECTION:	 screen = new IngameBlockSelectionScreen();	break;
 		case SCREEN_JOINBYIP:        screen = new JoinByIPScreen(); break;
-
+		case SCREEN_CONSOLE:		 screen = new ConsoleScreen(); break;
 		case SCREEN_NONE:
 		default:
 			// Do nothing

src/client/gui/screens/ScreenChooser.h

@@ -9,7 +9,8 @@ enum ScreenId {
 	SCREEN_PAUSEPREV,
 	SCREEN_SELECTWORLD,
 	SCREEN_BLOCKSELECTION,
-	SCREEN_JOINBYIP
+	SCREEN_JOINBYIP,
+	SCREEN_CONSOLE
 };
 
 class Screen;

src/client/gui/screens/UsernameScreen.cpp

@@ -1,7 +1,6 @@
 #include "UsernameScreen.h"
 #include "StartMenuScreen.h"
 #include "../../Minecraft.h"
-#include "../../User.h"
 #include "../Font.h"
 #include "../components/Button.h"
 #include "../../../platform/input/Keyboard.h"
@@ -75,7 +74,6 @@ void UsernameScreen::buttonClicked(Button* button)
     if (button == &_btnDone && !tUsername.text.empty()) {
         minecraft->options.set(OPTIONS_USERNAME, tUsername.text);
         minecraft->options.save();
-        minecraft->user->name = tUsername.text;
         minecraft->setScreen(NULL); // goes to StartMenuScreen
     }
 }

src/client/gui/screens/touch/TouchSelectWorldScreen.h

@@ -86,21 +86,21 @@ public:
 	SelectWorldScreen();
 	virtual ~SelectWorldScreen();
 
-	virtual void init();
+	virtual void init() override;
-	virtual void setupPositions();
+	virtual void setupPositions() override;
 
-	virtual void tick();
+	virtual void tick() override;
-	virtual void render(int xm, int ym, float a);
+	virtual void render(int xm, int ym, float a) override;
 
 	virtual bool isIndexValid(int index);
-	virtual bool handleBackEvent(bool isDown);
+	virtual bool handleBackEvent(bool isDown) override;
-	virtual void buttonClicked(Button* button);
+	virtual void buttonClicked(Button* button) override;
-	virtual void keyPressed(int eventKey);
+	virtual void keyPressed(int eventKey) override;
 
 	// support for mouse wheel when desktop code uses touch variant
 	virtual void mouseWheel(int dx, int dy, int xm, int ym) override;
 
-	bool isInGameScreen();
+	bool isInGameScreen() override;
 private:
 	void loadLevelSource();
 	std::string getUniqueLevelName(const std::string& level);

src/client/player/LocalPlayer.cpp

@@ -24,12 +24,15 @@
 #include "../../platform/HttpClient.h"
 #include "../../platform/CThread.h"
 #include "../../util/StringUtils.h"
+#include "client/Options.h"
 
 #if defined(_WIN32)
 #include <direct.h>
+#include <sys/stat.h>
 #else
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <errno.h>
 #endif
 
 #ifndef STANDALONE_SERVER
@@ -185,6 +188,33 @@ static bool ensureDirectoryExists(const std::string& path) {
     return _mkdir(path.c_str()) == 0 || errno == EEXIST;
 #else
     struct stat st;
+    if (stat(path.c_str(), &st) == 0 && S_ISDIR(st.st_mode))
+        return true;
+
+    std::string subPath;
+    size_t i = 0;
+    while (i < path.length()) {
+        i = path.find_first_of("/\\", i);
+        if (i == std::string::npos) {
+            subPath = path;
+        } else {
+            subPath = path.substr(0, i);
+        }
+
+        if (!subPath.empty()) {
+            if (stat(subPath.c_str(), &st) != 0) {
+                if (mkdir(subPath.c_str(), 0755) != 0 && errno != EEXIST)
+                    return false;
+            } else if (!S_ISDIR(st.st_mode)) {
+                return false;
+            }
+        }
+
+        if (i == std::string::npos)
+            break;
+        i += 1;
+    }
+
     if (stat(path.c_str(), &st) == 0 && S_ISDIR(st.st_mode))
         return true;
     return mkdir(path.c_str(), 0755) == 0 || errno == EEXIST;
@@ -226,6 +256,7 @@ static void* fetchSkinForPlayer(void* param) {
     std::string skinUrl = getSkinUrlForUsername(player->name);
     if (skinUrl.empty()) {
         LOGW("[Skin] skin URL lookup failed for %s\n", player->name.c_str());
+        player->setTextureName("mob/char.png");
         return NULL;
     }
 
@@ -233,6 +264,7 @@ static void* fetchSkinForPlayer(void* param) {
     std::vector<unsigned char> skinData;
     if (!HttpClient::download(skinUrl, skinData) || skinData.empty()) {
         LOGW("[Skin] download failed for %s\n", skinUrl.c_str());
+        player->setTextureName("mob/char.png");
         return NULL;
     }
 
@@ -242,11 +274,13 @@ static void* fetchSkinForPlayer(void* param) {
         fwrite(skinData.data(), 1, skinData.size(), fp);
         fclose(fp);
         LOGI("[Skin] cached skin to %s\n", cacheFile.c_str());
-    } else {
+
+		player->setTextureName("skins/" + player->name + ".png");
+	} else {
         LOGW("[Skin] failed to write skin cache %s\n", cacheFile.c_str());
+        player->setTextureName("mob/char.png");
     }
 
-    player->setTextureName("skins/" + player->name + ".png");
     return NULL;
 }
 
@@ -287,11 +321,12 @@ static void* fetchCapeForPlayer(void* param) {
         fwrite(capeData.data(), 1, capeData.size(), fp);
         fclose(fp);
         LOGI("[Cape] cached cape to %s\n", cacheFile.c_str());
+
+		player->setCapeTextureName("capes/" + player->name + ".png");
     } else {
         LOGW("[Cape] failed to write cape cache %s\n", cacheFile.c_str());
     }
 
-    player->setCapeTextureName("capes/" + player->name + ".png");
     return NULL;
 }
 
@@ -310,7 +345,7 @@ static bool isJumpable(int tileId) {
 
 } // anonymous namespace
 
-LocalPlayer::LocalPlayer(Minecraft* minecraft, Level* level, User* user, int dimension, bool isCreative)
+LocalPlayer::LocalPlayer(Minecraft* minecraft, Level* level, const std::string& username, int dimension, bool isCreative)
 :	Player(level, isCreative),
 	minecraft(minecraft),
 	input(NULL),
@@ -324,11 +359,15 @@ LocalPlayer::LocalPlayer(Minecraft* minecraft, Level* level, User* user, int dim
 {
 	this->dimension = dimension;
 	_init();
-
 #ifndef STANDALONE_SERVER
-	if (user != NULL && !user->name.empty()) {
+
-		this->name = user->name;
+	if (minecraft->options.getStringValue(OPTIONS_USERNAME).size() != 0) {
+		textureName = "mob/char.png";
+
+		this->name = minecraft->options.getStringValue(OPTIONS_USERNAME);
+		printf("test \n");
 		// Fetch user skin and cape from Mojang servers in the background (avoids blocking the main thread)
+		// TODO: Fix this memory leak
 		new CThread(fetchSkinForPlayer, this);
 		new CThread(fetchCapeForPlayer, this);
 	}
@@ -350,8 +389,8 @@ void LocalPlayer::calculateFlight(float xa, float ya, float za) {
     za = za * flySpeed;
 
 #ifdef ANDROID
-    if (Keyboard::isKeyDown(103)) ya = .2f * minecraft->options.flySpeed;
+    if (Keyboard::isKeyDown(103)) ya = .2f * flySpeed;
-    if (Keyboard::isKeyDown(102)) ya = -.2f * minecraft->options.flySpeed;
+    if (Keyboard::isKeyDown(102)) ya = -.2f * flySpeed;
 #else
     if (Keyboard::isKeyDown(Keyboard::KEY_E)) ya = .2f * flySpeed;
     if (Keyboard::isKeyDown(Keyboard::KEY_Q)) ya = -.2f * flySpeed;

src/client/player/LocalPlayer.h

@@ -4,8 +4,6 @@
 //package net.minecraft.client.player;
 
 #include "input/IMoveInput.h"
-#include "../User.h"
-#include "../../platform/input/Keyboard.h"
 #include "../../util/SmoothFloat.h"
 #include "../../world/entity/player/Player.h"
 
@@ -17,7 +15,7 @@ class LocalPlayer: public Player
 {
 	typedef Player super;
 public:
-	LocalPlayer(Minecraft* minecraft, Level* level, User* user, int dimension, bool isCreative);
+	LocalPlayer(Minecraft* minecraft, Level* level, const std::string& username, int dimension, bool isCreative);
 	~LocalPlayer();
 
 	void _init();

src/client/player/input/XperiaPlayInput.h

@@ -4,6 +4,8 @@
 //package net.minecraft.client.player;
 
 #include "KeyboardInput.h"
+#include "platform/input/Controller.h"
+#include "world/entity/player/Player.h"
 
 // @note: This is just copy-pasted from KeyboardInput right now.
 class XperiaPlayInput: public KeyboardInput

src/client/player/input/touchscreen/TouchInputHolder.h

@@ -426,9 +426,7 @@ public:
 	virtual void onConfigChanged(const Config& c) {
 		_move.onConfigChanged(c);
 		_turnBuild.moveArea = _move.getRectangleArea();
-#ifdef __APPLE__
 		_turnBuild.pauseArea = _move.getPauseRectangleArea();
-#endif
 		_turnBuild.inventoryArea = _mc->gui.getRectangleArea( _mc->options.getBooleanValue(OPTIONS_IS_LEFT_HANDED)? 1 : -1 );
 		_turnBuild.setSensitivity(c.options->getBooleanValue(OPTIONS_IS_JOY_TOUCH_AREA)? 1.8f : 1.0f);
 		((ITurnInput*)&_turnBuild)->onConfigChanged(c);

src/client/player/input/touchscreen/TouchscreenInput.cpp

@@ -9,7 +9,10 @@
 #include "../../../../platform/log.h"
 #include "../../../renderer/Textures.h"
 #include "../../../sound/SoundEngine.h"
+#include "client/gui/screens/ScreenChooser.h"
 
+
+// ARGHHHHHH WHY NOT FUCKING ENUM
 static const int AREA_DPAD_FIRST = 100;
 static const int AREA_DPAD_N = 100;
 static const int AREA_DPAD_S = 101;
@@ -17,6 +20,7 @@ static const int AREA_DPAD_W = 102;
 static const int AREA_DPAD_E = 103;
 static const int AREA_DPAD_C = 104;
 static const int AREA_PAUSE = 105;
+static const int AREA_CHAT = 106;
 
 static int cPressed = 0;
 static int cReleased = 0;
@@ -126,8 +130,8 @@ void TouchscreenInput_TestFps::onConfigChanged(const Config& c) {
     
     // If too large (like playing on Tablet)
     PixelCalc& pc = _minecraft->pixelCalc;
-    if (pc.pixelsToMillimeters(Bw) > 14) {
+    if (pc.pixelsToMillimeters(Bw) > 200) { //14
-        Bw = Bh = pc.millimetersToPixels(14);
+        Bw = Bh = pc.millimetersToPixels(200); //14
     }
 	// temp data
 	float xx;
@@ -158,14 +162,11 @@ void TouchscreenInput_TestFps::onConfigChanged(const Config& c) {
 	xx = BaseX + 2 * Bw; yy = BaseY + Bh;
 	_model.addArea(AREA_DPAD_E, aRight = new RectangleArea(xx, yy, xx+Bw, yy+Bh));
 
-#ifdef __APPLE__
     float maxPixels = _minecraft->pixelCalc.millimetersToPixels(10);
-    float btnSize = Mth::Min(18 * Gui::GuiScale, maxPixels);
+    // float btnSize = Mth::Min(18 * Gui::GuiScale, maxPixels);
-	_model.addArea(AREA_PAUSE, aPause = new RectangleArea(w - 4 - btnSize,
+	float btnSize = pc.millimetersToPixels(50);
-                                                          4,
+	_model.addArea(AREA_PAUSE, aPause = new RectangleArea(w - 4 - btnSize, 4, w - 4, 4 + btnSize));
-                                                          w - 4,
+	_model.addArea(AREA_CHAT,  aChat  = new RectangleArea(w - 8 - btnSize * 2, 4, w - 8 - btnSize, 4 + btnSize));
-                                                          4 + btnSize));
-#endif /* __APPLE__ */
 
 	//rebuild();
 }
@@ -309,14 +310,19 @@ void TouchscreenInput_TestFps::tick( Player* player )
 			setButton = true;
 			xa -= 1;
 		}
-#ifdef __APPLE__
 		else if (areaId == AREA_PAUSE) {
 			if (Multitouch::isReleased(p)) {
                 _minecraft->soundEngine->playUI("random.click", 1, 1);
 				_minecraft->screenChooser.setScreen(SCREEN_PAUSE);
             }
 		}
-#endif /*__APPLE__*/
+		else if (areaId == AREA_CHAT) {
+			if (Multitouch::isReleased(p)) {
+                _minecraft->soundEngine->playUI("random.click", 1, 1);
+				_minecraft->screenChooser.setScreen(SCREEN_CONSOLE);
+            }
+		}
+
 		_buttons[areaId - AREA_DPAD_FIRST] = setButton;
 	}
 
@@ -499,15 +505,14 @@ void TouchscreenInput_TestFps::rebuild() {
 		drawRectangleArea(t, aJump, imageU + imageSize * 4, imageV, (float)imageSize);
 	}
 	
-
-#ifdef __APPLE__
 	if (!_minecraft->screen) {
-		if (isButtonDown(AREA_PAUSE))  t.colorABGR(cPressedPause);
+		t.colorABGR(0xFFFFFFFF);
-		else						   t.colorABGR(cReleasedPause);
+		// if (isButtonDown(AREA_PAUSE))  t.colorABGR(cPressedPause);
+		// else						   t.colorABGR(cReleasedPause);
 		
         drawRectangleArea(t, aPause, 200, 64, 18.0f);
+		drawRectangleArea(t, aChat,  200, 82, 18.0f);
 	}
-#endif /*__APPLE__*/
 //t.end(true, _bufferId);
 	//return;
 

src/client/player/input/touchscreen/TouchscreenInput.h

@@ -61,6 +61,7 @@ private:
 	RectangleArea* aUp;
 	RectangleArea* aDown;
 	RectangleArea* aPause;
+	RectangleArea* aChat;
 	//RectangleArea* aUpJump;
 	RectangleArea* aJump;
 	RectangleArea* aUpLeft;

src/client/renderer/GameRenderer.cpp

@@ -1,4 +1,5 @@
 #include "GameRenderer.h"
+#include "client/Options.h"
 #include "gles.h"
 
 #include "../../util/PerfTimer.h"
@@ -214,12 +215,14 @@ void GameRenderer::render(float a) {
 			glDisable2(GL_SCISSOR_TEST);
 
 		mc->screen->render(xMouse, yMouse, a);
-#ifdef RPI
+
+    mc->platform()->hideCursor(!mc->options.getBooleanValue(OPTIONS_RPI_CURSOR));
+    if (mc->options.getBooleanValue(OPTIONS_RPI_CURSOR))        
 		renderCursor(xMouse, yMouse, mc);
-#endif
+        
-		// Screen might have been removed, so check it again
+	// Screen might have been removed, so check it again
-		if (mc->screen && !mc->screen->isInGameScreen())
+    if (mc->screen && !mc->screen->isInGameScreen())
-			sleepMs(15);
+        sleepMs(15);
     }
 }
 
@@ -655,7 +658,7 @@ void GameRenderer::pick(float a) {
     float range = mc->gameMode->getPickRange();
     bool isPicking = true;
 #ifndef PLATFORM_DESKTOP
-    bool freeform = mc->useTouchscreen()  && !mc->options.isJoyTouchArea;
+    bool freeform = mc->useTouchscreen()  && !mc->options.getBooleanValue(OPTIONS_IS_JOY_TOUCH_AREA);
 #else 
     bool freeform = false;
 #endif

src/client/renderer/Tesselator.cpp

@@ -79,6 +79,9 @@ RenderChunk Tesselator::end( bool useMine, int bufferId )
 	const int o_vertices = vertices;
 
 	if (vertices > 0) {
+		if (p <= 0 || p > maxVertices) { clear(); return RenderChunk(); }
+		int bytes = p * sizeof(VERTEX);
+		if (bytes <= 0) return RenderChunk();
 		if (++vboId >= vboCounts)
 			vboId = 0;
 
@@ -92,9 +95,9 @@ RenderChunk Tesselator::end( bool useMine, int bufferId )
 		bufferId = vboIds[vboId];
 #endif
 		int access = GL_STATIC_DRAW;//(accessMode==ACCESS_DYNAMIC) ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
-		int bytes = p * sizeof(VERTEX);
 		glBindBuffer2(GL_ARRAY_BUFFER, bufferId);
 		glBufferData2(GL_ARRAY_BUFFER, bytes, _varray, access); // GL_STREAM_DRAW
+		
 		totalSize += bytes;
 	
 #ifndef USE_VBO
@@ -264,6 +267,7 @@ void Tesselator::vertex( float x, float y, float z )
 		for (int i = 0; i < 2; i++) {
 
 			const int offs = 3 - i;
+			if (p - offs < 0 || p >= maxVertices) { clear(); return; }
 			VERTEX& src = _varray[p - offs];
 			VERTEX& dst = _varray[p];
 
@@ -287,6 +291,7 @@ void Tesselator::vertex( float x, float y, float z )
 		}
 	}
 
+	if (p < 0 || p >= maxVertices) { clear(); return; }
 	VERTEX& vertex = _varray[p];
 
 	if (hasTexture) {
@@ -377,13 +382,15 @@ void Tesselator::draw()
 	tesselating = false;
 
 	if (vertices > 0) {
+		if (p <= 0 || p > maxVertices) { clear(); return; }
+		int bytes = p * sizeof(VERTEX);
+		if (bytes <= 0) { clear(); return; }
 		if (++vboId >= vboCounts)
 			vboId = 0;
 
 		int bufferId = vboIds[vboId];
 		
 		int access = GL_DYNAMIC_DRAW;//(accessMode==ACCESS_DYNAMIC) ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
-		int bytes = p * sizeof(VERTEX);
 		glBindBuffer2(GL_ARRAY_BUFFER, bufferId);
 		glBufferData2(GL_ARRAY_BUFFER, bytes, _varray, access); // GL_STREAM_DRAW
 

src/client/renderer/entity/HumanoidMobRenderer.h

@@ -19,12 +19,13 @@ public:
 protected:
     void additionalRendering(Mob* mob, float a);
 
-private:
 	HumanoidModel* humanoidModel;
 
 	// Last rotation values for cape smoothing (reduces jitter)
 	float lastCapeXRot;
 	float lastCapeZRot;
+private:
+	// i guess ill keep this just in case seomthing breaks
 };
 
 #endif /*NET_MINECRAFT_CLIENT_RENDERER_ENTITY__HumanoidMobRenderer_H__*/

src/client/renderer/entity/MobRenderer.h

@@ -43,8 +43,8 @@ public:
 protected:
 	void setArmor(Model* armor);
 	Model* getArmor();
+	Model* model; // allows derived renderers to swap models dynamically for skin formats
 private:
-	Model* model;
 	Model* armor;
 };
 

src/client/renderer/entity/PlayerRenderer.cpp

@@ -1,5 +1,6 @@
 #include "PlayerRenderer.h"
 #include "EntityRenderDispatcher.h"
+#include "../Textures.h"
 #include "../../../world/entity/player/Player.h"
 #include "../../../world/level/Level.h"
 #include "../../../world/item/ArmorItem.h"
@@ -14,12 +15,22 @@ static const std::string armorFilenames[10] = {
 
 PlayerRenderer::PlayerRenderer( HumanoidModel* humanoidModel, float shadow )
 :	super(humanoidModel, shadow),
+	playerModel64(humanoidModel),
+	playerModel32(new HumanoidModel(0, 0, 64, 32)),
 	armorParts1(new HumanoidModel(1.0f, 0, 64, 64)),
 	armorParts2(new HumanoidModel(0.5f, 0, 64, 64))
 {
+	// default to legacy skin path until we know the exact texture size
+	model = playerModel32;
+	humanoidModel = playerModel32;
 }
 
 PlayerRenderer::~PlayerRenderer() {
+	// prevent MobRenderer destructor from deleting model pointers we manage manually
+	model = nullptr;
+
+	delete playerModel32;
+	delete playerModel64;
 	delete armorParts1;
 	delete armorParts2;
 }
@@ -43,6 +54,15 @@ void PlayerRenderer::setupRotations( Entity* mob, float bob, float bodyRot, floa
 	super::setupRotations(mob, bob, bodyRot, a);
 }
 
+bool PlayerRenderer::isModernPlayerSkin(Mob* mob) {
+	const std::string texName = mob->getTexture();
+	TextureId texId = entityRenderDispatcher->textures->loadTexture(texName);
+	if (!Textures::isTextureIdValid(texId))
+		return false;
+	const TextureData* texData = entityRenderDispatcher->textures->getTemporaryTextureData(texId);
+	return texData && texData->w == 64 && texData->h == 64;
+}
+
 void PlayerRenderer::renderName( Mob* mob, float x, float y, float z ){
 	//@todo: figure out how to handle HideGUI
 	if (mob != entityRenderDispatcher->cameraEntity && mob->level->adventureSettings.showNameTags) {
@@ -50,6 +70,20 @@ void PlayerRenderer::renderName( Mob* mob, float x, float y, float z ){
 	}
 }
 
+void PlayerRenderer::render(Entity* mob_, float x, float y, float z, float rot, float a) {
+	Mob* mob = (Mob*) mob_;
+	HumanoidModel* desired = isModernPlayerSkin(mob) ? playerModel64 : playerModel32;
+	if (model != desired || humanoidModel != desired) {
+		model = desired;
+		humanoidModel = desired;
+	}
+	// LOGI("[PlayerRenderer] %s: skin=%s, modelTex=%dx%d, desired=%s\n", 
+	// 	((Player*)mob)->name.c_str(), mob->getTexture().c_str(), 
+	// 	humanoidModel->texWidth, humanoidModel->texHeight,
+	// 	(desired == playerModel64 ? "64" : "32"));
+	HumanoidMobRenderer::render(mob_, x, y, z, rot, a);
+}
+
 int PlayerRenderer::prepareArmor(Mob* mob, int layer, float a) {
 	Player* player = (Player*) mob;
 
@@ -80,8 +114,11 @@ int PlayerRenderer::prepareArmor(Mob* mob, int layer, float a) {
 }
 
 void PlayerRenderer::onGraphicsReset() {
-	super::onGraphicsReset();
+	if (playerModel32) playerModel32->onGraphicsReset();
+	if (playerModel64) playerModel64->onGraphicsReset();
 
 	if (armorParts1) armorParts1->onGraphicsReset();
 	if (armorParts2) armorParts2->onGraphicsReset();
+
+	super::onGraphicsReset();
 }

src/client/renderer/entity/PlayerRenderer.h

@@ -11,6 +11,8 @@ public:
 	~PlayerRenderer();
 
 	virtual int prepareArmor(Mob* mob, int layer, float a);
+	bool isModernPlayerSkin(Mob* mob);
+	virtual void render(Entity* mob, float x, float y, float z, float rot, float a);
 
 	virtual void setupPosition(Entity* mob, float x, float y, float z);
 	virtual void setupRotations(Entity* mob, float bob, float bodyRot, float a);
@@ -18,6 +20,8 @@ public:
 	virtual void renderName(Mob* mob, float x, float y, float z);
 	virtual void onGraphicsReset();
 private:
+	HumanoidModel* playerModel32;
+	HumanoidModel* playerModel64;
 	HumanoidModel* armorParts1;
 	HumanoidModel* armorParts2;
 };

src/client/renderer/gles.cpp

@@ -47,9 +47,13 @@ void glInit()
 }
 
 void anGenBuffers(GLsizei n, GLuint* buffers) {
-	static GLuint k = 1;
+#ifdef __EMSCRIPTEN__
-	for (int i = 0; i < n; ++i)
+    glGenBuffers(n, buffers);
-		buffers[i] = ++k;
+#else
+    static GLuint k = 1;
+    for (int i = 0; i < n; ++i)
+        buffers[i] = ++k;
+#endif
 }
 
 #ifdef USE_VBO

src/client/renderer/gles.h

@@ -10,13 +10,13 @@
 #endif
 
 // Other systems might run it, if they #define OPENGL_ES
-#if defined(OPENGL_ES) // || defined(ANDROID)
+// #if defined(OPENGL_ES) // || defined(ANDROID)
 	#define USE_VBO
 	#define GL_QUADS 0x0007
     #if defined(__APPLE__)
         #import <OpenGLES/ES1/gl.height>
         #import <OpenGLES/ES1/glext.height>
-    #elif defined(ANDROID)
+    #elif defined(ANDROID) || defined(__EMSCRIPTEN__)
         #include <GLES/gl.h>
         #include <GLES/glext.h>
     #else
@@ -28,18 +28,18 @@
 		#define glClearDepthf(x)        glClearDepth(x)
 		#define glDepthRangef(a,b)      glDepthRange(a,b)
     #endif
-#else
+// #else
-    // Uglyness to fix redeclaration issues
+//     // Uglyness to fix redeclaration issues
-    #ifdef WIN32
+//     #ifdef WIN32
-	   #include <WinSock2.h>
+// 	   #include <winsock2.h>
-	   #include <Windows.h>
+// 	   #include <Windows.h>
-	#endif
+// 	#endif
-	#include <gl/glew.h>
+// 	#include <gl/glew.h>
-	#include <gl/GL.h>
+// 	#include <gl/GL.h>
 
-	#define glFogx(a,b)	glFogi(a,b)
+// 	#define glFogx(a,b)	glFogi(a,b)
-	#define glOrthof(a,b,c,d,e,f) glOrtho(a,b,c,d,e,f)
+// 	#define glOrthof(a,b,c,d,e,f) glOrtho(a,b,c,d,e,f)
-#endif
+// #endif
 
 
 #define GLERRDEBUG 1

src/main.cpp

@@ -22,12 +22,12 @@
 #include "NinecraftApp.h"
 #define MAIN_CLASS NinecraftApp
 
-#ifdef PLATFORM_WINDOWS
+// #ifdef PLATFORM_WINDOWS
-	#include "main_win32.h"
+// 	#include "main_win32.h"
-#endif
+// #endif
 
 
-#ifdef PLATFORM_GLFW
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
     #include "main_glfw.h"
 #endif
 

src/main_android.cpp

@@ -25,12 +25,33 @@ static void setupExternalPath(struct android_app* state, MAIN_CLASS* app)
     {
         LOGI("Environment exists");
     }
-    jclass clazz = env->FindClass("android/os/Environment");
+    // try appspecific external directory first
-    jmethodID method = env->GetStaticMethodID(clazz, "getExternalStorageDirectory", "()Ljava/io/File;");
+    jobject activity = state->activity->clazz;
-    if (env->ExceptionOccurred()) {
+    jclass activityClass = env->GetObjectClass(activity);
-        env->ExceptionDescribe();
+    jmethodID getExternalFilesDir = env->GetMethodID(activityClass, "getExternalFilesDir", "(Ljava/lang/String;)Ljava/io/File;");
+
+    jobject file = NULL;
+    if (getExternalFilesDir != NULL) {
+        file = env->CallObjectMethod(activity, getExternalFilesDir, NULL);
+    }
+
+    if (file == NULL) {
+        // Fallback to the legacy shared storage directory
+        jclass clazz = env->FindClass("android/os/Environment");
+        jmethodID method = env->GetStaticMethodID(clazz, "getExternalStorageDirectory", "()Ljava/io/File;");
+        if (env->ExceptionOccurred()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+        }
+        file = env->CallStaticObjectMethod(clazz, method);
+    }
+
+    if (!file) {
+        LOGI("Failed to get external storage file object, using current working dir");
+        app->externalStoragePath = ".";
+        app->externalCacheStoragePath = ".";
+        return;
     }
-    jobject file = env->CallStaticObjectMethod(clazz, method);
 
     jclass fileClass = env->GetObjectClass(file);
     jmethodID fileMethod = env->GetMethodID(fileClass, "getAbsolutePath", "()Ljava/lang/String;");
@@ -38,7 +59,7 @@ static void setupExternalPath(struct android_app* state, MAIN_CLASS* app)
 
     const char* str = env->GetStringUTFChars((jstring) pathString, NULL);
     app->externalStoragePath = str;
-	app->externalCacheStoragePath = str;
+    app->externalCacheStoragePath = str;
     LOGI("%s", str);
 
     // ensure the process working directory is set to a writable location

src/main_android.h

@@ -25,7 +25,7 @@
 #include "platform/input/Mouse.h"
 #include "platform/input/Multitouch.h"
 
-#include "EGLConfigPrinter.h"
+#include "EglConfigPrinter.h"
 
 const int BroadcastPort = 9991;
 

src/main_android_java.cpp

@@ -7,8 +7,7 @@
 //#include "main_android_java.h"
 #include "platform/input/Multitouch.h"
 #include <unistd.h>
-#include <sys/syscall.h>
+#include <pthread.h>
-#define gettid() ((int)syscall(SYS_gettid))
 
 // Horrible, I know. / A
 #ifndef MAIN_CLASS
@@ -31,12 +30,33 @@ static void setupExternalPath(JNIEnv* env, MAIN_CLASS* app)
     {
         LOGI("Environment exists");
     }
-    jclass clazz = env->FindClass("android/os/Environment");
+    // try appspecific external directory first
-    jmethodID method = env->GetStaticMethodID(clazz, "getExternalStorageDirectory", "()Ljava/io/File;");
+    jobject activity = g_pActivity;
-    if (env->ExceptionOccurred()) {
+    jclass activityClass = env->GetObjectClass(activity);
-        env->ExceptionDescribe();
+    jmethodID getExternalFilesDir = env->GetMethodID(activityClass, "getExternalFilesDir", "(Ljava/lang/String;)Ljava/io/File;");
+
+    jobject file = NULL;
+    if (getExternalFilesDir != NULL) {
+        file = env->CallObjectMethod(activity, getExternalFilesDir, NULL);
+    }
+
+    if (file == NULL) {
+        // Fallback to the legacy shared storage directory
+        jclass clazz = env->FindClass("android/os/Environment");
+        jmethodID method = env->GetStaticMethodID(clazz, "getExternalStorageDirectory", "()Ljava/io/File;");
+        if (env->ExceptionOccurred()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+        }
+        file = env->CallStaticObjectMethod(clazz, method);
+    }
+
+    if (!file) {
+        LOGI("Failed to get external storage file object, using current working dir");
+        app->externalStoragePath = ".";
+        app->externalCacheStoragePath = ".";
+        return;
     }
-    jobject file = env->CallStaticObjectMethod(clazz, method);
 
     jclass fileClass = env->GetObjectClass(file);
     jmethodID fileMethod = env->GetMethodID(fileClass, "getAbsolutePath", "()Ljava/lang/String;");
@@ -44,7 +64,7 @@ static void setupExternalPath(JNIEnv* env, MAIN_CLASS* app)
 
     const char* str = env->GetStringUTFChars((jstring) pathString, NULL);
     app->externalStoragePath = str;
-	app->externalCacheStoragePath = str;
+    app->externalCacheStoragePath = str;
     LOGI("%s", str);
 
     // same fix as the native entry point: make sure cwd is writable
@@ -145,7 +165,7 @@ Java_com_mojang_minecraftpe_GLRenderer_nativeOnSurfaceCreated(JNIEnv* env) {
 
 JNIEXPORT void JNICALL
 Java_com_mojang_minecraftpe_GLRenderer_nativeOnSurfaceChanged(JNIEnv* env, jclass cls, jint w, jint h) {
-    LOGI("@nativeOnSurfaceChanged: %p\n", pthread_self());
+    LOGI("@nativeOnSurfaceChanged: %lu\n", (unsigned long)pthread_self());
 
     if (gApp) {
         gApp->setSize(w, h);

src/main_android_java.h

@@ -23,7 +23,7 @@
 #include "platform/input/Mouse.h"
 #include "platform/input/Controller.h"
 
-#include "EGLConfigPrinter.h"
+#include "EglConfigPrinter.h"
 
 const int BroadcastPort = 9991;
 

src/main_glfw.h

@@ -2,9 +2,9 @@
 #define MAIN_GLFW_H__
 
 #include "App.h"
-#include "GLFW/glfw3.h"
+#include "client/renderer/entity/PlayerRenderer.h"
 #include "client/renderer/gles.h"
-#include "SharedConstants.h"
+#include "GLFW/glfw3.h"
 
 #include <cstdio>
 #include <chrono>
@@ -12,9 +12,10 @@
 #include "platform/input/Keyboard.h"
 #include "platform/input/Mouse.h"
 #include "platform/input/Multitouch.h"
-#include "util/Mth.h"
 #include "AppPlatform_glfw.h"
-
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
 static App* g_app = 0;
 
 int transformKey(int glfwkey) {
@@ -112,12 +113,39 @@ void error_callback(int error, const char* desc) {
 	printf("Error: %s\n", desc);
 }
 
+
+void loop() {
+	using clock = std::chrono::steady_clock;
+	auto frameStart = clock::now();
+
+	g_app->update();
+
+	glfwSwapBuffers(((AppPlatform_glfw*)g_app->platform())->window);
+	glfwPollEvents();
+
+	glfwSwapInterval(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_VSYNC) ? 1 : 0);
+	if(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_LIMIT_FRAMERATE)) {
+		auto frameEnd = clock::now();
+		auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(frameEnd - frameStart);
+		auto target = std::chrono::microseconds(33333); // ~30 fps
+		if(elapsed < target)
+			std::this_thread::sleep_for(target - elapsed);
+	}
+}
+
 int main(void) {
 	AppContext appContext;
 
 #ifndef STANDALONE_SERVER
 	// Platform init.
 	appContext.platform = new AppPlatform_glfw();
+#if defined(DEBUG) && defined(__EMSCRIPTEN__)
+	EM_ASM({
+		console.log(FS.readdir("/"));
+		console.log(FS.readdir("/data"));
+		console.log(FS.readdir("/data/images"));
+	});
+#endif
 
 	glfwSetErrorCallback(error_callback);
 
@@ -126,26 +154,36 @@ int main(void) {
 	}
 
 	glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
+#ifndef __EMSCRIPTEN__
 	glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
+#else
+	glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+#endif
 
-	GLFWwindow* window = glfwCreateWindow(appContext.platform->getScreenWidth(), appContext.platform->getScreenHeight(), "main", NULL, NULL);
+	AppPlatform_glfw* platform = (AppPlatform_glfw*)appContext.platform;
 
-	if (window == NULL) {
+	platform->window = glfwCreateWindow(appContext.platform->getScreenWidth(), appContext.platform->getScreenHeight(), "Minecraft PE 0.6.1", NULL, NULL);
+	
+	if (platform->window == NULL) {
 		return 1;
 	}
 
-	glfwSetKeyCallback(window, key_callback);
+	glfwSetKeyCallback(platform->window, key_callback);
-	glfwSetCharCallback(window, character_callback);
+	glfwSetCharCallback(platform->window, character_callback);
-	glfwSetCursorPosCallback(window, cursor_position_callback);
+	glfwSetCursorPosCallback(platform->window, cursor_position_callback);
-	glfwSetMouseButtonCallback(window, mouse_button_callback);
+	glfwSetMouseButtonCallback(platform->window, mouse_button_callback);
-	glfwSetScrollCallback(window, scroll_callback);
+	glfwSetScrollCallback(platform->window, scroll_callback);
-	glfwSetWindowSizeCallback(window, window_size_callback);
+	glfwSetWindowSizeCallback(platform->window, window_size_callback);
 
-	glfwMakeContextCurrent(window);
+	glfwMakeContextCurrent(platform->window);
+	#ifndef __EMSCRIPTEN__
 	gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
 	glfwSwapInterval(0);
+	#endif
 #endif
 
 	App* app = new MAIN_CLASS();
@@ -156,38 +194,27 @@ int main(void) {
 	g_app->init(appContext);
 	g_app->setSize(appContext.platform->getScreenWidth(), appContext.platform->getScreenHeight());
 
+#ifdef __EMSCRIPTEN__
+	emscripten_set_main_loop(loop, 0, 1);
+#else
 	// Main event loop
-	using clock = std::chrono::steady_clock;
+	while(!glfwWindowShouldClose(platform->window) && !app->wantToQuit()) {
-	while(!glfwWindowShouldClose(window) && !app->wantToQuit()) {
+		loop();
-		auto frameStart = clock::now();
-
-		app->update();
-
-		glfwSwapBuffers(window);
-		glfwPollEvents();
-
-		glfwSwapInterval(((MAIN_CLASS*)app)->options.getBooleanValue(OPTIONS_VSYNC) ? 1 : 0);
-		if(((MAIN_CLASS*)app)->options.getBooleanValue(OPTIONS_LIMIT_FRAMERATE)) {
-			auto frameEnd = clock::now();
-			auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(frameEnd - frameStart);
-			auto target = std::chrono::microseconds(33333); // ~30 fps
-			if(elapsed < target)
-				std::this_thread::sleep_for(target - elapsed);
-		}
 	}
+#endif
 
 	delete app;
 
+#ifndef STANDALONE_SERVER
+	// Exit.
+	glfwDestroyWindow(platform->window);
+	glfwTerminate();
+#endif
+
 	appContext.platform->finish();
 	
 	delete appContext.platform;
 
-#ifndef STANDALONE_SERVER
-	// Exit.
-	glfwDestroyWindow(window);
-	glfwTerminate();
-#endif
-
 	return 0;
 }
 

src/main_win32.h

@@ -14,7 +14,7 @@
 #include <windows.h>
 #include <windowsx.h>
 
-#include <WinSock2.h>
+#include <winsock2.h>
 #include <process.h>
 #include "SharedConstants.h"
 

src/network/ClientSideNetworkHandler.cpp

@@ -1,5 +1,6 @@
 
 #include "ClientSideNetworkHandler.h"
+#include "client/Options.h"
 #include "packet/PacketInclude.h"
 #include "RakNetInstance.h"
 #include "../world/level/chunk/ChunkSource.h"
@@ -85,7 +86,7 @@ void ClientSideNetworkHandler::onConnect(const RakNet::RakNetGUID& hostGuid)
 	serverGuid = hostGuid;
 
 	clearChunksLoaded();
-	LoginPacket packet(minecraft->user->name.c_str(), SharedConstants::NetworkProtocolVersion);
+	LoginPacket packet(minecraft->options.getStringValue(OPTIONS_USERNAME).c_str(), SharedConstants::NetworkProtocolVersion);
 	raknetInstance->send(packet);
 }
 
@@ -157,7 +158,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, StartGam
 	level->isClientSide = true;
 
 	bool isCreative = (packet->gameType == GameType::Creative);
-	LocalPlayer* player = new LocalPlayer(minecraft, level, minecraft->user, level->dimension->id, isCreative);
+	LocalPlayer* player = new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreative);
 	player->owner = rakPeer->GetMyGUID();
 	player->entityId = packet->entityId;
 	player->moveTo(packet->x, packet->y, packet->z, player->yRot, player->xRot);

src/network/ServerSideNetworkHandler.h

@@ -66,7 +66,9 @@ public:
 
 	void displayGameMessage(const std::string& message);
 private:
-
+	/**
+	 * @brief Send packet to all players
+	 */
 	void redistributePacket(Packet* packet, const RakNet::RakNetGUID& fromPlayer);
 	Player* getPlayer(const RakNet::RakNetGUID& source);
 

src/network/command/CommandServer.h

@@ -5,7 +5,7 @@
 #include <vector>
 
 #ifdef WIN32
-	#include <WinSock2.h>
+	#include <winsock2.h>
 #else
 	#include <sys/socket.h>
 	#include <netinet/in.h>

src/platform/CThread.cpp

@@ -25,7 +25,7 @@
 			&m_threadID        // pointer to receive thread ID
 		);
 	#endif
-	#if defined(__linux__) || defined(ANDROID) || defined(__APPLE__) || defined(POSIX)
+	#if defined(__linux__) || defined(ANDROID) || defined(__APPLE__) || defined(POSIX) || defined(__EMSCRIPTEN__)
 		mp_threadFunc = (pthread_fn)threadFunc;
 
 		pthread_attr_init(&m_attributes);

src/platform/CThread.h

@@ -13,7 +13,7 @@
 
 typedef void *( * pthread_fn )( void * );
 
-#if defined(__linux__) || defined(ANDROID) || defined(__APPLE__) || defined(POSIX)
+#if defined(__linux__) || defined(ANDROID) || defined(__APPLE__) || defined(POSIX) || defined(__EMSCRIPTEN__)
 	#include <pthread.h>
 	#include <unistd.h>
 
@@ -38,7 +38,7 @@ typedef void *( * pthread_fn )( void * );
 		DWORD						m_threadID;
 		HANDLE						m_threadHandle;
 	#endif
-	#if defined(__linux__) || defined(ANDROID) || defined(__APPLE__) || defined(POSIX)
+	#if defined(__linux__) || defined(ANDROID) || defined(__APPLE__) || defined(POSIX) || defined(__EMSCRIPTEN__)
 		pthread_fn					mp_threadFunc;
 		pthread_t					m_thread;
 		pthread_attr_t				m_attributes;

src/platform/PngLoader.cpp

@@ -10,6 +10,7 @@ struct MemoryReader {
 };
 
 static void pngMemoryRead(png_structp pngPtr, png_bytep outBytes, png_size_t byteCountToRead) {
+#ifndef STANDALONE_SERVER
     MemoryReader* reader = (MemoryReader*)png_get_io_ptr(pngPtr);
     if (!reader)
         return;
@@ -21,10 +22,12 @@ static void pngMemoryRead(png_structp pngPtr, png_bytep outBytes, png_size_t byt
 
     memcpy(outBytes, reader->data + reader->pos, byteCountToRead);
     reader->pos += byteCountToRead;
+#endif
 }
 
 TextureData loadPngFromMemory(const unsigned char* data, size_t size) {
     TextureData out;
+#ifndef STANDALONE_SERVER
     if (!data || size == 0) return out;
 
     png_structp pngPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
@@ -89,6 +92,7 @@ TextureData loadPngFromMemory(const unsigned char* data, size_t size) {
 
     png_destroy_read_struct(&pngPtr, &infoPtr, NULL);
     delete[] rowPtrs;
+#endif
 
     return out;
 }

src/raknet/GetTime.cpp

@@ -140,7 +140,9 @@ RakNet::TimeUS GetTimeUS_Windows( void )
 #if _MSC_VER >= 1400 && defined (_M_X64)
 		GetProcessAffinityMask(mProc, (PDWORD_PTR)&mProcMask, (PDWORD_PTR)&mSysMask);
 #else
+#ifndef __MINGW32__
 		GetProcessAffinityMask(mProc, &mProcMask, &mSysMask);
+#endif
 #endif
 		mThread = GetCurrentThread();
 

src/raknet/WindowsIncludes.h

@@ -1,8 +1,8 @@
 #if defined(X360__) 
 #elif defined (_WIN32)
-#include <WinSock2.h>
+#include <winsock2.h>
 #include <windows.h>
-#include <Ws2tcpip.h>
+#include <ws2tcpip.h>
 
 // Must always include Winsock2.h before windows.h
 // or else:

src/server/ServerPlayer.cpp

@@ -23,7 +23,7 @@
 ServerPlayer::ServerPlayer( Minecraft* minecraft, Level* level )
 :   super(level, minecraft->isCreativeMode()),
 	_mc(minecraft),
-	_sentHealth(-999),
+	_prevHealth(-999),
 	_containerCounter(0)
 {
 	hasFakeInventory = true;
@@ -58,8 +58,8 @@ void ServerPlayer::tick() {
 	if (containerMenu)
 		containerMenu->broadcastChanges();
 
-	if (health != _sentHealth) {
+	if (health != _prevHealth) {
-		_sentHealth = health;
+		_prevHealth = health;
 		SetHealthPacket packet(health);
 		_mc->raknetInstance->send(owner, packet);
 	}

src/server/ServerPlayer.h

@@ -48,7 +48,7 @@ private:
 	void setContainerMenu( BaseContainerMenu* menu );
 
 	Minecraft* _mc;
-    int _sentHealth;
+    int _prevHealth;
 	int _containerCounter;
 };
 

src/util/Mth.cpp

@@ -9,11 +9,6 @@ static Random _rand;
 
 namespace Mth
 {
-	const float PI = 3.1415926535897932384626433832795028841971f; // exactly!
-	const float TWO_PI = 2.0f * PI; // exactly!
-	const float DEGRAD = PI / 180.0f;
-	const float RADDEG = 180.0f / PI;
-
 	static float _sin[65536];
 	static const float _sinScale = 65536.0f / (2.0f * PI);
 

src/util/Mth.h

@@ -6,11 +6,10 @@
 #include <algorithm>
 
 namespace Mth {
-
+	constexpr float PI = 3.1415926535897932384626433832795028841971f; // exactly!
-	extern const float PI;
+	constexpr float TWO_PI = 2.0f * PI; // exactly!
-	extern const float TWO_PI;
+	constexpr float DEGRAD = PI / 180.0f;
-	extern const float RADDEG;
+	const float RADDEG = 180.0f / PI;
-	extern const float DEGRAD;
 
 	void initMth();
 

src/world/level/storage/ExternalFileLevelStorage.cpp

@@ -7,6 +7,7 @@
 #include "../chunk/LevelChunk.h"
 #include "../Level.h"
 #include "../LevelConstants.h"
+#include "platform/log.h"
 #include "../tile/TreeTile.h"
 #include "../../entity/EntityFactory.h"
 #include "../../../nbt/NbtIo.h"
@@ -289,8 +290,9 @@ bool ExternalFileLevelStorage::readPlayerData(const std::string& filename, Level
 void ExternalFileLevelStorage::tick()
 {
 	tickCount++;
-	if ((tickCount % 50) == 0 && level)
+	if ((tickCount % 1000) == 0 && level) {
-	{
+		LOGI("Saving level...\n");
+
 		// look for chunks that needs to be saved
 		for (int z = 0; z < CHUNK_CACHE_WIDTH; z++)
 		{

src/world/level/tile/DoorTile.h

@@ -25,38 +25,38 @@ public:
 	static const int C_RIGHT_HINGE_MASK = 16;
 
 	DoorTile(int id, const Material* material);
-	int getTexture(LevelSource* level, int x, int y, int z, int face);
+	int getTexture(LevelSource* level, int x, int y, int z, int face) override;
 
 	bool blocksLight();
-    bool isSolidRender();
+    bool isSolidRender() override;
-    bool isCubeShaped();
+    bool isCubeShaped() override;
-    int getRenderShape();
+    int getRenderShape() override;
-	int getRenderLayer();
+	int getRenderLayer() override;
 
-	AABB getTileAABB(Level* level, int x, int y, int z);
+	AABB getTileAABB(Level* level, int x, int y, int z) override;
-    AABB* getAABB(Level* level, int x, int y, int z);
+    AABB* getAABB(Level* level, int x, int y, int z) override;
 
-    void updateShape(LevelSource* level, int x, int y, int z);
+    void updateShape(LevelSource* level, int x, int y, int z) override;
     void setShape(int compositeData);
 
-    void attack(Level* level, int x, int y, int z, Player* player);
+    void attack(Level* level, int x, int y, int z, Player* player) override;
-    bool use(Level* level, int x, int y, int z, Player* player);
+    bool use(Level* level, int x, int y, int z, Player* player) override;
 
     void setOpen(Level* level, int x, int y, int z, bool shouldOpen);
 	static bool isOpen(LevelSource* level, int x, int y, int z);
 
-	void neighborChanged(Level* level, int x, int y, int z, int type);
+	void neighborChanged(Level* level, int x, int y, int z, int type) override;
 
-    int getResource(int data, Random* random);
+    int getResource(int data, Random* random) override;
 
     // override to avoid duplicate drops when upper half is mined directly
     void playerDestroy(Level* level, Player* player, int x, int y, int z, int data) override;
 
-    HitResult clip(Level* level, int xt, int yt, int zt, const Vec3& a, const Vec3& b);
+    HitResult clip(Level* level, int xt, int yt, int zt, const Vec3& a, const Vec3& b) override;
 
     int getDir(LevelSource* level, int x, int y, int z);
 
-    bool mayPlace(Level* level, int x, int y, int z, unsigned char face);
+    bool mayPlace(Level* level, int x, int y, int z, unsigned char face) override;
 
 	static int getCompositeData(LevelSource* level, int x, int y, int z);
 };