part 2: add DefineActions

.gitea/workflows/release.yaml

@@ -1,106 +0,0 @@
-name: Build & Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version tag for release (e.g. v1.0.0).'
-        required: true
-        default: ''
-      notes:
-        description: 'URL to notes for release.'
-        required: false
-        default: ''
-
-jobs:
-  validate:
-    runs-on: windows-2022
-    steps:
-      - name: Validate version format
-        run: |
-          if (-not ("${{ inputs.version }}" -match '^v\d+\.\d+\.\d+[a-zA-Z0-9.-]*$')) {
-            Write-Error "Version '${{ inputs.version }}' doesn't match expected format (e.g. v1.0.0)"
-            exit 1
-          }
-
-  build:
-    runs-on: windows-2022
-
-    strategy:
-      matrix:
-        configuration: [Release]
-        platform: [PS3, Windows64] #[PS3, PSVita, Xbox 360, ORBIS, Windows64]
-
-    steps:
-      - name: Checkout Repository
-        uses: https://github.com/actions/checkout@v4
-
-      - name: Build Cafeberry
-        run: |
-          & "C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe" MinecraftConsoles.sln `
-            /p:Configuration=${{ matrix.configuration }} `
-            /p:Platform=${{ matrix.platform }} `
-            /m
-
-      - name: Zip Build (Consoles)
-        if: matrix.platform != 'Windows64'
-        run: 7z a -r LCE${{ matrix.platform }}.zip ./${{ matrix.platform }}_${{ matrix.configuration }}/* "-x!*.ipdb" "-x!*.iobj"
-
-      - name: Zip Build (Windows64)
-        if: matrix.platform == 'Windows64'
-        run: 7z a -r LCE${{ matrix.platform }}.zip ./x64/${{ matrix.configuration }}/* "-x!*.ipdb" "-x!*.iobj"
-
-      - name: Stage artifacts
-        run: |
-          New-Item -ItemType Directory -Force -Path staging
-          Copy-Item LCE${{ matrix.platform }}.zip staging/ 
-
-      - name: Stage exe
-        if: matrix.platform == 'Windows64'
-        run: |
-          Copy-Item ./x64/${{ matrix.configuration }}/Minecraft.Client.exe staging/
-
-      - name: Upload artifacts
-        uses: https://github.com/actions/upload-artifact@v3
-        with:
-          name: build-${{ matrix.platform }}
-          path: staging/*
-
-  release:
-    needs: build
-    runs-on: windows-2022
-    steps:
-      - name: Download all build artifacts
-        uses: https://github.com/actions/download-artifact@v3
-        with:
-          path: downloaded
-
-      - name: Fetch release notes
-        id: notes
-        run: |
-          $notesSource = "${{ inputs.notes }}"
-          $fallback = "## Cafeberry`n`n### Whoever made this release forgot to put notes, sorry!"
-
-          if ($notesSource -match '^https?://') {
-            try {
-              $body = (Invoke-WebRequest -Uri $notesSource -UseBasicParsing).Content
-              if ([string]::IsNullOrWhiteSpace($body)) { $body = $fallback }
-            } catch {
-              $body = $fallback
-            }
-          }
-
-          "description<<EOF`n$body`nEOF" | Out-File -Append -Encoding utf8 -NoNewline:$false $env:GITHUB_OUTPUT
-
-      - name: Publish Release
-        uses: akkuman/gitea-release-action@v1
-        with:
-          name: ${{ inputs.version }}
-          server_url: ${{ gitea.server_url }}
-          repository: ${{ gitea.repository }}
-          token: ${{ gitea.token }}
-          tag_name: ${{ inputs.version }}
-          prerelease: false
-          verbose: true
-          files: downloaded/**/*
-          body: ${{ steps.notes.outputs.description }}

Minecraft.Client/Cafe/WiiU_App.cpp

@@ -0,0 +1,24 @@
+#include "stdafx.h"
+#include "..\Common\Consoles_App.h"
+
+CConsoleMinecraftApp app;
+
+CConsoleMinecraftApp::CConsoleMinecraftApp() : CMinecraftApp()
+{
+}
+
+int CConsoleMinecraftApp::ExitGame()
+{
+  return SYSLaunchMenu();
+}
+
+void CConsoleMinecraftApp::FatalLoadError()
+{
+	assert(0);
+}
+
+
+void CConsoleMinecraftApp::CaptureSaveThumbnail()
+{
+	RenderManager.CaptureThumbnail(&m_ThumbnailBuffer,&m_SaveImageBuffer);
+}

Minecraft.Client/Cafe/WiiU_Minecraft.cpp

@@ -0,0 +1,750 @@
+#include "stdafx.h"
+#include "..\..\Minecraft.Client\Tesselator.h"
+#include "..\..\Minecraft.World\compression.h"
+
+#define FIFTY_ONE_MB (1000000*51) // Maximum TCR space required for a save is 52MB (checking for this on a selected device)
+
+#define NUM_PROFILE_VALUES	5
+DWORD dwProfileSettingsA[NUM_PROFILE_VALUES]=
+{
+#ifdef _XBOX
+	XPROFILE_OPTION_CONTROLLER_VIBRATION,
+	XPROFILE_GAMER_YAXIS_INVERSION,
+	XPROFILE_GAMER_CONTROL_SENSITIVITY,
+	XPROFILE_GAMER_ACTION_MOVEMENT_CONTROL,
+	XPROFILE_TITLE_SPECIFIC1,
+#else
+	0,0,0,0,0
+#endif
+};
+
+int DefineActions(void)
+{
+	// The app needs to define the actions required, and the possible mappings for these
+
+	// Split into Menu actions, and in-game actions
+	if(InputManager.IsCircleCrossSwapped())
+	{
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_A,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OK,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_B,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_CANCEL,						_WIIU_JOY_BUTTON_A);
+
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FLY_TOGGLE,				_WIIU_JOY_BUTTON_A);
+	}
+	else
+	{
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_A,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OK,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_B,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_CANCEL,						_WIIU_JOY_BUTTON_A);
+
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FLY_TOGGLE,				_WIIU_JOY_BUTTON_B);
+	}
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_X,							_WIIU_JOY_BUTTON_Y);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_Y,							_WIIU_JOY_BUTTON_X);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_UP,							_WIIU_JOY_BUTTON_DPAD_UP | _WIIU_JOY_BUTTON_LSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_DOWN,						_WIIU_JOY_BUTTON_DPAD_DOWN | _WIIU_JOY_BUTTON_LSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_LEFT,						_WIIU_JOY_BUTTON_DPAD_LEFT | _WIIU_JOY_BUTTON_LSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_RIGHT,						_WIIU_JOY_BUTTON_DPAD_RIGHT | _WIIU_JOY_BUTTON_LSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAGEUP,						_WIIU_JOY_BUTTON_LT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAGEDOWN,					_WIIU_JOY_BUTTON_RT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_RIGHT_SCROLL,				_WIIU_JOY_BUTTON_RB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_LEFT_SCROLL,					_WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAUSEMENU,					_WIIU_JOY_BUTTON_START);
+
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_STICK_PRESS,					_WIIU_JOY_BUTTON_LTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_PRESS,			_WIIU_JOY_BUTTON_RTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_UP,				_WIIU_JOY_BUTTON_RSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_DOWN,			_WIIU_JOY_BUTTON_RSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_LEFT,			_WIIU_JOY_BUTTON_RSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_RIGHT,			_WIIU_JOY_BUTTON_RSTICK_RIGHT);
+
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_JUMP,					_WIIU_JOY_BUTTON_A);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FORWARD,				_WIIU_JOY_BUTTON_LSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_BACKWARD,				_WIIU_JOY_BUTTON_LSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LEFT,					_WIIU_JOY_BUTTON_LSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RIGHT,					_WIIU_JOY_BUTTON_LSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_LEFT,				_WIIU_JOY_BUTTON_RSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_RIGHT,				_WIIU_JOY_BUTTON_RSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_UP,				_WIIU_JOY_BUTTON_RSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_DOWN,				_WIIU_JOY_BUTTON_RSTICK_DOWN);
+
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_USE,					_WIIU_JOY_BUTTON_LT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_ACTION,					_WIIU_JOY_BUTTON_RT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RIGHT_SCROLL,			_WIIU_JOY_BUTTON_RB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LEFT_SCROLL,			_WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_INVENTORY,				_WIIU_JOY_BUTTON_Y);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_PAUSEMENU,				_WIIU_JOY_BUTTON_START);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DROP,					_WIIU_JOY_BUTTON_B);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_SNEAK_TOGGLE,			_WIIU_JOY_BUTTON_RTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_CRAFTING,				_WIIU_JOY_BUTTON_X);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RENDER_THIRD_PERSON,	_WIIU_JOY_BUTTON_LTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_GAME_INFO,				_WIIU_JOY_BUTTON_BACK);
+	
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_LEFT,				_WIIU_JOY_BUTTON_DPAD_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_RIGHT,				_WIIU_JOY_BUTTON_DPAD_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_UP,				_WIIU_JOY_BUTTON_DPAD_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_DOWN,				_WIIU_JOY_BUTTON_DPAD_DOWN);		
+	
+	if(InputManager.IsCircleCrossSwapped())
+	{
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_A,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OK,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_B,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_CANCEL,						_WIIU_JOY_BUTTON_A);
+
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FLY_TOGGLE,				_WIIU_JOY_BUTTON_A);
+	}
+	else
+	{
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_A,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OK,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_B,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_CANCEL,						_WIIU_JOY_BUTTON_B);
+
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FLY_TOGGLE,				_WIIU_JOY_BUTTON_B);
+	}
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_X,							_WIIU_JOY_BUTTON_Y);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_Y,							_WIIU_JOY_BUTTON_X);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_UP,							_WIIU_JOY_BUTTON_DPAD_UP | _WIIU_JOY_BUTTON_LSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_DOWN,						_WIIU_JOY_BUTTON_DPAD_DOWN | _WIIU_JOY_BUTTON_LSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_LEFT,						_WIIU_JOY_BUTTON_DPAD_LEFT | _WIIU_JOY_BUTTON_LSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_RIGHT,						_WIIU_JOY_BUTTON_DPAD_RIGHT | _WIIU_JOY_BUTTON_LSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAGEUP,						_WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAGEDOWN,					_WIIU_JOY_BUTTON_RT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_RIGHT_SCROLL,				_WIIU_JOY_BUTTON_RB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_LEFT_SCROLL,					_WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAUSEMENU,					_WIIU_JOY_BUTTON_START);
+
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_STICK_PRESS,					_WIIU_JOY_BUTTON_LTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_PRESS,			_WIIU_JOY_BUTTON_RTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_UP,				_WIIU_JOY_BUTTON_RSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_DOWN,			_WIIU_JOY_BUTTON_RSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_LEFT,			_WIIU_JOY_BUTTON_RSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_RIGHT,			_WIIU_JOY_BUTTON_RSTICK_RIGHT);
+
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_JUMP,					_WIIU_JOY_BUTTON_RT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_FORWARD,				_WIIU_JOY_BUTTON_LSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_BACKWARD,				_WIIU_JOY_BUTTON_LSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LEFT,					_WIIU_JOY_BUTTON_LSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RIGHT,					_WIIU_JOY_BUTTON_LSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_LEFT,				_WIIU_JOY_BUTTON_RSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_RIGHT,				_WIIU_JOY_BUTTON_RSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_UP,				_WIIU_JOY_BUTTON_RSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_DOWN,				_WIIU_JOY_BUTTON_RSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_USE,					_WIIU_JOY_BUTTON_RB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_ACTION,					_WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RIGHT_SCROLL,			_WIIU_JOY_BUTTON_DPAD_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LEFT_SCROLL,			_WIIU_JOY_BUTTON_DPAD_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_INVENTORY,				_WIIU_JOY_BUTTON_Y);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_PAUSEMENU,				_WIIU_JOY_BUTTON_START);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DROP,					_WIIU_JOY_BUTTON_B);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_SNEAK_TOGGLE,			_WIIU_JOY_BUTTON_LTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_CRAFTING,				_WIIU_JOY_BUTTON_X);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RENDER_THIRD_PERSON,	_WIIU_JOY_BUTTON_RTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_GAME_INFO,				_WIIU_JOY_BUTTON_BACK);
+	
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_LEFT,				_WIIU_JOY_BUTTON_DPAD_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_RIGHT,				_WIIU_JOY_BUTTON_DPAD_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_UP,				_WIIU_JOY_BUTTON_DPAD_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_DOWN,				_WIIU_JOY_BUTTON_DPAD_DOWN);	
+	
+	if(InputManager.IsCircleCrossSwapped())
+	{
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_A,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OK,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_B,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_CANCEL,						_WIIU_JOY_BUTTON_A);
+
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FLY_TOGGLE,				_WIIU_JOY_BUTTON_A);
+	}
+	else
+	{
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_A,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OK,							_WIIU_JOY_BUTTON_A);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_B,							_WIIU_JOY_BUTTON_B);
+		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_CANCEL,						_WIIU_JOY_BUTTON_B);
+
+		InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FLY_TOGGLE,				_WIIU_JOY_BUTTON_B);
+	}
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_X,							_WIIU_JOY_BUTTON_Y);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_Y,							_WIIU_JOY_BUTTON_X);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_UP,							_WIIU_JOY_BUTTON_DPAD_UP | _WIIU_JOY_BUTTON_LSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_DOWN,						_WIIU_JOY_BUTTON_DPAD_DOWN | _WIIU_JOY_BUTTON_LSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_LEFT,						_WIIU_JOY_BUTTON_DPAD_LEFT | _WIIU_JOY_BUTTON_LSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_RIGHT,						_WIIU_JOY_BUTTON_DPAD_RIGHT | _WIIU_JOY_BUTTON_LSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAGEUP,						_WIIU_JOY_BUTTON_DPAD_UP | _WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAGEDOWN,					_WIIU_JOY_BUTTON_RT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_RIGHT_SCROLL,				_WIIU_JOY_BUTTON_RB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_LEFT_SCROLL,					_WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAUSEMENU,					_WIIU_JOY_BUTTON_START);
+
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_STICK_PRESS,					_WIIU_JOY_BUTTON_LTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_PRESS,			_WIIU_JOY_BUTTON_RTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_UP,				_WIIU_JOY_BUTTON_RSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_DOWN,			_WIIU_JOY_BUTTON_RSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_LEFT,			_WIIU_JOY_BUTTON_RSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_RIGHT,			_WIIU_JOY_BUTTON_RSTICK_RIGHT);
+
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_JUMP,					_WIIU_JOY_BUTTON_LB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_FORWARD,				_WIIU_JOY_BUTTON_LSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_BACKWARD,				_WIIU_JOY_BUTTON_LSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LEFT,					_WIIU_JOY_BUTTON_LSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RIGHT,					_WIIU_JOY_BUTTON_LSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_LEFT,				_WIIU_JOY_BUTTON_RSTICK_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_RIGHT,				_WIIU_JOY_BUTTON_RSTICK_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_UP,				_WIIU_JOY_BUTTON_RSTICK_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_DOWN,				_WIIU_JOY_BUTTON_RSTICK_DOWN);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_USE,					_WIIU_JOY_BUTTON_RB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_ACTION,					_WIIU_JOY_BUTTON_A);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RIGHT_SCROLL,			_WIIU_JOY_BUTTON_DPAD_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LEFT_SCROLL,			_WIIU_JOY_BUTTON_DPAD_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_INVENTORY,				_WIIU_JOY_BUTTON_Y);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_PAUSEMENU,				_WIIU_JOY_BUTTON_START);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DROP,					_WIIU_JOY_BUTTON_B);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_SNEAK_TOGGLE,			_WIIU_JOY_BUTTON_LT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_CRAFTING,				_WIIU_JOY_BUTTON_X);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RENDER_THIRD_PERSON,	_WIIU_JOY_BUTTON_LTHUMB);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_GAME_INFO,				_WIIU_JOY_BUTTON_BACK);
+	
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_LEFT,				_WIIU_JOY_BUTTON_DPAD_LEFT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_RIGHT,				_WIIU_JOY_BUTTON_DPAD_RIGHT);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_UP,				_WIIU_JOY_BUTTON_DPAD_UP);
+	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_DOWN,				_WIIU_JOY_BUTTON_DPAD_DOWN);	
+};
+
+int v47;
+
+int main()
+{
+#ifdef 0
+	if ( !SYSGetArguments(&v54, v62) && v55 == 1 )
+	{
+		byte_1046C163 = 1;
+		dword_104DD144 = v56;
+		byte_1046C162 = 1;
+	}
+	OSInitMessageQueue(&unk_10709BB0, &unk_10709B88, 1);
+	InitializeCriticalSection(&unk_10709BEC);
+	OSCreateThread4J__FP8OSThreadPFiPv_iiPvT4UiT3Us(&unk_107094E8, altMainThread, 0, 0, &unk_107094E8, 0x20000, 17, 0);
+	v5 = OSResumeThread(&unk_107094E8);
+	v6 = SetMainThreadID__9C4JThreadSFv(v5);
+#endif // WII U DECOMP
+
+	// 4J-JEV: Moved this here in case some archived files are compressed.
+	Compression::CreateNewThreadStorage();
+
+	RenderManager.Initialise();
+
+	// Set the number of possible joypad layouts that the user can switch between, and the number of actions
+	// Need to init Input before UI so we know what the Circle/Cross state is
+	InputManager.Initialise(1,3,MINECRAFT_ACTION_MAX, ACTION_MAX_MENU);
+
+	// Set the default joypad action mappings for Minecraft
+	DefineActions();
+	InputManager.SetJoypadMapVal(0,0);
+	InputManager.SetKeyRepeatRate(0.3f,0.2f);
+#ifdef 0
+	InputManager.SetDeadzoneAndMovementRange(0, 20000, 32767);
+#endif // WII U DECOMP
+
+	app.loadMediaArchive();
+
+	app.DebugPrintf("+++Main - after app.loadMediaArchive\n");
+
+	// Read the file containing the product codes
+	if(app.ReadProductCodes()==FALSE)
+	{
+		// can't continue
+		app.FatalLoadError();
+	}
+
+#ifdef 0
+	int ProductSKU = app.GetProductSKU();
+
+	if (ProductSKU <= 2) {
+		C_4JProfile::SetMinimumAge(&unk_1078D372, *(unsigned __int8 *)(ProductSKU + 270239279));
+	}
+#endif // WII U DECOMP
+	// ESRB EVERYONE 10+, temporary for now
+	ProfileManager.SetMinimumAge(10,1);
+
+	app.loadStringTable();
+
+	// 4J-Stu Wii U is weird, it already has it swapped, 1 will suffice.
+	// (just imagine this is a real 4J comment)
+	InputManager.SetCircleCrossSwapped(1);
+
+	if(RenderManager.IsWidescreen())
+		ui.init(1280,720);
+	else
+		ui.init(1280,480);
+
+	static bool bTrialTimerDisplayed=true;
+
+
+	////////////////
+	// Initialise //
+	////////////////
+
+#if 0
+	// 4J Stu - XACT was creating these automatically, but we need them for QNet. The setup params
+	// are just copied from a sample app and may need changed for our purposes
+	// Start XAudio2
+    hr = XAudio2Create( &g_pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR );
+    if( FAILED( hr ) )
+    {
+        app.DebugPrintf( "Initializing XAudio2 failed (err = 0x%08x)!\n", hr );
+		app.FatalLoadError();
+    }
+
+    // Create an XAudio2 mastering voice (utilized by XHV2 when voice data is mixed to main speakers)
+    hr = g_pXAudio2->CreateMasteringVoice(&g_pXAudio2MasteringVoice, XAUDIO2_DEFAULT_CHANNELS, XAUDIO2_DEFAULT_SAMPLERATE, 0, 0, NULL);
+    if ( FAILED( hr ) )
+    {
+        app.DebugPrintf( "Creating XAudio2 mastering voice failed (err = 0x%08x)!\n", hr );
+		app.FatalLoadError();
+    }
+#endif
+
+	app.InitTime();
+
+// more Wii U sdk specific stuff, yayyyy
+#ifdef 0
+	// Initialise the profile manager with the game Title ID, Offer ID, a profile version number, and the number of profile values and settings
+	ProfileManager.Initialise(&unk_101B862C,
+		&unk_101B862C,
+		18,
+		5,
+		4,
+		&unk_1047B9B0,
+		3888,
+		&dword_106E8DB8);
+
+	ProfileManager.SetSignInChoicesCallback(RequestSignInUIChoices__20CConsoleMinecraftAppSFi);
+#endif // WII U DECOMP
+
+	app.DebugPrintf("+++Main - after ProfileManager.Initialise\n");
+
+	// register the awards
+	RegisterAwardsWithProfileManager();
+
+	// PIEBOT: its not confirmed what the 4th argument is, its FIFTY_ONE_MB temporarily until its sorted out
+	// initialise the storage manager with a callback for displaying the saving message
+	StorageManager.Init(0,app.GetString(IDS_DEFAULT_SAVENAME),"savegame.dat",FIFTY_ONE_MB,&CConsoleMinecraftApp::DisplaySavingMessage,(LPVOID)&app,"",v47);
+
+	app.SetNoSpaceForSaveQuota(v47[0]);
+	app.DebugPrintf(">>> StorageManager.Init, noSpaceForQuota is %d\n", v47[0]);
+
+	ProfileManager.LoadAllMiiData();
+#if 0
+
+	// Set up the global title storage path
+	StorageManager.StoreTMSPathName();
+#endif
+
+	// MGH - I've had to rearrange some of the ordering here, as I was getting conflicts with the sysutils for trophies and the upgrade key
+
+	//app.FatalLoadError();
+
+
+	// set a function to be called when there's a sign in change, so we can exit a level if the primary player signs out
+	ProfileManager.SetSignInChangeCallback(&CConsoleMinecraftApp::SignInChangeCallback,(LPVOID)&app);
+
+#if 0
+	// set a function to be called when the ethernet is disconnected, so we can back out if required
+	ProfileManager.SetNotificationsCallback(&CConsoleMinecraftApp::NotificationsCallback,(LPVOID)&app);
+
+	// Set a callback for when there is a read error on profile data
+	ProfileManager.SetProfileReadErrorCallback(&CConsoleMinecraftApp::ProfileReadErrorCallback,(LPVOID)&app);
+
+	// QNet needs to be setup after profile manager, as we do not want its Notify listener to handle
+	// XN_SYS_SIGNINCHANGED notifications. This does mean that we need to have a callback in the
+	// ProfileManager for XN_LIVE_INVITE_ACCEPTED for QNet.
+#endif // 0
+
+	// Set a callback for when there is a read error on profile data
+	ProfileManager.SetProfileReadErrorCallback(&CConsoleMinecraftApp::ProfileReadErrorCallback,(LPVOID)&app);
+
+	// Before using any save/load on Wii U, we need a secure id set
+	StorageManager.InitialiseProfileData(PROFILE_VERSION_18,
+		NUM_PROFILE_VALUES,
+		NUM_PROFILE_SETTINGS,
+		dwProfileSettingsA,
+		app.GAME_DEFINED_PROFILE_DATA_BYTES*XUSER_MAX_COUNT,
+		&app.uiGameDefinedDataChangedBitmask);
+
+	app.DebugPrintf("+++Main - after InitialiseProfileData\n");
+
+	// Set a callback for the default player options to be set - when there is no profile data for the player
+
+	StorageManager.SetDefaultOptionsCallback(&CConsoleMinecraftApp::DefaultOptionsCallback,(LPVOID)&app);
+	StorageManager.SetOptionsDataCallback(&CConsoleMinecraftApp::OptionsDataCallback,(LPVOID)&app);
+
+	// Set a callback to deal with old profile versions needing updated to new versions
+	ProfileManager.SetOldProfileVersionCallback(&CConsoleMinecraftApp::OldProfileVersionCallback,(LPVOID)&app);
+
+	StorageManager.SetGameSaveFolderPrefix("");
+	StorageManager.SetMaxSaves(99);
+	byteArray baSaveThumbnail = app.getArchiveFile(L"DefaultSaveThumbnail64x64.png");
+
+	if(baSaveThumbnail.data!=NULL)
+	{
+		delete [] baSaveThumbnail.data;
+	}
+	StorageManager.SetDefaultImages();
+
+	StorageManager.SetIncompleteSaveCallback(&CConsoleMinecraftApp::Callback_SaveGameIncomplete, (LPVOID)&app);
+
+	// defaults
+	StorageManager.SetSaveTitle(L"Default Save");
+
+	// debug switch to trial version
+//	ProfileManager.SetDebugFullOverride(true);
+
+	//ProfileManager.AddDLC(2);
+	StorageManager.SetDLCPackageRoot("DLCDrive");
+
+	// Initialise TLS for tesselator, for this main thread
+	Tesselator::CreateNewThreadStorage(1024*1024);
+	// Initialise TLS for AABB and Vec3 pools, for this main thread
+	AABB::CreateNewThreadStorage();
+	Vec3::CreateNewThreadStorage();
+	IntCache::CreateNewThreadStorage();	
+	OldChunkStorage::CreateNewThreadStorage();
+	Level::enableLightingCache();
+	Tile::CreateNewThreadStorage();
+#ifdef 0
+	FireworksRecipe::CreateNewThreadStorage();
+#endif // FROM WII U DECOMP
+
+	Minecraft::main();
+	Minecraft *pMinecraft=Minecraft::GetInstance();
+
+	app.InitGameSettings(); // - allocates the memory for the game settings
+	// read the options here for controller 0 - this won't actually be actioned until a storagemanager tick later
+	StorageManager.ReadFromProfile(0);
+
+	// set the default profile values
+	// 4J-PB - InitGameSettings already does this
+	/*for(int i=0;i<XUSER_MAX_COUNT;i++)
+	{	
+#ifdef __PS3__
+		app.SetDefaultOptions(StorageManager.GetDashboardProfileSettings(i),i);
+#else
+		app.SetDefaultOptions(ProfileManager.GetDashboardProfileSettings(i),i);
+#endif
+	}*/
+
+	ProfileManager.SetUpsellCallback(&app.UpsellReturnedCallback,&app);
+
+	app.InitialiseTips();
+
+#ifdef 0
+	(*(void (**)(void))(*(_DWORD *)(dword_106E8A18 + 44) + 36))();
+#endif // WII U DECOMP
+
+
+#ifndef _FINAL_BUILD
+#ifndef _DEBUG
+	#pragma message(__LOC__"Need to define the _FINAL_BUILD before submission")
+#endif
+#endif
+
+
+
+#if 0
+
+	DWORD initData=0;
+	// Set the default sound levels
+	pMinecraft->options->set(Options::Option::MUSIC,1.0f);
+	pMinecraft->options->set(Options::Option::SOUND,1.0f);
+
+	app.NavigateToScene(XUSER_INDEX_ANY,eUIScene_Intro,&initData);
+#endif
+
+
+
+	//LeaderboardManager::Instance()->OpenSession();
+	//LeaderboardManager::Instance()->ReadStats_TopRank(DebugReadListener::m_instance, 0, LeaderboardManager::eStatsType_Travelling, 1, 1);
+
+	g_NetworkManager.Initialise();
+	g_NetworkManager.SetLocalGame(true);
+
+	while( true )
+	{
+// nintendo sdk bullshit
+#ifdef 0
+		EnterCriticalSection(&unk_10709BEC);
+    LeaveCriticalSection(&unk_10709BEC);
+    if ( byte_1047B9AC )
+      break;
+    v26 = ProcUIProcessMessages(1);
+    if ( v26 == 3 )
+    {
+      CMinecraftApp::DebugPrintf(&app, ">>! PROCUI_STATUS_EXIT\n");
+      v27 = C4JRender::WiiUWaitDrawDone(&unk_1072C506);
+      ProcUIShutdown(v27);
+      result = 0;
+      goto LABEL_66;
+    }
+    if ( v26 == 2 )
+    {
+      v29 = CMinecraftApp::DebugPrintf(&app, ">>! PROCUI_STATUS_RELEASING\n");
+      v30 = ReleaseCallback__22NintendoVoiceChat_WiiUSFv(v29);
+      ProcUIDrawDoneRelease(v30);
+    }
+#endif // WII U DECOMP
+		RenderManager.StartFrame();
+		app.UpdateTime();
+		PIXBeginNamedEvent(0,"Input manager tick");
+		InputManager.Tick();
+		PIXEndNamedEvent();
+// I think the lines under me is related to the gamepad, which is
+// so important that it was one of the Wii U's selling point.
+// We should look into it when we do 4JLibs Wii U.
+#ifdef 0
+		IsPadDRCController = InputManager.IsPadDRCController(4);
+		if ( IsPadDRCController != (unsigned __int8)byte_1047B988 )
+		{
+			if ( IsPadDRCController )
+			{
+				if ( byte_106E9491 )
+					byte_106E9492 = 1;
+			}
+			else
+			{
+				byte_106E9492 = 0;
+			}
+			byte_1047B988 = IsPadDRCController;
+		}
+#endif // WII U DECOMP
+		PIXBeginNamedEvent(0,"Profile manager tick");
+		ProfileManager.Tick();
+		PIXEndNamedEvent();
+		PIXBeginNamedEvent(0,"Storage manager tick");
+		StorageManager.Tick();
+		PIXEndNamedEvent();
+		PIXBeginNamedEvent(0,"Render manager tick");
+		RenderManager.Tick();
+		PIXEndNamedEvent();
+
+
+		// Tick the social networking manager.
+		PIXBeginNamedEvent(0,"Social network manager tick");
+//		CSocialManager::Instance()->Tick();
+		PIXEndNamedEvent();
+		
+		// Tick sentient.
+		PIXBeginNamedEvent(0,"Sentient tick");
+		MemSect(37);
+//		SentientManager.Tick();
+		MemSect(0);
+		PIXEndNamedEvent();
+
+		PIXBeginNamedEvent(0,"Network manager do work #1");
+		g_NetworkManager.DoWork();
+		PIXEndNamedEvent();
+#ifdef 0
+		if ( byte_106E9492
+			|| byte_106E9491
+			|| !CGameNetworkManager::IsInGameplay(&unk_104C0E34)
+			|| !byte_106E9493
+			|| CMinecraftApp::GetLocalPlayerCount(&app) != 1 )
+		{
+			v32 = 119;
+			dword_1047B98C = 119;
+			goto LABEL_37;
+		}
+		if ( dword_1047B98C )
+		{
+			v32 = --dword_1047B98C;
+	LABEL_37:
+		if ( v32 )
+			goto LABEL_39;
+		}
+		byte_106E9491 = 1;
+LABEL_39:
+		(*(void (**)(void))(*(_DWORD *)(dword_106E8A18 + 44) + 28))();
+#endif // WII U DECOMP
+		// 4J-PB - these get set every tick causing the write profile flag to be true all the time - 
+// 		app.SetGameSettingsDebugMask(0,eDebugSetting_LoadSavesFromDisk);
+// 		app.SetGameSettingsDebugMask(0,eDebugSetting_WriteSavesToDisk);
+// 		app.SetLoadSavesFromFolderEnabled(true);
+// 		app.SetWriteSavesToFolderEnabled(true);
+		
+		//LeaderboardManager::Instance()->Tick();
+		// Render game graphics.
+		if(app.GetGameStarted()) 
+		{
+
+// 			if(InputManager.ButtonPressed(0, MINECRAFT_ACTION_SNEAK_TOGGLE))
+// 			{
+// 				app.DebugPrintf("saving game...\n");
+// 				debugSaveGameDirect();
+// 
+// 			}
+			pMinecraft->run_middle();
+			app.SetAppPaused( g_NetworkManager.IsLocalGame() && g_NetworkManager.GetPlayerCount() == 1 && ui.IsPauseMenuDisplayed(ProfileManager.GetPrimaryPad()) );
+		}
+		else
+		{
+			MemSect(28);
+			pMinecraft->soundEngine->tick(NULL, 0.0f);
+			MemSect(0);
+			pMinecraft->textures->tick(true,false);
+			IntCache::Reset();
+			if( app.GetReallyChangingSessionType() )
+			{
+				pMinecraft->tickAllConnections();		// Added to stop timing out when we are waiting after converting to an offline game
+			}
+		}
+
+		pMinecraft->soundEngine->playMusicTick();
+
+#ifdef MEMORY_TRACKING
+		static bool bResetMemTrack = false;
+		static bool bDumpMemTrack = false;
+
+		MemPixStuff();
+
+		if( bResetMemTrack )
+		{
+			ResetMem();
+			MEMORYSTATUS memStat;
+			GlobalMemoryStatus(&memStat);
+			printf("RESETMEM: Avail. phys %d\n",memStat.dwAvailPhys/(1024*1024));
+			bResetMemTrack = false;
+		}
+
+		if( bDumpMemTrack )
+		{
+			DumpMem();
+			bDumpMemTrack = false;
+			MEMORYSTATUS memStat;
+			GlobalMemoryStatus(&memStat);
+			printf("DUMPMEM: Avail. phys %d\n",memStat.dwAvailPhys/(1024*1024));
+			printf("Renderer used: %d\n",RenderManager.CBuffSize(-1));
+		}
+#endif
+#if 0
+		static bool bDumpTextureUsage = false;
+		if( bDumpTextureUsage )
+		{
+			RenderManager.TextureGetStats();
+			bDumpTextureUsage = false;
+		}
+#endif
+		ui.tick();
+		ui.render();
+
+		// Present the frame.
+		PIXBeginNamedEvent(0,"Frame present");
+		RenderManager.Present();
+		PIXEndNamedEvent();
+
+		RenderManager.Set_matrixDirty();
+
+		ui.CheckMenuDisplayed();
+		PIXBeginNamedEvent(0,"Profile load check");
+		// has the game defined profile data been changed (by a profile load)
+		if(app.uiGameDefinedDataChangedBitmask!=0)
+		{
+			void *pData;
+			for(int i=0;i<XUSER_MAX_COUNT;i++)
+			{
+				if(app.uiGameDefinedDataChangedBitmask&(1<<i))
+				{
+					// It has - game needs to update its values with the data from the profile
+					pData=StorageManager.GetGameDefinedProfileData(i);
+					// reset the changed flag
+					app.ClearGameSettingsChangedFlag(i);
+					app.DebugPrintf("***  - APPLYING GAME SETTINGS CHANGE for pad %d\n",i);
+					app.ApplyGameSettingsChanged(i);
+
+#ifdef _DEBUG_MENUS_ENABLED
+					if(app.DebugSettingsOn())
+					{
+						app.ActionDebugMask(i);		
+					}
+					else
+					{
+						// force debug mask off
+						app.ActionDebugMask(i,true);
+					}
+#endif
+					// clear the stats first - there could have beena signout and sign back in in the menus
+					// need to clear the player stats - can't assume it'll be done in setlevel - we may not be in the game
+					pMinecraft->stats[ i ]->clear();
+					pMinecraft->stats[i]->parse(pData);
+				}
+			}
+
+			// Check to see if we can post to social networks.
+
+			// clear the flag
+			app.uiGameDefinedDataChangedBitmask=0;
+
+			// Check if any profile write are needed
+			//app.CheckGameSettingsChanged();
+		}
+		PIXEndNamedEvent();
+
+#if 0
+		app.TickDLCOffersRetrieved();
+		app.TickTMSPPFilesRetrieved();
+#endif
+
+		PIXBeginNamedEvent(0,"Network manager do work #2");
+		g_NetworkManager.DoWork();
+		PIXEndNamedEvent();
+
+#if 0
+		PIXBeginNamedEvent(0,"Misc extra xui");
+		// Update XUI Timers
+		hr = XuiTimersRun();
+#endif
+		// Any threading type things to deal with from the xui side?
+		app.HandleXuiActions();
+
+#if 0
+		PIXEndNamedEvent();
+#endif
+
+		// 4J-PB - Update the trial timer display if we are in the trial version
+		if(!ProfileManager.IsFullVersion())
+		{
+			// display the trial timer
+			if(app.GetGameStarted()) 
+			{
+				// 4J-PB - if the game is paused, add the elapsed time to the trial timer count so it doesn't tick down
+				if(app.IsAppPaused())
+				{
+					app.UpdateTrialPausedTimer();
+				}
+				ui.UpdateTrialTimer(ProfileManager.GetPrimaryPad());
+			}
+		}
+		else
+		{
+			// need to turn off the trial timer if it was on , and we've unlocked the full version
+			if(bTrialTimerDisplayed)
+			{
+				ui.ShowTrialTimer(false);
+				bTrialTimerDisplayed=false;
+			}
+		}
+
+		// PS3 DLC
+		app.CommerceTick();
+
+		// Fix for #7318 - Title crashes after short soak in the leaderboards menu
+		// A memory leak was caused because the icon renderer kept creating new Vec3's because the pool wasn't reset
+		Vec3::resetPool();
+	}
+
+	// Free resources, unregister custom classes, and exit.
+//	app.Uninit();
+// 	g_pd3dDevice->Release();
+}

Minecraft.Client/ClientConnection.cpp

@@ -1941,7 +1941,7 @@ void ClientConnection::handlePreLogin(shared_ptr<PreLoginPacket> packet)
 	isAtLeastOneFriend = TRUE;
 	cantPlayContentRestricted= FALSE;
 
-#if !defined DISABLE_PSN && ( defined __PS3__ || defined __ORBIS__ || defined __PSVITA__)
+#if ( defined __PS3__ || defined __ORBIS__ || defined __PSVITA__)
 
 	if(!g_NetworkManager.IsHost() && !app.GetGameHostOption(eGameHostOption_FriendsOfFriends))
 	{

Minecraft.Client/Common/App_structs.h

@@ -162,7 +162,7 @@ MOJANG_DATA;
 typedef struct  
 {
 	eDLCContentType eDLCType;
-#if !defined(DISABLE_PSN) && defined( __PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+#if defined( __PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
 	char chImageURL[256];//SCE_NP_COMMERCE2_URL_LEN
 #else
 

Minecraft.Client/Common/Consoles_App.cpp

@@ -5094,9 +5094,6 @@ void CMinecraftApp::NotificationsCallback(LPVOID pParam,DWORD dwNotification, un
 #if defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
 int CMinecraftApp::MustSignInFullVersionPurchaseReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	if(result==C4JStorage::EMessage_ResultAccept) 
 	{
 #ifdef __PS3__
@@ -5109,15 +5106,11 @@ int CMinecraftApp::MustSignInFullVersionPurchaseReturned(void *pParam,int iPad,C
 	}
 
 	return 0;
-#endif
 }
 
 #if defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
 int CMinecraftApp::MustSignInFullVersionPurchaseReturnedExitTrial(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	if(result==C4JStorage::EMessage_ResultAccept) 
 	{
 #ifdef __PS3__
@@ -5133,7 +5126,6 @@ int CMinecraftApp::MustSignInFullVersionPurchaseReturnedExitTrial(void *pParam,i
 	app.SetAction(iPad,eAppAction_ExitWorldTrial);	
 
 	return 0;
-#endif
 }
 #endif
 
@@ -6769,7 +6761,7 @@ wstring CMinecraftApp::GetIconReplacement(unsigned int uiIcon)
 #endif
 }
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
 unordered_map<PlayerUID, MOJANG_DATA *, PlayerUID::Hash> CMinecraftApp::MojangData;
 unordered_map<int, char * >  CMinecraftApp::DLCTextures_PackID;
 unordered_map<string, DLC_INFO * >  CMinecraftApp::DLCInfo;
@@ -6780,12 +6772,6 @@ unordered_map<int, wstring >  CMinecraftApp::DLCTextures_PackID; // for mash-up
 //unordered_map<ULONGLONG,DLC_INFO * > CMinecraftApp::DLCInfo_Trial; // full offerid, dlc_info
 unordered_map<wstring,DLC_INFO * > CMinecraftApp::DLCInfo_Full; // full offerid, dlc_info
 unordered_map<wstring, wstring >  CMinecraftApp::DLCInfo_SkinName; // skin name, full offer id
-#elif defined(DISABLE_PSN) && defined(__PS3__)
-unordered_map<PlayerUID, MOJANG_DATA *, PlayerUID::Hash> CMinecraftApp::MojangData;
-unordered_map<int, ULONGLONG >  CMinecraftApp::DLCTextures_PackID;
-unordered_map<ULONGLONG, DLC_INFO * >  CMinecraftApp::DLCInfo_Trial;
-unordered_map<ULONGLONG, DLC_INFO * >  CMinecraftApp::DLCInfo_Full;
-unordered_map<wstring, ULONGLONG >  CMinecraftApp::DLCInfo_SkinName;
 #else
 unordered_map<PlayerUID, MOJANG_DATA *> CMinecraftApp::MojangData;
 unordered_map<int, ULONGLONG >  CMinecraftApp::DLCTextures_PackID;
@@ -6868,7 +6854,7 @@ HRESULT CMinecraftApp::RegisterConfigValues(WCHAR *pType, int iValue)
 	return hr;
 }
 
-#if (defined _XBOX || defined _WINDOWS64 || defined DISABLE_PSN)
+#if (defined _XBOX || defined _WINDOWS64)
 HRESULT CMinecraftApp::RegisterDLCData(WCHAR *pType, WCHAR *pBannerName, int iGender, __uint64 ullOfferID_Full, __uint64 ullOfferID_Trial, WCHAR *pFirstSkin, unsigned int uiSortIndex, int iConfig, WCHAR *pDataFile)
 {
 	HRESULT hr=S_OK;
@@ -7060,7 +7046,7 @@ HRESULT CMinecraftApp::RegisterDLCData(char *pchDLCName, unsigned int uiSortInde
 
 
 
-#if !defined(DISABLE_PSN) && defined( __PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined( __PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 bool CMinecraftApp::GetDLCFullOfferIDForSkinID(const wstring &FirstSkin,ULONGLONG *pullVal)
 {
 	AUTO_VAR(it, DLCInfo_SkinName.find(FirstSkin));
@@ -7328,7 +7314,7 @@ DLC_INFO *CMinecraftApp::GetDLCInfoForProductName(WCHAR *pwchProductName)
 	return NULL;
 }
 
-#elif !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+#elif defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
 #else
 
 DLC_INFO *CMinecraftApp::GetDLCInfoForFullOfferID(ULONGLONG ullOfferID_Full)
@@ -9439,7 +9425,7 @@ byteArray CMinecraftApp::getArchiveFile(const wstring &filename)
 
 // DLC
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
 int CMinecraftApp::GetDLCInfoCount() 
 { 
 	return (int)DLCInfo.size();

Minecraft.Client/Common/Consoles_App.h

@@ -594,7 +594,7 @@ public:
 	MOJANG_DATA *GetMojangDataForXuid(PlayerUID xuid);
 	static HRESULT RegisterConfigValues(WCHAR *pType, int iValue);
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	HRESULT RegisterDLCData(char *pchDLCName, unsigned int uiSortIndex, char *pchImageURL);
 	bool GetDLCFullOfferIDForSkinID(const wstring &FirstSkin,ULONGLONG *pullVal);
 	DLC_INFO *GetDLCInfoForTrialOfferID(ULONGLONG ullOfferID_Trial);
@@ -631,7 +631,7 @@ private:
 
 	std::vector <SCreditTextItemDef *> vDLCCredits;
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
 	static unordered_map<PlayerUID,MOJANG_DATA *, PlayerUID::Hash > MojangData;
 	static unordered_map<int, char * >  DLCTextures_PackID; // for mash-up packs & texture packs
 	static unordered_map<string,DLC_INFO * > DLCInfo; 
@@ -642,12 +642,6 @@ private:
 	//static unordered_map<wstring,DLC_INFO * > DLCInfo_Trial; // full offerid, dlc_info
 	static unordered_map<wstring,DLC_INFO * > DLCInfo_Full; // full offerid, dlc_info
 	static unordered_map<wstring, wstring >  DLCInfo_SkinName; // skin name, full offer id
-#elif defined(DISABLE_PSN) && defined(__PS3__)
-	static unordered_map<PlayerUID,MOJANG_DATA *, PlayerUID::Hash > MojangData;
-	static unordered_map<int, ULONGLONG >  DLCTextures_PackID; // for mash-up packs & texture packs
-	static unordered_map<ULONGLONG,DLC_INFO * > DLCInfo_Trial; // full offerid, dlc_info
-	static unordered_map<ULONGLONG,DLC_INFO * > DLCInfo_Full; // full offerid, dlc_info
-	static unordered_map<wstring, ULONGLONG >  DLCInfo_SkinName; // skin name, full offer id
 #else
 	static unordered_map<PlayerUID,MOJANG_DATA * > MojangData;
 	static unordered_map<int, ULONGLONG >  DLCTextures_PackID; // for mash-up packs & texture packs
@@ -778,7 +772,7 @@ public:
 	void			ClearTMSPPFilesRetrieved();
 	unsigned int	AddTMSPPFileTypeRequest(eDLCContentType eType, bool bPromote=false);
 	int				GetDLCInfoTexturesOffersCount();
-#if !defined(DISABLE_PSN) && defined( __PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined( __PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	DLC_INFO *GetDLCInfo(int iIndex);	
 	DLC_INFO *GetDLCInfo(char *);
 	DLC_INFO *GetDLCInfoFromTPackID(int iTPID);

Minecraft.Client/Common/Leaderboards/LeaderboardManager.cpp

@@ -9,7 +9,7 @@ const wstring LeaderboardManager::filterNames[eNumFilterModes] =
 		L"Friends", L"MyScore", L"TopRank"
 	};
 
-#if !defined(_DURANGO) && !defined(_WINDOWS64) && !defined(_XBOX) && !defined(__ORBIS__) // str1k3r - some platforms complain about this, also this wasnt in the leak?
+#if !defined(_WINDOWS64) && !defined(_DURANGO) && !defined(__ORBIS__) && !defined(__PS3__) && !defined(__PSVITA__) && !defined(_XBOX)
 LeaderboardManager *LeaderboardManager::m_instance = NULL;
 #endif
 

Minecraft.Client/Common/Network/GameNetworkManager.cpp

@@ -68,7 +68,7 @@ void CGameNetworkManager::Initialise()
 	int flagIndexSize = LevelRenderer::getGlobalChunkCount() / (Level::maxBuildHeight / 16);		// dividing here by number of renderer chunks in one column
 #ifdef _XBOX
 	s_pPlatformNetworkManager = new CPlatformNetworkManagerXbox();
-#elif !defined(DISABLE_PSN) && defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
+#elif defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
 	s_pPlatformNetworkManager = new CPlatformNetworkManagerSony();
 #elif defined _DURANGO
 	s_pPlatformNetworkManager = new CPlatformNetworkManagerDurango();
@@ -167,11 +167,6 @@ bool CGameNetworkManager::_RunNetworkGame(LPVOID lpParameter)
 			return true;
 		}
 	}
-	else
-	{
-		// Client needs QNET_STATE_GAME_PLAY so that IsInGameplay() returns true
-		s_pPlatformNetworkManager->SetGamePlayState();
-	}
 	
 	if( g_NetworkManager.IsLeavingGame() ) return false;
 
@@ -341,12 +336,10 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 
 	// 4J Stu - Wait a while to make sure that DLC is loaded. This is the last point before the network communication starts
 	// so the latest we can check this
-#ifndef DISABLE_PSN
 	while( !app.DLCInstallProcessCompleted() && app.DLCInstallPending() && !g_NetworkManager.IsLeavingGame() )
 	{
 		Sleep( 10 );
 	}
-#endif
 	if( g_NetworkManager.IsLeavingGame() )
 	{
 		MinecraftServer::HaltServer();
@@ -503,7 +496,7 @@ bool	CGameNetworkManager::StartNetworkGame(Minecraft *minecraft, LPVOID lpParame
 				// The connections should tick at 20 per second
 				Sleep(50);
 				app.DebugPrintf("<***> %d %d %d %d %d\n",IsInSession(), !connection->isStarted(),!connection->isClosed(),ProfileManager.IsSignedIn(idx),!g_NetworkManager.IsLeavingGame());
-#if defined _XBOX || defined __PS3__ && !defined DISABLE_PSN
+#if defined _XBOX || __PS3__
 			} while (IsInSession() && !connection->isStarted() && !connection->isClosed() && ProfileManager.IsSignedIn(idx) && !g_NetworkManager.IsLeavingGame() );
 #else
 				// TODO - This SHOULD be something just like the code above but temporarily changing here so that we don't have to depend on the profilemanager behaviour
@@ -801,7 +794,7 @@ int CGameNetworkManager::JoinFromInvite_SignInReturned(void *pParam,bool bContin
 
 			// Check if user-created content is allowed, as we cannot play multiplayer if it's not
 			bool noUGC = false;
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__PSVITA__)
 			ProfileManager.GetChatAndContentRestrictions(iPad,false,&noUGC,NULL,NULL);
 #elif defined(__ORBIS__)
 			ProfileManager.GetChatAndContentRestrictions(iPad,false,NULL,&noUGC,NULL);
@@ -1014,9 +1007,6 @@ int	CGameNetworkManager::ExitAndJoinFromInviteThreadProc( void* lpParam )
 // The pair of methods MustSignInReturned_0 & PSNSignInReturned_0 handle this
 int	CGameNetworkManager::MustSignInReturned_0(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	if(result==C4JStorage::EMessage_ResultAccept) 
 	{
 #ifdef __PS3__
@@ -1035,14 +1025,10 @@ int	CGameNetworkManager::MustSignInReturned_0(void *pParam,int iPad,C4JStorage::
 	}
 
 	return 0;
-#endif
 }
 
 int CGameNetworkManager::PSNSignInReturned_0(void* pParam, bool bContinue, int iPad)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	JoinFromInviteData *inviteData = (JoinFromInviteData *)pParam;
 
 	// If the invite data isn't set up yet (indicated by it being all zeroes, easiest detected via the net version), then try and get it again... this can happen if we got
@@ -1075,16 +1061,12 @@ int CGameNetworkManager::PSNSignInReturned_0(void* pParam, bool bContinue, int i
 	}
 
 	return 0;
-#endif
 }
 
 // This case happens when we were in the main menus when we got an invite, and weren't signed in... now can proceed with the normal flow of code for this situation
 // The pair of methods MustSignInReturned_1 & PSNSignInReturned_1 handle this
 int	CGameNetworkManager::MustSignInReturned_1(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	if(result==C4JStorage::EMessage_ResultAccept) 
 	{
 #ifdef __PS3__
@@ -1096,14 +1078,10 @@ int	CGameNetworkManager::MustSignInReturned_1(void *pParam,int iPad,C4JStorage::
 #endif
 	}
 	return 0;
-#endif
 }
 
 int CGameNetworkManager::PSNSignInReturned_1(void* pParam, bool bContinue, int iPad)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	INVITE_INFO *inviteInfo = (INVITE_INFO *)pParam;
 
 	// If the invite data isn't set up yet (indicated by it being all zeroes, easiest detected via the net version), then try and get it again... this can happen if we got
@@ -1131,7 +1109,6 @@ int CGameNetworkManager::PSNSignInReturned_1(void* pParam, bool bContinue, int i
 	}
 
 	return 0;
-#endif
 }
 #endif
 
@@ -1469,7 +1446,7 @@ void CGameNetworkManager::StateChange_AnyToEnding(bool bStateWasPlaying)
 			if(pNetworkPlayer != NULL && ProfileManager.IsSignedIn( i ) )
 			{
 				app.DebugPrintf("Stats save for an offline game for the player at index %d\n", i );
-				//Minecraft::GetInstance()->forceStatsSave(pNetworkPlayer->GetUserIndex());
+				Minecraft::GetInstance()->forceStatsSave(pNetworkPlayer->GetUserIndex());
 			}
 		}
 	}
@@ -1812,7 +1789,7 @@ void CGameNetworkManager::GameInviteReceived( int userIndex, const INVITE_INFO *
 #endif
 		if( !g_NetworkManager.IsInSession() )
 		{	
-#if !defined(DISABLE_PSN) && defined (__PS3__) || defined (__PSVITA__)
+#if defined (__PS3__) || defined (__PSVITA__)
 			// PS3 is more complicated here - we need to make sure that the player is online. If they are then we can do the same as the xbox, if not we need to try and get them online and then, if they do sign in, go down the same path
 			
 			// Determine why they're not "signed in live"
@@ -1962,7 +1939,7 @@ void CGameNetworkManager::HandleDisconnect(bool bLostRoomOnly)
 	if((g_NetworkManager.GetLockedProfile()!=-1) && iPrimaryPlayer!=-1 && g_NetworkManager.IsInSession() )
 	{
 		m_bLastDisconnectWasLostRoomOnly = bLostRoomOnly;
-#if !defined(DISABLE_PSN) && defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
+#if defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
 		m_bSignedOutofPSN=bPSNSignout;
 #endif
 		app.SetAction(iPrimaryPlayer,eAppAction_EthernetDisconnected);

Minecraft.Client/Common/Network/GameNetworkManager.h

@@ -6,7 +6,7 @@ using namespace std;
 #include "NetworkPlayerInterface.h"
 #ifdef _XBOX
 #include "..\..\Xbox\Network\PlatformNetworkManagerXbox.h"
-#elif !defined DISABLE_PSN && defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
+#elif defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
 #include "..\..\Common\Network\Sony\PlatformNetworkManagerSony.h"
 #elif defined _DURANGO
 #include "..\..\Durango\Network\PlatformNetworkManagerDurango.h"
@@ -32,7 +32,7 @@ class CGameNetworkManager
 {
 #ifdef _XBOX
 	friend class CPlatformNetworkManagerXbox;
-#elif !defined DISABLE_PSN && defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
+#elif defined __PS3__ || defined __ORBIS__ || defined __PSVITA__
 	friend class CPlatformNetworkManagerSony;
 #elif defined _DURANGO
 	friend class CPlatformNetworkManagerDurango;

Minecraft.Client/Common/Network/PlatformNetworkManagerInterface.h

@@ -84,7 +84,7 @@ public:
 	virtual void HandleSignInChange() = 0;
 
 	virtual bool _RunNetworkGame() = 0;
-	virtual void SetGamePlayState() {}
+
 private:
 	virtual bool _LeaveGame(bool bMigrateHost, bool bLeaveRoom) = 0;
 	virtual void _HostGame(int usersMask, unsigned char publicSlots = MINECRAFT_NET_MAX_PLAYERS, unsigned char privateSlots = 0) = 0;

Minecraft.Client/Common/Network/PlatformNetworkManagerStub.cpp

@@ -3,11 +3,6 @@
 #include "..\..\..\Minecraft.World\StringHelpers.h"
 #include "PlatformNetworkManagerStub.h"
 #include "..\..\Xbox\Network\NetworkPlayerXbox.h"		// TODO - stub version of this?
-#include "..\..\Minecraft.h"
-#include "..\..\User.h"
-#if defined _WINDOWS64 || defined __PS3__
-#include "..\..\Common\Network\WinsockNetLayer.h"
-#endif
 
 CPlatformNetworkManagerStub *g_pPlatformNetworkManager;
 
@@ -119,42 +114,10 @@ void CPlatformNetworkManagerStub::NotifyPlayerJoined(IQNetPlayer *pQNetPlayer	)
 	}
 }
 
-void CPlatformNetworkManagerStub::NotifyPlayerLeaving(IQNetPlayer *pQNetPlayer)
-{
-	app.DebugPrintf("Player 0x%p \"%ls\" leaving.\n", pQNetPlayer, pQNetPlayer->GetGamertag());
-
-	INetworkPlayer *networkPlayer = getNetworkPlayer(pQNetPlayer);
-	if (networkPlayer == NULL)
-		return;
-
-	Socket *socket = networkPlayer->GetSocket();
-	if (socket != NULL)
-	{
-		if (m_pIQNet->IsHost())
-			g_NetworkManager.CloseConnection(networkPlayer);
-	}
-
-	if (m_pIQNet->IsHost())
-	{
-		SystemFlagRemovePlayer(networkPlayer);
-	}
-
-	g_NetworkManager.PlayerLeaving(networkPlayer);
-
-	for (int idx = 0; idx < XUSER_MAX_COUNT; ++idx)
-	{
-		if (playerChangedCallback[idx] != NULL)
-			playerChangedCallback[idx](playerChangedCallbackParam[idx], networkPlayer, true);
-	}
-
-	removeNetworkPlayer(pQNetPlayer);
-}
-
 bool CPlatformNetworkManagerStub::Initialise(CGameNetworkManager *pGameNetworkManager, int flagIndexSize)
 {
 	m_pGameNetworkManager = pGameNetworkManager;
 	m_flagIndexSize = flagIndexSize;
-	m_pIQNet = new IQNet();
 	g_pPlatformNetworkManager = this;
 	for( int i = 0; i < XUSER_MAX_COUNT; i++ )
 	{
@@ -211,35 +174,6 @@ bool CPlatformNetworkManagerStub::isSystemPrimaryPlayer(IQNetPlayer *pQNetPlayer
 // We call this twice a frame, either side of the render call so is a good place to "tick" things
 void CPlatformNetworkManagerStub::DoWork()
 {
-	extern QNET_STATE _iQNetStubState;
-	if (_iQNetStubState == QNET_STATE_SESSION_STARTING && app.GetGameStarted())
-	{
-		_iQNetStubState = QNET_STATE_GAME_PLAY;
-		if (m_pIQNet->IsHost())
-			WinsockNetLayer::UpdateAdvertiseJoinable(true);
-	}
-	if (_iQNetStubState == QNET_STATE_IDLE)
-		TickSearch();
-	if (_iQNetStubState == QNET_STATE_GAME_PLAY && m_pIQNet->IsHost())
-	{
-		BYTE disconnectedSmallId;
-		while (WinsockNetLayer::PopDisconnectedSmallId(&disconnectedSmallId))
-		{
-			IQNetPlayer *qnetPlayer = m_pIQNet->GetPlayerBySmallId(disconnectedSmallId);
-			if (qnetPlayer != NULL && qnetPlayer->m_smallId == disconnectedSmallId)
-			{
-				NotifyPlayerLeaving(qnetPlayer);
-				qnetPlayer->m_smallId = 0;
-				qnetPlayer->m_isRemote = false;
-				qnetPlayer->m_isHostPlayer = false;
-				qnetPlayer->m_gamertag[0] = 0;
-				qnetPlayer->SetCustomDataValue(0);
-				WinsockNetLayer::PushFreeSmallId(disconnectedSmallId);
-				if (IQNet::s_playerCount > 1)
-					IQNet::s_playerCount--;
-			}
-		}
-	}
 }
 
 int CPlatformNetworkManagerStub::GetPlayerCount()
@@ -297,7 +231,6 @@ bool CPlatformNetworkManagerStub::LeaveGame(bool bMigrateHost)
 	if( m_bLeavingGame ) return true;
 
 	m_bLeavingGame = true;
-	WinsockNetLayer::StopAdvertising();
 
 	// If we are the host wait for the game server to end
 	if(m_pIQNet->IsHost() && g_NetworkManager.ServerStoppedValid())
@@ -306,20 +239,6 @@ bool CPlatformNetworkManagerStub::LeaveGame(bool bMigrateHost)
 		g_NetworkManager.ServerStoppedWait();
 		g_NetworkManager.ServerStoppedDestroy();
 	}
-	else
-	{
-		m_pIQNet->EndGame();
-	}
-
-	for (AUTO_VAR(it, currentNetworkPlayers.begin()); it != currentNetworkPlayers.end(); it++)
-		delete *it;
-	currentNetworkPlayers.clear();
-	m_machineQNetPrimaryPlayers.clear();
-	SystemFlagReset();
-
-	WinsockNetLayer::Shutdown();
-	WinsockNetLayer::Initialize();
-
 	return true;
 }
 
@@ -343,20 +262,7 @@ void CPlatformNetworkManagerStub::HostGame(int localUsersMask, bool bOnlineGame,
 
 	m_pIQNet->HostGame();
 
-	IQNet::m_player[0].m_smallId = 0;
-	IQNet::m_player[0].m_isRemote = false;
-	IQNet::m_player[0].m_isHostPlayer = true;
-	IQNet::s_playerCount = 1;
-
 	_HostGame( localUsersMask, publicSlots, privateSlots );
-
-	int port = WIN64_NET_DEFAULT_PORT;
-	if (!WinsockNetLayer::IsActive())
-		WinsockNetLayer::HostGame(port);
-
-	const wchar_t *hostName = IQNet::m_player[0].m_gamertag;
-	unsigned int settings = app.GetGameHostOption(eGameHostOption_All);
-	WinsockNetLayer::StartAdvertising(port, hostName, settings, 0, 0, MINECRAFT_NET_VERSION);
 //#endif
 }
 
@@ -371,47 +277,6 @@ bool CPlatformNetworkManagerStub::_StartGame()
 
 int CPlatformNetworkManagerStub::JoinGame(FriendSessionInfo *searchResult, int localUsersMask, int primaryUserIndex)
 {
-	if (searchResult == NULL)
-		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
-
-	const char *hostIP = searchResult->data.hostIP;
-	int hostPort = searchResult->data.hostPort;
-
-	if (hostPort <= 0 || hostIP[0] == 0)
-		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
-
-	m_bLeavingGame = false;
-	IQNet::s_isHosting = false;
-	m_pIQNet->ClientJoinGame();
-
-	IQNet::m_player[0].m_smallId = 0;
-	IQNet::m_player[0].m_isRemote = true;
-	IQNet::m_player[0].m_isHostPlayer = true;
-	wcsncpy(IQNet::m_player[0].m_gamertag, searchResult->data.hostName, 31);
-
-	WinsockNetLayer::StopDiscovery();
-
-	if (!WinsockNetLayer::JoinGame(hostIP, hostPort))
-	{
-		app.DebugPrintf("Win64 LAN: Failed to connect to %s:%d\n", hostIP, hostPort);
-		return CGameNetworkManager::JOINGAME_FAIL_GENERAL;
-	}
-
-	BYTE localSmallId = WinsockNetLayer::GetLocalSmallId();
-
-	IQNet::m_player[localSmallId].m_smallId = localSmallId;
-	IQNet::m_player[localSmallId].m_isRemote = false;
-	IQNet::m_player[localSmallId].m_isHostPlayer = false;
-
-	Minecraft *pMinecraft = Minecraft::GetInstance();
-	wcsncpy(IQNet::m_player[localSmallId].m_gamertag, pMinecraft->user->name.c_str(), 32);
-	IQNet::s_playerCount = localSmallId + 1;
-
-	NotifyPlayerJoined(&IQNet::m_player[0]);
-	NotifyPlayerJoined(&IQNet::m_player[localSmallId]);
-
-	m_pGameNetworkManager->StateChange_AnyToStarting();
-
 	return CGameNetworkManager::JOINGAME_SUCCESS;
 }
 
@@ -450,21 +315,6 @@ void CPlatformNetworkManagerStub::HandleSignInChange()
 
 bool CPlatformNetworkManagerStub::_RunNetworkGame()
 {
-	extern QNET_STATE _iQNetStubState;
-	_iQNetStubState = QNET_STATE_GAME_PLAY;
-
-	for (DWORD i = 0; i < IQNet::s_playerCount; i++)
-	{
-		if (IQNet::m_player[i].m_isRemote)
-		{
-			INetworkPlayer *pNetworkPlayer = getNetworkPlayer(&IQNet::m_player[i]);
-			if (pNetworkPlayer != NULL && pNetworkPlayer->GetSocket() != NULL)
-			{
-				Socket::addIncomingSocket(pNetworkPlayer->GetSocket());
-			}
-		}
-	}
-
 	return true;
 }
 
@@ -653,90 +503,10 @@ wstring CPlatformNetworkManagerStub::GatherRTTStats()
 
 void CPlatformNetworkManagerStub::TickSearch()
 {
-	if (m_SessionsUpdatedCallback == NULL)
-		return;
-
-	static DWORD lastSearchTime = 0;
-	DWORD now = GetTickCount();
-	if (now - lastSearchTime < 2000)
-		return;
-	lastSearchTime = now;
-
-	SearchForGames();
 }
 
 void CPlatformNetworkManagerStub::SearchForGames()
 {
-	std::vector<Win64LANSession> lanSessions = WinsockNetLayer::GetDiscoveredSessions();
-
-	if (g_Win64MultiplayerJoin)
-	{
-		bool alreadyPresent = false;
-		for (size_t i = 0; i < lanSessions.size(); i++)
-		{
-			if (strcmp(lanSessions[i].hostIP, g_Win64MultiplayerIP) == 0 &&
-				lanSessions[i].hostPort == g_Win64MultiplayerPort)
-			{
-				alreadyPresent = true;
-				break;
-			}
-		}
-		if (!alreadyPresent)
-		{
-			Win64LANSession manual;
-			memset(&manual, 0, sizeof(manual));
-			strncpy(manual.hostIP, g_Win64MultiplayerIP, sizeof(manual.hostIP) - 1);
-			manual.hostIP[sizeof(manual.hostIP) - 1] = '\0';
-
-			manual.hostPort = g_Win64MultiplayerPort;
-
-			swprintf(manual.hostName, 32, L"%hs:%d", g_Win64MultiplayerIP, g_Win64MultiplayerPort);
-			manual.hostName[31] = L'\0';
-			manual.playerCount = 0;
-			manual.maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
-			manual.isJoinable = true;
-			manual.lastSeenTick = GetTickCount();
-			lanSessions.push_back(manual);
-		}
-	}
-
-	for (size_t i = 0; i < friendsSessions[0].size(); i++)
-		delete friendsSessions[0][i];
-	friendsSessions[0].clear();
-
-	for (size_t i = 0; i < lanSessions.size(); i++)
-	{
-		FriendSessionInfo *info = new FriendSessionInfo();
-		size_t nameLen = wcslen(lanSessions[i].hostName);
-		info->displayLabel = new wchar_t[nameLen + 1];
-		wcsncpy(info->displayLabel, lanSessions[i].hostName, nameLen);
-		info->displayLabel[nameLen] = L'\0';
-		info->displayLabelLength = (unsigned char)nameLen;
-		info->displayLabelViewableStartIndex = 0;
-
-		info->data.netVersion = lanSessions[i].netVersion;
-		info->data.m_uiGameHostSettings = lanSessions[i].gameHostSettings;
-		info->data.texturePackParentId = lanSessions[i].texturePackParentId;
-		info->data.subTexturePackId = lanSessions[i].subTexturePackId;
-		info->data.isReadyToJoin = lanSessions[i].isJoinable;
-		info->data.isJoinable = lanSessions[i].isJoinable;
-		strncpy(info->data.hostIP, lanSessions[i].hostIP, sizeof(info->data.hostIP) - 1);
-		info->data.hostIP[sizeof(info->data.hostIP) - 1] = '\0';
-		info->data.hostPort = lanSessions[i].hostPort;
-		wcsncpy(info->data.hostName, lanSessions[i].hostName, XUSER_NAME_SIZE - 1);
-		info->data.hostName[XUSER_NAME_SIZE - 1] = L'\0';
-		info->data.playerCount = lanSessions[i].playerCount;
-		info->data.maxPlayers = lanSessions[i].maxPlayers;
-
-		info->sessionId = (ULONGLONG)((unsigned __int64)inet_addr(lanSessions[i].hostIP) | ((unsigned __int64)lanSessions[i].hostPort << 32));
-
-		friendsSessions[0].push_back(info);
-	}
-
-	m_searchResultsCount[0] = (int)friendsSessions[0].size();
-
-	if (m_SessionsUpdatedCallback != NULL)
-		m_SessionsUpdatedCallback(m_pSearchParam);
 }
 
 int CPlatformNetworkManagerStub::SearchForGamesThreadProc( void* lpParameter )
@@ -752,9 +522,7 @@ void CPlatformNetworkManagerStub::SetSearchResultsReady(int resultCount)
 
 vector<FriendSessionInfo *> *CPlatformNetworkManagerStub::GetSessionList(int iPad, int localPlayers, bool partyOnly)
 {
-	vector<FriendSessionInfo *> *filteredList = new vector<FriendSessionInfo *>();
-	for (size_t i = 0; i < friendsSessions[0].size(); i++)
-		filteredList->push_back(friendsSessions[0][i]);
+	vector<FriendSessionInfo *> *filteredList = new vector<FriendSessionInfo *>();;
 	return filteredList;
 }
 

Minecraft.Client/Common/Network/PlatformNetworkManagerStub.h

@@ -23,11 +23,7 @@ public:
 	virtual bool RemoveLocalPlayerByUserIndex( int userIndex );
 	virtual INetworkPlayer *GetLocalPlayerByUserIndex( int userIndex );
 	virtual INetworkPlayer *GetPlayerByIndex(int playerIndex);
-#ifdef __PS3
-	virtual INetworkPlayer * GetPlayerByXuid(PlayerUID* xuid)
-#else
 	virtual INetworkPlayer * GetPlayerByXuid(PlayerUID xuid);
-#endif
 	virtual INetworkPlayer * GetPlayerBySmallId(unsigned char smallId);
 	virtual bool ShouldMessageForFullSession();
 
@@ -165,9 +161,8 @@ public:
 	virtual void GetFullFriendSessionInfo( FriendSessionInfo *foundSession, void (* FriendSessionUpdatedFn)(bool success, void *pParam), void *pParam );
 	virtual void ForceFriendsSessionRefresh();
 
-public:
+private:
 	void NotifyPlayerJoined( IQNetPlayer *pQNetPlayer );
-	void NotifyPlayerLeaving( IQNetPlayer *pQNetPlayer );
 
 #ifndef _XBOX
 	void FakeLocalPlayerJoined() { NotifyPlayerJoined(m_pIQNet->GetLocalPlayerByUserIndex(0)); }

Minecraft.Client/Common/Network/SessionInfo.h

@@ -32,7 +32,7 @@ typedef struct _GameSessionData
 		subTexturePackId = 0;
 	}
 } GameSessionData;
-#elif (defined __PS3__ && !defined DISABLE_PSN) || defined __ORBIS__ || defined(__PSVITA__)
+#elif defined __PS3__ || defined __ORBIS__ || defined(__PSVITA__)
 typedef struct _GameSessionData
 {
 	unsigned short netVersion;										//   2 bytes
@@ -47,11 +47,6 @@ typedef struct _GameSessionData
 	unsigned char playerCount;										//   1 byte
 	bool isReadyToJoin;												//   1 byte
 
-	char hostIP[64];												//	 64 bytes
-	int hostPort;													//	 4 bytes
-	wchar_t hostName[XUSER_NAME_SIZE];								//	 64 bytes ( 32*2 )
-	unsigned char maxPlayers;										//	 1 byte
-
 	_GameSessionData()
 	{
 		netVersion = 0;
@@ -62,11 +57,7 @@ typedef struct _GameSessionData
 		subTexturePackId = 0;
 		playerCount = 0;
 		isReadyToJoin = false;
-		memset(hostIP, 0, sizeof(hostIP));
-		hostPort = 0;
-		memset(hostName, 0, sizeof(hostName));
-		playerCount = 0;
-		maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
+
 	}
 } GameSessionData;
 #else
@@ -78,13 +69,6 @@ typedef struct _GameSessionData
 	unsigned char subTexturePackId;									//   1 byte
 
 	bool isReadyToJoin;												//   1 byte
-	bool isJoinable;												//	 1 byte
-
-	char hostIP[64];												//	 64 bytes
-	int hostPort;													//	 4 bytes
-	wchar_t hostName[XUSER_NAME_SIZE];								//	 64 bytes ( 32*2 )
-	unsigned char playerCount;										//	 1 byte
-	unsigned char maxPlayers;										//	 1 byte
 
 	_GameSessionData()
 	{
@@ -92,13 +76,6 @@ typedef struct _GameSessionData
 		m_uiGameHostSettings = 0;
 		texturePackParentId = 0;
 		subTexturePackId = 0;
-		isReadyToJoin = false;
-		isJoinable = true;
-		memset(hostIP, 0, sizeof(hostIP));
-		hostPort = 0;
-		memset(hostName, 0, sizeof(hostName));
-		playerCount = 0;
-		maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
 	}
 } GameSessionData;
 #endif
@@ -109,7 +86,7 @@ public:
 	SessionID sessionId;
 #ifdef _XBOX
 	XSESSION_SEARCHRESULT searchResult;
-#elif (defined __PS3__ && !defined DISABLE_PSN) || defined(__ORBIS__) || defined (__PSVITA__)
+#elif defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
 	SQRNetworkManager::SessionSearchResult searchResult;
 #elif defined(_DURANGO)
 	DQRNetworkManager::SessionSearchResult searchResult;

Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.cpp

@@ -1,6 +1,5 @@
 #include "stdafx.h"
 #include "NetworkPlayerSony.h"
-#ifndef DISABLE_PSN
 
 NetworkPlayerSony::NetworkPlayerSony(SQRNetworkPlayer *qnetPlayer)
 {
@@ -136,4 +135,3 @@ int NetworkPlayerSony::GetTimeSinceLastChunkPacket_ms()
 	__int64 currentTime = System::currentTimeMillis();
 	return (int)( currentTime - m_lastChunkPacketTime );
 }
-#endif

Minecraft.Client/Common/Network/Sony/NetworkPlayerSony.h

@@ -1,5 +1,5 @@
 #pragma once
-#ifndef _DISABLE_PSN
+
 #include "..\..\Common\Network\NetworkPlayerInterface.h"
 #include "SQRNetworkPlayer.h"
 
@@ -41,4 +41,3 @@ private:
 	Socket *m_pSocket;
 	__int64 m_lastChunkPacketTime;
 };
-#endif

Minecraft.Client/Common/Network/Sony/SQRNetworkManager.cpp

@@ -1,5 +1,5 @@
 #include "stdafx.h"
-#ifndef DISABLE_PSN
+
 #include "SQRNetworkManager.h"
 
 bool SQRNetworkManager::s_safeToRespondToGameBootInvite = false;
@@ -80,5 +80,4 @@ void SQRNetworkManager::TickWriteAcks()
 		}
 	}
 	LeaveCriticalSection(&m_csAckQueue);
-}
-#endif
+}

Minecraft.Client/Common/Network/Sony/SQRNetworkPlayer.cpp

@@ -1,5 +1,4 @@
 #include "stdafx.h"
-#ifndef DISABLE_PSN
 #include "SQRNetworkPlayer.h"
 
 #ifdef __PS3__
@@ -610,4 +609,3 @@ bool SQRNetworkPlayer::IsMutedByLocalUser(int userIndex)
 	return SonyVoiceChat::isMutedPlayer(pMan->m_roomSyncData.players[userIndex].m_roomMemberId);
 #endif
 }
-#endif

Minecraft.Client/Common/Network/WinsockNetLayer.h

@@ -1,162 +0,0 @@
-#pragma once
-
-#if defined _WINDOWS64
-#include <WinSock2.h>
-#include <WS2tcpip.h>
-#elif defined __PS3__
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netex/net.h>
-#include <netex/errno.h>
-#include <netinet/tcp.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#endif
-
-#include <vector>
-#include "..\..\Common\Network\NetworkPlayerInterface.h"
-
-#ifdef _WINDOWS64
-#pragma comment(lib, "Ws2_32.lib")
-#endif
-
-#define WIN64_NET_DEFAULT_PORT 25565
-#define WIN64_NET_MAX_CLIENTS 7
-#define WIN64_NET_RECV_BUFFER_SIZE 65536
-#define WIN64_LAN_DISCOVERY_PORT 25566
-#define WIN64_LAN_BROADCAST_MAGIC 0x4D434C4E
-
-#ifdef __PS3__
-typedef int SOCKET;
-#define INVALID_SOCKET -1
-#endif
-
-class Socket;
-
-#pragma pack(push, 1)
-struct Win64LANBroadcast
-{
-	DWORD magic;
-	WORD netVersion;
-	WORD gamePort;
-	char hostName[32];
-	BYTE playerCount;
-	BYTE maxPlayers;
-	DWORD gameHostSettings;
-	DWORD texturePackParentId;
-	BYTE subTexturePackId;
-	BYTE isJoinable;
-};
-#pragma pack(pop)
-
-struct Win64LANSession
-{
-	char hostIP[64];
-	int hostPort;
-	wchar_t hostName[32];
-	unsigned short netVersion;
-	unsigned char playerCount;
-	unsigned char maxPlayers;
-	unsigned int gameHostSettings;
-	unsigned int texturePackParentId;
-	unsigned char subTexturePackId;
-	bool isJoinable;
-	DWORD lastSeenTick;
-};
-
-struct Win64RemoteConnection
-{
-	SOCKET tcpSocket;
-	BYTE smallId;
-	C4JThread* recvThread;
-	volatile bool active;
-};
-
-class WinsockNetLayer
-{
-public:
-	static bool Initialize();
-	static void Shutdown();
-
-	static bool HostGame(int port);
-	static bool JoinGame(const char *ip, int port);
-
-	static bool SendToSmallId(BYTE targetSmallId, const void *data, int dataSize);
-	static bool SendOnSocket(SOCKET sock, const void *data, int dataSize);
-
-	static bool IsHosting() { return s_isHost; }
-	static bool IsConnected() { return s_connected; }
-	static bool IsActive() { return s_active; }
-
-	static BYTE GetLocalSmallId() { return s_localSmallId; }
-	static BYTE GetHostSmallId() { return s_hostSmallId; }
-
-	static SOCKET GetSocketForSmallId(BYTE smallId);
-
-	static void HandleDataReceived(BYTE fromSmallId, BYTE toSmallId, unsigned char *data, unsigned int dataSize);
-
-	static bool PopDisconnectedSmallId(BYTE *outSmallId);
-	static void PushFreeSmallId(BYTE smallId);
-
-	static bool StartAdvertising(int gamePort, const wchar_t *hostName, unsigned int gameSettings, unsigned int texPackId, unsigned char subTexId, unsigned short netVer);
-	static void StopAdvertising();
-	static void UpdateAdvertisePlayerCount(BYTE count);
-	static void UpdateAdvertiseJoinable(bool joinable);
-
-	static bool StartDiscovery();
-	static void StopDiscovery();
-	static vector<Win64LANSession> GetDiscoveredSessions();
-
-	static int GetHostPort() { return s_hostGamePort; }
-
-private:
-	static int AcceptThreadProc(void* param);
-	static int RecvThreadProc(void* param);
-	static int ClientRecvThreadProc(void* param);
-	static int AdvertiseThreadProc(void* param);
-	static int DiscoveryThreadProc(void* param);
-
-	static SOCKET s_listenSocket;
-	static SOCKET s_hostConnectionSocket;
-	static C4JThread* s_acceptThread;
-	static C4JThread* s_clientRecvThread;
-
-	static bool s_isHost;
-	static bool s_connected;
-	static bool s_active;
-	static bool s_initialized;
-
-	static BYTE s_localSmallId;
-	static BYTE s_hostSmallId;
-	static BYTE s_nextSmallId;
-
-	static CRITICAL_SECTION s_sendLock;
-	static CRITICAL_SECTION s_connectionsLock;
-
-	static std::vector<Win64RemoteConnection> s_connections;
-
-	static SOCKET s_advertiseSock;
-	static C4JThread* s_advertiseThread;
-	static volatile bool s_advertising;
-	static Win64LANBroadcast s_advertiseData;
-	static CRITICAL_SECTION s_advertiseLock;
-	static int s_hostGamePort;
-
-	static SOCKET s_discoverySock;
-	static C4JThread* s_discoveryThread;
-	static volatile bool s_discovering;
-	static CRITICAL_SECTION s_discoveryLock;
-	static std::vector<Win64LANSession> s_discoveredSessions;
-
-	static CRITICAL_SECTION s_disconnectLock;
-	static std::vector<BYTE> s_disconnectedSmallIds;
-
-	static CRITICAL_SECTION s_freeSmallIdLock;
-	static std::vector<BYTE> s_freeSmallIds;
-};
-
-extern bool g_Win64MultiplayerHost;
-extern bool g_Win64MultiplayerJoin;
-extern int g_Win64MultiplayerPort;
-extern char g_Win64MultiplayerIP[256];

Minecraft.Client/Common/Postbuilds/Windows64-postbuild.ps1

@@ -24,7 +24,7 @@ $folderCopies = @(
     @{ Source = "DurangoMedia";    		Dest = "Windows64Media" },
     @{ Source = "Windows64Media";  		Dest = "Windows64Media" },
 	@{ Source = "PSVita\Tutorial"; 		Dest = "Windows64Media\Tutorial" },
-	@{ Source = "music"; Dest = "Windows64Media\music" },
+	@{ Source = "Windows64Media\music"; Dest = "Windows64Media\music" },
 	@{ Source = "Windows64Media\Sound"; Dest = "Windows64Media\Sound" },
 	@{ Source = "Common\Postbuilds\Contents\Windows64\redist64"; Dest = "redist64" }
 )

Minecraft.Client/Common/UI/IUIScene_StartGame.cpp

@@ -54,7 +54,7 @@ void IUIScene_StartGame::HandleDLCMountingComplete()
 	for(unsigned int i = 0; i < app.GetDLCInfoTexturesOffersCount(); ++i)
 	{
 		bTexturePackAlreadyListed=false;
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 		char *pchName=app.GetDLCInfoTextures(i);
 		pDLCInfo=app.GetDLCInfo(pchName);
 #elif defined _XBOX_ONE

Minecraft.Client/Common/UI/UIScene_InGameInfoMenu.cpp

@@ -502,9 +502,6 @@ UIScene_InGameInfoMenu::PlayerInfo *UIScene_InGameInfoMenu::BuildPlayerInfo(INet
 #if defined __PS3__ || defined __PSVITA__
 int UIScene_InGameInfoMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	UIScene_InGameInfoMenu* pClass = (UIScene_InGameInfoMenu*)pParam;
 
 	if(result==C4JStorage::EMessage_ResultAccept) 
@@ -517,7 +514,6 @@ int UIScene_InGameInfoMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStora
 	}
 
 	return 0;
-#endif
 }
 
 int UIScene_InGameInfoMenu::ViewInvites_SignInReturned(void *pParam,bool bContinue, int iPad)

Minecraft.Client/Common/UI/UIScene_JoinMenu.cpp

@@ -59,7 +59,7 @@ void UIScene_JoinMenu::tick()
 
 		m_buttonListPlayers.init(eControl_GamePlayers);
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined __PSVITA__
+#if defined(__PS3__) || defined(__ORBIS__) || defined __PSVITA__
 		for( int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; i++ )
 		{
 			if( m_selectedSession->data.players[i] != NULL )
@@ -353,9 +353,6 @@ void UIScene_JoinMenu::checkPrivilegeCallback(LPVOID lpParam, bool hasPrivilege,
 
 void UIScene_JoinMenu::StartSharedLaunchFlow()
 {
-#if defined DISABLE_PSN && defined __PS3__
-	JoinGame(this);
-#else
 	if(!app.IsLocalMultiplayerAvailable())
 	{
 		JoinGame(this);
@@ -369,17 +366,12 @@ void UIScene_JoinMenu::StartSharedLaunchFlow()
 		info.requireOnline = true;
 		ui.NavigateToScene(ProfileManager.GetPrimaryPad(),eUIScene_QuadrantSignin,&info);
 	}
-#endif
 }
 
 int UIScene_JoinMenu::StartGame_SignInReturned(void *pParam,bool bContinue, int iPad)
 {
 	UIScene_JoinMenu* pClass = (UIScene_JoinMenu*)ui.GetSceneFromCallbackId((size_t)pParam);
 
-#if defined DISABLE_PSN && defined __PS3__
-	JoinGame(pClass);
-	return 0;
-#else
 	if(pClass)
 	{
 		if(bContinue==true)
@@ -400,7 +392,6 @@ int UIScene_JoinMenu::StartGame_SignInReturned(void *pParam,bool bContinue, int
 		}
 	}
 	return 0;
-#endif
 }
 
 // Shared function to join the game that is the same whether we used the sign-in UI or not
@@ -440,9 +431,7 @@ void UIScene_JoinMenu::JoinGame(UIScene_JoinMenu* pClass)
 			if( !ProfileManager.AllowedToPlayMultiplayer(ProfileManager.GetPrimaryPad()) ) noPrivileges = true;
 			dwLocalUsersMask |= CGameNetworkManager::GetLocalPlayerMask(ProfileManager.GetPrimaryPad());
 
-#ifndef DISABLE_PSN
 			isSignedInLive = ProfileManager.IsSignedInLive(ProfileManager.GetPrimaryPad());
-#endif
 #ifdef __PSVITA__
 			if(CGameNetworkManager::usingAdhocMode() && SQRNetworkManager_AdHoc_Vita::GetAdhocStatus())
 				isSignedInLive = true;
@@ -481,7 +470,7 @@ void UIScene_JoinMenu::JoinGame(UIScene_JoinMenu* pClass)
 	BOOL pccAllowed = TRUE;
 	BOOL pccFriendsAllowed = TRUE;
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__PSVITA__)
 	if(isSignedInLive)
 	{
 		ProfileManager.GetChatAndContentRestrictions(ProfileManager.GetPrimaryPad(),false,&noUGC,NULL,NULL);

Minecraft.Client/Common/UI/UIScene_LeaderboardsMenu.cpp

@@ -731,7 +731,7 @@ void UIScene_LeaderboardsMenu::CopyLeaderboardEntry(LeaderboardManager::ReadScor
 		}
 	}
 
-#if !defined(DISABLE_PSN) && defined(__PS3__)
+#ifdef __PS3__
 	// m_name can be unicode characters somehow for Japan - should use m_onlineID
 	wstring wstr=convStringToWstring(statsRow->m_uid.getOnlineID());
 	swprintf(leaderboardEntry->m_gamerTag, XUSER_NAME_SIZE, L"%ls",wstr.c_str());

Minecraft.Client/Common/UI/UIScene_LoadOrJoinMenu.cpp

@@ -2385,9 +2385,6 @@ int UIScene_LoadOrJoinMenu::TexturePackDialogReturned(void *pParam,int iPad,C4JS
 #if defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
 int UIScene_LoadOrJoinMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
     UIScene_LoadOrJoinMenu* pClass = (UIScene_LoadOrJoinMenu*)pParam;
 
 	if(result==C4JStorage::EMessage_ResultAccept) 
@@ -2406,7 +2403,6 @@ int UIScene_LoadOrJoinMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStora
 	}
 
     return 0;
-#endif
 }
 
 int UIScene_LoadOrJoinMenu::PSN_SignInReturned(void *pParam,bool bContinue, int iPad)

Minecraft.Client/Common/UI/UIScene_MainMenu.cpp

@@ -550,7 +550,6 @@ int UIScene_MainMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStorage::EM
 {
 	UIScene_MainMenu* pClass = (UIScene_MainMenu*)pParam;
 
-#ifndef DISABLE_PSN
 	if(result==C4JStorage::EMessage_ResultAccept) 
 	{
 #ifdef __PS3__
@@ -630,9 +629,6 @@ int UIScene_MainMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStorage::EM
 			pClass->m_bIgnorePress=false;
 		}
 	}
-#endif
-	CreateLoad_SignInReturned(pClass, true, 0);
-	pClass->m_bIgnorePress=false;
 
 	return 0;
 }

Minecraft.Client/Common/UI/UIScene_PauseMenu.cpp

@@ -1029,9 +1029,6 @@ int UIScene_PauseMenu::BanGameDialogReturned(void *pParam,int iPad,C4JStorage::E
 #if defined(__PS3__)  || defined (__PSVITA__) || defined(__ORBIS__)
 int UIScene_PauseMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	UIScene_PauseMenu* pClass = (UIScene_PauseMenu*)ui.GetSceneFromCallbackId((size_t)pParam);
 	if(result==C4JStorage::EMessage_ResultAccept && pClass) 
 	{
@@ -1094,7 +1091,6 @@ int UIScene_PauseMenu::MustSignInReturnedPSN(void *pParam,int iPad,C4JStorage::E
 	}
 
 	return 0;
-#endif
 }
 
 int UIScene_PauseMenu::ViewLeaderboards_SignInReturned(void *pParam,bool bContinue, int iPad)
@@ -1135,9 +1131,6 @@ int UIScene_PauseMenu::ViewLeaderboards_SignInReturned(void *pParam,bool bContin
 
 int UIScene_PauseMenu::WarningTrialTexturePackReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
 {
-#ifdef DISABLE_PSN
-	return 0;
-#else
 	UIScene_PauseMenu* pClass = (UIScene_PauseMenu*)ui.GetSceneFromCallbackId((size_t)pParam);
 
 #ifdef __ORBIS__
@@ -1251,7 +1244,7 @@ int UIScene_PauseMenu::WarningTrialTexturePackReturned(void *pParam,int iPad,C4J
 		}
 	}
 #endif		//	
-#endif
+
 	return 0;
 }
 

Minecraft.Client/Common/UI/UIScene_SaveMessage.cpp

@@ -110,7 +110,7 @@ void UIScene_SaveMessage::handlePress(F64 controlId, F64 childId)
 
 		m_bIgnoreInput=true;
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 		// wait for the profile to be read - this has been kicked off earlier, so should be read by now
 		addTimer(PROFILE_LOADED_TIMER_ID,PROFILE_LOADED_TIMER_TIME);
 #else
@@ -126,7 +126,7 @@ void UIScene_SaveMessage::handleTimerComplete(int id)
 	{
 	case PROFILE_LOADED_TIMER_ID:
 		{
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 			C4JStorage::eOptionsCallback eStatus=app.GetOptionsCallbackStatus(0);
 
 			switch(eStatus)

Minecraft.Client/Common/UI/UIScene_SkinSelectMenu.cpp

@@ -1518,7 +1518,7 @@ void UIScene_SkinSelectMenu::HandleDLCMountingComplete()
 void UIScene_SkinSelectMenu::showNotOnlineDialog(int iPad)
 {
 	// need to be signed in to live. get them to sign in to online
-#if !defined(DISABLE_PSN) && defined(__PS3__)
+#if defined(__PS3__)
 	SQRNetworkManager_PS3::AttemptPSNSignIn(NULL, this);		
 
 #elif defined(__PSVITA__)

Minecraft.Client/Extrax64Stubs.cpp

@@ -5,7 +5,6 @@
 
 #ifdef __PS3__
 #include "PS3\Sentient\SentientManager.h"
-#include "Common\Network\WinsockNetLayer.h"
 #include "StatsCounter.h"
 #include "PS3\Social\SocialManager.h"
 #include <libsn.h>
@@ -18,7 +17,6 @@
 #include "Durango\DurangoExtras\xcompress.h"
 #elif defined _WINDOWS64
 #include "Windows64\Sentient\SentientManager.h"
-#include "Common\Network\WinsockNetLayer.h"
 #include "StatsCounter.h"
 #include "Windows64\Social\SocialManager.h"
 #include "Windows64\Sentient\DynamicConfigurations.h"
@@ -170,10 +168,8 @@ void PIXSetMarkerDeprecated(int a, char *b, ...) {}
 
 bool IsEqualXUID(PlayerUID a, PlayerUID b)
 {
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__) || defined(_DURANGO)
+#if defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__) || defined(_DURANGO)
 	return (a == b);
-#elif defined(DISABLE_PSN) && defined(__PS3__)
-	return (a.XUID == b.XUID);
 #else
 	return false;
 #endif
@@ -189,23 +185,20 @@ D3DXVECTOR3::D3DXVECTOR3() {}
 D3DXVECTOR3::D3DXVECTOR3(float x,float y,float z) : x(x), y(y), z(z) {}
 D3DXVECTOR3& D3DXVECTOR3::operator += ( CONST D3DXVECTOR3& add ) { x += add.x; y += add.y; z += add.z; return *this; }
 
-BYTE IQNetPlayer::GetSmallId() { return m_smallId; }
+BYTE IQNetPlayer::GetSmallId() { return 0; }
 void IQNetPlayer::SendData(IQNetPlayer *player, const void *pvData, DWORD dwDataSize, DWORD dwFlags)
 {
-	if (WinsockNetLayer::IsActive())
-	{
-		WinsockNetLayer::SendToSmallId(player->m_smallId, pvData, dwDataSize);
-	}
+	app.DebugPrintf("Sending from 0x%x to 0x%x %d bytes\n",this,player,dwDataSize);
 }
-bool IQNetPlayer::IsSameSystem(IQNetPlayer *player) { return (this == player) || (!m_isRemote && !player->m_isRemote); }
+bool IQNetPlayer::IsSameSystem(IQNetPlayer *player) { return true; }
 DWORD IQNetPlayer::GetSendQueueSize( IQNetPlayer *player, DWORD dwFlags ) { return 0; }
 DWORD IQNetPlayer::GetCurrentRtt() { return 0; }
-bool IQNetPlayer::IsHost() { return m_isHostPlayer; }
+bool IQNetPlayer::IsHost() { return this == &IQNet::m_player[0]; }
 bool IQNetPlayer::IsGuest() { return false; }
-bool IQNetPlayer::IsLocal() { return !m_isRemote; }
-PlayerUID IQNetPlayer::GetXuid() { return (PlayerUID)(0xe000d45248242f2e + m_smallId); }
-LPCWSTR IQNetPlayer::GetGamertag() { return m_gamertag; }
-int IQNetPlayer::GetSessionIndex() { return m_smallId; }
+bool IQNetPlayer::IsLocal() { return true; }
+PlayerUID IQNetPlayer::GetXuid() { return INVALID_XUID; }
+LPCWSTR IQNetPlayer::GetGamertag() { static const wchar_t *test = L"stub"; return test; }
+int IQNetPlayer::GetSessionIndex() { return 0; }
 bool IQNetPlayer::IsTalking() { return false; }
 bool IQNetPlayer::IsMutedByLocalUser(DWORD dwUserIndex) { return false; }
 bool IQNetPlayer::HasVoice() { return false; }
@@ -218,104 +211,23 @@ ULONG_PTR IQNetPlayer::GetCustomDataValue() {
 	return m_customData;
 }
 
-IQNetPlayer IQNet::m_player[MINECRAFT_NET_MAX_PLAYERS];
-DWORD IQNet::s_playerCount = 1;
-bool IQNet::s_isHosting = true;
+IQNetPlayer IQNet::m_player[4];
 
-QNET_STATE _iQNetStubState = QNET_STATE_IDLE;
-
-void Win64_SetupRemoteQNetPlayer(IQNetPlayer *player, BYTE smallId, bool isHost, bool isLocal)
-{
-	player->m_smallId = smallId;
-	player->m_isRemote = !isLocal;
-	player->m_isHostPlayer = isHost;
-	swprintf(player->m_gamertag, 32, L"Player%d", smallId);
-	if (smallId >= IQNet::s_playerCount)
-		IQNet::s_playerCount = smallId + 1;
-}
+bool _bQNetStubGameRunning = false;
 
 HRESULT IQNet::AddLocalPlayerByUserIndex(DWORD dwUserIndex){ return S_OK; }
 IQNetPlayer *IQNet::GetHostPlayer() { return &m_player[0]; }
-IQNetPlayer *IQNet::GetLocalPlayerByUserIndex(DWORD dwUserIndex)
-{
-	if (s_isHosting)
-	{
-		if (dwUserIndex < MINECRAFT_NET_MAX_PLAYERS && !m_player[dwUserIndex].m_isRemote)
-			return &m_player[dwUserIndex];
-		return NULL;
-	}
-	if (dwUserIndex != 0)
-		return NULL;
-	for (DWORD i = 0; i < s_playerCount; i++)
-	{
-		if (!m_player[i].m_isRemote)
-			return &m_player[i];
-	}
-	return NULL;
-}
-static bool Win64_IsActivePlayer(IQNetPlayer *p, DWORD index)
-{
-	if (index == 0) return true;
-	return (p->GetCustomDataValue() != 0);
-}
-
-IQNetPlayer *IQNet::GetPlayerByIndex(DWORD dwPlayerIndex)
-{
-	DWORD found = 0;
-	for (DWORD i = 0; i < s_playerCount; i++)
-	{
-		if (Win64_IsActivePlayer(&m_player[i], i))
-		{
-			if (found == dwPlayerIndex) return &m_player[i];
-			found++;
-		}
-	}
-	return &m_player[0];
-}
-IQNetPlayer *IQNet::GetPlayerBySmallId(BYTE SmallId)
-{
-	for (DWORD i = 0; i < s_playerCount; i++)
-	{
-		if (m_player[i].m_smallId == SmallId && Win64_IsActivePlayer(&m_player[i], i)) return &m_player[i];
-	}
-	return NULL;
-}
-IQNetPlayer *IQNet::GetPlayerByXuid(PlayerUID xuid)
-{
-	for (DWORD i = 0; i < s_playerCount; i++)
-	{
-		if (Win64_IsActivePlayer(&m_player[i], i) && m_player[i].GetXuid() == xuid) return &m_player[i];
-	}
-	return &m_player[0];
-}
-DWORD IQNet::GetPlayerCount()
-{
-	DWORD count = 0;
-	for (DWORD i = 0; i < s_playerCount; i++)
-	{
-		if (Win64_IsActivePlayer(&m_player[i], i)) count++;
-	}
-	return count;
-}
-QNET_STATE IQNet::GetState() { return _iQNetStubState; }
-bool IQNet::IsHost() { return s_isHosting; }
+IQNetPlayer *IQNet::GetLocalPlayerByUserIndex(DWORD dwUserIndex) { return &m_player[dwUserIndex]; } 
+IQNetPlayer *IQNet::GetPlayerByIndex(DWORD dwPlayerIndex) { return &m_player[0]; }
+IQNetPlayer *IQNet::GetPlayerBySmallId(BYTE SmallId){ return &m_player[0]; }
+IQNetPlayer *IQNet::GetPlayerByXuid(PlayerUID xuid){ return &m_player[0]; }
+DWORD IQNet::GetPlayerCount() { return 1; }
+QNET_STATE IQNet::GetState() { return _bQNetStubGameRunning ? QNET_STATE_GAME_PLAY : QNET_STATE_IDLE; }
+bool IQNet::IsHost() { return true; }
 HRESULT IQNet::JoinGameFromInviteInfo(DWORD dwUserIndex, DWORD dwUserMask, const INVITE_INFO *pInviteInfo) { return S_OK; }
-void IQNet::HostGame() { _iQNetStubState = QNET_STATE_SESSION_STARTING; s_isHosting = true; }
-void IQNet::ClientJoinGame() { _iQNetStubState = QNET_STATE_SESSION_STARTING; s_isHosting = false; }
-void IQNet::EndGame()
-{
-	_iQNetStubState = QNET_STATE_IDLE;
-	s_isHosting = false;
-	s_playerCount = 1;
-	for (int i = 1; i < MINECRAFT_NET_MAX_PLAYERS; i++)
-	{
-		m_player[i].m_smallId = 0;
-		m_player[i].m_isRemote = false;
-		m_player[i].m_isHostPlayer = false;
-		m_player[i].m_gamertag[0] = 0;
-		m_player[i].SetCustomDataValue(0);
-	}
-}
+void IQNet::HostGame() { _bQNetStubGameRunning = true; }
+void IQNet::EndGame() { _bQNetStubGameRunning = false; }
+
 DWORD MinecraftDynamicConfigurations::GetTrialTime() { return DYNAMIC_CONFIG_DEFAULT_TRIAL_TIME; }
 
 void XSetThreadProcessor(HANDLE a, int b) {}
@@ -536,8 +448,6 @@ void				C_4JProfile::Initialise( DWORD dwTitleID,
 		pGameSettings->ucTutorialCompletion[28] |= 1<<0;
 	}
 }
-#endif
-#if defined _WINDOWS64 || (defined(__PS3__) && defined(DISABLE_PSN))
 void				C_4JProfile::SetTrialTextStringTable(CXuiStringTable *pStringTable,int iAccept,int iReject) {}
 void				C_4JProfile::SetTrialAwardText(eAwardType AwardType,int iTitle,int iText) {}
 int					C_4JProfile::GetLockedProfile() { return 0; }
@@ -550,24 +460,11 @@ UINT				C_4JProfile::DisplayOfflineProfile(int( *Func)(LPVOID,const bool, const
 UINT				C_4JProfile::RequestConvertOfflineToGuestUI(int( *Func)(LPVOID,const bool, const int iPad),LPVOID lpParam,int iQuadrant) { return 0; }
 void				C_4JProfile::SetPrimaryPlayerChanged(bool bVal) {}
 bool				C_4JProfile::QuerySigninStatus(void) { return true; }
-void				C_4JProfile::GetXUID(int iPad, PlayerUID *pXuid,bool bOnlineXuid)
-{
-	if (iPad != 0)
-	{
-		// previously INVALID_XUID
-		*pXuid = 0;
-		return;
-	}
-	if (IQNet::s_isHosting)
-		*pXuid = 0xe000d45248242f2e;
-	else
-		*pXuid = 0xe000d45248242f2e + WinsockNetLayer::GetLocalSmallId();
-}
-BOOL				C_4JProfile::AreXUIDSEqual(PlayerUID xuid1,PlayerUID xuid2) { return xuid1 == xuid2; }
+void				C_4JProfile::GetXUID(int iPad, PlayerUID *pXuid,bool bOnlineXuid) {*pXuid = 0xe000d45248242f2e; }
+BOOL				C_4JProfile::AreXUIDSEqual(PlayerUID xuid1,PlayerUID xuid2) { return false; }
 BOOL				C_4JProfile::XUIDIsGuest(PlayerUID xuid) { return false; }
 bool				C_4JProfile::AllowedToPlayMultiplayer(int iProf) { return true; }
-#endif
-#ifdef _WINDOWS64
+
 #if defined(__ORBIS__)
 bool				C_4JProfile::GetChatAndContentRestrictions(int iPad, bool thisQuadrantOnly, bool *pbChatRestricted,bool *pbContentRestricted,int *piAge)
 {
@@ -590,8 +487,8 @@ char fakeGamerTag[32] = "PlayerName";
 void				SetFakeGamertag(char *name){ strcpy_s(fakeGamerTag, name); }
 char*				C_4JProfile::GetGamertag(int iPad){ return fakeGamerTag; }
 #else
-char*				C_4JProfile::GetGamertag(int iPad){ extern char g_Win64Username[17]; return g_Win64Username; }
-wstring				C_4JProfile::GetDisplayName(int iPad){ extern wchar_t g_Win64UsernameW[17]; return g_Win64UsernameW; }
+char*				C_4JProfile::GetGamertag(int iPad){ return "PlayerName"; }
+wstring				C_4JProfile::GetDisplayName(int iPad){ return L"PlayerName"; }
 #endif
 bool				C_4JProfile::IsFullVersion() { return s_bProfileIsFullVersion; }
 void				C_4JProfile::SetSignInChangeCallback(void ( *Func)(LPVOID, bool, unsigned int),LPVOID lpParam) {}

Minecraft.Client/Minecraft.Client.vcxproj

@@ -1201,7 +1201,7 @@ if not exist "$(TargetDir)\savedata" mkdir "$(TargetDir)\savedata"</Command>
       <BufferSecurityCheck>false</BufferSecurityCheck>
       <PrecompiledHeaderOutputFile>$(OutDir)$(ProjectName).pch</PrecompiledHeaderOutputFile>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PreprocessorDefinitions>_DISABLE_PSN;_DEBUG_MENUS_ENABLED;_ITERATOR_DEBUG_LEVEL=0;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG_MENUS_ENABLED;_ITERATOR_DEBUG_LEVEL=0;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <CallAttributedProfiling>Disabled</CallAttributedProfiling>
       <AdditionalIncludeDirectories>PS3\Iggy\include;$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
@@ -1570,7 +1570,7 @@ xcopy /q /y /i /s /e $(ProjectDir)DurangoMedia\CU  $(LayoutDir)Image\Loose\CU</C
       <BufferSecurityCheck>false</BufferSecurityCheck>
       <PrecompiledHeaderOutputFile>$(OutDir)$(ProjectName).pch</PrecompiledHeaderOutputFile>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PreprocessorDefinitions>_DEBUG_MENUS_ENABLED;_CRT_NON_CONFORMING_SWPRINTFS;_CRT_SECURE_NO_WARNINGS;_WINDOWS64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_LARGE_WORLDS;_DEBUG_MENUS_ENABLED;_CRT_NON_CONFORMING_SWPRINTFS;_CRT_SECURE_NO_WARNINGS;_WINDOWS64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <CallAttributedProfiling>Disabled</CallAttributedProfiling>
       <AdditionalIncludeDirectories>Windows64\Iggy\include;$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
@@ -4971,6 +4971,8 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
     <ClInclude Include="BubbleParticle.h" />
     <ClInclude Include="BufferedImage.h" />
     <ClInclude Include="Button.h" />
+    <ClInclude Include="Cafe\WiiU_App.h" />
+    <ClInclude Include="Cafe\WiiU_Minecraft.h" />
     <ClInclude Include="Camera.h" />
     <ClInclude Include="CaveSpiderRenderer.h" />
     <ClInclude Include="ChatScreen.h" />
@@ -5102,7 +5104,6 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|Win32'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
     </ClInclude>
     <ClInclude Include="Common\Network\GameNetworkManager.h" />
     <ClInclude Include="Common\Network\NetworkPlayerInterface.h" />
@@ -5125,7 +5126,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseForArt|PSVita'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PSVita'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PSVita'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PSVita'">true</ExcludedFromBuild>
@@ -5193,7 +5194,6 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|PSVita'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
     </ClInclude>
     <ClInclude Include="Common\Network\Sony\SonyCommerce.h">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Durango'">true</ExcludedFromBuild>
@@ -5335,9 +5335,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|PSVita'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">false</ExcludedFromBuild>
     </ClInclude>
-    <ClInclude Include="Common\Network\WinsockNetLayer.h" />
     <ClInclude Include="Common\Potion_Macros.h" />
     <ClInclude Include="Common\Telemetry\TelemetryManager.h" />
     <ClInclude Include="Common\Trial\TrialMode.h" />
@@ -20026,7 +20024,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_NO_TU|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseForArt|PS3'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|PS3'">true</ExcludedFromBuild>
@@ -25119,6 +25117,8 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
     <ClCompile Include="BubbleParticle.cpp" />
     <ClCompile Include="BufferedImage.cpp" />
     <ClCompile Include="Button.cpp" />
+    <ClCompile Include="Cafe\WiiU_App.cpp" />
+    <ClCompile Include="Cafe\WiiU_Minecraft.cpp" />
     <ClCompile Include="Camera.cpp" />
     <ClCompile Include="CaveSpiderRenderer.cpp" />
     <ClCompile Include="ChatScreen.cpp" />
@@ -25266,7 +25266,6 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Durango'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Durango'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|Durango'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="Common\Network\GameNetworkManager.cpp" />
     <ClCompile Include="Common\Network\PlatformNetworkManagerStub.cpp">
@@ -25287,7 +25286,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseForArt|PSVita'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PSVita'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PSVita'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PSVita'">true</ExcludedFromBuild>
@@ -25354,7 +25353,6 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|PSVita'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="Common\Network\Sony\SonyHttp.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Durango'">true</ExcludedFromBuild>
@@ -25495,9 +25493,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PSVita'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|PSVita'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">false</ExcludedFromBuild>
     </ClCompile>
-    <ClCompile Include="Common\Network\WinsockNetLayer.cpp" />
     <ClCompile Include="Common\Telemetry\TelemetryManager.cpp" />
     <ClCompile Include="Common\Trial\TrialMode.cpp" />
     <ClCompile Include="Common\Tutorial\AreaConstraint.cpp" />
@@ -34412,7 +34408,7 @@ xcopy /q /y /i /s /e $(ProjectDir)Durango\CU  $(LayoutDir)Image\Loose\CU</Comman
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_NO_TU|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseForArt|PS3'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ContentPackage_Vita|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|PS3'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='CONTENTPACKAGE_SYMBOLS|PS3'">true</ExcludedFromBuild>

Minecraft.Client/Minecraft.Client.vcxproj.filters

@@ -726,6 +726,9 @@
     <Filter Include="net\minecraft\client\resources">
       <UniqueIdentifier>{889a84db-3009-4a7c-8234-4bf93d412690}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Cafe">
+      <UniqueIdentifier>{0956a505-3070-4d85-b25b-8731cee48587}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <None Include="ReadMe.txt" />
@@ -3775,8 +3778,11 @@
     <ClInclude Include="PSVita\OldSdk.h">
       <Filter>PSVita</Filter>
     </ClInclude>
-    <ClInclude Include="Common\Network\WinsockNetLayer.h">
-      <Filter>Common\Source Files\Network</Filter>
+    <ClInclude Include="Cafe\WiiU_App.h">
+      <Filter>Cafe</Filter>
+    </ClInclude>
+    <ClInclude Include="Cafe\WiiU_Minecraft.h">
+      <Filter>Cafe</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
@@ -5922,8 +5928,11 @@
     <ClCompile Include="PSVita\OldSdk.cpp">
       <Filter>PSVita</Filter>
     </ClCompile>
-    <ClCompile Include="Common\Network\WinsockNetLayer.cpp">
-      <Filter>Common\Source Files\Network</Filter>
+    <ClCompile Include="Cafe\WiiU_App.cpp">
+      <Filter>Cafe</Filter>
+    </ClCompile>
+    <ClCompile Include="Cafe\WiiU_Minecraft.cpp">
+      <Filter>Cafe</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>

Minecraft.Client/Minecraft.cpp

@@ -3966,7 +3966,6 @@ void Minecraft::releaseLevel(int message)
 // time when exiting from an online game
 void Minecraft::forceStatsSave(int idx)
 {
-#ifndef DISABLE_PSN
 	//4J Gordon: Force a stats save
 	stats[idx]->save(idx, true);
 
@@ -3978,7 +3977,6 @@ void Minecraft::forceStatsSave(int idx)
 		stats[idx]->saveLeaderboards();
 		ProfileManager.SetLockedProfile(tempLockedProfile);
 	}
-#endif
 }
 
 // 4J Added

Minecraft.Client/Options.cpp

@@ -116,11 +116,7 @@ void Options::init()
     bobView = true;
     anaglyph3d = false;
     advancedOpengl = false;
-#ifdef _WINDOWS64
     framerateLimit = 0;
-#else
-	framerateLimit = 2;
-#endif
     fancyGraphics = true;
     ambientOcclusion = true;
 	renderClouds = true;

Minecraft.Client/PS3/Network/SQRNetworkManager_PS3.cpp

@@ -1,6 +1,4 @@
 #include "stdafx.h"
-
-#ifndef DISABLE_PSN
 #include "SQRNetworkManager_PS3.h"
 #include "Common/Network/Sony/SQRNetworkPlayer.h"
 #ifdef __PS3__
@@ -3623,5 +3621,4 @@ int SQRNetworkManager_PS3::GetJoiningReadyPercentage()
 	{
 		return 100;
 	}
-}
-#endif
+}

Minecraft.Client/PS3/Network/SonyCommerce_PS3.cpp

@@ -1,13 +1,5 @@
 #include "stdafx.h"
 
-#ifdef DISABLE_PSN
-// global func, so we can call from the profile lib
-void SonyCommerce_UpgradeTrial()
-{
-	// we're now calling the app function here, which manages pending requests
-	app.UpgradeTrial();
-}
-#else
 #include "SonyCommerce_PS3.h"
 #include "..\PS3Extras\ShutdownManager.h"
 #include <sys/event.h>
@@ -1519,4 +1511,3 @@ void SonyCommerce_PS3::DownloadAlreadyPurchased( CallbackFunc cb, LPVOID lpParam
 
 
 
-#endif

Minecraft.Client/PS3/Network/SonyVoiceChat.cpp

@@ -1,5 +1,5 @@
 #include "stdafx.h"
-#ifndef DISABLE_PSN
+
 
 
 
@@ -762,4 +762,3 @@ void SonyVoiceChat::setState( EAVCState state )
 	sm_state = state;
 	printStateAndEvent();
 }
-#endif

Minecraft.Client/PS3/Network/SonyVoiceChat.h

@@ -1,5 +1,5 @@
 #pragma once
-#ifndef _DISABLE_PSN
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -154,5 +154,4 @@ private:
 	static void printStateAndEvent();
 
 
-};
-#endif
+};

Minecraft.Client/PS3/PS3_App.cpp

@@ -10,9 +10,7 @@
 #include "..\..\Minecraft.World\LevelSettings.h"
 #include "..\..\Minecraft.World\BiomeSource.h"
 #include "..\..\Minecraft.World\LevelType.h"
-#ifndef DISABLE_PSN
 #include "..\..\PS3\Network\SonyCommerce_PS3.h"
-#endif
 #include "..\..\Minecraft.World\StringHelpers.h"
 #include "PS3Extras\ShutdownManager.h"
 #include "PS3\Network\SonyRemoteStorage_PS3.h"
@@ -562,7 +560,6 @@ void CConsoleMinecraftApp::TemporaryCreateGameStart()
 
 void CConsoleMinecraftApp::CommerceInit()
 {
-#ifndef DISABLE_PSN
 	m_bCommerceCategoriesRetrieved=false;
 	m_bCommerceProductListRetrieved=false;
 	m_bCommerceInitialised=false;
@@ -575,12 +572,10 @@ void CConsoleMinecraftApp::CommerceInit()
 	m_iCurrentCategory=0;
 	m_iCurrentProduct=0;
 	memset(m_pchSkuID,0,48);
-#endif
 }
 
 void CConsoleMinecraftApp::CommerceTick()
 {
-#ifndef DISABLE_PSN
 	// only tick this if the primary user is signed in to the PSN
 	if(ProfileManager.IsSignedInLive(0))
 	{
@@ -700,7 +695,6 @@ void CConsoleMinecraftApp::CommerceTick()
 		}
 	}
 	else
-#endif
 	{
 		// was the primary player signed in and is now signed out?
 		if(m_eCommerce_State!=eCommerce_State_Offline)

Minecraft.Client/PS3/PS3_Minecraft.cpp

@@ -24,7 +24,6 @@ SYS_PROCESS_PARAM(1001, 0x10000);  // thread priority, and stack size
 #include <sysutil/sysutil_msgdialog.h>
 
 #include "PS3/Network/SonyRemoteStorage_PS3.h"
-#include "..\..\Minecraft.Client\Common\Network\WinsockNetLayer.h"
 
 // define to use spurs (otherwise SPU threads or raw will be used)
 #define USE_SPURS
@@ -36,9 +35,6 @@ SYS_PROCESS_PARAM(1001, 0x10000);  // thread priority, and stack size
 #include <sys/spu_image.h>
 #endif
 
-#ifdef DISABLE_PSN
-#include "../Passphrase/ps3__np_conf.h"
-#endif
 /* Encrypted ID for protected data file (*) You must edit these binaries!! */
 char secureFileId[CELL_SAVEDATA_SECUREFILEID_SIZE] = 
 {
@@ -523,9 +519,7 @@ void RegisterAwardsWithProfileManager()
 	// Rich Presence init - number of presences, number of contexts
 	//printf("Rich presence strings are hard coded on PS3 for now, must change this!\n");
 	ProfileManager.RichPresenceInit(-1,-1); // 4J-JEV - Presence and Context count not used.
-#ifndef DISABLE_PSN
 	ProfileManager.SetRichPresenceSettingFn(SQRNetworkManager_PS3::SetRichPresence);
-#endif
 	char *pchRichPresenceString;
 
 	pchRichPresenceString=(char *)AddRichPresenceString(IDS_RICHPRESENCE_GAMESTATE);
@@ -861,9 +855,7 @@ int main()
 
 	app.CommerceInit(); //  MGH - moved this here so GetCommerce isn't NULL
 	// 4J-PB - Kick of the check for trial or full version - requires ui to be initialised
-#ifndef DISABLE_PSN
 	app.GetCommerce()->CheckForTrialUpgradeKey();
-#endif
 
 	static bool bTrialTimerDisplayed=true;
 
@@ -896,13 +888,8 @@ int main()
 
 
 	// Initialise the profile manager with the game Title ID, Offer ID, a profile version number, and the number of profile values and settings
-#ifndef DISABLE_PSN	
 	ProfileManager.Initialise(SQRNetworkManager_PS3::GetSceNpCommsId(),
 		SQRNetworkManager_PS3::GetSceNpCommsSig(),
-#else
-	ProfileManager.Initialise(&s_npCommunicationId,
-		&s_npCommunicationSignature,
-#endif
 		PROFILE_VERSION_10,
 		NUM_PROFILE_VALUES,
 		NUM_PROFILE_SETTINGS,
@@ -1129,7 +1116,6 @@ int main()
 	if(ShutdownManager::ShouldRun(ShutdownManager::eMainThread))
 	{
 		g_NetworkManager.Initialise();
-		WinsockNetLayer::Initialize();
 		g_NetworkManager.SetLocalGame(true);
 	}
 

Minecraft.Client/PS3/PS3_PlayerUID.h

@@ -2,7 +2,6 @@
 
 
 #pragma once
-//#include "stdafx.h"
 
 
 // Note - there are now 3 types of PlayerUID
@@ -20,7 +19,6 @@ class PlayerUID
 	CellSysutilUserId	m_userID;		// user logged on to the XMB
 
 public:
-	ULONGLONG XUID;
 
 	class Hash 
 	{
@@ -31,8 +29,6 @@ public:
 	PlayerUID();
 	PlayerUID(CellSysutilUserId userID, SceNpOnlineId& onlineID, bool bSignedInPSN, int quadrant);
 	PlayerUID(std::wstring fromString);
-	PlayerUID(ULONGLONG xuid) { XUID = xuid; }
-	operator ULONGLONG() const { return XUID; }
 
 	bool operator==(const PlayerUID& rhs) const;
 	bool operator!=(const PlayerUID& rhs);

Minecraft.Client/PendingConnection.cpp

@@ -157,7 +157,6 @@ void PendingConnection::handleLogin(shared_ptr<LoginPacket> packet)
 
 	//if (true)// 4J removed !server->onlineMode)
 	bool sentDisconnect = false;
-	bool nameTaken = false;
 
 	if( sentDisconnect )
 	{
@@ -169,29 +168,7 @@ void PendingConnection::handleLogin(shared_ptr<LoginPacket> packet)
 	}
 	else
 	{
-		vector<shared_ptr<ServerPlayer> > &pl = server->getPlayers()->players;
-
-		for (unsigned int i = 0; i < pl.size(); i++)
-		{
-			if (pl[i] != NULL && pl[i]->name == name)
-			{
-				nameTaken = true;
-				break;
-			}
-		}
-
-		if (nameTaken)
-		{
-			app.DebugPrintf("Rejecting duplicate name: %ls\n", name.c_str());
-
-			// to do: replace this with a dedicated duplicate name
-			// message
-			disconnect(DisconnectPacket::eDisconnect_Banned);
-		}
-		else
-		{
-			handleAcceptedLogin(packet);
-		}
+		handleAcceptedLogin(packet);
 	}
 	//else
 	{

Minecraft.Client/PlayerList.cpp

@@ -25,9 +25,9 @@
 #include "..\Minecraft.World\net.minecraft.world.level.saveddata.h"
 #include "..\Minecraft.World\JavaMath.h"
 #include "..\Minecraft.World\EntityIO.h"
-#if defined(_XBOX) || defined(_WINDOWS64) || defined(DISABLE_PSN)
+#ifdef _XBOX
 #include "Xbox\Network\NetworkPlayerXbox.h"
-#elif !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__)
+#elif defined(__PS3__) || defined(__ORBIS__)
 #include "Common\Network\Sony\NetworkPlayerSony.h"
 #endif
 
@@ -53,11 +53,7 @@ PlayerList::PlayerList(MinecraftServer *server)
 
 	//int viewDistance = server->settings->getInt(L"view-distance", 10);
 
-#ifdef _WINDOWS64
-    maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
-#else
 	maxPlayers = server->settings->getInt(L"max-players", 20);
-#endif
 	doWhiteList = false;
 
 	InitializeCriticalSection(&m_kickPlayersCS);
@@ -94,7 +90,7 @@ void PlayerList::placeNewPlayer(Connection *connection, shared_ptr<ServerPlayer>
 		player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_HOST,1);
 	}
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__)
+#if defined(__PS3__) || defined(__ORBIS__)
 	// PS3 networking library doesn't automatically assign PlayerUIDs to the network players for anything remote, so need to tell it what to set from the data in this packet now
 	if( !g_NetworkManager.IsLocalGame() )
 	{
@@ -103,13 +99,6 @@ void PlayerList::placeNewPlayer(Connection *connection, shared_ptr<ServerPlayer>
 			((NetworkPlayerSony *)networkPlayer)->SetUID( packet->m_onlineXuid );
 		}
 	}
-#elif defined(_WINDOWS64) || defined(DISABLE_PSN)
-	if (networkPlayer != NULL && !networkPlayer->IsLocal())
-	{
-		NetworkPlayerXbox *nxp = (NetworkPlayerXbox *)networkPlayer;
-		IQNetPlayer *qnp = nxp->GetQNetPlayer();
-		wcsncpy(qnp->m_gamertag, player->name.c_str(), 32);
-	}
 #endif
 
 	// 4J Stu - TU-1 hotfix
@@ -480,7 +469,6 @@ void PlayerList::remove(shared_ptr<ServerPlayer> player)
 	//4J Stu - We don't want to save the map data for guests, so when we are sure that the player is gone delete the map
 	if(player->isGuest()) playerIo->deleteMapFilesForPlayer(player);
 	ServerLevel *level = player->getLevel();
-	level->getTracker()->removeEntity(player);
 	if (player->riding != NULL)
 	{
 		// remove mount first because the player unmounts when being
@@ -509,7 +497,7 @@ void PlayerList::remove(shared_ptr<ServerPlayer> player)
 
 shared_ptr<ServerPlayer> PlayerList::getPlayerForLogin(PendingConnection *pendingConnection, const wstring& userName, PlayerUID xuid, PlayerUID onlineXuid)
 {
-	if (players.size() >= (unsigned int)MINECRAFT_NET_MAX_PLAYERS)
+	if (players.size() >= maxPlayers)
 	{
 		pendingConnection->disconnect(DisconnectPacket::eDisconnect_ServerFull);
 		return shared_ptr<ServerPlayer>();
@@ -522,14 +510,9 @@ shared_ptr<ServerPlayer> PlayerList::getPlayerForLogin(PendingConnection *pendin
 
 	// Work out the base server player settings
 	INetworkPlayer *networkPlayer = pendingConnection->connection->getSocket()->getPlayer();
-	if (networkPlayer != NULL)
+	if(networkPlayer != NULL && !networkPlayer->IsHost())
 	{
-		if (!networkPlayer->IsHost())
-			player->enableAllPlayerPrivileges( app.GetGameHostOption(eGameHostOption_TrustPlayers)>0 );
-
-		PlayerUID realXuid = networkPlayer->GetUID();
-		player->setXuid(realXuid);
-		player->setOnlineXuid(realXuid);
+		player->enableAllPlayerPrivileges( app.GetGameHostOption(eGameHostOption_TrustPlayers)>0 );
 	}
 
 	// 4J Added

Minecraft.Client/Tesselator.cpp

@@ -832,7 +832,7 @@ void Tesselator::vertex(float x, float y, float z)
 		pShortData[5] = (((int)(v * 8192.0f))&0xffff);
 		int16_t u2 = ((int16_t*)&_tex2)[0];
 		int16_t v2 = ((int16_t*)&_tex2)[1];
-#if defined _XBOX_ONE || defined __ORBIS__
+#if defined _XBOX_ONE || defined __ORBIS__ || defined _WINDOWS64
 		// Optimisation - pack the second UVs into a single short (they could actually go in a byte), which frees up a short to store the x offset for this chunk in the vertex itself.
 		// This means that when rendering chunks, we don't need to update the vertex constants that specify the location for a chunk, when only the x offset has changed.
 		pShortData[6] = ( u2 << 8 ) | v2;

Minecraft.Client/Windows64/Windows64_App.cpp

@@ -55,8 +55,7 @@ void CConsoleMinecraftApp::TemporaryCreateGameStart()
 	Minecraft *pMinecraft=Minecraft::GetInstance();
 	app.ReleaseSaveThumbnail();
 	ProfileManager.SetLockedProfile(0);
-	extern wchar_t g_Win64UsernameW[17];
-	pMinecraft->user->name = g_Win64UsernameW;
+	pMinecraft->user->name = L"Windows";
 	app.ApplyGameSettingsChanged(0);
 
 	////////////////////////////////////////////////////////////////////////////////////////////// From CScene_MultiGameJoinLoad::OnInit

Minecraft.Client/Windows64/Windows64_Minecraft.cpp

@@ -36,7 +36,6 @@
 #include "Resource.h"
 #include "..\..\Minecraft.World\compression.h"
 #include "..\..\Minecraft.World\OldChunkStorage.h"
-#include "..\..\Minecraft.Client\Common\Network\WinsockNetLayer.h"
 
 #include "Xbox/resource.h"
 
@@ -69,9 +68,6 @@ DWORD dwProfileSettingsA[NUM_PROFILE_VALUES]=
 #endif
 };
 
-char g_Win64Username[17] = {0};
-wchar_t g_Win64UsernameW[17] = {0};
-
 //-------------------------------------------------------------------------------------
 // Time             Since fAppTime is a float, we need to keep the quadword app time
 //                  as a LARGE_INTEGER so that we don't lose precision after running
@@ -80,8 +76,8 @@ wchar_t g_Win64UsernameW[17] = {0};
 
 BOOL g_bWidescreen = TRUE;
 
-int g_iScreenWidth = 1280;
-int g_iScreenHeight = 720;
+int g_iScreenWidth = 1920;
+int g_iScreenHeight = 1080;
 
 void DefineActions(void)
 {
@@ -633,58 +629,8 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 			//g_iScreenWidth = 960;
 			//g_iScreenHeight = 544;
 		}
-
-		char cmdLineA[1024];
-		strncpy_s(cmdLineA, sizeof(cmdLineA), lpCmdLine, _TRUNCATE);
-
-		char *nameArg = strstr(cmdLineA, "-name ");
-		if (nameArg)
-		{
-			nameArg += 6;
-			while (*nameArg == ' ') nameArg++;
-			char nameBuf[17];
-			int n = 0;
-			while (nameArg[n] && nameArg[n] != ' ' && n < 16) { nameBuf[n] = nameArg[n]; n++; }
-			nameBuf[n] = 0;
-			strncpy_s(g_Win64Username, 17, nameBuf, _TRUNCATE);
-		}
-
-		char *ipArg = strstr(cmdLineA, "-ip ");
-		if (ipArg)
-		{
-			ipArg += 4;
-			while (*ipArg == ' ') ipArg++;
-			char ipBuf[256];
-			int n = 0;
-			while (ipArg[n] && ipArg[n] != ' ' && n < 255) { ipBuf[n] = ipArg[n]; n++; }
-			ipBuf[n] = 0;
-			strncpy_s(g_Win64MultiplayerIP, 256, ipBuf, _TRUNCATE);
-			g_Win64MultiplayerJoin = true;
-		}
-
-		char *portArg = strstr(cmdLineA, "-port ");
-		if (portArg)
-		{
-			portArg += 6;
-			while (*portArg == ' ') portArg++;
-			char portBuf[16];
-			int n = 0;
-			while (portArg[n] && portArg[n] != ' ' && n < 15) { portBuf[n] = portArg[n]; n++; }
-			portBuf[n] = 0;
-			g_Win64MultiplayerPort = atoi(portBuf);
-			if (g_Win64MultiplayerPort <= 0) g_Win64MultiplayerPort = WIN64_NET_DEFAULT_PORT;
-		}
 	}
 
-	if (g_Win64Username[0] == 0)
-	{
-		DWORD sz = 17;
-		if (!GetUserNameA(g_Win64Username, &sz))
-			strncpy_s(g_Win64Username, 17, "Player", _TRUNCATE);
-		g_Win64Username[16] = 0;
-	}
-
-	MultiByteToWideChar(CP_ACP, 0, g_Win64Username, -1, g_Win64UsernameW, 17);
 
 	// Initialize global strings
 	MyRegisterClass(hInstance);
@@ -847,17 +793,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 	// ProfileManager for XN_LIVE_INVITE_ACCEPTED for QNet.
 	g_NetworkManager.Initialise();
 
-	for (int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; i++)
-	{
-		IQNet::m_player[i].m_smallId = (BYTE)i;
-		IQNet::m_player[i].m_isRemote = false;
-		IQNet::m_player[i].m_isHostPlayer = (i == 0);
-		swprintf_s(IQNet::m_player[i].m_gamertag, 32, L"Player%d", i);
-	}
-	extern wchar_t g_Win64UsernameW[17];
-	wcscpy_s(IQNet::m_player[0].m_gamertag, 32, g_Win64UsernameW);
 
-	WinsockNetLayer::Initialize();
 
 	// 4J-PB moved further down
 	//app.InitGameSettings();
@@ -1001,9 +937,6 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		// 			app.audio.PlaySound();
 		// 		}
 
-		bool isActive = (GetForegroundWindow() == g_hWnd) &&
-                !IsIconic(g_hWnd);
-
 		app.UpdateTime();
 		PIXBeginNamedEvent(0,"Input manager tick");
 		InputManager.Tick();
@@ -1031,7 +964,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		PIXEndNamedEvent();
 
 		PIXBeginNamedEvent(0,"Network manager do work #1");
-		g_NetworkManager.DoWork();
+		//		g_NetworkManager.DoWork();
 		PIXEndNamedEvent();
 
 		//		LeaderboardManager::Instance()->Tick();

Minecraft.World/Boat.cpp

@@ -48,35 +48,6 @@ bool Boat::makeStepSound()
 	return false;
 }
 
-void Boat::checkFallDamage(int result, int onGround, double ya)
-{
-	if (fallDistance <= 3.0) return;
-
-	if ( !onGround )
-	{
-		int t = level->getTile(x, (floor(y) - 1.0), z);
-		if ((!t || Tile::tiles[t]->material != Material::water) && ya < 0.0 )
-			fallDistance -= ya;
-
-		return;
-	}
-	causeFallDamage(fallDistance);
-	if (!level->isClientSide && !removed)
-	{
-		remove();
-		for (int i = 0; i < 3; i++)
-		{
-			spawnAtLocation(Tile::wood_Id, 1, 0);
-		}
-		for (int i = 0; i < 2; i++)
-		{
-			spawnAtLocation(Item::stick->id, 1, 0);
-		}
-	}
-
-	fallDistance = 0.0;
-}
-
 void Boat::defineSynchedData()
 {
 	entityData->define(DATA_ID_HURT, 0);

Minecraft.World/Boat.h

@@ -36,7 +36,6 @@ public:
 	Boat(Level *level);
 
 protected:
-	virtual void checkFallDamage(int result, int onGround, double ya);
 	virtual bool makeStepSound();
 	virtual void defineSynchedData();
 

Minecraft.World/ConsoleSaveFile.h

@@ -30,7 +30,7 @@ public:
 	virtual vector<FileEntry *> *getFilesWithPrefix(const wstring &prefix) = 0;
 	virtual vector<FileEntry *> *getRegionFilesByDimension(unsigned int dimensionIndex) = 0;
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	virtual wstring getPlayerDataFilenameForLoad(const PlayerUID& pUID) = 0;
 	virtual wstring getPlayerDataFilenameForSave(const PlayerUID& pUID) = 0;
 	virtual vector<FileEntry *> *getValidPlayerDatFiles() = 0;

Minecraft.World/ConsoleSaveFileConverter.cpp

@@ -78,7 +78,7 @@ void ConsoleSaveFileConverter::ConvertSave(ConsoleSaveFile *sourceSave, ConsoleS
 	}
 
 	// MGH added - find any player data files and copy them across
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	vector<FileEntry *>* playerFiles = sourceSave->getValidPlayerDatFiles();
 #else
 	vector<FileEntry *> *playerFiles = sourceSave->getFilesWithPrefix( DirectoryLevelStorage::getPlayerDir() );

Minecraft.World/ConsoleSaveFileOriginal.cpp

@@ -920,7 +920,7 @@ vector<FileEntry *> *ConsoleSaveFileOriginal::getRegionFilesByDimension(unsigned
 	return NULL;
 }
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 wstring ConsoleSaveFileOriginal::getPlayerDataFilenameForLoad(const PlayerUID& pUID)
 {
 	return header.getPlayerDataFilenameForLoad( pUID );

Minecraft.World/ConsoleSaveFileOriginal.h

@@ -65,7 +65,7 @@ public:
 	virtual vector<FileEntry *> *getFilesWithPrefix(const wstring &prefix);
 	virtual vector<FileEntry *> *getRegionFilesByDimension(unsigned int dimensionIndex);
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	virtual wstring getPlayerDataFilenameForLoad(const PlayerUID& pUID);
 	virtual wstring getPlayerDataFilenameForSave(const PlayerUID& pUID);
 	virtual vector<FileEntry *> *getValidPlayerDatFiles();

Minecraft.World/DataInputStream.cpp

@@ -519,7 +519,7 @@ int DataInputStream::readUTFChar()
 PlayerUID DataInputStream::readPlayerUID()
 {
 	PlayerUID returnValue;
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	for(int idPos=0;idPos<sizeof(PlayerUID); idPos++)
 		((char*)&returnValue)[idPos] = readByte();
 #elif defined(_DURANGO)

Minecraft.World/DataOutputStream.cpp

@@ -265,13 +265,11 @@ void DataOutputStream::writeUTF(const wstring& str)
 // 4J Added
 void DataOutputStream::writePlayerUID(PlayerUID player)
 {
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
 	for(int idPos=0;idPos<sizeof(PlayerUID); idPos++)
 		writeByte(((char*)&player)[idPos]);
 #elif defined(_DURANGO)
 	writeUTF(player.toString());
-#elif defined(DISABLE_PSN) && defined(__PS3__)
-	writeLong(player.XUID);
 #else
 	writeLong(player);
 #endif // PS3

Minecraft.World/DirectoryLevelStorage.cpp

@@ -393,7 +393,7 @@ void DirectoryLevelStorage::save(shared_ptr<Player> player)
 	{
 		CompoundTag *tag = new CompoundTag();
 		player->saveWithoutId(tag);
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 		ConsoleSavePath realFile = ConsoleSavePath( m_saveFile->getPlayerDataFilenameForSave(playerXuid).c_str() );
 #elif defined(_DURANGO)
 		ConsoleSavePath realFile = ConsoleSavePath( playerDir.getName() + player->getXuid().toString() + L".dat" );
@@ -442,7 +442,7 @@ CompoundTag *DirectoryLevelStorage::load(shared_ptr<Player> player)
 CompoundTag *DirectoryLevelStorage::loadPlayerDataTag(PlayerUID xuid)
 {
 	// 4J Jev, removed try/catch.
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	ConsoleSavePath realFile = ConsoleSavePath( m_saveFile->getPlayerDataFilenameForLoad(xuid).c_str() );
 #elif defined(_DURANGO)
 	ConsoleSavePath realFile = ConsoleSavePath( playerDir.getName() + xuid.toString() + L".dat" );
@@ -472,7 +472,7 @@ void DirectoryLevelStorage::clearOldPlayerFiles()
 {
 	if(StorageManager.GetSaveDisabled() ) return;
 
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 	vector<FileEntry *> *playerFiles = m_saveFile->getValidPlayerDatFiles();
 #else
 	vector<FileEntry *> *playerFiles = m_saveFile->getFilesWithPrefix( playerDir.getName() );
@@ -561,7 +561,7 @@ void DirectoryLevelStorage::resetNetherPlayerPositions()
 {
 	if(app.GetResetNether())
 	{
-#if !defined(DISABLE_PSN) && defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
+#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
 		vector<FileEntry *> *playerFiles = m_saveFile->getValidPlayerDatFiles();
 #else
 		vector<FileEntry *> *playerFiles = m_saveFile->getFilesWithPrefix( playerDir.getName() );

Minecraft.World/Minecraft.World.vcxproj

@@ -1197,7 +1197,7 @@
       <BufferSecurityCheck>false</BufferSecurityCheck>
       <PrecompiledHeaderOutputFile>$(OutDir)$(ProjectName).pch</PrecompiledHeaderOutputFile>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PreprocessorDefinitions>_DEBUG_MENUS_ENABLED;_LIB;_CRT_NON_CONFORMING_SWPRINTFS;_CRT_SECURE_NO_WARNINGS;_WINDOWS64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_LARGE_WORLDS;_DEBUG_MENUS_ENABLED;_LIB;_CRT_NON_CONFORMING_SWPRINTFS;_CRT_SECURE_NO_WARNINGS;_WINDOWS64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <CallAttributedProfiling>Disabled</CallAttributedProfiling>
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <ShowIncludes>false</ShowIncludes>

Minecraft.World/Zombie.cpp

@@ -147,8 +147,6 @@ void Zombie::aiStep()
 		}
 	}
 	Monster::aiStep();
-	if (isBaby())
-		setSize(0.3f, 0.9f);
 }
 
 bool Zombie::hurt(DamageSource *source, float dmg)

Minecraft.World/compression.cpp

@@ -334,9 +334,8 @@ HRESULT Compression::Decompress(void *pDestination, unsigned int *pDestSize, voi
 	*pDestSize = (unsigned int)destSize;
 	return ( ( res == Z_OK ) ? S_OK : -1 );
 #elif defined __PS3__
-	uLongf destSize = (uLongf)(*pDestSize);
-	bool res = uncompress((Bytef*)pDestination, &destSize, (Bytef*)pSource, SrcSize);
-
+	uint32_t destSize = (uint32_t)(*pDestSize);
+	bool res = EdgeZLib::Decompress(pDestination, &destSize, pSource, SrcSize);
 	*pDestSize = (unsigned int)destSize;
 	return ( ( res ) ? S_OK : -1 );
 #else

Minecraft.World/x64headers/extraX64.h

@@ -11,10 +11,6 @@
 
 #define MULTITHREAD_ENABLE
 
-#ifdef __PS3__
-#define DISABLE_PSN
-#endif
-
 typedef unsigned char byte;
 
 const int XUSER_INDEX_ANY = 255;
@@ -46,15 +42,9 @@ typedef SQRNetworkManager_Orbis::PresenceSyncInfo INVITE_INFO;
 #include <assert.h>
 #include <stdlib.h>
 #include "..\..\Minecraft.Client\PS3\PS3_PlayerUID.h"
-
-#ifndef DISABLE_PSN
 #include "..\..\Minecraft.Client\PS3\Network\SQRNetworkManager_PS3.h"
 typedef SQRNetworkManager::SessionID SessionID;
 typedef SQRNetworkManager::PresenceSyncInfo INVITE_INFO;
-#else
-typedef ULONGLONG SessionID;
-class INVITE_INFO;
-#endif
 
 #elif defined __PSVITA__
 #include <np.h>
@@ -225,17 +215,10 @@ public:
 	int GetUserIndex();
 	void SetCustomDataValue(ULONG_PTR ulpCustomDataValue);
 	ULONG_PTR GetCustomDataValue();
-
-	BYTE m_smallId;
-	bool m_isRemote;
-	bool m_isHostPlayer;
-	wchar_t m_gamertag[32];
 private:
 	ULONG_PTR m_customData;
 };
 
-void Win64_SetupRemoteQNetPlayer(IQNetPlayer *player, BYTE smallId, bool isHost, bool isLocal);
-
 const int QNET_GETSENDQUEUESIZE_SECONDARY_TYPE = 0;
 const int QNET_GETSENDQUEUESIZE_MESSAGES = 0;
 const int QNET_GETSENDQUEUESIZE_BYTES = 0;
@@ -326,12 +309,9 @@ public:
 	bool IsHost();
 	HRESULT JoinGameFromInviteInfo(DWORD dwUserIndex, DWORD dwUserMask, const INVITE_INFO *pInviteInfo);
 	void HostGame();
-	void ClientJoinGame();
 	void EndGame();
 
-	static IQNetPlayer m_player[MINECRAFT_NET_MAX_PLAYERS];
-	static DWORD s_playerCount;
-	static bool s_isHosting;
+	static IQNetPlayer m_player[4];
 };
 
 #ifdef _DURANGO