docs: rewrite MC, client, platforms, modding, world pages in casual tone

Author: coah80

src/content/docs/client/audio.md

@@ -3,7 +3,7 @@ title: "Audio"
 description: "Sound system in LCEMP."
 ---
 
-LCEMP's audio system is built on the Miles Sound System (MSS) library, abstracted through a two-class hierarchy: `ConsoleSoundEngine` defines the platform interface, and `SoundEngine` provides the shared implementation. The system handles positional 3D audio, background music streaming, and UI sound effects.
+LCEMP's audio system is built on the Miles Sound System (MSS) library, wrapped in a two-class hierarchy. `ConsoleSoundEngine` defines the platform interface, and `SoundEngine` provides the shared implementation. The system handles positional 3D audio, background music streaming, and UI sound effects.
 
 ## Architecture
 
@@ -117,19 +117,19 @@ Key playback methods:
 | `playUI(iSound, volume, pitch)` | Play a non-positional UI sound |
 | `playStreaming(name, x, y, z, volume, pitch, bMusicDelay)` | Start streaming music |
 
-The `MAX_SAME_SOUNDS_PLAYING = 8` limit prevents the same sound effect from stacking excessively. Per-sound tracking is maintained in `CurrentSoundsPlaying[eSoundType_MAX + eSFX_MAX]`.
+The `MAX_SAME_SOUNDS_PLAYING = 8` limit stops the same sound effect from stacking too much. Per-sound tracking is kept in `CurrentSoundsPlaying[eSoundType_MAX + eSFX_MAX]`.
 
 ### Sound invocation from game code
 
-`LevelRenderer` provides the bridge between game events and audio:
+`LevelRenderer` is the bridge between game events and audio:
 
 ```cpp
 void playSound(int iSound, double x, double y, double z,
                float volume, float pitch, float fSoundClipDist = 16.0f);
 void playStreamingMusic(const wstring& name, int x, int y, int z);
 ```
 
-The `fSoundClipDist` parameter (default 16 blocks) controls the maximum audible distance.
+The `fSoundClipDist` parameter (default 16 blocks) controls how far away a sound can be heard.
 
 ## Music system
 
@@ -190,15 +190,15 @@ static int OpenStreamThreadProc(void* lpParameter);
 
 ### Music selection
 
-`getMusicID(int iDomain)` selects a random track appropriate for the current dimension. The track ranges are configurable per texture/mash-up pack:
+`getMusicID(int iDomain)` picks a random track that fits the current dimension. The track ranges are configurable per texture/mash-up pack:
 
 ```cpp
 void SetStreamingSounds(int iOverworldMin, int iOverWorldMax,
                         int iNetherMin, int iNetherMax,
                         int iEndMin, int iEndMax, int iCD1);
 ```
 
-`GetRandomishTrack(iStart, iEnd)` selects a track, using `m_bHeardTrackA` to avoid immediate repeats.
+`GetRandomishTrack(iStart, iEnd)` selects a track, using `m_bHeardTrackA` to avoid playing the same track back to back.
 
 ### Music tick
 
@@ -222,23 +222,23 @@ The master volumes (`m_MasterMusicVolume`, `m_MasterEffectsVolume`) are set from
 ## Sound bank and driver
 
 The Miles Sound System uses:
-- **`HMSOUNDBANK m_hBank`** -- loaded sound bank containing all SFX
-- **`HDIGDRIVER m_hDriver`** -- the digital audio driver
-- **`HSTREAM m_hStream`** -- current streaming music handle
+- **`HMSOUNDBANK m_hBank`** is the loaded sound bank containing all SFX
+- **`HDIGDRIVER m_hDriver`** is the digital audio driver
+- **`HSTREAM m_hStream`** is the current streaming music handle
 
-Sound files and music files are registered through `add()`, `addMusic()`, and `addStreaming()` during initialization.
+Sound files and music files get registered through `add()`, `addMusic()`, and `addStreaming()` during initialization.
 
 ## DLC audio
 
-DLC packs (mash-up packs) can provide their own audio through `DLCAudioFile.h`. The `TexturePack::hasAudio()` method indicates whether a pack includes custom audio. When a DLC pack with audio is active, `SetStreamingSounds()` reconfigures the music track ranges.
+DLC packs (mash-up packs) can provide their own audio through `DLCAudioFile.h`. The `TexturePack::hasAudio()` method tells you whether a pack includes custom audio. When a DLC pack with audio is active, `SetStreamingSounds()` reconfigures the music track ranges.
 
 Audio resources are stored in:
-- `Common/res/audio/` -- base game sound banks
-- `Common/res/TitleUpdate/audio/` -- title update audio additions
+- `Common/res/audio/` for base game sound banks
+- `Common/res/TitleUpdate/audio/` for title update audio additions
 
 ## Platform-specific notes
 
 - **PS3**: `initAudioHardware()` has a platform-specific implementation for Cell audio initialization
-- **PS4 (Orbis)**: Uses `int32_t m_hBGMAudio` for background music audio handle
-- **PS Vita**: Miles integration through Vita-specific MSS build with `updateMiles()` called during the mixer callback
+- **PS4 (Orbis)**: Uses `int32_t m_hBGMAudio` for the background music audio handle
+- **PS Vita**: Miles integration through a Vita-specific MSS build with `updateMiles()` called during the mixer callback
 - **Xbox 360**: Uses native XAudio instead of Miles (no `mss.h` include)

src/content/docs/client/input.md

@@ -3,7 +3,7 @@ title: "Input System"
 description: "How LCEMP handles keyboard, mouse, and controller input."
 ---
 
-LCEMP supports three input methods: gamepad controllers (primary for all console platforms), keyboard/mouse (Windows 64-bit port), and touch (PS Vita). The input system is split across several classes that abstract platform differences and feed into the game's action system.
+LCEMP supports three input methods: gamepad controllers (the main one for all console platforms), keyboard/mouse (Windows 64-bit port), and touch (PS Vita). The input system is spread across several classes that abstract platform differences and feed into the game's action system.
 
 ## Input class hierarchy
 
@@ -25,11 +25,11 @@ public:
 };
 ```
 
-This is the minimal interface that `LocalPlayer` uses each tick to determine movement intent. The `xa`/`ya` values drive horizontal movement, while `jumping`, `sneaking`, and `sprinting` flags trigger their respective behaviors.
+This is the minimal interface that `LocalPlayer` uses each tick to figure out movement intent. The `xa`/`ya` values drive horizontal movement, while `jumping`, `sneaking`, and `sprinting` flags trigger their respective behaviors.
 
 ### KeyboardMouseInput
 
-The `KeyboardMouseInput` class handles keyboard and mouse input for the Windows 64-bit build. It is instantiated as a global (`g_KBMInput`):
+The `KeyboardMouseInput` class handles keyboard and mouse input for the Windows 64-bit build. It's set up as a global (`g_KBMInput`):
 
 ```cpp
 extern KeyboardMouseInput g_KBMInput;
@@ -70,10 +70,10 @@ extern KeyboardMouseInput g_KBMInput;
 The class tracks three states per key and mouse button:
 
 - **Down**: currently held
-- **Pressed**: transitioned from up to down this tick
-- **Released**: transitioned from down to up this tick
+- **Pressed**: went from up to down this tick
+- **Released**: went from down to up this tick
 
-State is double-buffered with accumulators (`m_keyPressedAccum`, `m_keyReleasedAccum`) that collect events between ticks, then are transferred to the readable state arrays during `Tick()`.
+State is double-buffered with accumulators (`m_keyPressedAccum`, `m_keyReleasedAccum`) that collect events between ticks, then get transferred to the readable state arrays during `Tick()`.
 
 #### Key methods
 
@@ -104,11 +104,11 @@ void SetScreenCursorHidden(bool hidden);
 bool HasAnyInput() const;
 ```
 
-`HasAnyInput()` returns true when any key or mouse event has occurred, useful for detecting whether to switch between controller and keyboard/mouse input modes.
+`HasAnyInput()` returns true when any key or mouse event has happened. This is handy for figuring out whether to switch between controller and keyboard/mouse input modes.
 
 ## Controller input (EControllerActions)
 
-Controller input is mapped through the `EControllerActions` enum defined in `Common/App_enums.h`. This provides a unified action system across all console platforms.
+Controller input is mapped through the `EControllerActions` enum defined in `Common/App_enums.h`. This gives you a unified action system across all console platforms.
 
 ### Menu actions
 
@@ -150,7 +150,7 @@ Platform-specific menu actions:
 
 ### Debug actions (created from D-pad)
 
-These are not mapped directly to the input manager but are derived from D-pad presses in `Minecraft::run_middle()`:
+These aren't mapped directly to the input manager but are derived from D-pad presses in `Minecraft::run_middle()`:
 
 | Action | Description |
 |---|---|
@@ -191,7 +191,7 @@ The `Options` class holds 14 key mappings:
 | `keyPickItem` | Pick block |
 | `keyToggleFog` | Toggle fog distance |
 
-These are primarily used by the Windows 64-bit build; console builds use the `EControllerActions` system instead.
+These are mainly used by the Windows 64-bit build. Console builds use the `EControllerActions` system instead.
 
 ## ConsoleInput / ConsoleInputSource
 
@@ -222,5 +222,5 @@ These are used for the integrated server console, not player gameplay input.
 2. **Input abstraction** (`KeyboardMouseInput` or platform controller API) processes raw events into state
 3. **`CMinecraftApp::HandleButtonPresses()`** reads controller state per player and translates to `EControllerActions`
 4. **`Input::tick()`** converts action state into movement axes (`xa`/`ya`) and action flags (`jumping`, `sneaking`, `sprinting`)
-5. **`LocalPlayer`** consumes the `Input` object each tick to update player movement and trigger actions
-6. **`Screen` / `UIScene`** intercepts input when menus are active, consuming events before they reach gameplay
+5. **`LocalPlayer`** reads the `Input` object each tick to update player movement and trigger actions
+6. **`Screen` / `UIScene`** intercepts input when menus are active, grabbing events before they reach gameplay

src/content/docs/client/settings.md

@@ -3,11 +3,11 @@ title: "Settings"
 description: "Game settings and options in LCEMP."
 ---
 
-LCEMP manages settings at two levels: the `Options` class handles legacy Java-style game options (graphics, controls, keybindings), while the `CMinecraftApp` game settings system manages console-specific per-player profile settings. The `Settings` class provides a simple key-value property store for server configuration.
+LCEMP manages settings at two levels. The `Options` class handles legacy Java-style game options (graphics, controls, keybindings), while the `CMinecraftApp` game settings system manages console-specific per-player profile settings. The `Settings` class provides a simple key-value property store for server configuration.
 
 ## Options class
 
-`Options` is the primary settings container, owned by the `Minecraft` instance. It manages graphics preferences, input sensitivity, key bindings, and gameplay toggles.
+`Options` is the main settings container, owned by the `Minecraft` instance. It manages graphics preferences, input sensitivity, key bindings, and gameplay toggles.
 
 ### Option definitions
 
@@ -189,7 +189,7 @@ static const int GAME_SETTINGS_PROFILE_DATA_BYTES = 204;
 static const int GAME_DEFINED_PROFILE_DATA_BYTES = 972; // per user (doubled for extended achievements)
 ```
 
-The 204-byte limit is preserved for backward compatibility with pre-TU5 save data. The remaining profile bytes store statistics and achievement data.
+The 204-byte limit is kept for backward compatibility with pre-TU5 save data. The remaining profile bytes store statistics and achievement data.
 
 ### Access methods
 
@@ -201,7 +201,7 @@ void CheckGameSettingsChanged(bool bOverride5MinuteTimer = false, int iPad = XUS
 void ApplyGameSettingsChanged(int iPad);
 ```
 
-Settings changes are batched and applied through `ApplyGameSettingsChanged()`. The system checks for changes periodically (with a 5-minute timer) or on explicit request.
+Settings changes are batched and applied through `ApplyGameSettingsChanged()`. The system checks for changes periodically (with a 5-minute timer) or when explicitly requested.
 
 ## Game host options (eGameHostOption)
 
@@ -237,7 +237,7 @@ unsigned int GetGameHostOption(eGameHostOption eVal);
 
 ### Achievement eligibility
 
-`CanRecordStatsAndAchievements()` checks whether the current host options allow achievements. Options like creative mode, cheats, and certain debug flags disable achievement recording.
+`CanRecordStatsAndAchievements()` checks whether the current host options allow achievements. Things like creative mode, cheats, and certain debug flags will disable achievement recording.
 
 ## Settings class
 
@@ -255,7 +255,7 @@ class Settings {
 };
 ```
 
-It wraps an `unordered_map<wstring, wstring>` and provides typed getters with defaults. Used by the integrated server for configuration like server name, port, max players, etc.
+It wraps an `unordered_map<wstring, wstring>` and provides typed getters with defaults. The integrated server uses it for configuration like server name, port, max players, etc.
 
 ## Player skin and cape settings
 
@@ -275,7 +275,7 @@ DWORD GetPlayerCapeId(int iPad);
 
 ### Favorite skins
 
-Players can save up to a set of favorite skins:
+Players can save a set of favorite skins:
 
 ```cpp
 void SetPlayerFavoriteSkin(int iPad, int iIndex, unsigned int uiSkinID);
@@ -286,7 +286,7 @@ void ValidateFavoriteSkins(int iPad);  // checks DLC availability
 
 ## Opacity timer
 
-The HUD opacity temporarily returns to full when the player changes hotbar selections:
+The HUD opacity temporarily goes back to full when the player changes hotbar selections:
 
 ```cpp
 void SetOpacityTimer(int iPad);       // starts a 6-second (120 tick) countdown

src/content/docs/client/textures.md

@@ -3,15 +3,15 @@ title: "Textures & Resources"
 description: "Texture loading and resource management in LCEMP."
 ---
 
-LCEMP manages textures through several cooperating systems: `Textures` handles loading and binding, `TextureManager` provides a name-to-ID registry, `TexturePackRepository` manages texture pack selection, and a hierarchy of `TexturePack` implementations abstracts resource sources.
+LCEMP manages textures through several systems working together. `Textures` handles loading and binding, `TextureManager` provides a name-to-ID registry, `TexturePackRepository` manages texture pack selection, and a hierarchy of `TexturePack` implementations abstracts where resources come from.
 
 ## Textures
 
-The `Textures` class is the primary texture management interface, owned by the `Minecraft` instance. It handles loading images from disk, binding textures for rendering, and managing dynamic/animated textures.
+The `Textures` class is the main texture management interface, owned by the `Minecraft` instance. It handles loading images from disk, binding textures for rendering, and managing dynamic/animated textures.
 
 ### Texture name registry (TEXTURE_NAME enum)
 
-All built-in textures are registered through the `TEXTURE_NAME` enum, which assigns a compile-time ID to each texture resource. The enum contains entries organized by version:
+All built-in textures are registered through the `TEXTURE_NAME` enum, which gives a compile-time ID to each texture resource. The enum has entries organized by version:
 
 **Original textures:**
 
@@ -67,7 +67,7 @@ The total count is `TN_COUNT`.
 
 ### HTTP and memory textures
 
-For multiplayer skins and DLC content, `Textures` supports loading from remote sources:
+For multiplayer skins and DLC content, `Textures` can load from remote sources:
 
 ```cpp
 int loadHttpTexture(const wstring& url, const wstring& backup);
@@ -87,15 +87,15 @@ MemTexture* addMemTexture(const wstring& url, MemTextureProcessor* processor);
 
 ### Anaglyph conversion
 
-When stereoscopic 3D is enabled, `Textures::anaglyph()` converts pixel data to the appropriate color channel separation.
+When stereoscopic 3D is enabled, `Textures::anaglyph()` converts pixel data to the right color channel separation.
 
 ### Title update textures
 
-`Textures::IsTUImage()` and `Textures::IsOriginalImage()` determine whether a texture should be loaded from the title update drive or the original game disc, enabling texture replacements through patches.
+`Textures::IsTUImage()` and `Textures::IsOriginalImage()` figure out whether a texture should be loaded from the title update drive or the original game disc. This is what lets texture replacements work through patches.
 
 ## TextureManager
 
-`TextureManager` is a singleton registry mapping string names to texture IDs and `Texture` objects:
+`TextureManager` is a singleton registry that maps string names to texture IDs and `Texture` objects:
 
 ```cpp
 class TextureManager {
@@ -137,11 +137,11 @@ Some textures animate each tick:
 | `ClockTexture` | Clock item face rotation |
 | `CompassTexture` | Compass needle direction |
 
-These are updated during `Textures::tick()` when `tickDynamics` is true.
+These get updated during `Textures::tick()` when `tickDynamics` is true.
 
 ## BufferedImage
 
-`BufferedImage` is the CPU-side image container used for loading and manipulating texture data before uploading to the GPU. It stores pixel data as integer arrays.
+`BufferedImage` is the CPU-side image container used for loading and working with texture data before uploading to the GPU. It stores pixel data as integer arrays.
 
 ## TexturePack hierarchy
 
@@ -220,11 +220,11 @@ res/
     res/             -- updated textures
 ```
 
-The `1_2_2/` subdirectory contains the original 1.2.2 version resources as a baseline.
+The `1_2_2/` subdirectory has the original 1.2.2 version resources as a baseline.
 
 ## DLC texture packs
 
-Each DLC pack under `TitleUpdate/DLC/` contains a `Data/` subdirectory with pack-specific resources. Available DLC packs in the source tree:
+Each DLC pack under `TitleUpdate/DLC/` has a `Data/` subdirectory with pack-specific resources. Available DLC packs in the source tree:
 
 - Candy
 - Cartoon
@@ -247,4 +247,4 @@ DLC packs are managed through `DLCManager` and `DLCPack` in `Common/DLC/`, with
 
 ## Texture format
 
-The static member `Textures::TEXTURE_FORMAT` controls the GPU texture format. Mipmapping is controlled by `Textures::MIPMAP`. Format selection via `setTextureFormat()` adapts to platform capabilities.
+The static member `Textures::TEXTURE_FORMAT` controls the GPU texture format. Mipmapping is controlled by `Textures::MIPMAP`. Format selection via `setTextureFormat()` adapts to whatever the platform supports.