.h -> .hpp everything

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

.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,343 @@
+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: Build Windows
+    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/libpng16.dll
+            ${{github.workspace}}/build/OpenAL32.dll
+            ${{github.workspace}}/build/libz.dll
+
+  build-linux:
+    name: Build Linux
+    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 (${{ 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
+
+  build-web:
+    name: Build Web
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup caches
+        uses: ./.github/actions/setup-cache
+        with:
+          host: linux
+          target: linux
+    
+      - name: Setup Ninja
+        uses: ./.github/actions/setup-ninja
+        with:
+          host: linux
+
+      - name: Setup emsdk
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: 5.0.3
+          actions-cache-folder: 'emsdk-cache'
+
+      - 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
+        # 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 -G Ninja -DCMAKE_TOOLCHAIN_FILE="$GITHUB_WORKSPACE/emsdk-cache/emsdk-main/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
+
+      - 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-web
+          path: |
+            ${{github.workspace}}/build/MinecraftPE.js
+            ${{github.workspace}}/build/MinecraftPE.wasm
+            ${{github.workspace}}/build/MinecraftPE.data
+
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    needs: [ build-windows, build-linux, build-android, build-web ]
+    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: mcpe-windows/MinecraftPE.exe mcpe-windows/libpng16.dll mcpe-windows/OpenAL32.dll mcpe-windows/libz.dll
+          dest: minecraftpe-${{ steps.ref.outputs.hash }}-windows.zip
+
+      - name: Zip Linux Artifacts
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: 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: Zip Web Artifact
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: mcpe-web/MinecraftPE.js mcpe-web/MinecraftPE.wasm mcpe-web/MinecraftPE.data misc/web/index.html
+          dest: minecraftpe-${{ steps.ref.outputs.hash }}-web.zip
+
+      - name: Zip Data
+        uses: vimtor/action-zip@v1.2
+        with:
+          files: data
+          recursive: false
+          dest: data.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: |
+            ./data.zip
+            ./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
+            ./minecraftpe-${{ steps.ref.outputs.hash }}-web.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,86 +6,148 @@ 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")
+
+include(cmake/EnumOption.cmake)
+
+if(EMSCRIPTEN)
+    # When configuring web builds with "emcmake cmake -B build -S .", set PLATFORM to Web by default
+    set(PLATFORM Web CACHE STRING "Platform to build for.")
 endif()
 
+enum_option(PLATFORM "Desktop;Web" "Platform to build for.")
+
 find_package(Threads REQUIRED)
-
 find_package(OpenSSL)
-if (OpenSSL_FOUND)
-    message(STATUS "found openssl ${OPENSSL_VERSION}")
+
+if (${PLATFORM} STREQUAL "Desktop")
+    set(PLATFORM_CPP "PLATFORM_DESKTOP")
+
+    if (MINGW)
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc")
+    endif()
+
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++11-narrowing -Wno-narrowing -Wno-invalid-source-encoding -Wno-reserved-user-defined-literal")
+    endif()
+
+    if (WIN32)
+        add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+        include_directories(misc/windows)
+        set(EXTRA_LIBS ws2_32 winhttp)
+    elseif(UNIX)
+        find_library(pthread NAMES pthread)
+        set(EXTRA_LIBS pthread m)
+    endif()
+
+    include_directories("glad/include")
+
+elseif (${PLATFORM} STREQUAL "Web")
+    set(PLATFORM_CPP "PLATFORM_WEB")
+    set(EXTRA_LIBS "idbfs.js")
 endif()
 
-CPMAddPackage("gh:madler/zlib@1.3.2")
-CPMAddPackage(
-    NAME "libpng"
-    GIT_REPOSITORY "https://github.com/pnggroup/libpng.git"
-    GIT_TAG "v1.6.55"
-    EXCLUDE_FROM_ALL TRUE
-    OPTIONS
-        "ZLIB_ROOT ${zlib_SOURCE_DIR}"
-        "ZLIB_INCLUDE_DIRS ${zlib_SOURCE_DIR}"
-        "PNG_TOOLS OFF"
-        "PNG_TESTS OFF"
-        "BUILD_SHARED_LIBS ON"
-)
+# 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_COMPILE_OPTIONS "-sUSE_LIBPNG=1" 
+        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"
-)
-
-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"
+        "LIBTYPE ${AL_LIBTYPE}"
+        "ALSOFT_ENABLE_MODULES OFF"
+        "ALSOFT_STATIC_STDCXX ON"
+        "ALSOFT_STATIC_LIBGCC ON"
 )
 
 # TODO: Clear this paths with *
 file(GLOB SERVER_SOURCES
     "project/lib_projects/raknet/jni/RaknetSources/*.cpp"
-    "src/NinecraftApp.cpp"
     "src/Performance.cpp"
     "src/SharedConstants.cpp"
+    "src/Minecraft.cpp"
+    "src/MinecraftServer.cpp"
+    "src/App.cpp"
+    "src/IPlatform.cpp"
 
-    "src/client/IConfigListener.cpp"
-    "src/client/Minecraft.cpp"
-    "src/client/OptionStrings.cpp"
-    "src/client/Option.cpp"
-    "src/client/Options.cpp"
-    "src/client/OptionsFile.cpp"
-    "src/client/ServerProfiler.cpp"
 
-    "src/client/gamemode/CreativeMode.cpp"
-    "src/client/gamemode/GameMode.cpp"
-    "src/client/gamemode/SurvivalMode.cpp"
+    # "src/client/IConfigListener.cpp"
+    # "src/client/Minecraft.cpp"
+    # "src/client/OptionStrings.cpp"
+    # "src/client/Option.cpp"
+    # "src/client/Options.cpp"
+    # "src/client/OptionsFile.cpp"
+    # "src/client/ServerProfiler.cpp"
 
-    "src/client/player/LocalPlayer.cpp"
-    "src/client/player/RemotePlayer.cpp"
-    "src/client/player/input/KeyboardInput.cpp"
+    # "src/client/gamemode/CreativeMode.cpp"
+    # "src/client/gamemode/GameMode.cpp"
+    # "src/client/gamemode/SurvivalMode.cpp"
+
+    # "src/client/player/LocalPlayer.cpp"
+    # "src/client/player/RemotePlayer.cpp"
+    # "src/client/player/input/KeyboardInput.cpp"
+
+    "src/gamemode/*.cpp"
 
     "src/locale/I18n.cpp"
 
-    "src/main.cpp"
     "src/main_dedicated.cpp"
 
     "src/nbt/Tag.cpp"
 
-    "src/network/ClientSideNetworkHandler.cpp"
     "src/network/NetEventCallback.cpp"
     "src/network/Packet.cpp"
     "src/network/RakNetInstance.cpp"
@@ -96,11 +158,7 @@ file(GLOB SERVER_SOURCES
     "src/platform/HttpClient.cpp"
     "src/platform/PngLoader.cpp"
     "src/platform/time.cpp"
-
-    "src/platform/input/Controller.cpp"
-    "src/platform/input/Keyboard.cpp"
-    "src/platform/input/Mouse.cpp"
-    "src/platform/input/Multitouch.cpp"
+    "src/platform/server/PlatformServer.cpp"
 
     "src/server/ArgumentsSettings.cpp"
     "src/server/ServerLevel.cpp"
@@ -234,50 +292,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)
-    set(PLATFORM "PLATFORM_GLFW")
-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")
+if (${PLATFORM} STREQUAL "Desktop")
+    list(APPEND CLIENT_SOURCES glad/src/glad.c)
 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 
-   "${CMAKE_SOURCE_DIR}/src/"
-   "project/lib_projects/raknet/jni/RaknetSources"
-)
+    target_include_directories("${PROJECT_NAME}-server" PUBLIC 
+        "${CMAKE_SOURCE_DIR}/src/"
+        "project/lib_projects/raknet/jni/RaknetSources"
+    )
 
-target_link_libraries("${PROJECT_NAME}-server" ${CMAKE_THREAD_LIBS_INIT} png_shared)
-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")
+    target_link_libraries("${PROJECT_NAME}-server" ${CMAKE_THREAD_LIBS_INIT})
 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 +327,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 -sUSE_LIBPNG=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")
+
+    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_compile_definitions(${PROJECT_NAME} PUBLIC "OPENGL_ES" "NO_EGL" "${PLATFORM_CPP}")
+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 +380,27 @@ if (OpenSSL_FOUND)
 endif()
 
 if (NOT UNIX)
-add_custom_command(
-    TARGET ${PROJECT_NAME} 
-    POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:${PROJECT_NAME}> $<TARGET_FILE_DIR:${PROJECT_NAME}> 
-        COMMAND_EXPAND_LISTS
-)
+    add_custom_command(
+        TARGET ${PROJECT_NAME} 
+        POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:${PROJECT_NAME}> $<TARGET_FILE_DIR:${PROJECT_NAME}> 
+            COMMAND_EXPAND_LISTS
+    )
 endif()
 
-add_custom_command(
-    TARGET ${PROJECT_NAME} 
-    POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_SOURCE_DIR}/data" $<TARGET_FILE_DIR:${PROJECT_NAME}>/data
-)
-
-# Installing and packing
-
-find_package(Git REQUIRED)
-
-execute_process(
-    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 .
-)
+if(NOT ${PLATFORM} MATCHES "Web")
+    add_custom_command(
+        TARGET ${PROJECT_NAME} 
+        POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_SOURCE_DIR}/data" $<TARGET_FILE_DIR:${PROJECT_NAME}>/data
+    )
+else()
+    add_custom_command(
+        TARGET ${PROJECT_NAME} 
+        POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/misc/web/index.html" $<TARGET_FILE_DIR:${PROJECT_NAME}>
+    )
 endif()
 
-install(DIRECTORY "${CMAKE_SOURCE_DIR}/data" DESTINATION .)
-
-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)
+message(STATUS "Compiling with the flags:")
+message(STATUS "  PLATFORM=" ${PLATFORM_CPP})

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
 
@@ -94,4 +94,107 @@ 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 -NoCpp   # skip NDK rebuild (Java/assets changed)
-#    .\build.ps1 -NoJava  # skip Java recompile (C++ changed only)
-#    .\build.ps1 -NoBuild # repackage + install only (no recompile)
+#    .\build.ps1              # full build (NDK + Java + APK + install)
+#    .\build.ps1 -NoCpp       # skip NDK rebuild (Java/assets changed)
+#    .\build.ps1 -NoJava      # skip Java recompile (C++ changed only)
+#    .\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
-    $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
-    # dump entire output for diagnosis
-    Write-Host "---- NDK BUILD OUTPUT BEGIN ----"
-    $ndkOutput | ForEach-Object { Write-Host $_ }
-    Write-Host "---- NDK BUILD OUTPUT END ----"
-    # optionally highlight errors/warnings afterwards
-    $ndkOutput | Where-Object { $_ -match "error:|warning:|libminecraftpe|In file included" }
+    # run ndk-build and stream output directly to the console
+    $ndkCmd = Join-Path $ndk 'ndk-build.cmd'
+    $ndkArgs = "NDK_PROJECT_PATH=`"$junctionBase/project/android`" APP_BUILD_SCRIPT=`"$junctionBase/project/android/jni/Android.mk`""
+
+    $proc = Start-Process -FilePath $ndkCmd -ArgumentList $ndkArgs -NoNewWindow -Wait -PassThru
     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 |
-              Where-Object { $_ -match "error:" }
-    $ErrorActionPreference = $eap
-    if ($errors) { Write-Host $errors -ForegroundColor Red; exit 1 }
+
+    & javac --release 8 -cp $androidJar -d $classesDir @srcs
+    if ($LASTEXITCODE -ne 0) { Write-Host 'javac failed' -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,7 +152,8 @@ options.group.graphics=Graphics
 options.group.tweaks=Tweaks
 options.allowSprint=Allow sprint
 options.barOnTop=HUD above inventory
-options.autojump=Auto Jump
+options.rpiCursor=Show Raspberry PI cursor
+options.autoJump=Auto Jump
 options.thirdperson=Third Person
 options.servervisible=Server Visible
 options.sensitivity=Sensitivity
@@ -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,46 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>MCPE 0.6.1</title>
+  <style>
+    html, body {
+      margin: 0;
+      padding: 0;
+      height: 100%;
+      background: black;
+      overflow: hidden;
+    }
+
+    #canvas {
+      width: 100vw;
+      height: 100vh;
+      display: block;
+    }
+  </style>
+</head>
+<body>
+
+<canvas id="canvas"></canvas>
+
+<script>
+  var Module = {
+    canvas: document.getElementById('canvas'),
+    onRuntimeInitialized: function () { resizeCanvas() }
+  };
+
+  function resizeCanvas() {
+    const canvas = Module.canvas;
+    canvas.width = window.innerWidth;
+    canvas.height = window.innerHeight;
+  }
+
+  window.addEventListener('resize', resizeCanvas);
+  window.addEventListener('onunload', () => {
+    FS.syncfs(true, function (err) { console.log('Sync FS failed: ' + err) });
+  })
+</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"
-                android:targetSdkVersion="24" />
+    <uses-sdk   android:minSdkVersion="19"
+                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:targetSdkVersion="28"/>
+        android:minSdkVersion="19"
+        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);
-    	
-    	_soundPlayer = new SoundPlayer(this, AudioManager.STREAM_MUSIC);
+        setContentView(_glView);
+
+        _soundPlayer = new SoundPlayer(this, AudioManager.STREAM_MUSIC);
 
-        // request dangerous permissions at runtime if necessary
         checkAndRequestPermissions();
+        initNative();
     }
 
-    private void checkAndRequestPermissions() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            boolean needRequest = false;
-            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);
-            }
+    private void initNative() {
+        if (_nativeInitialized) {
+            return;
         }
+        _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) {
-                // user denied; you might want to warn or close the app
+            if (granted) {
+                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/iosproj/minecraftpe.xcodeproj/project.pbxproj

@@ -1211,7 +1211,7 @@
 		042A91A916B17517007ABBC6 /* OptionsPane.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = OptionsPane.cpp; sourceTree = "<group>"; };
 		042A91AA16B17517007ABBC6 /* OptionsPane.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OptionsPane.h; sourceTree = "<group>"; };
 		042A91AB16B17517007ABBC6 /* TextBox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TextBox.cpp; sourceTree = "<group>"; };
-		042A91AC16B17517007ABBC6 /* TextBox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TextBox.h; path = ../../src/client/gui/components/TextBox.h; sourceTree = SOURCE_ROOT; };
+		042A91AC16B17517007ABBC6 /* TextBox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextBox.h; sourceTree = "<group>"; };
 		044129061682FF9600B70EE6 /* MouseHandler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MouseHandler.cpp; sourceTree = "<group>"; };
 		9D293CE616071C08000305C8 /* CreateNewWorld_iphone.xib */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.xib; name = CreateNewWorld_iphone.xib; path = minecraftpe/dialogs/CreateNewWorld_iphone.xib; sourceTree = "<group>"; };
 		9D293CEA160720D6000305C8 /* worldname_iphone5_3.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = worldname_iphone5_3.png; sourceTree = "<group>"; };
@@ -4527,16 +4527,10 @@
 			isa = PBXProject;
 			attributes = {
 				LastUpgradeCheck = 0420;
-				TargetAttributes = {
-					D5CF9C41144C225000E4244F = {
-						DevelopmentTeam = PZUVNW8F2U;
-						ProvisioningStyle = Automatic;
-					};
-				};
 			};
 			buildConfigurationList = D5CF9C3C144C225000E4244F /* Build configuration list for PBXProject "minecraftpe" */;
 			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = en;
+			developmentRegion = English;
 			hasScannedForEncodings = 0;
 			knownRegions = (
 				en,
@@ -5742,27 +5736,24 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD)";
+				ARCHS = "$(ARCHS_UNIVERSAL_IPHONE_OS)";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution: Mojang AB";
 				COPY_PHASE_STRIP = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_PREPROCESSOR_DEFINITIONS = PUBLISH;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
 				GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS = NO;
 				GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1";
 				"PROVISIONING_PROFILE[sdk=iphoneos*]" = "C93D3524-5C6F-466E-B12B-833663B7EAE0";
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
-				USER_HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
 				VALIDATE_PRODUCT = YES;
 			};
 			name = "Ad-Hoc";
@@ -5774,17 +5765,15 @@
 				GCC_PREFIX_HEADER = "minecraftpe/minecraftpe-Prefix.pch";
 				GCC_PREPROCESSOR_DEFINITIONS = "";
 				"GCC_THUMB_SUPPORT[arch=armv7]" = NO;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
 				HEADER_SEARCH_PATHS = "";
 				INFOPLIST_FILE = "minecraftpe/minecraftpe-Info.plist";
-				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.games";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
-				PRODUCT_BUNDLE_IDENTIFIER = "com.mojang.mcpe-arm64";
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
+				VALID_ARCHS = "i386 armv6 armv7";
 				WRAPPER_EXTENSION = app;
 			};
 			name = "Ad-Hoc";
@@ -5858,26 +5847,23 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD)";
+				ARCHS = "$(ARCHS_UNIVERSAL_IPHONE_OS)";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution: Mojang AB";
 				COPY_PHASE_STRIP = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
 				GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS = NO;
 				GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1";
 				"PROVISIONING_PROFILE[sdk=iphoneos*]" = "64BA8967-1A9A-4980-972C-42E75AD5E023";
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
-				USER_HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
 				VALIDATE_PRODUCT = YES;
 			};
 			name = AppStore;
@@ -5890,13 +5876,11 @@
 				GCC_PREFIX_HEADER = "minecraftpe/minecraftpe-Prefix.pch";
 				GCC_PREPROCESSOR_DEFINITIONS = PUBLISH;
 				"GCC_THUMB_SUPPORT[arch=armv7]" = NO;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
 				HEADER_SEARCH_PATHS = "";
 				INFOPLIST_FILE = "minecraftpe/minecraftpe-Info.plist";
-				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.games";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				OTHER_CFLAGS = (
 					"-DNS_BLOCK_ASSERTIONS=1",
 					"-DANDROID_PUBLISH",
@@ -5904,7 +5888,8 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				"PROVISIONING_PROFILE[sdk=iphoneos*]" = "1B194957-98CF-49B7-A0E7-76692B4B722D";
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
+				VALID_ARCHS = "i386 armv6 armv7";
 				WRAPPER_EXTENSION = app;
 			};
 			name = AppStore;
@@ -5938,7 +5923,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD)";
+				ARCHS = "$(ARCHS_UNIVERSAL_IPHONE_OS)";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
@@ -5950,21 +5935,17 @@
 					"$(inherited)",
 				);
 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
 				GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS = NO;
 				GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
-				USER_HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
-				VALIDATE_PRODUCT = YES;
 			};
 			name = Debug;
 		};
@@ -5972,26 +5953,23 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD)";
+				ARCHS = "$(ARCHS_UNIVERSAL_IPHONE_OS)";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_PREPROCESSOR_DEFINITIONS = PUBLISH;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
 				GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS = NO;
 				GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1";
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
-				USER_HEADER_SEARCH_PATHS = "$(SRCROOT)\\src/**";
 				VALIDATE_PRODUCT = YES;
 			};
 			name = Release;
@@ -5999,25 +5977,19 @@
 		D5CF9C6F144C225000E4244F /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CODE_SIGN_IDENTITY = "Apple Development";
-				CODE_SIGN_STYLE = Automatic;
-				DEVELOPMENT_TEAM = PZUVNW8F2U;
 				GCC_PRECOMPILE_PREFIX_HEADER = YES;
 				GCC_PREFIX_HEADER = "minecraftpe/minecraftpe-Prefix.pch";
 				GCC_PREPROCESSOR_DEFINITIONS = "DEBUG=1";
 				"GCC_THUMB_SUPPORT[arch=armv7]" = NO;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
 				HEADER_SEARCH_PATHS = "";
 				INFOPLIST_FILE = "minecraftpe/minecraftpe-Info.plist";
-				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.games";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
-				PRODUCT_BUNDLE_IDENTIFIER = "com.mojang.mcpe-arm64";
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				PROVISIONING_PROFILE_SPECIFIER = "";
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
+				VALID_ARCHS = "i386 armv6 armv7";
 				WRAPPER_EXTENSION = app;
 			};
 			name = Debug;
@@ -6025,25 +5997,19 @@
 		D5CF9C70144C225000E4244F /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CODE_SIGN_IDENTITY = "Apple Development";
-				CODE_SIGN_STYLE = Automatic;
-				DEVELOPMENT_TEAM = PZUVNW8F2U;
 				GCC_PRECOMPILE_PREFIX_HEADER = YES;
 				GCC_PREFIX_HEADER = "minecraftpe/minecraftpe-Prefix.pch";
 				GCC_PREPROCESSOR_DEFINITIONS = "";
 				"GCC_THUMB_SUPPORT[arch=armv7]" = NO;
-				GCC_VERSION = "";
+				GCC_VERSION = com.apple.compilers.llvmgcc42;
 				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
 				HEADER_SEARCH_PATHS = "";
 				INFOPLIST_FILE = "minecraftpe/minecraftpe-Info.plist";
-				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.games";
-				IPHONEOS_DEPLOYMENT_TARGET = 14;
-				ONLY_ACTIVE_ARCH = YES;
-				PRODUCT_BUNDLE_IDENTIFIER = "com.mojang.mcpe-arm64";
+				IPHONEOS_DEPLOYMENT_TARGET = 4.3;
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				PROVISIONING_PROFILE_SPECIFIER = "";
 				RUN_CLANG_STATIC_ANALYZER = NO;
-				SDKROOT = iphoneos;
+				SDKROOT = iphoneos6.0;
+				VALID_ARCHS = "i386 armv6 armv7";
 				WRAPPER_EXTENSION = app;
 			};
 			name = Release;

project/iosproj/minecraftpe/minecraftpe-Info.plist

@@ -37,7 +37,7 @@
 		</dict>
 	</dict>
 	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<string>com.mojang.${PRODUCT_NAME:rfc1034identifier}</string>
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>CFBundleName</key>

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/App.cpp

@@ -0,0 +1,26 @@
+#include "App.hpp"
+#include "IPlatform.hpp"
+
+#include "platform/server/PlatformServer.hpp"
+#include "platform/glfw/PlatformGlfw.hpp"
+
+std::unique_ptr<IPlatform> App::CreatePlatform() {
+#if defined(STANDALONE_SERVER)
+    return std::make_unique<PlatformServer>();
+#elif defined(PLATFORM_DESKTOP)
+    return std::make_unique<PlatformGlfw>();
+#else 
+    static_assert(false, "Unsupported platform!");
+#endif
+}
+
+void App::run() {
+    init();
+
+    m_platform->runMainLoop(*this);
+}
+
+void App::swapBuffers() {
+    m_platform->swapBuffers();
+}
+

src/App.h

@@ -1,87 +0,0 @@
-#ifndef APP_H__
-#define APP_H__
-
-#ifdef __APPLE__
-#define NO_EGL
-#endif
-#ifdef STANDALONE_SERVER
-#define NO_EGL
-#endif
-
-#include "AppPlatform.h"
-#ifndef NO_EGL 
-    #include <EGL/egl.h>
-#endif
-#include "platform/log.h"
-
-typedef struct AppContext {
-#ifndef NO_EGL
-	EGLDisplay display;
-	EGLContext context;
-	EGLSurface surface;
-#endif
-	AppPlatform* platform;
-	bool doRender;
-} AppContext;
-
-
-class App
-{
-public:
-    App()
-	:	_finished(false),
-		_inited(false)
-	{
-		_context.platform = 0;
-	}
-	virtual ~App() {}
-
-	void init(AppContext& c) {
-        _context = c;
-		init();
-		_inited = true;
-    }
-	bool isInited() { return _inited; }
-
-	virtual AppPlatform* platform() { return _context.platform; }
-
-	void onGraphicsReset(AppContext& c) {
-		_context = c;
-		onGraphicsReset();
-	}
-
-    virtual void audioEngineOn () {}
-    virtual void audioEngineOff() {}
-    
-	virtual void destroy() {}
-
-    virtual void loadState(void* state, int stateSize) {}
-    virtual bool saveState(void** state, int* stateSize) { return false; }
-    
-	void swapBuffers() {
-#ifndef NO_EGL
-		if (_context.doRender)
-			eglSwapBuffers(_context.display, _context.surface);
-#endif
-	}
-
-	virtual void draw() {}
-	virtual void update() {};// = 0;
-	virtual void setSize(int width, int height) {}
-	
-	virtual void quit() { _finished = true; }
-	virtual bool wantToQuit() { return _finished; }
-	virtual bool handleBack(bool isDown) { return false; }
-
-protected:
-	virtual void init() {}
-	//virtual void onGraphicsLost() = 0;
-	virtual void onGraphicsReset() = 0;
-
-private:
-	bool _inited;
-	bool _finished;
-    AppContext _context;
-};
-
-#endif//APP_H__

src/App.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <memory>
+#ifdef __APPLE__
+#define NO_EGL
+#endif
+#ifdef STANDALONE_SERVER
+#define NO_EGL
+#endif
+
+#include <IPlatform.hpp>
+#ifndef NO_EGL 
+    #include <EGL/egl.h>
+#endif
+
+
+// typedef struct AppContext {
+// #ifndef NO_EGL
+// 	EGLDisplay display;
+// 	EGLContext context;
+// 	EGLSurface surface;
+// #endif
+// 	AppPlatform* platform;
+// 	bool doRender;
+// } AppContext;
+
+class App {
+protected:
+	std::unique_ptr<IPlatform> m_platform;
+
+public:
+	static std::unique_ptr<IPlatform> CreatePlatform();
+
+    App(std::unique_ptr<IPlatform> platform) : m_platform(std::move(platform)), m_finished(false), m_inited(false) {}
+	App() = delete;
+	virtual ~App() {}
+
+	void run();
+
+	bool isInited() { return m_inited; }
+
+    virtual void audioEngineOn () {}
+    virtual void audioEngineOff() {}
+    
+	virtual void destroy() {}
+
+    virtual void loadState(void* state, int stateSize) {}
+    virtual bool saveState(void** state, int* stateSize) { return false; }
+    
+	void swapBuffers();
+// 	{
+// #ifndef NO_EGL
+// 		if (_context.doRender)
+// 			eglSwapBuffers(_context.display, _context.surface);
+// #endif
+// 		m_platform->swapBuffers();
+// 	}
+
+	virtual void update() = 0;
+	
+	virtual void quit() { m_finished = true; }
+	virtual bool wantToQuit() { return m_finished; }
+	virtual bool handleBack(bool isDown) { return false; }
+
+protected:
+	virtual void init() { m_inited = true;}
+
+private:
+	bool m_inited = false;
+	bool m_finished = false;
+};

src/AppConstants.h

@@ -1,10 +0,0 @@
-#ifndef _MINECRAFT_APPCONSTANTS_H_
-#define _MINECRAFT_APPCONSTANTS_H_
-
-
-#define APP_VERSION_STRING "Demo"
-#define APP_NAME "Minecraft - Pocket Edition " APP_VERSION_STRING
-
-
-
-#endif

src/AppPlatform.h

@@ -1,141 +0,0 @@
-#ifndef APPPLATFORM_H__
-#define APPPLATFORM_H__
-
-#include <vector>
-#include <string>
-#include <cstring>
-#include "client/renderer/TextureData.h"
-
-typedef std::vector<std::string> StringVector;
-
-/*
-typedef struct UserInput
-{
-    static const int STATUS_INVALID = -1;
-    static const int STATUS_NOTINITED = -2;
-    static const int STATUS_OK = 1;
-    static const int STATUS_CANCEL = 0;
-
-    UserInput(int id)
-    :   _id(id),
-        status(STATUS_NOTINITED)
-    {}
-    UserInput(int id, int status)
-    :   _id(id),
-        status(status)
-    {}
-    int getId() { return _id; }
-
-    int status;
-private:
-    int _id;
-} UserInput;
-
-
-class UserInputStatus {
-	int _status;
-public:
-	UserInputStatus(int status)
-	:	_status(status)
-	{}
-	bool isAnswered() { return _status >= 0; }
-	bool isOk() { return _status == UserInput::STATUS_OK; }
-	bool isCancel() { return _status == UserInput::STATUS_CANCEL; }
-};
-*/
-
-class BinaryBlob {
-public:
-	BinaryBlob()
-	:	data(NULL),
-		size(-1) {}
-
-	BinaryBlob(unsigned char* data, unsigned int size)
-	:	data(data),
-		size(size) {}
-
-	unsigned char* data;
-	int size;
-};
-
-class PlatformStringVars {
-public:
-	static const int DEVICE_BUILD_MODEL = 0;
-};
-
-class AppPlatform
-{
-public:
-	AppPlatform() : keyboardVisible(false) {}
-    virtual ~AppPlatform() {}
-
-	virtual void saveScreenshot(const std::string& filename, int glWidth, int glHeight) {}
-	virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
-	virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
-
-    virtual void playSound(const std::string& fn, float volume, float pitch) {}
-
-	virtual void showDialog(int dialogId) {}
-    virtual void createUserInput() {}
-	
-	bool is_big_endian(void)  {
-		union {
-			unsigned int i;
-			char c[4];
-		} bint = {0x01020304};
-		return bint.c[0] == 1;
-	} 
-
-	void createUserInput(int dialogId)
-	{
-		showDialog(dialogId);
-		createUserInput();
-	}
-	virtual int getUserInputStatus() { return 0; }
-	virtual StringVector getUserInput() { return StringVector(); }
-
-	virtual std::string getDateString(int s) { return ""; }
-	//virtual void createUserInputScreen(const char* types) {}
-
-	virtual void uploadPlatformDependentData(int id, void* data) {}
-	virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
-	virtual void _tick() {}
-
-	virtual int getScreenWidth() { return 854; }
-	virtual int getScreenHeight() { return 480; }
-    virtual float getPixelsPerMillimeter() { return 10; }
-
-	virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
-
-	virtual bool isPowerVR() {
-		return false;
-	}
-	virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
-#ifdef __APPLE__
-    virtual bool isSuperFast() = 0;
-#endif
-
-	virtual void openURL(const std::string& url) {}
-
-	virtual void finish() {}
-	
-	virtual bool supportsTouchscreen() { return false; }
-	
-	virtual void vibrate(int milliSeconds) {}
-
-	virtual std::string getPlatformStringVar(int stringId) {
-		return "<getPlatformStringVar NotImplemented>";
-	}
-
-	virtual void showKeyboard() {
-		keyboardVisible = true;
-	}
-	virtual void hideKeyboard() {
-		keyboardVisible = false;
-	}
-	virtual bool isKeyboardVisible() {return keyboardVisible;}
-protected:
-	bool keyboardVisible;
-};
-
-#endif /*APPPLATFORM_H__*/

src/AppPlatform_glfw.cpp

@@ -1,12 +0,0 @@
-#include "AppPlatform_glfw.h"
-
-float AppPlatform_glfw::getPixelsPerMillimeter() {
-    GLFWmonitor* monitor = glfwGetPrimaryMonitor();
-
-    int width_mm, height_mm;
-    glfwGetMonitorPhysicalSize(monitor, &width_mm, &height_mm);
-
-    const GLFWvidmode* mode = glfwGetVideoMode(monitor);
-
-    return (float)mode->width / (float)width_mm;
-}

src/AppPlatform_glfw.h

@@ -1,153 +0,0 @@
-#ifndef APPPLATFORM_GLFW_H__
-#define APPPLATFORM_GLFW_H__
-
-#include "AppPlatform.h"
-#include "platform/log.h"
-#include "platform/HttpClient.h"
-#include "platform/PngLoader.h"
-#include "client/renderer/gles.h"
-#include "world/level/storage/FolderMethods.h"
-#include <png.h>
-#include <cmath>
-#include <fstream>
-#include <sstream>
-#include <GLFW/glfw3.h>
-#include <ctime>
-#include "util/StringUtils.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#include <shellapi.h>
-#endif
-
-static void png_funcReadFile(png_structp pngPtr, png_bytep data, png_size_t length) {
-	((std::istream*)png_get_io_ptr(pngPtr))->read((char*)data, length);
-}
-
-class AppPlatform_glfw: public AppPlatform
-{
-public:
-    AppPlatform_glfw()
-    {
-    }
-
-	BinaryBlob readAssetFile(const std::string& filename) {
-		FILE* fp = fopen(("data/" + filename).c_str(), "r");
-		if (!fp)
-			return BinaryBlob();
-
-		int size = getRemainingFileSize(fp);
-
-		BinaryBlob blob;
-		blob.size = size;
-		blob.data = new unsigned char[size];
-
-		fread(blob.data, 1, size, fp);
-		fclose(fp);
-
-		return blob;
-	}
-
-    void saveScreenshot(const std::string& filename, int glWidth, int glHeight) {
-        //@todo
-    }
-
-    __inline unsigned int rgbToBgr(unsigned int p) {
-        return (p & 0xff00ff00) | ((p >> 16) & 0xff) | ((p << 16) & 0xff0000);
-    }
-
-    TextureData loadTexture(const std::string& filename_, bool textureFolder)
-	{
-		// Support fetching PNG textures via HTTP/HTTPS (for skins, etc)
-		if (Util::startsWith(filename_, "http://") || Util::startsWith(filename_, "https://")) {
-			std::vector<unsigned char> body;
-			if (HttpClient::download(filename_, body) && !body.empty()) {
-				return loadTextureFromMemory(body.data(), body.size());
-			}
-			return TextureData();
-		}
-
-		TextureData out;
-
-		std::string filename = textureFolder? "data/images/" + filename_
-								: filename_;
-		std::ifstream source(filename.c_str(), std::ios::binary);
-
-		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;
-		}
-    }
-
-	TextureData loadTextureFromMemory(const unsigned char* data, size_t size) override {
-		return loadPngFromMemory(data, size);
-	}
-
-	virtual std::string getDateString(int s) override {
-		time_t tm = s;
-
-		char mbstr[100];
-		std::strftime(mbstr, sizeof(mbstr), "%F %T", std::localtime(&tm));
-
-		return std::string(mbstr);
-	}
-
-	virtual int getScreenWidth() { return 854; };
-	virtual int getScreenHeight() { return 480; };
-
-	virtual float getPixelsPerMillimeter();
-
-	virtual bool supportsTouchscreen() override { return true; }
-
-	virtual void openURL(const std::string& url) override {
-#ifdef _WIN32
-		ShellExecuteA(NULL, "open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);
-#elif __linux__
-		std::string command = "xdg-open " + url;
-		system(command.c_str());
-#endif
-	}
-
-private:
-};
-#endif /*APPPLATFORM_GLFW_H__*/

src/EglConfigPrinter.hpp

@@ -1,5 +1,4 @@
-#ifndef EGLCONFIGPRINTER_H__
-#define EGLCONFIGPRINTER_H__
+#pragma once
 
 #include <cstdio>
 #include <string>
@@ -122,4 +121,3 @@ public:
     }
 };
 
-#endif /*EGLCONFIGPRINTER_H__*/

src/ErrorCodes.h

@@ -1,13 +0,0 @@
-#ifndef ERRORCODES_H__
-#define ERRORCODES_H__
-
-namespace ErrorCodes {
-
-enum Enum {
-	Unknown,
-	ContainerRefStillExistsAfterDestruction
-};
-
-}
-
-#endif /*ERRORCODES_H__*/

src/IPlatform.cpp

@@ -0,0 +1,14 @@
+#include <IPlatform.hpp>
+#include <App.hpp>
+#include <fstream>
+
+void IPlatform::runMainLoop(App& app) {
+    while(!app.wantToQuit()) app.update();
+}
+
+ByteVector IPlatform::readAssetFile(const std::string& path) {
+    std::ifstream instream(path, std::ios::in | std::ios::binary);
+    std::vector<uint8_t> data((std::istreambuf_iterator<char>(instream)), std::istreambuf_iterator<char>());
+    
+    return data;
+}

src/IPlatform.hpp

@@ -0,0 +1,81 @@
+#pragma once
+#include <vector>
+#include <string>
+#include "client/renderer/TextureData.hpp"
+#include <cstdint>
+
+typedef std::vector<std::string> StringVector;
+typedef std::vector<uint8_t> ByteVector; 
+
+class App;
+
+class IPlatform {
+public:
+	IPlatform() : keyboardVisible(false), windowSizeChanged(false), m_targetFrametime(0.f) {}
+    virtual ~IPlatform() {}
+
+	virtual bool init() { return true; }
+	virtual void swapBuffers() {}
+
+	virtual void runMainLoop(App& app);
+
+	virtual ByteVector readAssetFile(const std::string& path);
+
+
+	// Mojang functions here
+	virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
+	virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
+
+    virtual void playSound(const std::string& fn, float volume, float pitch) {}
+	
+	virtual void hideCursor(bool hide) {}
+
+	virtual std::string getDateString(int s) = 0;
+
+	virtual void uploadPlatformDependentData(int id, void* data) {}
+	// virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
+	virtual void _tick() {}
+
+	virtual int getScreenWidth() { return 854; }
+	virtual int getScreenHeight() { return 480; }
+    virtual float getPixelsPerMillimeter() { return 10; }
+
+	virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
+
+	virtual bool isPowerVR() {
+		return false;
+	}
+	virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
+#ifdef __APPLE__
+    virtual bool isSuperFast() = 0;
+#endif
+
+	virtual void openURL(const std::string& url) {}
+
+	virtual void finish() {}
+	
+	virtual bool supportsTouchscreen() { return false; }
+	
+	virtual void vibrate(int milliSeconds) {}
+
+	virtual std::string getPlatformStringVar(int stringId) = 0;
+
+	virtual void showKeyboard() { keyboardVisible = true; }
+
+	virtual void hideKeyboard() { keyboardVisible = false; }
+
+	virtual bool isKeyboardVisible() { return keyboardVisible; }
+
+	virtual void setTargetFPS(int fps) { m_targetFrametime = 1.0 / fps; }
+
+	bool isWindowSizeChanged() { return windowSizeChanged; }
+
+	virtual void setVSync(bool on) { vsync = on; }
+
+protected:
+	bool keyboardVisible;
+	bool windowSizeChanged;
+	bool vsync;
+
+	double m_targetFrametime;
+};

src/LicenseCodes.hpp

@@ -1,40 +1,39 @@
-#ifndef LICENSECODES_H__
-#define LICENSECODES_H__
-
-class LicenseCodes
-{
-public:
-    // Something's not ready, call again later
-    static const int WAIT_PLATFORM_NOT_READY = -2;
-    static const int WAIT_SERVER_NOT_READY = -1;
-
-    // License is ok
-    static const int LICENSE_OK = 0;
-    static const int LICENSE_TRIAL_OK = 1;
-
-    // License is not working in one way or another
-    static const int LICENSE_VALIDATION_FAILED = 50;
-    static const int ITEM_NOT_FOUND = 51;
-    static const int LICENSE_NOT_FOUND = 52;
-    static const int ERROR_CONTENT_HANDLER = 100;
-    static const int ERROR_ILLEGAL_ARGUMENT = 101;
-    static const int ERROR_SECURITY = 102;
-    static const int ERROR_INPUT_OUTPUT = 103;
-    static const int ERROR_ILLEGAL_STATE = 104;
-    static const int ERROR_NULL_POINTER = 105;
-    static const int ERROR_GENERAL = 106;
-    static const int ERROR_UNABLE_TO_CONNECT_TO_CDS = 107;
-    
-    // The call went wrong so we didn't get a license value at all
-    static const int ERROR_EXCEPTION = 200;
-    
-    static bool isOk(int i) {
-        return (i == 0) || (i == 1);
-    }
-    static bool isReady(int i) {
-        return (i >= 0);
-    }
-};
-
-#endif /*LICENSECODES_H__ */
-
+#pragma once
+
+class LicenseCodes
+{
+public:
+    // Something's not ready, call again later
+    static const int WAIT_PLATFORM_NOT_READY = -2;
+    static const int WAIT_SERVER_NOT_READY = -1;
+
+    // License is ok
+    static const int LICENSE_OK = 0;
+    static const int LICENSE_TRIAL_OK = 1;
+
+    // License is not working in one way or another
+    static const int LICENSE_VALIDATION_FAILED = 50;
+    static const int ITEM_NOT_FOUND = 51;
+    static const int LICENSE_NOT_FOUND = 52;
+    static const int ERROR_CONTENT_HANDLER = 100;
+    static const int ERROR_ILLEGAL_ARGUMENT = 101;
+    static const int ERROR_SECURITY = 102;
+    static const int ERROR_INPUT_OUTPUT = 103;
+    static const int ERROR_ILLEGAL_STATE = 104;
+    static const int ERROR_NULL_POINTER = 105;
+    static const int ERROR_GENERAL = 106;
+    static const int ERROR_UNABLE_TO_CONNECT_TO_CDS = 107;
+    
+    // The call went wrong so we didn't get a license value at all
+    static const int ERROR_EXCEPTION = 200;
+    
+    static bool isOk(int i) {
+        return (i == 0) || (i == 1);
+    }
+    static bool isReady(int i) {
+        return (i >= 0);
+    }
+};
+
+#endif /*LICENSECODES_H__ */
+

src/Minecraft.cpp

@@ -0,0 +1,502 @@
+#include <Minecraft.hpp>
+#include "gamemode/CreativeMode.hpp"
+#include "gamemode/SurvivalMode.hpp"
+#include "gamemode/CreatorMode.hpp"
+#include "world/entity/player/Player.hpp"
+#include "world/item/Item.hpp"
+#include "world/item/ItemInstance.hpp"
+#include "world/item/crafting/Recipes.hpp"
+#include "world/level/Level.hpp"
+#include "world/level/tile/entity/TileEntity.hpp"
+#include <string>
+#include <cstdlib>
+#include "client/gui/Screen.hpp"
+#include "world/level/storage/ExternalFileLevelStorageSource.hpp"
+
+#if defined(APPLE_DEMO_PROMOTION)
+    #define NO_NETWORK
+#endif
+
+#if defined(RPI)
+	#define CREATORMODE
+#endif
+#include "network/RakNetInstance.hpp"
+#include "network/ClientSideNetworkHandler.hpp"
+#include "network/ServerSideNetworkHandler.hpp"
+//#include "network/Packet.hpp"
+#include "world/entity/player/Inventory.hpp"
+#include "world/level/tile/Tile.hpp"
+#include "world/level/storage/LevelStorageSource.hpp"
+#include "world/level/storage/LevelStorage.hpp"
+#include "world/level/chunk/ChunkSource.hpp"
+
+#include "platform/CThread.hpp"
+#include <IPlatform.hpp>
+#include "util/PerfTimer.hpp"
+#include "util/PerfRenderer.hpp"
+
+#include "world/entity/MobFactory.hpp"
+#include "world/level/MobSpawner.hpp"
+#include "util/Mth.hpp"
+#include "world/entity/MobCategory.hpp"
+#include "server/ServerLevel.hpp"
+
+#ifdef CREATORMODE
+#include "server/CreatorLevel.hpp"
+#endif
+
+#include "network/command/CommandServer.hpp"
+
+/*static*/
+const char* Minecraft::progressMessages[] = {
+	"Locating server",
+	"Building terrain",
+	"Preparing",
+	"Saving chunks"
+};
+
+// int Minecraft::customDebugId = Minecraft::CDI_NONE;
+bool Minecraft::_hasInitedStatics = false;
+
+#if defined(_MSC_VER)
+	#pragma warning( disable : 4355 ) // 'this' pointer in initialization list which is perfectly legal
+#endif
+
+// Minecraft::Minecraft() :
+// #ifdef __APPLE__
+//     _isSuperFast(false),
+// #endif
+
+
+// #if defined(NO_NETWORK)
+//     raknetInstance = new IRakNetInstance();
+// #else
+// 	raknetInstance = new RakNetInstance();
+// #endif
+// #ifndef STANDALONE_SERVER
+// 	soundEngine = new SoundEngine(20.0f);
+// 	soundEngine->init(this, &options);
+// #endif
+// 	//setupPieces();
+
+// 	#if defined(ANDROID) || defined(__APPLE__) || defined(RPI)
+//         signal(SIGPIPE, SIG_IGN);
+//     #endif
+
+// 	externalCacheStoragePath = '.';
+// 	externalCacheStoragePath = '.';
+// }
+
+Minecraft::~Minecraft() {
+	delete netCallback;
+	delete raknetInstance;
+	delete gameMode;
+
+	if (level != NULL) {
+		level->saveGame();
+		if (level->getChunkSource())
+			level->getChunkSource()->saveAll(true);
+		delete level->getLevelStorage();
+		delete level;
+		level = NULL;
+	}
+
+	//delete player;
+	delete storageSource;
+	delete _commandServer;
+
+	MobFactory::clearStaticTestMobs();
+
+	// Note: Don't tear down statics if we run on Android
+	// (we might change this in the future)
+#ifndef ANDROID
+	Biome::teardownBiomes();
+	Item ::teardownItems();
+	Tile ::teardownTiles();
+	Material::teardownMaterials();
+	Recipes ::teardownRecipes();
+	TileEntity::teardownTileEntities();
+#endif
+}
+
+// Only called by server
+void Minecraft::selectLevel( const std::string& levelId, const std::string& levelName, const LevelSettings& settings ) {
+	level = (Level*)new ServerLevel(
+		storageSource->selectLevel(levelId, false),
+		levelName,
+		settings,
+		SharedConstants::GeneratorVersion
+	);
+
+	// note: settings is useless beyond this point, since it's
+	//       either copied to LevelData (or LevelData read from file)
+	setLevel(level, "Generating level");
+	setIsCreativeMode(level->getLevelData()->getGameType() == GameType::Creative);
+	_running = true;
+}
+
+void Minecraft::setLevel(Level* level, const std::string& message, Player* forceInsertPlayer) {
+	LOGI("Seed is %ld\n", level->getSeed());
+	
+	if (level != NULL) {
+		level->raknetInstance = raknetInstance;
+        gameMode->initLevel(level);
+
+		this->level = level;
+		_hasSignaledGeneratingLevelFinished = false;
+#ifdef STANDALONE_SERVER
+		const bool threadedLevelCreation = false;
+#else
+		const bool threadedLevelCreation = true;
+#endif
+
+		if (threadedLevelCreation) {
+			// Threaded
+			// "Lock"
+			isGeneratingLevel = true;
+			generateLevelThread = new CThread(Minecraft::prepareLevel_tspawn, this);
+		} else {
+			// Non-threaded
+			generateLevel("Currently not used", level);
+		}
+    }
+
+    this->lastTickTime = 0;
+	this->_running = true;
+}
+
+void Minecraft::prepareLevel(const std::string& title) {
+	LOGI("status: 1\n");
+	progressStageStatusId = 1;
+
+	Stopwatch A, B, C, D;
+	A.start();
+
+	Stopwatch L;
+
+	// Dont update lights if we load the level (ok, actually just with leveldata version=1.+(?))
+	if (!level->isNew())
+		level->setUpdateLights(false);
+
+	int Max = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
+	int pp = 0;
+	for (int x = 8; x < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); x += CHUNK_WIDTH) {
+        for (int z = 8; z < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); z += CHUNK_WIDTH) {
+            progressStagePercentage = 100 * pp++ / Max;
+            //printf("level generation progress %d\n", progressStagePercentage);
+			B.start();
+            level->getTile(x, 64, z);
+			B.stop();
+			L.start();
+			if (level->isNew())
+				while (level->updateLights())
+					;
+			L.stop();
+        }
+    }
+	A.stop();
+	level->setUpdateLights(true);
+
+	C.start();
+	for (int x = 0; x < CHUNK_CACHE_WIDTH; x++)
+	{
+		for (int z = 0; z < CHUNK_CACHE_WIDTH; z++)
+		{
+			LevelChunk* chunk = level->getChunk(x, z);
+			if (chunk && !chunk->createdFromSave)
+			{
+				chunk->unsaved = false;
+				chunk->clearUpdateMap();
+			}
+		}
+	}
+	C.stop();
+
+	LOGI("status: 3\n");
+	progressStageStatusId = 3;
+	if (level->isNew()) {
+		level->setInitialSpawn(); // @note: should obviously be called from Level itself
+		level->saveLevelData();
+		level->getChunkSource()->saveAll(false);
+		level->saveGame();
+	} else {
+		level->saveLevelData();
+		level->loadEntities();
+	}
+
+	progressStagePercentage = -1;
+	progressStageStatusId = 2;
+	LOGI("status: 2\n");
+
+	D.start();
+	level->prepare();
+	D.stop();
+
+	A.print("Generate level: ");
+	L.print(" - light: ");
+	B.print(" - getTl: ");
+	C.print(" - clear: ");
+	D.print(" - prepr: ");
+	progressStageStatusId = 0;
+}
+
+void Minecraft::update() {
+
+	timer.advanceTime();
+	raknetInstance->runEvents(netCallback);
+
+	TIMER_PUSH("tick");
+	int toTick = timer.ticks;
+	timer.ticks = 0;
+	for (int i = 0; i < toTick; ++i, ++ticks) tick(i, toTick-1);
+
+	TIMER_POP_PUSH("updatelights");
+	{
+		if (level && !isGeneratingLevel) {
+			level->updateLights();
+		}
+	}
+	TIMER_POP();
+
+
+    // Restart the server if (our modded) RakNet reports an error
+    if (level && raknetInstance->isProbablyBroken() && raknetInstance->isServer()) {
+        restartServer();
+    }
+}
+
+void Minecraft::restartServer() {
+    if (!level) return;
+
+	raknetInstance->resetIsBroken();
+
+    hostMultiplayer();
+    if (netCallback) netCallback->levelGenerated(level);
+}
+
+void Minecraft::tick(int nTick, int maxTick) {
+	if (missTime > 0) missTime--;
+
+	TIMER_PUSH("gameMode");
+	if (level) {
+		gameMode->tick();
+	}
+
+	TIMER_POP_PUSH("commandServer");
+	if (level && _commandServer) {
+		_commandServer->tick();
+	}
+	
+	//
+	// Ongoing level generation in a (perhaps) different thread. When it's
+	// ready, _levelGenerated() is called once and any threads are deleted.
+	//
+	if (isGeneratingLevel) {
+		return;
+	} else if (!_hasSignaledGeneratingLevelFinished) {
+		if (generateLevelThread) {
+			delete generateLevelThread;
+			generateLevelThread = NULL;
+		}
+		_levelGenerated();
+	}
+
+	//
+	// Normal game loop, run before or efter level generation
+	//
+	if (level != NULL) {
+		TIMER_POP_PUSH("level");
+		level->tickEntities();
+		level->tick();
+	}
+
+	TIMER_POP();
+}
+
+bool Minecraft::isOnlineClient() {
+    return false;
+}
+
+bool Minecraft::isOnline() {
+	return netCallback != NULL;
+}
+
+void Minecraft::init()
+{
+	// WHY DO WE NEED THIS ON MODERN PLATFORMS :sob:
+	// Global initialization goes here
+	Mth::initMth();
+
+	if (raknetInstance != nullptr) {
+		delete raknetInstance;
+	}
+
+	raknetInstance = new RakNetInstance();
+
+	// If we're running Android, only initialize
+	// the first time class is instanced
+#ifdef ANDROID
+	if (!_hasInitedStatics) {
+		_hasInitedStatics = true;
+#endif
+		Material::initMaterials();
+		MobCategory::initMobCategories();
+		Tile::initTiles();
+		Item::initItems();
+		Biome::initBiomes();
+		TileEntity::initTileEntities();
+
+#ifdef ANDROID
+	}
+#endif
+
+	setIsCreativeMode(false); // false means it's Survival Mode
+
+#if !defined(NO_STORAGE)
+	storageSource = new ExternalFileLevelStorageSource(externalStoragePath, externalCacheStoragePath);
+#else
+	storageSource = new MemoryLevelStorageSource();
+#endif
+
+	// Server-only featire @todo server class app
+	hostMultiplayer();
+}
+
+
+//
+// Multiplayer
+//
+
+void Minecraft::hostMultiplayer(int port) {
+    // Tear down last instance
+    raknetInstance->disconnect();
+    delete netCallback;
+    netCallback = nullptr;
+
+#if !defined(NO_NETWORK)
+	netCallback = new ServerSideNetworkHandler(this, raknetInstance);
+#endif
+}
+
+//
+// Level generation
+//
+/*static*/
+
+void* Minecraft::prepareLevel_tspawn(void *p_param) {
+	Minecraft* mc = (Minecraft*) p_param;
+	mc->generateLevel("Currently not used", mc->level);
+	return 0;
+}
+
+void Minecraft::generateLevel( const std::string& message, Level* level ) {
+	Stopwatch s;
+	s.start();
+	prepareLevel(message);
+	s.stop();
+	s.print("Level generated: ");
+
+	// "Unlock"
+	isGeneratingLevel = false;
+}
+
+void Minecraft::_levelGenerated() {
+	level->validateSpawn();
+
+	if (raknetInstance->isServer())
+		raknetInstance->announceServer(getServerName());
+
+	if (netCallback) {
+		netCallback->levelGenerated(level);
+	}
+
+	_hasSignaledGeneratingLevelFinished = true;
+}
+
+Player* Minecraft::respawnPlayer(int playerId) {
+	for (unsigned int i = 0; i < level->players.size(); ++i) {
+		if (level->players[i]->entityId == playerId) {
+			resetPlayer(level->players[i]);
+			return level->players[i];
+		}
+	}
+	return NULL;
+}
+
+void Minecraft::resetPlayer(Player* player) {
+	level->validateSpawn();
+	player->reset();
+
+	Pos p;
+	if(player->hasRespawnPosition()) {
+		p = player->getRespawnPosition();
+	}
+	else {
+		p = level->getSharedSpawnPos();
+	}
+	player->setPos((float)p.x + 0.5f, (float)p.y + 1.0f, (float)p.z + 0.5f);
+	player->resetPos(true);
+
+	if (isCreativeMode())
+		player->inventory->clearInventoryWithDefault();
+}
+
+int Minecraft::getProgressStatusId() {
+	return progressStageStatusId;
+}
+
+const char* Minecraft::getProgressMessage()
+{
+	return progressMessages[progressStageStatusId];
+}
+
+bool Minecraft::isLevelGenerated()
+{
+	return level != NULL && !isGeneratingLevel;
+}
+
+LevelStorageSource* Minecraft::getLevelSource()
+{
+	return storageSource;
+}
+
+void Minecraft::setIsCreativeMode(bool isCreative)
+{
+#ifdef CREATORMODE
+	delete gameMode;
+	gameMode = new CreatorMode(this);
+	_isCreativeMode = true;
+#else
+	if (!gameMode || isCreative != _isCreativeMode)
+	{
+		delete gameMode;
+		if (isCreative) gameMode = new CreativeMode(*this);
+		else			gameMode = new SurvivalMode(*this);
+		_isCreativeMode = isCreative;
+	}
+#endif
+}
+
+bool Minecraft::isCreativeMode() {
+	return _isCreativeMode;
+}
+
+ICreator* Minecraft::getCreator()
+{
+#ifdef CREATORMODE
+	return ((CreatorMode*)gameMode)->getCreator();
+#else
+	return NULL;
+#endif
+}
+
+void Minecraft::optionUpdated(OptionId option, bool value ) {
+	if(netCallback != NULL && option == OPTIONS_SERVER_VISIBLE) {
+		ServerSideNetworkHandler* ss = (ServerSideNetworkHandler*) netCallback;
+		ss->allowIncomingConnections(value);
+	}
+}
+
+void Minecraft::optionUpdated(OptionId option, float value ) {}
+
+void Minecraft::optionUpdated(OptionId option, int value ) {}

src/Minecraft.hpp

@@ -0,0 +1,138 @@
+#pragma once
+
+#include "client/Options.hpp"
+#include "client/Timer.hpp"
+
+//#include "../network/RakNetInstance.hpp"
+#include "world/phys/HitResult.hpp"
+
+#include "App.hpp"
+#include <cstddef>
+
+class Level;
+class LocalPlayer;
+class IInputHolder;
+class Mob;
+class Player;
+class Entity;
+class ICreator;
+class GameMode;
+class CThread;
+class LevelStorageSource;
+class BuildActionIntention;
+class PerfRenderer;
+class LevelSettings;
+class IRakNetInstance;
+class NetEventCallback;
+class CommandServer;
+struct PingedCompatibleServer;
+
+class Minecraft: public App {
+public:
+	using App::App;
+	virtual ~Minecraft();
+
+	virtual void init();
+	virtual void update();
+	virtual void restartServer();
+	virtual void tick(int nTick, int maxTick);
+
+	virtual bool isOnlineClient();
+	virtual bool isOnline();
+
+	virtual void setIsCreativeMode(bool isCreative);
+
+	virtual void optionUpdated(OptionId option, bool value);
+	virtual void optionUpdated(OptionId option, float value);
+	virtual void optionUpdated(OptionId option, int value);
+
+	/**
+	 * @brief Get public name that will be listed in JoinGame menu
+	 */
+	virtual std::string getServerName() { return "Unknown"; }
+
+	void toggleDimension() {}
+	bool isCreativeMode();
+
+	virtual void selectLevel(const std::string& levelId, const std::string& levelName, const LevelSettings& settings);
+	virtual void setLevel(Level* level, const std::string& message = "", Player* forceInsertPlayer = NULL);
+
+	virtual void onBlockDestroyed(Player* player, int x, int y, int z, int face) {}
+
+	void generateLevel( const std::string& message, Level* level );
+	LevelStorageSource* getLevelSource();
+
+	virtual void hostMultiplayer(int port=19132);
+	Player* respawnPlayer(int playerId);
+	void respawnPlayer();
+	void resetPlayer(Player* player);
+	void doActuallyRespawnPlayer();
+
+	void prepareLevel(const std::string& message);
+
+	int getProgressStatusId();
+	const char* getProgressMessage();
+
+	ICreator* getCreator();
+
+	bool isLevelGenerated();
+
+#ifdef __APPLE__
+    bool _isSuperFast = false;
+    bool isSuperFast() { return _isSuperFast; }
+#endif
+
+protected:
+	virtual void _levelGenerated();
+
+private:
+	static void* prepareLevel_tspawn(void *p_param);
+public:
+	Level* level = nullptr;
+	CommandServer* _commandServer = nullptr;
+	GameMode* gameMode = nullptr;
+	IRakNetInstance*  raknetInstance = nullptr;
+	NetEventCallback* netCallback = nullptr;
+
+	int commandPort = 4711;
+
+	int lastTime = 0;
+	int lastTickTime = -1;
+	int missTime = 0;
+	int ticks = 0;
+
+	CThread* generateLevelThread = nullptr;
+	// static int customDebugId;
+
+	HitResult hitResult;
+	volatile int progressStagePercentage = 0;
+
+	// This field is initialized in main()
+	// It sets the base path to where worlds can be written (sdcard on android)
+	std::string externalStoragePath;
+	std::string externalCacheStoragePath;
+protected:
+	Timer timer{20};
+    // @note @attn @warn: this is dangerous as fuck!
+	volatile bool isGeneratingLevel = false;
+	bool _hasSignaledGeneratingLevelFinished = true;
+
+	LevelStorageSource* storageSource;
+	bool _running;
+
+protected:
+	volatile int progressStageStatusId = 0;
+	static const char* progressMessages[];
+
+	int _licenseId;
+
+	bool _isCreativeMode;
+	Player* _pendingRemovePlayer; // @attn @todo @fix: remove this shait and fix the respawn behaviour
+
+	// from NinecraftApp
+	bool _verbose = true;
+	int _lastTickMs = 0;
+
+	static bool _hasInitedStatics;
+};
+

src/MinecraftClient.hpp

@@ -0,0 +1,142 @@
+#pragma once
+#include "client/gui/Font.hpp"
+#include "client/gui/Screen.hpp"
+#include "client/particle/ParticleEngine.hpp"
+#include "client/player/LocalPlayer.hpp"
+#include "client/renderer/GameRenderer.hpp"
+#include "client/renderer/Textures.hpp"
+#include "client/sound/SoundEngine.hpp"
+#include <Minecraft.hpp>
+
+#include <client/MouseHandler.hpp>
+#include <client/gui/Gui.hpp>
+#include <client/gui/screens/ScreenChooser.hpp>
+#include <client/PixelCalc.hpp>
+#include <client/renderer/LevelRenderer.hpp>
+
+class MinecraftClient : public Minecraft {
+public:
+    using Minecraft::Minecraft;
+    ~MinecraftClient();
+
+    void init() override;
+
+    void update() override;
+
+    void setSize(int width, int height);
+    void reloadOptions();
+    
+    bool supportNonTouchScreen();
+	bool useTouchscreen();
+	void grabMouse();
+	void releaseMouse();
+
+    void setScreen(Screen*);
+    void leaveGame(bool renameLevel = false);
+
+	void setLevel(Level* level, const std::string& message = "", Player* forceInsertPlayer = NULL) override;
+
+    void updateStats();
+
+    void restartServer() override;
+
+    bool handleBack(bool isDown) override;
+
+    void onGraphicsReset();
+    void initGLStates();
+
+    void tick(int nTick, int maxTick) override;
+    void tickInput();
+
+    void handleBuildAction(BuildActionIntention* action);
+
+    bool isOnlineClient() override;
+
+    void pauseGame(bool isBackPaused);
+    void gameLostFocus();
+
+    void respawnPlayer();
+
+    void audioEngineOn() override;
+    void audioEngineOff() override;
+
+    void setIsCreativeMode(bool isCreative) override;
+
+    void optionUpdated(OptionId option, bool value) override;
+	void optionUpdated(OptionId option, float value) override;
+	void optionUpdated(OptionId option, int value) override;
+
+    LocalPlayer* getPlayer() { return player; }
+    Font* getFont() { return font; }
+    Textures& textures() { return m_textures; }
+    Options& options() { return m_options;}
+    Screen* getScreen() { return m_screen; }
+    Gui& gui() { return m_gui; }
+    ParticleEngine* getParticleEngine() {return particleEngine; }
+
+    int getScreenWidth() { return width; }
+    int getScreenHeigth() { return height; }
+
+    virtual void hostMultiplayer(int port) override;
+
+    bool isPowerVR() { return _powerVr; }
+	bool isKindleFire(int kindleVersion);
+	bool transformResolution(int* w, int* h);
+
+    virtual std::string getServerName() override;
+
+    void locateMultiplayer();
+	void cancelLocateMultiplayer();
+	bool joinMultiplayer(const PingedCompatibleServer& server);
+	bool joinMultiplayerFromString(const std::string& server);
+
+    void onBlockDestroyed(Player* player, int x, int y, int z, int face) override;
+
+protected:
+    void _reloadInput();
+    void _levelGenerated() override;
+
+    int width = 1, height = 1;
+
+	Font* font = nullptr;
+    // @warn This is unsafe cuz Gui may call some MinecraftClient method while MinecraftClient is not ready 
+    MouseHandler mouseHandler;
+
+    LevelRenderer*  levelRenderer = nullptr;
+	GameRenderer*   gameRenderer = nullptr;
+	ParticleEngine* particleEngine = nullptr;
+	SoundEngine*    soundEngine = nullptr;
+    PerfRenderer* _perfRenderer = nullptr;
+
+	bool mouseGrabbed = false;
+
+    PixelCalc pixelCalc;
+    PixelCalc pixelCalcUi;
+
+    Screen* m_screen = nullptr;
+
+    bool screenMutex = false;
+	bool hasScheduledScreen = false;
+	Screen* scheduledScreen = nullptr;
+
+    int m_frames = 0;
+
+    volatile bool pause = false;
+
+    // @todo make static
+    LocalPlayer*	player = nullptr;
+	IInputHolder*	inputHolder = nullptr;
+	Mob*			cameraTargetPlayer = nullptr;
+
+    bool _supportsNonTouchscreen = false;
+    bool isLookingForMultiplayer = false;
+    bool _powerVr = false;
+
+    Options m_options{*this};
+
+    Textures m_textures{m_options, *m_platform};
+
+    ScreenChooser screenChooser{*this};
+
+    Gui m_gui{*this};
+};

src/MinecraftServer.cpp

@@ -0,0 +1,15 @@
+#include "MinecraftServer.hpp"
+#include <Minecraft.hpp>
+#include <network/RakNetInstance.hpp>
+
+
+void MinecraftServer::hostMultiplayer(int port) {
+    Minecraft::hostMultiplayer(port);
+
+    raknetInstance->host("Server", port, 16);
+}
+
+std::string MinecraftServer::getServerName() {
+	// @todo read server name from config
+    return "Dedicated server 0.6.1";
+}

src/MinecraftServer.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include <Minecraft.hpp>
+
+class MinecraftServer : public Minecraft { 
+public:
+    using Minecraft::Minecraft;
+
+    void hostMultiplayer(int port) override;
+    std::string getServerName() override;
+};

src/NinecraftApp.cpp

@@ -1,425 +0,0 @@
-#include "NinecraftApp.h"
-//#include <EGL/egl.h>
-
-#ifdef RPI
-//#define NO_STORAGE
-#endif
-
-#include <errno.h>
-
-#include "platform/input/Mouse.h"
-#include "platform/input/Multitouch.h"
-
-#include "world/item/Item.h"
-#include "world/level/Level.h"
-#include "world/level/biome/Biome.h"
-#include "world/level/material/Material.h"
-#include "world/entity/MobCategory.h"
-//#include "world/level/storage/FolderMethods.h"
-#ifndef STANDALONE_SERVER
-#include "client/gui/screens/StartMenuScreen.h"
-#include "client/gui/screens/UsernameScreen.h"
-#endif
-#include "client/player/LocalPlayer.h"
-#ifndef STANDALONE_SERVER
-#include "client/renderer/gles.h"
-#include "client/renderer/Chunk.h"
-#include "client/renderer/LevelRenderer.h"
-#include "client/renderer/Tesselator.h"
-#endif
-// sorry for raknet dependency, but I'm too lazy to find another getTime method
-#include "raknet/GetTime.h"
-#include "network/RakNetInstance.h"
-#include "network/ClientSideNetworkHandler.h"
-#include "client/gui/screens/ProgressScreen.h"
-
-//#include "world/entity/player/Inventory2.h"
-
-#if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION) && !defined(NO_STORAGE)
-	#include "world/level/storage/ExternalFileLevelStorageSource.h"
-#else
-	#include "world/level/storage/MemoryLevelStorageSource.h"
-#endif
-#ifndef STANDALONE_SERVER
-#include "client/renderer/Textures.h"
-#include "client/renderer/entity/ItemRenderer.h"
-#endif
-#include "world/item/crafting/Recipes.h"
-#include "world/level/tile/entity/TileEntity.h"
-#ifndef STANDALONE_SERVER
-#include "client/renderer/EntityTileRenderer.h"
-#endif
-
-bool NinecraftApp::_hasInitedStatics = false;
-
-NinecraftApp::NinecraftApp()
-:   _verbose(true),
-	_lastTickMs(0),
-	_frames(0)
-{
-    #if defined(ANDROID) || defined(__APPLE__) || defined(RPI)
-        signal(SIGPIPE, SIG_IGN);
-    #endif
-}
-
-NinecraftApp::~NinecraftApp()
-{
-	teardown();
-}
-
-void NinecraftApp::init()
-{
-	// Global initialization goes here
-	Mth::initMth();
-
-	//#ifdef DEMO_MODE
-	//writeDemoFile();
-	//#endif
-
-	// If we're running Android, only initialize
-	// the first time class is instanced
-	#ifdef ANDROID
-	if (!_hasInitedStatics) {
-		_hasInitedStatics = true;
-	#endif
-		Material::initMaterials();
-		MobCategory::initMobCategories();
-		Tile::initTiles();
-		Item::initItems();
-		Biome::initBiomes();
-		TileEntity::initTileEntities();
-
-	#ifdef ANDROID
-	}
-	#endif
-
-#ifndef STANDALONE_SERVER
-	initGLStates();
-	Tesselator::instance.init();
-	I18n::loadLanguage(platform(), "en_US");
-#endif
-
-	Minecraft::init();
-
-#if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION) && !defined(NO_STORAGE)
-	storageSource = new ExternalFileLevelStorageSource(externalStoragePath, externalCacheStoragePath);
-#else
-	storageSource = new MemoryLevelStorageSource();
-#endif
-	_running = false;
-
-#ifndef STANDALONE_SERVER
-	LOGI("This: %p\n", this);
-	screenChooser.setScreen(SCREEN_STARTMENU);
-
-	if (options.getBooleanValue(OPTIONS_FIRST_LAUNCH)) {
-		options.toggle(OPTIONS_FIRST_LAUNCH);
-		setScreen(new UsernameScreen());
-	}
-#else
-	user->name = "Server";
-	hostMultiplayer();
-#endif
-}
-
-void NinecraftApp::teardown()
-{
-	// Note: Don't tear down statics if we run on Android
-	// (we might change this in the future)
-#ifndef ANDROID
-	Biome::teardownBiomes();
-	Item ::teardownItems();
-	Tile ::teardownTiles();
-	Material::teardownMaterials();
-	Recipes ::teardownRecipes();
-	TileEntity::teardownTileEntities();
-#endif
-#ifdef WIN32
-	ItemRenderer::teardown_static();
-	if (EntityTileRenderer::instance != NULL) {
-		delete EntityTileRenderer::instance;
-		EntityTileRenderer::instance = NULL;
-	}
-	TileEntityRenderDispatcher::destroy();
-#endif
-}
-
-void NinecraftApp::update()
-{
-	++_frames;
-
-	// Generate Multitouch active pointer list
-	Multitouch::commit();
-
-#ifndef ANDROID_PUBLISH
-	//testCreationAndDestruction();
-	//testJoiningAndDestruction();
-#endif /*ANDROID_PUBLISH*/
-
-	Minecraft::update();
-
-	swapBuffers();
-	Mouse::reset2();
-
-    // Restart the server if (our modded) RakNet reports an error
-    if (level && raknetInstance->isProbablyBroken() && raknetInstance->isServer()) {
-        restartServer();
-    }
-
-#ifndef WIN32
-	updateStats();
-#endif
-}
-
-void NinecraftApp::updateStats()
-{
-#ifndef STANDALONE_SERVER
-	if (Options::debugGl)
-		LOGI("--------------------------------------------\n");
-
-	//*
-	int now = getTimeMs();
-	//int since = now - _lastTickMs;
-
-	if (now >= lastTime + 1000)
-	{
-		if (player) {
-			LOGI("%d fps   \t%3d chunk updates.   (%.2f, %.2f, %.2f)\n",
-				_frames, Chunk::updates, player->x, player->y, player->z);
-			Chunk::resetUpdates();
-
-			//static int _n = 0;
-			//if (++_n % 5 == -1) { // @note: -1
-			//	static char filename[256];
-			//	sprintf(filename, "%s/games/com.mojang/img_%.4d.jpg", externalStoragePath.c_str(), _n/5);
-			//	_context.platform->saveScreenshot(filename, width, height);
-			//}
-
-			LOGI("%s", levelRenderer->gatherStats1().c_str());
-			//printf("Texture swaps (this frame): %d\n", Textures::textureChanges);
-		} else {
-			LOGI("%d fps\n", _frames);
-		}
-
-		//const int* pointerIds;
-		//int pointerCount = Multitouch::getActivePointerIds(&pointerIds);
-		//if (pointerCount) {
-		//	std::string s = "Pointers (";
-		//	s += (char)(48 + pointerCount);
-		//	s += ": ";
-		//	for (int i = 0; i < pointerCount; ++i) {
-		//		s += (char)(48 + pointerIds[i]);
-		//		s += ", ";
-		//	}
-		//	LOGI("%s\n", s.c_str());
-		//}
-
-		lastTime = now;
-		_frames = 0;
-#ifdef GLDEBUG
-		while (1) {
-			int error = glGetError();
-			if (error == GL_NO_ERROR) break;
-
-			LOGI("#################### GL-ERROR: %d\t#####################\n", error);
-			LOGI("#################### GL-ERROR: %d\t#####################\n", error);
-			LOGI("#################### GL-ERROR: %d\t#####################\n", error);
-		}
-#endif
-	}
-	Textures::textureChanges = 0;
-	/**/
-#endif /* STANDALONE_SERVER */
-}
-
-void NinecraftApp::initGLStates()
-{
-#ifndef STANDALONE_SERVER
-	//glShadeModel2(GL_SMOOTH);
-	//glClearDepthf(1.0f);
-	glEnable2(GL_DEPTH_TEST);
-	glDepthFunc(GL_LEQUAL);
-	glDepthRangef(0, 1);
-	glEnable2(GL_ALPHA_TEST);
-	glAlphaFunc(GL_GREATER, 0.1f);
-	glEnable(GL_CULL_FACE);
-	glCullFace(GL_BACK);
-
-	glEnable2(GL_TEXTURE_2D);
-	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
-
-	// Both updates isPowerVR flag in java and returns if the graphics chip is PowerVR SGX or not
-	_powerVr = platform()->isPowerVR();
-#ifdef __APPLE__
-    _isSuperFast = platform()->isSuperFast();
-#endif
-	//glLineWidth(4);
-#endif /* STANDALONE_SERVER */
-}
-
-void NinecraftApp::restartServer() {
-    if (!level) return;
-
-    for (int i = level->players.size()-1; i >= 0; --i) {
-        Player* p = level->players[i];
-        if (p != player)
-            level->removeEntity(p);
-    }
-
-	raknetInstance->resetIsBroken();
-#ifndef STANDALONE_SERVER
-    gui.addMessage("This server has restarted!");
-#endif
-    hostMultiplayer();
-    if (netCallback) netCallback->levelGenerated(level);
-}
-
-bool NinecraftApp::handleBack(bool isDown)
-{
-	if (isGeneratingLevel)
-	{
-		return true;
-	}
-	if (level)
-	{
-		if (!isDown)
-		{
-			if (screen)
-			{
-				if (!screen->handleBackEvent(isDown))
-				{
-					if (player->containerMenu) player->closeContainer();
-					setScreen(NULL);
-				}
-				return true;
-			} else {
-				pauseGame(true);
-			}
-			//leaveGame();
-			return false;
-		}
-		return true;
-	}
-	else if (screen)
-	{
-		return screen->handleBackEvent(isDown);
-	}
-	return false;
-}
-
-void NinecraftApp::onGraphicsReset()
-{
-#ifndef STANDALONE_SERVER
-	initGLStates();
-	Tesselator::instance.init();
-
-	Minecraft::onGraphicsReset();
-#endif
-}
-
-#ifndef ANDROID_PUBLISH
-
-static int _state = -1;
-static int _stateTicksLeft = 0;
-void NinecraftApp::testCreationAndDestruction()
-{
-	if (_state == -1) {
-		_stateTicksLeft = 100;
-		_state = 0;
-	}
-	if (_state == 0) {
-		if (--_stateTicksLeft <= 0)
-			_state = 1;
-	}
-	else if (_state == 1) {
-		getLevelSource()->deleteLevel("perf");
-		int seed = getEpochTimeS();
-		LOGI(">seed %d\n", seed);
-		selectLevel("perf", "perf", LevelSettings(seed, GameType::Creative));
-		hostMultiplayer();
-#ifndef STANDALONE_SERVER
-		setScreen(new ProgressScreen());
-#endif
-		_state = 2;
-		_stateTicksLeft = 1000;//25000;//00;
-	}
-	else if (_state == 2) {
-		if (isLevelGenerated()) {
-			if (--_stateTicksLeft <= 0) {
-				_state = 3;
-			}
-		}
-	} else if (_state == 3) {
-		leaveGame();
-		_state = 1;
-	}
-}
-
-
-void NinecraftApp::testJoiningAndDestruction()
-{
-	if (_state == -1) {
-		//LightUpdate sz[2] = {	LightUpdate(LightLayer::Block, 0, 0, 0, 1, 1, 1), 
-		//						LightUpdate(LightLayer::Sky, 0, 0, 0, 1, 1, 1) };
-		//LOGI("size of lightupdate: %lu == %d\n", sizeof(LightUpdate), (const char*)&sz[1] - (const char*)&sz[0]);
-		_stateTicksLeft = 100;
-		_state = 0;
-	}
-	if (_state == 0) {
-		if (--_stateTicksLeft <= 0) {
-			raknetInstance->clearServerList();
-			locateMultiplayer();
-			_state = 1;
-		}
-	}
-	else if (_state == 1) {
-		if (!raknetInstance->getServerList().empty()) {
-			PingedCompatibleServer s = raknetInstance->getServerList().at(0);
-			if (s.name.GetLength() > 0) {
-				joinMultiplayer(s);
-#ifndef STANDALONE_SERVER
-				setScreen(new ProgressScreen());
-#endif
-				_state = 2;
-				_stateTicksLeft = 80;//1000;
-			}
-		}
-	}
-	else if (_state == 2) {
-		if (isLevelGenerated()) {
-			if (--_stateTicksLeft <= 0) {
-				_state = 3;
-			}
-		}
-	} else if (_state == 3) {
-		leaveGame();
-		_stateTicksLeft = 50;
-		_state = 0;
-	}
-}
-
-#endif /*ANDROID_PUBLISH*/
-
-/*
-void NinecraftApp::writeDemoFile() {
-	std::string path = externalStoragePath + "/games";
-
-	if (createFolderIfNotExists(path.c_str())) {
-	path += "/com.mojang";
-	if (createFolderIfNotExists(path.c_str())) {
-	path += "/minecraftpe";
-	if (createFolderIfNotExists(path.c_str())) {
-		path += "/played_demo";
-		FILE* fp = fopen(path.c_str(), "w");
-		if (fp) fclose(fp);
-	}}}
-}
-
-bool NinecraftApp::hasPlayedDemo() {
-	std::string filename = externalStoragePath + "/games/com.mojang/minecraftpe/played_demo";
-	FILE* fp = fopen(filename.c_str(), "r");
-	if (!fp) return false;
-	fclose(fp);
-	return true;
-}
-*/

src/NinecraftApp.h

@@ -1,52 +0,0 @@
-#ifndef NINECRAFTAPP_H__
-#define NINECRAFTAPP_H__
-
-#include "world/Pos.h"
-#include "App.h"
-#include "client/Minecraft.h"
-#include "world/level/storage/MemoryLevelStorage.h"
-#include <string>
-
-
-class Level;
-class LocalPlayer;
-class ExternalFileLevelStorageSource;
-
-class NinecraftApp: public Minecraft
-{
-public:
-    NinecraftApp();
-	~NinecraftApp();
-
-	void init();
-	void teardown();
-
-	void update();
-
-	virtual bool handleBack(bool isDown);
-
-protected:
-	void onGraphicsReset();
-
-private:
-	void initGLStates();
-    void restartServer();
-
-	void updateStats();
-
-	//void writeDemoFile();
-	//bool hasPlayedDemo();
-
-#ifndef ANDROID_PUBLISH
-	void testCreationAndDestruction();
-	void testJoiningAndDestruction();
-#endif /*ANDROID_PUBLISH*/
-
-	bool _verbose;
-	int _frames;
-	int _lastTickMs;
-
-	static bool _hasInitedStatics;
-};
-
-#endif//NINECRAFTAPP_H__

src/Performance.cpp

@@ -1,4 +1,4 @@
-#include "Performance.h"
-
-/*static*/
-StopwatchHandler Performance::watches;
+#include "Performance.hpp"
+
+/*static*/
+StopwatchHandler Performance::watches;

src/Performance.h

@@ -1,12 +0,0 @@
-#ifndef PERFORMANCE_H__
-#define PERFORMANCE_H__
-
-#include "platform/time.h"
-
-class Performance
-{
-public:
-    static StopwatchHandler watches;
-};
-
-#endif /*PERFORMANCE_H__*/

src/Performance.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "platform/time.hpp"
+
+class Performance
+{
+public:
+    static StopwatchHandler watches;
+};
+

src/SharedConstants.cpp

@@ -1,16 +1,16 @@
-#include "SharedConstants.h"
-
-namespace Common {
-
-std::string getGameVersionString(const std::string& versionSuffix /* = "" */)
-{
-	std::string result = std::string("v0.6.1") + versionSuffix;
-	// append 64-bit port marker only on Android 64‑bit targets
-	#if defined(ANDROID) && (defined(__aarch64__) || defined(__x86_64__))
-		result += " (64-bit port)";
-	#endif
-	result += " alpha";
-	return result;
-}
-
-};
+#include "SharedConstants.hpp"
+
+namespace Common {
+
+std::string getGameVersionString(const std::string& versionSuffix /* = "" */)
+{
+	std::string result = std::string("v0.6.1") + versionSuffix;
+	// append 64-bit port marker only on Android 64‑bit targets
+	#if defined(ANDROID) && (defined(__aarch64__) || defined(__x86_64__))
+		result += " (64-bit port)";
+	#endif
+	result += " alpha";
+	return result;
+}
+
+};

src/SharedConstants.hpp

@@ -1,34 +1,32 @@
-#ifndef NET_MINECRAFT_SharedConstants_H__
-#define NET_MINECRAFT_SharedConstants_H__
-
-#include <string>
-
-enum LevelGeneratorVersion
-{
-	LGV_ORIGINAL = 0,
-};
-
-namespace Common {
-	std::string getGameVersionString(const std::string& versionSuffix = "");
-}
-
-namespace SharedConstants
-{
-	// 0.5.0 uses NPv8
-	// 0.6.0 uses NPv9
-    const int NetworkProtocolVersion = 9;
-	const int NetworkProtocolLowestSupportedVersion = 9;
-	const int GameProtocolVersion = 1;
-	const int GameProtocolLowestSupportedVersion = 1;
-
-	const int StorageVersion = 3;
-
-	const int MaxChatLength = 100;
-    
-	const int TicksPerSecond = 20;
-
-	const int GeneratorVersion = (int)LGV_ORIGINAL;
-	//int FULLBRIGHT_LIGHTVALUE = 15 << 20 | 15 << 4;
-}
-
-#endif /*NET_MINECRAFT_SharedConstants_H__*/
+#pragma once
+
+#include <string>
+
+enum LevelGeneratorVersion
+{
+	LGV_ORIGINAL = 0,
+};
+
+namespace Common {
+	std::string getGameVersionString(const std::string& versionSuffix = "");
+}
+
+namespace SharedConstants
+{
+	// 0.5.0 uses NPv8
+	// 0.6.0 uses NPv9
+    const int NetworkProtocolVersion = 9;
+	const int NetworkProtocolLowestSupportedVersion = 9;
+	const int GameProtocolVersion = 1;
+	const int GameProtocolLowestSupportedVersion = 1;
+
+	const int StorageVersion = 3;
+
+	const int MaxChatLength = 100;
+    
+	const int TicksPerSecond = 20;
+
+	const int GeneratorVersion = (int)LGV_ORIGINAL;
+	//int FULLBRIGHT_LIGHTVALUE = 15 << 20 | 15 << 4;
+}
+

src/client/IConfigListener.cpp

@@ -1,16 +1,16 @@
-#include "IConfigListener.h"
-#include "Minecraft.h"
-#ifndef STANDALONE_SERVER
-#include "gui/Gui.h"
-#endif /* STANDALONE_SERVER */
-Config createConfig(Minecraft* mc) {
-	Config c;
-	#ifndef STANDALONE_SERVER
-	c.setScreenSize(mc->width, mc->height, Gui::GuiScale);
-	#endif
-	c.pixelCalc   = mc->pixelCalc;
-	c.pixelCalcUi = mc->pixelCalcUi;
-	c.minecraft = mc;
-	c.options   = &mc->options;
-	return c;
-}
+#include "IConfigListener.hpp"
+#include "Minecraft.hpp"
+#ifndef STANDALONE_SERVER
+#include "gui/Gui.hpp"
+#endif /* STANDALONE_SERVER */
+Config createConfig(Minecraft* mc) {
+	Config c;
+	#ifndef STANDALONE_SERVER
+	c.setScreenSize(mc->width, mc->height, Gui::GuiScale);
+	#endif
+	c.pixelCalc   = mc->pixelCalc;
+	c.pixelCalcUi = mc->pixelCalcUi;
+	c.minecraft = mc;
+	c.options   = &mc->options;
+	return c;
+}

src/client/IConfigListener.hpp

@@ -1,48 +1,46 @@
-#ifndef CONFIGLISTENER_H__
-#define CONFIGLISTENER_H__
-
-#include "PixelCalc.h"
-class Minecraft;
-class Options;
-
-class Config {
-public:
-    // Screen dimensions and world-to-screen conversion
-    void setScreenSize(int width, int height, float scale) {
-        this->width = width;
-        this->height = height;
-        this->guiScale = scale;
-        this->invGuiScale = 1.0f / scale;
-        this->guiWidth = (int)(width * invGuiScale);
-        this->guiHeight = (int)(height * invGuiScale);
-    }
-
-	int width;
-	int height;
-
-	float guiScale;
-    float invGuiScale;
-    int guiWidth;
-    int guiHeight;
-
-    PixelCalc pixelCalc;
-    PixelCalc pixelCalcUi;
-
-    Minecraft* minecraft;
-    Options* options;
-};
-
-Config createConfig(Minecraft* mc);
-
-// Interface for Configuration-Changed listener
-// This can mean (for instance);
-// - Screen has changed dimensions, or rotation if rotations are enabled
-// - New input device or control mechanism
-class IConfigListener
-{
-public:
-    virtual ~IConfigListener() {}
-    virtual void onConfigChanged(const Config& config) = 0;
-};
-
-#endif /*CONFIGLISTENER_H__*/
+#pragma once
+
+#include "PixelCalc.hpp"
+class Minecraft;
+class Options;
+
+class Config {
+public:
+    // Screen dimensions and world-to-screen conversion
+    void setScreenSize(int width, int height, float scale) {
+        this->width = width;
+        this->height = height;
+        this->guiScale = scale;
+        this->invGuiScale = 1.0f / scale;
+        this->guiWidth = (int)(width * invGuiScale);
+        this->guiHeight = (int)(height * invGuiScale);
+    }
+
+	int width;
+	int height;
+
+	float guiScale;
+    float invGuiScale;
+    int guiWidth;
+    int guiHeight;
+
+    PixelCalc pixelCalc;
+    PixelCalc pixelCalcUi;
+
+    Minecraft* minecraft;
+    Options* options;
+};
+
+Config createConfig(Minecraft* mc);
+
+// Interface for Configuration-Changed listener
+// This can mean (for instance);
+// - Screen has changed dimensions, or rotation if rotations are enabled
+// - New input device or control mechanism
+class IConfigListener
+{
+public:
+    virtual ~IConfigListener() {}
+    virtual void onConfigChanged(const Config& config) = 0;
+};
+

src/client/KeyMapping.h

@@ -1,21 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT__KeyMapping_H__
-#define NET_MINECRAFT_CLIENT__KeyMapping_H__
-
-//package net.minecraft.client;
-#include <string>
-
-class KeyMapping
-{
-public:
-    std::string name;
-    int key;
-    
-	KeyMapping() {}
-
-    KeyMapping(const std::string& name_, int key_)
-	:	name(name_),
-		key(key_)
-    {}
-};
-
-#endif /*NET_MINECRAFT_CLIENT__KeyMapping_H__*/

src/client/Minecraft.h

@@ -1,229 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT__Minecraft_H__
-#define NET_MINECRAFT_CLIENT__Minecraft_H__
-
-#include "Options.h"
-#ifndef STANDALONE_SERVER
-#include "MouseHandler.h"
-#include "gui/Gui.h"
-#include "gui/screens/ScreenChooser.h"
-#endif
-
-#include "Timer.h"
-
-//#include "../network/RakNetInstance.h"
-#include "../world/phys/HitResult.h"
-
-class User;
-class Level;
-class LocalPlayer;
-class IInputHolder;
-class Mob;
-class Player;
-class LevelRenderer;
-class GameRenderer;
-class ParticleEngine;
-class Entity;
-class ICreator;
-class GameMode;
-class Textures;
-class CThread;
-class SoundEngine;
-class Screen;
-class Font;
-class LevelStorageSource;
-class BuildActionIntention;
-class PerfRenderer;
-class LevelSettings;
-class IRakNetInstance;
-class NetEventCallback;
-class CommandServer;
-struct PingedCompatibleServer;
-//class ExternalFileLevelStorageSource;
-
-
-#include "../App.h"
-#include "PixelCalc.h"
-class AppPlatform;
-class AppPlatform_android;
-
-class Minecraft: public App
-{
-protected:
-	Minecraft();
-public:
-	virtual ~Minecraft();
-
-	void init();
-	void setSize(int width, int height);
-	void reloadOptions();
-
-	bool supportNonTouchScreen();
-	bool useTouchscreen();
-	void grabMouse();
-	void releaseMouse();
-
-	void handleBuildAction(BuildActionIntention*);
-
-	void toggleDimension(){}
-	bool isCreativeMode();
-	void setIsCreativeMode(bool isCreative);
-	void setScreen(Screen*);
-
-	virtual void selectLevel(const std::string& levelId, const std::string& levelName, const LevelSettings& settings);
-	virtual void setLevel(Level* level, const std::string& message = "", LocalPlayer* forceInsertPlayer = NULL);
-
-	void generateLevel( const std::string& message, Level* level );
-	LevelStorageSource* getLevelSource();
-
-	bool isLookingForMultiplayer;
-	void locateMultiplayer();
-	void cancelLocateMultiplayer();
-	bool joinMultiplayer(const PingedCompatibleServer& server);
-	bool joinMultiplayerFromString(const std::string& server);
-	void hostMultiplayer(int port=19132);
-	Player* respawnPlayer(int playerId);
-	void respawnPlayer();
-	void resetPlayer(Player* player);
-	void doActuallyRespawnPlayer();
-
-	void update();
-
-	void tick(int nTick, int maxTick);
-	void tickInput();
-
-	bool isOnlineClient();
-	bool isOnline();
-	void pauseGame(bool isBackPaused);
-	void gameLostFocus();
-
-	void prepareLevel(const std::string& message);
-
-	void leaveGame(bool renameLevel = false);
-
-	int getProgressStatusId();
-	const char* getProgressMessage();
-
-	ICreator* getCreator();
-
-	// void onGraphicsLost() {}
-	void onGraphicsReset();
-
-	bool isLevelGenerated();
-
-    void audioEngineOn();
-    void audioEngineOff();
-    
-	bool isPowerVR() { return _powerVr; }
-	bool isKindleFire(int kindleVersion);
-	bool transformResolution(int* w, int* h);
-	void optionUpdated(OptionId option, bool value);
-	void optionUpdated(OptionId option, float value);
-	void optionUpdated(OptionId option, int value);
-#ifdef __APPLE__
-    bool _isSuperFast;
-    bool isSuperFast() { return _isSuperFast; }
-#endif
-
-protected:
-	void _levelGenerated();
-
-private:
-	static void* prepareLevel_tspawn(void *p_param);
-
-	void _reloadInput();
-public:
-	int width;
-	int height;
-
-	// Vars that the platform is allowed to use in the future
-	int commandPort;
-	int reserved_d1, reserved_d2;
-	float reserved_f1, reserved_f2;
-
-	Options options;
-
-	static bool useAmbientOcclusion;
-	//static bool threadInterrupt;
-
-	volatile bool pause;
-
-	LevelRenderer*  levelRenderer;
-	GameRenderer*   gameRenderer;
-	ParticleEngine* particleEngine;
-	SoundEngine*    soundEngine;
-
-	GameMode* gameMode;
-#ifndef STANDALONE_SERVER
-	Textures* textures;
-	ScreenChooser screenChooser;
-	Font* font;
-#endif
-	IRakNetInstance*  raknetInstance;
-	NetEventCallback* netCallback;
-
-	int lastTime;
-	int lastTickTime;
-	float ticksSinceLastUpdate;
-
-	User*  user;
-	Level* level;
-
-	LocalPlayer*	player;
-	IInputHolder*	inputHolder;
-	Mob*			cameraTargetPlayer;
-#ifndef STANDALONE_SERVER
-	Gui gui;
-#endif
-	CThread* generateLevelThread;
-	Screen* screen;
-	static int customDebugId;
-
-	static const int CDI_NONE = 0;
-	static const int CDI_GRAPHICS = 1;
-#ifndef STANDALONE_SERVER
-	MouseHandler mouseHandler;
-#endif
-	bool mouseGrabbed;
-
-    PixelCalc pixelCalc;
-    PixelCalc pixelCalcUi;
-
-	HitResult hitResult;
-	volatile int progressStagePercentage;
-
-	// This field is initialized in main()
-	// It sets the base path to where worlds can be written (sdcard on android)
-	std::string externalStoragePath;
-	std::string externalCacheStoragePath;
-protected:
-	Timer timer;
-    // @note @attn @warn: this is dangerous as fuck!
-	volatile bool isGeneratingLevel;
-	bool _hasSignaledGeneratingLevelFinished;
-
-	LevelStorageSource* storageSource;
-	bool _running;
-	bool _powerVr;
-
-private:
-	volatile int progressStageStatusId;
-	static const char* progressMessages[];
-
-	int missTime;
-	int ticks;
-	bool screenMutex;
-	bool hasScheduledScreen;
-	Screen* scheduledScreen;
-
-	int _licenseId;
-	bool _supportsNonTouchscreen;
-
-	bool _isCreativeMode;
-	//int _respawnPlayerTicks;
-	Player* _pendingRemovePlayer; // @attn @todo @fix: remove this shait and fix the respawn behaviour
-
-	PerfRenderer* _perfRenderer;
-	CommandServer* _commandServer;
-};
-
-#endif /*NET_MINECRAFT_CLIENT__Minecraft_H__*/

src/client/MouseHandler.cpp

@@ -1,60 +1,60 @@
-#include "MouseHandler.h"
-#include "player/input/ITurnInput.h"
-
-#ifdef RPI
-#include <SDL/SDL.h>
-#endif
-
-#ifdef PLATFORM_GLFW
-#include <GLFW/glfw3.h>
-#endif
-
-MouseHandler::MouseHandler( ITurnInput* turnInput )
-:	_turnInput(turnInput)
-{}
-
-MouseHandler::MouseHandler()
-:	_turnInput(0)
-{}
-
-MouseHandler::~MouseHandler() {
-}
-
-void MouseHandler::setTurnInput( ITurnInput* turnInput ) {
-	_turnInput = turnInput;
-}
-
-void MouseHandler::grab() {
-	xd = 0;
-	yd = 0;
-
-#if defined(RPI)
-	//LOGI("Grabbing input!\n");
-	SDL_WM_GrabInput(SDL_GRAB_ON);
-	SDL_ShowCursor(0);
-#endif
-
-#ifdef PLATFORM_GLFW
-	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_DISABLED);
-#endif
-}
-
-void MouseHandler::release() {
-#if defined(RPI)
-	//LOGI("Releasing input!\n");
-	SDL_WM_GrabInput(SDL_GRAB_OFF);
-	SDL_ShowCursor(1);
-#endif
-
-#ifdef PLATFORM_GLFW
-	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
-#endif
-}
-
-void MouseHandler::poll() {
-	if (_turnInput != 0) {
-		TurnDelta td = _turnInput->getTurnDelta();
-		xd = td.x;
-		yd = td.y;
-	}
-}
+#include "MouseHandler.hpp"
+#include "player/input/ITurnInput.hpp"
+
+#ifdef RPI
+#include <SDL/SDL.h>
+#endif
+
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
+#include <GLFW/glfw3.h>
+#endif
+
+MouseHandler::MouseHandler( ITurnInput* turnInput )
+:	_turnInput(turnInput)
+{}
+
+MouseHandler::MouseHandler()
+:	_turnInput(0)
+{}
+
+MouseHandler::~MouseHandler() {
+}
+
+void MouseHandler::setTurnInput( ITurnInput* turnInput ) {
+	_turnInput = turnInput;
+}
+
+void MouseHandler::grab() {
+	xd = 0;
+	yd = 0;
+
+#if defined(RPI)
+	//LOGI("Grabbing input!\n");
+	SDL_WM_GrabInput(SDL_GRAB_ON);
+	SDL_ShowCursor(0);
+#endif
+
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
+	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+#endif
+}
+
+void MouseHandler::release() {
+#if defined(RPI)
+	//LOGI("Releasing input!\n");
+	SDL_WM_GrabInput(SDL_GRAB_OFF);
+	SDL_ShowCursor(1);
+#endif
+
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
+	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+#endif
+}
+
+void MouseHandler::poll() {
+	if (_turnInput != 0) {
+		TurnDelta td = _turnInput->getTurnDelta();
+		xd = td.x;
+		yd = td.y;
+	}
+}

src/client/MouseHandler.hpp

@@ -1,28 +1,26 @@
-#ifndef NET_MINECRAFT_CLIENT__MouseHandler_H__
-#define NET_MINECRAFT_CLIENT__MouseHandler_H__
-
-//package net.minecraft.client;
-
-class ITurnInput;
-
-class MouseHandler
-{
-public:
-	MouseHandler(ITurnInput* turnInput);
-	MouseHandler();
-	~MouseHandler();
-
-	void setTurnInput(ITurnInput* turnInput);
-
-    void grab();
-    void release();
-
-    void poll();
-
-    float xd, yd;
-private:
-	int toSkip;
-	ITurnInput* _turnInput;
-};
-
-#endif /*NET_MINECRAFT_CLIENT__MouseHandler_H__*/
+#pragma once
+
+//package net.minecraft.client;
+
+class ITurnInput;
+
+class MouseHandler
+{
+public:
+	MouseHandler(ITurnInput* turnInput);
+	MouseHandler();
+	~MouseHandler();
+
+	void setTurnInput(ITurnInput* turnInput);
+
+    void grab();
+    void release();
+
+    void poll();
+
+    float xd, yd;
+private:
+	int toSkip;
+	ITurnInput* _turnInput;
+};
+

src/client/Option.cpp

@@ -1,5 +1,8 @@
-#include "Option.h"
+#include "Option.hpp"
 #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.hpp

@@ -1,7 +1,7 @@
 #pragma once 
 #include <sstream>
 #include <type_traits>
-#include "Mth.h"
+#include <util/Mth.hpp>
 /*
 template<typename T>
 struct is_option_type : std::false_type {};
@@ -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; }
 
@@ -104,4 +104,4 @@ public:
 
 private:
     std::string m_value;
-};
+};

src/client/OptionStrings.cpp

@@ -1,4 +1,4 @@
-#include "OptionStrings.h"
+#include "OptionStrings.hpp"
 
 const char* OptionStrings::Multiplayer_Username        = "mp_username";
 const char* OptionStrings::Multiplayer_ServerVisible   = "mp_server_visible_default";

src/client/OptionStrings.hpp

@@ -1,5 +1,4 @@
-#ifndef NET_MINECRAFT_CLIENT__OptionStrings_H__
-#define NET_MINECRAFT_CLIENT__OptionStrings_H__
+#pragma once
 
 class OptionStrings {
 public:
@@ -33,4 +32,3 @@ public:
 
 };
 
-#endif /*NET_MINECRAFT_CLIENT__OptionsStrings_H__*/

src/client/Options.cpp

@@ -1,304 +1,297 @@
-#include "Options.h"
-#include "OptionStrings.h"
-#include "Minecraft.h"
-#include "../platform/log.h"
-#include "../world/Difficulty.h"
-#include <cmath>
-
-#include <memory>
-
-bool Options::debugGl = false;
-
-// OPTIONS TABLE
-
-OptionInt difficulty("difficulty", Difficulty::NORMAL, 0, Difficulty::COUNT);
-OptionBool hidegui("hidegui", false);
-OptionBool thirdPersonView("thirdperson", false);
-OptionBool renderDebug("renderDebug", false);
-OptionBool smoothCamera("smoothCamera", false);
-OptionBool fixedCamera("fixedCamera", false);
-OptionBool isFlying("isflying", false);
-OptionBool barOnTop("barOnTop", false);
-OptionBool allowSprint("allowSprint", true);
-OptionBool autoJump("autoJump", true);
-
-
-OptionFloat flySpeed("flySpeed", 1.f);
-OptionFloat cameraSpeed("cameraSpeed", 1.f);
-
-OptionInt guiScale("guiScale", 0, 0, 5);
-
-OptionString skin("skin", "Default");
-
-#ifdef RPI
-OptionString username("username", "StevePi");
-#else 
-OptionString username("username", "Steve");
-#endif
-
-OptionBool destroyVibration("destroyVibration", true);
-OptionBool isLeftHanded("isLeftHanded", false);
-OptionBool isJoyTouchArea("isJoyTouchArea", false);
-
-OptionFloat musicVolume("music", 1.f, MUSIC_MIN_VALUE, MUSIC_MAX_VALUE);
-OptionFloat soundVolume("sound", 1.f, SOUND_MIN_VALUE, SOUND_MAX_VALUE);
-
-OptionFloat sensitivityOpt("sensitivity", 0.5f, SENSITIVITY_MIN_VALUE, SENSITIVITY_MAX_VALUE);
-
-OptionBool invertYMouse("invertMouse", false);
-OptionInt viewDistance("renderDistance", 2, 0, 4);
-
-OptionBool anaglyph3d("anaglyph3d", false);
-OptionBool limitFramerate("limitFramerate", false);
-OptionBool vsync("vsync", true);
-OptionBool fancyGraphics("fancyGraphics", true);
-OptionBool viewBobbing("viewBobbing", true);
-OptionBool ambientOcclusion("ao", false);
-
-OptionBool useTouchscreen("useTouchscreen", true);
-
-OptionBool serverVisible("servervisible", true);
-
-OptionInt keyForward("key.forward", Keyboard::KEY_W);
-OptionInt keyLeft("key.left", Keyboard::KEY_A);
-OptionInt keyBack("key.back", Keyboard::KEY_S);
-OptionInt keyRight("key.right", Keyboard::KEY_D);
-OptionInt keyJump("key.jump", Keyboard::KEY_SPACE);
-OptionInt keyInventory("key.inventory", Keyboard::KEY_E);
-OptionInt keySneak("key.sneak", Keyboard::KEY_LSHIFT);
-OptionInt keyDrop("key.drop", Keyboard::KEY_Q);
-OptionInt keyChat("key.chat", Keyboard::KEY_T);
-OptionInt keyFog("key.fog", Keyboard::KEY_F);
-OptionInt keyUse("key.use", Keyboard::KEY_U);
-
-// TODO: make human readable keycodes here
-OptionInt keyMenuNext("key.menu.next", 40);
-OptionInt keyMenuPrev("key.menu.previous", 38);
-OptionInt keyMenuOk("key.menu.ok", 13);
-OptionInt keyMenuCancel("key.menu.cancel", 8);
-
-OptionBool firstLaunch("firstLaunch", true);
-
-OptionString lastIp("lastip");
-
-void Options::initTable() {
-    m_options[OPTIONS_DIFFICULTY] = &difficulty;
-    m_options[OPTIONS_HIDEGUI] = &hidegui;
-    m_options[OPTIONS_THIRD_PERSON_VIEW] = &thirdPersonView;
-    m_options[OPTIONS_RENDER_DEBUG] = &renderDebug;
-    m_options[OPTIONS_SMOOTH_CAMERA] = &smoothCamera;
-    m_options[OPTIONS_FIXED_CAMERA] = &fixedCamera;
-	m_options[OPTIONS_IS_FLYING] = &isFlying;
-
-	m_options[OPTIONS_FLY_SPEED] = &flySpeed;
-	m_options[OPTIONS_CAMERA_SPEED] = &cameraSpeed;
-
-	m_options[OPTIONS_GUI_SCALE] = &guiScale;
-
-	m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
-
-	m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
-	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = &isJoyTouchArea;
-
-	m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
-	m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
-
-	#if defined(PLATFORM_DESKTOP) || defined(RPI)
-		float sensitivity = sensitivityOpt.get();
-		sensitivity *= 0.4f;
-		sensitivityOpt.set(sensitivity);
-	#endif
-
-
-    m_options[OPTIONS_GUI_SCALE] = &guiScale;
-
-	m_options[OPTIONS_SKIN] = &skin;
-	m_options[OPTIONS_USERNAME] = &username;
-
-    m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
-    m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
-
-    m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
-    m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
-
-    m_options[OPTIONS_SENSITIVITY] = &sensitivityOpt;
-
-    m_options[OPTIONS_INVERT_Y_MOUSE] = &invertYMouse;
-    m_options[OPTIONS_VIEW_DISTANCE] = &viewDistance;
-
-    m_options[OPTIONS_ANAGLYPH_3D] = &anaglyph3d;
-    m_options[OPTIONS_LIMIT_FRAMERATE] = &limitFramerate;
-    m_options[OPTIONS_VSYNC] = &vsync;
-    m_options[OPTIONS_FANCY_GRAPHICS] = &fancyGraphics;
-	m_options[OPTIONS_VIEW_BOBBING] = &viewBobbing;
-	m_options[OPTIONS_AMBIENT_OCCLUSION] = &ambientOcclusion;
-
-    m_options[OPTIONS_USE_TOUCHSCREEN] = &useTouchscreen;
-
-    m_options[OPTIONS_SERVER_VISIBLE] = &serverVisible;
-
-    m_options[OPTIONS_KEY_FORWARD] = &keyForward;
-    m_options[OPTIONS_KEY_LEFT] = &keyLeft;
-    m_options[OPTIONS_KEY_BACK] = &keyBack;
-    m_options[OPTIONS_KEY_RIGHT] = &keyRight;
-    m_options[OPTIONS_KEY_JUMP] = &keyJump;
-    m_options[OPTIONS_KEY_INVENTORY] = &keyInventory;
-    m_options[OPTIONS_KEY_SNEAK] = &keySneak;
-    m_options[OPTIONS_KEY_DROP] = &keyDrop;
-    m_options[OPTIONS_KEY_CHAT] = &keyChat;
-    m_options[OPTIONS_KEY_FOG] = &keyFog;
-    m_options[OPTIONS_KEY_USE] = &keyUse;
-
-    m_options[OPTIONS_KEY_MENU_NEXT] = &keyMenuNext;
-    m_options[OPTIONS_KEY_MENU_PREV] = &keyMenuPrev;
-    m_options[OPTIONS_KEY_MENU_OK] = &keyMenuOk;
-    m_options[OPTIONS_KEY_MENU_CANCEL] = &keyMenuCancel;
-
-	m_options[OPTIONS_FIRST_LAUNCH] = &firstLaunch;
-
-	m_options[OPTIONS_BAR_ON_TOP] = &barOnTop;
-	m_options[OPTIONS_ALLOW_SPRINT] = &allowSprint;
-
-	m_options[OPTIONS_AUTOJUMP] = &autoJump;
-	m_options[OPTIONS_LAST_IP] = &lastIp;
-}
-
-void Options::set(OptionId key, const std::string& value) {
-	auto option = opt<OptionString>(key);
-
-	if (option) {
-		option->set(value);
-
-		notifyOptionUpdate(key, value);
-		save();
-	}
-}
-
-void Options::set(OptionId key, float value) {
-	auto option = opt<OptionFloat>(key);
-
-	if (option) {
-		option->set(value);
-
-		notifyOptionUpdate(key, value);
-		save();
-	}
-}
-
-void Options::set(OptionId key, int value) {
-	auto option = opt<OptionInt>(key);
-
-	if (option) {
-		option->set(value);
-
-		notifyOptionUpdate(key, value);
-		save();
-	}
-}
-
-void Options::toggle(OptionId key) {
-	auto option = opt<OptionBool>(key);
-
-	if (option) {
-		option->toggle();
-
-		notifyOptionUpdate(key, option->get());
-		save();
-	}
-}
-
-void Options::load() {
-	StringVector optionStrings = optionsFile.getOptionStrings();
-
-	for (auto i = 0; i < optionStrings.size(); i += 2) {
-		const std::string& key = optionStrings[i];
-		const std::string& value = optionStrings[i+1];
-
-		// FIXME: woah this is so slow 
-		auto opt = std::find_if(m_options.begin(), m_options.end(), [&](auto& it) {
-			return it != nullptr && it->getStringId() == key;
-		});
-
-		if (opt == m_options.end()) continue;
-
-		(*opt)->parse(value);
-/*
-        // //LOGI("reading key: %s (%s)\n", key.c_str(), value.c_str());
-        
-		// // Multiplayer
-		// // if (key == OptionStrings::Multiplayer_Username) username = value;
-		// if (key == OptionStrings::Multiplayer_ServerVisible) {
-		// 	m_options[OPTIONS_SERVER_VISIBLE] = readBool(value);
-		// }
-
-		// // Controls
-        // if (key == OptionStrings::Controls_Sensitivity) {
-		// 	float sens = readFloat(value);
-
-		// 	// sens is in range [0,1] with default/center at 0.5 (for aesthetics)
-        //     // We wanna map it to something like [0.3, 0.9] BUT keep 0.5 @ ~0.5...
-        //     m_options[OPTIONS_SENSITIVITY] = 0.3f + std::pow(1.1f * sens, 1.3f) * 0.42f;
-        // }
-
-		// if (key == OptionStrings::Controls_InvertMouse) {
-		// 	m_options[OPTIONS_INVERT_Y_MOUSE] = readBool(value);
-		// }
-
-		// if (key == OptionStrings::Controls_IsLefthanded) {
-		// 	m_options[OPTIONS_IS_LEFT_HANDED] = readBool(value);
-		// }
-		
-		// if (key == OptionStrings::Controls_UseTouchJoypad) {
-		// 	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = readBool(value) && minecraft->useTouchscreen();
-		// }
-
-		// // Feedback
-		// if (key == OptionStrings::Controls_FeedbackVibration) {
-		// 	m_options[OPTIONS_DESTROY_VIBRATION] = readBool(value);
-		// }
-
-		// // Graphics
-		// if (key == OptionStrings::Graphics_Fancy) {
-		// 	m_options[OPTIONS_FANCY_GRAPHICS] = readBool(value);
-		// }
-
-		// // Graphics extras
-		// if (key == OptionStrings::Graphics_Vsync) {
-		// 	m_options[OPTIONS_VSYNC] = readBool(value);
-		// }
-
-		// if (key == OptionStrings::Graphics_GUIScale) {
-		// 	m_options[OPTIONS_GUI_SCALE] = readInt(value) % 5;
-		// }
-
-		// // Game
-		// if (key == OptionStrings::Game_DifficultyLevel) {
-		// 	readInt(value, difficulty);
-		// 	// Only support peaceful and normal right now
-		// 	if (difficulty != Difficulty::PEACEFUL && difficulty != Difficulty::NORMAL)
-		// 		difficulty = Difficulty::NORMAL;
-		// }*/
-	}
-}
-
-void Options::save() {
-	StringVector stringVec;
-	
-	for (auto& it : m_options) {
-		if (it) stringVec.push_back(it->serialize());
-	}
-
-	optionsFile.save(stringVec);
-}
-
-void Options::notifyOptionUpdate(OptionId key, bool value) {
-	minecraft->optionUpdated(key, value);
-}
-
-void Options::notifyOptionUpdate(OptionId key, float value) {
-	minecraft->optionUpdated(key, value);
-}
-
-void Options::notifyOptionUpdate(OptionId key, int value) {
-	minecraft->optionUpdated(key, value);
-}
+#include "Options.hpp"
+#include "world/Difficulty.hpp"
+#include <MinecraftClient.hpp>
+
+bool Options::debugGl = false;
+
+// OPTIONS TABLE
+
+OptionInt difficulty("difficulty", Difficulty::NORMAL, 0, Difficulty::COUNT);
+OptionBool hidegui("hidegui", false);
+OptionBool thirdPersonView("thirdperson", false);
+OptionBool renderDebug("renderDebug", false);
+OptionBool smoothCamera("smoothCamera", false);
+OptionBool fixedCamera("fixedCamera", false);
+OptionBool isFlying("isflying", false);
+OptionBool barOnTop("barOnTop", false);
+OptionBool allowSprint("allowSprint", true);
+OptionBool rpiCursor("rpiCursor", false);
+OptionBool autoJump("autoJump", true);
+
+
+OptionFloat flySpeed("flySpeed", 1.f);
+OptionFloat cameraSpeed("cameraSpeed", 1.f);
+
+OptionInt guiScale("guiScale", 0, 0, 5);
+
+OptionString skin("skin", "Default");
+
+#ifdef RPI
+OptionString username("username", "StevePi");
+#else 
+OptionString username("username", "Steve");
+#endif
+
+OptionBool destroyVibration("destroyVibration", true);
+OptionBool isLeftHanded("isLeftHanded", false);
+OptionBool isJoyTouchArea("isJoyTouchArea", false);
+
+OptionFloat musicVolume("music", 1.f, MUSIC_MIN_VALUE, MUSIC_MAX_VALUE);
+OptionFloat soundVolume("sound", 1.f, SOUND_MIN_VALUE, SOUND_MAX_VALUE);
+
+OptionFloat sensitivityOpt("sensitivity", 0.5f, SENSITIVITY_MIN_VALUE, SENSITIVITY_MAX_VALUE);
+
+OptionBool invertYMouse("invertMouse", false);
+OptionInt viewDistance("renderDistance", 2, 0, 4);
+
+OptionBool anaglyph3d("anaglyph3d", false);
+OptionBool limitFramerate("limitFramerate", false);
+OptionBool vsync("vsync", true);
+OptionBool fancyGraphics("fancyGraphics", true);
+OptionBool viewBobbing("viewBobbing", true);
+OptionBool ambientOcclusion("ao", false);
+
+OptionBool useTouchscreen("useTouchscreen", true);
+
+OptionBool serverVisible("servervisible", true);
+
+OptionInt keyForward("key.forward", Keyboard::KEY_W);
+OptionInt keyLeft("key.left", Keyboard::KEY_A);
+OptionInt keyBack("key.back", Keyboard::KEY_S);
+OptionInt keyRight("key.right", Keyboard::KEY_D);
+OptionInt keyJump("key.jump", Keyboard::KEY_SPACE);
+OptionInt keyInventory("key.inventory", Keyboard::KEY_E);
+OptionInt keySneak("key.sneak", Keyboard::KEY_LSHIFT);
+OptionInt keyDrop("key.drop", Keyboard::KEY_Q);
+OptionInt keyChat("key.chat", Keyboard::KEY_T);
+OptionInt keyFog("key.fog", Keyboard::KEY_F);
+OptionInt keyUse("key.use", Keyboard::KEY_U);
+
+// TODO: make human readable keycodes here
+OptionInt keyMenuNext("key.menu.next", 40);
+OptionInt keyMenuPrev("key.menu.previous", 38);
+OptionInt keyMenuOk("key.menu.ok", 13);
+OptionInt keyMenuCancel("key.menu.cancel", 8);
+
+OptionBool firstLaunch("firstLaunch", true);
+
+OptionString lastIp("lastip");
+
+void Options::initTable() {
+    m_options[OPTIONS_DIFFICULTY] = &difficulty;
+    m_options[OPTIONS_HIDEGUI] = &hidegui;
+    m_options[OPTIONS_THIRD_PERSON_VIEW] = &thirdPersonView;
+    m_options[OPTIONS_RENDER_DEBUG] = &renderDebug;
+    m_options[OPTIONS_SMOOTH_CAMERA] = &smoothCamera;
+    m_options[OPTIONS_FIXED_CAMERA] = &fixedCamera;
+	m_options[OPTIONS_IS_FLYING] = &isFlying;
+
+	m_options[OPTIONS_FLY_SPEED] = &flySpeed;
+	m_options[OPTIONS_CAMERA_SPEED] = &cameraSpeed;
+
+	m_options[OPTIONS_GUI_SCALE] = &guiScale;
+
+	m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
+
+	m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
+	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = &isJoyTouchArea;
+
+	m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
+	m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
+
+	#if defined(PLATFORM_DESKTOP) || defined(RPI)
+		float sensitivity = sensitivityOpt.get();
+		sensitivity *= 0.4f;
+		sensitivityOpt.set(sensitivity);
+	#endif
+
+
+    m_options[OPTIONS_GUI_SCALE] = &guiScale;
+
+	m_options[OPTIONS_SKIN] = &skin;
+	m_options[OPTIONS_USERNAME] = &username;
+
+    m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
+    m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
+
+    m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
+    m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
+
+    m_options[OPTIONS_SENSITIVITY] = &sensitivityOpt;
+
+    m_options[OPTIONS_INVERT_Y_MOUSE] = &invertYMouse;
+    m_options[OPTIONS_VIEW_DISTANCE] = &viewDistance;
+
+    m_options[OPTIONS_ANAGLYPH_3D] = &anaglyph3d;
+    m_options[OPTIONS_LIMIT_FRAMERATE] = &limitFramerate;
+    m_options[OPTIONS_VSYNC] = &vsync;
+    m_options[OPTIONS_FANCY_GRAPHICS] = &fancyGraphics;
+	m_options[OPTIONS_VIEW_BOBBING] = &viewBobbing;
+	m_options[OPTIONS_AMBIENT_OCCLUSION] = &ambientOcclusion;
+
+    m_options[OPTIONS_USE_TOUCHSCREEN] = &useTouchscreen;
+
+    m_options[OPTIONS_SERVER_VISIBLE] = &serverVisible;
+
+    m_options[OPTIONS_KEY_FORWARD] = &keyForward;
+    m_options[OPTIONS_KEY_LEFT] = &keyLeft;
+    m_options[OPTIONS_KEY_BACK] = &keyBack;
+    m_options[OPTIONS_KEY_RIGHT] = &keyRight;
+    m_options[OPTIONS_KEY_JUMP] = &keyJump;
+    m_options[OPTIONS_KEY_INVENTORY] = &keyInventory;
+    m_options[OPTIONS_KEY_SNEAK] = &keySneak;
+    m_options[OPTIONS_KEY_DROP] = &keyDrop;
+    m_options[OPTIONS_KEY_CHAT] = &keyChat;
+    m_options[OPTIONS_KEY_FOG] = &keyFog;
+    m_options[OPTIONS_KEY_USE] = &keyUse;
+
+    m_options[OPTIONS_KEY_MENU_NEXT] = &keyMenuNext;
+    m_options[OPTIONS_KEY_MENU_PREV] = &keyMenuPrev;
+    m_options[OPTIONS_KEY_MENU_OK] = &keyMenuOk;
+    m_options[OPTIONS_KEY_MENU_CANCEL] = &keyMenuCancel;
+
+	m_options[OPTIONS_FIRST_LAUNCH] = &firstLaunch;
+
+	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;
+}
+
+void Options::set(OptionId key, const std::string& value) {
+	auto option = opt<OptionString>(key);
+
+	if (option) {
+		option->set(value);
+		notifyOptionUpdate(key, value);
+	}
+}
+
+void Options::set(OptionId key, float value) {
+	auto option = opt<OptionFloat>(key);
+
+	if (option) {
+		option->set(value);
+		notifyOptionUpdate(key, value);
+	}
+}
+
+void Options::set(OptionId key, int value) {
+	auto option = opt<OptionInt>(key);
+
+	if (option) {
+		option->set(value);
+		notifyOptionUpdate(key, value);
+	}
+}
+
+void Options::toggle(OptionId key) {
+	auto option = opt<OptionBool>(key);
+
+	if (option) {
+		option->toggle();
+		notifyOptionUpdate(key, option->get());
+	}
+}
+
+void Options::load() {
+	StringVector optionStrings = optionsFile.getOptionStrings();
+
+	for (auto i = 0; i < optionStrings.size(); i += 2) {
+		const std::string& key = optionStrings[i];
+		const std::string& value = optionStrings[i+1];
+
+		// FIXME: woah this is so slow 
+		auto opt = std::find_if(m_options.begin(), m_options.end(), [&](auto& it) {
+			return it != nullptr && it->getStringId() == key;
+		});
+
+		if (opt == m_options.end()) continue;
+
+		(*opt)->parse(value);
+/*
+        // //LOGI("reading key: %s (%s)\n", key.c_str(), value.c_str());
+        
+		// // Multiplayer
+		// // if (key == OptionStrings::Multiplayer_Username) username = value;
+		// if (key == OptionStrings::Multiplayer_ServerVisible) {
+		// 	m_options[OPTIONS_SERVER_VISIBLE] = readBool(value);
+		// }
+
+		// // Controls
+        // if (key == OptionStrings::Controls_Sensitivity) {
+		// 	float sens = readFloat(value);
+
+		// 	// sens is in range [0,1] with default/center at 0.5 (for aesthetics)
+        //     // We wanna map it to something like [0.3, 0.9] BUT keep 0.5 @ ~0.5...
+        //     m_options[OPTIONS_SENSITIVITY] = 0.3f + std::pow(1.1f * sens, 1.3f) * 0.42f;
+        // }
+
+		// if (key == OptionStrings::Controls_InvertMouse) {
+		// 	m_options[OPTIONS_INVERT_Y_MOUSE] = readBool(value);
+		// }
+
+		// if (key == OptionStrings::Controls_IsLefthanded) {
+		// 	m_options[OPTIONS_IS_LEFT_HANDED] = readBool(value);
+		// }
+		
+		// if (key == OptionStrings::Controls_UseTouchJoypad) {
+		// 	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = readBool(value) && minecraft->useTouchscreen();
+		// }
+
+		// // Feedback
+		// if (key == OptionStrings::Controls_FeedbackVibration) {
+		// 	m_options[OPTIONS_DESTROY_VIBRATION] = readBool(value);
+		// }
+
+		// // Graphics
+		// if (key == OptionStrings::Graphics_Fancy) {
+		// 	m_options[OPTIONS_FANCY_GRAPHICS] = readBool(value);
+		// }
+
+		// // Graphics extras
+		// if (key == OptionStrings::Graphics_Vsync) {
+		// 	m_options[OPTIONS_VSYNC] = readBool(value);
+		// }
+
+		// if (key == OptionStrings::Graphics_GUIScale) {
+		// 	m_options[OPTIONS_GUI_SCALE] = readInt(value) % 5;
+		// }
+
+		// // Game
+		// if (key == OptionStrings::Game_DifficultyLevel) {
+		// 	readInt(value, difficulty);
+		// 	// Only support peaceful and normal right now
+		// 	if (difficulty != Difficulty::PEACEFUL && difficulty != Difficulty::NORMAL)
+		// 		difficulty = Difficulty::NORMAL;
+		// }*/
+	}
+}
+
+void Options::save() {
+	StringVector stringVec;
+	
+	for (auto& it : m_options) {
+		if (it) stringVec.push_back(it->serialize());
+	}
+
+	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);
+}
+
+void Options::notifyOptionUpdate(OptionId key, float value) {
+	minecraft.optionUpdated(key, value);
+}
+
+void Options::notifyOptionUpdate(OptionId key, int value) {
+	minecraft.optionUpdated(key, value);
+}

src/client/Options.hpp

@@ -1,166 +1,164 @@
-#ifndef NET_MINECRAFT_CLIENT__Options_H__
-#define NET_MINECRAFT_CLIENT__Options_H__
-
-#define SOUND_MIN_VALUE 0.0f
-#define SOUND_MAX_VALUE 1.0f
-#define MUSIC_MIN_VALUE 0.0f
-#define MUSIC_MAX_VALUE 1.0f
-#define SENSITIVITY_MIN_VALUE 0.0f
-#define SENSITIVITY_MAX_VALUE 1.0f
-#define PIXELS_PER_MILLIMETER_MIN_VALUE 3.0f
-#define PIXELS_PER_MILLIMETER_MAX_VALUE 4.0f
-
-//package net.minecraft.client;
-
-//#include "locale/Language.h"
-
-#include <string>
-#include <cstdio>
-#include "../platform/input/Keyboard.h"
-#include "../util/StringUtils.h"
-#include "OptionsFile.h"
-#include "Option.h"
-#include <array>
-
-enum OptionId {
-    // General
-    OPTIONS_DIFFICULTY,
-    OPTIONS_HIDEGUI,
-    OPTIONS_THIRD_PERSON_VIEW,
-    OPTIONS_GUI_SCALE,
-    OPTIONS_DESTROY_VIBRATION,
-    OPTIONS_MUSIC_VOLUME,
-    OPTIONS_SOUND_VOLUME,
-    OPTIONS_SKIN,
-    OPTIONS_USERNAME,
-    OPTIONS_SERVER_VISIBLE,
-    OPTIONS_BAR_ON_TOP,
-    OPTIONS_ALLOW_SPRINT,
-    OPTIONS_AUTOJUMP,
-
-    // Graphics
-    OPTIONS_RENDER_DEBUG,
-    OPTIONS_SMOOTH_CAMERA,
-    OPTIONS_FIXED_CAMERA,
-    OPTIONS_VIEW_DISTANCE,
-    OPTIONS_VIEW_BOBBING,
-    OPTIONS_AMBIENT_OCCLUSION,
-    OPTIONS_ANAGLYPH_3D,
-    OPTIONS_LIMIT_FRAMERATE,
-    OPTIONS_VSYNC,
-    OPTIONS_FANCY_GRAPHICS,
-
-    // Cheats / debug
-    OPTIONS_FLY_SPEED,
-    OPTIONS_CAMERA_SPEED,
-    OPTIONS_IS_FLYING,
-
-    // Control
-    OPTIONS_USE_MOUSE_FOR_DIGGING,
-    OPTIONS_IS_LEFT_HANDED,
-    OPTIONS_IS_JOY_TOUCH_AREA,
-    OPTIONS_SENSITIVITY,
-    OPTIONS_INVERT_Y_MOUSE,
-    OPTIONS_USE_TOUCHSCREEN,
-
-    OPTIONS_KEY_FORWARD,
-    OPTIONS_KEY_LEFT,
-    OPTIONS_KEY_BACK,
-    OPTIONS_KEY_RIGHT,
-    OPTIONS_KEY_JUMP,
-    OPTIONS_KEY_INVENTORY,
-    OPTIONS_KEY_SNEAK,
-    OPTIONS_KEY_DROP,
-    OPTIONS_KEY_CHAT,
-    OPTIONS_KEY_FOG,
-    OPTIONS_KEY_USE,
-
-    OPTIONS_KEY_MENU_NEXT,
-    OPTIONS_KEY_MENU_PREV,
-    OPTIONS_KEY_MENU_OK,
-    OPTIONS_KEY_MENU_CANCEL,
-
-    OPTIONS_FIRST_LAUNCH,
-    OPTIONS_LAST_IP,
-
-	// Should be last!
-	OPTIONS_COUNT
-};
-
-class Minecraft;
-typedef std::vector<std::string> StringVector;
-
-class Options
-{
-public:
-    static bool debugGl;
-
-    Options(Minecraft* minecraft, const std::string& workingDirectory = "") 
-	: minecraft(minecraft) {
-        // elements werent initialized so i was getting a garbage pointer and a crash
-        m_options.fill(nullptr);
-        initTable();
-		load();
-    }
-
-	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);
-        return (option)? option->get() : 0;
-    }
-
-    std::string getStringValue(OptionId key) {
-        auto option = opt<OptionString>(key);
-        return (option)? option->get() : "";
-    }
-
-    float getProgressValue(OptionId key) {
-        auto option = opt<OptionFloat>(key);
-        return (option)? option->get() : 0.f;
-    }
-
-    bool getBooleanValue(OptionId key) {
-        auto option = opt<OptionBool>(key);
-        return (option)? option->get() : false;
-    }
-
-    float getProgrssMin(OptionId key) {
-        auto option = opt<OptionFloat>(key);
-        return (option)? option->getMin() : 0.f;
-    }
-
-    float getProgrssMax(OptionId key) {
-        auto option = opt<OptionFloat>(key);
-        return (option)? option->getMax() : 0.f;
-    }
-
-    Option* getOpt(OptionId id) { return m_options[id]; }
-
-    void load();
-    void save();
-
-	void notifyOptionUpdate(OptionId key, bool value);
-	void notifyOptionUpdate(OptionId key, float value);
-	void notifyOptionUpdate(OptionId key, int value);
-    void notifyOptionUpdate(OptionId key, const std::string& value) {}
-
-private:
-    template<typename T>
-    T* opt(OptionId key) { 
-        if (m_options[key] == nullptr) return nullptr;
-        return dynamic_cast<T*>(m_options[key]); 
-    }
-
-	std::array<Option*, OPTIONS_COUNT> m_options;
-	OptionsFile optionsFile;
-
-	Minecraft* minecraft;
-};
-
-#endif /*NET_MINECRAFT_CLIENT__Options_H__*/
+#pragma once
+
+#define SOUND_MIN_VALUE 0.0f
+#define SOUND_MAX_VALUE 1.0f
+#define MUSIC_MIN_VALUE 0.0f
+#define MUSIC_MAX_VALUE 1.0f
+#define SENSITIVITY_MIN_VALUE 0.0f
+#define SENSITIVITY_MAX_VALUE 1.0f
+#define PIXELS_PER_MILLIMETER_MIN_VALUE 3.0f
+#define PIXELS_PER_MILLIMETER_MAX_VALUE 4.0f
+
+//package net.minecraft.client;
+
+//#include "locale/Language.hpp"
+
+#include <string>
+#include <platform/input/Keyboard.hpp>
+#include <util/StringUtils.hpp>
+#include "OptionsFile.hpp"
+#include "Option.hpp"
+#include <array>
+
+enum OptionId {
+    // General
+    OPTIONS_DIFFICULTY,
+    OPTIONS_HIDEGUI,
+    OPTIONS_THIRD_PERSON_VIEW,
+    OPTIONS_GUI_SCALE,
+    OPTIONS_DESTROY_VIBRATION,
+    OPTIONS_MUSIC_VOLUME,
+    OPTIONS_SOUND_VOLUME,
+    OPTIONS_SKIN,
+    OPTIONS_USERNAME,
+    OPTIONS_SERVER_VISIBLE,
+    OPTIONS_BAR_ON_TOP,
+    OPTIONS_ALLOW_SPRINT,
+    OPTIONS_AUTOJUMP,
+
+    // Graphics
+    OPTIONS_RENDER_DEBUG,
+    OPTIONS_SMOOTH_CAMERA,
+    OPTIONS_FIXED_CAMERA,
+    OPTIONS_VIEW_DISTANCE,
+    OPTIONS_VIEW_BOBBING,
+    OPTIONS_AMBIENT_OCCLUSION,
+    OPTIONS_ANAGLYPH_3D,
+    OPTIONS_LIMIT_FRAMERATE,
+    OPTIONS_VSYNC,
+    OPTIONS_FANCY_GRAPHICS,
+
+    // Cheats / debug
+    OPTIONS_FLY_SPEED,
+    OPTIONS_CAMERA_SPEED,
+    OPTIONS_IS_FLYING,
+
+    // Control
+    OPTIONS_USE_MOUSE_FOR_DIGGING,
+    OPTIONS_IS_LEFT_HANDED,
+    OPTIONS_IS_JOY_TOUCH_AREA,
+    OPTIONS_SENSITIVITY,
+    OPTIONS_INVERT_Y_MOUSE,
+    OPTIONS_USE_TOUCHSCREEN,
+
+    OPTIONS_KEY_FORWARD,
+    OPTIONS_KEY_LEFT,
+    OPTIONS_KEY_BACK,
+    OPTIONS_KEY_RIGHT,
+    OPTIONS_KEY_JUMP,
+    OPTIONS_KEY_INVENTORY,
+    OPTIONS_KEY_SNEAK,
+    OPTIONS_KEY_DROP,
+    OPTIONS_KEY_CHAT,
+    OPTIONS_KEY_FOG,
+    OPTIONS_KEY_USE,
+
+    OPTIONS_KEY_MENU_NEXT,
+    OPTIONS_KEY_MENU_PREV,
+    OPTIONS_KEY_MENU_OK,
+    OPTIONS_KEY_MENU_CANCEL,
+
+    OPTIONS_FIRST_LAUNCH,
+    OPTIONS_LAST_IP,
+
+    OPTIONS_RPI_CURSOR,
+	// Should be last!
+	OPTIONS_COUNT
+};
+
+class MinecraftClient;
+typedef std::vector<std::string> StringVector;
+
+class Options
+{
+public:
+    static bool debugGl;
+
+    Options(MinecraftClient& minecraft, const std::string& workingDirectory = "") 
+	: minecraft(minecraft) {
+        // elements werent initialized so i was getting a garbage pointer and a crash
+        m_options.fill(nullptr);
+        initTable();
+	    // load() is deferred to init() where path is configured correctly
+    }
+
+    void initTable();
+
+    int getIntValue(OptionId key) {
+        auto option = opt<OptionInt>(key);
+        return (option)? option->get() : 0;
+    }
+
+    std::string getStringValue(OptionId key) {
+        auto option = opt<OptionString>(key);
+        return (option)? option->get() : "";
+    }
+
+    float getProgressValue(OptionId key) {
+        auto option = opt<OptionFloat>(key);
+        return (option)? option->get() : 0.f;
+    }
+
+    bool getBooleanValue(OptionId key) {
+        auto option = opt<OptionBool>(key);
+        return (option)? option->get() : false;
+    }
+
+    float getProgrssMin(OptionId key) {
+        auto option = opt<OptionFloat>(key);
+        return (option)? option->getMin() : 0.f;
+    }
+
+    float getProgrssMax(OptionId key) {
+        auto option = opt<OptionFloat>(key);
+        return (option)? option->getMax() : 0.f;
+    }
+
+    Option* getOpt(OptionId id) { return m_options[id]; }
+
+    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);
+	void notifyOptionUpdate(OptionId key, int value);
+    void notifyOptionUpdate(OptionId key, const std::string& value) {}
+
+private:
+    template<typename T>
+    T* opt(OptionId key) { 
+        if (m_options[key] == nullptr) return nullptr;
+        return dynamic_cast<T*>(m_options[key]); 
+    }
+
+	std::array<Option*, OPTIONS_COUNT> m_options;
+	OptionsFile optionsFile;
+
+	MinecraftClient& minecraft;
+};
+

src/client/OptionsFile.cpp

@@ -1,51 +1,98 @@
-#include "OptionsFile.h"
-#include <stdio.h>
-#include <string.h>
-#include <platform/log.h>
-
-OptionsFile::OptionsFile() {
-#ifdef __APPLE__
-	settingsPath = "./Documents/options.txt";
-#elif defined(ANDROID)
-	settingsPath = "options.txt";
-#else
-	settingsPath = "options.txt";
-#endif
-}
-
-void OptionsFile::save(const StringVector& settings) {
-	FILE* pFile = fopen(settingsPath.c_str(), "w");
-	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));
-	}
-}
-
-StringVector OptionsFile::getOptionStrings() {
-	StringVector returnVector;
-	FILE* pFile = fopen(settingsPath.c_str(), "r");
-	if(pFile != NULL) {
-		char lineBuff[128];
-		while(fgets(lineBuff, sizeof lineBuff, pFile)) {
-			// Strip trailing newline
-			size_t len = strlen(lineBuff);
-			while(len > 0 && (lineBuff[len-1] == '\n' || lineBuff[len-1] == '\r'))
-				lineBuff[--len] = '\0';
-			if(len < 3) continue;
-			// Split "key:value" into two separate entries to match update() pairing
-			char* colon = strchr(lineBuff, ':');
-			if(colon) {
-				returnVector.push_back(std::string(lineBuff, colon - lineBuff));
-				returnVector.push_back(std::string(colon + 1));
-			}
-		}
-		fclose(pFile);
-	} else {
-		LOGI("OptionsFile::getOptionStrings failed to open '%s' for reading: %s", settingsPath.c_str(), strerror(errno));
-	}
-	return returnVector;
-}
+#include "OptionsFile.hpp"
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <platform/log.hpp>
+
+#if defined(_WIN32)
+    #include <direct.h>
+#else
+    #include <sys/stat.h>
+    #include <sys/types.h>
+#endif
+
+OptionsFile::OptionsFile() {
+#ifdef __APPLE__
+	settingsPath = "./Documents/options.txt";
+#elif defined(ANDROID)
+	settingsPath = "options.txt";
+#elif defined(__EMSCRIPTEN__)
+    settingsPath = "/games/com.mojang/options.txt";
+#else
+	settingsPath = "options.txt";
+#endif
+}
+
+void OptionsFile::setOptionsPath(const std::string& path) {
+	settingsPath = path;
+}
+
+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");
+	if(pFile != NULL) {
+		char lineBuff[128];
+		while(fgets(lineBuff, sizeof lineBuff, pFile)) {
+			// Strip trailing newline
+			size_t len = strlen(lineBuff);
+			while(len > 0 && (lineBuff[len-1] == '\n' || lineBuff[len-1] == '\r'))
+				lineBuff[--len] = '\0';
+			if(len < 3) continue;
+			// Split "key:value" into two separate entries to match update() pairing
+			char* colon = strchr(lineBuff, ':');
+			if(colon) {
+				returnVector.push_back(std::string(lineBuff, colon - lineBuff));
+				returnVector.push_back(std::string(colon + 1));
+			}
+		}
+		fclose(pFile);
+	} else {
+		if (errno != ENOENT)
+			LOGI("OptionsFile::getOptionStrings failed to open '%s' for reading: %s", settingsPath.c_str(), strerror(errno));
+	}
+	return returnVector;
+}

src/client/OptionsFile.hpp

@@ -1,19 +1,19 @@
-#ifndef NET_MINECRAFT_CLIENT__OptionsFile_H__
-#define NET_MINECRAFT_CLIENT__OptionsFile_H__
-
-//package net.minecraft.client;
-#include <string>
-#include <vector>
-typedef std::vector<std::string> StringVector;
-class OptionsFile
-{
-public:
-	OptionsFile();
-    void save(const StringVector& settings);
-	StringVector getOptionStrings();
-	
-private:
-	std::string settingsPath;
-};
-
-#endif /* NET_MINECRAFT_CLIENT__OptionsFile_H__ */
+#pragma once
+
+//package net.minecraft.client;
+#include <string>
+#include <vector>
+typedef std::vector<std::string> StringVector;
+class OptionsFile
+{
+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/Timer.hpp

@@ -1,124 +1,122 @@
-#ifndef NET_MINECRAFT_CLIENT__Timer_H__
-#define NET_MINECRAFT_CLIENT__Timer_H__
-
-//package net.minecraft.client;
-#include "../platform/time.h"
-
-class Timer
-{
-public:
-	Timer(float ticksPerSecond)
-	:	ticksPerSecond(ticksPerSecond),
-		adjustTime(1.0f),
-		timeScale(1.0f),
-		passedTime(0)
-	{
-        lastMs = getTimeMs();
-        lastMsSysTime = lastMs;
-        lastTime = lastMs / 1000.0f;
-    }
-
-    void advanceTime() {
-        long nowMs = getTimeMs();
-        long passedMs = nowMs - lastMs;
-        long msSysTime = nowMs;//System.nanoTime() / 1000000;
-
-        if (passedMs > 1000) {
-            long passedMsSysTime = msSysTime - lastMsSysTime;
-            if (passedMsSysTime == 0)
-                passedMs = passedMsSysTime = 1;
-
-            float adjustTimeT = passedMs / (float) passedMsSysTime;
-            adjustTime += (adjustTimeT - adjustTime) * 0.2f;
-
-            lastMs = nowMs;
-            lastMsSysTime = msSysTime;
-        }
-        if (passedMs < 0) {
-            lastMs = nowMs;
-            lastMsSysTime = msSysTime;
-        }
-
-		float now = msSysTime / 1000.0f;
-        float passedSeconds = (now - lastTime) * adjustTime;
-        lastTime = now;
-
-        if (passedSeconds < 0) passedSeconds = 0;
-        if (passedSeconds > 1) passedSeconds = 1;
-        //LOGI("passed s: %f\n", passedSeconds);
-
-        passedTime += passedSeconds * timeScale * ticksPerSecond;
-
-        ticks = (int) passedTime;
-        passedTime -= ticks;
-        if (ticks > MAX_TICKS_PER_UPDATE) ticks = MAX_TICKS_PER_UPDATE;
-        a = passedTime;
-    }
-
-    /**
-     * Advances time the max number of ticks per second.
-     */
-    void advanceTimeQuickly() {
-
-        float passedSeconds = (float) MAX_TICKS_PER_UPDATE / (float) ticksPerSecond;
-
-        passedTime += passedSeconds * timeScale * ticksPerSecond;
-        ticks = (int) passedTime;
-        passedTime -= ticks;
-        a = passedTime;
-
-        lastMs = getTimeMs();//System.currentTimeMillis();
-        lastMsSysTime = lastMs;
-    }
-
-    void skipTime() {
-        long nowMs = getTimeMs();//System.currentTimeMillis();
-        long passedMs = nowMs - lastMs;
-        long msSysTime = nowMs;//System.nanoTime() / 1000000;
-
-        if (passedMs > 1000) {
-            long passedMsSysTime = msSysTime - lastMsSysTime;
-            if (passedMsSysTime == 0)
-                passedMs = passedMsSysTime = 1;
-
-            float adjustTimeT = passedMs / (float) passedMsSysTime;
-            adjustTime += (adjustTimeT - adjustTime) * 0.2f;
-
-            lastMs = nowMs;
-            lastMsSysTime = msSysTime;
-        }
-        if (passedMs < 0) {
-            lastMs = nowMs;
-            lastMsSysTime = msSysTime;
-        }
-
-		float now = msSysTime / 1000.0f;
-        float passedSeconds = (now - lastTime) * adjustTime;
-        lastTime = now;
-
-        if (passedSeconds < 0) passedSeconds = 0;
-        if (passedSeconds > 1) passedSeconds = 1;
-
-        passedTime += passedSeconds * timeScale * ticksPerSecond;
-
-        ticks = (int) 0;
-        if (ticks > MAX_TICKS_PER_UPDATE) ticks = MAX_TICKS_PER_UPDATE;
-        passedTime -= ticks;
-    }
-
-public:
-	float ticksPerSecond;
-	int ticks;
-	float a;
-	float timeScale;
-	float passedTime;
-private:
-	static const int MAX_TICKS_PER_UPDATE = 10;
-
-	float lastTime;
-	long lastMs;
-	long lastMsSysTime;
-	float adjustTime;
-};
-
-#endif /*NET_MINECRAFT_CLIENT__Timer_H__*/
+#pragma once
+
+//package net.minecraft.client;
+#include "platform/time.hpp"
+
+class Timer
+{
+public:
+	Timer(float ticksPerSecond)
+	:	ticksPerSecond(ticksPerSecond),
+		adjustTime(1.0f),
+		timeScale(1.0f),
+		passedTime(0)
+	{
+        lastMs = getTimeMs();
+        lastMsSysTime = lastMs;
+        lastTime = lastMs / 1000.0f;
+    }
+
+    void advanceTime() {
+        long nowMs = getTimeMs();
+        long passedMs = nowMs - lastMs;
+        long msSysTime = nowMs;//System.nanoTime() / 1000000;
+
+        if (passedMs > 1000) {
+            long passedMsSysTime = msSysTime - lastMsSysTime;
+            if (passedMsSysTime == 0)
+                passedMs = passedMsSysTime = 1;
+
+            float adjustTimeT = passedMs / (float) passedMsSysTime;
+            adjustTime += (adjustTimeT - adjustTime) * 0.2f;
+
+            lastMs = nowMs;
+            lastMsSysTime = msSysTime;
+        }
+        if (passedMs < 0) {
+            lastMs = nowMs;
+            lastMsSysTime = msSysTime;
+        }
+
+		float now = msSysTime / 1000.0f;
+        float passedSeconds = (now - lastTime) * adjustTime;
+        lastTime = now;
+
+        if (passedSeconds < 0) passedSeconds = 0;
+        if (passedSeconds > 1) passedSeconds = 1;
+        //LOGI("passed s: %f\n", passedSeconds);
+
+        passedTime += passedSeconds * timeScale * ticksPerSecond;
+
+        ticks = (int) passedTime;
+        passedTime -= ticks;
+        if (ticks > MAX_TICKS_PER_UPDATE) ticks = MAX_TICKS_PER_UPDATE;
+        a = passedTime;
+    }
+
+    /**
+     * Advances time the max number of ticks per second.
+     */
+    void advanceTimeQuickly() {
+
+        float passedSeconds = (float) MAX_TICKS_PER_UPDATE / (float) ticksPerSecond;
+
+        passedTime += passedSeconds * timeScale * ticksPerSecond;
+        ticks = (int) passedTime;
+        passedTime -= ticks;
+        a = passedTime;
+
+        lastMs = getTimeMs();//System.currentTimeMillis();
+        lastMsSysTime = lastMs;
+    }
+
+    void skipTime() {
+        long nowMs = getTimeMs();//System.currentTimeMillis();
+        long passedMs = nowMs - lastMs;
+        long msSysTime = nowMs;//System.nanoTime() / 1000000;
+
+        if (passedMs > 1000) {
+            long passedMsSysTime = msSysTime - lastMsSysTime;
+            if (passedMsSysTime == 0)
+                passedMs = passedMsSysTime = 1;
+
+            float adjustTimeT = passedMs / (float) passedMsSysTime;
+            adjustTime += (adjustTimeT - adjustTime) * 0.2f;
+
+            lastMs = nowMs;
+            lastMsSysTime = msSysTime;
+        }
+        if (passedMs < 0) {
+            lastMs = nowMs;
+            lastMsSysTime = msSysTime;
+        }
+
+		float now = msSysTime / 1000.0f;
+        float passedSeconds = (now - lastTime) * adjustTime;
+        lastTime = now;
+
+        if (passedSeconds < 0) passedSeconds = 0;
+        if (passedSeconds > 1) passedSeconds = 1;
+
+        passedTime += passedSeconds * timeScale * ticksPerSecond;
+
+        ticks = (int) 0;
+        if (ticks > MAX_TICKS_PER_UPDATE) ticks = MAX_TICKS_PER_UPDATE;
+        passedTime -= ticks;
+    }
+
+public:
+	float ticksPerSecond;
+	int ticks;
+	float a;
+	float timeScale;
+	float passedTime;
+private:
+	static const int MAX_TICKS_PER_UPDATE = 10;
+
+	float lastTime;
+	long lastMs;
+	long lastMsSysTime;
+	float adjustTime;
+};
+

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/CreativeMode.cpp

@@ -1,69 +0,0 @@
-#include "CreativeMode.h"
-#include "../Minecraft.h"
-#ifndef STANDALONE_SERVER
-#include "../particle/ParticleEngine.h"
-#endif
-#include "../player/LocalPlayer.h"
-#ifndef STANDALONE_SERVER
-#include "../renderer/LevelRenderer.h"
-#include "../sound/SoundEngine.h"
-#endif
-#include "../../world/level/Level.h"
-//#include "../../network/Packet.h"
-#include "../../network/packet/RemoveBlockPacket.h"
-#include "../../world/entity/player/Abilities.h"
-
-static const int DestructionTickDelay = 5;
-
-CreativeMode::CreativeMode(Minecraft* minecraft)
-: 	super(minecraft)
-{
-}
-
-void CreativeMode::startDestroyBlock(int x, int y, int z, int face) {
-	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
-		return;
-
-	creativeDestroyBlock(x, y, z, face);
-	destroyDelay = DestructionTickDelay;
-}
-
-void CreativeMode::creativeDestroyBlock(int x, int y, int z, int face) {
-	minecraft->level->extinguishFire(x, y, z, face);
-	destroyBlock(x, y, z, face);
-}
-
-void CreativeMode::continueDestroyBlock(int x, int y, int z, int face) {
-	destroyDelay--;
-	if (destroyDelay <= 0) {
-		destroyDelay = DestructionTickDelay;
-		creativeDestroyBlock(x, y, z, face);
-	}
-}
-
-void CreativeMode::stopDestroyBlock() {
-	destroyDelay = 0;
-}
-
-void CreativeMode::initAbilities( Abilities& abilities ) {
-	abilities.mayfly = true;
-	abilities.instabuild = true;
-	abilities.invulnerable = true;
-}
-
-bool CreativeMode::isCreativeType() {
-	return true;
-}
-
-void CreativeMode::releaseUsingItem( Player* player ) {
-	if(player->getCarriedItem() != NULL) {
-		int oldItemId = player->getCarriedItem()->id;
-		int oldAux = player->getAuxData();
-		super::releaseUsingItem(player);
-		if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == oldItemId) {
-			player->getCarriedItem()->setAuxValue(oldAux);
-		}
-	} else {
-		super::releaseUsingItem(player);
-	}
-}

src/client/gamemode/CreativeMode.h

@@ -1,27 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__
-#define NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__
-
-//package net.minecraft.client.gamemode;
-
-#include "GameMode.h"
-
-class CreativeMode: public GameMode
-{
-	typedef GameMode super;
-public:
-    CreativeMode(Minecraft* minecraft);
-
-    void startDestroyBlock(int x, int y, int z, int face);
-    void continueDestroyBlock(int x, int y, int z, int face);
-    void stopDestroyBlock();
-
-	bool isCreativeType();
-
-	void initAbilities(Abilities& abilities);
-
-	void releaseUsingItem(Player* player);
-private:
-	void creativeDestroyBlock(int x, int y, int z, int face);
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__*/

src/client/gamemode/SurvivalMode.cpp

@@ -1,98 +0,0 @@
-#include "SurvivalMode.h"
-#include "../Minecraft.h"
-#include "../player/LocalPlayer.h"
-#ifndef STANDALONE_SERVER
-#include "../particle/ParticleEngine.h"
-#include "../sound/SoundEngine.h"
-#endif
-#include "../../world/level/Level.h"
-#include "../../world/entity/player/Abilities.h"
-
-SurvivalMode::SurvivalMode( Minecraft* minecraft )
-:	super(minecraft),
-	xDestroyBlock(-1),
-	yDestroyBlock(-1),
-	zDestroyBlock(-1)
-{
-}
-
-void SurvivalMode::continueDestroyBlock( int x, int y, int z, int face ) {
-	if (destroyDelay > 0) {
-		destroyDelay--;
-		return;
-	}
-
-	if (x == xDestroyBlock && y == yDestroyBlock && z == zDestroyBlock) {
-		int t = minecraft->level->getTile(x, y, z);
-		if (t == 0) return;
-		Tile* tile = Tile::tiles[t];
-
-		destroyProgress += tile->getDestroyProgress(minecraft->player);
-
-		if ((++destroyTicks & 3) == 1) {
-#ifndef STANDALONE_SERVER
-			if (tile != NULL) {
-				minecraft->soundEngine->play(tile->soundType->getStepSound(), x + 0.5f, y + 0.5f, z + 0.5f, (tile->soundType->getVolume() + 1) / 8, tile->soundType->getPitch() * 0.5f);
-			}
-#endif
-		}
-
-		if (destroyProgress >= 1) {
-			destroyBlock(x, y, z, face);
-			destroyProgress = 0;
-			oDestroyProgress = 0;
-			destroyTicks = 0;
-			destroyDelay = 5;
-		}
-	} else {
-		destroyProgress = 0;
-		oDestroyProgress = 0;
-		destroyTicks = 0;
-		xDestroyBlock = x;
-		yDestroyBlock = y;
-		zDestroyBlock = z;
-	}
-}
-
-bool SurvivalMode::destroyBlock( int x, int y, int z, int face ) {
-	int t = minecraft->level->getTile(x, y, z);
-	int data = minecraft->level->getData(x, y, z);
-	bool changed = GameMode::destroyBlock(x, y, z, face);
-	bool couldDestroy = minecraft->player->canDestroy(Tile::tiles[t]);
-
-	ItemInstance* item = minecraft->player->inventory->getSelected();
-	if (item != NULL) {
-		item->mineBlock(t, x, y, z);
-		if (item->count == 0) {
-			//item->snap(minecraft->player);
-			minecraft->player->inventory->clearSlot(minecraft->player->inventory->selected);
-		}
-	}
-	if (changed && couldDestroy) {
-		ItemInstance instance(t, 1, data);
-		Tile::tiles[t]->playerDestroy(minecraft->level, minecraft->player, x, y, z, data);
-	}
-	return changed;
-}
-
-void SurvivalMode::stopDestroyBlock() {
-	destroyProgress = 0;
-	destroyDelay = 0;
-}
-
-void SurvivalMode::initAbilities( Abilities& abilities ) {
-	abilities.flying = false;
-	abilities.mayfly = false;
-	abilities.instabuild = false;
-	abilities.invulnerable = false;
-}
-
-void SurvivalMode::startDestroyBlock( int x, int y, int z, int face ) {
-	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
-		return;
-
-	int t = minecraft->level->getTile(x, y, z);
-	if (t > 0 && destroyProgress == 0) Tile::tiles[t]->attack(minecraft->level, x, y, z, minecraft->player);
-	if (t > 0 && Tile::tiles[t]->getDestroyProgress(minecraft->player) >= 1)
-		destroyBlock(x, y, z, face);
-}

src/client/gamemode/SurvivalMode.h

@@ -1,31 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT_GAMEMODE__SurvivalMode_H__
-#define NET_MINECRAFT_CLIENT_GAMEMODE__SurvivalMode_H__
-
-#include "GameMode.h"
-
-class Abilities;
-class Minecraft;
-
-class SurvivalMode: public GameMode
-{
-	typedef GameMode super;
-public:
-	SurvivalMode(Minecraft* minecraft);
-
-	bool destroyBlock(int x, int y, int z, int face);
-	void startDestroyBlock(int x, int y, int z, int face);
-	void continueDestroyBlock(int x, int y, int z, int face);
-	void stopDestroyBlock();
-
-	bool canHurtPlayer() { return true; }
-
-	bool isSurvivalType() { return true; }
-
-	void initAbilities( Abilities& abilities );
-private:
-	int xDestroyBlock;
-	int yDestroyBlock;
-	int zDestroyBlock;
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__SurvivalMode_H__*/

src/client/gui/Font.cpp

@@ -1,372 +1,372 @@
-#include "Font.h"
-
-//#include "SharedConstants.h"
-#include "../Options.h"
-#include "../renderer/Textures.h"
-#include "../renderer/Tesselator.h"
-#include "../../util/Mth.h"
-#include <cstring>
-
-Font::Font( Options* options, const std::string& name, Textures* textures )
-:	options(options),
-	fontTexture(0),
-	fontName(name),
-	index(0),
-	count(0),
-	_textures(textures),
-	_x(0), _y(0),
-	_cols(16), _rows(16),
-	_charOffset(0),
-	lineHeight(DefaultLineHeight)
-{
-	init(options);
-}
-
-
-//Font::Font( Options* options, const std::string& name, Textures* textures, int imgW, int imgH, int x, int y, int cols, int rows, unsigned char charOffset )
-//:	options(options),
-//	fontTexture(0),
-//	fontName(name),
-//	index(0),
-//	count(0),
-//	_textures(textures),
-//	_x(x), _y(y),
-//	_cols(cols), _rows(rows),
-//	_charOffset(charOffset)
-//{
-//	init(options);
-//}
-
-void Font::onGraphicsReset()
-{
-	init(options);
-}
-
-void Font::init( Options* options )
-{
-	TextureId fontTexture = _textures->loadTexture(fontName);
-	const TextureData* tex = _textures->getTemporaryTextureData(fontTexture);
-
-	if (!tex)
-		return;
-
-	unsigned char* rawPixels = tex->data;
-
-	const int numChars = _rows * _cols;
-	for (int i = 0; i < numChars; i++) {
-		int xt = i % _cols;
-		int yt = i / _cols;
-
-		int x = 7;
-		for (; x >= 0; x--) {
-			int xPixel = _x + xt * 8 + x;
-			bool emptyColumn = true;
-			for (int y = 0; y < 8 && emptyColumn; y++) {
-				int yPixel = _y + (yt * 8 + y) * tex->w;
-				unsigned char pixelalpha = rawPixels[(xPixel + yPixel) << 2];
-				if (pixelalpha > 0) emptyColumn = false;
-			}
-			if (!emptyColumn) {
-				break;
-			}
-		}
-
-		if (i == ' ') x = 4 - 2;
-		charWidths[i] = x + 2;
-		fcharWidths[i] = (float) charWidths[i];
-	}
-
-#ifdef USE_VBO
-	return; // this <1
-#endif
-
-#ifndef USE_VBO
-	listPos = glGenLists(256 + 32);
-
-	Tesselator& t = Tesselator::instance;
-	for (int i = 0; i < 256; i++) {
-		glNewList(listPos + i, GL_COMPILE);
-		// @attn @huge @note: This is some dangerous code right here / Aron, added ^1
-		t.begin();
-		buildChar(i);
-		t.end(false, -1);
-
-		glTranslatef2((GLfloat)charWidths[i], 0.0f, 0.0f);
-		glEndList();
-	}
-
-	for (int i = 0; i < 32; i++) {
-		int br = ((i >> 3) & 1) * 0x55;
-		int r = ((i >> 2) & 1) * 0xaa + br;
-		int g = ((i >> 1) & 1) * 0xaa + br;
-		int b = ((i >> 0) & 1) * 0xaa + br;
-		if (i == 6) {
-			r += 0x55;
-		}
-		bool darken = i >= 16;
-
-		if (options->anaglyph3d) {
-			int cr = (r * 30 + g * 59 + b * 11) / 100;
-			int cg = (r * 30 + g * 70) / (100);
-			int cb = (r * 30 + b * 70) / (100);
-
-			r = cr;
-			g = cg;
-			b = cb;
-		}
-
-		// color = r << 16 | g << 8 | b;
-		if (darken) {
-			r /= 4;
-			g /= 4;
-			b /= 4;
-		}
-
-		glNewList(listPos + 256 + i, GL_COMPILE);
-		glColor3f(r / 255.0f, g / 255.0f, b / 255.0f);
-		glEndList();
-	}
-#endif
-}
-
-void Font::drawShadow( const std::string& str, float x, float y, int color )
-{
-	draw(str, x + 1, y + 1, color, true);
-	draw(str, x, y, color);
-}
-void Font::drawShadow( const char* str, float x, float y, int color )
-{
-	draw(str, x + 1, y + 1, color, true);
-	draw(str, x, y, color);
-}
-
-void Font::draw( const std::string& str, float x, float y, int color )
-{
-	draw(str, x, y, color, false);
-}
-
-void Font::draw( const char* str, float x, float y, int color )
-{
-	draw(str, x, y, color, false);
-}
-
-void Font::draw( const char* str, float x, float y, int color, bool darken )
-{
-#ifdef USE_VBO
-	drawSlow(str, x, y, color, darken);
-#endif
-}
-
-void Font::draw( const std::string& str, float x, float y, int color, bool darken )
-{
-#ifdef USE_VBO
-	drawSlow(str, x, y, color, darken);
-	return;
-#endif
-
-	if (str.empty()) return;
-
-	if (darken) {
-		int oldAlpha = color & 0xff000000;
-		color = (color & 0xfcfcfc) >> 2;
-		color += oldAlpha;
-	}
-
-	_textures->loadAndBindTexture(fontName);
-	float r = ((color >> 16) & 0xff) / 255.0f;
-	float g = ((color >> 8) & 0xff) / 255.0f;
-	float b = ((color) & 0xff) / 255.0f;
-	float a = ((color >> 24) & 0xff) / 255.0f;
-	if (a == 0) a = 1;
-	glColor4f2(r, g, b, a);
-
-	static const std::string hex("0123456789abcdef");
-
-	index = 0;
-	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>') {
-			int cc = hex.find((char)tolower(str[i + 1]));
-			if (cc < 0 || cc > 15) cc = 15;
-			lists[index++] = listPos + 256 + cc + (darken ? 16 : 0);
-
-			if (index == 1024) {
-				count = index;
-				index = 0;
-#ifndef USE_VBO
-				glCallLists(count, GL_UNSIGNED_INT, lists);
-#endif
-				count = 1024;
-			}
-
-			i += 2;
-		}
-
-		if (i < str.length()) {
-			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
-			char ch = str[i];
-			if (ch >= 0) {
-				//ib.put(listPos + ch + 32);
-				lists[index++] = listPos + ch;
-			}
-		}
-
-		if (index == 1024) {
-			count = index;
-			index = 0;
-#ifndef USE_VBO
-			glCallLists(count, GL_UNSIGNED_INT, lists);
-#endif
-			count = 1024;
-		}
-	}
-	count = index;
-	index = 0;
-#ifndef USE_VBO
-	glCallLists(count, GL_UNSIGNED_INT, lists);
-#endif
-	glPopMatrix2();
-}
-
-int Font::width( const std::string& str )
-{
-	int maxLen = 0;
-	int len = 0;
-
-	for (unsigned int i = 0; i < str.length(); i++) {
-		if (str[i] == '<EFBFBD>') {
-			i++;
-		} else {
-			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
-			//if (ch >= 0) {
-			//    len += charWidths[ch + 32];
-			//}
-			if (str[i] == '\n') {
-				if (len > maxLen) maxLen = len;
-				len = 0;
-			}
-			else {
-				int charWidth = charWidths[ (unsigned char) str[i] ];
-				len += charWidth;
-			}
-		}
-	}
-	return maxLen>len? maxLen : len;
-}
-
-int Font::height( const std::string& str ) {
-	int h = 0;
-	bool hasLine = false;
-	for (unsigned int i = 0; i < str.length(); ++i) {
-		if (str[i] == '\n') hasLine = true;
-		else {
-			if (hasLine) h += lineHeight;
-			hasLine = false;
-		}
-	}
-	return h;
-}
-
-std::string Font::sanitize( const std::string& str )
-{
-	std::string sanitized(str.length() + 1, 0);
-	int j = 0;
-
-	for (unsigned int i = 0; i < str.length(); i++) {
-		if (str[i] == '<EFBFBD>') {
-			i++;
-			//} else if (SharedConstants.acceptableLetters.indexOf(str.charAt(i)) >= 0) {
-		} else {
-			sanitized[j++] = str[i];
-		}
-	}
-	return sanitized.erase(j);
-}
-
-void Font::drawWordWrap( const std::string& str, float x, float y, float w, int col )
-{
-	char* cstr = new char[str.length() + 1];
-	strncpy(cstr, str.c_str(), str.length());
-	cstr[str.length()] = 0;
-
-	const char* lims = " \n\t\r";
-	char* ptok = strtok(cstr, lims);
-
-	std::vector<std::string> words;
-	while (ptok != NULL) {
-		words.push_back( ptok );
-		ptok = strtok(NULL, lims);
-	}
-
-	delete[] cstr;
-
-	int pos = 0;
-	while (pos < (int)words.size()) {
-		std::string line = words[pos++] + " ";
-		while (pos < (int)words.size() && width(line + words[pos]) < w) {
-			line += words[pos++] + " ";
-		}
-		drawShadow(line, x, y, col);
-		y += lineHeight;
-	}
-}
-
-void Font::drawSlow( const std::string& str, float x, float y, int color, bool darken /*= false*/ ) {
-	drawSlow(str.c_str(), x, y, color, darken);
-}
-void Font::drawSlow( const char* str, float x, float y, int color, bool darken /*= false*/ )
-{
-	if (!str) return;
-
-	if (darken) {
-		int oldAlpha = color & 0xff000000;
-		color = (color & 0xfcfcfc) >> 2;
-		color += oldAlpha;
-	}
-
-	_textures->loadAndBindTexture(fontName);
-
-	Tesselator& t = Tesselator::instance;
-	t.begin();
-	int alpha = (0xff000000 & color) >> 24;
-	if (!alpha) alpha = 0xff;
-	t.color((color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff, alpha);
-	
-	t.addOffset((float)x, (float)y, 0);
-	float xOffset = 0;
-	float yOffset = 0;
-
-	while (unsigned char ch = *(str++)) {
-		if (ch == '\n') {
-			xOffset = 0;
-			yOffset += lineHeight;
-		} else {
-			buildChar(ch, xOffset, yOffset);
-			xOffset += fcharWidths[ch];
-		}
-	}
-	t.draw();
-	t.addOffset(-(float)x, -(float)y, 0);
-}
-
-void Font::buildChar( unsigned char i, float x /*= 0*/, float y /*=0*/ )
-{
-	Tesselator& t = Tesselator::instance;
-
-	//i -= _charOffset;
-	//int ix = (i % _cols) * 8 + _x;
-	//int iy = (i / _cols) * 8 + _y;
-	float ix = (float)((i & 15) * 8);
-	float iy = (float)((i >> 4) * 8);
-	float s = 7.99f;
-
-	float uo = (0.0f) / 128.0f;
-	float vo = (0.0f) / 128.0f;
-
-	t.vertexUV(x, y + s, 0, ix / 128.0f + uo, (iy + s) / 128.0f + vo);
-	t.vertexUV(x + s, y + s, 0, (ix + s) / 128.0f + uo, (iy + s) / 128.0f + vo);
-	t.vertexUV(x + s, y, 0, (ix + s) / 128.0f + uo, iy / 128.0f + vo);
-	t.vertexUV(x, y, 0, ix / 128.0f + uo, iy / 128.0f + vo);
-}
-
+#include "Font.hpp"
+
+//#include "SharedConstants.hpp"
+#include "client/Options.hpp"
+#include "client/renderer/Textures.hpp"
+#include "client/renderer/Tesselator.hpp"
+#include "util/Mth.hpp"
+#include <cstring>
+
+Font::Font( Options* options, const std::string& name, Textures* textures )
+:	options(options),
+	fontTexture(0),
+	fontName(name),
+	index(0),
+	count(0),
+	_textures(textures),
+	_x(0), _y(0),
+	_cols(16), _rows(16),
+	_charOffset(0),
+	lineHeight(DefaultLineHeight)
+{
+	init(options);
+}
+
+
+//Font::Font( Options* options, const std::string& name, Textures* textures, int imgW, int imgH, int x, int y, int cols, int rows, unsigned char charOffset )
+//:	options(options),
+//	fontTexture(0),
+//	fontName(name),
+//	index(0),
+//	count(0),
+//	_textures(textures),
+//	_x(x), _y(y),
+//	_cols(cols), _rows(rows),
+//	_charOffset(charOffset)
+//{
+//	init(options);
+//}
+
+void Font::onGraphicsReset()
+{
+	init(options);
+}
+
+void Font::init( Options* options )
+{
+	TextureId fontTexture = _textures->loadTexture(fontName);
+	const TextureData* tex = _textures->getTemporaryTextureData(fontTexture);
+
+	if (!tex)
+		return;
+
+	unsigned char* rawPixels = tex->data;
+
+	const int numChars = _rows * _cols;
+	for (int i = 0; i < numChars; i++) {
+		int xt = i % _cols;
+		int yt = i / _cols;
+
+		int x = 7;
+		for (; x >= 0; x--) {
+			int xPixel = _x + xt * 8 + x;
+			bool emptyColumn = true;
+			for (int y = 0; y < 8 && emptyColumn; y++) {
+				int yPixel = _y + (yt * 8 + y) * tex->w;
+				unsigned char pixelalpha = rawPixels[(xPixel + yPixel) << 2];
+				if (pixelalpha > 0) emptyColumn = false;
+			}
+			if (!emptyColumn) {
+				break;
+			}
+		}
+
+		if (i == ' ') x = 4 - 2;
+		charWidths[i] = x + 2;
+		fcharWidths[i] = (float) charWidths[i];
+	}
+
+#ifdef USE_VBO
+	return; // this <1
+#endif
+
+#ifndef USE_VBO
+	listPos = glGenLists(256 + 32);
+
+	Tesselator& t = Tesselator::instance;
+	for (int i = 0; i < 256; i++) {
+		glNewList(listPos + i, GL_COMPILE);
+		// @attn @huge @note: This is some dangerous code right here / Aron, added ^1
+		t.begin();
+		buildChar(i);
+		t.end(false, -1);
+
+		glTranslatef2((GLfloat)charWidths[i], 0.0f, 0.0f);
+		glEndList();
+	}
+
+	for (int i = 0; i < 32; i++) {
+		int br = ((i >> 3) & 1) * 0x55;
+		int r = ((i >> 2) & 1) * 0xaa + br;
+		int g = ((i >> 1) & 1) * 0xaa + br;
+		int b = ((i >> 0) & 1) * 0xaa + br;
+		if (i == 6) {
+			r += 0x55;
+		}
+		bool darken = i >= 16;
+
+		if (options->anaglyph3d) {
+			int cr = (r * 30 + g * 59 + b * 11) / 100;
+			int cg = (r * 30 + g * 70) / (100);
+			int cb = (r * 30 + b * 70) / (100);
+
+			r = cr;
+			g = cg;
+			b = cb;
+		}
+
+		// color = r << 16 | g << 8 | b;
+		if (darken) {
+			r /= 4;
+			g /= 4;
+			b /= 4;
+		}
+
+		glNewList(listPos + 256 + i, GL_COMPILE);
+		glColor3f(r / 255.0f, g / 255.0f, b / 255.0f);
+		glEndList();
+	}
+#endif
+}
+
+void Font::drawShadow( const std::string& str, float x, float y, int color )
+{
+	draw(str, x + 1, y + 1, color, true);
+	draw(str, x, y, color);
+}
+void Font::drawShadow( const char* str, float x, float y, int color )
+{
+	draw(str, x + 1, y + 1, color, true);
+	draw(str, x, y, color);
+}
+
+void Font::draw( const std::string& str, float x, float y, int color )
+{
+	draw(str, x, y, color, false);
+}
+
+void Font::draw( const char* str, float x, float y, int color )
+{
+	draw(str, x, y, color, false);
+}
+
+void Font::draw( const char* str, float x, float y, int color, bool darken )
+{
+#ifdef USE_VBO
+	drawSlow(str, x, y, color, darken);
+#endif
+}
+
+void Font::draw( const std::string& str, float x, float y, int color, bool darken )
+{
+#ifdef USE_VBO
+	drawSlow(str, x, y, color, darken);
+	return;
+#endif
+
+	if (str.empty()) return;
+
+	if (darken) {
+		int oldAlpha = color & 0xff000000;
+		color = (color & 0xfcfcfc) >> 2;
+		color += oldAlpha;
+	}
+
+	_textures->loadAndBindTexture(fontName);
+	float r = ((color >> 16) & 0xff) / 255.0f;
+	float g = ((color >> 8) & 0xff) / 255.0f;
+	float b = ((color) & 0xff) / 255.0f;
+	float a = ((color >> 24) & 0xff) / 255.0f;
+	if (a == 0) a = 1;
+	glColor4f2(r, g, b, a);
+
+	static const std::string hex("0123456789abcdef");
+
+	index = 0;
+	glPushMatrix2();
+	glTranslatef2((GLfloat)x, (GLfloat)y, 0.0f);
+	for (unsigned int i = 0; i < str.length(); i++) {
+		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);
+
+			if (index == 1024) {
+				count = index;
+				index = 0;
+#ifndef USE_VBO
+				glCallLists(count, GL_UNSIGNED_INT, lists);
+#endif
+				count = 1024;
+			}
+
+			i += 2;
+		}
+
+		if (i < str.length()) {
+			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
+			char ch = str[i];
+			if (ch >= 0) {
+				//ib.put(listPos + ch + 32);
+				lists[index++] = listPos + ch;
+			}
+		}
+
+		if (index == 1024) {
+			count = index;
+			index = 0;
+#ifndef USE_VBO
+			glCallLists(count, GL_UNSIGNED_INT, lists);
+#endif
+			count = 1024;
+		}
+	}
+	count = index;
+	index = 0;
+#ifndef USE_VBO
+	glCallLists(count, GL_UNSIGNED_INT, lists);
+#endif
+	glPopMatrix2();
+}
+
+int Font::width( const std::string& str )
+{
+	int maxLen = 0;
+	int len = 0;
+
+	for (unsigned int i = 0; i < str.length(); i++) {
+		if (str[i] == '\xa7') {
+			i++;
+		} else {
+			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
+			//if (ch >= 0) {
+			//    len += charWidths[ch + 32];
+			//}
+			if (str[i] == '\n') {
+				if (len > maxLen) maxLen = len;
+				len = 0;
+			}
+			else {
+				int charWidth = charWidths[ (unsigned char) str[i] ];
+				len += charWidth;
+			}
+		}
+	}
+	return maxLen>len? maxLen : len;
+}
+
+int Font::height( const std::string& str ) {
+	int h = 0;
+	bool hasLine = false;
+	for (unsigned int i = 0; i < str.length(); ++i) {
+		if (str[i] == '\n') hasLine = true;
+		else {
+			if (hasLine) h += lineHeight;
+			hasLine = false;
+		}
+	}
+	return h;
+}
+
+std::string Font::sanitize( const std::string& str )
+{
+	std::string sanitized(str.length() + 1, 0);
+	int j = 0;
+
+	for (unsigned int i = 0; i < str.length(); i++) {
+		if (str[i] == '\xa7') {
+			i++;
+			//} else if (SharedConstants.acceptableLetters.indexOf(str.charAt(i)) >= 0) {
+		} else {
+			sanitized[j++] = str[i];
+		}
+	}
+	return sanitized.erase(j);
+}
+
+void Font::drawWordWrap( const std::string& str, float x, float y, float w, int col )
+{
+	char* cstr = new char[str.length() + 1];
+	strncpy(cstr, str.c_str(), str.length());
+	cstr[str.length()] = 0;
+
+	const char* lims = " \n\t\r";
+	char* ptok = strtok(cstr, lims);
+
+	std::vector<std::string> words;
+	while (ptok != NULL) {
+		words.push_back( ptok );
+		ptok = strtok(NULL, lims);
+	}
+
+	delete[] cstr;
+
+	int pos = 0;
+	while (pos < (int)words.size()) {
+		std::string line = words[pos++] + " ";
+		while (pos < (int)words.size() && width(line + words[pos]) < w) {
+			line += words[pos++] + " ";
+		}
+		drawShadow(line, x, y, col);
+		y += lineHeight;
+	}
+}
+
+void Font::drawSlow( const std::string& str, float x, float y, int color, bool darken /*= false*/ ) {
+	drawSlow(str.c_str(), x, y, color, darken);
+}
+void Font::drawSlow( const char* str, float x, float y, int color, bool darken /*= false*/ )
+{
+	if (!str) return;
+
+	if (darken) {
+		int oldAlpha = color & 0xff000000;
+		color = (color & 0xfcfcfc) >> 2;
+		color += oldAlpha;
+	}
+
+	_textures->loadAndBindTexture(fontName);
+
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	int alpha = (0xff000000 & color) >> 24;
+	if (!alpha) alpha = 0xff;
+	t.color((color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff, alpha);
+	
+	t.addOffset((float)x, (float)y, 0);
+	float xOffset = 0;
+	float yOffset = 0;
+
+	while (unsigned char ch = *(str++)) {
+		if (ch == '\n') {
+			xOffset = 0;
+			yOffset += lineHeight;
+		} else {
+			buildChar(ch, xOffset, yOffset);
+			xOffset += fcharWidths[ch];
+		}
+	}
+	t.draw();
+	t.addOffset(-(float)x, -(float)y, 0);
+}
+
+void Font::buildChar( unsigned char i, float x /*= 0*/, float y /*=0*/ )
+{
+	Tesselator& t = Tesselator::instance;
+
+	//i -= _charOffset;
+	//int ix = (i % _cols) * 8 + _x;
+	//int iy = (i / _cols) * 8 + _y;
+	float ix = (float)((i & 15) * 8);
+	float iy = (float)((i >> 4) * 8);
+	float s = 7.99f;
+
+	float uo = (0.0f) / 128.0f;
+	float vo = (0.0f) / 128.0f;
+
+	t.vertexUV(x, y + s, 0, ix / 128.0f + uo, (iy + s) / 128.0f + vo);
+	t.vertexUV(x + s, y + s, 0, (ix + s) / 128.0f + uo, (iy + s) / 128.0f + vo);
+	t.vertexUV(x + s, y, 0, (ix + s) / 128.0f + uo, iy / 128.0f + vo);
+	t.vertexUV(x, y, 0, ix / 128.0f + uo, iy / 128.0f + vo);
+}
+

src/client/gui/Font.hpp

@@ -1,63 +1,61 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__Font_H__
-#define NET_MINECRAFT_CLIENT_GUI__Font_H__
-
-//package net.minecraft.client.gui;
-
-#include <string>
-#include <cctype>
-
-#include "../renderer/gles.h"
-
-class Textures;
-class Options;
-
-class Font
-{
-public:
-    Font(Options* options, const std::string& name, Textures* textures);
-	//Font(Options* options, const std::string& name, Textures* textures, int imgW, int imgH, int x, int y, int cols, int rows, unsigned char charOffset);
-	
-	void init(Options* options);
-	void onGraphicsReset();
-
-	void draw(const char* str, float x, float y, int color);
-    void draw(const std::string& str, float x, float y, int color);
-	void draw(const char* str, float x, float y, int color, bool darken);
-    void draw(const std::string& str, float x, float y, int color, bool darken);
-	void drawShadow(const std::string& str, float x, float y, int color);
-	void drawShadow(const char* str, float x, float y, int color);
-	void drawWordWrap(const std::string& str, float x, float y, float w, int col);
-
-	int width(const std::string& str);
-	int height(const std::string& str);
-
-	static std::string sanitize(const std::string& str);
-private:
-	void buildChar(unsigned char i, float x = 0, float y = 0);
-	void drawSlow(const std::string& str, float x, float y, int color, bool darken = false);
-	void drawSlow(const char* str, float x, float y, int color, bool darken = false);
-public:
-	int fontTexture;
-	int lineHeight;
-	static const int DefaultLineHeight = 10;
-private:
-	int charWidths[256];
-	float fcharWidths[256];
-	int listPos;
-
-	int index;
-	int count;
-	GLuint lists[1024];
-
-	std::string fontName;
-	Textures* _textures;
-
-	Options* options;
-
-	int _x, _y;
-	int _cols;
-	int _rows;
-	unsigned char _charOffset;
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__Font_H__*/
+#pragma once
+
+//package net.minecraft.client.gui;
+
+#include <string>
+#include <cctype>
+
+#include "client/renderer/gles.hpp"
+
+class Textures;
+class Options;
+
+class Font
+{
+public:
+    Font(Options* options, const std::string& name, Textures* textures);
+	//Font(Options* options, const std::string& name, Textures* textures, int imgW, int imgH, int x, int y, int cols, int rows, unsigned char charOffset);
+	
+	void init(Options* options);
+	void onGraphicsReset();
+
+	void draw(const char* str, float x, float y, int color);
+    void draw(const std::string& str, float x, float y, int color);
+	void draw(const char* str, float x, float y, int color, bool darken);
+    void draw(const std::string& str, float x, float y, int color, bool darken);
+	void drawShadow(const std::string& str, float x, float y, int color);
+	void drawShadow(const char* str, float x, float y, int color);
+	void drawWordWrap(const std::string& str, float x, float y, float w, int col);
+
+	int width(const std::string& str);
+	int height(const std::string& str);
+
+	static std::string sanitize(const std::string& str);
+private:
+	void buildChar(unsigned char i, float x = 0, float y = 0);
+	void drawSlow(const std::string& str, float x, float y, int color, bool darken = false);
+	void drawSlow(const char* str, float x, float y, int color, bool darken = false);
+public:
+	int fontTexture;
+	int lineHeight;
+	static const int DefaultLineHeight = 10;
+private:
+	int charWidths[256];
+	float fcharWidths[256];
+	int listPos;
+
+	int index;
+	int count;
+	GLuint lists[1024];
+
+	std::string fontName;
+	Textures* _textures;
+
+	Options* options;
+
+	int _x, _y;
+	int _cols;
+	int _rows;
+	unsigned char _charOffset;
+};
+

src/client/gui/Gui.cpp

@@ -1,32 +1,36 @@
-#include "Gui.h"
-#include "Font.h"
-#include "client/Options.h"
-#include "platform/input/Keyboard.h"
-#include "screens/IngameBlockSelectionScreen.h"
-#include "screens/ChatScreen.h"
-#include "screens/ConsoleScreen.h"
-#include "../Minecraft.h"
-#include "../player/LocalPlayer.h"
-#include "../renderer/Tesselator.h"
-#include "../renderer/TileRenderer.h"
-#include "../renderer/LevelRenderer.h"
-#include "../renderer/GameRenderer.h"
-#include "../renderer/entity/ItemRenderer.h"
-#include "../player/input/IInputHolder.h"
-#include "../gamemode/GameMode.h"
-#include "../gamemode/CreativeMode.h"
-#include "../renderer/Textures.h"
-#include "../../AppConstants.h"
-#include "../../world/entity/player/Inventory.h"
-#include "../../world/level/material/Material.h"
-#include "../../world/item/Item.h"
-#include "../../world/item/ItemInstance.h"
-#include "../../platform/input/Mouse.h"
-#include "../../world/level/Level.h"
-#include "../../world/PosTranslator.h"
-#include "../../platform/time.h"
+#include "Gui.hpp"
+#include "Font.hpp"
+#include "MinecraftClient.hpp"
+#include "client/Options.hpp"
+#include "platform/input/Keyboard.hpp"
+#include "screens/IngameBlockSelectionScreen.hpp"
+#include "screens/ChatScreen.hpp"
+#include "screens/ConsoleScreen.hpp"
+#include <Minecraft.hpp>
+#include "client/player/LocalPlayer.hpp"
+#include "client/renderer/Tesselator.hpp"
+#include "client/renderer/TileRenderer.hpp"
+#include "client/renderer/LevelRenderer.hpp"
+#include "client/renderer/GameRenderer.hpp"
+#include "client/renderer/entity/ItemRenderer.hpp"
+#include "client/player/input/IInputHolder.hpp"
+#include "client/gamemode/GameMode.hpp"
+#include "client/gamemode/CreativeMode.hpp"
+#include "client/renderer/Textures.hpp"
+#include "AppConstants.hpp"
+#include "world/entity/player/Inventory.hpp"
+#include "world/level/material/Material.hpp"
+#include "world/item/Item.hpp"
+#include "world/item/ItemInstance.hpp"
+#include "platform/input/Mouse.hpp"
+#include "world/level/Level.hpp"
+#include "world/PosTranslator.hpp"
+#include "platform/time.hpp"
 #include <cmath>
 #include <algorithm>
+#include <sstream>
+
+#define MAX_MESSAGE_WIDTH 240
 
 float Gui::InvGuiScale = 1.0f / 3.0f;
 float Gui::GuiScale = 1.0f / Gui::InvGuiScale;
@@ -34,32 +38,15 @@ const float Gui::DropTicks = 40.0f;
 
 //#include <android/log.h>
 
-Gui::Gui(Minecraft* minecraft)
-:	minecraft(minecraft),
-	tickCount(0),
-	progress(0),
-	overlayMessageTime(0),
-	animateOverlayMessageColor(false),
-	chatScrollOffset(0),
-	tbr(1),
-	_inventoryNeedsUpdate(true),
-	_flashSlotId(-1),
-	_flashSlotStartTime(-1),
-	_slotFont(NULL),
-	_numSlots(4),
-	_currentDropTicks(-1),
-	_currentDropSlot(-1),
-	MAX_MESSAGE_WIDTH(240),
-	itemNameOverlayTime(2)
-{
+// @todo virtual controlConfigurationChanged() when player switches from keyboard to touch for example 
+Gui::Gui(MinecraftClient& minecraft) : minecraft(minecraft), _openInventorySlot(minecraft.useTouchscreen()) {
 	glGenBuffers2(1, &_inventoryRc.vboId);
 	glGenBuffers2(1, &rcFeedbackInner.vboId);
 	glGenBuffers2(1, &rcFeedbackOuter.vboId);
 	//Gui::InvGuiScale = 1.0f / (int) (3 * Minecraft::width / 854);
 }
 
-Gui::~Gui()
-{
+Gui::~Gui() {
 	if (_slotFont)
 		delete _slotFont;
 
@@ -67,20 +54,16 @@ Gui::~Gui()
 }
 
 void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
-
-	if (!minecraft->level || !minecraft->player)
+	if (!minecraft.level || !minecraft.getPlayer())
 		return;
 
 	//minecraft->gameRenderer->setupGuiScreen();
-	Font* font = minecraft->font;
+	Font* font = minecraft.getFont();
 
-#ifdef PLATFORM_DESKTOP
-	const bool isTouchInterface = false;
-#else
-	const bool isTouchInterface = minecraft->useTouchscreen();
-#endif
-	const int screenWidth = (int)(minecraft->width * InvGuiScale);
-	const int screenHeight = (int)(minecraft->height * InvGuiScale);
+	const bool isTouchInterface = minecraft.useTouchscreen();
+	
+	const int screenWidth = (int)(minecraft.getScreenWidth() * InvGuiScale);
+	const int screenHeight = (int)(minecraft.getScreenHeigth() * InvGuiScale);
 	blitOffset = -90;
 	renderProgressIndicator(isTouchInterface, screenWidth, screenHeight, a);
 
@@ -92,9 +75,9 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
     // F: 3
 	int ySlot = screenHeight - 16 - 3;
 
-	if (!minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
-		if (minecraft->gameMode->canHurtPlayer()) {
-			minecraft->textures->loadAndBindTexture("gui/icons.png");
+	if (!minecraft.options.getBooleanValue(OPTIONS_HIDEGUI)) {
+		if (minecraft.gameMode->canHurtPlayer()) {
+			minecraft.getTextures()->loadAndBindTexture("gui/icons.png");
 			Tesselator& t = Tesselator::instance;
 			t.beginOverride();
 			t.colorABGR(0xffffffff);
@@ -104,7 +87,7 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
 		}
 	}
 
-	if(minecraft->player->getSleepTimer() > 0) {
+	if(minecraft.getPlayer()->getSleepTimer() > 0) {
 		glDisable(GL_DEPTH_TEST);
 		glDisable(GL_ALPHA_TEST);
 
@@ -113,7 +96,7 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
 		glEnable(GL_ALPHA_TEST);
 		glEnable(GL_DEPTH_TEST);
 	}
-	if (!minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
+	if (!minecraft.options.getBooleanValue(OPTIONS_HIDEGUI)) {
 	renderToolBar(a, ySlot, screenWidth);
 
 	glEnable(GL_BLEND);
@@ -205,16 +188,10 @@ void Gui::handleClick(int button, int x, int y) {
 	if (button != MouseAction::ACTION_LEFT)	return;
 
 	int slot = getSlotIdAt(x, y);
-	if (slot != -1)
-	{
-#ifndef PLATFORM_DESKTOP
-		if (slot == (getNumSlots()-1))
-		{
+	if (slot != -1) {
+		if (_openInventorySlot && slot == (getNumSlots()-1)) {
 			minecraft->screenChooser.setScreen(SCREEN_BLOCKSELECTION);
-		}
-		else
-#endif
-		{
+		} else {
 			minecraft->player->inventory->selectSlot(slot);
 			itemNameOverlayTime = 0;
 		}
@@ -348,7 +325,7 @@ void Gui::setNowPlaying(const std::string& string) {
 void Gui::displayClientMessage(const std::string& messageId) {
 	//Language language = Language.getInstance();
 	//std::string languageString = language.getElement(messageId);
-	addMessage(std::string("Client message: ") + messageId);
+	addMessage(messageId);
 }
 
 void Gui::renderVignette(float br, int w, int h) {
@@ -429,9 +406,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);
@@ -536,11 +513,7 @@ void Gui::tickItemDrop()
 	static bool isCurrentlyActive = false;
 	isCurrentlyActive = false;
 
-	int slots = getNumSlots();
-
-#ifndef PLATFORM_DESKTOP
-	slots--;
-#endif
+	int slots = getNumSlots() - _openInventorySlot;
 
 	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT)) {
 		int slot = getSlotIdAt(Mouse::getX(), Mouse::getY());
@@ -841,7 +814,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)
@@ -1080,13 +1055,7 @@ void Gui::renderToolBar( float a, int ySlot, const int screenWidth ) {
 
 	float x = baseItemX;
 
-	int slots = getNumSlots();
-
-	// TODO: if using touchscreen
-
-#ifndef PLATFORM_DESKTOP
-	slots--;
-#endif
+	int slots = getNumSlots() - _openInventorySlot;
 
 	for (int i = 0; i < slots; i++) {
 		renderSlot(i, (int)x, ySlot, a);
@@ -1094,9 +1063,10 @@ void Gui::renderToolBar( float a, int ySlot, const int screenWidth ) {
 	}
 	_inventoryNeedsUpdate = false;
 
-#ifndef PLATFORM_DESKTOP
-	blit(screenWidth / 2 + 10 * getNumSlots() - 20 + 4, ySlot + 6, 242, 252, 14, 4, 14, 4);
-#endif
+
+	if (_openInventorySlot) {
+		blit(screenWidth / 2 + 10 * getNumSlots() - 20 + 4, ySlot + 6, 242, 252, 14, 4, 14, 4);
+	}
 
 	minecraft->textures->loadAndBindTexture("gui/gui_blocks.png");
 	t.endOverrideAndDraw();

src/client/gui/Gui.hpp

@@ -1,132 +1,131 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__Gui_H__
-#define NET_MINECRAFT_CLIENT_GUI__Gui_H__
-
-//package net.minecraft.client.gui;
-
-#include "GuiComponent.h"
-#include "Font.h"
-#include "../player/input/touchscreen/TouchAreaModel.h"
-#include "../renderer/RenderChunk.h"
-#include "../../util/Random.h"
-#include "../IConfigListener.h"
-
-class Minecraft;
-class ItemInstance;
-class Textures;
-class Tesselator;
-struct IntRectangle;
-
-struct GuiMessage
-{
-	std::string message;
-	int ticks;
-};
-
-typedef std::vector<GuiMessage> GuiMessageList;
-
-class Gui: public GuiComponent, IConfigListener
-{
-public:
-    Gui(Minecraft* minecraft);
-	~Gui();
-
-	int getSlotIdAt(int x, int y);
-	void flashSlot(int slotId);
-	bool isInside(int x, int y);
-	RectangleArea getRectangleArea(int extendSide);
-	void getSlotPos(int slot, int& posX, int& posY);
-	int getNumSlots();
-
-	void handleClick(int button, int x, int y);
-	void handleKeyPressed( int key );
-	void scrollChat(int delta);
-
-	void tick();
-	void render(float a, bool mouseFree, int xMouse, int yMouse);
-
-	void renderToolBar( float a, int ySlot, const int screenWidth );
-
-	void renderChatMessages( const int screenHeight, unsigned int max, bool isChatting, Font* font );
-
-	// draw a string containing simple [color]...[/color] tags; color names are matched
-	// case-insensitively and default to white. alpha is applied to each segment.
-	// draw tagged string (ignores simple [color]…[/color] tags)
-	static void drawColoredString(Font* font, const std::string& text, float x, float y, int alpha);
-	static float getColoredWidth(Font* font, const std::string& text);
-
-	void renderOnSelectItemNameText( const int screenWidth, Font* font, int ySlot );
-
-	void renderSleepAnimation( const int screenWidth, const int screenHeight );
-
-	void renderBubbles();
-	void renderHearts();
-	void renderDebugInfo();
-	void renderPlayerList(Font* font, int screenWidth, int screenHeight);
-
-	void renderProgressIndicator( const bool isTouchInterface, const int screenWidth, const int screenHeight, float a );
-
-    void addMessage(const std::string& string);
-	void clearMessages();
-	void postError(int errCode);
-
-    void onGraphicsReset();
-	void inventoryUpdated();
-
-	void setNowPlaying(const std::string& string);
-	void displayClientMessage(const std::string& messageId);
-	void renderSlotText(const ItemInstance* item, float x, float y, bool hasFinite, bool shadow);
-	void texturesLoaded( Textures* textures );
-
-	void onConfigChanged(const Config& config);
-	void onLevelGenerated();
-
-	void setScissorRect(const IntRectangle& rect);
-
-	static float floorAlignToScreenPixel(float);
-	static int itemCountItoa(char* buf, int count);
-private:
-	void renderVignette(float br, int w, int h);
-	void renderSlot(int slot, int x, int y, float a);
-	void tickItemDrop();
-	float cubeSmoothStep(float percentage, float min, float max);
-public:
-	float progress;
-	std::string selectedName;
-	static float InvGuiScale;
-	static float GuiScale;
-
-private:
-	int MAX_MESSAGE_WIDTH;
-	//ItemRenderer itemRenderer;
-	GuiMessageList guiMessages;
-	int chatScrollOffset;
-	Random random;
-
-	Minecraft* minecraft;
-	int tickCount;
-	float itemNameOverlayTime;
-	std::string overlayMessageString;
-	int overlayMessageTime;
-	bool animateOverlayMessageColor;
-
-	float tbr;
-
-	RenderChunk _inventoryRc;
-	bool _inventoryNeedsUpdate;
-	
-	int _flashSlotId;
-	float _flashSlotStartTime;
-
-	Font* _slotFont;
-	int _numSlots;
-
-	RenderChunk rcFeedbackOuter;
-	RenderChunk rcFeedbackInner;
-
-	// For dropping
-	static const float DropTicks;
-	float  _currentDropTicks;
-	int    _currentDropSlot;
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__Gui_H__*/
+#pragma once
+
+//package net.minecraft.client.gui;
+
+#include "GuiComponent.hpp"
+#include "Font.hpp"
+#include "client/player/input/touchscreen/TouchAreaModel.hpp"
+#include "client/renderer/RenderChunk.hpp"
+#include "util/Random.hpp"
+#include "client/IConfigListener.hpp"
+
+class MinecraftClient;
+class ItemInstance;
+class Textures;
+class Tesselator;
+struct IntRectangle;
+
+struct GuiMessage
+{
+	std::string message;
+	int ticks;
+};
+
+typedef std::vector<GuiMessage> GuiMessageList;
+
+class Gui: public GuiComponent, IConfigListener
+{
+public:
+    Gui(MinecraftClient& minecraft);
+	~Gui();
+
+	int getSlotIdAt(int x, int y);
+	void flashSlot(int slotId);
+	bool isInside(int x, int y);
+	RectangleArea getRectangleArea(int extendSide);
+	void getSlotPos(int slot, int& posX, int& posY);
+	int getNumSlots();
+
+	void handleClick(int button, int x, int y);
+	void handleKeyPressed( int key );
+	void scrollChat(int delta);
+
+	void tick();
+	void render(float a, bool mouseFree, int xMouse, int yMouse);
+
+	void renderToolBar( float a, int ySlot, const int screenWidth );
+
+	void renderChatMessages( const int screenHeight, unsigned int max, bool isChatting, Font* font );
+
+	// draw a string containing simple [color]...[/color] tags; color names are matched
+	// case-insensitively and default to white. alpha is applied to each segment.
+	// draw tagged string (ignores simple [color]…[/color] tags)
+	static void drawColoredString(Font* font, const std::string& text, float x, float y, int alpha);
+	static float getColoredWidth(Font* font, const std::string& text);
+
+	void renderOnSelectItemNameText( const int screenWidth, Font* font, int ySlot );
+
+	void renderSleepAnimation( const int screenWidth, const int screenHeight );
+
+	void renderBubbles();
+	void renderHearts();
+	void renderDebugInfo();
+	void renderPlayerList(Font* font, int screenWidth, int screenHeight);
+
+	void renderProgressIndicator( const bool isTouchInterface, const int screenWidth, const int screenHeight, float a );
+
+    void addMessage(const std::string& string);
+	void clearMessages();
+	void postError(int errCode);
+
+    void onGraphicsReset();
+	void inventoryUpdated();
+
+	void setNowPlaying(const std::string& string);
+	void displayClientMessage(const std::string& messageId);
+	void renderSlotText(const ItemInstance* item, float x, float y, bool hasFinite, bool shadow);
+	void texturesLoaded( Textures* textures );
+
+	void onConfigChanged(const Config& config);
+	void onLevelGenerated();
+
+	void setScissorRect(const IntRectangle& rect);
+
+	static float floorAlignToScreenPixel(float);
+	static int itemCountItoa(char* buf, int count);
+private:
+	void renderVignette(float br, int w, int h);
+	void renderSlot(int slot, int x, int y, float a);
+	void tickItemDrop();
+	float cubeSmoothStep(float percentage, float min, float max);
+public:
+	float progress = 0.f;
+	std::string selectedName;
+	static float InvGuiScale;
+	static float GuiScale;
+
+private:
+	//ItemRenderer itemRenderer;
+	GuiMessageList guiMessages;
+	int chatScrollOffset = 0;
+	Random random;
+
+	MinecraftClient& minecraft;
+	int tickCount = 0;
+	float itemNameOverlayTime = 2;
+	std::string overlayMessageString;
+	int overlayMessageTime = 0;
+	bool animateOverlayMessageColor = false;
+
+	float tbr = 1.f;
+
+	RenderChunk _inventoryRc;
+	bool _inventoryNeedsUpdate = true;
+	
+	int _flashSlotId = -1;
+	float _flashSlotStartTime = -1;
+
+	Font* _slotFont = nullptr;
+	int _numSlots = 4;
+
+	RenderChunk rcFeedbackOuter;
+	RenderChunk rcFeedbackInner;
+
+	// For dropping
+	static const float DropTicks;
+	float  _currentDropTicks = -1;
+	int    _currentDropSlot = -1;
+
+	bool   _openInventorySlot;
+};
+

src/client/gui/GuiComponent.cpp

@@ -1,156 +1,156 @@
-#include "GuiComponent.h"
-
-#include "../renderer/Tesselator.h"
-#include "../renderer/gles.h"
-#include "Font.h"
-
-
-GuiComponent::GuiComponent()
-:	blitOffset(0)
-{
-}
-
-GuiComponent::~GuiComponent()
-{
-}
-
-void GuiComponent::drawCenteredString( Font* font, const std::string& str, int x, int y, int color )
-{
-	font->drawShadow(str, (float)(x - font->width(str) / 2), (float)(y - font->height(str) / 2), color);
-}
-
-void GuiComponent::drawString( Font* font, const std::string& str, int x, int y, int color )
-{
-	font->drawShadow(str, (float)x, (float)y /*- font->height(str)/2*/, color);
-}
-
-void GuiComponent::blit( int x, int y, int sx, int sy, int w, int h, int sw/*=0*/, int sh/*=0*/ )
-{
-	if (!sw) sw = w;
-	if (!sh) sh = h;
-	float us = 1 / 256.0f;
-	float vs = 1 / 256.0f;
-	Tesselator& t = Tesselator::instance;
-	t.begin();
-	t.vertexUV((float)(x)    , (float)(y + h), blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
-	t.vertexUV((float)(x + w), (float)(y + h), blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
-	t.vertexUV((float)(x + w), (float)(y)    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
-	t.vertexUV((float)(x)    , (float)(y)    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
-	t.draw();
-}
-void GuiComponent::blit( float x, float y, int sx, int sy, float w, float h, int sw/*=0*/, int sh/*=0*/ )
-{
-	if (!sw) sw = (int)w;
-	if (!sh) sh = (int)h;
-	float us = 1 / 256.0f;
-	float vs = 1 / 256.0f;
-	Tesselator& t = Tesselator::instance;
-	t.begin();
-	t.vertexUV(x    , y + h, blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
-	t.vertexUV(x + w, y + h, blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
-	t.vertexUV(x + w, y    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
-	t.vertexUV(x    , y    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
-	t.draw();
-}
-
-void GuiComponent::fill( int x0, int y0, int x1, int y1, int col ) {
-	fill((float)x0, (float)y0, (float)x1, (float)y1, col);
-}
-void GuiComponent::fill( float x0, float y0, float x1, float y1, int col )
-{
-	//float a = ((col >> 24) & 0xff) / 255.0f;
-	//float r = ((col >> 16) & 0xff) / 255.0f;
-	//float g = ((col >> 8) & 0xff) / 255.0f;
-	//float b = ((col) & 0xff) / 255.0f;
-	//glColor4f2(r, g, b, a);
-
-	Tesselator& t = Tesselator::instance;
-	glEnable2(GL_BLEND);
-	glDisable2(GL_TEXTURE_2D);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	
-	//LOGI("col: %f, %f, %f, %f\n", r, g, b, a);
-	t.begin();
-	const int color = (col&0xff00ff00) | ((col&0xff0000) >> 16) | ((col&0xff) << 16);
-	t.colorABGR(color);
-	t.vertex(x0, y1, 0);
-	t.vertex(x1, y1, 0);
-	t.vertex(x1, y0, 0);
-	t.vertex(x0, y0, 0);
-	t.draw();
-	glEnable2(GL_TEXTURE_2D);
-	glDisable2(GL_BLEND);
-}
-
-void GuiComponent::fillGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
-	fillGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
-}
-void GuiComponent::fillGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
-{
-	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
-	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
-	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
-	float b1 = ((col1) & 0xff) / 255.0f;
-
-	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
-	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
-	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
-	float b2 = ((col2) & 0xff) / 255.0f;
-	glDisable2(GL_TEXTURE_2D);
-	glEnable2(GL_BLEND);
-	glDisable2(GL_ALPHA_TEST);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glShadeModel2(GL_SMOOTH);
-
-	Tesselator& t = Tesselator::instance;
-	t.begin();
-	t.color(r1, g1, b1, a1);
-	t.vertex(x1, y0, 0);
-	t.vertex(x0, y0, 0);
-	t.color(r2, g2, b2, a2);
-	t.vertex(x0, y1, 0);
-	t.vertex(x1, y1, 0);
-	t.draw();
-
-	glShadeModel2(GL_FLAT);
-	glDisable2(GL_BLEND);
-	glEnable2(GL_ALPHA_TEST);
-	glEnable2(GL_TEXTURE_2D);
-}
-void GuiComponent::fillHorizontalGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
-	fillHorizontalGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
-}
-void GuiComponent::fillHorizontalGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
-{
-	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
-	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
-	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
-	float b1 = ((col1) & 0xff) / 255.0f;
-
-	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
-	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
-	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
-	float b2 = ((col2) & 0xff) / 255.0f;
-	glDisable2(GL_TEXTURE_2D);
-	glEnable2(GL_BLEND);
-	glDisable2(GL_ALPHA_TEST);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glShadeModel2(GL_SMOOTH);
-
-	Tesselator& t = Tesselator::instance;
-	t.begin();
-	t.color(r2, g2, b2, a2);
-	t.vertex(x1, y0, 0);
-	t.color(r1, g1, b1, a1);
-	t.vertex(x0, y0, 0);
-	t.color(r1, g1, b1, a1);
-	t.vertex(x0, y1, 0);
-	t.color(r2, g2, b2, a2);
-	t.vertex(x1, y1, 0);
-	t.draw();
-
-	glShadeModel2(GL_FLAT);
-	glDisable2(GL_BLEND);
-	glEnable2(GL_ALPHA_TEST);
-	glEnable2(GL_TEXTURE_2D);
-}
+#include "GuiComponent.hpp"
+
+#include "client/renderer/Tesselator.hpp"
+#include "client/renderer/gles.hpp"
+#include "Font.hpp"
+
+
+GuiComponent::GuiComponent()
+:	blitOffset(0)
+{
+}
+
+GuiComponent::~GuiComponent()
+{
+}
+
+void GuiComponent::drawCenteredString( Font* font, const std::string& str, int x, int y, int color )
+{
+	font->drawShadow(str, (float)(x - font->width(str) / 2), (float)(y - font->height(str) / 2), color);
+}
+
+void GuiComponent::drawString( Font* font, const std::string& str, int x, int y, int color )
+{
+	font->drawShadow(str, (float)x, (float)y /*- font->height(str)/2*/, color);
+}
+
+void GuiComponent::blit( int x, int y, int sx, int sy, int w, int h, int sw/*=0*/, int sh/*=0*/ )
+{
+	if (!sw) sw = w;
+	if (!sh) sh = h;
+	float us = 1 / 256.0f;
+	float vs = 1 / 256.0f;
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	t.vertexUV((float)(x)    , (float)(y + h), blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
+	t.vertexUV((float)(x + w), (float)(y + h), blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
+	t.vertexUV((float)(x + w), (float)(y)    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
+	t.vertexUV((float)(x)    , (float)(y)    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
+	t.draw();
+}
+void GuiComponent::blit( float x, float y, int sx, int sy, float w, float h, int sw/*=0*/, int sh/*=0*/ )
+{
+	if (!sw) sw = (int)w;
+	if (!sh) sh = (int)h;
+	float us = 1 / 256.0f;
+	float vs = 1 / 256.0f;
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	t.vertexUV(x    , y + h, blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
+	t.vertexUV(x + w, y + h, blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
+	t.vertexUV(x + w, y    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
+	t.vertexUV(x    , y    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
+	t.draw();
+}
+
+void GuiComponent::fill( int x0, int y0, int x1, int y1, int col ) {
+	fill((float)x0, (float)y0, (float)x1, (float)y1, col);
+}
+void GuiComponent::fill( float x0, float y0, float x1, float y1, int col )
+{
+	//float a = ((col >> 24) & 0xff) / 255.0f;
+	//float r = ((col >> 16) & 0xff) / 255.0f;
+	//float g = ((col >> 8) & 0xff) / 255.0f;
+	//float b = ((col) & 0xff) / 255.0f;
+	//glColor4f2(r, g, b, a);
+
+	Tesselator& t = Tesselator::instance;
+	glEnable2(GL_BLEND);
+	glDisable2(GL_TEXTURE_2D);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	
+	//LOGI("col: %f, %f, %f, %f\n", r, g, b, a);
+	t.begin();
+	const int color = (col&0xff00ff00) | ((col&0xff0000) >> 16) | ((col&0xff) << 16);
+	t.colorABGR(color);
+	t.vertex(x0, y1, 0);
+	t.vertex(x1, y1, 0);
+	t.vertex(x1, y0, 0);
+	t.vertex(x0, y0, 0);
+	t.draw();
+	glEnable2(GL_TEXTURE_2D);
+	glDisable2(GL_BLEND);
+}
+
+void GuiComponent::fillGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
+	fillGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
+}
+void GuiComponent::fillGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
+{
+	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
+	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
+	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
+	float b1 = ((col1) & 0xff) / 255.0f;
+
+	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
+	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
+	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
+	float b2 = ((col2) & 0xff) / 255.0f;
+	glDisable2(GL_TEXTURE_2D);
+	glEnable2(GL_BLEND);
+	glDisable2(GL_ALPHA_TEST);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glShadeModel2(GL_SMOOTH);
+
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	t.color(r1, g1, b1, a1);
+	t.vertex(x1, y0, 0);
+	t.vertex(x0, y0, 0);
+	t.color(r2, g2, b2, a2);
+	t.vertex(x0, y1, 0);
+	t.vertex(x1, y1, 0);
+	t.draw();
+
+	glShadeModel2(GL_FLAT);
+	glDisable2(GL_BLEND);
+	glEnable2(GL_ALPHA_TEST);
+	glEnable2(GL_TEXTURE_2D);
+}
+void GuiComponent::fillHorizontalGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
+	fillHorizontalGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
+}
+void GuiComponent::fillHorizontalGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
+{
+	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
+	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
+	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
+	float b1 = ((col1) & 0xff) / 255.0f;
+
+	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
+	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
+	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
+	float b2 = ((col2) & 0xff) / 255.0f;
+	glDisable2(GL_TEXTURE_2D);
+	glEnable2(GL_BLEND);
+	glDisable2(GL_ALPHA_TEST);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glShadeModel2(GL_SMOOTH);
+
+	Tesselator& t = Tesselator::instance;
+	t.begin();
+	t.color(r2, g2, b2, a2);
+	t.vertex(x1, y0, 0);
+	t.color(r1, g1, b1, a1);
+	t.vertex(x0, y0, 0);
+	t.color(r1, g1, b1, a1);
+	t.vertex(x0, y1, 0);
+	t.color(r2, g2, b2, a2);
+	t.vertex(x1, y1, 0);
+	t.draw();
+
+	glShadeModel2(GL_FLAT);
+	glDisable2(GL_BLEND);
+	glEnable2(GL_ALPHA_TEST);
+	glEnable2(GL_TEXTURE_2D);
+}

src/client/gui/GuiComponent.hpp

@@ -1,34 +1,32 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__GuiComponent_H__
-#define NET_MINECRAFT_CLIENT_GUI__GuiComponent_H__
-
-//package net.minecraft.client.gui;
-
-#include <string>
-class Font;
-class Minecraft;
-
-class GuiComponent
-{
-public:
-	GuiComponent();
-	virtual ~GuiComponent();
-
-	void drawString(Font* font, const std::string& str, int x, int y, int color);
-	void drawCenteredString(Font* font, const std::string& str, int x, int y, int color);
-
-	void blit(int x, int y, int sx, int sy, int w, int h, int sw=0, int sh=0);
-	void blit(float x, float y, int sx, int sy, float w, float h, int sw=0, int sh=0);
-
-protected:
-    void fill(int x0, int y0, int x1, int y1, int col);
-	void fill(float x0, float y0, float x1, float y1, int col);
-    void fillGradient(int x0, int y0, int x1, int y1, int col1, int col2);
-	void fillGradient(float x0, float y0, float x1, float y1, int col1, int col2);
-	void fillHorizontalGradient(int x0, int y0, int x1, int y1, int col1, int col2);
-	void fillHorizontalGradient(float x0, float y0, float x1, float y1, int col1, int col2);
-
-	float blitOffset;
-	
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__GuiComponent_H__*/
+#pragma once
+
+//package net.minecraft.client.gui;
+
+#include <string>
+class Font;
+class Minecraft;
+
+class GuiComponent
+{
+public:
+	GuiComponent();
+	virtual ~GuiComponent();
+
+	void drawString(Font* font, const std::string& str, int x, int y, int color);
+	void drawCenteredString(Font* font, const std::string& str, int x, int y, int color);
+
+	void blit(int x, int y, int sx, int sy, int w, int h, int sw=0, int sh=0);
+	void blit(float x, float y, int sx, int sy, float w, float h, int sw=0, int sh=0);
+
+protected:
+    void fill(int x0, int y0, int x1, int y1, int col);
+	void fill(float x0, float y0, float x1, float y1, int col);
+    void fillGradient(int x0, int y0, int x1, int y1, int col1, int col2);
+	void fillGradient(float x0, float y0, float x1, float y1, int col1, int col2);
+	void fillHorizontalGradient(int x0, int y0, int x1, int y1, int col1, int col2);
+	void fillHorizontalGradient(float x0, float y0, float x1, float y1, int col1, int col2);
+
+	float blitOffset;
+	
+};
+

src/client/gui/Screen.cpp

@@ -1,286 +1,291 @@
-#include "Screen.h"
-#include "components/Button.h"
-#include "components/TextBox.h"
-#include "../Minecraft.h"
-#include "../renderer/Tesselator.h"
-#include "../sound/SoundEngine.h"
-#include "../../platform/input/Keyboard.h"
-#include "../../platform/input/Mouse.h"
-#include "../renderer/Textures.h"
-
-Screen::Screen()
-:   passEvents(false),
-	clickedButton(NULL),
-	tabButtonIndex(0),
-	width(1),
-	height(1),
-	minecraft(NULL),
-	font(NULL)
-{
-}
-
-void Screen::render( int xm, int ym, float a )
-{
-	for (unsigned int i = 0; i < buttons.size(); i++) {
-		Button* button = buttons[i];
-		button->render(minecraft, xm, ym);
-	}
-
-	// render any text boxes after buttons
-	for (unsigned int i = 0; i < textBoxes.size(); i++) {
-		TextBox* textbox = textBoxes[i];
-		textbox->render(minecraft, xm, ym);
-	}
-}
-
-void Screen::init( Minecraft* minecraft, int width, int height )
-{
-	//particles = /*new*/ GuiParticles(minecraft);
-	this->minecraft = minecraft;
-	this->font = minecraft->font;
-	this->width = width;
-	this->height = height;
-	init();
-	setupPositions();
-	updateTabButtonSelection();
-}
-
-void Screen::init()
-{
-}
-
-void Screen::setSize( int width, int height )
-{
-	this->width = width;
-	this->height = height;
-	setupPositions();
-}
-
-bool Screen::handleBackEvent( bool isDown )
-{
-	return false;
-}
-
-void Screen::updateEvents()
-{
-	if (passEvents)
-		return;
-
-	while (Mouse::next())
-		mouseEvent();
-
-	while (Keyboard::next())
-		keyboardEvent();
-	while (Keyboard::nextTextChar())
-		keyboardTextEvent();
-}
-
-void Screen::mouseEvent()
-{
-	const MouseAction& e = Mouse::getEvent();
-	// forward wheel events to subclasses
-	if (e.action == MouseAction::ACTION_WHEEL) {
-		int xm = e.x * width / minecraft->width;
-		int ym = e.y * height / minecraft->height - 1;
-		mouseWheel(e.dx, e.dy, xm, ym);
-		return;
-	}
-
-	if (!e.isButton())
-		return;
-
-	if (Mouse::getEventButtonState()) {
-		int xm = e.x * width / minecraft->width;
-		int ym = e.y * height / minecraft->height - 1;
-		mouseClicked(xm, ym, Mouse::getEventButton());
-	} else {
-		int xm = e.x * width / minecraft->width;
-		int ym = e.y * height / minecraft->height - 1;
-		mouseReleased(xm, ym, Mouse::getEventButton());
-	}
-}
-
-void Screen::keyboardEvent()
-{
-	if (Keyboard::getEventKeyState()) {
-		//if (Keyboard.getEventKey() == Keyboard.KEY_F11) {
-		//    minecraft->toggleFullScreen();
-		//    return;
-		//}
-		keyPressed(Keyboard::getEventKey());
-	}
-}
-void Screen::keyboardTextEvent()
-{
-	charPressed(Keyboard::getChar());
-}
-void Screen::renderBackground()
-{
-	renderBackground(0);
-}
-
-void Screen::renderBackground( int vo )
-{
-	if (minecraft->isLevelGenerated()) {
-		fillGradient(0, 0, width, height, 0xc0101010, 0xd0101010);
-	} else {
-		renderDirtBackground(vo);
-	}
-}
-
-void Screen::renderDirtBackground( int vo )
-{
-	//glDisable2(GL_LIGHTING);
-	glDisable2(GL_FOG);
-	Tesselator& t = Tesselator::instance;
-	minecraft->textures->loadAndBindTexture("gui/background.png");
-	glColor4f2(1, 1, 1, 1);
-	float s = 32;
-	float fvo = (float) vo;
-	t.begin();
-	t.color(0x404040);
-	t.vertexUV(0, (float)height, 0, 0, height / s + fvo);
-	t.vertexUV((float)width, (float)height, 0, width / s, (float)height / s + fvo);
-	t.vertexUV((float)width, 0, 0, (float)width / s, 0 + fvo);
-	t.vertexUV(0, 0, 0, 0, 0 + fvo);
-	t.draw();
-}
-
-bool Screen::isPauseScreen()
-{
-	return true;
-}
-
-bool Screen::isErrorScreen()
-{
-	return false;
-}
-
-bool Screen::isInGameScreen()
-{
-	return true;
-}
-
-bool Screen::closeOnPlayerHurt() {
-    return false;
-}
-
-void Screen::keyPressed( int eventKey )
-{
-	if (eventKey == Keyboard::KEY_ESCAPE) {
-		minecraft->setScreen(NULL);
-		//minecraft->grabMouse();
-	}
-
-	// pass key events to any text boxes first
-	for (auto& textbox : textBoxes) {
-		textbox->keyPressed(minecraft, eventKey);
-	}
-
-	if (minecraft->useTouchscreen())
-		return;
-
-	// "Tabbing" the buttons (walking with keys)
-	const int tabButtonCount = tabButtons.size();
-	if (!tabButtonCount)
-		return;
-
-	Options& o = minecraft->options;
-	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_NEXT))
-		if (++tabButtonIndex == tabButtonCount) tabButtonIndex = 0;
-	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_PREV))
-		if (--tabButtonIndex == -1) tabButtonIndex = tabButtonCount-1;
-	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_OK)) {
-		Button* button = tabButtons[tabButtonIndex];
-		if (button->active) {
-			minecraft->soundEngine->playUI("random.click", 1, 1);
-			buttonClicked(button);
-		}
-	}
-
-	updateTabButtonSelection();
-}
-
-void Screen::charPressed(char inputChar) {
-	for (auto& textbox : textBoxes) {
-		textbox->charPressed(minecraft, inputChar);
-	}
-}
-
-void Screen::updateTabButtonSelection()
-{
-	if (minecraft->useTouchscreen())
-		return;
-
-	for (unsigned int i = 0; i < tabButtons.size(); ++i)
-		tabButtons[i]->selected = (i == tabButtonIndex);
-}
-
-void Screen::mouseClicked( int x, int y, int buttonNum )
-{
-	if (buttonNum == MouseAction::ACTION_LEFT) {
-		for (unsigned int i = 0; i < buttons.size(); ++i) {
-			Button* button = buttons[i];
-            //LOGI("Hit-testing button: %p\n", button);
-			if (button->clicked(minecraft, x, y)) {
-                button->setPressed();
-
-                //LOGI("Hit-test successful: %p\n", button);
-				clickedButton = button;
-/*
-#if !defined(ANDROID) && !defined(__APPLE__) //if (!minecraft->isTouchscreen()) {
-					minecraft->soundEngine->playUI("random.click", 1, 1);
-					buttonClicked(button);
-#endif }
-*/
-			}
-		}
-	}
-
-	// let textboxes see the click regardless
-	for (auto& textbox : textBoxes) {
-		textbox->mouseClicked(minecraft, x, y, buttonNum);
-	}
-}
-
-void Screen::mouseReleased( int x, int y, int buttonNum )
-{
-	//LOGI("b_id: %d, (%p), text: %s\n", buttonNum, clickedButton, clickedButton?clickedButton->msg.c_str():"<null>");
-	if (!clickedButton || buttonNum != MouseAction::ACTION_LEFT) return;
-
-#if 1
-//#if defined(ANDROID) || defined(__APPLE__) //if (minecraft->isTouchscreen()) {
-		for (unsigned int i = 0; i < buttons.size(); ++i) {
-			Button* button = buttons[i];
-			if (clickedButton == button && button->clicked(minecraft, x, y)) {
-				buttonClicked(button);
-				minecraft->soundEngine->playUI("random.click", 1, 1);
-				clickedButton->released(x, y);
-			}
-		}
-# else //	} else {
-		clickedButton->released(x, y);
-#endif // }
-	clickedButton = NULL;
-}
-
-bool Screen::renderGameBehind() {
-	return true;
-}
-
-bool Screen::hasClippingArea( IntRectangle& out )
-{
-	return false;
-}
-
-void Screen::lostFocus() {
-	for(std::vector<TextBox*>::iterator it = textBoxes.begin(); it != textBoxes.end(); ++it) {
-		TextBox* tb = *it;
-		tb->loseFocus(minecraft);
-	}
-}
-
-void Screen::toGUICoordinate( int& x, int& y ) {
-	x = x * width / minecraft->width;
-	y = y * height / minecraft->height - 1;
-}
+#include "Screen.hpp"
+#include "components/Button.hpp"
+#include "components/TextBox.hpp"
+#include <Minecraft.hpp>
+#include "client/renderer/Tesselator.hpp"
+#include "client/sound/SoundEngine.hpp"
+#include "platform/input/Keyboard.hpp"
+#include "platform/input/Mouse.hpp"
+#include "client/renderer/Textures.hpp"
+
+Screen::Screen()
+:   passEvents(false),
+	clickedButton(NULL),
+	tabButtonIndex(0),
+	width(1),
+	height(1),
+	minecraft(NULL),
+	font(NULL)
+{
+}
+
+void Screen::render( int xm, int ym, float a )
+{
+	for (unsigned int i = 0; i < buttons.size(); i++) {
+		Button* button = buttons[i];
+		button->render(minecraft, xm, ym);
+	}
+
+	// render any text boxes after buttons
+	for (unsigned int i = 0; i < textBoxes.size(); i++) {
+		TextBox* textbox = textBoxes[i];
+		textbox->render(minecraft, xm, ym);
+	}
+}
+
+void Screen::init( Minecraft* minecraft, int width, int height )
+{
+	//particles = /*new*/ GuiParticles(minecraft);
+	this->minecraft = minecraft;
+	this->font = minecraft->font;
+	this->width = width;
+	this->height = height;
+	init();
+	setupPositions();
+	updateTabButtonSelection();
+}
+
+void Screen::init()
+{
+}
+
+void Screen::setSize( int width, int height )
+{
+	this->width = width;
+	this->height = height;
+	setupPositions();
+}
+
+bool Screen::handleBackEvent( bool isDown )
+{
+	return false;
+}
+
+void Screen::updateEvents()
+{
+	if (passEvents)
+		return;
+
+	while (Mouse::next())
+		mouseEvent();
+
+	while (Keyboard::next())
+		keyboardEvent();
+	while (Keyboard::nextTextChar())
+		keyboardTextEvent();
+}
+
+void Screen::mouseEvent()
+{
+	const MouseAction& e = Mouse::getEvent();
+	// forward wheel events to subclasses
+	if (e.action == MouseAction::ACTION_WHEEL) {
+		int xm = e.x * width / minecraft->width;
+		int ym = e.y * height / minecraft->height - 1;
+		mouseWheel(e.dx, e.dy, xm, ym);
+		return;
+	}
+
+	if (!e.isButton())
+		return;
+
+	if (Mouse::getEventButtonState()) {
+		int xm = e.x * width / minecraft->width;
+		int ym = e.y * height / minecraft->height - 1;
+		mouseClicked(xm, ym, Mouse::getEventButton());
+	} else {
+		int xm = e.x * width / minecraft->width;
+		int ym = e.y * height / minecraft->height - 1;
+		mouseReleased(xm, ym, Mouse::getEventButton());
+	}
+}
+
+void Screen::keyboardEvent()
+{
+	if (Keyboard::getEventKeyState()) {
+		//if (Keyboard.getEventKey() == Keyboard.KEY_F11) {
+		//    minecraft->toggleFullScreen();
+		//    return;
+		//}
+		keyPressed(Keyboard::getEventKey());
+	}
+}
+void Screen::keyboardTextEvent()
+{
+	charPressed(Keyboard::getChar());
+}
+void Screen::renderBackground()
+{
+	renderBackground(0);
+}
+
+void Screen::renderBackground( int vo )
+{
+	if (minecraft->isLevelGenerated()) {
+		fillGradient(0, 0, width, height, 0xc0101010, 0xd0101010);
+	} else {
+		renderDirtBackground(vo);
+	}
+}
+
+void Screen::renderDirtBackground( int vo )
+{
+	//glDisable2(GL_LIGHTING);
+	glDisable2(GL_FOG);
+	Tesselator& t = Tesselator::instance;
+	minecraft->textures->loadAndBindTexture("gui/background.png");
+	glColor4f2(1, 1, 1, 1);
+	float s = 32;
+	float fvo = (float) vo;
+	t.begin();
+	t.color(0x404040);
+	t.vertexUV(0, (float)height, 0, 0, height / s + fvo);
+	t.vertexUV((float)width, (float)height, 0, width / s, (float)height / s + fvo);
+	t.vertexUV((float)width, 0, 0, (float)width / s, 0 + fvo);
+	t.vertexUV(0, 0, 0, 0, 0 + fvo);
+	t.draw();
+}
+
+bool Screen::isPauseScreen()
+{
+	return true;
+}
+
+bool Screen::isErrorScreen()
+{
+	return false;
+}
+
+bool Screen::isInGameScreen()
+{
+	return true;
+}
+
+bool Screen::closeOnPlayerHurt() {
+    return false;
+}
+
+void Screen::keyPressed( int eventKey )
+{
+	if (eventKey == Keyboard::KEY_ESCAPE) {
+		minecraft->setScreen(NULL);
+		//minecraft->grabMouse();
+	}
+
+	// pass key events to any text boxes first
+	for (auto& textbox : textBoxes) {
+		textbox->keyPressed(minecraft, eventKey);
+	}
+
+#ifdef TABBING
+	if (minecraft->useTouchscreen())
+		return;
+
+
+	// "Tabbing" the buttons (walking with keys)
+	const int tabButtonCount = tabButtons.size();
+	if (!tabButtonCount)
+		return;
+
+	Options& o = minecraft->options;
+	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_NEXT))
+		if (++tabButtonIndex == tabButtonCount) tabButtonIndex = 0;
+	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_PREV))
+		if (--tabButtonIndex == -1) tabButtonIndex = tabButtonCount-1;
+	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_OK)) {
+		Button* button = tabButtons[tabButtonIndex];
+		if (button->active) {
+			minecraft->soundEngine->playUI("random.click", 1, 1);
+			buttonClicked(button);
+		}
+	}
+
+	updateTabButtonSelection();
+#endif
+}
+
+void Screen::charPressed(char inputChar) {
+	for (auto& textbox : textBoxes) {
+		textbox->charPressed(minecraft, inputChar);
+	}
+}
+
+void Screen::updateTabButtonSelection()
+{
+#ifdef TABBING
+	if (minecraft->useTouchscreen())
+		return;
+
+	for (unsigned int i = 0; i < tabButtons.size(); ++i)
+		tabButtons[i]->selected = (i == tabButtonIndex);
+#endif
+}
+
+void Screen::mouseClicked( int x, int y, int buttonNum )
+{
+	if (buttonNum == MouseAction::ACTION_LEFT) {
+		for (unsigned int i = 0; i < buttons.size(); ++i) {
+			Button* button = buttons[i];
+            //LOGI("Hit-testing button: %p\n", button);
+			if (button->clicked(minecraft, x, y)) {
+                button->setPressed();
+
+                //LOGI("Hit-test successful: %p\n", button);
+				clickedButton = button;
+/*
+#if !defined(ANDROID) && !defined(__APPLE__) //if (!minecraft->isTouchscreen()) {
+					minecraft->soundEngine->playUI("random.click", 1, 1);
+					buttonClicked(button);
+#endif }
+*/
+			}
+		}
+	}
+
+	// let textboxes see the click regardless
+	for (auto& textbox : textBoxes) {
+		textbox->mouseClicked(minecraft, x, y, buttonNum);
+	}
+}
+
+void Screen::mouseReleased( int x, int y, int buttonNum )
+{
+	//LOGI("b_id: %d, (%p), text: %s\n", buttonNum, clickedButton, clickedButton?clickedButton->msg.c_str():"<null>");
+	if (!clickedButton || buttonNum != MouseAction::ACTION_LEFT) return;
+
+#if 1
+//#if defined(ANDROID) || defined(__APPLE__) //if (minecraft->isTouchscreen()) {
+		for (unsigned int i = 0; i < buttons.size(); ++i) {
+			Button* button = buttons[i];
+			if (clickedButton == button && button->clicked(minecraft, x, y)) {
+				buttonClicked(button);
+				minecraft->soundEngine->playUI("random.click", 1, 1);
+				clickedButton->released(x, y);
+			}
+		}
+# else //	} else {
+		clickedButton->released(x, y);
+#endif // }
+	clickedButton = NULL;
+}
+
+bool Screen::renderGameBehind() {
+	return true;
+}
+
+bool Screen::hasClippingArea( IntRectangle& out )
+{
+	return false;
+}
+
+void Screen::lostFocus() {
+	for(std::vector<TextBox*>::iterator it = textBoxes.begin(); it != textBoxes.end(); ++it) {
+		TextBox* tb = *it;
+		tb->loseFocus(minecraft);
+	}
+}
+
+void Screen::toGUICoordinate( int& x, int& y ) {
+	x = x * width / minecraft->width;
+	y = y * height / minecraft->height - 1;
+}

src/client/gui/Screen.hpp

@@ -1,83 +1,81 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__Screen_H__
-#define NET_MINECRAFT_CLIENT_GUI__Screen_H__
-
-//package net.minecraft.client.gui;
-
-#include <vector>
-#include "GuiComponent.h"
-
-class Font;
-class Minecraft;
-class Button;
-class TextBox;
-struct IntRectangle;
-
-class Screen: public GuiComponent
-{
-public:
-	Screen();
-
-    virtual void render(int xm, int ym, float a);
-
-    void init(Minecraft* minecraft, int width, int height);
-	virtual void init();
-
-    void setSize(int width, int height);
-	virtual void setupPositions() {};
-
-	virtual void updateEvents();
-    virtual void mouseEvent();
-    virtual void keyboardEvent();
-	virtual void keyboardTextEvent();
-	virtual bool handleBackEvent(bool isDown);
-
-    virtual void tick() {}
-
-    virtual void removed() {}
-
-    virtual void renderBackground();
-    virtual void renderBackground(int vo);
-    virtual void renderDirtBackground(int vo);
-	// query
-	virtual bool renderGameBehind();
-	virtual bool hasClippingArea(IntRectangle& out);
-
-    virtual bool isPauseScreen();
-	virtual bool isErrorScreen();
-	virtual bool isInGameScreen();
-    virtual bool closeOnPlayerHurt();
-
-    virtual void confirmResult(bool result, int id) {}
-	virtual void lostFocus();
-	virtual void toGUICoordinate(int& x, int& y);
-protected:
-	void updateTabButtonSelection();
-
-	virtual void buttonClicked(Button* button) {}
-	virtual void mouseClicked(int x, int y, int buttonNum);
-	virtual void mouseReleased(int x, int y, int buttonNum);
-
-	// mouse wheel movement (dx/dy are wheel deltas, xm/ym are GUI coords)
-	virtual void mouseWheel(int dx, int dy, int xm, int ym) {}
-
-	virtual void keyPressed(int eventKey);
-	virtual void charPressed(char inputChar);
-public:
-	int width;
-	int height;
-	bool passEvents;
-	//GuiParticles* particles;
-protected:
-	Minecraft* minecraft;
-	std::vector<Button*> buttons;
-	std::vector<TextBox*> textBoxes;
-
-	std::vector<Button*> tabButtons;
-	int tabButtonIndex;
-
-	Font* font;
-private:
-	Button* clickedButton;
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__Screen_H__*/
+#pragma once
+
+//package net.minecraft.client.gui;
+
+#include <vector>
+#include "GuiComponent.hpp"
+
+class Font;
+class Minecraft;
+class Button;
+class TextBox;
+struct IntRectangle;
+
+class Screen: public GuiComponent
+{
+public:
+	Screen();
+
+    virtual void render(int xm, int ym, float a);
+
+    void init(Minecraft* minecraft, int width, int height);
+	virtual void init();
+
+    void setSize(int width, int height);
+	virtual void setupPositions() {};
+
+	virtual void updateEvents();
+    virtual void mouseEvent();
+    virtual void keyboardEvent();
+	virtual void keyboardTextEvent();
+	virtual bool handleBackEvent(bool isDown);
+
+    virtual void tick() {}
+
+    virtual void removed() {}
+
+    virtual void renderBackground();
+    virtual void renderBackground(int vo);
+    virtual void renderDirtBackground(int vo);
+	// query
+	virtual bool renderGameBehind();
+	virtual bool hasClippingArea(IntRectangle& out);
+
+    virtual bool isPauseScreen();
+	virtual bool isErrorScreen();
+	virtual bool isInGameScreen();
+    virtual bool closeOnPlayerHurt();
+
+    virtual void confirmResult(bool result, int id) {}
+	virtual void lostFocus();
+	virtual void toGUICoordinate(int& x, int& y);
+protected:
+	void updateTabButtonSelection();
+
+	virtual void buttonClicked(Button* button) {}
+	virtual void mouseClicked(int x, int y, int buttonNum);
+	virtual void mouseReleased(int x, int y, int buttonNum);
+
+	// mouse wheel movement (dx/dy are wheel deltas, xm/ym are GUI coords)
+	virtual void mouseWheel(int dx, int dy, int xm, int ym) {}
+
+	virtual void keyPressed(int eventKey);
+	virtual void charPressed(char inputChar);
+public:
+	int width;
+	int height;
+	bool passEvents;
+	//GuiParticles* particles;
+protected:
+	Minecraft* minecraft;
+	std::vector<Button*> buttons;
+	std::vector<TextBox*> textBoxes;
+
+	std::vector<Button*> tabButtons;
+	int tabButtonIndex;
+
+	Font* font;
+private:
+	Button* clickedButton;
+};
+

src/client/gui/TweenData.h

@@ -1,11 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__TweenData_H__
-#define NET_MINECRAFT_CLIENT_GUI__TweenData_H__
-
-typedef struct TweenData {
-	float cur;
-	float dur;
-	float start;
-	float stop;
-} TweenData;
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__TweenData_H__*/

src/client/gui/TweenData.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+typedef struct TweenData {
+	float cur;
+	float dur;
+	float start;
+	float stop;
+} TweenData;
+

src/client/gui/components/Button.cpp

@@ -1,218 +1,219 @@
-#include "Button.h"
-#include "../../Minecraft.h"
-#include "../../renderer/Textures.h"
-
-Button::Button(int id, const std::string& msg)
-:	GuiElement(true, true, 0, 0, 200, 24),
-    id(id),
-	msg(msg),
-	selected(false),
-    _currentlyDown(false)
-{
-}
-
-Button::Button( int id, int x, int y, const std::string& msg )
-:	GuiElement(true, true, x, y, 200, 24),
-    id(id),
-	msg(msg),
-	selected(false),
-    _currentlyDown(false)
-{
-}
-
-Button::Button( int id, int x, int y, int w, int h, const std::string& msg )
-:	GuiElement(true, true, x, y, w, h),
-    id(id),
-	msg(msg),
-	selected(false),
-    _currentlyDown(false)
-{
-}
-
-void Button::render( Minecraft* minecraft, int xm, int ym )
-{
-	if (!visible) return;
-
-	/*
-	minecraft->textures->loadAndBindTexture("gui/gui.png");
-	glColor4f2(1, 1, 1, 1);
-
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	int yImage = getYImage(hovered || selected);
-
-	blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
-	blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
-	*/
-
-	renderBg(minecraft, xm, ym);
-	renderFace(minecraft, xm , ym);
-}
-
-void Button::released( int mx, int my ) {
-    _currentlyDown = false;
-}
-
-bool Button::clicked( Minecraft* minecraft, int mx, int my )
-{
-	return active && mx >= x && my >= y && mx < x + width && my < y + height;
-}
-
-void Button::setPressed() {
-    _currentlyDown = true;
-}
-
-int Button::getYImage( bool hovered )
-{
-	int res = 1;
-	if (!active) res = 0;
-	else if (hovered) res = 2;
-	return res;
-}
-
-void Button::renderFace(Minecraft* mc, int xm, int ym) {
-	Font* font = mc->font;
-	if (!active) {
-		drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffa0a0a0);
-	} else {
-		if (hovered(mc, xm, ym) || selected) {
-			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffffa0);
-		} else {
-			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xe0e0e0);
-		}
-	}
-}
-
-void Button::renderBg( Minecraft* minecraft, int xm, int ym )
-{
-	minecraft->textures->loadAndBindTexture("gui/gui.png");
-	glColor4f2(1, 1, 1, 1);
-
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	int yImage = getYImage(selected || hovered(minecraft, xm, ym));;
-
-	blit(x, y, 0, 46 + yImage * 20, width / 2, height, 0, 20);
-	blit(x + width / 2, y, 200 - width / 2, 46 + yImage * 20, width / 2, height, 0, 20);
-}
-
-bool Button::hovered(Minecraft* minecraft, int xm , int ym) {
-	return minecraft->useTouchscreen()? (_currentlyDown && isInside(xm, ym)) : false;
-}
-
-bool Button::isInside( int xm, int ym ) {
-	return xm >= x && ym >= y && xm < x + width && ym < y + height;
-}
-
-//
-// BlankButton
-//
-BlankButton::BlankButton(int id)
-:	super(id, "")
-{
-	visible = false;
-}
-
-BlankButton::BlankButton(int id, int x, int y, int w, int h)
-:	super(id, x, y, w, h, "")
-{
-	visible = false;
-}
-
-//
-// The Touch-interface button
-//
-namespace Touch {
-
-TButton::TButton(int id, const std::string& msg)
-:	super(id, msg)
-{
-	width = 66;
-	height = 26;
-}
-
-TButton::TButton( int id, int x, int y, const std::string& msg )
-:	super(id, x, y, msg)
-{
-	width = 66;
-	height = 26;
-}
-
-TButton::TButton( int id, int x, int y, int w, int h, const std::string& msg )
-:	super(id, x, y, w, h, msg)
-{
-}
-
-void TButton::renderBg( Minecraft* minecraft, int xm, int ym )
-{
-	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : false);
-
-	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
-
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	if (active)
-		glColor4f2(1, 1, 1, 1);
-	else
-		glColor4f2(0.5f, 0.5f, 0.5f, 1);
-
-	blit(x, y, hovered?66:0, 0, width, height, 66, 26);
-	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
-}
-
-
-//
-// Header spacing in Touchscreen mode
-//
-THeader::THeader(int id, const std::string& msg)
-:	super(id, msg),
-	xText(-99999)
-{
-	active = false;
-	width = 66;
-	height = 26;
-}
-
-THeader::THeader( int id, int x, int y, const std::string& msg )
-:	super(id, x, y, msg),
-	xText(-99999)
-{
-	active = false;
-	width = 66;
-	height = 26;
-}
-
-THeader::THeader( int id, int x, int y, int w, int h, const std::string& msg )
-:	super(id, x, y, w, h, msg),
-	xText(-99999)
-{
-	active = false;
-}
-
-void THeader::render( Minecraft* minecraft, int xm, int ym ) {
-	Font* font = minecraft->font;
-	renderBg(minecraft, xm, ym);
-	
-	int xx = x + width/2;
-	if (xText != -99999)
-		xx = xText;
-	drawCenteredString(font, msg, xx, y + (height - 8) / 2, 0xe0e0e0);
-}
-
-void THeader::renderBg( Minecraft* minecraft, int xm, int ym )
-{
-	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
-
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	glColor4f2(1, 1, 1, 1);
-
-	// Left cap
-	blit(x, y, 150, 26, 2, height-1, 2, 25);
-	// Middle
-	blit(x+2, y, 153, 26, width-3, height-1, 8, 25);
-	// Right cap
-	blit(x+width-2, y, 162, 26, 2, height-1, 2, 25);
-	// Shadow
-	glEnable2(GL_BLEND);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	blit(x, y+height-1, 153, 52, width, 3, 8, 3);
-}
-
-};
+#include "Button.hpp"
+#include "client/Minecraft.hpp"
+#include "client/renderer/Textures.hpp"
+
+Button::Button(int id, const std::string& msg)
+:	GuiElement(true, true, 0, 0, 200, 24),
+    id(id),
+	msg(msg),
+	selected(false),
+    _currentlyDown(false)
+{
+}
+
+Button::Button( int id, int x, int y, const std::string& msg )
+:	GuiElement(true, true, x, y, 200, 24),
+    id(id),
+	msg(msg),
+	selected(false),
+    _currentlyDown(false)
+{
+}
+
+Button::Button( int id, int x, int y, int w, int h, const std::string& msg )
+:	GuiElement(true, true, x, y, w, h),
+    id(id),
+	msg(msg),
+	selected(false),
+    _currentlyDown(false)
+{
+}
+
+void Button::render( Minecraft* minecraft, int xm, int ym )
+{
+	if (!visible) return;
+
+	/*
+	minecraft->textures->loadAndBindTexture("gui/gui.png");
+	glColor4f2(1, 1, 1, 1);
+
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	int yImage = getYImage(hovered || selected);
+
+	blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
+	blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
+	*/
+
+	renderBg(minecraft, xm, ym);
+	renderFace(minecraft, xm , ym);
+}
+
+void Button::released( int mx, int my ) {
+    _currentlyDown = false;
+}
+
+bool Button::clicked( Minecraft* minecraft, int mx, int my )
+{
+	return active && mx >= x && my >= y && mx < x + width && my < y + height;
+}
+
+void Button::setPressed() {
+    _currentlyDown = true;
+}
+
+int Button::getYImage( bool hovered )
+{
+	int res = 1;
+	if (!active) res = 0;
+	else if (hovered) res = 2;
+	return res;
+}
+
+void Button::renderFace(Minecraft* mc, int xm, int ym) {
+	Font* font = mc->font;
+	if (!active) {
+		drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffa0a0a0);
+	} else {
+		if (hovered(mc, xm, ym) || selected) {
+			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffffa0);
+		} else {
+			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xe0e0e0);
+		}
+	}
+}
+
+void Button::renderBg( Minecraft* minecraft, int xm, int ym )
+{
+	minecraft->textures->loadAndBindTexture("gui/gui.png");
+	glColor4f2(1, 1, 1, 1);
+
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	int yImage = getYImage(selected || hovered(minecraft, xm, ym));;
+
+	blit(x, y, 0, 46 + yImage * 20, width / 2, height, 0, 20);
+	blit(x + width / 2, y, 200 - width / 2, 46 + yImage * 20, width / 2, height, 0, 20);
+}
+
+bool Button::hovered(Minecraft* minecraft, int xm , int ym) {
+	return minecraft->useTouchscreen()? (_currentlyDown && isInside(xm, ym)) : isInside(xm, ym);
+}
+
+bool Button::isInside( int xm, int ym ) {
+	return xm >= x && ym >= y && xm < x + width && ym < y + height;
+}
+
+//
+// BlankButton
+//
+BlankButton::BlankButton(int id)
+:	super(id, "")
+{
+	visible = false;
+}
+
+BlankButton::BlankButton(int id, int x, int y, int w, int h)
+:	super(id, x, y, w, h, "")
+{
+	visible = false;
+}
+
+//
+// The Touch-interface button
+//
+namespace Touch {
+
+TButton::TButton(int id, const std::string& msg)
+:	super(id, msg)
+{
+	width = 66;
+	height = 26;
+}
+
+TButton::TButton( int id, int x, int y, const std::string& msg )
+:	super(id, x, y, msg)
+{
+	width = 66;
+	height = 26;
+}
+
+TButton::TButton( int id, int x, int y, int w, int h, const std::string& msg )
+:	super(id, x, y, w, h, msg)
+{
+}
+
+void TButton::renderBg( Minecraft* minecraft, int xm, int ym )
+{
+	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
+	// bool hovered = active && (_currentlyDown && isInside(xm, ym));
+
+	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
+
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	if (active)
+		glColor4f2(1, 1, 1, 1);
+	else
+		glColor4f2(0.5f, 0.5f, 0.5f, 1);
+
+	blit(x, y, hovered?66:0, 0, width, height, 66, 26);
+	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
+}
+
+
+//
+// Header spacing in Touchscreen mode
+//
+THeader::THeader(int id, const std::string& msg)
+:	super(id, msg),
+	xText(-99999)
+{
+	active = false;
+	width = 66;
+	height = 26;
+}
+
+THeader::THeader( int id, int x, int y, const std::string& msg )
+:	super(id, x, y, msg),
+	xText(-99999)
+{
+	active = false;
+	width = 66;
+	height = 26;
+}
+
+THeader::THeader( int id, int x, int y, int w, int h, const std::string& msg )
+:	super(id, x, y, w, h, msg),
+	xText(-99999)
+{
+	active = false;
+}
+
+void THeader::render( Minecraft* minecraft, int xm, int ym ) {
+	Font* font = minecraft->font;
+	renderBg(minecraft, xm, ym);
+	
+	int xx = x + width/2;
+	if (xText != -99999)
+		xx = xText;
+	drawCenteredString(font, msg, xx, y + (height - 8) / 2, 0xe0e0e0);
+}
+
+void THeader::renderBg( Minecraft* minecraft, int xm, int ym )
+{
+	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
+
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	glColor4f2(1, 1, 1, 1);
+
+	// Left cap
+	blit(x, y, 150, 26, 2, height-1, 2, 25);
+	// Middle
+	blit(x+2, y, 153, 26, width-3, height-1, 8, 25);
+	// Right cap
+	blit(x+width-2, y, 162, 26, 2, height-1, 2, 25);
+	// Shadow
+	glEnable2(GL_BLEND);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	blit(x, y+height-1, 153, 52, width, 3, 8, 3);
+}
+
+};

src/client/gui/components/Button.hpp

@@ -1,80 +1,78 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI_COMPONENTS__Button_H__
-#define NET_MINECRAFT_CLIENT_GUI_COMPONENTS__Button_H__
-
-//package net.minecraft.client.gui;
-
-#include <string>
-#include "GuiElement.h"
-#include "../../Options.h"
-
-class Font;
-class Minecraft;
-
-class Button: public GuiElement
-{
-public:
-	Button(int id, const std::string& msg);
-    Button(int id, int x, int y, const std::string& msg);
-    Button(int id, int x, int y, int w, int h, const std::string& msg);
-	virtual ~Button() {}
-    virtual void render(Minecraft* minecraft, int xm, int ym);
-
-	virtual bool clicked(Minecraft* minecraft, int mx, int my);
-    virtual void released(int mx, int my);
-    virtual void setPressed();
-
-	bool isInside(int xm, int ym);
-protected:
-	virtual int getYImage(bool hovered);
-	virtual void renderBg(Minecraft* minecraft, int xm, int ym);
-
-	virtual void renderFace(Minecraft* minecraft, int xm, int ym);
-	bool hovered(Minecraft* minecraft, int xm, int ym);	
-public:
-	std::string msg;
-	int id;
-
-	bool selected;
-protected:
-    bool _currentlyDown;
-};
-
-// @note: A bit backwards, but this is a button that
-//        only reacts to clicks, but isn't rendered.
-class BlankButton: public Button
-{
-	typedef Button super;
-public:
-	BlankButton(int id);
-	BlankButton(int id, int x, int y, int w, int h);
-};
-
-
-namespace Touch {
-class TButton: public Button
-{
-	typedef Button super;
-public:
-	TButton(int id, const std::string& msg);
-	TButton(int id, int x, int y, const std::string& msg);
-	TButton(int id, int x, int y, int w, int h, const std::string& msg);
-protected:
-	virtual void renderBg(Minecraft* minecraft, int xm, int ym);
-};
-
-// "Header" in Touchscreen mode
-class THeader: public Button {
-	typedef Button super;
-public:
-	THeader(int id, const std::string& msg);
-	THeader(int id, int x, int y, const std::string& msg);
-	THeader(int id, int x, int y, int w, int h, const std::string& msg);
-protected:
-	virtual void renderBg(Minecraft* minecraft, int xm, int ym);
-	void render( Minecraft* minecraft, int xm, int ym );
-public:
-	int xText;
-};
-}
-
-#endif /*NET_MINECRAFT_CLIENT_GUI_COMPONENTS__Button_H__*/
+#pragma once
+
+//package net.minecraft.client.gui;
+
+#include <string>
+#include "GuiElement.hpp"
+#include "client/Options.hpp"
+
+class Font;
+class Minecraft;
+
+class Button: public GuiElement
+{
+public:
+	Button(int id, const std::string& msg);
+    Button(int id, int x, int y, const std::string& msg);
+    Button(int id, int x, int y, int w, int h, const std::string& msg);
+	virtual ~Button() {}
+    virtual void render(Minecraft* minecraft, int xm, int ym);
+
+	virtual bool clicked(Minecraft* minecraft, int mx, int my);
+    virtual void released(int mx, int my);
+    virtual void setPressed();
+
+	bool isInside(int xm, int ym);
+protected:
+	virtual int getYImage(bool hovered);
+	virtual void renderBg(Minecraft* minecraft, int xm, int ym);
+
+	virtual void renderFace(Minecraft* minecraft, int xm, int ym);
+	bool hovered(Minecraft* minecraft, int xm, int ym);	
+public:
+	std::string msg;
+	int id;
+
+	bool selected;
+protected:
+    bool _currentlyDown;
+};
+
+// @note: A bit backwards, but this is a button that
+//        only reacts to clicks, but isn't rendered.
+class BlankButton: public Button
+{
+	typedef Button super;
+public:
+	BlankButton(int id);
+	BlankButton(int id, int x, int y, int w, int h);
+};
+
+
+namespace Touch {
+class TButton: public Button
+{
+	typedef Button super;
+public:
+	TButton(int id, const std::string& msg);
+	TButton(int id, int x, int y, const std::string& msg);
+	TButton(int id, int x, int y, int w, int h, const std::string& msg);
+protected:
+	virtual void renderBg(Minecraft* minecraft, int xm, int ym);
+};
+
+// "Header" in Touchscreen mode
+class THeader: public Button {
+	typedef Button super;
+public:
+	THeader(int id, const std::string& msg);
+	THeader(int id, int x, int y, const std::string& msg);
+	THeader(int id, int x, int y, int w, int h, const std::string& msg);
+protected:
+	virtual void renderBg(Minecraft* minecraft, int xm, int ym);
+	void render( Minecraft* minecraft, int xm, int ym );
+public:
+	int xText;
+};
+}
+

src/client/gui/components/GButton.cpp

@@ -1 +1 @@
-#include "GuiElement.h"
+#include "GuiElement.hpp"

src/client/gui/components/GButton.hpp

@@ -1,55 +1,53 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__GButton_H__
-#define NET_MINECRAFT_CLIENT_GUI__GButton_H__
-#include "Button.h"
-
-class GButton: public Button {
-	typedef Button super;
-public:
-	static const int LayerDefault	= 1;
-	static const int LayerSelected  = 2;
-	static const int LayerMax       = 4;
-
-	GButton(int id)
-		:	super(id, "")
-	{}
-	~GButton() {
-		for (unsigned int i = 0; i < layers.size(); ++i) {
-			delete layers[i].first;
-		}
-	}
-
-	void addElement(int layerId, GuiElement* e) {
-		if (!e || layerId < 0 || layerId >= LayerMax) {
-			LOGE("Error @ GButton::element : Trying to add element %p at layer: %d\n", e, layerId);
-			return;
-		}
-		layers.push_back(std::make_pair(e, layerId));
-	}
-
-	void render( Minecraft* minecraft, int xm, int ym )
-	{
-		if (!visible) return;
-
-		bool isHovered = minecraft->isTouchscreen()?
-			(_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height): false;
-
-		int layer = isHovered? LayerSelected : LayerDefault;
-		if (layer < 0) return;
-
-		Tesselator& t = Tesselator::instance;
-		t.addOffset((float)x, (float)y, 0);
-
-		for (unsigned int i = 0; i < layers.size(); ++i) {
-			if ((layers[i].second & layer) != 0)
-				layers[i].first->render(minecraft, 0, 0);
-		}
-
-		t.addOffset((float)-x, (float)-y, 0);
-	}
-
-private:
-	std::vector<std::pair<GuiElement*, int> > layers;
-};
-
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__GButton_H__*/
+#pragma once
+#include "Button.hpp"
+
+class GButton: public Button {
+	typedef Button super;
+public:
+	static const int LayerDefault	= 1;
+	static const int LayerSelected  = 2;
+	static const int LayerMax       = 4;
+
+	GButton(int id)
+		:	super(id, "")
+	{}
+	~GButton() {
+		for (unsigned int i = 0; i < layers.size(); ++i) {
+			delete layers[i].first;
+		}
+	}
+
+	void addElement(int layerId, GuiElement* e) {
+		if (!e || layerId < 0 || layerId >= LayerMax) {
+			LOGE("Error @ GButton::element : Trying to add element %p at layer: %d\n", e, layerId);
+			return;
+		}
+		layers.push_back(std::make_pair(e, layerId));
+	}
+
+	void render( Minecraft* minecraft, int xm, int ym )
+	{
+		if (!visible) return;
+
+		bool isHovered = minecraft->isTouchscreen()?
+			(_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height): false;
+
+		int layer = isHovered? LayerSelected : LayerDefault;
+		if (layer < 0) return;
+
+		Tesselator& t = Tesselator::instance;
+		t.addOffset((float)x, (float)y, 0);
+
+		for (unsigned int i = 0; i < layers.size(); ++i) {
+			if ((layers[i].second & layer) != 0)
+				layers[i].first->render(minecraft, 0, 0);
+		}
+
+		t.addOffset((float)-x, (float)-y, 0);
+	}
+
+private:
+	std::vector<std::pair<GuiElement*, int> > layers;
+};
+
+

src/client/gui/components/GuiElement.cpp

@@ -1,20 +1,20 @@
-#include "GuiElement.h"
-
-GuiElement::GuiElement( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
-: active(active),
-  visible(visible),
-  x(x),
-  y(y),
-  width(width),
-  height(height) {
-		
-}
-
-bool GuiElement::pointInside( int x, int y ) {
-	if(x >= this->x && x < this->x + this->width) {
-		if(y >= this->y && y < this->y + this->height) {
-			return true;
-		}
-	}
-	return false;
-}
+#include "GuiElement.hpp"
+
+GuiElement::GuiElement( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
+: active(active),
+  visible(visible),
+  x(x),
+  y(y),
+  width(width),
+  height(height) {
+		
+}
+
+bool GuiElement::pointInside( int x, int y ) {
+	if(x >= this->x && x < this->x + this->width) {
+		if(y >= this->y && y < this->y + this->height) {
+			return true;
+		}
+	}
+	return false;
+}

src/client/gui/components/GuiElement.hpp

@@ -1,34 +1,32 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__GuiElement_H__
-#define NET_MINECRAFT_CLIENT_GUI__GuiElement_H__
-#include "../GuiComponent.h"
-
-class Tesselator;
-class Minecraft;
-
-class GuiElement : public GuiComponent {
-public:
-	GuiElement(bool active=false, bool visible=true, int x = 0, int y = 0, int width=24, int height=24);
-    virtual ~GuiElement() {}
-    
-	virtual void tick(Minecraft* minecraft) {}
-    virtual void render(Minecraft* minecraft, int xm, int ym) { }
-	virtual void setupPositions() {}
-
-	virtual void mouseClicked(Minecraft* minecraft, int x, int y, int buttonNum) {}
-	virtual void mouseReleased(Minecraft* minecraft, int x, int y, int buttonNum) {}
-	virtual void keyPressed(Minecraft* minecraft, int key) {}
-	virtual void charPressed(Minecraft* minecraft, char key) {}
-
-	virtual bool pointInside(int x, int y);
-	
-	void setVisible(bool visible);
-	
-	bool active;
-	bool visible;
-	int x;
-	int y;
-	int width;
-	int height;
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__GuiElement_H__*/
+#pragma once
+#include "client/gui/GuiComponent.hpp"
+
+class Tesselator;
+class Minecraft;
+
+class GuiElement : public GuiComponent {
+public:
+	GuiElement(bool active=false, bool visible=true, int x = 0, int y = 0, int width=24, int height=24);
+    virtual ~GuiElement() {}
+    
+	virtual void tick(Minecraft* minecraft) {}
+    virtual void render(Minecraft* minecraft, int xm, int ym) { }
+	virtual void setupPositions() {}
+
+	virtual void mouseClicked(Minecraft* minecraft, int x, int y, int buttonNum) {}
+	virtual void mouseReleased(Minecraft* minecraft, int x, int y, int buttonNum) {}
+	virtual void keyPressed(Minecraft* minecraft, int key) {}
+	virtual void charPressed(Minecraft* minecraft, char key) {}
+
+	virtual bool pointInside(int x, int y);
+	
+	void setVisible(bool visible);
+	
+	bool active;
+	bool visible;
+	int x;
+	int y;
+	int width;
+	int height;
+};
+

src/client/gui/components/GuiElementContainer.cpp

@@ -1,66 +1,66 @@
-#include "GuiElementContainer.h"
-#include <algorithm>
-GuiElementContainer::GuiElementContainer( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
-: GuiElement(active, visible, x, y, width, height) {
-
-}
-
-GuiElementContainer::~GuiElementContainer() {
-	while(!children.empty()) {
-		GuiElement* element = children.back();
-		children.pop_back();
-		delete element;
-	}
-}
-
-void GuiElementContainer::render( Minecraft* minecraft, int xm, int ym ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->render(minecraft, xm, ym);
-	}
-}
-
-void GuiElementContainer::setupPositions() {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->setupPositions();
-	}
-}
-
-void GuiElementContainer::addChild( GuiElement* element ) {
-	children.push_back(element);
-}
-
-void GuiElementContainer::removeChild( GuiElement* element ) {
-	std::vector<GuiElement*>::iterator it = std::find(children.begin(), children.end(), element);
-	if(it != children.end())
-		children.erase(it);
-}
-
-void GuiElementContainer::tick( Minecraft* minecraft ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->tick(minecraft);
-	}
-}
-
-void GuiElementContainer::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->mouseClicked(minecraft, x, y, buttonNum);
-	}
-}
-
-void GuiElementContainer::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->mouseReleased(minecraft, x, y, buttonNum);
-	}
-}
-
-void GuiElementContainer::keyPressed(Minecraft* minecraft, int key) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->keyPressed(minecraft, key);
-	}
-}
-
-void GuiElementContainer::charPressed(Minecraft* minecraft, char key) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->charPressed(minecraft, key);
-	}
+#include "GuiElementContainer.hpp"
+#include <algorithm>
+GuiElementContainer::GuiElementContainer( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
+: GuiElement(active, visible, x, y, width, height) {
+
+}
+
+GuiElementContainer::~GuiElementContainer() {
+	while(!children.empty()) {
+		GuiElement* element = children.back();
+		children.pop_back();
+		delete element;
+	}
+}
+
+void GuiElementContainer::render( Minecraft* minecraft, int xm, int ym ) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+		(*it)->render(minecraft, xm, ym);
+	}
+}
+
+void GuiElementContainer::setupPositions() {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+		(*it)->setupPositions();
+	}
+}
+
+void GuiElementContainer::addChild( GuiElement* element ) {
+	children.push_back(element);
+}
+
+void GuiElementContainer::removeChild( GuiElement* element ) {
+	std::vector<GuiElement*>::iterator it = std::find(children.begin(), children.end(), element);
+	if(it != children.end())
+		children.erase(it);
+}
+
+void GuiElementContainer::tick( Minecraft* minecraft ) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+		(*it)->tick(minecraft);
+	}
+}
+
+void GuiElementContainer::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+		(*it)->mouseClicked(minecraft, x, y, buttonNum);
+	}
+}
+
+void GuiElementContainer::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+		(*it)->mouseReleased(minecraft, x, y, buttonNum);
+	}
+}
+
+void GuiElementContainer::keyPressed(Minecraft* minecraft, int key) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+		(*it)->keyPressed(minecraft, key);
+	}
+}
+
+void GuiElementContainer::charPressed(Minecraft* minecraft, char key) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+		(*it)->charPressed(minecraft, key);
+	}
 }

src/client/gui/components/GuiElementContainer.hpp

@@ -1,28 +1,26 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI__GuiElementContainer_H__
-#define NET_MINECRAFT_CLIENT_GUI__GuiElementContainer_H__
-#include "GuiElement.h"
-#include <vector>
-class Tesselator;
-class Minecraft;
-
-class GuiElementContainer : public GuiElement {
-public:
-	GuiElementContainer(bool active=false, bool visible=true, int x = 0, int y = 0, int width=24, int height=24);
-    virtual ~GuiElementContainer();
-    virtual void render(Minecraft* minecraft, int xm, int ym);
-	virtual void setupPositions();
-	virtual void addChild(GuiElement* element);
-	virtual void removeChild(GuiElement* element);
-
-	virtual void tick( Minecraft* minecraft );
-
-	virtual void mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum );
-	virtual void mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum );
-	virtual void keyPressed(Minecraft* minecraft, int key);
-	virtual void charPressed(Minecraft* minecraft, char key);
-
-protected:
-	std::vector<GuiElement*> children;
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI__GuiElementContainer_H__*/
+#pragma once
+#include "GuiElement.hpp"
+#include <vector>
+class Tesselator;
+class Minecraft;
+
+class GuiElementContainer : public GuiElement {
+public:
+	GuiElementContainer(bool active=false, bool visible=true, int x = 0, int y = 0, int width=24, int height=24);
+    virtual ~GuiElementContainer();
+    virtual void render(Minecraft* minecraft, int xm, int ym);
+	virtual void setupPositions();
+	virtual void addChild(GuiElement* element);
+	virtual void removeChild(GuiElement* element);
+
+	virtual void tick( Minecraft* minecraft );
+
+	virtual void mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum );
+	virtual void mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum );
+	virtual void keyPressed(Minecraft* minecraft, int key);
+	virtual void charPressed(Minecraft* minecraft, char key);
+
+protected:
+	std::vector<GuiElement*> children;
+};
+

src/client/gui/components/ImageButton.cpp

@@ -1,135 +1,135 @@
-#include "ImageButton.h"
-#include "../../renderer/Tesselator.h"
-#include "../../Minecraft.h"
-#include "../../../platform/log.h"
-#include "../../../util/Mth.h"
-#include "../../renderer/Textures.h"
-#include <client/Option.h>
-
-
-ImageButton::ImageButton(int id, const std::string& msg)
-:	super(id, msg)
-{
-	setupDefault();
-}
-
-ImageButton::ImageButton(int id, const std::string& msg, const ImageDef& imagedef)
-:	super(id, msg),
-	_imageDef(imagedef)
-{
-	setupDefault();
-}
-
-void ImageButton::setupDefault() {
-	width = 48;
-	height = 48;
-	scaleWhenPressed = true;
-}
-
-void ImageButton::setImageDef(const ImageDef& imageDef, bool setButtonSize) {
-	_imageDef = imageDef;
-	if (setButtonSize) {
-		width = (int)_imageDef.width;
-		height = (int)_imageDef.height;
-	}
-}
-
-void ImageButton::render(Minecraft* minecraft, int xm, int ym) {
-	if (!visible) return;
-
-	Font* font = minecraft->font;
-
-	//minecraft->textures->loadAndBindTexture("gui/gui.png");
-	glColor4f2(1, 1, 1, 1);
-
-	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : false);
-	bool IsSecondImage = isSecondImage(hovered);
-
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	//int yImage = getYImage(hovered || selected);
-
-	//blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
-	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
-
-	renderBg(minecraft, xm, ym);
-
-	TextureId texId = (_imageDef.name.length() > 0)? minecraft->textures->loadAndBindTexture(_imageDef.name) : Textures::InvalidId;
-	if ( Textures::isTextureIdValid(texId) ) {
-		const ImageDef& d = _imageDef;
-		Tesselator& t = Tesselator::instance;
-		
-		t.begin();
-			if (!active)				t.color(0xff808080);
-			//else if (hovered||selected) t.color(0xffffffff);
-			//else						t.color(0xffe0e0e0);
-			else t.color(0xffffffff);
-
-			float hx = ((float) d.width) * 0.5f;
-			float hy = ((float) d.height) * 0.5f;
-			const float cx = ((float)x+d.x) + hx;
-			const float cy = ((float)y+d.y) + hy;
-			if (scaleWhenPressed && hovered) {
-				hx *= 0.95f;
-				hy *= 0.95f;
-			}
-
-			const IntRectangle* src = _imageDef.getSrc();
-			if (src) {
-				const TextureData* d = minecraft->textures->getTemporaryTextureData(texId);
-				if (d != NULL) {
-					float u0 = (src->x+(IsSecondImage?src->w:0)) / (float)d->w;
-					float u1 = (src->x+(IsSecondImage?2*src->w:src->w)) / (float)d->w;
-					float v0 = src->y / (float)d->h;
-					float v1 = (src->y+src->h) / (float)d->h;
-					t.vertexUV(cx-hx, cy-hy, blitOffset, u0, v0);
-					t.vertexUV(cx-hx, cy+hy, blitOffset, u0, v1);
-					t.vertexUV(cx+hx, cy+hy, blitOffset, u1, v1);
-					t.vertexUV(cx+hx, cy-hy, blitOffset, u1, v0);
-				}
-			} else {
-				t.vertexUV(cx-hx, cy-hy, blitOffset, 0, 0);
-				t.vertexUV(cx-hx, cy+hy, blitOffset, 0, 1);
-				t.vertexUV(cx+hx, cy+hy, blitOffset, 1, 1);
-				t.vertexUV(cx+hx, cy-hy, blitOffset, 1, 0);
-			}
-		t.draw();
-	}
-	//blit(0, 0, 0, 0, 64, 64, 256, 256);
-
-	//LOGI("%d %d\n", x+d.x, x+d.x+d.w);
-
-	if (!active) {
-		drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 16)*/, 0xffa0a0a0);
-	} else {
-		if (hovered || selected) {
-			drawCenteredString(font, msg, x + width / 2, y + 17/*(h - 16)*/, 0xffffa0);
-		} else {
-			drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 48)*/, 0xe0e0e0);
-		}
-	}
-}
-
-
-//
-// A toggleable Button
-//
-OptionButton::OptionButton(OptionId option) : m_optId(option), super(ButtonId, "") {}
-
-void OptionButton::toggle(Options* options) {
-	options->toggle(m_optId);
-
-	// Update graphics here
-	updateImage(options);
-}
-
-void OptionButton::updateImage(Options* options) {
-	_secondImage = options->getBooleanValue(m_optId);
-}
-
-void OptionButton::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	if(buttonNum == MouseAction::ACTION_LEFT) {
-		if(clicked(minecraft, x, y)) {
-			toggle(&minecraft->options);
-		}
-	}
-}
+#include "ImageButton.hpp"
+#include "client/renderer/Tesselator.hpp"
+#include "client/Minecraft.hpp"
+#include "platform/log.hpp"
+#include "util/Mth.hpp"
+#include "client/renderer/Textures.hpp"
+#include <client/Option.hpp>
+
+
+ImageButton::ImageButton(int id, const std::string& msg)
+:	super(id, msg)
+{
+	setupDefault();
+}
+
+ImageButton::ImageButton(int id, const std::string& msg, const ImageDef& imagedef)
+:	super(id, msg),
+	_imageDef(imagedef)
+{
+	setupDefault();
+}
+
+void ImageButton::setupDefault() {
+	width = 48;
+	height = 48;
+	scaleWhenPressed = true;
+}
+
+void ImageButton::setImageDef(const ImageDef& imageDef, bool setButtonSize) {
+	_imageDef = imageDef;
+	if (setButtonSize) {
+		width = (int)_imageDef.width;
+		height = (int)_imageDef.height;
+	}
+}
+
+void ImageButton::render(Minecraft* minecraft, int xm, int ym) {
+	if (!visible) return;
+
+	Font* font = minecraft->font;
+
+	//minecraft->textures->loadAndBindTexture("gui/gui.png");
+	glColor4f2(1, 1, 1, 1);
+
+	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
+	bool IsSecondImage = isSecondImage(hovered);
+
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	//int yImage = getYImage(hovered || selected);
+
+	//blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
+	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
+
+	renderBg(minecraft, xm, ym);
+
+	TextureId texId = (_imageDef.name.length() > 0)? minecraft->textures->loadAndBindTexture(_imageDef.name) : Textures::InvalidId;
+	if ( Textures::isTextureIdValid(texId) ) {
+		const ImageDef& d = _imageDef;
+		Tesselator& t = Tesselator::instance;
+		
+		t.begin();
+			if (!active)				t.color(0xff808080);
+			//else if (hovered||selected) t.color(0xffffffff);
+			//else						t.color(0xffe0e0e0);
+			else t.color(0xffffffff);
+
+			float hx = ((float) d.width) * 0.5f;
+			float hy = ((float) d.height) * 0.5f;
+			const float cx = ((float)x+d.x) + hx;
+			const float cy = ((float)y+d.y) + hy;
+			if (scaleWhenPressed && hovered) {
+				hx *= 0.95f;
+				hy *= 0.95f;
+			}
+
+			const IntRectangle* src = _imageDef.getSrc();
+			if (src) {
+				const TextureData* d = minecraft->textures->getTemporaryTextureData(texId);
+				if (d != NULL) {
+					float u0 = (src->x+(IsSecondImage?src->w:0)) / (float)d->w;
+					float u1 = (src->x+(IsSecondImage?2*src->w:src->w)) / (float)d->w;
+					float v0 = src->y / (float)d->h;
+					float v1 = (src->y+src->h) / (float)d->h;
+					t.vertexUV(cx-hx, cy-hy, blitOffset, u0, v0);
+					t.vertexUV(cx-hx, cy+hy, blitOffset, u0, v1);
+					t.vertexUV(cx+hx, cy+hy, blitOffset, u1, v1);
+					t.vertexUV(cx+hx, cy-hy, blitOffset, u1, v0);
+				}
+			} else {
+				t.vertexUV(cx-hx, cy-hy, blitOffset, 0, 0);
+				t.vertexUV(cx-hx, cy+hy, blitOffset, 0, 1);
+				t.vertexUV(cx+hx, cy+hy, blitOffset, 1, 1);
+				t.vertexUV(cx+hx, cy-hy, blitOffset, 1, 0);
+			}
+		t.draw();
+	}
+	//blit(0, 0, 0, 0, 64, 64, 256, 256);
+
+	//LOGI("%d %d\n", x+d.x, x+d.x+d.w);
+
+	if (!active) {
+		drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 16)*/, 0xffa0a0a0);
+	} else {
+		if (hovered || selected) {
+			drawCenteredString(font, msg, x + width / 2, y + 17/*(h - 16)*/, 0xffffa0);
+		} else {
+			drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 48)*/, 0xe0e0e0);
+		}
+	}
+}
+
+
+//
+// A toggleable Button
+//
+OptionButton::OptionButton(OptionId option) : m_optId(option), super(ButtonId, "") {}
+
+void OptionButton::toggle(Options* options) {
+	options->toggle(m_optId);
+
+	// Update graphics here
+	updateImage(options);
+}
+
+void OptionButton::updateImage(Options* options) {
+	_secondImage = options->getBooleanValue(m_optId);
+}
+
+void OptionButton::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
+	if(buttonNum == MouseAction::ACTION_LEFT) {
+		if(clicked(minecraft, x, y)) {
+			toggle(&minecraft->options);
+		}
+	}
+}

src/client/gui/components/ImageButton.hpp

@@ -1,97 +1,95 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI_COMPONENTS__ImageButton_H__
-#define NET_MINECRAFT_CLIENT_GUI_COMPONENTS__ImageButton_H__
-
-#include "Button.h"
-
-typedef struct IntRectangle {
-	IntRectangle()
-	:	x(0),
-		y(0),
-		w(1),
-		h(1)
-	{}
-	IntRectangle(int x, int y, int w, int h)
-	:	x(x),
-		y(y),
-		w(w),
-		h(h)
-	{}
-
-	int x, y;
-	int w, h;
-} IntRectangle;
-
-typedef struct ImageDef {
-	ImageDef()
-	:	hasSrc(false),
-		x(0),
-		y(0),
-		width(16),
-		height(16)
-		{}
-
-	std::string name;
-	int x;
-	int y;
-	float width;
-	float height;
-
-	ImageDef& setSrc(const IntRectangle& srcRect) {
-		hasSrc = true;
-		src = srcRect;
-		return *this;
-	}
-	IntRectangle* getSrc() {
-		return hasSrc? &src : NULL;
-	}
-protected:
-	IntRectangle src;
-	bool hasSrc;
-} ImageDef;
-
-
-class ImageButton: public Button
-{
-	typedef Button super;
-public:
-	ImageButton(int id, const std::string& msg);
-	ImageButton(int id, const std::string& msg, const ImageDef& imageDef);
-	void setImageDef(const ImageDef& imageDef, bool setButtonSize);
-
-	void render(Minecraft* minecraft, int xm, int ym);
-	void renderBg(Minecraft* minecraft, int xm, int ym) {}
-
-protected:
-	virtual void setupDefault();
-	virtual bool isSecondImage(bool hovered) { return hovered; }
-
-	ImageDef _imageDef;
-public:
-	bool scaleWhenPressed;
-};
-
-//
-// A toggleable Button
-//
-class OptionButton: public ImageButton
-{
-	typedef ImageButton super;
-public:
-	OptionButton(OptionId optId);
-
-	void toggle(Options* options);
-	void updateImage(Options* options);
-
-	static const int ButtonId = 9999999;
-protected:
-	bool isSecondImage(bool hovered) { return _secondImage; }
-
-	virtual void mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum );
-
-private:
-	OptionId m_optId;
-	bool _secondImage;
-};
-
-
-#endif /*NET_MINECRAFT_CLIENT_GUI_COMPONENTS__ImageButton_H__*/
+#pragma once
+
+#include "Button.hpp"
+
+typedef struct IntRectangle {
+	IntRectangle()
+	:	x(0),
+		y(0),
+		w(1),
+		h(1)
+	{}
+	IntRectangle(int x, int y, int w, int h)
+	:	x(x),
+		y(y),
+		w(w),
+		h(h)
+	{}
+
+	int x, y;
+	int w, h;
+} IntRectangle;
+
+typedef struct ImageDef {
+	ImageDef()
+	:	hasSrc(false),
+		x(0),
+		y(0),
+		width(16),
+		height(16)
+		{}
+
+	std::string name;
+	int x;
+	int y;
+	float width;
+	float height;
+
+	ImageDef& setSrc(const IntRectangle& srcRect) {
+		hasSrc = true;
+		src = srcRect;
+		return *this;
+	}
+	IntRectangle* getSrc() {
+		return hasSrc? &src : NULL;
+	}
+protected:
+	IntRectangle src;
+	bool hasSrc;
+} ImageDef;
+
+
+class ImageButton: public Button
+{
+	typedef Button super;
+public:
+	ImageButton(int id, const std::string& msg);
+	ImageButton(int id, const std::string& msg, const ImageDef& imageDef);
+	void setImageDef(const ImageDef& imageDef, bool setButtonSize);
+
+	void render(Minecraft* minecraft, int xm, int ym);
+	void renderBg(Minecraft* minecraft, int xm, int ym) {}
+
+protected:
+	virtual void setupDefault();
+	virtual bool isSecondImage(bool hovered) { return hovered; }
+
+	ImageDef _imageDef;
+public:
+	bool scaleWhenPressed;
+};
+
+//
+// A toggleable Button
+//
+class OptionButton: public ImageButton
+{
+	typedef ImageButton super;
+public:
+	OptionButton(OptionId optId);
+
+	void toggle(Options* options);
+	void updateImage(Options* options);
+
+	static const int ButtonId = 9999999;
+protected:
+	bool isSecondImage(bool hovered) { return _secondImage; }
+
+	virtual void mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum );
+
+private:
+	OptionId m_optId;
+	bool _secondImage;
+};
+
+

src/client/gui/components/InventoryPane.cpp

@@ -1,206 +1,206 @@
-#include "InventoryPane.h"
-#include "../Gui.h"
-#include "../../Minecraft.h"
-#include "../../player/input/touchscreen/TouchAreaModel.h"
-#include "../../renderer/entity/ItemRenderer.h"
-#include "../../renderer/Tesselator.h"
-#include "../../renderer/Textures.h"
-#include "../../../world/item/ItemInstance.h"
-#include "../../../world/entity/player/Inventory.h"
-
-namespace Touch {
-
-static const int By = 6; // Border Frame height
-
-InventoryPane::InventoryPane( IInventoryPaneCallback* screen, Minecraft* mc, const IntRectangle& rect, int paneWidth, float clickMarginH, int numItems, int itemSize, int itemBorderSize)
-:	screen(screen),
-	mc(mc),
-	paneWidth(paneWidth),
-	rect(rect),
-	super(
-	SF_LockX|/*SF_Scissor|*/SF_ShowScrollbar|SF_NoHoldSelect,
-	rect,  // Pane rect
-	IntRectangle(0, 0, itemSize, itemSize), // Item rect
-	0, numItems, Gui::GuiScale),
-    BorderPixels(itemBorderSize),
-	lastItemIndex(-1),
-	lastItemTicks(-1),
-	fillMarginX(2),
-	fillMarginY(4),
-	markerType(1),
-	markerIndex(-1),
-	markerShare(0),
-	renderDecorations(true)
-{
-	_clickArea = new RectangleArea(0, 0, 0, 0);
-	area._x0 = rect.x - clickMarginH;
-	area._x1 = rect.x + rect.w + clickMarginH;
-	area._y0 -= By;
-	area._y1 += By;
-
-	/*
-	const int left = bbox.x + (bbox.w - paneWidth) / 2;
-	bg.x = left;
-	bg.w = left + paneWidth; // @note: read as x1, not width
-	bg.y = bbox.y - fillMarginY;
-	bg.h = bbox.y + bbox.h + fillMarginY; // @note: read as y1, not width
-	*/
-}
-
-InventoryPane::~InventoryPane() {
-	delete _clickArea;
-}
-
-void InventoryPane::renderBatch( std::vector<GridItem>& items, float alpha )
-{
-	//fill(bg.x, bg.y, bg.w, bg.h, 0xff333333);
-	fill((float)(bbox.x-fillMarginX-1), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX+1), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
-	//fill(0.0f, (float)(bbox.y-fillMarginY), 400.0f, (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);//(float)(bbox.x-fillMarginX), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
-	glEnable2(GL_BLEND);
-	glDisable2(GL_ALPHA_TEST);
-	std::vector<const ItemInstance*> inventoryItems = screen->getItems(this);
-
-	glEnable2(GL_SCISSOR_TEST);
-	GLuint x = (GLuint)(screenScale * bbox.x);
-	GLuint y = mc->height - (GLuint)(screenScale * (bbox.y + bbox.h));
-	GLuint w = (GLuint)(screenScale * bbox.w);
-	GLuint h = (GLuint)(screenScale * bbox.h);
-	glScissor(x, y, w, h);
-
-	Tesselator& t = Tesselator::instance;
-
-	t.beginOverride();
-	t.colorABGR(0xffffffff);
-	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
-		blit(item.xf, item.yf, 200, 46, (float)itemBbox.w, (float)itemBbox.h, 16, 16);
-	}
-	mc->textures->loadAndBindTexture("gui/gui.png");
-	t.endOverrideAndDraw();
-
-	GridItem* marked = NULL;
-	float mxx, myy;
-
-	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
-		int j = item.id;
-		const ItemInstance* citem = inventoryItems[j];
-		if (!citem) continue;
-
-		bool allowed = true;
-
-		t.enableColor();
-		//#ifdef DEMO_MODE //@huge @attn
-		if (!screen->isAllowed(j)) { allowed = false; t.color( 64,  64,  64); }
-		else
-			//#endif
-			if (lastItemTicks > 0 && lastItemIndex == j) {
-				int gv = 255 - lastItemTicks * 15;
-				t.color(gv, gv, gv, (allowed && citem->count <= 0)?0x60:0xff);
-			} else {
-				t.color(255, 255, 255, (allowed && citem->count <= 0)?0x60:0xff);
-			}          
-			t.noColor();
-			float xx = Gui::floorAlignToScreenPixel(item.xf + BorderPixels + 4);
-			float yy = Gui::floorAlignToScreenPixel(item.yf + BorderPixels + 4);
-			ItemRenderer::renderGuiItem(NULL, mc->textures, citem, xx, yy, 16, 16, false);
-
-			if (j == markerIndex && markerShare >= 0)
-				marked = &item, mxx = xx, myy = yy;
-
-	}
-	t.endOverrideAndDraw();
-
-	if (marked) {
-		glDisable2(GL_TEXTURE_2D);
-		const float yy0 = myy - 5.0f;
-		const float yy1 = yy0 + 2;
-		fill(mxx, yy0, mxx + 16.0f, yy1, 0xff606060);
-		fill(mxx, yy0, mxx + markerShare * 16.0f, yy1, markerType==1?0xff00ff00:0xff476543);
-		glEnable2(GL_BLEND);
-		glEnable2(GL_TEXTURE_2D);
-	}
-
-
-	if (!mc->isCreativeMode()) {
-		const float ikText = Gui::InvGuiScale + Gui::InvGuiScale;
-		const float kText = 0.5f * Gui::GuiScale;
-		t.beginOverride();
-		t.scale2d(ikText, ikText);
-		for (unsigned int i = 0; i < items.size(); ++i) {
-			GridItem& item = items[i];
-			const ItemInstance* citem = inventoryItems[item.id];
-			if (!citem) continue;
-
-			char buf[64] = {0};
-			/*int c = */ Gui::itemCountItoa(buf, citem->count);
-
-			float tx = Gui::floorAlignToScreenPixel(kText * (item.xf + BorderPixels + 3));
-			float ty = Gui::floorAlignToScreenPixel(kText * (item.yf + BorderPixels + 3));
-			mc->gui.renderSlotText(citem, tx, ty, true, true);
-		}
-		t.resetScale();
-		glEnable2(GL_BLEND);
-		t.endOverrideAndDraw();
-	}
-
-	if (renderDecorations) {
-		t.beginOverride();
-		for (unsigned int i = 0; i < items.size(); ++i) {
-			GridItem& item = items[i];
-			const ItemInstance* citem = inventoryItems[item.id];
-			if (!citem || citem->isNull()) continue;
-
-			if (citem->isDamaged()) {
-				ItemRenderer::renderGuiItemDecorations(citem, item.xf + 8, item.yf + 12);
-			}
-		}
-
-		glDisable2(GL_TEXTURE_2D);
-		t.endOverrideAndDraw();
-		glEnable2(GL_TEXTURE_2D);
-	}
-	glDisable2(GL_SCISSOR_TEST);
-
-	//fillGradient(bbox.x - 1, bbox.y, bbox.x + bbox.w + 1, bbox.y + 20, 0x99000000, 0x00000000);
-	//fillGradient(bbox.x - 1, bbox.y + bbox.h - 20, bbox.x + bbox.w + 1, bbox.y + bbox.h, 0x00000000, 0x99000000);
-	fillGradient(bg.x - fillMarginX, bbox.y, bg.w + fillMarginX, bbox.y + 20, 0x99000000, 0x00000000);
-	fillGradient(bg.x - fillMarginX, bbox.y + bbox.h - 20, bg.w + fillMarginX, bbox.y + bbox.h, 0x00000000, 0x99000000);
-
-	drawScrollBar(hScroll);
-	drawScrollBar(vScroll);
-}
-
-bool InventoryPane::onSelect( int gridId, bool selected )
-{
-	//screen->onItemSelected(gridId);
-	if (screen->isAllowed(gridId))
-		if (screen->addItem(this, gridId)) {
-			lastItemIndex = gridId;
-			lastItemTicks = 7;
-		}
-
-		return false;
-}
-
-void InventoryPane::drawScrollBar( ScrollBar& sb ) {
-	if (sb.alpha <= 0)
-		return;
-
-	const int color = ((int)(255.0f * sb.alpha) << 24) | 0xaaaaaa;
-	const float xx = (float)(bbox.x + bbox.w);
-	fill(xx - sb.w, sb.y, xx, sb.y + sb.h, color);
-}
-
-void InventoryPane::tick()
-{
-	--lastItemTicks;
-	super::tick();
-}
-
-void InventoryPane::setRenderDecorations( bool value ) {
-	renderDecorations = value;
-}
-
-}
+#include "InventoryPane.hpp"
+#include "client/gui/Gui.hpp"
+#include "client/Minecraft.hpp"
+#include "client/player/input/touchscreen/TouchAreaModel.hpp"
+#include "client/renderer/entity/ItemRenderer.hpp"
+#include "client/renderer/Tesselator.hpp"
+#include "client/renderer/Textures.hpp"
+#include "world/item/ItemInstance.hpp"
+#include "world/entity/player/Inventory.hpp"
+
+namespace Touch {
+
+static const int By = 6; // Border Frame height
+
+InventoryPane::InventoryPane( IInventoryPaneCallback* screen, Minecraft* mc, const IntRectangle& rect, int paneWidth, float clickMarginH, int numItems, int itemSize, int itemBorderSize)
+:	screen(screen),
+	mc(mc),
+	paneWidth(paneWidth),
+	rect(rect),
+	super(
+	SF_LockX|/*SF_Scissor|*/SF_ShowScrollbar|SF_NoHoldSelect,
+	rect,  // Pane rect
+	IntRectangle(0, 0, itemSize, itemSize), // Item rect
+	0, numItems, Gui::GuiScale),
+    BorderPixels(itemBorderSize),
+	lastItemIndex(-1),
+	lastItemTicks(-1),
+	fillMarginX(2),
+	fillMarginY(4),
+	markerType(1),
+	markerIndex(-1),
+	markerShare(0),
+	renderDecorations(true)
+{
+	_clickArea = new RectangleArea(0, 0, 0, 0);
+	area._x0 = rect.x - clickMarginH;
+	area._x1 = rect.x + rect.w + clickMarginH;
+	area._y0 -= By;
+	area._y1 += By;
+
+	/*
+	const int left = bbox.x + (bbox.w - paneWidth) / 2;
+	bg.x = left;
+	bg.w = left + paneWidth; // @note: read as x1, not width
+	bg.y = bbox.y - fillMarginY;
+	bg.h = bbox.y + bbox.h + fillMarginY; // @note: read as y1, not width
+	*/
+}
+
+InventoryPane::~InventoryPane() {
+	delete _clickArea;
+}
+
+void InventoryPane::renderBatch( std::vector<GridItem>& items, float alpha )
+{
+	//fill(bg.x, bg.y, bg.w, bg.h, 0xff333333);
+	fill((float)(bbox.x-fillMarginX-1), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX+1), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
+	//fill(0.0f, (float)(bbox.y-fillMarginY), 400.0f, (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);//(float)(bbox.x-fillMarginX), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
+	glEnable2(GL_BLEND);
+	glDisable2(GL_ALPHA_TEST);
+	std::vector<const ItemInstance*> inventoryItems = screen->getItems(this);
+
+	glEnable2(GL_SCISSOR_TEST);
+	GLuint x = (GLuint)(screenScale * bbox.x);
+	GLuint y = mc->height - (GLuint)(screenScale * (bbox.y + bbox.h));
+	GLuint w = (GLuint)(screenScale * bbox.w);
+	GLuint h = (GLuint)(screenScale * bbox.h);
+	glScissor(x, y, w, h);
+
+	Tesselator& t = Tesselator::instance;
+
+	t.beginOverride();
+	t.colorABGR(0xffffffff);
+	for (unsigned int i = 0; i < items.size(); ++i) {
+		GridItem& item = items[i];
+		blit(item.xf, item.yf, 200, 46, (float)itemBbox.w, (float)itemBbox.h, 16, 16);
+	}
+	mc->textures->loadAndBindTexture("gui/gui.png");
+	t.endOverrideAndDraw();
+
+	GridItem* marked = NULL;
+	float mxx, myy;
+
+	t.beginOverride();
+	for (unsigned int i = 0; i < items.size(); ++i) {
+		GridItem& item = items[i];
+		int j = item.id;
+		const ItemInstance* citem = inventoryItems[j];
+		if (!citem) continue;
+
+		bool allowed = true;
+
+		t.enableColor();
+		//#ifdef DEMO_MODE //@huge @attn
+		if (!screen->isAllowed(j)) { allowed = false; t.color( 64,  64,  64); }
+		else
+			//#endif
+			if (lastItemTicks > 0 && lastItemIndex == j) {
+				int gv = 255 - lastItemTicks * 15;
+				t.color(gv, gv, gv, (allowed && citem->count <= 0)?0x60:0xff);
+			} else {
+				t.color(255, 255, 255, (allowed && citem->count <= 0)?0x60:0xff);
+			}          
+			t.noColor();
+			float xx = Gui::floorAlignToScreenPixel(item.xf + BorderPixels + 4);
+			float yy = Gui::floorAlignToScreenPixel(item.yf + BorderPixels + 4);
+			ItemRenderer::renderGuiItem(NULL, mc->textures, citem, xx, yy, 16, 16, false);
+
+			if (j == markerIndex && markerShare >= 0)
+				marked = &item, mxx = xx, myy = yy;
+
+	}
+	t.endOverrideAndDraw();
+
+	if (marked) {
+		glDisable2(GL_TEXTURE_2D);
+		const float yy0 = myy - 5.0f;
+		const float yy1 = yy0 + 2;
+		fill(mxx, yy0, mxx + 16.0f, yy1, 0xff606060);
+		fill(mxx, yy0, mxx + markerShare * 16.0f, yy1, markerType==1?0xff00ff00:0xff476543);
+		glEnable2(GL_BLEND);
+		glEnable2(GL_TEXTURE_2D);
+	}
+
+
+	if (!mc->isCreativeMode()) {
+		const float ikText = Gui::InvGuiScale + Gui::InvGuiScale;
+		const float kText = 0.5f * Gui::GuiScale;
+		t.beginOverride();
+		t.scale2d(ikText, ikText);
+		for (unsigned int i = 0; i < items.size(); ++i) {
+			GridItem& item = items[i];
+			const ItemInstance* citem = inventoryItems[item.id];
+			if (!citem) continue;
+
+			char buf[64] = {0};
+			/*int c = */ Gui::itemCountItoa(buf, citem->count);
+
+			float tx = Gui::floorAlignToScreenPixel(kText * (item.xf + BorderPixels + 3));
+			float ty = Gui::floorAlignToScreenPixel(kText * (item.yf + BorderPixels + 3));
+			mc->gui.renderSlotText(citem, tx, ty, true, true);
+		}
+		t.resetScale();
+		glEnable2(GL_BLEND);
+		t.endOverrideAndDraw();
+	}
+
+	if (renderDecorations) {
+		t.beginOverride();
+		for (unsigned int i = 0; i < items.size(); ++i) {
+			GridItem& item = items[i];
+			const ItemInstance* citem = inventoryItems[item.id];
+			if (!citem || citem->isNull()) continue;
+
+			if (citem->isDamaged()) {
+				ItemRenderer::renderGuiItemDecorations(citem, item.xf + 8, item.yf + 12);
+			}
+		}
+
+		glDisable2(GL_TEXTURE_2D);
+		t.endOverrideAndDraw();
+		glEnable2(GL_TEXTURE_2D);
+	}
+	glDisable2(GL_SCISSOR_TEST);
+
+	//fillGradient(bbox.x - 1, bbox.y, bbox.x + bbox.w + 1, bbox.y + 20, 0x99000000, 0x00000000);
+	//fillGradient(bbox.x - 1, bbox.y + bbox.h - 20, bbox.x + bbox.w + 1, bbox.y + bbox.h, 0x00000000, 0x99000000);
+	fillGradient(bg.x - fillMarginX, bbox.y, bg.w + fillMarginX, bbox.y + 20, 0x99000000, 0x00000000);
+	fillGradient(bg.x - fillMarginX, bbox.y + bbox.h - 20, bg.w + fillMarginX, bbox.y + bbox.h, 0x00000000, 0x99000000);
+
+	drawScrollBar(hScroll);
+	drawScrollBar(vScroll);
+}
+
+bool InventoryPane::onSelect( int gridId, bool selected )
+{
+	//screen->onItemSelected(gridId);
+	if (screen->isAllowed(gridId))
+		if (screen->addItem(this, gridId)) {
+			lastItemIndex = gridId;
+			lastItemTicks = 7;
+		}
+
+		return false;
+}
+
+void InventoryPane::drawScrollBar( ScrollBar& sb ) {
+	if (sb.alpha <= 0)
+		return;
+
+	const int color = ((int)(255.0f * sb.alpha) << 24) | 0xaaaaaa;
+	const float xx = (float)(bbox.x + bbox.w);
+	fill(xx - sb.w, sb.y, xx, sb.y + sb.h, color);
+}
+
+void InventoryPane::tick()
+{
+	--lastItemTicks;
+	super::tick();
+}
+
+void InventoryPane::setRenderDecorations( bool value ) {
+	renderDecorations = value;
+}
+
+}

src/client/gui/components/InventoryPane.hpp

@@ -1,62 +1,60 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI_COMPONENTS__InventoryPane_H__
-#define NET_MINECRAFT_CLIENT_GUI_COMPONENTS__InventoryPane_H__
-
-#include "ScrollingPane.h"
-#include "ImageButton.h"
-
-class Minecraft;
-class ItemInstance;
-class Font;
-class IArea;
-
-namespace Touch {
-
-class IInventoryPaneCallback;
-
-class InventoryPane: public ScrollingPane 
-{
-	typedef ScrollingPane super;
-public:
-	InventoryPane(IInventoryPaneCallback* screen, Minecraft* mc, const IntRectangle& rect, int paneWidth, float clickMarginH, int numItems, int itemSize, int itemBorderSize);
-	~InventoryPane();
-
-	void tick();
-	void renderBatch( std::vector<GridItem>& item, float alpha );
-	bool onSelect( int gridId, bool selected );
-	void drawScrollBar( ScrollBar& hScroll );
-
-	void setRenderDecorations(bool value);
-
-	IntRectangle rect;
-	int paneWidth;
-	IArea* _clickArea;
-	IInventoryPaneCallback* screen;
-	Minecraft* mc;
-
-	int fillMarginX;
-	int fillMarginY;
-
-	int markerType;
-	int markerIndex;
-	float markerShare;
-private:
-	int lastItemIndex;
-	int lastItemTicks;
-    int BorderPixels;
-	bool renderDecorations;
-
-	IntRectangle bg;
-};
-
-class IInventoryPaneCallback
-{
-public:
-	virtual ~IInventoryPaneCallback() {}
-	virtual bool addItem(const InventoryPane* forPane, int index) = 0;
-	virtual bool isAllowed( int slot ) = 0;
-	virtual std::vector<const ItemInstance*> getItems(const InventoryPane* forPane) = 0;
-};
-
-}
-
-#endif /*NET_MINECRAFT_CLIENT_GUI_COMPONENTS__InventoryPane_H__*/
+#pragma once
+
+#include "ScrollingPane.hpp"
+#include "ImageButton.hpp"
+
+class Minecraft;
+class ItemInstance;
+class Font;
+class IArea;
+
+namespace Touch {
+
+class IInventoryPaneCallback;
+
+class InventoryPane: public ScrollingPane 
+{
+	typedef ScrollingPane super;
+public:
+	InventoryPane(IInventoryPaneCallback* screen, Minecraft* mc, const IntRectangle& rect, int paneWidth, float clickMarginH, int numItems, int itemSize, int itemBorderSize);
+	~InventoryPane();
+
+	void tick();
+	void renderBatch( std::vector<GridItem>& item, float alpha );
+	bool onSelect( int gridId, bool selected );
+	void drawScrollBar( ScrollBar& hScroll );
+
+	void setRenderDecorations(bool value);
+
+	IntRectangle rect;
+	int paneWidth;
+	IArea* _clickArea;
+	IInventoryPaneCallback* screen;
+	Minecraft* mc;
+
+	int fillMarginX;
+	int fillMarginY;
+
+	int markerType;
+	int markerIndex;
+	float markerShare;
+private:
+	int lastItemIndex;
+	int lastItemTicks;
+    int BorderPixels;
+	bool renderDecorations;
+
+	IntRectangle bg;
+};
+
+class IInventoryPaneCallback
+{
+public:
+	virtual ~IInventoryPaneCallback() {}
+	virtual bool addItem(const InventoryPane* forPane, int index) = 0;
+	virtual bool isAllowed( int slot ) = 0;
+	virtual std::vector<const ItemInstance*> getItems(const InventoryPane* forPane) = 0;
+};
+
+}
+

src/client/gui/components/ItemPane.cpp

@@ -1,148 +1,148 @@
-#include "ItemPane.h"
-#include "../Gui.h"
-#include "../../renderer/gles.h"
-#include "../../renderer/Tesselator.h"
-#include "NinePatch.h"
-#include "../../renderer/entity/ItemRenderer.h"
-
-const int rgbActive = 0xfff0f0f0;
-const int rgbInactive = 0xc0635558;
-const int rgbInactiveShadow = 0xc0aaaaaa;
-
-ItemPane::ItemPane( IItemPaneCallback* screen,
-					Textures* textures,
-					const IntRectangle& rect,
-					int numItems,
-					int guiHeight,
-					int physicalScreenHeight,
-					bool isVertical /*= true*/)
-:	super(
-	(isVertical?SF_LockX:SF_LockY)/*|SF_Scissor*/|SF_ShowScrollbar,
-	rect,							// Pane rect
-	isVertical?IntRectangle(0, 0, rect.w, 22)  // Item rect if vertical
-			  :IntRectangle(0, 0, 32, rect.h), // Item rect if horizontal
-	isVertical?1:numItems, numItems, Gui::GuiScale),
-	screen(screen),
-	textures(textures),
-	physicalScreenHeight(physicalScreenHeight),
-	guiSlotItem(NULL),
-	guiSlotItemSelected(NULL),
-	isVertical(isVertical)
-{
-	// Expand the area to make it easier to scroll
-	area._x0 -= 4;
-	area._x1 += 4;
-	area._y0 = 0;
-	area._y1 = (float)guiHeight;
-
-	// GUI
-	NinePatchFactory builder(textures, "gui/spritesheet.png");
-	guiSlotItem = builder.createSymmetrical(IntRectangle(20, 32, 8, 8), 2, 2);
-	guiSlotItemSelected = builder.createSymmetrical(IntRectangle(28, 32, 8, 8), 2, 2);
-	guiSlotItem->setSize((float)rect.w + 4, 22);
-	guiSlotItemSelected->setSize((float)rect.w + 4, 22);
-}
-
-ItemPane::~ItemPane() {
-	delete guiSlotItem;
-	delete guiSlotItemSelected;
-}
-
-void ItemPane::renderBatch( std::vector<GridItem>& items, float alpha )
-{
-	//fill(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0xff666666);
-	const std::vector<CItem*>& cat = screen->getItems(this);
-	if (cat.empty()) return;
-
-	glEnable2(GL_SCISSOR_TEST);
-	GLuint x = (GLuint)(screenScale * bbox.x);
-	GLuint y = physicalScreenHeight - (GLuint)(screenScale * (bbox.y + bbox.h));
-	GLuint w = (GLuint)(screenScale * bbox.w);
-	GLuint h = (GLuint)(screenScale * bbox.h);
-	glScissor(x, y, w, h);
-
-	Tesselator& t = Tesselator::instance;
-
-	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
-		(item.selected? guiSlotItemSelected : guiSlotItem)->draw(t, Gui::floorAlignToScreenPixel(item.xf-1), Gui::floorAlignToScreenPixel(item.yf));
-	}
-	t.endOverrideAndDraw();
-
-	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
-		CItem* citem = cat[item.id];
-
-		ItemRenderer::renderGuiItem(NULL, textures, &citem->item,
-			Gui::floorAlignToScreenPixel(item.xf + itemBbox.w - 16),
-			Gui::floorAlignToScreenPixel(2 + item.yf), 16, 16, false);
-	}
-	t.endOverrideAndDraw();
-
-	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
-		CItem* citem = cat[item.id];
-
-		char buf[64] = {0};
-		int c = Gui::itemCountItoa(buf, citem->inventoryCount);
-
-		float xf = item.xf - 1;
-		if (citem->canCraft()) {
-			f->drawShadow(citem->text,
-				Gui::floorAlignToScreenPixel(xf + 2),
-				Gui::floorAlignToScreenPixel(item.yf + 6), rgbActive);
-			t.scale2d(0.6667f, 0.6667f);
-			f->drawShadow(buf,
-				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
-				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbActive);
-			t.resetScale();
-		} else {
-			f->draw(citem->text,
-				Gui::floorAlignToScreenPixel(xf + 3),
-				Gui::floorAlignToScreenPixel(item.yf + 7), rgbInactiveShadow);
-			f->draw(citem->text,
-				Gui::floorAlignToScreenPixel(xf + 2),
-				Gui::floorAlignToScreenPixel(item.yf + 6), rgbInactive);
-			t.scale2d(0.6667f, 0.6667f);
-			f->draw(buf,
-				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
-				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbInactive);
-			t.resetScale();
-		}
-	}
-	t.endOverrideAndDraw();
-
-	//fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, 20, 0x00000000, 0x80ff0000)
-	if (isVertical) {
-		fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + 28, 0xbb000000, 0x00000000);
-		fillGradient(bbox.x, bbox.y + bbox.h - 28, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
-	} else {
-		fillHorizontalGradient(bbox.x, bbox.y, bbox.x + 28, bbox.y + bbox.h, 0xbb000000, 0x00000000);
-		fillHorizontalGradient(bbox.x + bbox.w - 28, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
-	}
-
-	//LOGI("scroll: %f - %f, %f :: %f, %f\n", hScroll.alpha, hScroll.x, hScroll.y, hScroll.w, hScroll.h);
-	glDisable2(GL_SCISSOR_TEST);
-
-	drawScrollBar(hScroll);
-	drawScrollBar(vScroll);
-}
-
-bool ItemPane::onSelect( int gridId, bool selected )
-{
-	if (selected)
-		screen->onItemSelected(this, gridId);
-
-	return selected;
-}
-
-void ItemPane::drawScrollBar( ScrollBar& sb ) {
-	if (sb.alpha <= 0)
-		return;
-
-	int color = ((int)(255.0f * sb.alpha) << 24) | 0xffffff;
-	fill(2 + sb.x, sb.y, 2 + sb.x + sb.w, sb.y + sb.h, color);
-}
+#include "ItemPane.hpp"
+#include "client/gui/Gui.hpp"
+#include "client/renderer/gles.hpp"
+#include "client/renderer/Tesselator.hpp"
+#include "NinePatch.hpp"
+#include "client/renderer/entity/ItemRenderer.hpp"
+
+const int rgbActive = 0xfff0f0f0;
+const int rgbInactive = 0xc0635558;
+const int rgbInactiveShadow = 0xc0aaaaaa;
+
+ItemPane::ItemPane( IItemPaneCallback* screen,
+					Textures* textures,
+					const IntRectangle& rect,
+					int numItems,
+					int guiHeight,
+					int physicalScreenHeight,
+					bool isVertical /*= true*/)
+:	super(
+	(isVertical?SF_LockX:SF_LockY)/*|SF_Scissor*/|SF_ShowScrollbar,
+	rect,							// Pane rect
+	isVertical?IntRectangle(0, 0, rect.w, 22)  // Item rect if vertical
+			  :IntRectangle(0, 0, 32, rect.h), // Item rect if horizontal
+	isVertical?1:numItems, numItems, Gui::GuiScale),
+	screen(screen),
+	textures(textures),
+	physicalScreenHeight(physicalScreenHeight),
+	guiSlotItem(NULL),
+	guiSlotItemSelected(NULL),
+	isVertical(isVertical)
+{
+	// Expand the area to make it easier to scroll
+	area._x0 -= 4;
+	area._x1 += 4;
+	area._y0 = 0;
+	area._y1 = (float)guiHeight;
+
+	// GUI
+	NinePatchFactory builder(textures, "gui/spritesheet.png");
+	guiSlotItem = builder.createSymmetrical(IntRectangle(20, 32, 8, 8), 2, 2);
+	guiSlotItemSelected = builder.createSymmetrical(IntRectangle(28, 32, 8, 8), 2, 2);
+	guiSlotItem->setSize((float)rect.w + 4, 22);
+	guiSlotItemSelected->setSize((float)rect.w + 4, 22);
+}
+
+ItemPane::~ItemPane() {
+	delete guiSlotItem;
+	delete guiSlotItemSelected;
+}
+
+void ItemPane::renderBatch( std::vector<GridItem>& items, float alpha )
+{
+	//fill(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0xff666666);
+	const std::vector<CItem*>& cat = screen->getItems(this);
+	if (cat.empty()) return;
+
+	glEnable2(GL_SCISSOR_TEST);
+	GLuint x = (GLuint)(screenScale * bbox.x);
+	GLuint y = physicalScreenHeight - (GLuint)(screenScale * (bbox.y + bbox.h));
+	GLuint w = (GLuint)(screenScale * bbox.w);
+	GLuint h = (GLuint)(screenScale * bbox.h);
+	glScissor(x, y, w, h);
+
+	Tesselator& t = Tesselator::instance;
+
+	t.beginOverride();
+	for (unsigned int i = 0; i < items.size(); ++i) {
+		GridItem& item = items[i];
+		(item.selected? guiSlotItemSelected : guiSlotItem)->draw(t, Gui::floorAlignToScreenPixel(item.xf-1), Gui::floorAlignToScreenPixel(item.yf));
+	}
+	t.endOverrideAndDraw();
+
+	t.beginOverride();
+	for (unsigned int i = 0; i < items.size(); ++i) {
+		GridItem& item = items[i];
+		CItem* citem = cat[item.id];
+
+		ItemRenderer::renderGuiItem(NULL, textures, &citem->item,
+			Gui::floorAlignToScreenPixel(item.xf + itemBbox.w - 16),
+			Gui::floorAlignToScreenPixel(2 + item.yf), 16, 16, false);
+	}
+	t.endOverrideAndDraw();
+
+	t.beginOverride();
+	for (unsigned int i = 0; i < items.size(); ++i) {
+		GridItem& item = items[i];
+		CItem* citem = cat[item.id];
+
+		char buf[64] = {0};
+		int c = Gui::itemCountItoa(buf, citem->inventoryCount);
+
+		float xf = item.xf - 1;
+		if (citem->canCraft()) {
+			f->drawShadow(citem->text,
+				Gui::floorAlignToScreenPixel(xf + 2),
+				Gui::floorAlignToScreenPixel(item.yf + 6), rgbActive);
+			t.scale2d(0.6667f, 0.6667f);
+			f->drawShadow(buf,
+				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
+				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbActive);
+			t.resetScale();
+		} else {
+			f->draw(citem->text,
+				Gui::floorAlignToScreenPixel(xf + 3),
+				Gui::floorAlignToScreenPixel(item.yf + 7), rgbInactiveShadow);
+			f->draw(citem->text,
+				Gui::floorAlignToScreenPixel(xf + 2),
+				Gui::floorAlignToScreenPixel(item.yf + 6), rgbInactive);
+			t.scale2d(0.6667f, 0.6667f);
+			f->draw(buf,
+				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
+				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbInactive);
+			t.resetScale();
+		}
+	}
+	t.endOverrideAndDraw();
+
+	//fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, 20, 0x00000000, 0x80ff0000)
+	if (isVertical) {
+		fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + 28, 0xbb000000, 0x00000000);
+		fillGradient(bbox.x, bbox.y + bbox.h - 28, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
+	} else {
+		fillHorizontalGradient(bbox.x, bbox.y, bbox.x + 28, bbox.y + bbox.h, 0xbb000000, 0x00000000);
+		fillHorizontalGradient(bbox.x + bbox.w - 28, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
+	}
+
+	//LOGI("scroll: %f - %f, %f :: %f, %f\n", hScroll.alpha, hScroll.x, hScroll.y, hScroll.w, hScroll.h);
+	glDisable2(GL_SCISSOR_TEST);
+
+	drawScrollBar(hScroll);
+	drawScrollBar(vScroll);
+}
+
+bool ItemPane::onSelect( int gridId, bool selected )
+{
+	if (selected)
+		screen->onItemSelected(this, gridId);
+
+	return selected;
+}
+
+void ItemPane::drawScrollBar( ScrollBar& sb ) {
+	if (sb.alpha <= 0)
+		return;
+
+	int color = ((int)(255.0f * sb.alpha) << 24) | 0xffffff;
+	fill(2 + sb.x, sb.y, 2 + sb.x + sb.w, sb.y + sb.h, color);
+}

src/client/gui/components/ItemPane.hpp

@@ -1,95 +1,93 @@
-#ifndef ITEMPANE_H__
-#define ITEMPANE_H__
-
-#include <string>
-#include <vector>
-#include "ScrollingPane.h"
-#include "../../../world/item/ItemInstance.h"
-
-class Font;
-class Textures;
-class NinePatchLayer;
-class Recipe;
-class ItemPane;
-
-class CItem
-{
-public:
-	CItem(const ItemInstance& ins, Recipe* recipe, const std::string& text)
-	:	item(ins),
-		recipe(recipe),
-		text(text),
-		sortText(text),
-		//maxBuildCount(0),
-		numBuilt(0),
-		inventoryCount(0),
-		_canCraft(false)
-	{
-	}
-
-	typedef struct ReqItem {
-		ReqItem() {}
-		ReqItem(const ItemInstance& needItem, int has)
-			:	item(needItem), has(has) {}
-		ItemInstance item;
-		int has;
-		bool enough() { return has >= item.count; }
-	} ReqItem;
-
-    bool canCraft() {
-        return _canCraft;// || maxBuildCount > 0;
-    }
-	void setCanCraft(bool status) {
-		_canCraft = status;
-	}
-    
-	ItemInstance item;
-	Recipe*		recipe;
-	std::string text;
-	std::string sortText;
-	//int			maxBuildCount;
-	int			numBuilt;
-	int			inventoryCount;
-	std::vector<ReqItem> neededItems;
-private:
-	bool		_canCraft;
-};
-
-class IItemPaneCallback
-{
-public:
-	virtual ~IItemPaneCallback() {}
-	virtual void onItemSelected(const ItemPane* forPane, int index) = 0;
-	virtual const std::vector<CItem*>& getItems(const ItemPane* forPane) = 0;
-};
-
-class ItemPane: public ScrollingPane
-{
-	typedef ScrollingPane super;
-public:
-	ItemPane(	IItemPaneCallback* screen,
-				Textures* textures,
-				const IntRectangle& rect,
-				int numItems,
-				int guiHeight,
-				int physicalScreenHeight,
-				bool isVertical = true);
-	~ItemPane();
-
-	void renderBatch( std::vector<GridItem>& item, float alpha );
-	bool onSelect( int gridId, bool selected );
-	void drawScrollBar( ScrollBar& hScroll );
-	//void setSize()
-
-	Font* f;
-	Textures* textures;
-	IItemPaneCallback* screen;
-
-	int physicalScreenHeight; // Needed for glScissor
-	bool isVertical;
-
-	NinePatchLayer* guiSlotItem;
-	NinePatchLayer* guiSlotItemSelected;
-};
-
-#endif /*ITEMPANE_H__*/
+#pragma once
+
+#include <string>
+#include <vector>
+#include "ScrollingPane.hpp"
+#include "world/item/ItemInstance.hpp"
+
+class Font;
+class Textures;
+class NinePatchLayer;
+class Recipe;
+class ItemPane;
+
+class CItem
+{
+public:
+	CItem(const ItemInstance& ins, Recipe* recipe, const std::string& text)
+	:	item(ins),
+		recipe(recipe),
+		text(text),
+		sortText(text),
+		//maxBuildCount(0),
+		numBuilt(0),
+		inventoryCount(0),
+		_canCraft(false)
+	{
+	}
+
+	typedef struct ReqItem {
+		ReqItem() {}
+		ReqItem(const ItemInstance& needItem, int has)
+			:	item(needItem), has(has) {}
+		ItemInstance item;
+		int has;
+		bool enough() { return has >= item.count; }
+	} ReqItem;
+
+    bool canCraft() {
+        return _canCraft;// || maxBuildCount > 0;
+    }
+	void setCanCraft(bool status) {
+		_canCraft = status;
+	}
+    
+	ItemInstance item;
+	Recipe*		recipe;
+	std::string text;
+	std::string sortText;
+	//int			maxBuildCount;
+	int			numBuilt;
+	int			inventoryCount;
+	std::vector<ReqItem> neededItems;
+private:
+	bool		_canCraft;
+};
+
+class IItemPaneCallback
+{
+public:
+	virtual ~IItemPaneCallback() {}
+	virtual void onItemSelected(const ItemPane* forPane, int index) = 0;
+	virtual const std::vector<CItem*>& getItems(const ItemPane* forPane) = 0;
+};
+
+class ItemPane: public ScrollingPane
+{
+	typedef ScrollingPane super;
+public:
+	ItemPane(	IItemPaneCallback* screen,
+				Textures* textures,
+				const IntRectangle& rect,
+				int numItems,
+				int guiHeight,
+				int physicalScreenHeight,
+				bool isVertical = true);
+	~ItemPane();
+
+	void renderBatch( std::vector<GridItem>& item, float alpha );
+	bool onSelect( int gridId, bool selected );
+	void drawScrollBar( ScrollBar& hScroll );
+	//void setSize()
+
+	Font* f;
+	Textures* textures;
+	IItemPaneCallback* screen;
+
+	int physicalScreenHeight; // Needed for glScissor
+	bool isVertical;
+
+	NinePatchLayer* guiSlotItem;
+	NinePatchLayer* guiSlotItemSelected;
+};
+

src/client/gui/components/KeyOption.cpp

@@ -1,5 +1,5 @@
-#include "KeyOption.h"
-#include <client/Minecraft.h>
+#include "KeyOption.hpp"
+#include <client/Minecraft.hpp>
 
 KeyOption::KeyOption(Minecraft* minecraft, OptionId optId) 
     : Touch::TButton((int)optId, Keyboard::getKeyName(minecraft->options.getIntValue(optId))) {}

src/client/gui/components/KeyOption.hpp

@@ -1,6 +1,6 @@
 #pragma once
-#include "Button.h"
-#include <client/Options.h>
+#include "Button.hpp"
+#include <client/Options.hpp>
 
 class KeyOption : public Touch::TButton {
 public: