pyncraft 0.2.2__py3-none-any.whl

pyncraft/block.py

@@ -0,0 +1,103 @@
+'''
+This isn't tested (and isn't that useful since the 1.13/FruitJuice update), 
+but has been modified with the intent of maintaining backward compatibility 
+with mcpi-developed programs, and may be extended as a list of allowed blocks.
+NOTE: See data/blocks_1.19.csv for many more available blocks
+'''
+class Block:
+    """Minecraft PI block description. Can be sent to Minecraft.setBlock/s"""
+    def __init__(self, id, data=0):
+        self.id = id
+        self.data = data
+
+    def __cmp__(self, rhs):
+        return hash(self) - hash(rhs)
+
+    def __eq__(self, rhs):
+        return self.id == rhs.id and self.data == rhs.data
+
+    def __hash__(self):
+        return (self.id << 8) + self.data
+
+    def withData(self, data):
+        return Block(self.id, data)
+
+    def __iter__(self):
+        """Allows a Block to be sent whenever id [and data] is needed"""
+        return iter((self.id, self.data))
+        
+    def __repr__(self):
+        return "Block(%d, %d)"%(self.id, self.data)
+
+AIR                 = Block("AIR")
+STONE               = Block("STONE")
+GRASS               = Block("GRASS_BLOCK")
+DIRT                = Block("DIRT")
+COBBLESTONE         = Block("COBBLESTONE")
+WOOD_PLANKS         = Block("OAK_PLANKS")
+SAPLING             = Block("OAK_SAPLING")
+BEDROCK             = Block("BEDROCK")
+WATER_FLOWING       = Block("WATER")
+WATER               = WATER_FLOWING
+WATER_STATIONARY    = Block("WATER")
+LAVA_FLOWING        = Block("LAVA")
+LAVA                = LAVA_FLOWING
+LAVA_STATIONARY     = Block("LAVA")
+SAND                = Block("SAND")
+GRAVEL              = Block("GRAVEL")
+GOLD_ORE            = Block("GOLD_ORE")
+IRON_ORE            = Block("IRON_ORE")
+COAL_ORE            = Block("COAL_ORE")
+WOOD                = Block("OAK_LOG")
+LEAVES              = Block("OAK_LEAVES")
+GLASS               = Block("GLASS")
+LAPIS_LAZULI_ORE    = Block("LAPIS_ORE")
+LAPIS_LAZULI_BLOCK  = Block("LAPIS_BLOCK")
+SANDSTONE           = Block("SANDSTONE")
+BED                 = Block("WHITE_BED") # NOTE: this doesn't really work (2-block piece needs special handling)
+COBWEB              = Block("COBWEB")
+GRASS_TALL          = Block("TALL_GRASS")
+WOOL                = Block("WHITE_WOOL")
+FLOWER_YELLOW       = Block("DANDELION")
+FLOWER_CYAN         = Block(38)
+MUSHROOM_BROWN      = Block("BROWN_MUSHROOM")
+MUSHROOM_RED        = Block("RED_MUSHROOM")
+GOLD_BLOCK          = Block("GOLD_BLOCK")
+IRON_BLOCK          = Block("IRON_BLOCK")
+STONE_SLAB_DOUBLE   = Block(43)
+STONE_SLAB          = Block("STONE_SLAB")
+BRICK_BLOCK         = Block("BRICKS")
+TNT                 = Block("TNT")
+BOOKSHELF           = Block("BOOKSHELF")
+MOSS_STONE          = Block("MOSS_STONE")
+OBSIDIAN            = Block("OBSIDIAN")
+TORCH               = Block("TORCH")
+FIRE                = Block("FIRE")
+STAIRS_WOOD         = Block("OAK_STAIRS")
+CHEST               = Block("CHEST")
+DIAMOND_ORE         = Block("DIAMOND_ORE")
+DIAMOND_BLOCK       = Block("DIAMOND_BLOCK")
+CRAFTING_TABLE      = Block("CRAFTING_TABLE")
+FARMLAND            = Block("FARMLAND")
+FURNACE_INACTIVE    = Block("FURNACE_INACTIVE")
+FURNACE_ACTIVE      = Block("FURNACE_ACTIVE")
+DOOR_WOOD           = Block("OAK_DOOR") # NOTE: this doesn't really work (2-block piece needs special handling)
+LADDER              = Block("LADDER")
+STAIRS_COBBLESTONE  = Block("COBBLESTONE_STAIRS")
+DOOR_IRON           = Block("IRON_DOOR")
+REDSTONE_ORE        = Block("REDSTONE_ORE")
+SNOW                = Block("SNOW")
+ICE                 = Block("ICE")
+SNOW_BLOCK          = Block("SNOW_BLOCK")
+CACTUS              = Block("CACTUS")
+CLAY                = Block("CLAY")
+SUGAR_CANE          = Block("SUGAR_CANE")
+FENCE               = Block("OAK_FENCE")
+GLOWSTONE_BLOCK     = Block("GLOWSTONE")
+BEDROCK_INVISIBLE   = Block("BEDROCK")
+STONE_BRICK         = Block("STONE_BRICKS")
+GLASS_PANE          = Block("GLASS_PANE")
+MELON               = Block("MELON")
+FENCE_GATE          = Block("OAK_FENCE_GATE")
+GLOWING_OBSIDIAN    = Block("GLOWING_OBSIDIAN")
+NETHER_REACTOR_CORE = Block(247)

pyncraft/connection.py

@@ -0,0 +1,75 @@
+import socket
+import select
+import sys
+from .util import flatten_parameters_to_bytestring
+
+""" @author: Aron Nieminen, Mojang AB"""
+
+class RequestError(Exception):
+    pass
+
+class ConnectionClosed(Exception):
+    """The server closed the TCP connection.
+
+    Deliberately not named ConnectionError: that has been a Python builtin
+    since 3.3, and shadowing it here would mean any except ConnectionError
+    in this module silently stops catching real socket errors.
+    """
+    pass
+
+class Connection:
+    """Connection to a Minecraft Pi game"""
+    RequestFailed = "Fail"
+
+    def __init__(self, address, port):
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.connect((address, port))
+        self.lastSent = ""
+
+    def drain(self):
+        """Drains the socket of incoming data"""
+        while True:
+            readable, _, _ = select.select([self.socket], [], [], 0.0)
+            if not readable:
+                break
+            data = self.socket.recv(1500)
+            if len(data) == 0:
+                raise ConnectionClosed("%s failed! Cause: connection closed" % self.lastSent.strip())
+            e =  "Drained Data: <%s>\n"%data.strip().decode('cp437')
+            e += "Last Message: <%s>\n"%self.lastSent.strip().decode('cp437')
+            sys.stderr.write(e)
+
+    def send(self, f, *data):
+        """
+        Sends data. Note that a trailing newline '\n' is added here
+
+        The protocol uses CP437 encoding - https://en.wikipedia.org/wiki/Code_page_437
+        which is mildly distressing as it can't encode all of Unicode.
+        """
+
+        s = b"".join([f, b"(", flatten_parameters_to_bytestring(data), b")", b"\n"])
+        self._send(s)
+
+    def _send(self, s):
+        """
+        The actual socket interaction from self.send, extracted for easier mocking
+        and testing
+        """
+        self.drain()
+        self.lastSent = s
+        self.socket.sendall(s)
+
+    def receive(self):
+        """Receives data. Note that the trailing newline '\n' is trimmed"""
+        s = self.socket.makefile("r").readline().rstrip("\n")
+        checkFail = s.split(",")
+        if checkFail[0] == Connection.RequestFailed:
+            # clear anything still queued, or the next call reads this failure's tail
+            self.drain()
+            raise RequestError("%s failed! Cause: %s" % (self.lastSent.strip(),checkFail[-1]))
+        return s
+
+    def sendReceive(self, *data):
+        """Sends and receive data"""
+        self.send(*data)
+        return self.receive()

pyncraft/coord.py

@@ -0,0 +1,289 @@
+from typing import Callable, Iterable, Union, Optional
+
+import numpy as np
+
+
+
+class Coord(np.ndarray):
+    """
+    Implement 3D coordinates as a 3-element (x, y, z) numpy array subclass.
+
+    This avoids having to reinvent the wheel for basic vector operations.
+    You can pass in a Vec3, list, tuple, pd.Series or individual x, y, z values.
+    They must be numeric (int or float).
+
+    Parameters
+    ----------
+    x : int, float, Iterable
+        The x coordinate or a 3-element iterable containing x, y, z coordinates.
+        Positive x is east, negative x is west.
+    y : int, float, None
+        The y coordinate (vertical position). Positive y is up, negative y is 
+        down. Unused if `x` is an iterable.
+    z : int, float, None
+        The z coordinate. Positive z is south, negative z is north. Unused if 
+        `x` is an iterable.
+    """
+
+    __int_types__ = (int, np.int32, np.int64)
+    __float_types__ = (float, np.float32, np.float64)
+    __numeric__ = __int_types__ + __float_types__
+    
+    def __new__(cls, 
+                x: Union[int, float, Iterable], 
+                y: Union[int, float, None] = None, 
+                z: Union[int, float, None] = None
+    ):
+        if isinstance(x, Iterable):
+            x = [v for i, v in enumerate(x) if i < 4]
+            if len(x) != 3:
+                raise ValueError(f"Expected 3 coordinates, got {len(x)}: {x}")
+            x, y, z = tuple(x)
+        else:
+            if not isinstance(x, cls.__numeric__):
+                raise TypeError(f"x must be int or float, got {type(x)}: {x}")
+            if not isinstance(y, cls.__numeric__):
+                raise TypeError(f"y must be int or float, got {type(y)}: {y}")
+            if not isinstance(z, cls.__numeric__):
+                raise TypeError(f"z must be int or float, got {type(z)}: {z}")
+        
+        # float64 always: an int array would silently truncate a later
+        # fractional assignment, and minecraft positions are fractional.
+        # Use block() when you want whole-number block coordinates.
+        obj = np.asarray([x, y, z], dtype=float).view(cls)
+        return obj
+    
+    # accessor methods convert numpy int/float to Python int/float
+    @property
+    def x(self):
+        return int(self[0]) if isinstance(self[0], self.__int_types__) else float(self[0])
+
+    @x.setter
+    def x(self, value):
+        self[0] = value
+
+    @property
+    def y(self):
+        return int(self[1]) if isinstance(self[1], self.__int_types__) else float(self[1])
+
+    @y.setter
+    def y(self, value):
+        self[1] = value
+
+    @property
+    def z(self):
+        return int(self[2]) if isinstance(self[2], self.__int_types__) else float(self[2])
+
+    @z.setter
+    def z(self, value):
+        self[2] = value
+
+    
+    def adjust(self, axis: str, delta: Union[int, float]) -> 'Coord':
+        """
+        Copy Coord and adjust one axis (x, y or z) by delta
+        """
+        axis = {'x': 0, 'y': 1, 'z': 2}.get(str(axis).lower())
+        if axis is None:
+            # without this, coord[None] += delta broadcasts across every axis
+            raise ValueError("axis must be one of 'x', 'y' or 'z'")
+        coord = self.copy()
+        coord[axis] += delta
+        return coord
+
+
+    def block(self, as_int: bool = True) -> 'Coord':
+        """
+        Get the whole-number block coordinates as Coord object By Flooring.
+
+        If as_int is True, returns the block coordinate as an integer.
+        Otherwise, float.
+        """
+        block = np.floor(self)
+        if as_int:
+            block = block.astype(int)
+        return block
+    
+    
+    def midblock(self) -> 'Coord':
+        return self.block(as_int=False) + Coord(0.5, 0.0, 0.5)
+    
+
+    def coplane(self, c2: 'Coord') -> bool:
+        """
+        Check whether the second coordinate shares a plane with this one.
+
+        Use Vec3D(c1, c2).coplane() if you want to know which plane.
+        """
+
+        return bool(Vec3D(self, c2).coplane())
+    
+
+    def direction(self, c2: 'Coord') -> 'Vec3D':
+        """
+        Get the unit vector from c1 to c2 (normalized to length 1).
+        """
+        return Vec3D(self, c2).direction()
+    
+    
+    def cardinal_direction(self, c2: 'Coord', *args, **kwargs) -> Union[str, 'Coord']:
+        """
+        Get the Cardinal Direction of a Second Coordinate.
+
+        See help for Vec3D.cardinal_direction() for details.
+        """
+        return Vec3D(self, c2).cardinal_direction(*args, **kwargs)
+    
+
+    def distance(self, c2: 'Coord') -> float:
+        """
+        Calculate the distance between two coordinates.
+        """
+        return float(np.sqrt(((self - c2) ** 2).sum()))
+        
+
+
+class Vec3D(Coord):
+    """
+    A 3D vector class that takes one or two Coord objects as input.
+    """
+    
+    def __init__(self, c1: Coord, c2: Coord = None):
+
+        v = c1 if c2 is None else c2 - c1
+        
+        self.x = v.x
+        self.y = v.y
+        self.z = v.z
+
+
+    def rotateLeft(self):  self.x, self.z = self.z, -self.x
+
+    def rotateRight(self): self.x, self.z = -self.z, self.x
+    
+
+    def is_unit(self):
+        """Test if the vector is a unit vector (normalized to length 1)."""
+        return np.isclose(np.linalg.norm(self), 1.0)
+    
+
+    def direction(self) -> Coord:
+        """
+        Get the unit vector from c1 to c2 (normalized to length 1).
+        """
+        return (self) / np.linalg.norm(self)
+    
+
+    def coplane(self) -> str:
+        """
+        Which plane, if any, this vector lies in.
+
+        Returns the axes the vector does not move along: 'y' means it stays at
+        one height, 'xz' means it only moves up and down, '' means it moves in
+        all three. Falsy when the vector is in no plane.
+        """
+
+        plane = ''
+        if np.isclose(self.x, 0.0):
+            plane += 'x'
+        if np.isclose(self.y, 0.0):
+            plane += 'y'
+        if np.isclose(self.z, 0.0):
+            plane += 'z'
+
+        return plane
+    
+    
+    def cardinal_direction(
+            self, 
+            returns: str = 'string',
+            compass_points: int = 4
+        ) -> Union[str, int, Coord]:
+        """
+        Get the Cardinal Direction Of The Vector In The XY Plane.
+
+        Uses the x and z components only, and returns the closest direction
+        based on the number fo compass points.  Direction may be returned 
+        as a string ("north"), minecraft rotation value (0-15), degrees (0-360),
+        radians (0-2pi), or a Vec3D/Coord unit vector with y==0.
+
+        Note that when there is a tie (like x=1 and z=-1 with 4 compass points),
+        I'm not doing anything specific to resolve (north or east in this case).
+        Could return 'indeteminate', None/np.nan or raise an exception.  Also
+        leaving it up to the user whether to convert Coords to integer.
+
+        Parameters
+        ----------
+        returns : str
+            The type of return value. Can be 'string', 'rotation', 'coord', or 
+            'degrees'. Default is 'string'.
+        compass_points : int
+            The number of compass points to use for the direction. 
+            Default is 4 (north, east, south, west). If set to 8, it will also
+            return northeast, southeast, southwest, and northwest.  If set
+            to 16, it will return all 16 compass points ('northnortheast', 
+            'northeast', 'eastnortheast', 'east', etc).  
+        
+        Returns
+        -------
+        Union[str, int, Coord]:
+            If returns is string: 'north', 'south', 'east', 'west',.
+        """
+        ok = {'string', 'rotation', 'coord', 'degrees', 'radians'} 
+        invalid = {returns} - ok
+        if invalid:
+            raise ValueError(
+                f'Invalid returns argument "{returns}"; must be one of:\n   '
+                + ', '.join(list(ok)))
+        
+        if self.x == 0 and self.z == 0:
+            raise ValueError('Vector point straight up or down; indeterminate.')
+
+        # drop the y component and normalize the xz vector (z -> y)
+        xz = np.delete(self, 1)
+        xz = xz / np.linalg.norm(xz)
+
+        # atan2 returns angle from x-axis (east), so swap arguments and invert z
+        # calculate fraction of a turn [0, 1) from North = 0 degrees
+        frac360 = (np.arctan2(xz.x, -xz.y) / (np.pi * 2)) % 1.0
+
+        bearings = ['north', 'northnortheast', 'northeast', 'eastnortheast', 
+                    'east', 'eastsoutheast', 'southeast', 'southsoutheast', 
+                    'south', 'southsouthwest', 'southwest', 'westsouthwest',
+                    'west', 'westnorthwest', 'northwest', 'northnorthwest',
+                    'north']
+
+        if compass_points > 0:
+            # convert to a rotation value, rounded to the nearest compass point
+            rotation = int(
+                np.round(frac360 * compass_points) * 16 / compass_points)
+
+            if returns == 'rotation':
+                return rotation
+            elif returns == 'degrees':
+                return rotation * 360 / 16
+            elif returns == 'string':
+                return bearings[rotation]
+            else: 
+                radians = rotation * 2 * np.pi / 16
+                if returns == 'radians':
+                    return radians
+                else:
+                    # rounded unit vector in the xz plane
+                    coord = Coord(np.sin(radians), 0, -np.cos(radians))
+                    if compass_points == 4:
+                        coord = coord.astype(int)
+                    return coord
+        elif returns in ('string', 'rotation'):
+            raise ValueError(
+                f'Must set compass_points > 0 for returns "string" or "rotation"')
+        else:
+            # return results without rounding
+            radians = frac360 * 2 * np.pi
+            if returns == 'degrees':
+                return frac360 * 360
+            else:
+                if returns == 'radians':
+                    return radians
+                else:
+                    return Coord(np.sin(radians), 0,-np.cos(radians))

pyncraft/entity.py

@@ -0,0 +1,102 @@
+class Entity:
+    '''Minecraft PI entity description. Can be sent to Minecraft.spawnEntity'''
+
+    def __init__(self, id, name = None):
+        self.id = id
+        self.name = name
+
+    def __cmp__(self, rhs):
+        return hash(self) - hash(rhs)
+
+    def __eq__(self, rhs):
+        return self.id == rhs.id
+
+    def __hash__(self):
+        return self.id
+
+    def __iter__(self):
+        '''Allows an Entity to be sent whenever id is needed'''
+        return iter((self.id,))
+
+    def __repr__(self):
+        return 'Entity(%d)'%(self.id)
+
+EXPERIENCE_ORB = Entity(2, "EXPERIENCE_ORB")
+AREA_EFFECT_CLOUD = Entity(3, "AREA_EFFECT_CLOUD")
+ELDER_GUARDIAN = Entity(4, "ELDER_GUARDIAN")
+WITHER_SKELETON = Entity(5, "WITHER_SKELETON")
+STRAY = Entity(6, "STRAY")
+EGG = Entity(7, "EGG")
+LEASH_HITCH = Entity(8, "LEASH_HITCH")
+PAINTING = Entity(9, "PAINTING")
+ARROW = Entity(10, "ARROW")
+SNOWBALL = Entity(11, "SNOWBALL")
+FIREBALL = Entity(12, "FIREBALL")
+SMALL_FIREBALL = Entity(13, "SMALL_FIREBALL")
+ENDER_PEARL = Entity(14, "ENDER_PEARL")
+ENDER_SIGNAL = Entity(15, "ENDER_SIGNAL")
+THROWN_EXP_BOTTLE = Entity(17, "THROWN_EXP_BOTTLE")
+ITEM_FRAME = Entity(18, "ITEM_FRAME")
+WITHER_SKULL = Entity(19, "WITHER_SKULL")
+PRIMED_TNT = Entity(20, "PRIMED_TNT")
+HUSK = Entity(23, "HUSK")
+SPECTRAL_ARROW = Entity(24, "SPECTRAL_ARROW")
+SHULKER_BULLET = Entity(25, "SHULKER_BULLET")
+DRAGON_FIREBALL = Entity(26, "DRAGON_FIREBALL")
+ZOMBIE_VILLAGER = Entity(27, "ZOMBIE_VILLAGER")
+SKELETON_HORSE = Entity(28, "SKELETON_HORSE")
+ZOMBIE_HORSE = Entity(29, "ZOMBIE_HORSE")
+ARMOR_STAND = Entity(30, "ARMOR_STAND")
+DONKEY = Entity(31, "DONKEY")
+MULE = Entity(32, "MULE")
+EVOKER_FANGS = Entity(33, "EVOKER_FANGS")
+EVOKER = Entity(34, "EVOKER")
+VEX = Entity(35, "VEX")
+VINDICATOR = Entity(36, "VINDICATOR")
+ILLUSIONER = Entity(37, "ILLUSIONER")
+MINECART_COMMAND = Entity(40, "MINECART_COMMAND")
+BOAT = Entity(41, "BOAT")
+MINECART = Entity(42, "MINECART")
+MINECART_CHEST = Entity(43, "MINECART_CHEST")
+MINECART_FURNACE = Entity(44, "MINECART_FURNACE")
+MINECART_TNT = Entity(45, "MINECART_TNT")
+MINECART_HOPPER = Entity(46, "MINECART_HOPPER")
+MINECART_MOB_SPAWNER = Entity(47, "MINECART_MOB_SPAWNER")
+CREEPER = Entity(50, "CREEPER")
+SKELETON = Entity(51, "SKELETON")
+SPIDER = Entity(52, "SPIDER")
+GIANT = Entity(53, "GIANT")
+ZOMBIE = Entity(54, "ZOMBIE")
+SLIME = Entity(55, "SLIME")
+GHAST = Entity(56, "GHAST")
+PIG_ZOMBIE = Entity(57, "PIG_ZOMBIE")
+ENDERMAN = Entity(58, "ENDERMAN")
+CAVE_SPIDER = Entity(59, "CAVE_SPIDER")
+SILVERFISH = Entity(60, "SILVERFISH")
+BLAZE = Entity(61, "BLAZE")
+MAGMA_CUBE = Entity(62, "MAGMA_CUBE")
+ENDER_DRAGON = Entity(63, "ENDER_DRAGON")
+WITHER = Entity(64, "WITHER")
+BAT = Entity(65, "BAT")
+WITCH = Entity(66, "WITCH")
+ENDERMITE = Entity(67, "ENDERMITE")
+GUARDIAN = Entity(68, "GUARDIAN")
+SHULKER = Entity(69, "SHULKER")
+PIG = Entity(90, "PIG")
+SHEEP = Entity(91, "SHEEP")
+COW = Entity(92, "COW")
+CHICKEN = Entity(93, "CHICKEN")
+SQUID = Entity(94, "SQUID")
+WOLF = Entity(95, "WOLF")
+MUSHROOM_COW = Entity(96, "MUSHROOM_COW")
+SNOWMAN = Entity(97, "SNOWMAN")
+OCELOT = Entity(98, "OCELOT")
+IRON_GOLEM = Entity(99, "IRON_GOLEM")
+HORSE = Entity(100, "HORSE")
+RABBIT = Entity(101, "RABBIT")
+POLAR_BEAR = Entity(102, "POLAR_BEAR")
+LLAMA = Entity(103, "LLAMA")
+LLAMA_SPIT = Entity(104, "LLAMA_SPIT")
+PARROT = Entity(105, "PARROT")
+VILLAGER = Entity(120, "VILLAGER")
+ENDER_CRYSTAL = Entity(200, "ENDER_CRYSTAL")

pyncraft/event.py

@@ -0,0 +1,65 @@
+from .vec3 import Vec3
+
+class BlockEvent:
+    """An Event related to blocks (e.g. placed, removed, hit)"""
+    HIT = 0
+
+    def __init__(self, type, x, y, z, face, entityId):
+        self.type = type
+        self.pos = Vec3(x, y, z)
+        self.face = face
+        self.entityId = entityId
+
+    def __repr__(self):
+        sType = {
+            BlockEvent.HIT: "BlockEvent.HIT"
+        }.get(self.type, "???")
+
+        return "BlockEvent(%s, %d, %d, %d, %d, %d)"%(
+            sType,self.pos.x,self.pos.y,self.pos.z,self.face,self.entityId);
+
+    @staticmethod
+    def Hit(x, y, z, face, entityId):
+        return BlockEvent(BlockEvent.HIT, x, y, z, face, entityId)
+
+class ArrowHitEvent:
+    """An Event related to blocks (e.g. placed, removed, hit)"""
+    HIT = 0
+
+    def __init__(self, type, x, y, z, entityId):
+        self.type = type
+        self.pos = Vec3(x, y, z)
+        self.entityId = entityId
+
+    def __repr__(self):
+        sType = {
+            ArrowHitEvent.HIT: "ArrowHitEvent.HIT"
+        }.get(self.type, "???")
+
+        return "BlockEvent(%s, %d, %d, %d, %d)"%(
+            sType,self.pos.x,self.pos.y,self.pos.z,self.entityId);
+
+    @staticmethod
+    def Hit(x, y, z, entityId):
+        return ArrowHitEvent(ArrowHitEvent.HIT, x, y, z, entityId)
+
+class ChatEvent:
+    """An Event related to chat (e.g. posts)"""
+    POST = 0
+
+    def __init__(self, type, entityId, message):
+        self.type = type
+        self.entityId = entityId
+        self.message = message
+
+    def __repr__(self):
+        sType = {
+            ChatEvent.POST: "ChatEvent.POST"
+        }.get(self.type, "???")
+
+        return "ChatEvent(%s, %d, %s)"%(
+            sType,self.entityId,self.message);
+
+    @staticmethod
+    def Post(entityId, message):
+        return ChatEvent(ChatEvent.POST, entityId, message)

pyncraft/logger.py

@@ -0,0 +1,33 @@
+import pyncraft.settings as settings
+
+class BColors:
+    
+    TWHITE = '\033[32m'
+    TGREY = '\033[90m'
+    TRED = '\033[31m'
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    LOG ='\033[96m'
+    WARNING = '\033[45m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+    def disable(self):
+        self.HEADER = ''
+        self.OKBLUE = ''
+        self.OKGREEN = ''
+        self.WARNING = ''
+        self.FAIL = ''
+        self.ENDC = ''
+
+def debug(*msg):
+    if(settings.SHOW_DEBUG):
+        print(BColors.TGREY,msg,BColors.ENDC)
+
+def log(*msg):
+    if(settings.SHOW_Log):
+        print(BColors.LOG,msg,BColors.ENDC)
+def warn(*msg):
+    print(BColors.WARNING,msg,BColors.ENDC)