gmdkit 0.7.0__tar.gz → 0.7.1__tar.gz

{gmdkit-0.7.0 → gmdkit-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gmdkit
-Version: 0.7.0
+Version: 0.7.1
 Summary: A toolkit for handling Geometry Dash level data.
 Author: HDanke
 License: MIT
@@ -70,11 +70,8 @@ from gmdkit import Level
 # import object
 from gmdkit import Object
 
-# import property mappings
-from gmdkit.mappings import obj_prop
-
-# import object functions
-import gmdkit.functions.object as obj_func
+# import interfaces
+from gmdkit.models import interfaces
 
 # open file
 level = Level.from_file("example.gmd")
@@ -84,31 +81,18 @@ start = level.start
 
 # get level objects as an ObjectList()
 # object lists subclass list() so they can use all list methods alongside the ones defined by ListClass
-# level.objects WILL throw an error if the level lacks an object string,
-# or if you passed load = False to Level.from_file(), which skips loading objects
-# LevelSave by default does not load the objects of levels
-# so for any level you want to edit the objects of you must call level.load() first
 obj_list = level.objects
 
 # filter by condition
-after_origin = obj_list.where(lambda obj: obj.get(obj_prop.X, 0) > 0)
-
-# apply functions, kwargs are filtered for each called function
-# ex: obj_func.fix_lighter has 'replacement' as a key argument
-after_origin.apply(obj_func.clean_duplicate_groups, obj_func.fix_lighter, replacement=0)
+after_origin = obj_list.where(lambda obj: obj.interface.x > 0)
 
 # create new object
 new_obj = Object.default(1)
-# set properties of object
-# objects subclass dict() so they can use all dict methods alongside the ones defined by DictClass
-new_obj.update(
-  {
-    obj_prop.X: 100,
-    obj_prop.Y: 200,
-    obj_prop.SCALE_X: 2,
-    obj_prop.SCALE_Y: 2
-  }
-)
+# set properties of object using the typed interface
+intf = new_obj.require_interface(interfaces.BaseObject)
+intf.x = 100
+intf.y = 200
+intf.scale = 2
 
 # append object to the level's object list
 # can also be done directly to level.objects or level['k4'].objects (which level.objects references)

{gmdkit-0.7.0 → gmdkit-0.7.1}/README.md

@@ -47,11 +47,8 @@ from gmdkit import Level
 # import object
 from gmdkit import Object
 
-# import property mappings
-from gmdkit.mappings import obj_prop
-
-# import object functions
-import gmdkit.functions.object as obj_func
+# import interfaces
+from gmdkit.models import interfaces
 
 # open file
 level = Level.from_file("example.gmd")
@@ -61,31 +58,18 @@ start = level.start
 
 # get level objects as an ObjectList()
 # object lists subclass list() so they can use all list methods alongside the ones defined by ListClass
-# level.objects WILL throw an error if the level lacks an object string,
-# or if you passed load = False to Level.from_file(), which skips loading objects
-# LevelSave by default does not load the objects of levels
-# so for any level you want to edit the objects of you must call level.load() first
 obj_list = level.objects
 
 # filter by condition
-after_origin = obj_list.where(lambda obj: obj.get(obj_prop.X, 0) > 0)
-
-# apply functions, kwargs are filtered for each called function
-# ex: obj_func.fix_lighter has 'replacement' as a key argument
-after_origin.apply(obj_func.clean_duplicate_groups, obj_func.fix_lighter, replacement=0)
+after_origin = obj_list.where(lambda obj: obj.interface.x > 0)
 
 # create new object
 new_obj = Object.default(1)
-# set properties of object
-# objects subclass dict() so they can use all dict methods alongside the ones defined by DictClass
-new_obj.update(
-  {
-    obj_prop.X: 100,
-    obj_prop.Y: 200,
-    obj_prop.SCALE_X: 2,
-    obj_prop.SCALE_Y: 2
-  }
-)
+# set properties of object using the typed interface
+intf = new_obj.require_interface(interfaces.BaseObject)
+intf.x = 100
+intf.y = 200
+intf.scale = 2
 
 # append object to the level's object list
 # can also be done directly to level.objects or level['k4'].objects (which level.objects references)

gmdkit-0.7.1/scripts/compile_defaults.py

@@ -0,0 +1,45 @@
+from gmdkit import Object, ObjectList
+from gmdkit.models import interfaces
+
+pool = ObjectList.from_file("data/txt/default.txt")
+
+
+def clean_obj(obj:Object):
+    intf = obj.require_interface(interfaces.BaseObject)
+    del intf.color_1_index
+    del intf.color_2_index
+    intf.x = 0
+    intf.y = 0
+    
+    intf = obj.require_interface(interfaces.ParticleObject,None)
+    if intf:
+        intf.data = "30a-1a1a0.3a30a90a90a29a0a11a0a0a0a0a0a0a0a2a1a0a0a1a0a1a0a1a0a1a0a1a1a0a0a1a0a1a0a1a0a1a0a0a0a0a0a0a0a0a0a0a0a0a2a1a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0"
+        
+        
+pool.apply(clean_obj)
+
+
+default = dict()
+
+for obj in pool:
+    intf = obj.require_interface(interfaces.BaseObject)
+    object_id = intf.obj_id
+    default.setdefault(object_id, dict())
+    default[object_id].update(obj)
+
+
+lines = list()
+
+for key, value in default.items():
+    lines.append(f"    {repr(key)}: {repr(value)}")
+                 
+
+with open("../src/gmdkit/defaults/objects.py","w") as file:
+    
+    file.write("Default = {\n")
+    
+    file.write(',\n'.join(lines))
+    
+    file.write('\n')
+    
+    file.write('    }')

{gmdkit-0.7.0 → gmdkit-0.7.1}/scripts/grab_official_levels.py

@@ -2,8 +2,7 @@
 from pathlib import Path
 
 # Package Imports
-from gmdkit import GameSave, ObjectString
-from gmdkit.mappings import lvl_prop
+from gmdkit import Level, GameSave, ObjectString
 from gmdkit.functions.object import to_user_coins
 
 save_path = Path("data/dat/")
@@ -30,16 +29,13 @@ for folder in common:
         print(f"Processing level with ID {data['k1']}...")
             
         try:
-            
-            data[lvl_prop.OBJECT_STRING] = ObjectString.from_file(level_file,encoding="latin-1")
-            
+            data: Level
+            data.object_string = ObjectString.from_file(level_file,encoding="latin-1")
             data.objects.apply(to_user_coins)
-            
-            data[lvl_prop.TYPE] = 2
-            
+            data.level_type = 2
             data.to_file(output_path)
         except FileNotFoundError:
             print("No object string file found, skipping.")
             continue
         
-        print(f"Saved {data[lvl_prop.NAME]}.gmd")
+        print(f"Saved {data.name}.gmd")

{gmdkit-0.7.0 → gmdkit-0.7.1}/src/gmdkit/__init__.py

@@ -2,7 +2,6 @@ __all__ = [
     "constants",
     "extensions",
     "functions",
-    "mappings",
     "models",
     "remapping",
     "typing",
@@ -23,7 +22,6 @@ __all__ = [
 from . import constants
 from . import extensions
 from . import functions
-from . import mappings
 from . import models
 from . import remapping
 from .utils import typing, enums

{gmdkit-0.7.0 → gmdkit-0.7.1}/src/gmdkit/casting/level_loader.py

@@ -1,6 +1,7 @@
 # Package Imports
 from gmdkit.utils import enums
 from gmdkit.serialization.type_cast import decode_text, encode_text, get_string
+from gmdkit.models.object import Object, ObjectList
 from gmdkit.models.prop.list import IntList
 from gmdkit.models.prop.pos_list import PositionList
 from gmdkit.models.prop.gzip import ObjectString, ReplayString
@@ -72,7 +73,7 @@ class FieldLoaderMixin(PlistLoaderMixin, metaclass=FieldMetaclass):
 
     practice_mode_best: int = DictField(key="k20", default=0)
 
-    list_type: enums.LevelType = DictField(
+    level_type: enums.LevelType = DictField(
         key="k21",
         decoder=enums.LevelType,
         default=enums.LevelType.LOCAL,
@@ -304,6 +305,229 @@ class FieldLoaderMixin(PlistLoaderMixin, metaclass=FieldMetaclass):
     editor_build_tab_pages: dict = DictField(key="kI6", default_factory=dict, is_node=True)
 
     editor_layer: int = DictField(key="kI7", default=0)
+    
+    @property
+    def start(self) -> Object:
+        objstr = self.object_string
+
+        if not hasattr(objstr, "start"):
+            objstr.load()
+
+        return getattr(objstr, "start")
+
+    @start.setter
+    def start(self, value: Object):
+        objstr = self.object_string
+
+        if not hasattr(objstr, "start"):
+            objstr.load()
+
+        setattr(objstr, "start", value)
+
+    @property
+    def objects(self) -> ObjectList:
+        objstr = self.object_string
+
+        if not hasattr(objstr, "objects"):
+            objstr.load()
+
+        return getattr(objstr, "objects")
+
+    @objects.setter
+    def objects(self, value: ObjectList):
+        objstr = self.object_string
+
+        if not hasattr(objstr, "objects"):
+            objstr.load()
+
+        setattr(objstr, "objects", value)
+    
+    @property
+    def difficulty(self) -> enums.LevelDifficulty:
+        """
+        Gets the difficulty rating of a level.
+
+        Returns
+        -------
+        enums.LevelDifficulty
+            An enum specifying the level's difficulty.
+        """
+        if self.rating == 0:
+            return enums.LevelDifficulty.NA
+
+        match self.rating_sum:
+            case enums.LevelRating.NONE:
+                return enums.LevelDifficulty.NA
+            case enums.LevelRating.EASY:
+                if self.is_auto:
+                    return enums.LevelDifficulty.AUTO
+                else:
+                    return enums.LevelDifficulty.EASY
+            case enums.LevelRating.NORMAL:
+                return enums.LevelDifficulty.NORMAL
+            case enums.LevelRating.HARD:
+                return enums.LevelDifficulty.HARD
+
+            case enums.LevelRating.HARDER:
+                return enums.LevelDifficulty.HARDER
+
+            case enums.LevelRating.INSANE:
+                if self.is_demon:
+
+                    match self.demon_type:
+
+                        case enums.DemonRating.EASY:
+                            return enums.LevelDifficulty.EASY_DEMON
+
+                        case enums.DemonRating.MEDIUM:
+                            return enums.LevelDifficulty.MEDIUM_DEMON
+
+                        case enums.DemonRating.HARD:
+                            return enums.LevelDifficulty.HARD_DEMON
+
+                        case enums.DemonRating.INSANE:
+                            return enums.LevelDifficulty.INSANE_DEMON
+
+                        case enums.DemonRating.EXTREME:
+                            return enums.LevelDifficulty.EXTREME_DEMON
+
+                        case _:
+                            return enums.LevelDifficulty.HARD_DEMON
+                else:
+                    return enums.LevelDifficulty.INSANE
+
+            case _:
+                return enums.LevelDifficulty.NA
+    
+    @difficulty.setter
+    def difficulty(self, value: enums.LevelDifficulty):
+        del self.is_auto
+        del self.is_demon
+        self.rating = 10
+        
+        match value:
+            case enums.LevelDifficulty.NA:
+                del self.rating
+                self.rating_sum = enums.LevelRating.NONE
+                
+            case enums.LevelDifficulty.AUTO:
+                self.rating_sum = enums.LevelRating.EASY
+                self.is_auto = True
+                
+            case enums.LevelDifficulty.EASY:
+                self.rating_sum = enums.LevelRating.EASY
+                
+            case enums.LevelDifficulty.NORMAL:
+                self.rating_sum = enums.LevelRating.NORMAL
+                
+            case enums.LevelDifficulty.HARD:
+                self.rating_sum = enums.LevelRating.HARD
+                
+            case enums.LevelDifficulty.HARDER:
+                self.rating_sum = enums.LevelRating.HARDER
+                
+            case enums.LevelDifficulty.INSANE:
+                self.rating_sum = enums.LevelRating.INSANE
+                
+            case (
+                enums.LevelDifficulty.EASY_DEMON
+                | enums.LevelDifficulty.MEDIUM_DEMON
+                | enums.LevelDifficulty.HARD_DEMON
+                | enums.LevelDifficulty.INSANE_DEMON
+                | enums.LevelDifficulty.EXTREME_DEMON
+            ):
+                self.rating_sum = enums.LevelRating.INSANE
+                self.is_demon = True
+                
+                match value:
+                    case enums.LevelDifficulty.EASY_DEMON: 
+                        self.demon_type = enums.DemonRating.EASY,
+                    case enums.LevelDifficulty.MEDIUM_DEMON: 
+                        self.demon_type = enums.DemonRating.MEDIUM,
+                    case enums.LevelDifficulty.HARD_DEMON: 
+                        self.demon_type = enums.DemonRating.HARD,
+                    case enums.LevelDifficulty.INSANE_DEMON: 
+                        self.demon_type = enums.DemonRating.INSANE,
+                    case enums.LevelDifficulty.EXTREME_DEMON: 
+                        self.demon_type = enums.DemonRating.EXTREME,
+                        
+            case _:
+                raise ValueError(f"Unsupported level difficulty: {value!r}")
+
+    @property
+    def feature_rating(self) -> enums.FeatureRating:
+        match self.epic_rating:
+
+            case enums.EpicRating.EPIC:
+                return enums.FeatureRating.EPIC
+
+            case enums.EpicRating.LEGENDARY:
+                return enums.FeatureRating.LEGENDARY
+
+            case enums.EpicRating.MYTHIC:
+                return enums.FeatureRating.MYTHIC
+
+            case _:
+                if self.feature_score:
+                    return enums.FeatureRating.FEATURED
+
+                elif self.stars:
+                    return enums.FeatureRating.RATED
+
+                else:
+                    return enums.FeatureRating.UNRATED
+
+    @feature_rating.setter
+    def feature_rating(self, value: enums.FeatureRating) -> None:
+        match value:
+            case enums.FeatureRating.UNRATED:
+                self.epic_rating = enums.EpicRating.NONE
+                self.feature_score = 0
+                self.stars = 0
+
+            case enums.FeatureRating.RATED:
+                self.epic_rating = enums.EpicRating.NONE
+                self.feature_score = 0
+
+            case enums.FeatureRating.FEATURED:
+                self.epic_rating = enums.EpicRating.NONE
+                self.feature_score = self.feature_score or 1
+
+            case enums.FeatureRating.EPIC:
+                self.epic_rating = enums.EpicRating.EPIC
+
+            case enums.FeatureRating.LEGENDARY:
+                self.epic_rating = enums.EpicRating.LEGENDARY
+
+            case enums.FeatureRating.MYTHIC:
+                self.epic_rating = enums.EpicRating.MYTHIC
+
+            case _:
+                raise ValueError(f"Unsupported feature rating: {value!r}")
+
+    @property
+    def timely_type(self) -> enums.TimelyType:
+        """
+        Gets the timely (daily, weekly, event) type of a level.
+            
+        Returns
+        -------
+        enums.TimelyType
+            An enum specifying the level's timely type.
+        """
+        tid = self.timely_id
+        
+        if tid is None:
+            return enums.TimelyType.NONE
+        elif (0<tid<=10000):
+            return enums.TimelyType.DAILY
+        elif (10000<tid<=20000):
+            return enums.TimelyType.WEEKLY
+        elif (20000<tid<=30000):
+            return enums.TimelyType.EVENT
+        else:
+            return enums.TimelyType.NONE
+    
 
 FieldLoaderMixin.add_field(key="k24") # dislikes, unused
 FieldLoaderMixin.add_field(key="k106") # unknown

{gmdkit-0.7.0 → gmdkit-0.7.1}/src/gmdkit/extensions/globed.py

@@ -6,8 +6,8 @@ from os import PathLike
 
 # Package Imports
 from gmdkit.models.object import Object, ObjectList
-from gmdkit.mappings import obj_prop, obj_id
-
+from gmdkit.models import interfaces
+from gmdkit.utils import enums
 
 MAGIC = b'\xc4\x19\x7b\xfa'
 PREFIX = "GLOBED_SCRIPT"
@@ -147,7 +147,7 @@ class GlobedScript:
             tail:bytes|None=None
             ):
         
-        self.object = text_object or Object.default(obj_id.TEXT)
+        self.object = text_object or Object.default(enums.ObjectID.OBJECT_TEXT)
         self.prefix = prefix
         self.main = main
         self.filename = filename
@@ -163,7 +163,8 @@ class GlobedScript:
         
     def load(self):
         try:
-            string = self.object[obj_prop.text.DATA]
+            intf = self.object.require_interface(interfaces.Text)
+            string = intf.data
             string_bytes = string.encode("utf-8", errors="surrogateescape")              
             pre, main, fn, content, sig, tail = decode_script(string_bytes)
             self.prefix = pre
@@ -189,7 +190,8 @@ class GlobedScript:
                 )
             
             string = string_bytes.decode("utf-8", errors="surrogateescape")
-            self.object[obj_prop.text.DATA] = string
+            intf = self.object.require_interface(interfaces.Text)
+            intf.data = string
             
         except Exception as e:
             raise RuntimeError(f"Error while saving script data to object: {e}") from e
@@ -225,11 +227,12 @@ class GlobedScript:
         result = []
         
         for obj in obj_list:
+            intf = obj.require_interface(interfaces.Text, fallback=None)
             
-            if obj_id.TEXT != obj.get(obj_prop.ID):
+            if intf is None:
                 continue
             
-            string = obj.get(obj_prop.text.DATA)
+            string = intf.data
             
             if string is None:
                 continue

gmdkit-0.7.1/src/gmdkit/functions/color.py

@@ -0,0 +1,113 @@
+# Package Imports
+from gmdkit.models.level import Level
+from gmdkit.models.object import ObjectList
+from gmdkit.models.prop.color import Color, ColorList
+from gmdkit import remapping
+from gmdkit.models import interfaces
+
+RGBA = tuple[int,int,int,float]
+
+def color_fade(color_1:Color, color_2:Color, percent:float) -> RGBA:
+    """
+    Calculates an intermediary color between two colors.
+
+    Parameters
+    ----------
+    color_1 : Color
+        The original color.
+    color_2 : Color
+        The new color.
+    percent : float
+        How much of the new color will be mixed in with the original one.
+
+    Returns
+    -------
+    RGBA
+        DESCRIPTION.
+
+    """
+    r1, g1, b1, a1 = color_1.get_rgba()
+    r2, g2, b2, a2 = color_2.get_rgba()
+
+    r = round(r1 + (r2 - r1) * percent)
+    g = round(g1 + (g2 - g1) * percent)
+    b = round(b1 + (b2 - b1) * percent)
+    a = a1 + (a2 - a1) * percent
+
+    return (r,g,b,a)
+
+
+def create_color_triggers(
+        color_list:ColorList,
+        ignore_default:bool=True,
+        ignore_ids:None=None,
+        pos_x:float=0,
+        pos_y:float=0
+        ) -> ObjectList:
+    """
+    Converts a list of colors into color triggers.
+
+    Parameters
+    ----------
+    color_list :
+        A list to retrieve colors from.
+    offset_x : float, optional
+        Horizontal offset between triggers. The default is 0.
+    offset_y : float, optional
+        Vertical offset between triggers. The default is -30.
+
+    Returns
+    -------
+    ObjectListx
+        An ObjectList containing the generated color triggers.
+    """
+    obj_list = ObjectList()
+
+    y = pos_y
+    x = pos_x
+
+    for color in color_list:
+
+        if ignore_ids is not None and color.channel in ignore_ids:
+            continue
+
+        if ignore_default and color.is_default():
+            continue
+        
+        intf = interfaces.ColorTrigger.from_color(color)
+        intf.x = x
+        intf.y = y
+        y += -30
+        obj_list.append(intf.obj)
+
+    return obj_list
+
+
+def create_lvl_color_triggers(
+        lvl:Level,
+        ignore_default:bool=True,
+        pos_x:float=0,
+        pos_y:float=0
+        ) -> ObjectList:
+    intf = lvl.start.require_interface(interfaces.LevelSettings)
+    lvl.objects += create_color_triggers(intf.colors,ignore_default,pos_x,pos_y)
+
+
+def set_used_colors(lvl:Level):
+    used = remapping.rules.COLOR_ID_HANDLER.compile_ids(lvl).filter_values(reference=True).get_ids()
+    intf = lvl.start.require_interface(interfaces.LevelSettings)
+    intf.colors.set_defaults(*used)
+
+
+def free_unused_colors(lvl:Level, ignore_ids:dict):
+    ignore_ids = ignore_ids or {}
+
+    rules = remapping.rules.BASE_ID_HANDLER.compile_rules(id_types=(remapping.IDType.COLOR_ID,))
+
+    ids = rules.compile_ids(lvl.objects, by_type=False).filter_values(fixed=False)
+    id_base = ids.filter_values(reference=False).get_ids()
+    id_ref = ids.filter_values(reference=True).get_ids()
+    unused = id_base - id_ref - ignore_ids
+    
+    intf = lvl.start.require_interface(interfaces.LevelSettings)
+    intf.colors.exclude(lambda color: color.channel in unused)