mirror of
https://github.com/smartcmd/MinecraftConsoles.git
synced 2026-08-20 09:57:09 +00:00
79afded2ff
Adds the networking layer for non-host split-screen multiplayer, implements live window resize with swap chain recreation, fixes bitmap font scaling at small window sizes, and fixes several crash-causing bugs in the multiplayer stack (compression buffer overflow, TCP stream desync, chunk visibility race, CompressedTileStorage torn reads, reconnect stability). == Non-host split-screen multiplayer == Each split-screen pad on a non-host client opens its own TCP connection to the host. From the host's perspective each connection looks like a normal remote player (gets its own smallId, Socket, PlayerConnection). WinsockNetLayer: JoinSplitScreen(), CloseSplitScreenConnection(), SplitScreenRecvThreadProc, per-pad socket/thread/smallId tracking (s_splitScreenSocket[], s_splitScreenSmallId[], s_splitScreenRecvThread[]). GetLocalSocket() returns the correct TCP socket for a given local sender's smallId. GetSplitScreenSmallId() returns the host-assigned smallId for a pad. GameNetworkManager::CreateSocket: non-host path (localPlayer && !IsHost() && IsInGameplay()) calls JoinSplitScreen, sets the IQNet slot's smallId and resolvedXuid, creates a non-hostLocal Socket + ClientConnection, sends PreLoginPacket, registers via addPendingLocalConnection. PlatformNetworkManagerStub::RemoveLocalPlayerByUserIndex: implemented the formerly-empty stub. Calls NotifyPlayerLeaving, CloseSplitScreenConnection, and clears the IQNet slot fields so the pad can rejoin cleanly. SmallId pool: s_nextSmallId starts at XUSER_MAX_COUNT (4), reserving m_player[0-3] for local pads so remote players never collide. IQNetPlayer::SendData: non-host local senders now route through GetLocalSocket(m_smallId) instead of always using SendToSmallId. IQNet::GetLocalPlayerByUserIndex: rewritten. Pad 0 on non-host uses GetLocalSmallId() for direct lookup; pads 1-3 check m_player[padIdx]. C_4JProfile::IsSignedIn: pad 0 always returns true (was checking controller connection, which is unreliable on Win64). GetGamertag/GetDisplayName: for pads 1-3 with active local players, returns the pad-specific gamertag from IQNet::m_player instead of always returning the primary username. ClientConnection: isPrimaryConnection() (true on host or for the primary pad on non-host) guards relative-delta and world-modifying handlers to prevent double-processing of shared state: - Guarded: handleMoveEntity, handleMoveEntitySmall, handleChunkTilesUpdate, handleBlockRegionUpdate, handleTileUpdate, handleTakeItemEntity, handleSignUpdate, handleTileEntityData, handleTileEvent, handleTileDestruction, handleComplexItemData, handleLevelEvent, handleSoundEvent, handleParticleEvent, handleAddGlobalEntity. - handleSetEntityMotion: secondary connections only accept motion targeting their own local player (knockback). - handleExplosion: world modification (finalizeExplosion) guarded, per-player knockback unguarded. Added null check on localplayers[]. - Entity spawn/remove/teleport/data handlers left unguarded (putEntity is idempotent, absolute value setters). handleLogin: added else clause to set level when the dimension already exists (was leaving level NULL on reconnect). handleChunkVisibilityArea/handleChunkVisibility: added null check on level. handleContainerOpen: added null check on localplayers[m_userIndex]. == Reconnect stability == PendingConnection: duplicate XUID no longer rejects with eDisconnect_Banned. Instead it force-disconnects the stale old connection via stalePlayer->connection->disconnect(), queues the old smallId for recycling via queueSmallIdForRecycle(), then calls handleAcceptedLogin for the new connection. MinecraftServer: swapped tick order so players->tick() (disconnect queue) runs before connection->tick() (new logins). The old player is removed from PlayerList before the new LoginPacket's XUID check runs. PlayerList: PushFreeSmallId and ClearSocketForSmallId moved here from DoWork, called only after PlayerConnection::disconnect() completes and the read/write threads are dead. New queueSmallIdForRecycle() method lets PendingConnection push smallIds into m_smallIdsToClose, which PlayerList::tick() processes through closePlayerConnectionBySmallId() for deferred cleanup. Prevents a race where the old write thread could resolve getPlayer() to a recycled smallId's new connection and send stale packets on it. SocketInputStreamLocal::close() and SocketOutputStreamLocal::close() now actually clear their queues (std::swap with empty queue instead of calling .empty() which is a read-only no-op). ServerConnection::stop(): pending and players vectors are snapshot-copied before iterating (prevents iterator invalidation). Remote players receive a DisconnectPacket via disconnect(eDisconnect_Quitting) instead of raw close(). tick(): added else clause so flush() only runs on live connections. WinsockNetLayer::Shutdown(): accept thread stopped first (prevents new recv threads from spawning), then all recv threads are collected and waited on, then connections are closed and split-screen sockets cleaned up. Clears disconnect and free-pool vectors before deleting critical sections. WinsockNetLayer::JoinGame(): waits for old s_clientRecvThread to fully exit before creating a new TCP connection. Prevents the old recv thread from reading bytes off the new socket and desynchronizing the stream. == Compression buffer overflow == CompressLZXRLE and CompressRLE wrote RLE intermediate output into a fixed 100KB buffer with no bounds checking. Full chunk columns are ~160KB and the RLE step can expand 0xFF bytes to 2 bytes each, easily overflowing into rleDecompressBuf and heap metadata. This caused delayed crashes in unrelated code (Packet::readPacket, LevelRenderer::updateDirtyChunks) after the first autosave, since that's when full chunks get compressed. Fix: dynamic allocation when worst-case RLE output (SrcSize * 2) exceeds the static buffer. Static buffer still used for small inputs (zero overhead). CompressRLE: moved LeaveCriticalSection after dynamic buffer cleanup. DecompressLZXRLE: now checks zlib return value (was completely ignored). On failure, bails out immediately with *pDestSize = 0. Added RLE input bounds checking (pucIn >= pucEnd before reading count/data bytes) and output bounds checking (pucOut + count > pucOutEnd). Same bounds checks applied to DecompressRLE. == Stream desync (Connection write thread) == The write thread had two output paths to the same TCP socket: bufferedDos (5KB buffered stream) and direct sos->writeWithFlags(). Chunk data sent via queueSend() used the direct path with shouldDelay=true, while other packets used bufferedDos. If bufferedDos had unflushed bytes, the direct write arrived at the client first, reordering the TCP stream and producing bad packet ID crashes. Fix: flush bufferedDos immediately before every direct sos->writeWithFlags(). == Chunk visibility race (empty first chunk after 30s) == BlockRegionUpdatePacket (direct socket write via queueSend) could arrive at the client before ChunkVisibilityAreaPacket (buffered). The client called getChunk() on a chunk that didn't exist yet in the cache, got EmptyLevelChunk (whose setBlocksAndData is a no-op), and silently lost the block data. On superflat this left one invisible chunk; on normal worlds it crashed the renderer. Fix: handleBlockRegionUpdate calls dimensionLevel->setChunkVisible() for full-chunk BRUPs before writing data, making it independent of packet ordering. Added post-write verification logging. CompressedTileStorage race: get() reads indicesAndData twice without a lock. compress() can swap the pointer between reads, producing indices from the old buffer paired with data from the new buffer. Fix: snapshot indicesAndData into a local variable before deriving both pointers. Same snapshot pattern applied to getData() (non-Vita path), isRenderChunkEmpty(), getHighestNonEmptyY(), getAllocatedSize(), and write(). All methods now also guard against NULL snapshots. == Window resize == ResizeD3D() destroys the old swap chain, creates a new one at the target size, then patches InternalRenderManager members directly via memory offsets (0x20=swap chain, 0x28=RTV, 0x50=SRV, 0x98=DSV, 0x5138/0x513C= backbuffer width/height). Offset verification cross-checks known pointers (device at 0x10, swap chain at 0x20) before patching. Old RTV/SRV are intentionally leaked (orphaned with the old swap chain) to avoid fighting unknown ref holders in the precompiled RenderManager. The flow: Suspend RenderManager, ClearState+Flush, release views, gdraw_D3D11_PreReset, destroy old swap chain, create new swap chain via IDXGIFactory, patch offsets, recreate RTV/SRV/DSV, rebind render targets, update UIController (updateRenderTargets + updateScreenSize), gdraw_D3D11_PostReset + SetRendertargetSize, IggyFlushInstalledFonts, Resume, PostProcesser::Init. WM_SIZE handling defers resize during window drag (WM_ENTERSIZEMOVE/ WM_EXITSIZEMOVE). Immediate resizes (maximize, programmatic) call ResizeD3D directly. Removed the old UpdateAspectRatio() function. CleanupDevice() was leaking g_pDepthStencilView and g_pDepthStencilBuffer. InitDevice: swap chain BufferUsage now includes DXGI_USAGE_SHADER_INPUT (needed for the SRV created from the backbuffer for CaptureThumbnail). New globals: g_rScreenWidth/g_rScreenHeight (real window dimensions, updated on resize) vs g_iScreenWidth/g_iScreenHeight (fixed logical resolution, stays 1920x1080). ComputeViewportForPlayer and getFovAndAspect now use g_rScreenWidth/ g_rScreenHeight instead of the fixed startup values, so 3D perspective and split-screen viewports adapt to window size. Main loop: rendering skipped when window is minimized (IsIconic check) to avoid 100% GPU usage on a hidden swap chain. Windows64_UIController: new updateRenderTargets(rtv, dsv) method updates cached D3D pointers used by gdraw_D3D11_SetTileOrigin every frame. UIController.h: new inline updateScreenSize(w, h) sets m_fScreenWidth/ m_fScreenHeight so all downstream UI code picks up the new size. == Bitmap font scaling == At small window sizes, dynamic text (scrollable list items, HowToPlay pages) showed overlapping characters. Static SWF text was unaffected because it uses embedded vector glyphs. Root cause in UIBitmapFont.cpp GetGlyphBitmap: when display scale is smaller than the bitmap's native scale (pixel_scale < truePixelScale, glyphScale stays at 1), Iggy displayed the glyph at native 1:1 pixel size but advanced the cursor by the smaller display-scale amount. At intermediate window sizes (e.g. 1678x756, scale factor ~0.7), a second bug appeared: some SWF font sizes produced pixel_scale just above truePixelScale (13 for Mojangles_11) while others fell just below, splitting glyphs across the small-display and normal cache branches. The normal branch cached all glyphs in a single [truePixelScale, 99] range, so the first glyph cached set pixel_scale_correct for every subsequent request regardless of font size. Different font sizes then got scaled by wrong ratios (e.g. 18.9/13.3 = 1.42x with point sampling), producing visibly inconsistent letter sizes. This only happened at specific window sizes where the display scale put some fonts above and others below the truePixelScale boundary. Full 1080p and very small windows were unaffected because all fonts landed in the same branch. Fix: on _WINDOWS64, always use pixel_scale_correct = truePixelScale so every cache entry is consistent regardless of which font size creates it first. Two cache ranges: downscale (pixel_scale < truePixelScale) uses bilinear for smooth reduction, upscale uses point_sample for crisp pixel-art rendering. At most two cache entries per glyph. The console code path (fixed resolution, integer-multiple scaling) is preserved behind #else. UIScene.cpp loadMovie: always load 1080.swf on _WINDOWS64 regardless of window size. The old height-based selection could pick 480 or 720 variants which either crashed or loaded the wrong skin library (skinHD.swf vs skin.swf). Display size is now set via Fit16x9 BEFORE the init tick so Iggy's ActionScript text field creation sees the same scale that render() will use. IggyFlushInstalledFonts() called after init tick to clear stale glyph cache entries from previous scenes. Font.cpp addCharacterQuad/renderCharacter: yOff was computed with m_charWidth instead of m_charHeight, producing wrong texture coordinates for non-square glyph cells. This is the world-rendering font (chat, signs, name tags), not the Iggy UI font. == XUID generation == Split-screen pad XUIDs derived by hashing baseXuid + iPad through Mix64 (DeriveXuidForPad in Windows64_Xuid.h) instead of simple addition. Pad 0 returns the base XUID unchanged for save compatibility. Includes validity fallbacks if the hash produces an invalid XUID. (Suggested by rtm516) == Misc == Packet::readPacket: thread-local ring buffer tracks last 8 good packet IDs. On bad packet ID, dumps the history plus next 32 bytes of stream for diagnosing TCP desynchronization. PendingConnection/PlayerList: debug logging for the reconnect flow (duplicate XUID handling, force-disconnect, handleAcceptedLogin, placeNewPlayer with smallId/entityId/dimension). ClientConnection::handleBlockRegionUpdate: warning log when a full chunk arrives with ys==0 (empty full chunk, data loss indicator). == Known issues / future work == SendOnSocket global lock (WinsockNetLayer.cpp): s_sendLock is a single CriticalSection serializing ALL TCP sends across ALL connections. If one client's send() blocks (TCP window full, slow network), every other write thread stalls — no data flows to any player until the slow send completes. Each PlayerConnection has its own write thread, so with 8+ players one slow client can cause latency spikes or timeout disconnects for healthy players. Fix: replace s_sendLock with per-socket locks indexed by smallId. The lock only needs to prevent header+payload interleaving on the SAME socket; sends to different sockets are independent. Deferred to a separate PR to keep this one focused. Textures::releaseTexture: early return for id <= 0, checks TextureGetTexture(id) != NULL before calling glDeleteTextures. Prevents crashes on stale texture IDs after RenderManager reset. UIController TextureSubstitutionDestroyCallback: null guard on Minecraft::GetInstance() and mc->textures before calling releaseTexture. Prevents crash during shutdown. StringTable: removed __debugbreak() on language load failure in debug builds. |
||
|---|---|---|
| .github | ||
| .vscode | ||
| cmake | ||
| Minecraft.Client | ||
| Minecraft.World | ||
| x64 | ||
| .clang-format | ||
| .clang-tidy | ||
| .gitignore | ||
| CMakeLists.txt | ||
| COMPILE.md | ||
| CONTRIBUTING.md | ||
| MinecraftConsoles.sln | ||
| README.md | ||
MinecraftConsoles
Introduction
This project contains the source code of Minecraft Legacy Console Edition v1.6.0560.0 (TU19) from https://archive.org/details/minecraft-legacy-console-edition-source-code, with some fixes and improvements applied.
Download
Windows users can download our Nightly Build! Simply download the .zip file and extract it to a folder where you'd like to keep the game. You can set your username in username.txt (you'll have to make this file) and add servers to connect to in servers.txt
Platform Support
- Windows: Supported for building and running the project
- macOS / Linux: The Windows nightly build may run through Wine or CrossOver based on community reports, but this is unofficial and not currently tested by the maintainers
Features
- Fixed compilation and execution in both Debug and Release mode on Windows using Visual Studio 2022
- Added support for keyboard and mouse input
- Added fullscreen mode support (toggle using F11)
- (WIP) Disabled V-Sync for better performance
- Added a high-resolution timer path on Windows for smoother high-FPS gameplay timing
- Device's screen resolution will be used as the game resolution instead of using a fixed resolution (1920x1080)
- LAN Multiplayer & Discovery
- Added persistent username system via "username.txt"
Multiplayer
Basic LAN multiplayer is available on the Windows build
- Hosting a multiplayer world automatically advertises it on the local network
- Other players on the same LAN can discover the session from the in-game Join Game menu
- Game connections use TCP port
25565by default - LAN discovery uses UDP port
25566 - Add servers to your server list with
servers.txt(temp solution) - Rename yourself without losing data by keeping your
uid.dat
Parts of this feature are based on code from LCEMP (thanks!)
servers.txt
To add a server to your game, create the servers.txt file in the same directory as you have Minecraft.Client.exe. Inside, follow this format:
serverip.example.com
25565
The name of your server in UI!
For example, here's a valid servers.txt
1.1.1.1
25565
Cloudflare's Very Own LCE Server
127.0.0.1
25565
Localhost Test Crap
Launch Arguments
| Argument | Description |
|---|---|
-name <username> |
Sets your in-game username. |
-fullscreen |
Launches the game in Fullscreen mode |
Example:
Minecraft.Client.exe -name Steve -fullscreen
Controls (Keyboard & Mouse)
- Movement:
WASD - Jump / Fly (Up):
Space - Sneak / Fly (Down):
Shift(Hold) - Sprint:
Ctrl(Hold) or Double-tapW - Inventory:
E - Chat:
T - Drop Item:
Q - Crafting:
CUseQandEto move through tabs (cycles Left/Right) - Toggle View (FPS/TPS):
F5 - Fullscreen:
F11 - Pause Menu:
Esc - Attack / Destroy:
Left Click - Use / Place:
Right Click - Select Item:
Mouse Wheelor keys1to9 - Accept or Decline Tutorial hints:
Enterto accept andBto decline - Game Info (Player list and Host Options):
TAB - Toggle HUD:
F1 - Toggle Debug Info:
F3 - Open Debug Overlay:
F4 - Toggle Debug Console:
F6
Build & Run
- Install Visual Studio 2022.
- Clone the repository.
- Open the project by double-clicking
MinecraftConsoles.sln. - Make sure
Minecraft.Clientis set as the Startup Project. - Set the build configuration to Debug (Release is also OK but has some bugs) and the target platform to Windows64, then build and run.
CMake (Windows x64)
cmake -S . -B build -G "Visual Studio 17 2022" -A x64
cmake --build build --config Debug --target MinecraftClient
For more information, see COMPILE.md.
Known Issues
- Native builds for platforms other than Windows have not been tested and are most likely non-functional. The Windows nightly build may still run on macOS and Linux through Wine or CrossOver, but that path is unofficial and not currently supported
Contributors
Would you like to contribute to this project? Please read our Contributor's Guide before doing so! This document includes our current goals, standards for inclusions, rules, and more.