World module architecture

class Level : public LevelSource {
    static const int maxBuildHeight = 256;
    static const int genDepth = 128;  // Sea level depth
    
    vector<shared_ptr<Entity>> entities;
    vector<shared_ptr<Player>> players;
    vector<shared_ptr<TileEntity>> tileEntityList;
    
    ChunkSource *chunkSource;
    Dimension *dimension;
    LevelData *levelData;
    Random *random;
    
    void tick();
    void tickEntities();
};

Entity (base class)
├── LivingEntity (health, AI, combat)
│   ├── Mob (pathfinding, spawning)
│   │   ├── PathfinderMob (navigation)
│   │   │   ├── Creature (passive mobs)
│   │   │   │   ├── Animal (breeding)
│   │   │   │   │   ├── Cow, Sheep, Pig, Chicken
│   │   │   │   │   └── TamableAnimal
│   │   │   │   │       └── Wolf, Ocelot
│   │   │   │   └── Bat, Squid
│   │   │   └── Monster (hostile mobs)
│   │   │       ├── Zombie, Skeleton, Creeper
│   │   │       ├── Spider, Enderman, Witch
│   │   │       └── Blaze, Ghast, Slime
│   │   └── FlyingMob
│   │       └── Ghast, EnderDragon
│   └── Player
│       └── LocalPlayer, RemotePlayer, ServerPlayer
├── Minecart (rideable entities)
│   ├── MinecartRideable, MinecartChest
│   └── MinecartFurnace, MinecartHopper
├── Projectile
│   ├── Arrow, Snowball, ThrownEgg
│   └── Fireball, WitherSkull
├── ItemEntity (dropped items)
├── ExperienceOrb
├── HangingEntity
│   ├── Painting, ItemFrame
│   └── LeashFenceKnotEntity
└── Boat, PrimedTnt, FallingTile

int entityId;           // Unique ID
double x, y, z;         // Position
double xd, yd, zd;      // Velocity
float yRot, xRot;       // Rotation (yaw, pitch)
AABB *bb;               // Bounding box
bool onGround;          // Collision state
Level *level;           // World reference

class Mob {
    GoalSelector *goalSelector;      // Behavior goals
    GoalSelector *targetSelector;    // Target selection
};

static const int MAX_XBOX_BOATS = 40;
static const int MAX_CONSOLE_MINECARTS = 40;
static const int MAX_DISPENSABLE_FIREBALLS = 200;
static const int MAX_DISPENSABLE_PROJECTILES = 300;

class LevelChunk {
    static const int WIDTH = 16;
    static const int HEIGHT = 256;
    
    byte blocks[WIDTH * HEIGHT * WIDTH];      // Block IDs
    DataLayer *data;                          // Block metadata
    DataLayer *skyLight, *blockLight;         // Lighting
    
    unordered_map<TilePos, shared_ptr<TileEntity>> tileEntities;
};

class Tile {
    int id;                    // Block ID (0-255)
    Material *material;        // Material properties
    float destroyTime;         // Hardness
    float explosionResistance; // Blast resistance
    
    virtual void tick(Level *level, int x, int y, int z, Random *random);
    virtual void neighborChanged(Level *level, int x, int y, int z, int neighborId);
};

class TileEntity {
    int x, y, z;
    
    virtual void load(CompoundTag *tag);  // Load from NBT
    virtual void save(CompoundTag *tag);  // Save to NBT
};

void Level::checkLight(LightLayer::variety layer, int x, int y, int z) {
    // Flood-fill algorithm
    // Updates light values for chunk sections
    // Marks chunks dirty for re-rendering
}

class TickNextTickData {
    int x, y, z;
    int tileId;
    int tickDelay;
    int priority;
};

void Level::addToTickNextTick(int x, int y, int z, int tileId, int tickDelay);

class AABB {
    double x0, y0, z0;  // Min corner
    double x1, y1, z1;  // Max corner
    
    bool intersects(AABB *other);
    AABB *move(double xa, double ya, double za);
};

class Item {
    int id;                    // Item ID (256+)
    int maxStackSize;          // Stack limit (usually 64)
    int maxDamage;             // Durability (0 = no damage)
    
    virtual bool useOn(ItemInstance *item, Player *player, 
                      Level *level, int x, int y, int z, int face);
};

class ItemInstance {
    int id;                    // Item/block ID
    int count;                 // Stack size
    int auxValue;              // Metadata/damage
    CompoundTag *tag;          // NBT data (optional)
};

class AbstractContainerMenu {
    vector<Slot *> slots;              // UI slots
    vector<Container *> containers;    // Backing inventories
    
    ItemInstance *clicked(int slotId, int button, int mode, Player *player);
};

class Recipes {
    vector<Recipe *> recipes;
    
    ItemInstance *findMatchingRecipe(CraftingContainer *container);
};

class Enchantment {
    int id;
    int rarity;                // Common, uncommon, rare, very rare
    EnchantmentCategory *type; // Weapon, armor, tool, bow, etc.
    
    int getMinCost(int level);
    int getMaxCost(int level);
};

class Achievement : public Stat {
    const int x, y;              // Position in achievement tree
    Achievement *requires;        // Prerequisite achievement
    const wstring desc;          // Description text
    shared_ptr<ItemInstance> icon; // Display icon
    bool isGoldenVar;            // Special "golden" achievements
};

class Packet {
    virtual int getId() = 0;
    virtual void read(DataInputStream *dis) = 0;
    virtual void write(DataOutputStream *dos) = 0;
    virtual void handle(PacketListener *listener) = 0;
    
    static shared_ptr<Packet> readPacket(DataInputStream *dis, bool isServer);
    static void writePacket(shared_ptr<Packet> packet, DataOutputStream *dos);
};

class Tag {
    virtual void write(DataOutputStream *dos) = 0;
    virtual void read(DataInputStream *dis) = 0;
};

// Tag types
ByteTag, ShortTag, IntTag, LongTag, FloatTag, DoubleTag
ByteArrayTag, StringTag, ListTag<T>, CompoundTag

class CompoundTag {
    unordered_map<wstring, shared_ptr<Tag>> tags;
    
    void putInt(const wstring& key, int value);
    int getInt(const wstring& key);
};

class LevelData {
    __int64 seed;              // World seed
    __int64 gameTime;          // Total ticks
    int spawnX, spawnY, spawnZ; // Spawn point
    bool raining, thundering;   // Weather
    int gameType;              // Survival, creative, adventure
    bool hardcore, cheatsAllowed;
    GameRules *gameRules;      // Game rules (command-set)
};