port ott stuff

eventually i should make this a submodule

Author: drewc5131

.gitignore

@@ -136,3 +136,4 @@ phase_*/
 build.py
 *.bat
 ttle_dist.py
+leveleditor/settings.json

toontown/leveleditor/OTTUtil.py ott/OTTUtil.pytoontown/leveleditor/OTTUtil.py renamed to ott/OTTUtil.py

@@ -1,13 +1,16 @@
-'''
+"""
 Helpers and such for Open Toontown Tools
-'''
+"""
+from direct.task.TaskManagerGlobal import taskMgr
 
 
-def sleep(duration):
-    '''
+def sleep(duration: float):
+    """
     Breaks for a number of seconds. Returns an awaitable.
     @LittleToonCat
-    '''
+
+    :param duration: Duration of sleep
+    """
 
     def __task(task):
         if task.time > duration:

ott/Settings.py

@@ -0,0 +1,87 @@
+"""
+OpenTTTools Settings
+Slight override of a typical dict to make the file auto save when a change is made
+"""
+
+import collections
+import json
+import os
+
+
+class Settings(collections.MutableMapping):
+
+    def __init__(self, filename: str):
+        """
+        :param filename: File path to json file
+        """
+        self.filename = filename
+
+        self.data = {}
+
+        # Make sure the file exists
+        if os.path.exists(self.filename):
+            try:
+                with open(self.filename, 'r') as f:
+                    self.data = json.load(f)
+            except:
+                # Something went wrong with the file, probable corruption, make a new one
+                self.save()
+        # If not, create it
+        else:
+            self.save()
+
+    def save(self):
+        """
+        Write settings changes to the json file
+        """
+        with open(self.filename, 'w') as jsonFile:
+            json.dump(self.data, jsonFile, indent = 4)
+            print('Saved settings')
+
+    ''' Overrides '''
+
+    def __getitem__(self, key: str):
+        """
+        x = settings['setting'] override
+
+        :param key: Setting Key
+        :return: Setting value
+        """
+        return self.data[key]
+
+    def __setitem__(self, key: str, value: str):
+        """
+        settings['setting'] = 'value' override
+
+        :param key: Setting Key
+        :param value: The value to set the setting to
+        """
+        self.data[key] = value
+        # Save the file
+        self.save()
+
+    def __delitem__(self, key: str):
+        """
+        del settings['setting'] override
+
+        :param key: Setting Key to remove
+        """
+        del self.data[key]
+        # Save the file
+        self.save()
+
+    def __iter__(self):
+        """
+        iteration override (e.g. for x in settings)
+
+        :return: Iterable of settings
+        """
+        return iter(self.data)
+
+    def __len__(self) -> int:
+        """
+        len(settings) Override
+
+        :return: Number of settings as integer
+        """
+        return len(self.data)

ott/ShaderRegistry.py

@@ -0,0 +1,67 @@
+"""
+    Shader Registry - drewcification 111420
+    Static class to register and get shaders
+
+    Shaders are registered at the games initialization
+        from ott.ShaderRegistry import ShaderRegistry
+        ShaderRegistry.register('render:black_and_white',
+                                frag = 'phase_3/shaders/tt_sha_render_bandw.frag',
+                                vert = 'phase_3/shaders/tt_sha_render_bandw.vert')
+
+    They can be retrieved at any point during runtime
+        from ott.ShaderRegistry import ShaderRegistry
+        render.setShader(ShaderRegistry.get('render:black_and_white'))
+"""
+
+from panda3d.core import Shader
+
+
+class ShaderRegistry:
+    # Static shader dictionary
+    shaders = {}
+
+    @staticmethod
+    def register(identifier: str, frag: str, vert: str):
+        """
+        Register shader
+
+        All shaders must be in GLSL with separate .frag and .vert files!
+
+        Shader identifiers should be formatted by where they are used
+
+        e.g.:
+            Full scene render effects are prefixed with 'render:'
+            CheesyEffects are prefixed with  'ce:'
+            Make-A-Toon shaders are prefixed with 'mat:'
+            etc.
+
+        :param identifier: Identifier string
+        :param frag: Fragment shader file path
+        :param vert: Vertex shader file path
+        """
+        shader = Shader.load(Shader.SL_GLSL, fragment = frag, vertex = vert)
+        ShaderRegistry.shaders[identifier] = shader
+        print(f'Registered shader {identifier}')
+
+    @staticmethod
+    def get(identifier: str) -> Shader:
+        """
+        Returns loaded shader
+
+        :param identifier:
+        :return: Shader
+        """
+
+        # Raise an exception if we load a shader we haven't registered yet
+        if identifier not in ShaderRegistry.shaders:
+            raise NotInRegistryError(identifier)
+
+        return ShaderRegistry.shaders.get(identifier)
+
+
+class NotInRegistryError(Exception):
+    def __init__(self, identifier: str):
+        self.identifier = identifier
+
+    def __str__(self):
+        return f'identifier {self.identifier} not in registry'

ott/__init__.py

@@ -0,0 +1 @@
+""" Universal classes for all OTT Projects """

toontown/leveleditor/LevelEditorGlobals.py

@@ -191,14 +191,16 @@
             DNA_WALL,
             DNA_WINDOWS]
 
-DNA_PROP_SETS = {'tree': ["prop_tree_small_ul",
-                      "prop_tree_small_ur",
-                      "prop_tree_large_ur",
-                      "prop_tree_large_ul"],
+DNA_PROP_SETS = {'tree':      ["prop_tree_small_ul",
+                               "prop_tree_small_ur",
+                               "prop_tree_large_ur",
+                               "prop_tree_large_ul"],
                  'snow_tree': ["prop_snow_tree_small_ul",
-                                       "prop_snow_tree_small_ur",
-                                       "prop_snow_tree_large_ur",
-                                       "prop_snow_tree_large_ul"]}
+                               "prop_snow_tree_small_ur",
+                               "prop_snow_tree_large_ur",
+                               "prop_snow_tree_large_ul"]
+                 }
+
 CONTROLS = '''
 --Camera--
 Note: All camera transformations orbit the currently selected object

ttle.py

@@ -1,19 +1,19 @@
 """ OpenLevelEditor Base Class - Drewcification 091420 """
 
+import argparse
+import asyncio
+import builtins
+import os
+import pathlib
+import sys
 from direct.directnotify.DirectNotifyGlobal import directNotify
-from direct.showbase.ShowBase import ShowBase
 from direct.gui.OnscreenText import OnscreenText
-
+from direct.showbase.ShowBase import ShowBase
 from panda3d.core import loadPrcFile, loadPrcFileData
-
 from tkinter import Tk, messagebox
-from toontown.toonbase import ToontownGlobals
 
-import asyncio
-import argparse
-import builtins
-import os
-import sys
+from ott.Settings import Settings
+from toontown.toonbase import ToontownGlobals
 
 TOONTOWN_ONLINE = 0
 TOONTOWN_REWRITTEN = 1
@@ -28,6 +28,12 @@
 
 DEFAULT_SERVER = TOONTOWN_ONLINE
 
+DEFAULT_SETTINGS = {
+    'autosave-enabled':   True,
+    'autosave-interval':  15,
+    'autosave-max-files': 10,
+    'fps-meter-update-rate': 0
+    }
 
 class ToontownLevelEditor(ShowBase):
     notify = directNotify.newCategory("Open Level Editor")
@@ -44,18 +50,24 @@ def __init__(self):
         if not os.path.exists(userfiles):
             pathlib.Path(userfiles).mkdir(parents = True, exist_ok = True)
 
+        builtins.settings = Settings(f'{userfiles}/settings.json')
+
+        for setting in DEFAULT_SETTINGS:
+            if setting not in settings:
+                settings[setting] = DEFAULT_SETTINGS[setting]
+
         # Check for -e or -d launch options
         parser = argparse.ArgumentParser(description = "Modes")
         parser.add_argument("--experimental", action = 'store_true', help = "Enables experimental features")
         parser.add_argument("--debug", action = 'store_true', help = "Enables debugging features")
         parser.add_argument("--noupdate", action = 'store_true', help = "Disables Auto Updating")
-        parser.add_argument("--png", action = 'store_true', help = "Forces PNG resources mode, if this is not specified, "
-                                                                   "it will automatically determine the format")
+        parser.add_argument("--png", action = 'store_true', help = "Forces PNG resources mode, if this is not "
+                                                                   "specified, it will automatically determine the "
+                                                                   "format")
         parser.add_argument("--compiler", nargs = "*",
                             help = "Specify which compiler to use (Only useful if your game uses a form of "
                                    "libpandadna.) Valid options are 'libpandadna', for games which use the "
-                                   "modern c++ version of libpandadna, and 'clash', "
-                                   "for Corporate Clash")
+                                   "modern c++ version of libpandadna, and 'clash', for Corporate Clash")
 
         parser.add_argument("--server", nargs = "*", help = "Enables features exclusive to various Toontown projects",
                             default = 'online')
@@ -151,21 +163,21 @@ def updateFrameRateMeter(self, task):
         """
         fps = globalClock.getAverageFrameRate()
 
-        # Color is green by default
-        color = (0, 0.9, 0, 1)
-
-        # At or below 45 fps is yellow
         if fps <= 45:
+            # At or below 45 fps is yellow
             color = (1, 0.9, 0, 1)
-        # At or below 30 fps is red
         elif fps <= 30:
+            # At or below 30 fps is red
             color = (1, 0, 0, 1)
+        else:
+            # Color is green by default
+            color = (0, 0.9, 0, 1)
 
         text = f'{round(fps, 1)} FPS'
         self.frameRateMeter.setText(text)
         self.frameRateMeter.setFg(color)
-
-        return task.cont
+        task.delayTime = settings['fps-meter-update-rate']/1000
+        return task.again
 
     def __checkForFiles(self):
         # Make custom hood directory if it doesn't exist
@@ -194,7 +206,8 @@ def __createTk(self):
 
         self.tkRoot = tkroot
 
-    def __addCullBins(self):
+    @staticmethod
+    def __addCullBins():
         cbm = CullBinManager.getGlobalPtr()
         cbm.addBin('ground', CullBinManager.BTUnsorted, 18)
         cbm.addBin('shadow', CullBinManager.BTBackToFront, 19)