def toString(self):
stream = io.BytesIO()
serialize.writeVariant(stream, self.type)
serialize.writeVariant(stream, self.session)
serialize.writeString(stream, self.name)
content = stream.getvalue()
stream.close()
return content
def toString(self):
stream = io.BytesIO()
serialize.writeVariant(stream, self.type)
serialize.writeVariant(stream, self.session)
serialize.writeString(stream, self.client_key)
serialize.writeString(stream, self.digest)
serialize.writeVariant(stream, self.sender)
serialize.writeString(stream, self.name)
serialize.writeString(stream, self.ip)
serialize.writeVariant(stream, self.port)
content = stream.getvalue()
stream.close()
return content
def toString(self):
stream = io.BytesIO()
##write basic attrib
##msg id
serialize.writeVariant(stream, self.id)
##type&success
##bin: 6bit type | 1bit success
if self.success:
stream.write(chr((self.type<<1)|1))
else:
stream.write(chr((self.type<<1)|0))
##sender&receiver
serialize.writeString(stream, self.sender)
serialize.writeString(stream, self.receiver)
serialize.writeVariant(stream, self.session)
serialize.writeVariant(stream, self.sequence)
serialize.writeVariant(stream, self.transaction)
serialize.writeVariant(stream, self.timestamp)
self.writeParams(stream)
content = stream.getvalue()
stream.close()
return content
def toString(self):
stream = io.BytesIO()
serialize.writeVariant(stream, self.type)
serialize.writeVariant(stream, self.session)
if self.success:
success = 1
else:
success = 0
if self.need_digest:
bool_value = success << 1|1
else:
bool_value = success << 1|0
serialize.writeVariant(stream, bool_value)
serialize.writeString(stream, self.client_key)
serialize.writeString(stream, self.server_key)
serialize.writeVariant(stream, self.sender)
serialize.writeString(stream, self.name)
serialize.writeString(stream, self.ip)
serialize.writeVariant(stream, self.port)
content = stream.getvalue()
stream.close()
return content
def writeParams(self, stream):
for value_type in self.params.keys():
for key in self.params[value_type]:
value = self.params[value_type][key]
## 2bytes: 11 bits key, 5 bits type
key_value = key << 5|value_type
stream.write(chr(key_value >> 8))
stream.write(chr(key_value&0xFF))
if self.param_type_uint == value_type:
##write uint params
if not (isinstance(value, int) or isinstance(value, long)):
raise Exception("write param:invalid uint value for key %d, msg %d"%(key, self.id))
serialize.writeVariant(stream, value)
elif self.param_type_bool == value_type:
if not isinstance(value, int):
raise Exception("write param:invalid bool value for key %d, msg %d"%(key, self.id))
##write bool params
if value:
serialize.writeVariant(stream, 1)
else:
serialize.writeVariant(stream, 0)
elif self.param_type_int == value_type:
if not (isinstance(value, int) or isinstance(value, long)):
raise Exception("write param:invalid int value for key %d, msg %d"%(key, self.id))
##write int params
serialize.writeVariant(stream, serialize.zigzagEncode(value))
elif self.param_type_string == value_type:
if not isinstance(value, str):
raise Exception("write param:invalid string value for key %d, msg %d"%(key, self.id))
##write string params
serialize.writeString(stream, value)
elif self.param_type_float == value_type:
if not (isinstance(value, float) or isinstance(value, int) or isinstance(value, long)):
raise Exception("write param:invalid float value for key %d, msg %d"%(key, self.id))
##write float
serialize.writeFloat(stream, value)
elif self.param_type_uint_array == value_type:
##write uint array
if not isinstance(value, list):
raise Exception("write param:invalid uint array for key %d, msg %d"%(key, self.id))
##write count
count = len(value)
serialize.writeVariant(stream, count)
for uint_value in value:
if not (isinstance(uint_value, int) or isinstance(uint_value, long)):
raise Exception("write param:invalid uint item for key %d, msg %d"%(key, self.id))
serialize.writeVariant(stream, uint_value)
elif self.param_type_string_array == value_type:
##write string array
if not isinstance(value, list):
raise Exception("write param:invalid string array for key %d, msg %d"%(key, self.id))
##write count
count = len(value)
serialize.writeVariant(stream, count)
for string_value in value:
if not isinstance(string_value, str):
raise Exception("write param:invalid string item for key %d, msg %d, params:%s"%(key, self.id, self.params))
serialize.writeString(stream, string_value)
elif self.param_type_float_array == value_type:
##write float array
if not isinstance(value, list):
raise Exception("write param:invalid float array for key %d, msg %d"%(key, self.id))
##write count
count = len(value)
serialize.writeVariant(stream, count)
for float_value in value:
if not (isinstance(float_value, float) or isinstance(float_value, int) or isinstance(float_value, long)):
raise Exception("write param:invalid float item for key %d, msg %d"%(key, self.id))
serialize.writeFloat(stream, float_value)
elif self.param_type_uint_array_array == value_type:
##write uint array array
if not isinstance(value, list):
raise Exception("write param:invalid uint array array for key %d, msg %d"%(key, self.id))
##write count
array_count = len(value)
serialize.writeVariant(stream, array_count)
for sub_array in value:
if not isinstance(sub_array, list):
raise Exception("write param:invalid uint sub array for key %d, msg %d"%(key, self.id))
sub_count = len(sub_array)
serialize.writeVariant(stream, sub_count)
for uint_value in sub_array:
if not (isinstance(uint_value, int) or isinstance(uint_value, long)):
raise Exception("write param:invalid uint sub item for key %d, msg %d"%(key, self.id))
serialize.writeVariant(stream, uint_value)
elif self.param_type_string_array_array == value_type:
##write string array array
if not isinstance(value, list):
raise Exception("write param:invalid string array array for key %d, msg %d"%(key, self.id))
##write count
array_count = len(value)
serialize.writeVariant(stream, array_count)
for sub_array in value:
if not isinstance(sub_array, list):
raise Exception("write param:invalid string sub array for key %d, msg %d"%(key, self.id))
sub_count = len(sub_array)
serialize.writeVariant(stream, sub_count)
for string_value in sub_array:
if not isinstance(string_value, str):
raise Exception("write param:invalid string sub item for key %d, msg %d, params:%s"%(
key, self.id, self.params))
serialize.writeString(stream, string_value)
elif self.param_type_float_array_array == value_type:
##write float array array
if not isinstance(value, list):
raise Exception("write param:invalid float array array for key %d, msg %d"%(key, self.id))
##write count
array_count = len(value)
serialize.writeVariant(stream, array_count)
for sub_array in value:
if not isinstance(sub_array, list):
raise Exception("write param:invalid float sub array for key %d, msg %d"%(key, self.id))
sub_count = len(sub_array)
serialize.writeVariant(stream, sub_count)
for float_value in sub_array:
if not (isinstance(float_value, float) or isinstance(float_value, int) or isinstance(float_value, long)):
raise Exception("write param:invalid float sub item for key %d, msg %d"%(key, self.id))
serialize.writeFloat(stream, float_value)
def getBlockData(self):
out = BytesIO()
serialize.writeU8(out, 25) # Version
#flags
flags = 0x00
if self.pos[1] < -1:
flags |= 0x01 #is_underground
flags |= 0x02 #day_night_differs
flags |= 0x04 #lighting_expired
flags |= 0x08 #generated
serialize.writeU8(out, flags)
serialize.writeU8(out, 2) # content_width
serialize.writeU8(out, 2) # params_width
cbuffer = BytesIO()
# Bulk node data
content = self.content
k = 0
nimap = {}
rev_nimap = []
first_free_content = 0
for z in range(16):
for y in range(16):
for x in range(16):
#writeU16(cbuffer, content[k])
c = content[k]
if c in nimap:
serialize.writeU16(cbuffer, nimap[c])
else:
nimap[c] = first_free_content
serialize.writeU16(cbuffer, first_free_content)
rev_nimap.append(c)
first_free_content += 1
k += 1
k += (256 - 16)
k += (16 - (16 * 256))
param1 = self.param1
k = 0
for z in range(16):
for y in range(16):
for x in range(16):
serialize.writeU8(cbuffer, param1[k])
k += 1
k += (256 - 16)
k += (16 - (16 * 256))
param2 = self.param2
k = 0
for z in range(16):
for y in range(16):
for x in range(16):
serialize.writeU8(cbuffer, param2[k])
k += 1
k += (256 - 16)
k += (16 - (16 * 256))
out.write(zlib.compress(cbuffer.getvalue()))
# Nodemeta
meta = self.metadata
cbuffer = BytesIO()
serialize.writeU8(cbuffer, 1) # Version
serialize.writeU16(cbuffer, len(meta))
for pos, data in meta.items():
serialize.writeU16(cbuffer, (pos[2] << 8) | (pos[1] << 4) | pos[0])
serialize.writeU32(cbuffer, len(data[0]))
for name, val in data[0].items():
serialize.writeString(cbuffer, name)
serialize.writeLongString(cbuffer, str(val))
serialize_inv(cbuffer, data[1])
out.write(zlib.compress(cbuffer.getvalue()))
# Static objects
serialize.writeU8(out, 0) # Version
serialize.writeU16(out, 0) # Number of objects
# Timestamp
serialize.writeU32(out, 0xffffffff) # BLOCK_TIMESTAMP_UNDEFINED
# Name-ID mapping
serialize.writeU8(out, 0) # Version
serialize.writeU16(out, len(rev_nimap))
for i in range(len(rev_nimap)):
serialize.writeU16(out, i)
serialize.writeString(out, self.name_id_mapping[rev_nimap[i]])
# Node timer
serialize.writeU8(out, 2 + 4 + 4) # Timer data len
serialize.writeU16(out, len(self.timers)) # Number of timers
if len(self.timers) > 0:
pass
#logger.info('wrote ' + str(len(self.timers)) + ' node timers')
for i in range(len(self.timers)):
serialize.writeU16(out, self.timers[i][0])
serialize.writeU32(out, self.timers[i][1])
serialize.writeU32(out, self.timers[i][2])
return out.getvalue()
