1 files changed, 116 insertions, 15 deletions

diff --git a/NeoRuntime/Runtime/luxcena_neo/neo_behaviour.py b/NeoRuntime/Runtime/luxcena_neo/neo_behaviour.py
index 9920ca4..66678c4 100644
--- a/NeoRuntime/Runtime/luxcena_neo/neo_behaviour.py
+++ b/NeoRuntime/Runtime/luxcena_neo/neo_behaviour.py
@@ -1,6 +1,8 @@
 import json
 from os import path
 from enum import Enum
+from .strip import detect_format_convert_color
+from .color_utils import rgb_from_24bit, hex_from_24bit
 
 class NeoBehaviour:
     """
@@ -14,7 +16,11 @@ class NeoBehaviour:
         THIS METHOD SHOULD NOT BE OVERIDDEN! Use onStart if you want a setup-method!!!
         Contains basic setup 
         """
-        self.vars = Variables(package_path)
+        self.var = Variables(package_path)
+
+        self.declare = self.var.declare
+        self.declare_variables()
+        del self.declare
 
     def declare_variables(self):
         """ This should be overridden, and ALL variables should be declared here. """
@@ -47,14 +53,14 @@ class NeoBehaviour:
 class VariableType(Enum):
     TEXT = 1
     INT = 2
-    RANGE = 3
+    FLOAT = 3
     COLOR = 4
 
 class Variables:
 
     def __init__(self, package_path):
         self.__vars = {}
-        self.__vars_save_file = f"{package_path}/variables.json"
+        self.__vars_save_file = f"{package_path}/state.json"
         self.__saved_variables = {}
         self.read_saved_variables()
     
@@ -66,8 +72,6 @@ class Variables:
     def __setattr__(self, name, value):
         if name in ["_Variables__vars", "_Variables__vars_save_file", "_Variables__saved_variables"]:
             super(Variables, self).__setattr__(name, value)
-        elif type(value) == Variable:
-            self.__vars[name] = value
         else:
             self.__vars[name].value = value
     
@@ -101,12 +105,15 @@ class Variables:
     def __iter__(self):
         return iter(self.__vars.items())
 
-    def declare(self, name: str, default: any, var_type: VariableType, on_change = None, **kwargs):
+    def declare(self, variable):
         """ Declare a new variable. """
-        if name in self.__saved_variables:
-            default = self.__saved_variables[name]
-        var = Variable(self.save_variables, name, default, var_type, on_change, **kwargs)
-        self.__setattr__(name, var)
+        if variable.name in self.__vars:
+            raise Exception(f"Variable with name {variable.name} already defined.")
+        if variable.name in self.__saved_variables:
+            variable.value = self.__saved_variables[variable.name]
+
+        variable.set_save_func(self.save_variables)
+        self.__vars[variable.name] = variable
     
     def read_saved_variables(self):
         """ Read saved variable values from file. """
@@ -123,17 +130,20 @@ class Variables:
         with open(self.__vars_save_file, "w") as f:
             f.write(json.dumps(self.__saved_variables))
 
+    def to_dict(self):
+        return {x.name: x.to_dict() for x in self.__vars.values()}
+
 class Variable:
 
-    def __init__(self, save_func, key, default, var_type, on_change):
-        self.__save_func = save_func
-        self.__key = key
+    def __init__(self, name, default, var_type: VariableType, on_change = None):
+        self.__name = name
         self.__value = default
         self.__var_type = var_type
         self.__on_change = on_change
+        self.__save_func = None
     
     @property
-    def key(self): return self.__key
+    def name(self): return self.__name
 
     @property
     def value(self): return self.__value
@@ -141,9 +151,100 @@ class Variable:
     @value.setter
     def value(self, value):
         self.__value = value
-        self.__save_func()
+        if self.__save_func is not None:
+            self.__save_func()
         if self.__on_change is not None:
             self.__on_change(self.value)
     
     @property
     def var_type(self): return self.__var_type.name
+
+    def to_dict(self):
+        return {"name": self.name, "value": self.value, "type": self.var_type}
+    
+    def __str__(self):
+        return f"{self.name}: {self.value}"
+
+    def set_save_func(self, save_func):
+        self.__save_func = save_func
+
+class ColorVariable(Variable):
+
+    def __init__(self, name: str, *color, **kwargs):
+        if not self.verify_color(*color):
+            raise Exception(f"Invalid color {color}")
+        super().__init__(name, self.extract_interesting(*color), VariableType.COLOR, **kwargs)
+    
+    @Variable.value.setter
+    def value(self, *color):
+        if not self.verify_color(*color):
+            print(f"Attempting to set {self.name} to invalid value {color}")
+            return
+        super(ColorVariable, type(self)).value.fset(self, self.extract_interesting(*color))
+
+    def verify_color(self, *color):
+        if (len(color) == 1) and (isinstance(color[0], str)):
+            return True
+        if (len(color) == 1) and (isinstance(color[0], tuple)):
+            if len(color[0]) != 3: return False
+            for c in color[0]:
+                if not (0 <= c <= 255): return False
+            return True
+        if (len(color) == 1) and (isinstance(color[0], int)):
+            return True
+        if (len(color) == 3):
+            for c in color:
+                if not isinstance(c, int): return False
+                if not (0 <= c <= 255): return False
+                return True
+        return False
+    
+    def extract_interesting(self, *color):
+        if (len(color) == 1): return color[0]
+        return color
+
+class IntegerVariable(Variable):
+
+    def __init__(self, name: str, default: int = 0, min_val: int = 0, max_val: int = 255, **kwargs):
+        self.__min = min_val
+        self.__max = max_val
+        super().__init__(name, default, VariableType.INT)
+    
+    @Variable.value.setter
+    def value(self, value):
+        try:
+            value = int(value)
+            if (self.__min <= value <= self.__max):
+                super(ColorVariable, type(self)).value.fset(self, value)
+            else:
+                print(f"Attempted to set {self.name} to {value} but range is [{self.__min},{self.__max}].")
+        except ValueError:
+            print(f"Attempted to set {self.name} to \"{value}\", which is not a valid integer...")
+
+    def to_dict(self):
+        return {"name": self.name, "value": self.value, "type": self.var_type, "min": self.__min, "max": self.__max}
+
+
+class FloatVariable(Variable):
+
+    def __init__(self, name: str, default: float = 0.0, min_val: float = 0.0, max_val: float = 255.0, **kwargs):
+        self.__min = min_val
+        self.__max = max_val
+        super().__init__(name, default, VariableType.FLOAT)
+    
+    @Variable.value.setter
+    def value(self, value):
+        try:
+            value = float(value)
+            if (self.__min <= value <= self.__max):
+                super(ColorVariable, type(self)).value.fset(self, value)
+            else:
+                print(f"Attempted to set {self.name} to {value} but range is [{self.__min},{self.__max}].")
+        except ValueError:
+            print(f"Attempted to set {self.name} to \"{value}\", which is not a valid float...")
+    
+    def __str__(self):
+        return round(self.value, 2)
+
+    def to_dict(self):
+        return {"name": self.name, "value": self.value, "type": self.var_type, "min": self.__min, "max": self.__max}