Minecraft Dump.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "007f18d6-6479-458e-8b97-c536209fe59d",
   "metadata": {},
   "source": [
    "# Getting Started\n",
    "Minecraft bedrock's data is stored in a LevelDB database. Let's get a LevelDB library and start looking at a world."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc6afc4e-55f1-4c3d-b461-faab200c73ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "from leveldb import LevelDB\n",
    "db_filename = \"jupyter-world/db\"\n",
    "db = LevelDB(db_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97a41fe4-224e-4bd0-94e0-12c9fee11184",
   "metadata": {},
   "source": [
    "The file opened without errors. LevelDB is a \"key/value\" datastore. It's like a big python dictionary. Let's see how many keys there are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50bc86a0-484d-44da-8e07-cce38aeb4714",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "num_keys = 0\n",
    "\n",
    "# This library doesn't provide a way to quickly find the number of keys, so we have to iterate the entire list of keys.\n",
    "for i in db.keys():\n",
    "    # In case there's a lot of keys, let's print some progress\n",
    "    if num_keys % 10000 == 0 and num_keys != 0:\n",
    "        print(f\"processed {num_keys} keys\")\n",
    "    num_keys += 1\n",
    "print(f\"Number of Keys - {num_keys}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80908189-e77f-40c0-b69d-413148b7ab25",
   "metadata": {},
   "source": [
    "Large world files can have hundreds of thousands or millions of keys so I'm not going to print all of them. Let's first see if there's anything that's ascii readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56c859d1-5293-463b-b5ac-4d48b8883fcb",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import string\n",
    "strs = set()\n",
    "for i in db.keys():\n",
    "    strs.add(''.join(filter(lambda x: bytes(x, \"latin-1\") < b'\\x80' and str(x) in string.printable, i.decode(\"latin-1\"))))\n",
    "\n",
    "print(sorted(strs, key=len, reverse=True)[0:500])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebf50bb0-21c9-466e-a69a-36de27c87ba7",
   "metadata": {},
   "source": [
    "There do seem to be some patterns here. I see 'LevelChunkMetaDataDictionary', 'AutonomousEntities', 'BiomeData', 'Overworld', 'mobevents', 'schedulerWT', 'scoreboard', and a bunch that start with 'actorprefix', 'digp', and 'map_'. (VILLAGE, player, player_server)\n",
    "\n",
    "How many keys are there in total, and how many are there that start with those strings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2349e260-70f5-49e3-a9a1-3c1eb2e25375",
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "actorprefix = 0\n",
    "village = 0\n",
    "player_server = 0\n",
    "player = 0\n",
    "digp = 0\n",
    "map_ = 0\n",
    "for i in db.keys():\n",
    "    if i.startswith(b\"actorprefix\"): actorprefix += 1\n",
    "    elif i.startswith(b\"digp\"): digp += 1\n",
    "    elif i.startswith(b\"player_server\"): player_server += 1\n",
    "    elif i.startswith(b\"player\"): player += 1\n",
    "    elif i.startswith(b\"VILLAGE_\"): village += 1\n",
    "    elif i.startswith(b\"map_\"): map_ += 1\n",
    "    total += 1\n",
    "\n",
    "print(f\"actorprefix- {actorprefix} ({round((actorprefix*100)/total)}%)\")\n",
    "print(f\"digp- {digp} ({round((digp*100)/total)}%)\")\n",
    "print(f\"map- {map_} ({round((map_*100)/total)}%)\")\n",
    "print(f\"village- {village} ({round((village*100)/total)}%)\")\n",
    "print(f\"player_server- {player_server} ({round((player_server*100)/total)}%)\")\n",
    "print(f\"player- {player} ({round((player*100)/total)}%)\")\n",
    "print(f\"total- {total}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1896bfe5-ff33-4bc8-9b79-6158bc20e485",
   "metadata": {},
   "source": [
    "# Diving In"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c634fbb-334b-40a1-9f9d-fa178ab4ecac",
   "metadata": {},
   "source": [
    "## actorprefix\n",
    "\n",
    "Let's start with looking at actorprefix records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25f6d416-0411-4651-b691-ef94a1be43c9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b'actorprefix') # seek to the given key, or to the first one that is after where that key would be.\n",
    "\n",
    "# This will print the key and the value of the key that is \"actorprefix\" or the first one that is lexicographically after it.\n",
    "print(f\"key - {iterator.key()}\")\n",
    "print(f\"value - {iterator.value()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "618e3bea-400e-4d02-ad0a-df33fedc9d92",
   "metadata": {},
   "source": [
    "Looks like we're getting somewhere. I see some text I recognize.\n",
    "\n",
    "I'm guessing this is in NBT format. Let's use amulet's nbt library to look at the first one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee3134ee-d51e-4e8f-bf22-6a3d870f1885",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import amulet_nbt\n",
    "from amulet_nbt import utf8_escape_decoder\n",
    "\n",
    "nbt = amulet_nbt.load(iterator.value(), little_endian=True, string_decoder=utf8_escape_decoder)\n",
    "print(nbt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e65c6209-bba1-403d-98cf-e91bc77a4f29",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Looks like it parses well. Let's pretty-print it.\n",
    "\n",
    "def print_nbt(nbt):\n",
    "    print(nbt.to_snbt(indent=4))\n",
    "\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a689394-10f8-421a-a052-f2fd4db9db2d",
   "metadata": {},
   "source": [
    "There's some interesting stuff in there. \"Pos\" is probably this entity's (x, y, z) coordinates.\n",
    "\n",
    "Let's see how many different types we have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "363d4646-8279-40c0-8d4a-b855502acbe5",
   "metadata": {},
   "outputs": [],
   "source": [
    "identifiers = {}\n",
    "for (k, v) in db.iterate(start = b'actorprefix', end = b'actorprefiz'):\n",
    "    nbt = amulet_nbt.load(v, little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "    id = str(nbt['identifier'])\n",
    "    if id in identifiers:\n",
    "        identifiers[id] += 1\n",
    "    else:\n",
    "        identifiers[id] = 1\n",
    "\n",
    "print(dict(sorted(identifiers.items(), key=lambda x:x[1], reverse=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac6aec84-78b4-4d89-96a2-1f93bf635616",
   "metadata": {},
   "source": [
    "I wonder what 'minecraft:item' ids are. Maybe a dropped item?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5dd3905d-c4a3-4dae-93a1-395d344f0bf8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for (k, v) in db.iterate(start = b'actorprefix', end = b'actorprefiz'):\n",
    "    nbt = amulet_nbt.load(v, little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "    id = str(nbt['identifier'])\n",
    "    if id == 'minecraft:item':\n",
    "        print(nbt.to_snbt(indent=4))\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97beafda-3fe4-47fa-b146-cc2ee31c441a",
   "metadata": {},
   "source": [
    "Looks like maybe.\n",
    "\n",
    "Let's do the same loop, but demux the \"minecraft:item\"s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f123599-1e88-4224-9d39-d8d05139e34d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "identifiers = {}\n",
    "for (k, v) in db.iterate(start = b'actorprefix', end = b'actorprefiz'):\n",
    "    nbt = amulet_nbt.load(v, little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "    id = str(nbt['identifier'])\n",
    "    if id == 'minecraft:item':\n",
    "        Item = nbt['Item']\n",
    "        if 'Block' in Item:\n",
    "            id = f\"minecraft:item : {str(nbt['Item']['Block']['name'])}\"\n",
    "        else:\n",
    "            id = f\"minecraft:item : {str(nbt['Item']['Name'])}\"\n",
    "    if id in identifiers:\n",
    "        identifiers[id] += 1\n",
    "    else:\n",
    "        identifiers[id] = 1\n",
    "\n",
    "print(dict(sorted(identifiers.items(), key=lambda x:x[1], reverse=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89c69962-9af5-4d43-8b34-6faaa3ed6c3d",
   "metadata": {},
   "source": [
    "Ooo, some netherite gear!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61279860-50be-4c36-af27-52eb799b3035",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for (k, v) in db.iterate(start = b'actorprefix', end = b'actorprefiz'):\n",
    "    nbt = amulet_nbt.load(v, little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "    id = str(nbt['identifier'])\n",
    "    if id == 'minecraft:item':\n",
    "        Item = nbt['Item']\n",
    "        if 'Name' in Item and ('netherite' in str(Item['Name']) or 'diamond' in str(Item['Name'])):\n",
    "            print(f\"{Item['Name']} - ({nbt['Pos'][0]}, {nbt['Pos'][1]}, {nbt['Pos'][2]})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49465931-93ca-460d-ac85-6cb0087a6e49",
   "metadata": {},
   "source": [
    "## digp\n",
    "[This URL](https://learn.microsoft.com/en-us/minecraft/creator/documents/actorstorage) describes a relationship between the 'digp' keys and the 'actorprefix' keys.\n",
    "\n",
    "Let's look at the 'digp' keys and values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b25175e0-bbbf-4074-8907-80f4cbdc323b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"digp\")\n",
    "number_to_print = 20\n",
    "while number_to_print >= 0 and iterator.key().startswith(b\"digp\"):\n",
    "    print(f\"Key - {iterator.key()}\")\n",
    "    print(f\"Value - {iterator.value()}\")\n",
    "    iterator.next()\n",
    "    number_to_print -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa457348-3a3b-4e23-867e-4989266c801d",
   "metadata": {},
   "source": [
    "So, the digp keys have the form digp(4-byte x chunk ID)+(4-byte z chunk-id)+(optional 4-byte dimension ID)\n",
    "If the dimension ID is missing, then it's the Overworld.\n",
    "\n",
    "    b'digp\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00' is (0, 0) Overworld\n",
    "    b'digp\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00' is (0, 0) Nether\n",
    "    b'digp\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x02\\x00\\x00\\x00' is (0, 0) The End\n",
    "\n",
    "The values for each key are have lengths that are multiples of 8. Each 8-byte part if the value is an actorprefix id.\n",
    "Let's see what the actors are at (0, 0) in the Overworld."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eef2c69b-4505-4519-83c3-c592ae3fb809",
   "metadata": {},
   "outputs": [],
   "source": [
    "digp = db[b\"digp\\x01\\x00\\x00\\x00\\xfd\\xff\\xff\\xff\"]\n",
    "for i in range(0, len(digp) // 8 * 8, 8):\n",
    "    v = db[b\"actorprefix\" + digp[i : i + 8]]\n",
    "    nbt = amulet_nbt.load(v, little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "    print(nbt['identifier'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b756e263-b37a-42d2-9316-4d8582f48c6f",
   "metadata": {},
   "source": [
    "I wonder if there are actorprefixes that aren't in the digp. Also, are there any digp ActorUniqueIDs in digp that don't exist in actorprefix?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f5949de-d9d0-45e9-a6d8-d65c59e1ddb2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "digp = set()\n",
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"digp\")\n",
    "count = 0\n",
    "print(\"processing digp\")\n",
    "while iterator.key().startswith(b\"digp\"):\n",
    "    if count % 10000 == 0 and count != 0:\n",
    "        print(f\"processed {count}\")\n",
    "    v = iterator.value()\n",
    "    for i in range(0, len(v) // 8 * 8, 8):\n",
    "        apfx = v[i : i + 8]\n",
    "        digp.add(v[i : i + 8])\n",
    "    iterator.next()\n",
    "    count += 1\n",
    "print(f\"size of digp - {len(digp)}\")\n",
    "\n",
    "actorprefix = set()\n",
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"actorprefix\")\n",
    "count = 0\n",
    "print(\"processing actorprefix\")\n",
    "while iterator.key().startswith(b\"actorprefix\"):\n",
    "    if count % 10000 == 0 and count != 0:\n",
    "        print(f\"processed {count}\")\n",
    "    actorprefix.add(iterator.key()[11:])\n",
    "    iterator.next()\n",
    "    count += 1\n",
    "print(f\"size of actorprefix - {len(actorprefix)}\")\n",
    "\n",
    "print(f\"Number of actors that are in digp but not actorprefix - {len(digp.difference(actorprefix))}\")\n",
    "print(f\"Number of actors in actorprefix but not in digp - {len(actorprefix.difference(digp))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "206467d4-cc51-4182-a684-e3a86ef81301",
   "metadata": {},
   "source": [
    "It looks like we're good. In older worlds, there are can be many disjoint records. There's a [Mojang bug report](https://bugs.mojang.com/browse/MCPE-155283) for this scenario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f9e8b6d-36c0-444b-9c67-6557db1c2115",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "identifiers = {}\n",
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"digp\")\n",
    "while iterator.key().startswith(b\"digp\"):\n",
    "    v = iterator.value()\n",
    "    for i in range(0, len(iterator.value()) // 8 * 8, 8):\n",
    "        try:\n",
    "            data = db[b'actorprefix'+v[i : i + 8]]\n",
    "        except:\n",
    "            continue\n",
    "        nbt = amulet_nbt.load(data, little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "        id = str(nbt['identifier'])\n",
    "        if id == 'minecraft:item':\n",
    "            Item = nbt['Item']\n",
    "            if 'Block' in Item:\n",
    "                id = f\"minecraft:item : {str(nbt['Item']['Block']['name'])}\"\n",
    "            else:\n",
    "                id = f\"minecraft:item : {str(nbt['Item']['Name'])}\"\n",
    "        if id in identifiers:\n",
    "            identifiers[id] += 1\n",
    "        else:\n",
    "            identifiers[id] = 1\n",
    "\n",
    "    iterator.next()\n",
    "\n",
    "print(dict(sorted(identifiers.items(), key=lambda x:x[1], reverse=True)))        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a4436a3-050f-422e-8263-3dd81bdbc311",
   "metadata": {},
   "source": [
    "Any diamond or netherite gear there?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6932b646-d00f-4216-87f6-33615d1414d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in identifiers.keys():\n",
    "    if ('netherite' in k) or ('diamond' in k):\n",
    "        print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f04c95e-9b2d-4f6e-a2a5-129d47eb6aab",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Let's do the earlier one but print xyz and dimension for netherite gear.\n",
    "\n",
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"digp\")\n",
    "while iterator.key().startswith(b\"digp\"):\n",
    "    if len(iterator.key()) == 12:\n",
    "        dimension = 'Overworld'\n",
    "    elif int.from_bytes(iterator.key()[12:], \"little\") == 1:\n",
    "        dimension = 'Nether'\n",
    "    elif int.from_bytes(iterator.key()[12:], \"little\") == 2:\n",
    "        dimension = 'The End'\n",
    "    else:\n",
    "        print(f\"Error - {iterator.key()}\")\n",
    "        print(iterator.key()[12:])\n",
    "        break\n",
    "    v = iterator.value()\n",
    "    for i in range(0, len(iterator.value()) // 8 * 8, 8):\n",
    "        try:\n",
    "            data = db[b'actorprefix'+v[i : i + 8]]\n",
    "        except:\n",
    "            continue\n",
    "        nbt = amulet_nbt.load(data, little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "        if str(nbt['identifier']) == 'minecraft:item':\n",
    "            if 'Name' in nbt['Item'] and 'netherite' in str(nbt['Item']['Name']):\n",
    "                print(f\"item - {str(nbt['Item']['Name'])} : ({nbt['Pos'][0]}, {nbt['Pos'][1]}, {nbt['Pos'][2]}) {dimension}\")\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85d50c23-3ef6-4549-ab93-1dbf4de14554",
   "metadata": {},
   "source": [
    "Looks like somebody died in the end with a full kit of netherite gear and it's still lying on the ground. I'll have to fly out there and look for it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5c75f6e-d6b0-4709-96e9-b16ad68b62d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import attrgetter\n",
    "\n",
    "villager_jobs = {\n",
    "    \"+librarian\": \"Librarian\",\n",
    "    \"+farmer\": \"Farmer\",\n",
    "    \"+fisherman\": \"Fisherman\",\n",
    "    \"+nitwit\": \"Nitwit\",\n",
    "    \"+weaponsmith\": \"Weaponsmith\",\n",
    "    \"+cleric\": \"Cleric\",\n",
    "    \"+shepherd\": \"Shepherd\",\n",
    "    \"+mason\": \"Mason\",\n",
    "    \"+toolsmith\": \"Toolsmith\",\n",
    "}\n",
    "\n",
    "enchantments = {\n",
    "    0: \"Protection\",\n",
    "    1: \"Fire Protection\",\n",
    "    2: \"Feather Falling\",\n",
    "    3: \"Blast Protection\",\n",
    "    4: \"Projectile Protection\",\n",
    "    5: \"Thorns\",\n",
    "    6: \"Respiration\",\n",
    "    7: \"Depth Strider\",\n",
    "    8: \"Aqua Affinity\",\n",
    "    9: \"Sharpness\",\n",
    "    10: \"Smite\",\n",
    "    11: \"Bane of Arthropods\",\n",
    "    12: \"Knockback\",\n",
    "    13: \"Fire Aspect\",\n",
    "    14: \"Looting\",\n",
    "    15: \"Efficiency\",\n",
    "    16: \"Silk Touch\",\n",
    "    17: \"Unbreaking\",\n",
    "    18: \"Fortune\",\n",
    "    19: \"Power\",\n",
    "    20: \"Punch\",\n",
    "    21: \"Flame\",\n",
    "    22: \"Infinity\",\n",
    "    23: \"Luck of the Sea\",\n",
    "    24: \"Lure\",\n",
    "    25: \"Frost Walker\",\n",
    "    26: \"Mending\",\n",
    "    29: \"Impaling\",\n",
    "    30: \"Riptide\",\n",
    "    31: \"Loyalty\",\n",
    "    32: \"Channeling\",\n",
    "    33: \"Multishot\",\n",
    "    34: \"Piercing\",\n",
    "    35: \"Quick Charge\"\n",
    "}\n",
    "\n",
    "\n",
    "# For fun, let's use map() and set operations instead of for loops\n",
    "def print_villager(nbt):\n",
    "    \n",
    "    inter = set(villager_jobs.keys()).intersection(\n",
    "        set(map(attrgetter(\"py_str\"), nbt[\"definitions\"]))\n",
    "    )\n",
    "    print(\"Type: Unknown\" if not len(inter) else f\"Type: {villager_jobs[inter.pop()]}\")\n",
    "\n",
    "    print(\"ChestItems\")\n",
    "    print(\n",
    "        *list(\n",
    "            map(\n",
    "                lambda x: \"    Empty\"\n",
    "                if x[\"Count\"].py_int == 0\n",
    "                else f\"    {x['Name']} ({x['Count']})\",\n",
    "                nbt[\"ChestItems\"],\n",
    "            )\n",
    "        ),\n",
    "        sep=\"\\n\",\n",
    "    )\n",
    "\n",
    "    if \"Offers\" in nbt:\n",
    "        print(\"Offers\")\n",
    "        print(\n",
    "            *list(\n",
    "                map(\n",
    "                    lambda x: f\"    {x['maxUses']}x {x['buyA']['Name']} ({x['buyA']['Count']}) -> \"\n",
    "                    + (\n",
    "                        str(x[\"sell\"][\"Name\"])\n",
    "                        + \" \"\n",
    "                        + str(\n",
    "                            *map(\n",
    "                                lambda y: f'{enchantments[y[\"id\"].py_int]} {y[\"lvl\"]}',\n",
    "                                list(x[\"sell\"][\"tag\"][\"ench\"]),\n",
    "                            )\n",
    "                        )\n",
    "                        if str(x[\"sell\"][\"Name\"]) == \"minecraft:enchanted_book\"\n",
    "                        else str(x[\"sell\"][\"Name\"])\n",
    "                    )\n",
    "                    + f\"({x['sell']['Count']})\",\n",
    "                    list(nbt[\"Offers\"][\"Recipes\"]),\n",
    "                )\n",
    "            ),\n",
    "            sep=\"\\n\",\n",
    "        )\n",
    "    print()\n",
    "\n",
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"actorprefix\")\n",
    "while iterator.key().startswith(b\"actorprefix\"):\n",
    "    nbt = amulet_nbt.load(\n",
    "        iterator.value(), little_endian=True, string_decoder=utf8_escape_decoder\n",
    "    ).compound\n",
    "    if str(nbt[\"identifier\"]) == \"minecraft:villager_v2\":\n",
    "        print_villager(nbt)\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe95e50c-2533-4d63-8fca-7ec5aa87da84",
   "metadata": {},
   "source": [
    "## ~local_player, player, and player_server\n",
    "Another key that's always around is ~local_player. If you've had remote players join the world, then there'd also be player and player_server records. Let's look at some of these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53f9ccfd-de3b-484a-9452-a460075f745a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(db[b\"~local_player\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ae9a164-6d58-4d1a-8a4d-3b6d871eb53f",
   "metadata": {},
   "source": [
    "Looks like more NBT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edb4b6ce-e294-4fd2-a05d-2421eab7c1b7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nbt = amulet_nbt.load(db[b\"~local_player\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "068cda8d-5c77-489c-9c28-59413971487e",
   "metadata": {},
   "source": [
    "Let's pretty-print some of the interesting bits from the NBT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e682270-bddc-4226-a1ba-ed705a00e505",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def display_armor(item):\n",
    "    name = str(item['Name'])\n",
    "    if name == \"\":\n",
    "        print(\"    empty\")\n",
    "    else:\n",
    "        short_name = name[10:]\n",
    "        if \"tag\" in item and \"display\" in item[\"tag\"]:\n",
    "            print(f\"    {short_name} ({item['tag']['display']['Name']})\")\n",
    "            # print enchantments?\n",
    "        else:\n",
    "            print(f\"    {short_name}\")\n",
    "    pass\n",
    "    \n",
    "def display_item(item):\n",
    "    name = str(item['Name'])\n",
    "    if name == \"\":\n",
    "        print(\"    empty\")\n",
    "    else:\n",
    "        short_name = name[10:]\n",
    "        if \"tag\" in item and \"display\" in item[\"tag\"]:\n",
    "            print(f\"    {short_name} ({item['tag']['display']['Name']})\")\n",
    "        else:\n",
    "            print(f\"    {short_name}\")\n",
    "        \n",
    "\n",
    "nbt = amulet_nbt.load(db[b\"~local_player\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print(\"Armor\")\n",
    "for i in nbt[\"Armor\"]:\n",
    "    display_armor(i)\n",
    "    \n",
    "print(\"EnderChestInventory\")\n",
    "for i in nbt[\"EnderChestInventory\"]:\n",
    "    display_item(i)\n",
    "    \n",
    "print(\"Inventory\")\n",
    "count = 0\n",
    "for i in nbt[\"Inventory\"]:\n",
    "    display_item(i)\n",
    "\n",
    "print(f\"Mainhand - {str(nbt['Mainhand'][0]['Name'])[10:]}\")\n",
    "print(f\"Offhand - {str(nbt['Offhand'][0]['Name'])[10:]}\")\n",
    "print(f\"Pos - {nbt['Pos']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69c4b7f4-06c9-4e27-b534-0c0d491cb3e5",
   "metadata": {},
   "source": [
    "## map_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db095476-e1f8-4d1c-93a2-29dff3511371",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"map_\")\n",
    "while iterator.key().startswith(b\"map_\"):\n",
    "    nbt = amulet_nbt.load(iterator.value(), little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "    print(f\"{iterator.key()} - ({nbt['xCenter']}, {nbt['zCenter']}) : scale - {nbt['scale']} : fullyExplored - {nbt['fullyExplored']} : decorations - {len(nbt['decorations'])}\")\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02d6795e-a6ce-4e18-a120-ce4b48c06afd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's print some maps\n",
    "\n",
    "def show_map(map_name):\n",
    "    import numpy\n",
    "    from PIL import Image\n",
    "\n",
    "    # Let's get the entire NBT\n",
    "    nbt = amulet_nbt.load(db[map_name], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "    \n",
    "    # Let's put the colors into a list\n",
    "    colors = list(nbt['colors'])\n",
    "\n",
    "    # There are four unsigned bytes per pixel of the map.\n",
    "    # I have no idea what column 4 represents, so let's delete it and treat it as RGB\n",
    "    del colors[4-1::4]\n",
    "\n",
    "    # Reshape c as a 128x128 matrix of 8-bit unsi[R G B] values\n",
    "    n_colors = numpy.array(colors).reshape(128, 128, -1).astype(numpy.uint8)\n",
    "    Image.fromarray(n_colors).resize((256, 256), resample=Image.Resampling.NEAREST).show()\n",
    "        \n",
    "def show_alpha_map(map_name):\n",
    "    import numpy\n",
    "    from PIL import Image\n",
    "\n",
    "    nbt = amulet_nbt.load(db[map_name], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "\n",
    "    # Let's get the fourth value for each pixel, and interpret a 0 as black and a -1 (or 255 unsigned int) as white\n",
    "    colors = list(map(lambda x: [0, 0, 0] if not x else [255, 255, 255], list(nbt['colors'])[3::4]))\n",
    "    n_colors = numpy.array(colors).reshape(128, 128, -1).astype(numpy.uint8)\n",
    "    Image.fromarray(n_colors).resize((256, 256), resample=Image.Resampling.NEAREST).show()\n",
    "\n",
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"map_\")\n",
    "while iterator.key().startswith(b\"map_\"):\n",
    "    print(iterator.key())\n",
    "    show_alpha_map(iterator.key())\n",
    "    show_map(iterator.key())\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8c41ad5-072c-43f4-a31c-eac625cdc257",
   "metadata": {},
   "source": [
    "## BiomeData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adbb2d20-44dd-41f5-87e8-d92f97ebb4c7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nbt = amulet_nbt.load(db[b\"BiomeData\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f80eeba-890b-4e5c-9610-1725170e703f",
   "metadata": {},
   "source": [
    "My guess is that the \"id\" is the binary biome id. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a6c40cb-1999-4805-99a6-8c56ea52a029",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# This data from https://minecraft.fandom.com/wiki/Biome\n",
    "biome_name_to_id = {\n",
    "    \"ocean\": 0,\n",
    "    \"legacy_frozen_ocean\": 10,\n",
    "    \"deep_ocean\": 24,\n",
    "    \"frozen_ocean\": 46,\n",
    "    \"deep_frozen_ocean\": 47,\n",
    "    \"cold_ocean\": 44,\n",
    "    \"deep_cold_ocean\": 45,\n",
    "    \"lukewarm_ocean\": 42,\n",
    "    \"deep_lukewarm_ocean\": 43,\n",
    "    \"warm_ocean\": 40,\n",
    "    \"deep_warm_ocean\": 41,\n",
    "    \"river\": 7,\n",
    "    \"frozen_river\": 11,\n",
    "    \"beach\": 16,\n",
    "    \"stone_beach\": 25,\n",
    "    \"cold_beach\": 26,\n",
    "    \"forest\": 4,\n",
    "    \"forest_hills\": 18,\n",
    "    \"flower_forest\": 132,\n",
    "    \"birch_forest\": 27,\n",
    "    \"birch_forest_hills\": 28,\n",
    "    \"birch_forest_mutated\": 155,\n",
    "    \"birch_forest_hills_mutated\": 156,\n",
    "    \"roofed_forest\": 29,\n",
    "    \"roofed_forest_mutated\": 157,\n",
    "    \"jungle\": 21,\n",
    "    \"jungle_hills\": 22,\n",
    "    \"jungle_mutated\": 149,\n",
    "    \"jungle_edge\": 23,\n",
    "    \"jungle_edge_mutated\": 151,\n",
    "    \"bamboo_jungle\": 48,\n",
    "    \"bamboo_jungle_hills\": 49,\n",
    "    \"taiga\": 5,\n",
    "    \"taiga_hills\": 19,\n",
    "    \"taiga_mutated\": 133,\n",
    "    \"cold_taiga\": 30,\n",
    "    \"cold_taiga_hills\": 31,\n",
    "    \"cold_taiga_mutated\": 158,\n",
    "    \"mega_taiga\": 32,\n",
    "    \"mega_taiga_hills\": 33,\n",
    "    \"redwood_taiga_mutated\": 160,\n",
    "    \"redwood_taiga_hills_mutated\": 161,\n",
    "    \"mushroom_island\": 14,\n",
    "    \"mushroom_island_shore\": 15,\n",
    "    \"swampland\": 6,\n",
    "    \"swampland_mutated\": 134,\n",
    "    \"savanna\": 35,\n",
    "    \"savanna_plateau\": 36,\n",
    "    \"savanna_mutated\": 163,\n",
    "    \"savanna_plateau_mutated\": 164,\n",
    "    \"plains\": 1,\n",
    "    \"sunflower_plains\": 129,\n",
    "    \"desert\": 2,\n",
    "    \"desert_hills\": 17,\n",
    "    \"desert_mutated\": 130,\n",
    "    \"ice_plains\": 12,\n",
    "    \"ice_mountains\": 13,\n",
    "    \"ice_plains_spikes\": 140,\n",
    "    \"extreme_hills\": 3,\n",
    "    \"extreme_hills_plus_trees\": 34,\n",
    "    \"extreme_hills_mutated\": 131,\n",
    "    \"extreme_hills_plus_trees_mutated\": 162,\n",
    "    \"extreme_hills_edge\": 20,\n",
    "    \"mesa\": 37,\n",
    "    \"mesa_plateau\": 39,\n",
    "    \"mesa_plateau_mutated\": 167,\n",
    "    \"mesa_plateau_stone\": 38,\n",
    "    \"mesa_plateau_stone_mutated\": 166,\n",
    "    \"mesa_bryce\": 165,\n",
    "    \"meadow\": 186,\n",
    "    \"grove\": 185,\n",
    "    \"snowy_slopes\": 184,\n",
    "    \"jagged_peaks\": 182,\n",
    "    \"frozen_peaks\": 183,\n",
    "    \"stony_peaks\": 189,\n",
    "    \"lush_caves\": 187,\n",
    "    \"dripstone_caves\": 188,\n",
    "    \"deep_dark\": 190,\n",
    "    \"mangrove_swamp\": 191,\n",
    "    \"hell\": 8,\n",
    "    \"crimson_forest\": 179,\n",
    "    \"warped_forest\": 180,\n",
    "    \"soulsand_valley\": 178,\n",
    "    \"basalt_deltas\": 181,\n",
    "    \"the_end\": 9,\n",
    "    \"cherry_grove\": 192\n",
    "}\n",
    "\n",
    "biome_id_to_name = {v: k for k, v in biome_name_to_id.items()}\n",
    "\n",
    "nbt = amulet_nbt.load(db[b\"BiomeData\"], little_endian=True, string_decoder=utf8_escape_decoder).compound[\"list\"]\n",
    "for i in nbt:\n",
    "    # The Amulet NBT library doesn't seem to be able to return the ByteTag as a python \"bytes\" object\n",
    "    # I'd like to convert the signed int to an unsigned int since the wiki's biome data is unsigned.\n",
    "    bytes = int(i[\"id\"]).to_bytes(1, byteorder=\"little\", signed=True) # It's just a single byte, so \"byte order\" doesn't really matter\n",
    "    uint = int.from_bytes(bytes, byteorder=\"little\", signed=False)\n",
    "    print(biome_id_to_name[uint])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b752cfa-57f0-434f-a2db-430def131ecb",
   "metadata": {},
   "source": [
    "Looks like a correct assumption."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc09b908-c7ea-4b01-98bf-35f9a3419a55",
   "metadata": {},
   "source": [
    "## AutonomousEntities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b72a56ab-781f-4117-a17f-497064f8216c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nbt = amulet_nbt.load(db[b\"AutonomousEntities\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f60c6f36-85c3-478e-9538-c7d5caed036d",
   "metadata": {},
   "source": [
    "Nothing exciting there."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f0458b7-2ce9-4c22-9592-4baea6314954",
   "metadata": {},
   "source": [
    "## Overworld"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf186bec-2b7a-44b8-9ab7-458a33bc6cfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "nbt = amulet_nbt.load(db[b\"Overworld\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d2f303a-6673-4c7b-9e3d-b96f3137aa04",
   "metadata": {},
   "source": [
    "Nothing exciting there either."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dda04ad3-f97a-4d46-89e5-7d3124610f18",
   "metadata": {},
   "source": [
    "## mobevents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "975a8784-ff1f-4409-951a-968c81b41dc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "nbt = amulet_nbt.load(db[b\"mobevents\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74866038-5e56-4cc4-a7b2-8ef3eceab7c5",
   "metadata": {},
   "source": [
    "## schedulerWT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2f4d0fc-4458-4586-8655-38bfc6f75451",
   "metadata": {},
   "outputs": [],
   "source": [
    "nbt = amulet_nbt.load(db[b\"schedulerWT\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b530e05-799b-4edc-88fe-5de3c73ddd6f",
   "metadata": {},
   "source": [
    "## scoreboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72d0bba8-b8b4-4d36-a572-84e634d58441",
   "metadata": {},
   "outputs": [],
   "source": [
    "nbt = amulet_nbt.load(db[b\"scoreboard\"], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_nbt(nbt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "620e8e40-9974-4dc2-8aba-f3c23ec3ca57",
   "metadata": {},
   "source": [
    "## VILLAGE\n",
    "\n",
    "Let's look at Village keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c7a00f3-bbef-4256-b353-24c8a7c6db91",
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"VILLAGE_\")\n",
    "while iterator.key().startswith(b\"VILLAGE_\"):\n",
    "    print(iterator.key())\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3848471d-594d-416b-af21-1fa9d25d00b4",
   "metadata": {},
   "source": [
    "I'm guessing these keys are \"VILLAGE_\" + unique village ID + ('_DWELLERS', '_INFO', '_PLAYERS', '_POI'). Let's look at the sizes of the different subkeys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bac073d-871f-47bc-8778-6f356ac6932c",
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"VILLAGE_\")\n",
    "while iterator.key().startswith(b\"VILLAGE_\"):\n",
    "    print(f\"{iterator.key()}: {len(iterator.value())}\")\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e91cf05a-7aa8-4341-8bb4-8889295c7fa8",
   "metadata": {},
   "source": [
    "'PLAYERS' is the smallest, so let's start with that one."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f1288a2-6cb3-48cd-8fb8-5c6320d09d9c",
   "metadata": {},
   "source": [
    "### PLAYERS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a05e313-ca6b-4d24-9f87-0c0cb31c11cc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"VILLAGE_\")\n",
    "while iterator.key().startswith(b\"VILLAGE_\"):\n",
    "    if iterator.key().endswith(b\"_PLAYERS\"):\n",
    "        print(iterator.key())\n",
    "        nbt = amulet_nbt.load(iterator.value(), little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "        print_nbt(nbt)\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f1ccdc9-ff70-41a6-b882-734df942a830",
   "metadata": {},
   "source": [
    "### INFO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12bc6b84-d144-4973-b9ca-c8bfc9c4298b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"VILLAGE_\")\n",
    "while iterator.key().startswith(b\"VILLAGE_\"):\n",
    "    if iterator.key().endswith(b\"_INFO\"):\n",
    "        print(iterator.key())\n",
    "        nbt = amulet_nbt.load(iterator.value(), little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "        print_nbt(nbt)\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ada6f972-89c8-4e65-869c-d40bc6eb1d53",
   "metadata": {},
   "source": [
    "### DWELLERS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2040d4a0-b12b-4543-b82f-eefa483dfaf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"VILLAGE_\")\n",
    "while iterator.key().startswith(b\"VILLAGE_\"):\n",
    "    if iterator.key().endswith(b\"_DWELLERS\"):\n",
    "        print(iterator.key())\n",
    "        nbt = amulet_nbt.load(iterator.value(), little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "        print_nbt(nbt)\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "116a1c21-0538-4631-9ad3-7944909e6f2c",
   "metadata": {},
   "source": [
    "### POI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89050e0c-fa02-43ea-96ec-46b98c32b5c5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "iterator = db.new_iterator()\n",
    "iterator.seek(b\"VILLAGE_\")\n",
    "while iterator.key().startswith(b\"VILLAGE_\"):\n",
    "    if iterator.key().endswith(b\"_POI\"):\n",
    "        print(iterator.key())\n",
    "        nbt = amulet_nbt.load(iterator.value(), little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "        print_nbt(nbt)\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58a27d73-71d2-4658-893e-684ec829662f",
   "metadata": {},
   "source": [
    "# Chunk Keys\n",
    "\n",
    "Here we get to the meat of the data. Chunk keys. The Minecraft world is divided into chunks. Each chunk in the database is a box that is 16 blocks long in the x axis, 16 wide in the z axis, and spans from bedrock to the build limit in the y axis.\n",
    "\n",
    "The format of these LevelDB keys is somewhat like the digp keys; for the _overworld_ the key is (chunk_x, chunk_z, chunk_tag). If the chunk_tag is 0x2F (or '/' in ASCII) then there's an additional byte for a subchunk id. Chunk keys for the nether and the end are (chunk_x, chunk_z, dimension_id, chunk_tag) where dimension_id is 1 for the nether and 2 for the end. The subchunk additional byetes are also possible. As we saw above, the local_player is at (x, z) of (1, -27). Let's look at that chunk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b2609a8-16ae-4f51-8c1a-26f6a1d8676d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def x_z_to_chunk_x_chunk_z(x, z):\n",
    "    return (x // 16, z // 16)\n",
    "\n",
    "x = 1\n",
    "z = -27\n",
    "print(f\"(x, z): ({x}, {z}) is (chunk_x, chunk_z): {x_z_to_chunk_x_chunk_z(x, z)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abf6727b-726c-4ebf-8e9a-ee40d3436c01",
   "metadata": {},
   "outputs": [],
   "source": [
    "from struct import pack\n",
    "\n",
    "x = 1\n",
    "z = -27\n",
    "\n",
    "(chunk_x, chunk_z) = x_z_to_chunk_x_chunk_z(x, z)\n",
    "chunk_key_x_z = pack(\"ii\", chunk_x, chunk_z)\n",
    "\n",
    "iterator = db.new_iterator()\n",
    "iterator.seek(chunk_key_x_z+b'\\x2b')\n",
    "while iterator.key().startswith(chunk_key_x_z):\n",
    "    print(iterator.key())\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56e021f7-330b-42a8-8ef9-20ef560897b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data from https://learn.microsoft.com/en-us/minecraft/creator/documents/actorstorage\n",
    "LevelChunkTag_name_to_id = {\n",
    "    \"Data3D\": 43,\n",
    "    \"Version\": 44,\n",
    "    \"Data2D\": 45,\n",
    "    \"Data2DLegacy\": 46,\n",
    "    \"SubChunkPrefix\": 47,\n",
    "    \"LegacyTerrain\": 48,\n",
    "    \"BlockEntity\": 49,\n",
    "    \"Entity\": 50,\n",
    "    \"PendingTicks\": 51,\n",
    "    \"LegacyBlockExtraData\": 52,\n",
    "    \"BiomeState\": 53,\n",
    "    \"FinalizedState\": 54,\n",
    "    \"ConversionData\": 55,\n",
    "    \"BorderBlocks\": 56,\n",
    "    \"HardcodedSpawners\": 57,\n",
    "    \"RandomTicks\": 58,\n",
    "    \"CheckSums\": 59,\n",
    "    \"GenerationSeed\": 60,\n",
    "    \"GeneratedPreCavesAndCliffsBlending\": 61,\n",
    "    \"BlendingBiomeHeight\": 62,\n",
    "    \"MetaDataHash\": 63,\n",
    "    \"BlendingData\": 64,\n",
    "    \"ActorDigestVersion\": 65,\n",
    "    \"LegacyVersion\": 118\n",
    "}\n",
    "\n",
    "LevelChunkTag_id_to_name = {v: k for k, v in LevelChunkTag_name_to_id.items()}\n",
    "\n",
    "iterator = db.new_iterator()\n",
    "chunk_x = 0\n",
    "chunk_z = -2\n",
    "chunk_key_x_z = pack(\"ii\", chunk_x, chunk_z)\n",
    "iterator.seek(chunk_key_x_z+b'\\x2b')\n",
    "while iterator.key().startswith(chunk_key_x_z):\n",
    "    chunk_x = int.from_bytes(iterator.key()[0:3], byteorder=\"little\", signed = True)\n",
    "    chunk_z = int.from_bytes(iterator.key()[4:7], byteorder=\"little\", signed = True)\n",
    "    LevelChunkTag_name = LevelChunkTag_id_to_name[int.from_bytes(iterator.key()[8:9], byteorder=\"little\")]\n",
    "    print(f\"chunk ({chunk_x}, {chunk_z}) : {LevelChunkTag_name}\")\n",
    "    iterator.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79b48735-ba06-4938-aee0-355776d6b727",
   "metadata": {},
   "source": [
    "## BlockEntity\n",
    "\n",
    "The BlockEntity keys contain data about blocks in the chunk that have variable states, such as the inventories of chests, hoppers, and furnaces, for example, or the text that's written on signs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5509921b-c0e1-4e16-81f9-ba75398d2279",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_items(items):\n",
    "    if len(items) == 0:\n",
    "        print(\"    Empty\")\n",
    "    else:\n",
    "        for item in items:\n",
    "            print(f\"    Slot {item['Slot']} - {item['Name']} ({item['Count']})\")\n",
    "            \n",
    "chunk_key = pack(\"iic\", chunk_x, chunk_z, LevelChunkTag_name_to_id[\"BlockEntity\"].to_bytes(1, \"little\"))\n",
    "nbt = amulet_nbt.load(db[chunk_key], little_endian=True, string_decoder=utf8_escape_decoder).compound\n",
    "print_items(nbt[\"Items\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27a6b1df-8470-4e14-b25a-a0cbc280e98b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# db.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}