(=°ω°)丿
python3 是否有方法可以读取并修改例如原版末地船的 nbt 或者 command storage 等文件？
阴阳师元素祭祀
有啊有啊
一个编程语言怎么可能读写不了文件呢
按照字节读自己解析即可了
https://wiki.biligame.com/mc/NBT%E6%A0%BC%E5%BC%8F


代码思路可以参考
https://www.mcbbs.net/thread-1014198-272076-1.html
这边帮忙折叠了只解析了int和{}的nbt代码


代码:

  1. private static String getYYS(int depth) {
  2.   StringBuilder sb = new StringBuilder();
  3.   for (int i = 0; i < depth; ++i) {
  4.    sb.append("    ");
  5.   }
  6.   return sb.toString();
  7.     }
  8.     private static void read(DataInputStream in, int depth) throws IOException {
  9.   boolean next = true;
  10.   while (next) {
  11.    byte tag = in.readByte();
  12.    next = tag != 0;
  13.    if (next) {
  14.     short nameLength = in.readShort();
  15.     if (nameLength != 0) {
  16.   byte[] name = new byte[nameLength];
  17.   if (in.read(name) != name.length) {
  18.    throw new IOException("ljyys for name error");
  19.   }
  20.   String tagName = new String(name);
  21.   System.out.println(getYYS(depth) + tagName + " {");
  22.     } else {
  23.   System.out.println(getYYS(depth) + "{");
  24.     }
  25.     switch (tag) {
  26.   case 0x3: {
  27.    System.out.println(getYYS(depth + 1) + in.readInt());
  28.    System.out.println(getYYS(depth) + "}");
  29.    break;
  30.   }
  31.   case 0xA: {
  32.    read(in, depth + 1);
  33.    next = in.available() > 0;
  34.    break;
  35.   }
  36.   default: {
  37.    System.out.println("data left: " + in.available());
  38.    throw new IOException("ljyys for tag:" + tag);
  39.   }
  40.     }
  41.    }
  42.   }
  43.   System.out.println(getYYS(depth) + "}");
  44.     }
  45.     public static void main(String[] args) throws Throwable {
  46.   DataInputStream in = new DataInputStream(Files.newInputStream(Paths.get("command_storage_minecraft")));
  47.   read(in, 0);
  48.     }



我相信 简单 的 python 代码 会更少


py:
open(...)
read(...)
我相信楼主肯定会python 不至于基础代码还需要教


(=°ω°)丿
阴阳师元素祭祀 发表于 2020-4-11 21:52
有啊有啊
一个编程语言怎么可能读写不了文件呢
https://wiki.biligame.com/mc/NBT%E6%A0%BC%E5%BC%8F

我说的是 python 而你给的是 java（
阴阳师元素祭祀
(=°ω°)丿 发表于 2020-4-11 21:53
我说的是 python 而你给的是 java（

根据隔壁群的情况 我猜测
你需要
@箱子 的好东西


[搬运+翻译][从零学编程]Python3Ⅳ：异常 &amp; 文件
https://www.mcbbs.net/thread-990257-1-1.html
(出处: Minecraft(我的世界)中文论坛)


你 该不会想要完整代码吧...   走莉走莉
阴阳师元素祭祀
(=°ω°)丿 发表于 2020-4-11 22:24
那你就帮我把 https://pca006132.neocities.org/tutorials/nbt/format.html 里的 python nbt 库下载下来 ...

因为不会下载
所以..请原谅我这样发文件
https://github.com/twoolie/NBT


是重要的协议：
Copyright (c) 2010-2013 Thomas Woolford and contributors


Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the &quot;Software&quot;), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:


The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.


THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

nbt/__init__.py


代码:


  2. __all__ = ["nbt", "world", "region", "chunk"]
  3. from . import *

  5. # Documentation only automatically includes functions specified in __all__.
  6. # If you add more functions, please manually include them in doc/index.rst.

  8. VERSION = (1, 5, 0)
  9. """NBT version as tuple. Note that the major and minor revision number are
  10. always present, but the patch identifier (the 3rd number) is only used in 1.4."""

  12. def _get_version():
  13.     """Return the NBT version as string."""
  14.     return ".".join([str(v) for v in VERSION])



nbt/chunk.py


代码:


  2. """
  3. Handles a single chunk of data (16x16x128 blocks) from a Minecraft save.
  4. For more information about the chunck format:
  5. https://minecraft.gamepedia.com/Chunk_format
  6. """

  8. from io import BytesIO
  9. from struct import pack
  10. import array
  11. import nbt


  14. # Legacy numeric block identifiers
  15. # mapped to alpha identifiers in best effort
  16. # See https://minecraft.gamepedia.com/Java_Edition_data_values/Pre-flattening
  17. # TODO: move this map into a separate file

  19. block_ids = {
  20.    0: 'air',
  21.    1: 'stone',
  22.    2: 'grass_block',
  23.    3: 'dirt',
  24.    4: 'cobblestone',
  25.    5: 'oak_planks',
  26.    6: 'sapling',
  27.    7: 'bedrock',
  28.    8: 'flowing_water',
  29.    9: 'water',
  30.   10: 'flowing_lava',
  31.   11: 'lava',
  32.   12: 'sand',
  33.   13: 'gravel',
  34.   14: 'gold_ore',
  35.   15: 'iron_ore',
  36.   16: 'coal_ore',
  37.   17: 'oak_log',
  38.   18: 'oak_leaves',
  39.   19: 'sponge',
  40.   20: 'glass',
  41.   21: 'lapis_ore',
  42.   24: 'sandstone',
  43.   30: 'cobweb',
  44.   31: 'grass',
  45.   32: 'dead_bush',
  46.   35: 'white_wool',
  47.   37: 'dandelion',
  48.   38: 'poppy',
  49.   39: 'brown_mushroom',
  50.   40: 'red_mushroom',
  51.   43: 'stone_slab',
  52.   44: 'stone_slab',
  53.   47: 'bookshelf',
  54.   48: 'mossy_cobblestone',
  55.   49: 'obsidian',
  56.   50: 'torch',
  57.   51: 'fire',
  58.   52: 'spawner',
  59.   53: 'oak_stairs',
  60.   54: 'chest',
  61.   56: 'diamond_ore',
  62.   58: 'crafting_table',
  63.   59: 'wheat',
  64.   60: 'farmland',
  65.   61: 'furnace',
  66.   62: 'furnace',
  67.   63: 'sign',# will change to oak_sign in 1.14
  68.   64: 'oak_door',
  69.   65: 'ladder',
  70.   66: 'rail',
  71.   67: 'cobblestone_stairs',
  72.   72: 'oak_pressure_plate',
  73.   73: 'redstone_ore',
  74.   74: 'redstone_ore',
  75.   78: 'snow',
  76.   79: 'ice',
  77.   81: 'cactus',
  78.   82: 'clay',
  79.   83: 'sugar_cane',
  80.   85: 'oak_fence',
  81.   86: 'pumpkin',
  82.   91: 'lit_pumpkin',
  83.     101: 'iron_bars',
  84.     102: 'glass_pane',
  85.     }


  88. def block_id_to_name(bid):
  89.     try:
  90.   name = block_ids[bid]
  91.     except KeyError:
  92.   name = 'unknown_%d' % (bid,)
  93.   print("warning: unknown block id %i" % bid)
  94.   print("hint: add that block to the 'block_ids' map")
  95.     return name


  98. # Generic Chunk

  100. class Chunk(object):
  101.     """Class for representing a single chunk."""
  102.     def __init__(self, nbt):
  103.   self.chunk_data = nbt['Level']
  104.   self.coords = self.chunk_data['xPos'],self.chunk_data['zPos']

  106.     def get_coords(self):
  107.   """Return the coordinates of this chunk."""
  108.   return (self.coords[0].value,self.coords[1].value)

  110.     def __repr__(self):
  111.   """Return a representation of this Chunk."""
  112.   return "Chunk("+str(self.coords[0])+","+str(self.coords[1])+")"


  115. # Chunk in Region old format

  117. class McRegionChunk(Chunk):

  119.     def __init__(self, nbt):
  120.   Chunk.__init__(self, nbt)
  121.   self.blocks = BlockArray(self.chunk_data['Blocks'].value, self.chunk_data['Data'].value)

  123.     def get_max_height(self):
  124.   return 127

  126.     def get_block(self, x, y, z):
  127.   name = block_id_to_name(self.blocks.get_block(x, y, z))
  128.   return name

  130.     def iter_block(self):
  131.   for y in range(0, 128):
  132.    for z in range(0, 16):
  133.     for x in range(0, 16):
  134.   yield self.get_block(x, y, z)


  137. # Section in Anvil new format

  139. class AnvilSection(object):

  141.     def __init__(self, nbt, version):
  142.   self.names = []
  143.   self.indexes = []

  145.   # Is the section flattened ?
  146.   # See https://minecraft.gamepedia.com/1.13/Flattening

  148.   if version == 0 or version == 1343:# 1343 = MC 1.12.2
  149.    self._init_array(nbt)
  150.   elif version == 1631:# MC 1.13
  151.    self._init_index(nbt)
  152.   else:
  153.    raise NotImplementedError()

  155.   # Section contains 4096 blocks whatever data version

  157.   assert len(self.indexes) == 4096


  160.     # Decode legacy section
  161.     # Contains an array of block numeric identifiers

  163.     def _init_array(self, nbt):
  164.   bids = []
  165.   for bid in nbt['Blocks'].value:
  166.    try:
  167.     i = bids.index(bid)
  168.    except ValueError:
  169.     bids.append(bid)
  170.     i = len(bids) - 1
  171.    self.indexes.append(i)

  173.   for bid in bids:
  174.    bname = block_id_to_name(bid)
  175.    self.names.append(bname)


  178.     # Decode modern section
  179.     # Contains palette of block names and indexes

  181.     def _init_index(self, nbt):

  183.   for p in nbt['Palette']:
  184.    name = p['Name'].value
  185.    if name.startswith('minecraft:'):
  186.     name = name[10:]
  187.    self.names.append(name)

  189.   states = nbt['BlockStates'].value

  191.   # Block states are packed into an array of longs
  192.   # with variable number of bits per block (min: 4)

  194.   nb = (len(self.names) - 1).bit_length()
  195.   if nb < 4: nb = 4
  196.   assert nb == len(states) * 8 * 8 / 4096
  197.   m = pow(2, nb) - 1

  199.   j = 0
  200.   bl = 64
  201.   ll = states[0]

  203.   for i in range(0,4096):
  204.    if bl == 0:
  205.     j = j + 1
  206.     ll = states[j]
  207.     bl = 64

  209.    if nb <= bl:
  210.     self.indexes.append(ll & m)
  211.     ll = ll >> nb
  212.     bl = bl - nb
  213.    else:
  214.     j = j + 1
  215.     lh = states[j]
  216.     bh = nb - bl

  218.     lh = (lh & (pow(2, bh) - 1)) << bl
  219.     ll = (ll & (pow(2, bl) - 1))
  220.     self.indexes.append(lh | ll)

  222.     ll = states[j]
  223.     ll = ll >> bh
  224.     bl = 64 - bh


  227.     def get_block(self, x, y, z):
  228.   # Blocks are stored in YZX order
  229.   i = y * 256 + z * 16 + x
  230.   p = self.indexes
  231.   return self.names[p]


  234.     def iter_block(self):
  235.   for i in range(0, 4096):
  236.    p = self.indexes
  237.    yield self.names[p]


  240. # Chunck in Anvil new format

  242. class AnvilChunk(Chunk):

  244.     def __init__(self, nbt):
  245.   Chunk.__init__(self, nbt)

  247.   # Started to work on this class with MC version 1.13.2
  248.   # so with the chunk data version 1631
  249.   # Backported to first Anvil version (= 0) from examples
  250.   # Could work with other versions, but has to be tested first

  252.   try:
  253.    version = nbt['DataVersion'].value
  254.    if version != 1343 and version != 1631:
  255.     raise NotImplementedError('DataVersion %d not implemented' % (version,))
  256.   except KeyError:
  257.    version = 0

  259.   # Load all sections

  261.   self.sections = {}
  262.   if 'Sections' in self.chunk_data:
  263.    for s in self.chunk_data['Sections']:
  264.     self.sections[s['Y'].value] = AnvilSection(s, version)


  267.     def get_section(self, y):
  268.   """Get a section from Y index."""
  269.   if y in self.sections:
  270.    return self.sections[y]

  272.   return None


  275.     def get_max_height(self):
  276.   ymax = 0
  277.   for y in self.sections.keys():
  278.    if y > ymax: ymax = y
  279.   return ymax * 16 + 15


  282.     def get_block(self, x, y, z):
  283.   """Get a block from relative x,y,z."""
  284.   sy,by = divmod(y, 16)
  285.   section = self.get_section(sy)
  286.   if section == None:
  287.    return None

  289.   return section.get_block(x, by, z)


  292.     def iter_block(self):
  293.   for s in self.sections.values():
  294.    for b in s.iter_block():
  295.     yield b


  298. class BlockArray(object):
  299.     """Convenience class for dealing with a Block/data byte array."""
  300.     def __init__(self, blocksBytes=None, dataBytes=None):
  301.   """Create a new BlockArray, defaulting to no block or data bytes."""
  302.   if isinstance(blocksBytes, (bytearray, array.array)):
  303.    self.blocksList = list(blocksBytes)
  304.   else:
  305.    self.blocksList = [0]*32768 # Create an empty block list (32768 entries of zero (air))

  307.   if isinstance(dataBytes, (bytearray, array.array)):
  308.    self.dataList = list(dataBytes)
  309.   else:
  310.    self.dataList = [0]*16384 # Create an empty data list (32768 4-bit entries of zero make 16384 byte entries)

  312.     def get_blocks_struct(self):
  313.   """Return a dictionary with block ids keyed to (x, y, z)."""
  314.   cur_x = 0
  315.   cur_y = 0
  316.   cur_z = 0
  317.   blocks = {}
  318.   for block_id in self.blocksList:
  319.    blocks[(cur_x,cur_y,cur_z)] = block_id
  320.    cur_y += 1
  321.    if (cur_y > 127):
  322.     cur_y = 0
  323.     cur_z += 1
  324.     if (cur_z > 15):
  325.   cur_z = 0
  326.   cur_x += 1
  327.   return blocks

  329.     # Give blockList back as a byte array
  330.     def get_blocks_byte_array(self, buffer=False):
  331.   """Return a list of all blocks in this chunk."""
  332.   if buffer:
  333.    length = len(self.blocksList)
  334.    return BytesIO(pack(">i", length)+self.get_blocks_byte_array())
  335.   else:
  336.    return array.array('B', self.blocksList).tostring()

  338.     def get_data_byte_array(self, buffer=False):
  339.   """Return a list of data for all blocks in this chunk."""
  340.   if buffer:
  341.    length = len(self.dataList)
  342.    return BytesIO(pack(">i", length)+self.get_data_byte_array())
  343.   else:
  344.    return array.array('B', self.dataList).tostring()

  346.     def generate_heightmap(self, buffer=False, as_array=False):
  347.   """Return a heightmap, representing the highest solid blocks in this chunk."""
  348.   non_solids = [0, 8, 9, 10, 11, 38, 37, 32, 31]
  349.   if buffer:
  350.    return BytesIO(pack(">i", 256)+self.generate_heightmap()) # Length + Heightmap, ready for insertion into Chunk NBT
  351.   else:
  352.    bytes = []
  353.    for z in range(16):
  354.     for x in range(16):
  355.   for y in range(127, -1, -1):
  356.    offset = y + z*128 + x*128*16
  357.    if (self.blocksList[offset] not in non_solids or y == 0):
  358.     bytes.append(y+1)
  359.     break
  360.    if (as_array):
  361.     return bytes
  362.    else:
  363.     return array.array('B', bytes).tostring()

  365.     def set_blocks(self, list=None, dict=None, fill_air=False):
  366.   """
  367.   Sets all blocks in this chunk, using either a list or dictionary.
  368.   Blocks not explicitly set can be filled to air by setting fill_air to True.
  369.   """
  370.   if list:
  371.    # Inputting a list like self.blocksList
  372.    self.blocksList = list
  373.   elif dict:
  374.    # Inputting a dictionary like result of self.get_blocks_struct()
  375.    list = []
  376.    for x in range(16):
  377.     for z in range(16):
  378.   for y in range(128):
  379.    coord = x,y,z
  380.    offset = y + z*128 + x*128*16
  381.    if (coord in dict):
  382.     list.append(dict[coord])
  383.    else:
  384.     if (self.blocksList[offset] and not fill_air):
  385.   list.append(self.blocksList[offset])
  386.     else:
  387.   list.append(0) # Air
  388.    self.blocksList = list
  389.   else:
  390.    # None of the above...
  391.    return False
  392.   return True

  394.     def set_block(self, x,y,z, id, data=0):
  395.   """Sets the block a x, y, z to the specified id, and optionally data."""
  396.   offset = y + z*128 + x*128*16
  397.   self.blocksList[offset] = id
  398.   if (offset % 2 == 1):
  399.    # offset is odd
  400.    index = (offset-1)//2
  401.    b = self.dataList[index]
  402.    self.dataList[index] = (b & 240) + (data & 15) # modify lower bits, leaving higher bits in place
  403.   else:
  404.    # offset is even
  405.    index = offset//2
  406.    b = self.dataList[index]
  407.    self.dataList[index] = (b & 15) + (data << 4 & 240) # modify ligher bits, leaving lower bits in place

  409.     # Get a given X,Y,Z or a tuple of three coordinates
  410.     def get_block(self, x,y,z, coord=False):
  411.   """Return the id of the block at x, y, z."""
  412.   """
  413.   Laid out like:
  414.   (0,0,0), (0,1,0), (0,2,0) ... (0,127,0), (0,0,1), (0,1,1), (0,2,1) ... (0,127,1), (0,0,2) ... (0,127,15), (1,0,0), (1,1,0) ... (15,127,15)
  415.  
  416.   ::
  417.  
  418.     blocks = []
  419.     for x in range(15):
  420.    for z in range(15):
  421.   for y in range(127):
  422.     blocks.append(Block(x,y,z))
  423.   """

  425.   offset = y + z*128 + x*128*16 if (coord == False) else coord[1] + coord[2]*128 + coord[0]*128*16
  426.   return self.blocksList[offset]



nbt/nbt.py


代码:


  2. """
  3. Handle the NBT (Named Binary Tag) data format
  4. For more information about the NBT format:
  5. https://minecraft.gamepedia.com/NBT_format
  6. """

  8. from struct import Struct, error as StructError
  9. from gzip import GzipFile
  10. from collections import MutableMapping, MutableSequence, Sequence
  11. import sys

  13. _PY3 = sys.version_info >= (3,)
  14. if _PY3:
  15.     unicode = str
  16.     basestring = str
  17. else:
  18.     range = xrange

  20. TAG_END = 0
  21. TAG_BYTE = 1
  22. TAG_SHORT = 2
  23. TAG_INT = 3
  24. TAG_LONG = 4
  25. TAG_FLOAT = 5
  26. TAG_DOUBLE = 6
  27. TAG_BYTE_ARRAY = 7
  28. TAG_STRING = 8
  29. TAG_LIST = 9
  30. TAG_COMPOUND = 10
  31. TAG_INT_ARRAY = 11
  32. TAG_LONG_ARRAY = 12


  35. class MalformedFileError(Exception):
  36.     """Exception raised on parse error."""
  37.     pass


  40. class TAG(object):
  41.     """TAG, a variable with an intrinsic name."""
  42.     id = None

  44.     def __init__(self, value=None, name=None):
  45.   self.name = name
  46.   self.value = value

  48.     # Parsers and Generators
  49.     def _parse_buffer(self, buffer):
  50.   raise NotImplementedError(self.__class__.__name__)

  52.     def _render_buffer(self, buffer):
  53.   raise NotImplementedError(self.__class__.__name__)

  55.     # Printing and Formatting of tree
  56.     def tag_info(self):
  57.   """Return Unicode string with class, name and unnested value."""
  58.   return self.__class__.__name__ + (
  59.    '(%r)' % self.name if self.name
  60.    else "") + ": " + self.valuestr()

  62.     def valuestr(self):
  63.   """Return Unicode string of unnested value. For iterators, this
  64.   returns a summary."""
  65.   return unicode(self.value)

  67.     def pretty_tree(self, indent=0):
  68.   """Return formated Unicode string of self, where iterable items are
  69.   recursively listed in detail."""
  70.   return ("\t" * indent) + self.tag_info()

  72.     # Python 2 compatibility; Python 3 uses __str__ instead.
  73.     def __unicode__(self):
  74.   """Return a unicode string with the result in human readable format.
  75.   Unlike valuestr(), the result is recursive for iterators till at least
  76.   one level deep."""
  77.   return unicode(self.value)

  79.     def __str__(self):
  80.   """Return a string (ascii formated for Python 2, unicode for Python 3)
  81.   with the result in human readable format. Unlike valuestr(), the result
  82.    is recursive for iterators till at least one level deep."""
  83.   return str(self.value)

  85.     # Unlike regular iterators, __repr__() is not recursive.
  86.     # Use pretty_tree for recursive results.
  87.     # iterators should use __repr__ or tag_info for each item, like
  88.     #regular iterators
  89.     def __repr__(self):
  90.   """Return a string (ascii formated for Python 2, unicode for Python 3)
  91.   describing the class, name and id for debugging purposes."""
  92.   return "<%s(%r) at 0x%x>" % (
  93.    self.__class__.__name__, self.name, id(self))


  96. class _TAG_Numeric(TAG):
  97.     """_TAG_Numeric, comparable to int with an intrinsic name"""

  99.     def __init__(self, value=None, name=None, buffer=None):
  100.   super(_TAG_Numeric, self).__init__(value, name)
  101.   if buffer:
  102.    self._parse_buffer(buffer)

  104.     # Parsers and Generators
  105.     def _parse_buffer(self, buffer):
  106.   # Note: buffer.read() may raise an IOError, for example if buffer is a
  107.   # corrupt gzip.GzipFile
  108.   self.value = self.fmt.unpack(buffer.read(self.fmt.size))[0]

  110.     def _render_buffer(self, buffer):
  111.   buffer.write(self.fmt.pack(self.value))


  114. class _TAG_End(TAG):
  115.     id = TAG_END
  116.     fmt = Struct(">b")

  118.     def _parse_buffer(self, buffer):
  119.   # Note: buffer.read() may raise an IOError, for example if buffer is a
  120.   # corrupt gzip.GzipFile
  121.   value = self.fmt.unpack(buffer.read(1))[0]
  122.   if value != 0:
  123.    raise ValueError(
  124.     "A Tag End must be rendered as '0', not as '%d'." % value)

  126.     def _render_buffer(self, buffer):
  127.   buffer.write(b'\x00')


  130. # == Value Tags ==#
  131. class TAG_Byte(_TAG_Numeric):
  132.     """Represent a single tag storing 1 byte."""
  133.     id = TAG_BYTE
  134.     fmt = Struct(">b")


  137. class TAG_Short(_TAG_Numeric):
  138.     """Represent a single tag storing 1 short."""
  139.     id = TAG_SHORT
  140.     fmt = Struct(">h")


  143. class TAG_Int(_TAG_Numeric):
  144.     """Represent a single tag storing 1 int."""
  145.     id = TAG_INT
  146.     fmt = Struct(">i")
  147.     """Struct(">i"), 32-bits integer, big-endian"""


  150. class TAG_Long(_TAG_Numeric):
  151.     """Represent a single tag storing 1 long."""
  152.     id = TAG_LONG
  153.     fmt = Struct(">q")


  156. class TAG_Float(_TAG_Numeric):
  157.     """Represent a single tag storing 1 IEEE-754 floating point number."""
  158.     id = TAG_FLOAT
  159.     fmt = Struct(">f")


  162. class TAG_Double(_TAG_Numeric):
  163.     """Represent a single tag storing 1 IEEE-754 double precision floating
  164.     point number."""
  165.     id = TAG_DOUBLE
  166.     fmt = Struct(">d")


  169. class TAG_Byte_Array(TAG, MutableSequence):
  170.     """
  171.     TAG_Byte_Array, comparable to a collections.UserList with
  172.     an intrinsic name whose values must be bytes
  173.     """
  174.     id = TAG_BYTE_ARRAY

  176.     def __init__(self, name=None, buffer=None):
  177.   # TODO: add a value parameter as well
  178.   super(TAG_Byte_Array, self).__init__(name=name)
  179.   if buffer:
  180.    self._parse_buffer(buffer)

  182.     # Parsers and Generators
  183.     def _parse_buffer(self, buffer):
  184.   length = TAG_Int(buffer=buffer)
  185.   self.value = bytearray(buffer.read(length.value))

  187.     def _render_buffer(self, buffer):
  188.   length = TAG_Int(len(self.value))
  189.   length._render_buffer(buffer)
  190.   buffer.write(bytes(self.value))

  192.     # Mixin methods
  193.     def __len__(self):
  194.   return len(self.value)

  196.     def __iter__(self):
  197.   return iter(self.value)

  199.     def __contains__(self, item):
  200.   return item in self.value

  202.     def __getitem__(self, key):
  203.   return self.value[key]

  205.     def __setitem__(self, key, value):
  206.   # TODO: check type of value
  207.   self.value[key] = value

  209.     def __delitem__(self, key):
  210.   del (self.value[key])

  212.     def insert(self, key, value):
  213.   # TODO: check type of value, or is this done by self.value already?
  214.   self.value.insert(key, value)

  216.     # Printing and Formatting of tree
  217.     def valuestr(self):
  218.   return "[%i byte(s)]" % len(self.value)

  220.     def __unicode__(self):
  221.   return '[' + ",".join([unicode(x) for x in self.value]) + ']'

  223.     def __str__(self):
  224.   return '[' + ",".join([str(x) for x in self.value]) + ']'


  227. class TAG_Int_Array(TAG, MutableSequence):
  228.     """
  229.     TAG_Int_Array, comparable to a collections.UserList with
  230.     an intrinsic name whose values must be integers
  231.     """
  232.     id = TAG_INT_ARRAY

  234.     def __init__(self, name=None, buffer=None):
  235.   # TODO: add a value parameter as well
  236.   super(TAG_Int_Array, self).__init__(name=name)
  237.   if buffer:
  238.    self._parse_buffer(buffer)

  240.     def update_fmt(self, length):
  241.   """ Adjust struct format description to length given """
  242.   self.fmt = Struct(">" + str(length) + "i")

  244.     # Parsers and Generators
  245.     def _parse_buffer(self, buffer):
  246.   length = TAG_Int(buffer=buffer).value
  247.   self.update_fmt(length)
  248.   self.value = list(self.fmt.unpack(buffer.read(self.fmt.size)))

  250.     def _render_buffer(self, buffer):
  251.   length = len(self.value)
  252.   self.update_fmt(length)
  253.   TAG_Int(length)._render_buffer(buffer)
  254.   buffer.write(self.fmt.pack(*self.value))

  256.     # Mixin methods
  257.     def __len__(self):
  258.   return len(self.value)

  260.     def __iter__(self):
  261.   return iter(self.value)

  263.     def __contains__(self, item):
  264.   return item in self.value

  266.     def __getitem__(self, key):
  267.   return self.value[key]

  269.     def __setitem__(self, key, value):
  270.   self.value[key] = value

  272.     def __delitem__(self, key):
  273.   del (self.value[key])

  275.     def insert(self, key, value):
  276.   self.value.insert(key, value)

  278.     # Printing and Formatting of tree
  279.     def valuestr(self):
  280.   return "[%i int(s)]" % len(self.value)


  283. class TAG_Long_Array(TAG, MutableSequence):
  284.     """
  285.     TAG_Long_Array, comparable to a collections.UserList with
  286.     an intrinsic name whose values must be integers
  287.     """
  288.     id = TAG_LONG_ARRAY

  290.     def __init__(self, name=None, buffer=None):
  291.   super(TAG_Long_Array, self).__init__(name=name)
  292.   if buffer:
  293.    self._parse_buffer(buffer)

  295.     def update_fmt(self, length):
  296.   """ Adjust struct format description to length given """
  297.   self.fmt = Struct(">" + str(length) + "q")

  299.     # Parsers and Generators
  300.     def _parse_buffer(self, buffer):
  301.   length = TAG_Int(buffer=buffer).value
  302.   self.update_fmt(length)
  303.   self.value = list(self.fmt.unpack(buffer.read(self.fmt.size)))

  305.     def _render_buffer(self, buffer):
  306.   length = len(self.value)
  307.   self.update_fmt(length)
  308.   TAG_Int(length)._render_buffer(buffer)
  309.   buffer.write(self.fmt.pack(*self.value))

  311.     # Mixin methods
  312.     def __len__(self):
  313.   return len(self.value)

  315.     def __iter__(self):
  316.   return iter(self.value)

  318.     def __contains__(self, item):
  319.   return item in self.value

  321.     def __getitem__(self, key):
  322.   return self.value[key]

  324.     def __setitem__(self, key, value):
  325.   self.value[key] = value

  327.     def __delitem__(self, key):
  328.   del (self.value[key])

  330.     def insert(self, key, value):
  331.   self.value.insert(key, value)

  333.     # Printing and Formatting of tree
  334.     def valuestr(self):
  335.   return "[%i long(s)]" % len(self.value)


  338. class TAG_String(TAG, Sequence):
  339.     """
  340.     TAG_String, comparable to a collections.UserString with an
  341.     intrinsic name
  342.     """
  343.     id = TAG_STRING

  345.     def __init__(self, value=None, name=None, buffer=None):
  346.   super(TAG_String, self).__init__(value, name)
  347.   if buffer:
  348.    self._parse_buffer(buffer)

  350.     # Parsers and Generators
  351.     def _parse_buffer(self, buffer):
  352.   length = TAG_Short(buffer=buffer)
  353.   read = buffer.read(length.value)
  354.   if len(read) != length.value:
  355.    raise StructError()
  356.   self.value = read.decode("utf-8")

  358.     def _render_buffer(self, buffer):
  359.   save_val = self.value.encode("utf-8")
  360.   length = TAG_Short(len(save_val))
  361.   length._render_buffer(buffer)
  362.   buffer.write(save_val)

  364.     # Mixin methods
  365.     def __len__(self):
  366.   return len(self.value)

  368.     def __iter__(self):
  369.   return iter(self.value)

  371.     def __contains__(self, item):
  372.   return item in self.value

  374.     def __getitem__(self, key):
  375.   return self.value[key]

  377.     # Printing and Formatting of tree
  378.     def __repr__(self):
  379.   return self.value


  382. # == Collection Tags ==#
  383. class TAG_List(TAG, MutableSequence):
  384.     """
  385.     TAG_List, comparable to a collections.UserList with an intrinsic name
  386.     """
  387.     id = TAG_LIST

  389.     def __init__(self, type=None, value=None, name=None, buffer=None):
  390.   super(TAG_List, self).__init__(value, name)
  391.   if type:
  392.    self.tagID = type.id
  393.   else:
  394.    self.tagID = None
  395.   self.tags = []
  396.   if buffer:
  397.    self._parse_buffer(buffer)
  398.   # if self.tagID == None:
  399.   #  raise ValueError("No type specified for list: %s" % (name))

  401.     # Parsers and Generators
  402.     def _parse_buffer(self, buffer):
  403.   self.tagID = TAG_Byte(buffer=buffer).value
  404.   self.tags = []
  405.   length = TAG_Int(buffer=buffer)
  406.   for x in range(length.value):
  407.    self.tags.append(TAGLIST[self.tagID](buffer=buffer))

  409.     def _render_buffer(self, buffer):
  410.   TAG_Byte(self.tagID)._render_buffer(buffer)
  411.   length = TAG_Int(len(self.tags))
  412.   length._render_buffer(buffer)
  413.   for i, tag in enumerate(self.tags):
  414.    if tag.id != self.tagID:
  415.     raise ValueError(
  416.   "List element %d(%s) has type %d != container type %d" %
  417.   (i, tag, tag.id, self.tagID))
  418.    tag._render_buffer(buffer)

  420.     # Mixin methods
  421.     def __len__(self):
  422.   return len(self.tags)

  424.     def __iter__(self):
  425.   return iter(self.tags)

  427.     def __contains__(self, item):
  428.   return item in self.tags

  430.     def __getitem__(self, key):
  431.   return self.tags[key]

  433.     def __setitem__(self, key, value):
  434.   self.tags[key] = value

  436.     def __delitem__(self, key):
  437.   del (self.tags[key])

  439.     def insert(self, key, value):
  440.   self.tags.insert(key, value)

  442.     # Printing and Formatting of tree
  443.     def __repr__(self):
  444.   return "%i entries of type %s" % (
  445.    len(self.tags), TAGLIST[self.tagID].__name__)

  447.     # Printing and Formatting of tree
  448.     def valuestr(self):
  449.   return "[%i %s(s)]" % (len(self.tags), TAGLIST[self.tagID].__name__)

  451.     def __unicode__(self):
  452.   return "[" + ", ".join([tag.tag_info() for tag in self.tags]) + "]"

  454.     def __str__(self):
  455.   return "[" + ", ".join([tag.tag_info() for tag in self.tags]) + "]"

  457.     def pretty_tree(self, indent=0):
  458.   output = [super(TAG_List, self).pretty_tree(indent)]
  459.   if len(self.tags):
  460.    output.append(("\t" * indent) + "{")
  461.    output.extend([tag.pretty_tree(indent + 1) for tag in self.tags])
  462.    output.append(("\t" * indent) + "}")
  463.   return '\n'.join(output)


  466. class TAG_Compound(TAG, MutableMapping):
  467.     """
  468.     TAG_Compound, comparable to a collections.OrderedDict with an
  469.     intrinsic name
  470.     """
  471.     id = TAG_COMPOUND

  473.     def __init__(self, buffer=None, name=None):
  474.   # TODO: add a value parameter as well
  475.   super(TAG_Compound, self).__init__()
  476.   self.tags = []
  477.   self.name = ""
  478.   if buffer:
  479.    self._parse_buffer(buffer)

  481.     # Parsers and Generators
  482.     def _parse_buffer(self, buffer):
  483.   while True:
  484.    type = TAG_Byte(buffer=buffer)
  485.    if type.value == TAG_END:
  486.     # print("found tag_end")
  487.     break
  488.    else:
  489.     name = TAG_String(buffer=buffer).value
  490.     try:
  491.   tag = TAGLIST[type.value]()
  492.     except KeyError:
  493.   raise ValueError("Unrecognised tag type %d" % type.value)
  494.     tag.name = name
  495.     self.tags.append(tag)
  496.     tag._parse_buffer(buffer)

  498.     def _render_buffer(self, buffer):
  499.   for tag in self.tags:
  500.    TAG_Byte(tag.id)._render_buffer(buffer)
  501.    TAG_String(tag.name)._render_buffer(buffer)
  502.    tag._render_buffer(buffer)
  503.   buffer.write(b'\x00')# write TAG_END

  505.     # Mixin methods
  506.     def __len__(self):
  507.   return len(self.tags)

  509.     def __iter__(self):
  510.   for key in self.tags:
  511.    yield key.name

  513.     def __contains__(self, key):
  514.   if isinstance(key, int):
  515.    return key <= len(self.tags)
  516.   elif isinstance(key, basestring):
  517.    for tag in self.tags:
  518.     if tag.name == key:
  519.   return True
  520.    return False
  521.   elif isinstance(key, TAG):
  522.    return key in self.tags
  523.   return False

  525.     def __getitem__(self, key):
  526.   if isinstance(key, int):
  527.    return self.tags[key]
  528.   elif isinstance(key, basestring):
  529.    for tag in self.tags:
  530.     if tag.name == key:
  531.   return tag
  532.    else:
  533.     raise KeyError("Tag %s does not exist" % key)
  534.   else:
  535.    raise TypeError(
  536.     "key needs to be either name of tag, or index of tag, "
  537.     "not a %s" % type(key).__name__)

  539.     def __setitem__(self, key, value):
  540.   assert isinstance(value, TAG), "value must be an nbt.TAG"
  541.   if isinstance(key, int):
  542.    # Just try it. The proper error will be raised if it doesn't work.
  543.    self.tags[key] = value
  544.   elif isinstance(key, basestring):
  545.    value.name = key
  546.    for i, tag in enumerate(self.tags):
  547.     if tag.name == key:
  548.   self.tags = value
  549.   return
  550.    self.tags.append(value)

  552.     def __delitem__(self, key):
  553.   if isinstance(key, int):
  554.    del (self.tags[key])
  555.   elif isinstance(key, basestring):
  556.    self.tags.remove(self.__getitem__(key))
  557.   else:
  558.    raise ValueError(
  559.     "key needs to be either name of tag, or index of tag")

  561.     def keys(self):
  562.   return [tag.name for tag in self.tags]

  564.     def iteritems(self):
  565.   for tag in self.tags:
  566.    yield (tag.name, tag)

  568.     # Printing and Formatting of tree
  569.     def __unicode__(self):
  570.   return "{" + ", ".join([tag.tag_info() for tag in self.tags]) + "}"

  572.     def __str__(self):
  573.   return "{" + ", ".join([tag.tag_info() for tag in self.tags]) + "}"

  575.     def valuestr(self):
  576.   return '{%i Entries}' % len(self.tags)

  578.     def pretty_tree(self, indent=0):
  579.   output = [super(TAG_Compound, self).pretty_tree(indent)]
  580.   if len(self.tags):
  581.    output.append(("\t" * indent) + "{")
  582.    output.extend([tag.pretty_tree(indent + 1) for tag in self.tags])
  583.    output.append(("\t" * indent) + "}")
  584.   return '\n'.join(output)


  587. TAGLIST = {TAG_END: _TAG_End, TAG_BYTE: TAG_Byte, TAG_SHORT: TAG_Short,
  588.   TAG_INT: TAG_Int, TAG_LONG: TAG_Long, TAG_FLOAT: TAG_Float,
  589.   TAG_DOUBLE: TAG_Double, TAG_BYTE_ARRAY: TAG_Byte_Array,
  590.   TAG_STRING: TAG_String, TAG_LIST: TAG_List,
  591.   TAG_COMPOUND: TAG_Compound, TAG_INT_ARRAY: TAG_Int_Array,
  592.   TAG_LONG_ARRAY: TAG_Long_Array}


  595. class NBTFile(TAG_Compound):
  596.     """Represent an NBT file object."""

  598.     def __init__(self, filename=None, buffer=None, fileobj=None):
  599.   """
  600.   Create a new NBTFile object.
  601.   Specify either a filename, file object or data buffer.
  602.   If filename of file object is specified, data should be GZip-compressed.
  603.   If a data buffer is specified, it is assumed to be uncompressed.
  604.   If filename is specified, the file is closed after reading and writing.
  605.   If file object is specified, the caller is responsible for closing the
  606.   file.
  607.   """
  608.   super(NBTFile, self).__init__()
  609.   self.filename = filename
  610.   self.type = TAG_Byte(self.id)
  611.   closefile = True
  612.   # make a file object
  613.   if filename:
  614.    self.filename = filename
  615.    self.file = GzipFile(filename, 'rb')
  616.   elif buffer:
  617.    if hasattr(buffer, 'name'):
  618.     self.filename = buffer.name
  619.    self.file = buffer
  620.    closefile = False
  621.   elif fileobj:
  622.    if hasattr(fileobj, 'name'):
  623.     self.filename = fileobj.name
  624.    self.file = GzipFile(fileobj=fileobj)
  625.   else:
  626.    self.file = None
  627.    closefile = False
  628.   # parse the file given initially
  629.   if self.file:
  630.    self.parse_file()
  631.    if closefile:
  632.     # Note: GzipFile().close() does NOT close the fileobj,
  633.     # So we are still responsible for closing that.
  634.     try:
  635.   self.file.close()
  636.     except (AttributeError, IOError):
  637.   pass
  638.    self.file = None

  640.     def parse_file(self, filename=None, buffer=None, fileobj=None):
  641.   """Completely parse a file, extracting all tags."""
  642.   if filename:
  643.    self.file = GzipFile(filename, 'rb')
  644.   elif buffer:
  645.    if hasattr(buffer, 'name'):
  646.     self.filename = buffer.name
  647.    self.file = buffer
  648.   elif fileobj:
  649.    if hasattr(fileobj, 'name'):
  650.     self.filename = fileobj.name
  651.    self.file = GzipFile(fileobj=fileobj)
  652.   if self.file:
  653.    try:
  654.     type = TAG_Byte(buffer=self.file)
  655.     if type.value == self.id:
  656.   name = TAG_String(buffer=self.file).value
  657.   self._parse_buffer(self.file)
  658.   self.name = name
  659.   self.file.close()
  660.     else:
  661.   raise MalformedFileError(
  662.    "First record is not a Compound Tag")
  663.    except StructError as e:
  664.     raise MalformedFileError(
  665.   "Partial File Parse: file possibly truncated.")
  666.   else:
  667.    raise ValueError(
  668.     "NBTFile.parse_file(): Need to specify either a "
  669.     "filename or a file object"
  670.    )

  672.     def write_file(self, filename=None, buffer=None, fileobj=None):
  673.   """Write this NBT file to a file."""
  674.   closefile = True
  675.   if buffer:
  676.    self.filename = None
  677.    self.file = buffer
  678.    closefile = False
  679.   elif filename:
  680.    self.filename = filename
  681.    self.file = GzipFile(filename, "wb")
  682.   elif fileobj:
  683.    self.filename = None
  684.    self.file = GzipFile(fileobj=fileobj, mode="wb")
  685.   elif self.filename:
  686.    self.file = GzipFile(self.filename, "wb")
  687.   elif not self.file:
  688.    raise ValueError(
  689.     "NBTFile.write_file(): Need to specify either a "
  690.     "filename or a file object"
  691.    )
  692.   # Render tree to file
  693.   TAG_Byte(self.id)._render_buffer(self.file)
  694.   TAG_String(self.name)._render_buffer(self.file)
  695.   self._render_buffer(self.file)
  696.   # make sure the file is complete
  697.   try:
  698.    self.file.flush()
  699.   except (AttributeError, IOError):
  700.    pass
  701.   if closefile:
  702.    try:
  703.     self.file.close()
  704.    except (AttributeError, IOError):
  705.     pass

  707.     def __repr__(self):
  708.   """
  709.   Return a string (ascii formated for Python 2, unicode
  710.   for Python 3) describing the class, name and id for
  711.   debugging purposes.
  712.   """
  713.   if self.filename:
  714.    return "<%s(%r) with %s(%r) at 0x%x>" % (
  715.     self.__class__.__name__, self.filename,
  716.     TAG_Compound.__name__, self.name, id(self)
  717.    )
  718.   else:
  719.    return "<%s with %s(%r) at 0x%x>" % (
  720.     self.__class__.__name__, TAG_Compound.__name__,
  721.     self.name, id(self)
  722.    )



nbt/region.py


代码:



  3. """
  4. Handle a region file, containing 32x32 chunks.
  5. For more information about the region file format:
  6. https://minecraft.gamepedia.com/Region_file_format
  7. """

  9. from .nbt import NBTFile, MalformedFileError
  10. from struct import pack, unpack
  11. from collections import Mapping
  12. import zlib
  13. import gzip
  14. from io import BytesIO
  15. import time
  16. from os import SEEK_END

  18. # constants

  20. SECTOR_LENGTH = 4096
  21. """Constant indicating the length of a sector. A Region file is divided in sectors of 4096 bytes each."""

  23. # TODO: move status codes to an (Enum) object

  25. # Status is a number representing:
  26. # -5 = Error, the chunk is overlapping with another chunk
  27. # -4 = Error, the chunk length is too large to fit in the sector length in the region header
  28. # -3 = Error, chunk header has a 0 length
  29. # -2 = Error, chunk inside the header of the region file
  30. # -1 = Error, chunk partially/completely outside of file
  31. #0 = Ok
  32. #1 = Chunk non-existant yet
  33. STATUS_CHUNK_OVERLAPPING = -5
  34. """Constant indicating an error status: the chunk is allocated to a sector already occupied by another chunk"""
  35. STATUS_CHUNK_MISMATCHED_LENGTHS = -4
  36. """Constant indicating an error status: the region header length and the chunk length are incompatible"""
  37. STATUS_CHUNK_ZERO_LENGTH = -3
  38. """Constant indicating an error status: chunk header has a 0 length"""
  39. STATUS_CHUNK_IN_HEADER = -2
  40. """Constant indicating an error status: chunk inside the header of the region file"""
  41. STATUS_CHUNK_OUT_OF_FILE = -1
  42. """Constant indicating an error status: chunk partially/completely outside of file"""
  43. STATUS_CHUNK_OK = 0
  44. """Constant indicating an normal status: the chunk exists and the metadata is valid"""
  45. STATUS_CHUNK_NOT_CREATED = 1
  46. """Constant indicating an normal status: the chunk does not exist"""

  48. COMPRESSION_NONE = 0
  49. """Constant indicating that the chunk is not compressed."""
  50. COMPRESSION_GZIP = 1
  51. """Constant indicating that the chunk is GZip compressed."""
  52. COMPRESSION_ZLIB = 2
  53. """Constant indicating that the chunk is zlib compressed."""


  56. # TODO: reconsider these errors. where are they catched? Where would an implementation make a difference in handling the different exceptions.

  58. class RegionFileFormatError(Exception):
  59.     """Base class for all file format errors.
  60.     Note: InconceivedChunk is not a child class, because it is not considered a format error."""
  61.     def __init__(self, msg=""):
  62.   self.msg = msg
  63.     def __str__(self):
  64.   return self.msg

  66. class NoRegionHeader(RegionFileFormatError):
  67.     """The size of the region file is too small to contain a header."""

  69. class RegionHeaderError(RegionFileFormatError):
  70.     """Error in the header of the region file for a given chunk."""

  72. class ChunkHeaderError(RegionFileFormatError):
  73.     """Error in the header of a chunk, included the bytes of length and byte version."""

  75. class ChunkDataError(RegionFileFormatError):
  76.     """Error in the data of a chunk."""

  78. class InconceivedChunk(LookupError):
  79.     """Specified chunk has not yet been generated."""
  80.     def __init__(self, msg=""):
  81.   self.msg = msg


  84. class ChunkMetadata(object):
  85.     """
  86.     Metadata for a particular chunk found in the 8 kiByte header and 5-byte chunk header.
  87.     """

  89.     def __init__(self, x, z):
  90.   self.x = x
  91.   """x-coordinate of the chunk in the file"""
  92.   self.z = z
  93.   """z-coordinate of the chunk in the file"""
  94.   self.blockstart = 0
  95.   """start of the chunk block, counted in 4 kiByte sectors from the
  96.   start of the file. (24 bit int)"""
  97.   self.blocklength = 0
  98.   """amount of 4 kiBytes sectors in the block (8 bit int)"""
  99.   self.timestamp = 0
  100.   """a Unix timestamps (seconds since epoch) (32 bits), found in the
  101.   second sector in the file."""
  102.   self.length = 0
  103.   """length of the block in bytes. This excludes the 4-byte length header,
  104.   and includes the 1-byte compression byte. (32 bit int)"""
  105.   self.compression = None
  106.   """type of compression used for the chunk block. (8 bit int).
  107.    
  108.   - 0: uncompressed
  109.   - 1: gzip compression
  110.   - 2: zlib compression"""
  111.   self.status = STATUS_CHUNK_NOT_CREATED
  112.   """status as determined from blockstart, blocklength, length, file size
  113.   and location of other chunks in the file.
  114.  
  115.   - STATUS_CHUNK_OVERLAPPING
  116.   - STATUS_CHUNK_MISMATCHED_LENGTHS
  117.   - STATUS_CHUNK_ZERO_LENGTH
  118.   - STATUS_CHUNK_IN_HEADER
  119.   - STATUS_CHUNK_OUT_OF_FILE
  120.   - STATUS_CHUNK_OK
  121.   - STATUS_CHUNK_NOT_CREATED"""
  122.     def __str__(self):
  123.   return "%s(%d, %d, sector=%s, blocklength=%s, timestamp=%s, bytelength=%s, compression=%s, status=%s)" % \
  124.    (self.__class__.__name__, self.x, self.z, self.blockstart, self.blocklength, self.timestamp, \
  125.    self.length, self.compression, self.status)
  126.     def __repr__(self):
  127.   return "%s(%d,%d)" % (self.__class__.__name__, self.x, self.z)
  128.     def requiredblocks(self):
  129.   # slightly faster variant of: floor(self.length + 4) / 4096))
  130.   return (self.length + 3 + SECTOR_LENGTH) // SECTOR_LENGTH
  131.     def is_created(self):
  132.   """return True if this chunk is created according to the header.
  133.   This includes chunks which are not readable for other reasons."""
  134.   return self.blockstart != 0

  136. class _HeaderWrapper(Mapping):
  137.     """Wrapper around self.metadata to emulate the old self.header variable"""
  138.     def __init__(self, metadata):
  139.   self.metadata = metadata
  140.     def __getitem__(self, xz):
  141.   m = self.metadata[xz]
  142.   return (m.blockstart, m.blocklength, m.timestamp, m.status)
  143.     def __iter__(self):
  144.   return iter(self.metadata) # iterates over the keys
  145.     def __len__(self):
  146.   return len(self.metadata)
  147. class _ChunkHeaderWrapper(Mapping):
  148.     """Wrapper around self.metadata to emulate the old self.chunk_headers variable"""
  149.     def __init__(self, metadata):
  150.   self.metadata = metadata
  151.     def __getitem__(self, xz):
  152.   m = self.metadata[xz]
  153.   return (m.length if m.length > 0 else None, m.compression, m.status)
  154.     def __iter__(self):
  155.   return iter(self.metadata) # iterates over the keys
  156.     def __len__(self):
  157.   return len(self.metadata)

  159. class Location(object):
  160.     def __init__(self, x=None, y=None, z=None):
  161.   self.x = x
  162.   self.y = y
  163.   self.z = z
  164.     def __str__(self):
  165.   return "%s(x=%s, y=%s, z=%s)" % (self.__class__.__name__, self.x, self.y, self.z)

  167. class RegionFile(object):
  168.     """A convenience class for extracting NBT files from the Minecraft Beta Region Format."""
  169.    
  170.     # Redefine constants for backward compatibility.
  171.     STATUS_CHUNK_OVERLAPPING = STATUS_CHUNK_OVERLAPPING
  172.     """Constant indicating an error status: the chunk is allocated to a sector
  173.     already occupied by another chunk.
  174.     Deprecated. Use :const:`nbt.region.STATUS_CHUNK_OVERLAPPING` instead."""
  175.     STATUS_CHUNK_MISMATCHED_LENGTHS = STATUS_CHUNK_MISMATCHED_LENGTHS
  176.     """Constant indicating an error status: the region header length and the chunk
  177.     length are incompatible. Deprecated. Use :const:`nbt.region.STATUS_CHUNK_MISMATCHED_LENGTHS` instead."""
  178.     STATUS_CHUNK_ZERO_LENGTH = STATUS_CHUNK_ZERO_LENGTH
  179.     """Constant indicating an error status: chunk header has a 0 length.
  180.     Deprecated. Use :const:`nbt.region.STATUS_CHUNK_ZERO_LENGTH` instead."""
  181.     STATUS_CHUNK_IN_HEADER = STATUS_CHUNK_IN_HEADER
  182.     """Constant indicating an error status: chunk inside the header of the region file.
  183.     Deprecated. Use :const:`nbt.region.STATUS_CHUNK_IN_HEADER` instead."""
  184.     STATUS_CHUNK_OUT_OF_FILE = STATUS_CHUNK_OUT_OF_FILE
  185.     """Constant indicating an error status: chunk partially/completely outside of file.
  186.     Deprecated. Use :const:`nbt.region.STATUS_CHUNK_OUT_OF_FILE` instead."""
  187.     STATUS_CHUNK_OK = STATUS_CHUNK_OK
  188.     """Constant indicating an normal status: the chunk exists and the metadata is valid.
  189.     Deprecated. Use :const:`nbt.region.STATUS_CHUNK_OK` instead."""
  190.     STATUS_CHUNK_NOT_CREATED = STATUS_CHUNK_NOT_CREATED
  191.     """Constant indicating an normal status: the chunk does not exist.
  192.     Deprecated. Use :const:`nbt.region.STATUS_CHUNK_NOT_CREATED` instead."""
  193.    
  194.     def __init__(self, filename=None, fileobj=None, chunkclass = None):
  195.   """
  196.   Read a region file by filename or file object.
  197.   If a fileobj is specified, it is not closed after use; it is the callers responibility to close it.
  198.   """
  199.   self.file = None
  200.   self.filename = None
  201.   self._closefile = False
  202.   self.chunkclass = chunkclass
  203.   if filename:
  204.    self.filename = filename
  205.    self.file = open(filename, 'r+b') # open for read and write in binary mode
  206.    self._closefile = True
  207.   elif fileobj:
  208.    if hasattr(fileobj, 'name'):
  209.     self.filename = fileobj.name
  210.    self.file = fileobj
  211.   elif not self.file:
  212.    raise ValueError("RegionFile(): Need to specify either a filename or a file object")

  214.   # Some variables
  215.   self.metadata = {}
  216.   """
  217.   dict containing ChunkMetadata objects, gathered from metadata found in the
  218.   8 kiByte header and 5-byte chunk header.
  219.  
  220.   ``metadata[x, z]: ChunkMetadata()``
  221.   """
  222.   self.header = _HeaderWrapper(self.metadata)
  223.   """
  224.   dict containing the metadata found in the 8 kiByte header:
  225.  
  226.   ``header[x, z]: (offset, sectionlength, timestamp, status)``
  227.  
  228.   :offset: counts in 4 kiByte sectors, starting from the start of the file. (24 bit int)
  229.   :blocklength: is in 4 kiByte sectors (8 bit int)
  230.   :timestamp: is a Unix timestamps (seconds since epoch) (32 bits)
  231.   :status: can be any of:
  232.  
  233.    - STATUS_CHUNK_OVERLAPPING
  234.    - STATUS_CHUNK_MISMATCHED_LENGTHS
  235.    - STATUS_CHUNK_ZERO_LENGTH
  236.    - STATUS_CHUNK_IN_HEADER
  237.    - STATUS_CHUNK_OUT_OF_FILE
  238.    - STATUS_CHUNK_OK
  239.    - STATUS_CHUNK_NOT_CREATED
  240.  
  241.   Deprecated. Use :attr:`metadata` instead.
  242.   """
  243.   self.chunk_headers = _ChunkHeaderWrapper(self.metadata)
  244.   """
  245.   dict containing the metadata found in each chunk block:
  246.  
  247.   ``chunk_headers[x, z]: (length, compression, chunk_status)``
  248.  
  249.   :chunk length: in bytes, starting from the compression byte (32 bit int)
  250.   :compression: is 1 (Gzip) or 2 (bzip) (8 bit int)
  251.   :chunk_status: is equal to status in :attr:`header`.
  252.  
  253.   If the chunk is not defined, the tuple is (None, None, STATUS_CHUNK_NOT_CREATED)
  254.  
  255.   Deprecated. Use :attr:`metadata` instead.
  256.   """

  258.   self.loc = Location()
  259.   """Optional: x,z location of a region within a world."""
  260.  
  261.   self._init_header()
  262.   self._parse_header()
  263.   self._parse_chunk_headers()

  265.     def get_size(self):
  266.   """ Returns the file size in bytes. """
  267.   # seek(0,2) jumps to 0-bytes from the end of the file.
  268.   # Python 2.6 support: seek does not yet return the position.
  269.   self.file.seek(0, SEEK_END)
  270.   return self.file.tell()

  272.     @staticmethod
  273.     def _bytes_to_sector(bsize, sectorlength=SECTOR_LENGTH):
  274.   """Given a size in bytes, return how many sections of length sectorlen are required to contain it.
  275.   This is equivalent to ceil(bsize/sectorlen), if Python would use floating
  276.   points for division, and integers for ceil(), rather than the other way around."""
  277.   sectors, remainder = divmod(bsize, sectorlength)
  278.   return sectors if remainder == 0 else sectors + 1
  279.    
  280.     def close(self):
  281.   """
  282.   Clean up resources after use.
  283.  
  284.   Note that the instance is no longer readable nor writable after calling close().
  285.   The method is automatically called by garbage collectors, but made public to
  286.   allow explicit cleanup.
  287.   """
  288.   if self._closefile:
  289.    try:
  290.     self.file.close()
  291.    except IOError:
  292.     pass

  294.     def __del__(self):
  295.   self.close()
  296.   # Parent object() has no __del__ method, otherwise it should be called here.

  298.     def _init_file(self):
  299.   """Initialise the file header. This will erase any data previously in the file."""
  300.   header_length = 2*SECTOR_LENGTH
  301.   if self.size > header_length:
  302.    self.file.truncate(header_length)
  303.   self.file.seek(0)
  304.   self.file.write(header_length*b'\x00')
  305.   self.size = header_length

  307.     def _init_header(self):
  308.   for x in range(32):
  309.    for z in range(32):
  310.     self.metadata[x,z] = ChunkMetadata(x, z)

  312.     def _parse_header(self):
  313.   """Read the region header and stores: offset, length and status."""
  314.   # update the file size, needed when parse_header is called after
  315.   # we have unlinked a chunk or writed a new one
  316.   self.size = self.get_size()

  318.   if self.size == 0:
  319.    # Some region files seems to have 0 bytes of size, and
  320.    # Minecraft handle them without problems. Take them
  321.    # as empty region files.
  322.    return
  323.   elif self.size < 2*SECTOR_LENGTH:
  324.    raise NoRegionHeader('The region file is %d bytes, too small in size to have a header.' % self.size)
  325.  
  326.   for index in range(0, SECTOR_LENGTH, 4):
  327.    x = int(index//4) % 32
  328.    z = int(index//4)//32
  329.    m = self.metadata[x, z]
  330.    
  331.    self.file.seek(index)
  332.    offset, length = unpack(">IB", b"\0" + self.file.read(4))
  333.    m.blockstart, m.blocklength = offset, length
  334.    self.file.seek(index + SECTOR_LENGTH)
  335.    m.timestamp = unpack(">I", self.file.read(4))[0]
  336.    
  337.    if offset == 0 and length == 0:
  338.     m.status = STATUS_CHUNK_NOT_CREATED
  339.    elif length == 0:
  340.     m.status = STATUS_CHUNK_ZERO_LENGTH
  341.    elif offset < 2 and offset != 0:
  342.     m.status = STATUS_CHUNK_IN_HEADER
  343.    elif SECTOR_LENGTH * offset + 5 > self.size:
  344.     # Chunk header can't be read.
  345.     m.status = STATUS_CHUNK_OUT_OF_FILE
  346.    else:
  347.     m.status = STATUS_CHUNK_OK
  348.  
  349.   # Check for chunks overlapping in the file
  350.   for chunks in self._sectors()[2:]:
  351.    if len(chunks) > 1:
  352.     # overlapping chunks
  353.     for m in chunks:
  354.   # Update status, unless these more severe errors take precedence
  355.   if m.status not in (STATUS_CHUNK_ZERO_LENGTH, STATUS_CHUNK_IN_HEADER,
  356.     STATUS_CHUNK_OUT_OF_FILE):
  357.    m.status = STATUS_CHUNK_OVERLAPPING

  359.     def _parse_chunk_headers(self):
  360.   for x in range(32):
  361.    for z in range(32):
  362.     m = self.metadata[x, z]
  363.     if m.status not in (STATUS_CHUNK_OK, STATUS_CHUNK_OVERLAPPING, \
  364.    STATUS_CHUNK_MISMATCHED_LENGTHS):
  365.   # skip to next if status is NOT_CREATED, OUT_OF_FILE, IN_HEADER,
  366.   # ZERO_LENGTH or anything else.
  367.   continue
  368.     try:
  369.   self.file.seek(m.blockstart*SECTOR_LENGTH) # offset comes in sectors of 4096 bytes
  370.   length = unpack(">I", self.file.read(4))
  371.   m.length = length[0] # unpack always returns a tuple, even unpacking one element
  372.   compression = unpack(">B",self.file.read(1))
  373.   m.compression = compression[0]
  374.     except IOError:
  375.   m.status = STATUS_CHUNK_OUT_OF_FILE
  376.   continue
  377.     if m.blockstart*SECTOR_LENGTH + m.length + 4 > self.size:
  378.   m.status = STATUS_CHUNK_OUT_OF_FILE
  379.     elif m.length <= 1: # chunk can't be zero length
  380.   m.status = STATUS_CHUNK_ZERO_LENGTH
  381.     elif m.length + 4 > m.blocklength * SECTOR_LENGTH:
  382.   # There are not enough sectors allocated for the whole block
  383.   m.status = STATUS_CHUNK_MISMATCHED_LENGTHS

  385.     def _sectors(self, ignore_chunk=None):
  386.   """
  387.   Return a list of all sectors, each sector is a list of chunks occupying the block.
  388.   """
  389.   sectorsize = self._bytes_to_sector(self.size)
  390.   sectors = [[] for s in range(sectorsize)]
  391.   sectors[0] = True # locations
  392.   sectors[1] = True # timestamps
  393.   for m in self.metadata.values():
  394.    if not m.is_created():
  395.     continue
  396.    if ignore_chunk == m:
  397.     continue
  398.    if m.blocklength and m.blockstart:
  399.     blockend = m.blockstart + max(m.blocklength, m.requiredblocks())
  400.     # Ensure 2 <= b < sectorsize, as well as m.blockstart <= b < blockend
  401.     for b in range(max(m.blockstart, 2), min(blockend, sectorsize)):
  402.   sectors.append(m)
  403.   return sectors

  405.     def _locate_free_sectors(self, ignore_chunk=None):
  406.   """Return a list of booleans, indicating the free sectors."""
  407.   sectors = self._sectors(ignore_chunk=ignore_chunk)
  408.   # Sectors are considered free, if the value is an empty list.
  409.   return [not i for i in sectors]

  411.     def _find_free_location(self, free_locations, required_sectors=1, preferred=None):
  412.   """
  413.   Given a list of booleans, find a list of <required_sectors> consecutive True values.
  414.   If no such list is found, return length(free_locations).
  415.   Assumes first two values are always False.
  416.   """
  417.   # check preferred (current) location
  418.   if preferred and all(free_locations[preferred:preferred+required_sectors]):
  419.    return preferred
  420.  
  421.   # check other locations
  422.   # Note: the slicing may exceed the free_location boundary.
  423.   # This implementation relies on the fact that slicing will work anyway,
  424.   # and the any() function returns True for an empty list. This ensures
  425.   # that blocks outside the file are considered Free as well.
  426.  
  427.   i = 2 # First two sectors are in use by the header
  428.   while i < len(free_locations):
  429.    if all(free_locations[i:i+required_sectors]):
  430.     break
  431.    i += 1
  432.   return i

  434.     def get_metadata(self):
  435.   """
  436.   Return a list of the metadata of each chunk that is defined in te regionfile.
  437.   This includes chunks which may not be readable for whatever reason,
  438.   but excludes chunks that are not yet defined.
  439.   """
  440.   return [m for m in self.metadata.values() if m.is_created()]

  442.     def get_chunks(self):
  443.   """
  444.   Return the x,z coordinates and length of the chunks that are defined in te regionfile.
  445.   This includes chunks which may not be readable for whatever reason.
  446.   Warning: despite the name, this function does not actually return the chunk,
  447.   but merely it's metadata. Use get_chunk(x,z) to get the NBTFile, and then Chunk()
  448.   to get the actual chunk.
  449.  
  450.   This method is deprecated. Use :meth:`get_metadata` instead.
  451.   """
  452.   return self.get_chunk_coords()

  454.     def get_chunk_coords(self):
  455.   """
  456.   Return the x,z coordinates and length of the chunks that are defined in te regionfile.
  457.   This includes chunks which may not be readable for whatever reason.
  458.  
  459.   This method is deprecated. Use :meth:`get_metadata` instead.
  460.   """
  461.   chunks = []
  462.   for x in range(32):
  463.    for z in range(32):
  464.     m = self.metadata[x,z]
  465.     if m.is_created():
  466.   chunks.append({'x': x, 'z': z, 'length': m.blocklength})
  467.   return chunks

  469.     def iter_chunks(self):
  470.   """
  471.   Yield each readable chunk present in the region.
  472.   Chunks that can not be read for whatever reason are silently skipped.
  473.   Warning: this function returns a :class:`nbt.nbt.NBTFile` object, use ``Chunk(nbtfile)`` to get a
  474.   :class:`nbt.chunk.Chunk` instance.
  475.   """
  476.   for m in self.get_metadata():
  477.    try:
  478.     yield self.get_chunk(m.x, m.z)
  479.    except RegionFileFormatError:
  480.     pass

  482.     # The following method will replace 'iter_chunks'
  483.     # but the previous is kept for the moment
  484.     # until the users update their code

  486.     def iter_chunks_class(self):
  487.   """
  488.   Yield each readable chunk present in the region.
  489.   Chunks that can not be read for whatever reason are silently skipped.
  490.   This function returns a :class:`nbt.chunk.Chunk` instance.
  491.   """
  492.   for m in self.get_metadata():
  493.    try:
  494.     yield self.chunkclass(self.get_chunk(m.x, m.z))
  495.    except RegionFileFormatError:
  496.     pass

  498.     def __iter__(self):
  499.   return self.iter_chunks()

  501.     def get_timestamp(self, x, z):
  502.   """
  503.   Return the timestamp of when this region file was last modified.
  504.  
  505.   Note that this returns the timestamp as-is. A timestamp may exist,
  506.   while the chunk does not, or it may return a timestamp of 0 even
  507.   while the chunk exists.
  508.  
  509.   To convert to an actual date, use `datetime.fromtimestamp()`.
  510.   """
  511.   return self.metadata[x,z].timestamp

  513.     def chunk_count(self):
  514.   """Return the number of defined chunks. This includes potentially corrupt chunks."""
  515.   return len(self.get_metadata())

  517.     def get_blockdata(self, x, z):
  518.   """
  519.   Return the decompressed binary data representing a chunk.
  520.  
  521.   May raise a RegionFileFormatError().
  522.   If decompression of the data succeeds, all available data is returned,
  523.   even if it is shorter than what is specified in the header (e.g. in case
  524.   of a truncated while and non-compressed data).
  525.   """
  526.   # read metadata block
  527.   m = self.metadata[x, z]
  528.   if m.status == STATUS_CHUNK_NOT_CREATED:
  529.    raise InconceivedChunk("Chunk %d,%d is not present in region" % (x,z))
  530.   elif m.status == STATUS_CHUNK_IN_HEADER:
  531.    raise RegionHeaderError('Chunk %d,%d is in the region header' % (x,z))
  532.   elif m.status == STATUS_CHUNK_OUT_OF_FILE and (m.length <= 1 or m.compression == None):
  533.    # Chunk header is outside of the file.
  534.    raise RegionHeaderError('Chunk %d,%d is partially/completely outside the file' % (x,z))
  535.   elif m.status == STATUS_CHUNK_ZERO_LENGTH:
  536.    if m.blocklength == 0:
  537.     raise RegionHeaderError('Chunk %d,%d has zero length' % (x,z))
  538.    else:
  539.     raise ChunkHeaderError('Chunk %d,%d has zero length' % (x,z))
  540.   elif m.blockstart * SECTOR_LENGTH + 5 >= self.size:
  541.    raise RegionHeaderError('Chunk %d,%d is partially/completely outside the file' % (x,z))

  543.   # status is STATUS_CHUNK_OK, STATUS_CHUNK_MISMATCHED_LENGTHS, STATUS_CHUNK_OVERLAPPING
  544.   # or STATUS_CHUNK_OUT_OF_FILE.
  545.   # The chunk is always read, but in case of an error, the exception may be different
  546.   # based on the status.

  548.   err = None
  549.   try:
  550.    # offset comes in sectors of 4096 bytes + length bytes + compression byte
  551.    self.file.seek(m.blockstart * SECTOR_LENGTH + 5)
  552.    # Do not read past the length of the file.
  553.    # The length in the file includes the compression byte, hence the -1.
  554.    length = min(m.length - 1, self.size - (m.blockstart * SECTOR_LENGTH + 5))
  555.    chunk = self.file.read(length)
  556.    
  557.    if (m.compression == COMPRESSION_GZIP):
  558.     # Python 3.1 and earlier do not yet support gzip.decompress(chunk)
  559.     f = gzip.GzipFile(fileobj=BytesIO(chunk))
  560.     chunk = bytes(f.read())
  561.     f.close()
  562.    elif (m.compression == COMPRESSION_ZLIB):
  563.     chunk = zlib.decompress(chunk)
  564.    elif m.compression != COMPRESSION_NONE:
  565.     raise ChunkDataError('Unknown chunk compression/format (%s)' % m.compression)
  566.    
  567.    return chunk
  568.   except RegionFileFormatError:
  569.    raise
  570.   except Exception as e:
  571.    # Deliberately catch the Exception and re-raise.
  572.    # The details in gzip/zlib/nbt are irrelevant, just that the data is garbled.
  573.    err = '%s' % e # avoid str(e) due to Unicode issues in Python 2.
  574.   if err:
  575.    # don't raise during exception handling to avoid the warning
  576.    # "During handling of the above exception, another exception occurred".
  577.    # Python 3.3 solution (see PEP 409 & 415): "raise ChunkDataError(str(e)) from None"
  578.    if m.status == STATUS_CHUNK_MISMATCHED_LENGTHS:
  579.     raise ChunkHeaderError('The length in region header and the length in the header of chunk %d,%d are incompatible' % (x,z))
  580.    elif m.status == STATUS_CHUNK_OVERLAPPING:
  581.     raise ChunkHeaderError('Chunk %d,%d is overlapping with another chunk' % (x,z))
  582.    else:
  583.     raise ChunkDataError(err)

  585.     def get_nbt(self, x, z):
  586.   """
  587.   Return a NBTFile of the specified chunk.
  588.   Raise InconceivedChunk if the chunk is not included in the file.
  589.   """
  590.   # TODO: cache results?
  591.   data = self.get_blockdata(x, z) # This may raise a RegionFileFormatError.
  592.   data = BytesIO(data)
  593.   err = None
  594.   try:
  595.    nbt = NBTFile(buffer=data)
  596.    if self.loc.x != None:
  597.     x += self.loc.x*32
  598.    if self.loc.z != None:
  599.     z += self.loc.z*32
  600.    nbt.loc = Location(x=x, z=z)
  601.    return nbt
  602.    # this may raise a MalformedFileError. Convert to ChunkDataError.
  603.   except MalformedFileError as e:
  604.    err = '%s' % e # avoid str(e) due to Unicode issues in Python 2.
  605.   if err:
  606.    raise ChunkDataError(err)

  608.     def get_chunk(self, x, z):
  609.   """
  610.   Return a NBTFile of the specified chunk.
  611.   Raise InconceivedChunk if the chunk is not included in the file.
  612.  
  613.   Note: this function may be changed later to return a Chunk() rather
  614.   than a NBTFile() object. To keep the old functionality, use get_nbt().
  615.   """
  616.   return self.get_nbt(x, z)

  618.     def write_blockdata(self, x, z, data, compression=COMPRESSION_ZLIB):
  619.   """
  620.   Compress the data, write it to file, and add pointers in the header so it
  621.   can be found as chunk(x,z).
  622.   """
  623.   if compression == COMPRESSION_GZIP:
  624.    # Python 3.1 and earlier do not yet support `data = gzip.compress(data)`.
  625.    compressed_file = BytesIO()
  626.    f = gzip.GzipFile(fileobj=compressed_file)
  627.    f.write(data)
  628.    f.close()
  629.    compressed_file.seek(0)
  630.    data = compressed_file.read()
  631.    del compressed_file
  632.   elif compression == COMPRESSION_ZLIB:
  633.    data = zlib.compress(data) # use zlib compression, rather than Gzip
  634.   elif compression != COMPRESSION_NONE:
  635.    raise ValueError("Unknown compression type %d" % compression)
  636.   length = len(data)

  638.   # 5 extra bytes are required for the chunk block header
  639.   nsectors = self._bytes_to_sector(length + 5)

  641.   if nsectors >= 256:
  642.    raise ChunkDataError("Chunk is too large (%d sectors exceeds 255 maximum)" % (nsectors))

  644.   # Ensure file has a header
  645.   if self.size < 2*SECTOR_LENGTH:
  646.    self._init_file()

  648.   # search for a place where to write the chunk:
  649.   current = self.metadata[x, z]
  650.   free_sectors = self._locate_free_sectors(ignore_chunk=current)
  651.   sector = self._find_free_location(free_sectors, nsectors, preferred=current.blockstart)

  653.   # If file is smaller than sector*SECTOR_LENGTH (it was truncated), pad it with zeroes.
  654.   if self.size < sector*SECTOR_LENGTH:
  655.    # jump to end of file
  656.    self.file.seek(0, SEEK_END)
  657.    self.file.write((sector*SECTOR_LENGTH - self.size) * b"\x00")
  658.    assert self.file.tell() == sector*SECTOR_LENGTH

  660.   # write out chunk to region
  661.   self.file.seek(sector*SECTOR_LENGTH)
  662.   self.file.write(pack(">I", length + 1)) #length field
  663.   self.file.write(pack(">B", compression)) #compression field
  664.   self.file.write(data) #compressed data

  666.   # Write zeros up to the end of the chunk
  667.   remaining_length = SECTOR_LENGTH * nsectors - length - 5
  668.   self.file.write(remaining_length * b"\x00")

  670.   #seek to header record and write offset and length records
  671.   self.file.seek(4 * (x + 32*z))
  672.   self.file.write(pack(">IB", sector, nsectors)[1:])

  674.   #write timestamp
  675.   self.file.seek(SECTOR_LENGTH + 4 * (x + 32*z))
  676.   timestamp = int(time.time())
  677.   self.file.write(pack(">I", timestamp))

  679.   # Update free_sectors with newly written block
  680.   # This is required for calculating file truncation and zeroing freed blocks.
  681.   free_sectors.extend((sector + nsectors - len(free_sectors)) * [True])
  682.   for s in range(sector, sector + nsectors):
  683.    free_sectors = False
  684.  
  685.   # Check if file should be truncated:
  686.   truncate_count = list(reversed(free_sectors)).index(False)
  687.   if truncate_count > 0:
  688.    self.size = SECTOR_LENGTH * (len(free_sectors) - truncate_count)
  689.    self.file.truncate(self.size)
  690.    free_sectors = free_sectors[:-truncate_count]
  691.  
  692.   # Calculate freed sectors
  693.   for s in range(current.blockstart, min(current.blockstart + current.blocklength, len(free_sectors))):
  694.    if free_sectors:
  695.     # zero sector s
  696.     self.file.seek(SECTOR_LENGTH*s)
  697.     self.file.write(SECTOR_LENGTH*b'\x00')
  698.  
  699.   # update file size and header information
  700.   self.size = max((sector + nsectors)*SECTOR_LENGTH, self.size)
  701.   assert self.get_size() == self.size
  702.   current.blockstart = sector
  703.   current.blocklength = nsectors
  704.   current.status = STATUS_CHUNK_OK
  705.   current.timestamp = timestamp
  706.   current.length = length + 1
  707.   current.compression = COMPRESSION_ZLIB

  709.   # self.parse_header()
  710.   # self.parse_chunk_headers()

  712.     def write_chunk(self, x, z, nbt_file):
  713.   """
  714.   Pack the NBT file as binary data, and write to file in a compressed format.
  715.   """
  716.   data = BytesIO()
  717.   nbt_file.write_file(buffer=data) # render to buffer; uncompressed
  718.   self.write_blockdata(x, z, data.getvalue())

  720.     def unlink_chunk(self, x, z):
  721.   """
  722.   Remove a chunk from the header of the region file.
  723.   Fragmentation is not a problem, chunks are written to free sectors when possible.
  724.   """
  725.   # This function fails for an empty file. If that is the case, just return.
  726.   if self.size < 2*SECTOR_LENGTH:
  727.    return

  729.   # zero the region header for the chunk (offset length and time)
  730.   self.file.seek(4 * (x + 32*z))
  731.   self.file.write(pack(">IB", 0, 0)[1:])
  732.   self.file.seek(SECTOR_LENGTH + 4 * (x + 32*z))
  733.   self.file.write(pack(">I", 0))

  735.   # Check if file should be truncated:
  736.   current = self.metadata[x, z]
  737.   free_sectors = self._locate_free_sectors(ignore_chunk=current)
  738.   truncate_count = list(reversed(free_sectors)).index(False)
  739.   if truncate_count > 0:
  740.    self.size = SECTOR_LENGTH * (len(free_sectors) - truncate_count)
  741.    self.file.truncate(self.size)
  742.    free_sectors = free_sectors[:-truncate_count]
  743.  
  744.   # Calculate freed sectors
  745.   for s in range(current.blockstart, min(current.blockstart + current.blocklength, len(free_sectors))):
  746.    if free_sectors:
  747.     # zero sector s
  748.     self.file.seek(SECTOR_LENGTH*s)
  749.     self.file.write(SECTOR_LENGTH*b'\x00')

  751.   # update the header
  752.   self.metadata[x, z] = ChunkMetadata(x, z)

  754.     def _classname(self):
  755.   """Return the fully qualified class name."""
  756.   if self.__class__.__module__ in (None,):
  757.    return self.__class__.__name__
  758.   else:
  759.    return "%s.%s" % (self.__class__.__module__, self.__class__.__name__)

  761.     def __str__(self):
  762.   if self.filename:
  763.    return "<%s(%r)>" % (self._classname(), self.filename)
  764.   else:
  765.    return '<%s object at %d>' % (self._classname(), id(self))
  766.    
  767.     def __repr__(self):
  768.   if self.filename:
  769.    return "%s(%r)" % (self._classname(), self.filename)
  770.   else:
  771.    return '<%s object at %d>' % (self._classname(), id(self))



nbt/world.py


代码:


  2. """
  3. Handles a Minecraft world save using either the Anvil or McRegion format.
  4. For more information about the world format:
  5. https://minecraft.gamepedia.com/Level_format
  6. """

  8. import os, glob, re
  9. from . import region
  10. from . import chunk
  11. from .region import InconceivedChunk, Location

  13. class UnknownWorldFormat(Exception):
  14.     """Unknown or invalid world folder."""
  15.     def __init__(self, msg=""):
  16.   self.msg = msg


  19. class _BaseWorldFolder(object):
  20.     """
  21.     Abstract class, representing either a McRegion or Anvil world folder.
  22.     This class will use either Anvil or McRegion, with Anvil the preferred format.
  23.     Simply calling WorldFolder() will do this automatically.
  24.     """
  25.     type = "Generic"
  26.     extension = ''
  27.     chunkclass = chunk.Chunk

  29.     def __init__(self, world_folder):
  30.   """Initialize a WorldFolder."""
  31.   self.worldfolder = world_folder
  32.   self.regionfiles = {}
  33.   self.regions  = {}
  34.   self.chunks= None
  35.   # os.listdir triggers an OSError for non-existant directories or permission errors.
  36.   # This is needed, because glob.glob silently returns no files.
  37.   os.listdir(world_folder)
  38.   self.set_regionfiles(self.get_filenames())

  40.     def get_filenames(self):
  41.   """Find all matching file names in the world folder.
  42.  
  43.   This method is private, and it's use it deprecated. Use get_regionfiles() instead."""
  44.   # Warning: glob returns a empty list if the directory is unreadable, without raising an Exception
  45.   return list(glob.glob(os.path.join(self.worldfolder,'region','r.*.*.'+self.extension)))

  47.     def set_regionfiles(self, filenames):
  48.   """
  49.   This method directly sets the region files for this instance to use.
  50.   It assumes the filenames are in the form r.<x-digit>.<z-digit>.<extension>
  51.   """
  52.   for filename in filenames:
  53.    # Assume that filenames have the name r.<x-digit>.<z-digit>.<extension>
  54.    m = re.match(r"r.(\-?\d+).(\-?\d+)."+self.extension, os.path.basename(filename))
  55.    if m:
  56.     x = int(m.group(1))
  57.     z = int(m.group(2))
  58.    else:
  59.     # Only raised if a .mca of .mcr file exists which does not comply to the
  60.     #r.<x-digit>.<z-digit>.<extension> filename format. This may raise false
  61.     # errors if a copy is made, e.g. "r.0.-1 copy.mca". If this is an issue, override
  62.     # get_filenames(). In most cases, it is an error, and we like to raise that.
  63.     # Changed, no longer raise error, because we want to continue the loop.
  64.     # raise UnknownWorldFormat("Unrecognized filename format %s" % os.path.basename(filename))
  65.     # TODO: log to stderr using logging facility.
  66.     pass
  67.    self.regionfiles[(x,z)] = filename

  69.     def get_regionfiles(self):
  70.   """Return a list of full path of all region files."""
  71.   return list(self.regionfiles.values())

  73.     def nonempty(self):
  74.   """Return True is the world is non-empty."""
  75.   return len(self.regionfiles) > 0

  77.     def get_region(self, x,z):
  78.   """Get a region using x,z coordinates of a region. Cache results."""
  79.   if (x,z) not in self.regions:
  80.    if (x,z) in self.regionfiles:
  81.     self.regions[(x,z)] = region.RegionFile(self.regionfiles[(x,z)])
  82.    else:
  83.     # Return an empty RegionFile object
  84.     # TODO: this does not yet allow for saving of the region file
  85.     # TODO: this currently fails with a ValueError!
  86.     # TODO: generate the correct name, and create the file
  87.     # and add the fie to self.regionfiles
  88.     self.regions[(x,z)] = region.RegionFile()
  89.    self.regions[(x,z)].loc = Location(x=x,z=z)
  90.   return self.regions[(x,z)]

  92.     def iter_regions(self):
  93.   """
  94.   Return an iterable list of all region files. Use this function if you only
  95.   want to loop through each region files once, and do not want to cache the results.
  96.   """
  97.   # TODO: Implement BoundingBox
  98.   # TODO: Implement sort order
  99.   for x,z in self.regionfiles.keys():
  100.    close_after_use = False
  101.    if (x,z) in self.regions:
  102.     regionfile = self.regions[(x,z)]
  103.    else:
  104.     # It is not yet cached.
  105.     # Get file, but do not cache later.
  106.     regionfile = region.RegionFile(self.regionfiles[(x,z)], chunkclass = self.chunkclass)
  107.     regionfile.loc = Location(x=x,z=z)
  108.     close_after_use = True
  109.    try:
  110.     yield regionfile
  111.    finally:
  112.     if close_after_use:
  113.   regionfile.close()

  115.     def call_for_each_region(self, callback_function, boundingbox=None):
  116.   """
  117.   Return an iterable that calls callback_function for each region file
  118.   in the world. This is equivalent to:
  119.   ```
  120.   for the_region in iter_regions():
  121.     yield callback_function(the_region)
  122.   ````
  123.  
  124.   This function is threaded. It uses pickle to pass values between threads.
  125.   See [What can be pickled and unpickled?](https://docs.python.org/library/pickle.html#what-can-be-pickled-and-unpickled) in the Python documentation
  126.   for limitation on the output of `callback_function()`.
  127.   """
  128.   raise NotImplementedError()

  130.     def get_nbt(self,x,z):
  131.   """
  132.   Return a NBT specified by the chunk coordinates x,z. Raise InconceivedChunk
  133.   if the NBT file is not yet generated. To get a Chunk object, use get_chunk.
  134.   """
  135.   rx,cx = divmod(x,32)
  136.   rz,cz = divmod(z,32)
  137.   if (rx,rz) not in self.regions and (rx,rz) not in self.regionfiles:
  138.    raise InconceivedChunk("Chunk %s,%s is not present in world" % (x,z))
  139.   nbt = self.get_region(rx,rz).get_nbt(cx,cz)
  140.   assert nbt != None
  141.   return nbt

  143.     def set_nbt(self,x,z,nbt):
  144.   """
  145.   Set a chunk. Overrides the NBT if it already existed. If the NBT did not exists,
  146.   adds it to the Regionfile. May create a new Regionfile if that did not exist yet.
  147.   nbt must be a nbt.NBTFile instance, not a Chunk or regular TAG_Compound object.
  148.   """
  149.   raise NotImplementedError()
  150.   # TODO: implement

  152.     def iter_nbt(self):
  153.   """
  154.   Return an iterable list of all NBT. Use this function if you only
  155.   want to loop through the chunks once, and don't need the block or data arrays.
  156.   """
  157.   # TODO: Implement BoundingBox
  158.   # TODO: Implement sort order
  159.   for region in self.iter_regions():
  160.    for c in region.iter_chunks():
  161.     yield c

  163.     def call_for_each_nbt(self, callback_function, boundingbox=None):
  164.   """
  165.   Return an iterable that calls callback_function for each NBT structure
  166.   in the world. This is equivalent to:
  167.   ```
  168.   for the_nbt in iter_nbt():
  169.     yield callback_function(the_nbt)
  170.   ````
  171.  
  172.   This function is threaded. It uses pickle to pass values between threads.
  173.   See [What can be pickled and unpickled?](https://docs.python.org/library/pickle.html#what-can-be-pickled-and-unpickled) in the Python documentation
  174.   for limitation on the output of `callback_function()`.
  175.   """
  176.   raise NotImplementedError()

  178.     def get_chunk(self,x,z):
  179.   """
  180.   Return a chunk specified by the chunk coordinates x,z. Raise InconceivedChunk
  181.   if the chunk is not yet generated. To get the raw NBT data, use get_nbt.
  182.   """
  183.   return self.chunkclass(self.get_nbt(x, z))

  185.     def get_chunks(self, boundingbox=None):
  186.   """
  187.   Return a list of all chunks. Use this function if you access the chunk
  188.   list frequently and want to cache the result.
  189.   Use iter_chunks() if you only want to loop through the chunks once or have a
  190.   very large world.
  191.   """
  192.   if self.chunks == None:
  193.    self.chunks = list(self.iter_chunks())
  194.   return self.chunks

  196.     def iter_chunks(self):
  197.   """
  198.   Return an iterable list of all chunks. Use this function if you only
  199.   want to loop through the chunks once or have a very large world.
  200.   Use get_chunks() if you access the chunk list frequently and want to cache
  201.   the results. Use iter_nbt() if you are concerned about speed and don't want
  202.   to parse the block data.
  203.   """
  204.   # TODO: Implement BoundingBox
  205.   # TODO: Implement sort order
  206.   for c in self.iter_nbt():
  207.    yield self.chunkclass(c)

  209.     def chunk_count(self):
  210.   """Return a count of the chunks in this world folder."""
  211.   c = 0
  212.   for r in self.iter_regions():
  213.    c += r.chunk_count()
  214.   return c

  216.     def get_boundingbox(self):
  217.   """
  218.   Return minimum and maximum x and z coordinates of the chunks that
  219.   make up this world save
  220.   """
  221.   b = BoundingBox()
  222.   for rx,rz in self.regionfiles.keys():
  223.    region = self.get_region(rx,rz)
  224.    rx,rz = 32*rx,32*rz
  225.    for cc in region.get_chunk_coords():
  226.     x,z = (rx+cc['x'],rz+cc['z'])
  227.     b.expand(x,None,z)
  228.   return b

  230.     def __repr__(self):
  231.   return "%s(%r)" % (self.__class__.__name__,self.worldfolder)


  234. class McRegionWorldFolder(_BaseWorldFolder):
  235.     """Represents a world save using the old McRegion format."""
  236.     type = "McRegion"
  237.     extension = 'mcr'
  238.     chunkclass = chunk.McRegionChunk


  241. class AnvilWorldFolder(_BaseWorldFolder):
  242.     """Represents a world save using the new Anvil format."""
  243.     type = "Anvil"
  244.     extension = 'mca'
  245.     chunkclass = chunk.AnvilChunk


  248. class _WorldFolderFactory(object):
  249.     """Factory class: instantiate the subclassses in order, and the first instance
  250.     whose nonempty() method returns True is returned. If no nonempty() returns True,
  251.     a UnknownWorldFormat exception is raised."""
  252.     def __init__(self, subclasses):
  253.   self.subclasses = subclasses
  254.     def __call__(self, *args, **kwargs):
  255.   for cls in self.subclasses:
  256.    wf = cls(*args, **kwargs)
  257.    if wf.nonempty(): # Check if the world is non-empty
  258.     return wf
  259.   raise UnknownWorldFormat("Empty world or unknown format")

  261. WorldFolder = _WorldFolderFactory([AnvilWorldFolder, McRegionWorldFolder])
  262. """
  263. Factory instance that returns a AnvilWorldFolder or McRegionWorldFolder
  264. instance, or raise a UnknownWorldFormat.
  265. """



  269. class BoundingBox(object):
  270.     """A bounding box of x,y,z coordinates."""
  271.     def __init__(self, minx=None, maxx=None, miny=None, maxy=None, minz=None, maxz=None):
  272.   self.minx,self.maxx = minx, maxx
  273.   self.miny,self.maxy = miny, maxy
  274.   self.minz,self.maxz = minz, maxz
  275.     def expand(self,x,y,z):
  276.   """
  277.   Expands the bounding
  278.   """
  279.   if x != None:
  280.    if self.minx is None or x < self.minx:
  281.     self.minx = x
  282.    if self.maxx is None or x > self.maxx:
  283.     self.maxx = x
  284.   if y != None:
  285.    if self.miny is None or y < self.miny:
  286.     self.miny = y
  287.    if self.maxy is None or y > self.maxy:
  288.     self.maxy = y
  289.   if z != None:
  290.    if self.minz is None or z < self.minz:
  291.     self.minz = z
  292.    if self.maxz is None or z > self.maxz:
  293.     self.maxz = z
  294.     def lenx(self):
  295.   if self.maxx is None or self.minx is None:
  296.    return 0
  297.   return self.maxx-self.minx+1
  298.     def leny(self):
  299.   if self.maxy is None or self.miny is None:
  300.    return 0
  301.   return self.maxy-self.miny+1
  302.     def lenz(self):
  303.   if self.maxz is None or self.minz is None:
  304.    return 0
  305.   return self.maxz-self.minz+1
  306.     def __repr__(self):
  307.   return "%s(%s,%s,%s,%s,%s,%s)" % (self.__class__.__name__,self.minx,self.maxx,
  308.     self.miny,self.maxy,self.minz,self.maxz)



/setup.py

代码:

  1. #!/usr/bin/env python

  3. from setuptools import setup
  4. from nbt import VERSION

  6. setup(
  7. name    = 'NBT',
  8. version    = ".".join(str(x) for x in VERSION),
  9. description   = 'Named Binary Tag Reader/Writer',
  10. author  = 'Thomas Woolford',
  11. author_email  = '[email protected]',
  12. url  = 'http://github.com/twoolie/NBT',
  13. license    = open("LICENSE.txt").read(),
  14. long_description = open("README.txt").read(),
  15. packages   = ['nbt'],
  16. classifiers   = [
  17.   "Development Status :: 5 - Production/Stable",
  18.   "Intended Audience :: Developers",
  19.   "License :: OSI Approved :: MIT License",
  20.   "Operating System :: OS Independent",
  21.   "Programming Language :: Python",
  22.   "Programming Language :: Python :: 2.7",
  23.   "Programming Language :: Python :: 3.3",
  24.   "Programming Language :: Python :: 3.4",
  25.   "Programming Language :: Python :: 3.5",
  26.   "Programming Language :: Python :: 3.6",
  27.   "Topic :: Games/Entertainment",
  28.   "Topic :: Software Development :: Libraries :: Python Modules"
  29. ]
  30. )