def set_compression(self, threshold):
""" Used internally for compression packet handlers
"""
if not self.compression_enabled:
self.compression_enabled = True
yatelog.debug('MCSock', 'Compression enabled')
self.compression_threshold = threshold
def send_yate_msg(msgtype, params, addr, sock):
""" Sends a message and returns the message ID
"""
msgid = gen_msg_id()
msgdata = msgpack.packb((msgtype, params, msgid))
sock.sendto(msgdata, (addr[0], addr[1]))
yatelog.debug(
'yateproto.py', 'Sent message %s to %s:%s' %
(str([msgtype_str[msgtype], params, msgid]), addr[0], addr[1]))
return msgid
def __init__(self, name, sock):
yatelog.debug('MCSock', 'Adding new packet type: %s' % name)
self.idents = {}
self.name = name
self.sock = sock
for k, v in protocol_modes.items():
if packets.packet_idents.has_key(
(sock.protocol_version, v, 'upstream', name)):
self.idents[k] = packets.packet_idents[(sock.protocol_version,
v, 'upstream', name)]
def msg_reader_thread(self, msg_type):
""" This is used internally to handle all messages of the specified type when they come in from the parser thread
"""
msg_type_s = msgtype_str[msg_type]
while self.active:
eventlet.greenthread.sleep(0)
if not self.handlers.has_key(
msg_type
): # don't bother wasting CPU time on it, just pull from the queue and then do nothing else
yatelog.warn('YATESock', 'No handler for %s' % msg_type_s)
try:
self.in_queues[msg_type].get()
except:
pass
continue
eventlet.greenthread.sleep(0)
msg_tuple = None
while msg_tuple == None:
eventlet.greenthread.sleep(0)
try:
msg_tuple = self.in_queues[msg_type].get()
except:
yatelog.minor_exception('YATESock',
'Error reading packet from queue')
if msg_tuple != None:
msg_params = msg_tuple[0]
msg_id = msg_tuple[1]
from_addr = msg_tuple[2]
yatelog.debug(
'YATESock', 'Got message %s from %s:%s: %s' %
(msg_type_s, from_addr[0], from_addr[1], msg_params))
if (from_addr in self.known_peers):
try:
self.handlers[msg_type](msg_params, from_addr, msg_id)
except:
yatelog.minor_exception('YATESock',
'Error handling message')
else:
if msg_type == MSGTYPE_CONNECT:
self.handle_connect(msg_params, from_addr, msg_id)
else:
self.send_unknown_peer(to_addr=from_addr)
def __init__(self,username=None,password=None,server='127.0.0.1:25565'):
super(MinecraftDriver,self).__init__(username=username,password=password,server=server)
self.username = username
self.password = password
self.avatar_uuid = None
self.avatar_eid = 0
self.avatar_name = username # not always the same, just usually
server_ip,server_port = server.split(':')
self.server_addr = (server_ip,int(server_port))
yatelog.info('minecraft','Minecraft driver starting up')
pack_handlers = {'login_success': self.handle_login_success,
'join_game': self.handle_join_game,
'player_position_and_look':self.handle_player_position_and_look,
'chunk_data': self.handle_chunk_data}
self.sock = mcsock.MCSocket(self.server_addr,handlers=pack_handlers,display_name=username)
self.sock.switch_mode(mcsock.protocol_modes['login'])
self.tick_delay = (1.0/20.0)
self.last_tick = time.time() - self.tick_delay # make sure that we tick after connecting
self.last_full_update = time.time() - 1.0 # make sure we run a full update after connecting
self.av_pos = None # stores the avatar position, in minecraft format also known as (x,z,y) to sane humans
self.av_pitch = None
self.av_yaw = None
self.on_ground = True
self.world = smpmap.Dimension(smpmap.DIMENSION_OVERWORLD)
self.sock.blocking_handlers = False
yatelog.info('minecraft','Awaiting download of avatar position and terrain data')
while self.av_pos is None:
eventlet.greenthread.sleep(self.tick_delay)
self.minecraft_client_tick()
yatelog.info('minecraft','Got avatar position, awaiting chunks')
while self.world.get_block(self.av_pos[0],self.av_pos[2],self.av_pos[1]) is None:
self.minecraft_client_tick()
yatelog.debug('minecraft','Waiting for chunk %s' % str(self.get_av_chunk()) )
yatelog.info('minecraft','Got terrain data, ready to rock')
def msg_sender_thread(self, msg_type, delay=0):
""" World's simplest QoS implementation is here - just set delay to the number of seconds to wait in between each packet transmission
"""
msg_type_s = msgtype_str[msg_type]
while self.active:
eventlet.greenthread.sleep(delay)
msg_tuple = None
while msg_tuple == None:
eventlet.greenthread.sleep(0)
try:
msg_tuple = self.out_queues[msg_type].get()
except:
yatelog.minor_exception('YATESock',
'Error reading packet from queue')
if msg_tuple != None:
msg_params = msg_tuple[0]
msg_id = msg_tuple[1]
to_addr = msg_tuple[2]
msgdata = msgpack.packb((msg_type, msg_params, msg_id))
msgdata = zlib.compress(msgdata)
if to_addr == None:
yatelog.debug(
'YATESock',
'Broadcasting message %s to all peers: %s' %
(msg_type, msg_params))
peer_list = self.known_peers.copy()
for peer in peer_list:
try:
self.sock.sendto(msgdata, peer)
yatelog.debug(
'YATESock',
'Sent broadcast message to %s:%s' % peer)
except:
yatelog.minor_exception(
'YATESock',
'Error during broadcast of message')
else:
try:
self.sock.sendto(msgdata, to_addr)
yatelog.debug(
'YATESock', 'Sent message %s to %s:%s: %s' %
(msg_type_s, to_addr[0], to_addr[1], msg_params))
except:
yatelog.minor_exception(
'YATESock', 'Error during transmission of message')
def get_voxel(self,spatial_pos):
yatelog.debug('minecraft','Querying block at %s' % str(spatial_pos))
insane_x = spatial_pos[0]
insane_y = spatial_pos[2]
insane_z = spatial_pos[1]
block = self.world.get_block(insane_x,insane_y,insane_z)
if block is None:
yate_type = YATE_VOXEL_UNKNOWN
yatelog.warn('minecraft','Requested unknown block at %s' % (str(spatial_pos)))
vox = base.YateBaseVoxel(spatial_pos=tuple(spatial_pos),basic_type=YATE_VOXEL_UNKNOWN)
return vox
yatelog.debug('minecraft','Block is %s' % str(block))
blockid = block[0]
blockdata = burger_data.blockid_blocks[blockid]
yatelog.debug('minecraft','Block at %s: %s' % (str(spatial_pos),blockdata))
if blockdata['hardness'] == 0: yate_type=YATE_VOXEL_EMPTY
if blockdata['hardness'] > 0: yate_type=YATE_VOXEL_TOTAL_OBSTACLE
vox = base.YateBaseVoxel(spatial_pos=tuple(spatial_pos),basic_type=yate_type,specific_type=blockid)
return vox
def handle_connect_ack(self, msg_params, from_addr, msg_id):
""" Confirmed new peers - only really here to shutup the warning when not overridden
"""
yatelog.debug('YATESock', 'Confirmed connection to %s:%s' % from_addr)