dfpyre 0.4.6__py3-none-any.whl → 0.6.0__py3-none-any.whl

dfpyre/items.py

@@ -3,8 +3,17 @@ Contains class definitions for code items.
 """
 
 from enum import Enum
-from typing import Literal, Dict
-from dfpyre.style import isAmpersandCoded, ampersandToMinimessage
+import re
+from typing import Literal, Dict, Any
+from dfpyre.style import is_ampersand_coded, ampersand_to_minimessage
+from mcitemlib.itemlib import Item as NbtItem
+
+
+NUMBER_REGEX = r'-?\d*\.?\d+'
+
+
+class PyreException(Exception):
+    pass
 
 
 def _add_slot(d: Dict, slot: int|None):
@@ -12,27 +21,16 @@ def _add_slot(d: Dict, slot: int|None):
         d['slot'] = slot
 
 
-class item:
+class item(NbtItem):
     """
     Represents a Minecraft item.
     """
     type = 'item'
 
-    def __init__(self, itemID: str, count: int=1):
-        self.id = itemID
-        self.count = count
-    
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "item": f"{{DF_NBT:2586,id:\"{self.id}\",Count:{self.count}b}}"
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type, "data": {"item": self.get_nbt()}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class string:
@@ -45,16 +43,9 @@ class string:
         self.value = value
     
     def format(self, slot: int|None):
-        formattedDict = {
-              "item": {
-                "id": self.type,
-                "data": {
-                  "name": self.value
-                }
-              }
-            }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type, "data": {"name": self.value}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class text:
@@ -64,21 +55,14 @@ class text:
     type = 'comp'
 
     def __init__(self, value: str):
-        if isAmpersandCoded(value):
-            value = ampersandToMinimessage(value)
+        if is_ampersand_coded(value):
+            value = ampersand_to_minimessage(value)
         self.value = value
-      
+    
     def format(self, slot: int|None):
-      formattedDict = {
-              "item": {
-                "id": self.type,
-                "data": {
-                  "name": self.value
-                }
-              }
-            }
-      _add_slot(formattedDict, slot)
-      return formattedDict
+      formatted_dict = {"item": {"id": self.type, "data": {"name": self.value}}}
+      _add_slot(formatted_dict, slot)
+      return formatted_dict
 
 
 class num:
@@ -87,20 +71,13 @@ class num:
     """
     type = 'num'
 
-    def __init__(self, num: int|float):
+    def __init__(self, num: int|float|str):
         self.value = num
     
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "name": str(self.value)
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type, "data": {"name": str(self.value)}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class loc:
@@ -117,23 +94,21 @@ class loc:
         self.yaw = float(yaw)
     
     def format(self, slot: int|None):
-        formattedDict =  {
-            "item": {
-              "id": self.type,
-              "data": {
+        formatted_dict =  {"item": {
+            "id": self.type,
+            "data": {
                 "isBlock": False,
                 "loc": {
-                  "x": self.x,
-                  "y": self.y,
-                  "z": self.z,
-                  "pitch": self.pitch,
-                  "yaw": self.yaw
+                    "x": self.x,
+                    "y": self.y,
+                    "z": self.z,
+                    "pitch": self.pitch,
+                    "yaw": self.yaw
                 }
-              }
             }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        }}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class var:
@@ -147,17 +122,9 @@ class var:
         self.scope = scope
 
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "name": self.name,
-                "scope": self.scope
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type,"data": {"name": self.name, "scope": self.scope}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class sound:
@@ -172,18 +139,9 @@ class sound:
         self.vol = vol
 
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "sound": self.name,
-                "pitch": self.pitch,
-                "vol": self.vol
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type,"data": {"sound": self.name, "pitch": self.pitch, "vol": self.vol}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class particle:
@@ -191,39 +149,13 @@ class particle:
     Represents a DiamondFire particle object.
     """
     type = 'part'
-    def __init__(self, name: str='Cloud', amount: int=1, horizontal: float=0.0, vertical: float=0.0, 
-                 x: float=1.0, y: float=0.0, z: float=0.0, motionVariation: float=100):
-        self.name = name
-        self.amount = amount
-        self.horizontal = horizontal
-        self.vertical = vertical
-        self.x = x
-        self.y = y
-        self.z = z
-        self.motionVariation = motionVariation
+    def __init__(self, particle_data: dict):
+        self.particle_data = particle_data
     
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "particle": self.name,
-                "cluster": {
-                  "amount": self.amount,
-                  "horizontal": self.horizontal,
-                  "vertical": self.vertical
-                },
-                "data": {
-                  "x": self.x,
-                  "y": self.y,
-                  "z": self.z,
-                  "motionVariation": self.motionVariation
-                }
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type, "data": self.particle_data}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class potion:
@@ -238,18 +170,9 @@ class potion:
         self.amp = amp
     
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "pot": self.name,
-                "dur": self.dur,
-                "amp": self.amp
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type,"data": {"pot": self.name, "dur": self.dur, "amp": self.amp}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class gamevalue:
@@ -263,17 +186,9 @@ class gamevalue:
         self.target = target
     
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "type": self.name,
-                "target": self.target
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type, "data": {"type": self.name, "target": self.target}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 class vector:
@@ -288,18 +203,9 @@ class vector:
         self.z = float(z)
     
     def format(self, slot: int|None):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
-                "x": self.x,
-                "y": self.y,
-                "z": self.z
-              }
-            }
-          }
-        _add_slot(formattedDict, slot)
-        return formattedDict
+        formatted_dict = {"item": {"id": self.type, "data": {"x": self.x, "y": self.y, "z": self.z}}}
+        _add_slot(formatted_dict, slot)
+        return formatted_dict
 
 
 PARAMETER_TYPE_LOOKUP = ['txt', 'comp', 'num', 'loc', 'vec', 'snd', 'part', 'pot', 'item', 'any', 'var', 'list', 'dict']
@@ -328,34 +234,89 @@ class parameter:
     """
     type = 'pn_el'
 
-    def __init__(self, name: str, paramType: ParameterType, plural: bool=False, optional: bool=False, description: str="", note: str="", defaultValue=None):
+    def __init__(self, name: str, param_type: ParameterType, plural: bool=False, optional: bool=False, description: str="", note: str="", default_value=None):
         self.name = name
-        self.paramType = paramType
+        self.param_type = param_type
         self.plural = plural
         self.optional = optional
         self.description = description
         self.note = note
-        self.defaultValue = defaultValue
+        self.default_value = default_value
       
     
     def format(self, slot: int):
-        formattedDict = {
-            "item": {
-              "id": self.type,
-              "data": {
+        formatted_dict = {"item": {
+            "id": self.type,
+            "data": {
                 "name": self.name,
-                "type": self.paramType.get_string_value(),
+                "type": self.param_type.get_string_value(),
                 "plural": self.plural,
                 "optional": self.optional,
-              }
-            },
+            }},
             "slot": slot
-          }
+        }
         if self.description:
-            formattedDict['item']['data']['description'] = self.description
+            formatted_dict['item']['data']['description'] = self.description
         if self.note:
-            formattedDict['item']['data']['note'] = self.note
-        if self.defaultValue is not None and not self.plural and self.optional:
-            formattedDict['item']['data']['default_value'] = self.defaultValue.format(None)['item']
+            formatted_dict['item']['data']['note'] = self.note
+        if self.default_value is not None and not self.plural and self.optional:
+            formatted_dict['item']['data']['default_value'] = self.default_value.format(None)['item']
         
-        return formattedDict
+        return formatted_dict
+
+
+def _some_or(value: Any, none_value: Any):
+    """
+    Returns `none_value` if `value` is None, otherwise returns `value`.
+    """
+    if value is None:
+        return none_value
+    return value
+
+
+def item_from_dict(item_dict: Dict) -> object:
+    item_id = item_dict['id']
+    item_data = item_dict['data']
+
+    if item_id == 'item':
+        return item.from_nbt(item_data['item'])
+    elif item_id == 'txt':
+        return string(item_data['name'])
+    elif item_id == 'comp':
+        return text(item_data['name'])
+    elif item_id == 'num':
+        num_value = item_data['name']
+        if re.match(NUMBER_REGEX, num_value):
+            num_value = float(item_data['name'])
+            if num_value % 1 == 0:
+                num_value = int(num_value)
+            return num(num_value)
+        return num(num_value)
+    elif item_id == 'loc':
+        item_loc = item_data['loc']
+        return loc(item_loc['x'], item_loc['y'], item_loc['z'], item_loc['pitch'], item_loc['yaw'])
+    elif item_id == 'var':
+        return var(item_data['name'], item_data['scope'])
+    elif item_id == 'snd':
+        return sound(item_data['sound'], item_data['pitch'], item_data['vol'])
+    elif item_id == 'part':
+        return particle(item_data)
+    elif item_id == 'pot':
+        return potion(item_data['pot'], item_data['dur'], item_data['amp'])
+    elif item_id == 'g_val':
+        return gamevalue(item_data['type'], item_data['target'])
+    elif item_id == 'vec':
+        return vector(item_data['x'], item_data['y'], item_data['z'])
+    elif item_id == 'pn_el':
+        description = _some_or(item_data.get('description'), '')
+        note = _some_or(item_data.get('note'), '')
+        param_type = ParameterType(PARAMETER_TYPE_LOOKUP.index(item_data['type']))
+        if item_data['optional']:
+            param = parameter(item_data['name'], param_type, item_data['plural'], True, description, note, item_from_dict(item_data['default_value']))
+        else:
+            param = parameter(item_data['name'], param_type, item_data['plural'], False, description, note)
+        return param
+    elif item_id == 'bl_tag':
+        return
+    else:
+        raise PyreException(f'Unrecognized item id `{item_id}`')