gistfile1.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
import time
from subprocess import Popen, PIPE, STDOUT
import serial

from watchdog.events import FileSystemEventHandler
from watchdog.observers import Observer

import redstone as rs

class DataSentence(object):
    def __init__(self, root):
        super(DataSentence, self).__init__()
        self.r = root
        self.fields = ['time', 'min', 'hour', 'day', 'month', 'year', 'sun', 'moon', 'rainTime', 'thunderTime', 'raining', 'thundering', 'x', 'y', 'z', 'pos2spawn', 'world']
    
    def get(self):
        data = []
        for field in self.fields:
            data.append(getattr(self, field))
        return '@' + ','.join(map(str, data)) + '#'
    
    @property
    def time(self):
        return self.r['Data']['Time'].integer
    @property
    def min(self):
        return int(((self.time % 1000) / 40) * 2.4)
    @property
    def hour(self):
        diff = self.time % 24000
        hour = diff // 1000 + 8
        if hour > 24:
            hour -= 24
        return hour
    @property
    def day(self):
        day = (self.time + 8000) // 24000
        day = day % 30
        return day + 1
    @property
    def month(self):
        day = (self.time + 8000) // 24000
        month = day // 30
        month = month % 12
        return month + 1
    @property
    def year(self):
        day = (self.time + 8000) // 24000
        month = day // 30
        year = month // 12
        return year
    @property
    def sun(self):
        diff = self.time % 24000
        if (diff >= 0 and diff < 13800) or (diff >= 23000 and diff < 24000):
            return 1
        return 0
    @property
    def moon(self):
        diff = self.time % 24000
        if diff >= 13800 and diff < 23000:
            return 1
        return 0
    
    @property
    def rainTime(self):
        return self.r['Data']['rainTime'].integer
    @property
    def thunderTime(self):
        return self.r['Data']['thunderTime'].integer
    @property
    def raining(self):
        return self.r['Data']['raining'].integer
    @property
    def thundering(self):
        return self.r['Data']['thundering'].integer
    
    @property
    def x(self):
        return self.r['Data']['Player']['Pos'][0].float
    @property
    def y(self):
        return self.r['Data']['Player']['Pos'][1].float
    @property
    def z(self):
        return self.r['Data']['Player']['Pos'][2].float
    
    @property
    def pos2spawn(self):
        playerx, playery, playerz = map(lambda t: t.float, self.r['Data']['Player']['Pos'])
        spawnx = self.r['Data']['SpawnX'].integer
        spawny = self.r['Data']['SpawnY'].integer
        spawnz = self.r['Data']['SpawnZ'].integer
        
        return ((playerx - spawnx)**2 + (playery - spawny)**2 + (playerz - spawnz)**2)**(0.5)
    
    @property
    def world(self):
        return self.r['Data']['LevelName'].string

class MyEventHandler(FileSystemEventHandler):
    def __init__(self, path, ser):
        super(MyEventHandler, self).__init__()
        self.path = path
        self.ser = ser
    
    def on_modified(self, event):
        nbt = rs.NBT.parse_from_file(self.path)
        sentence = DataSentence(nbt.root)
        ser.write(sentence.get())

if __name__ == "__main__":
    path = os.path.join(sys.argv[1], 'level.dat')
    ser = serial.Serial(sys.argv[2], 9600)
    
    event_handler = MyEventHandler(path, ser)
    observer = Observer()
    observer.schedule(event_handler, path, recursive=False)
    observer.start()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        pass
    finally:
        observer.stop()
        print "Bye bye!"
        ser.close()
        observer.join()