From 15e966a9c50662b3688c76276c48650dedf5683e Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Fri, 14 Jan 2022 23:05:09 -0800
Subject: [PATCH 01/10] added "mult" to all three example traits

---
 evennia/contrib/rpg/traits/traits.py | 44 +++++++++++++++++++++++-----
 1 file changed, 37 insertions(+), 7 deletions(-)

diff --git a/evennia/contrib/rpg/traits/traits.py b/evennia/contrib/rpg/traits/traits.py
index f178c68e80..884da45e5b 100644
--- a/evennia/contrib/rpg/traits/traits.py
+++ b/evennia/contrib/rpg/traits/traits.py
@@ -1151,7 +1151,7 @@ class StaticTrait(Trait):
 
     trait_type = "static"
 
-    default_keys = {"base": 0, "mod": 0}
+    default_keys = {"base": 0, "mod": 0, "mult": 1.0}
 
     def __str__(self):
         status = "{value:11}".format(value=self.value)
@@ -1179,10 +1179,20 @@ class StaticTrait(Trait):
         if type(amount) in (int, float):
             self._data["mod"] = amount
 
+    @property
+    def mult(self):
+        """The trait's multiplier."""
+        return self._data["mult"]
+    
+    @mult.setter
+    def mult(self, amount):
+        if type(amount) in (int, float):
+            self._data["mult"] = amount
+
     @property
     def value(self):
-        "The value of the Trait"
-        return self.base + self.mod
+        "The value of the Trait."
+        return (self.base + self.mod) * self.mult
 
 
 class CounterTrait(Trait):
@@ -1225,6 +1235,7 @@ class CounterTrait(Trait):
     default_keys = {
         "base": 0,
         "mod": 0,
+        "mult": 1.0,
         "min": None,
         "max": None,
         "descs": None,
@@ -1353,6 +1364,15 @@ class CounterTrait(Trait):
                 value = self.max - self.base
             self._data["mod"] = value
 
+    @property
+    def mult(self):
+        return self._data["mult"]
+    
+    @mult.setter
+    def mult(self, amount):
+        if type(amount) in (int, float):
+            self._data["mult"] = amount
+
     @property
     def min(self):
         return self._data["min"]
@@ -1398,8 +1418,8 @@ class CounterTrait(Trait):
 
     @property
     def value(self):
-        "The value of the Trait (current + mod)"
-        return self._enforce_boundaries(self.current + self.mod)
+        "The value of the Trait. (current + mod) * mult"
+        return self._enforce_boundaries( (self.current + self.mod) * self.mult)
 
     @property
     def ratetarget(self):
@@ -1494,6 +1514,7 @@ class GaugeTrait(CounterTrait):
     default_keys = {
         "base": 0,
         "mod": 0,
+        "mult": 1.0,
         "min": 0,
         "descs": None,
         "rate": 0,
@@ -1560,6 +1581,15 @@ class GaugeTrait(CounterTrait):
             if value + self.base < self.min:
                 value = self.min - self.base
             self._data["mod"] = value
+    
+    @property
+    def mult(self):
+        return self._data["mult"]
+    
+    @mult.setter
+    def mult(self, amount):
+        if type(amount) in (int, float):
+            self._data["mult"] = amount
 
     @property
     def min(self):
@@ -1576,8 +1606,8 @@ class GaugeTrait(CounterTrait):
 
     @property
     def max(self):
-        "The max is always base + mod."
-        return self.base + self.mod
+        "The max is always (base + mod) * mult."
+        return (self.base + self.mod) * self.mult
 
     @max.setter
     def max(self, value):

From b355008295fff1df5109a304e0f6d4364a4483ae Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Wed, 19 Jan 2022 12:52:15 -0800
Subject: [PATCH 02/10] edited docstrings to reflect multiplier addition. added
 mult to validation and string methods

---
 evennia/contrib/rpg/traits/traits.py | 106 ++++++++++++++-------------
 1 file changed, 56 insertions(+), 50 deletions(-)

diff --git a/evennia/contrib/rpg/traits/traits.py b/evennia/contrib/rpg/traits/traits.py
index 884da45e5b..da1e5b5e9d 100644
--- a/evennia/contrib/rpg/traits/traits.py
+++ b/evennia/contrib/rpg/traits/traits.py
@@ -45,7 +45,7 @@ class Character(DefaultCharacter):
 
     def at_object_creation(self):
         # (or wherever you want)
-        self.traits.add("str", "Strength", trait_type="static", base=10, mod=2)
+        self.traits.add("str", "Strength", trait_type="static", base=10, mod=2, mult=2.0)
         self.traits.add("hp", "Health", trait_type="gauge", min=0, max=100)
         self.traits.add("hunting", "Hunting Skill", trait_type="counter",
                         base=10, mod=1, min=0, max=100)
@@ -74,9 +74,9 @@ from evennia.contrib.rpg.traits import TraitProperty
 
 class Object(DefaultObject):
     ...
-    strength = TraitProperty("Strength", trait_type="static", base=10, mod=2)
+    strength = TraitProperty("Strength", trait_type="static", base=10, mod=2, mult=1.5)
     health = TraitProperty("Health", trait_type="gauge", min=0, base=100, mod=2)
-    hunting = TraitProperty("Hunting Skill", trait_type="counter", base=10, mod=1, min=0, max=100)
+    hunting = TraitProperty("Hunting Skill", trait_type="counter", base=10, mod=1, mult=2.0, min=0, max=100)
 
 ```
 
@@ -102,14 +102,14 @@ each other depends on the trait type.
 
 ```python
 > obj.traits.strength.value
-12                                  # base + mod
+18                                  # (base + mod) * mult
 
-> obj.traits.strength.base += 5
+> obj.traits.strength.base += 6
 obj.traits.strength.value
-17
+27
 
 > obj.traits.hp.value
-102                                 # base + mod
+102                                 # (base + mod) * mult
 
 > obj.traits.hp.base -= 200
 > obj.traits.hp.value
@@ -131,11 +131,11 @@ obj.traits.strength.value
 # with TraitProperties:
 
 > obj.hunting.value
-12
+22
 
 > obj.strength.value += 5
 > obj.strength.value
-17
+32
 
 ```
 
@@ -171,25 +171,26 @@ if trait1 > trait2:
 ```
 ## Static trait
 
-`value = base + mod`
+`value = (base + mod) * mult`
 
-The static trait has a `base` value and an optional `mod`-ifier. A typical use
+The static trait has a `base` value and an optional `mod`-ifier and 'mult'-iplier. A typical use
 of a static trait would be a Strength stat or Skill value. That is, something
 that varies slowly or not at all, and which may be modified in-place.
 
 ```python
 > obj.traits.add("str", "Strength", trait_type="static", base=10, mod=2)
 > obj.traits.mytrait.value
-
 12   # base + mod
+
 > obj.traits.mytrait.base += 2
 > obj.traits.mytrait.mod += 1
 > obj.traits.mytrait.value
 15
 
 > obj.traits.mytrait.mod = 0
+> obj.traits.mytrait.mult = 2.0
 > obj.traits.mytrait.value
-12
+20
 
 ```
 
@@ -201,16 +202,17 @@ that varies slowly or not at all, and which may be modified in-place.
                                   current    value
                                              = current
                                              + mod
+                                             * mult
 
 A counter describes a value that can move from a base. The `.current` property
 is the thing usually modified. It starts at the `.base`. One can also add a
-modifier, which will both be added to the base and to current (forming
-`.value`).  The min/max of the range are optional, a boundary set to None will
-remove it. A suggested use for a Counter Trait would be to track skill values.
+modifier, which is added to both the base and to current. '.value' is then formed 
+by multiplying by the multiplier. The min/max of the range are optional, a boundary 
+set to None will remove it. A suggested use for a Counter Trait would be to track skill values.
 
 ```python
 > obj.traits.add("hunting", "Hunting Skill", trait_type="counter",
-                   base=10, mod=1, min=0, max=100)
+                   base=10, mod=1, mult=1.0, min=0, max=100)
 > obj.traits.hunting.value
 11  # current starts at base + mod
 
@@ -222,7 +224,10 @@ remove it. A suggested use for a Counter Trait would be to track skill values.
 > del obj.traits.hunting.current
 > obj.traits.hunting.value
 11
+
 > obj.traits.hunting.max = None  # removing upper bound
+> obj.traits.hunting.mult = 100.0
+1100
 
 # for TraitProperties, pass the args/kwargs of traits.add() to the
 # TraitProperty constructor instead.
@@ -1142,10 +1147,10 @@ class Trait:
 
 class StaticTrait(Trait):
     """
-    Static Trait. This is a single value with a modifier,
-    with no concept of a 'current' value or min/max etc.
+    Static Trait. This is a single value with a modifier, 
+    multiplier, and no concept of a 'current' value or min/max etc.
 
-    value = base + mod
+    value = (base + mod) * mult
 
     """
 
@@ -1155,7 +1160,7 @@ class StaticTrait(Trait):
 
     def __str__(self):
         status = "{value:11}".format(value=self.value)
-        return "{name:12} {status} ({mod:+3})".format(name=self.name, status=status, mod=self.mod)
+        return "{name:12} {status} ({mod:+3}) (* {mult:.2f})".format(name=self.name, status=status, mod=self.mod, mult=self.mult)
 
     # Helpers
     @property
@@ -1207,8 +1212,9 @@ class CounterTrait(Trait):
                                     current   value
                                               = current
                                               + mod
+                                              * mult
 
-    - value = current + mod, starts at base + mod
+    - value = (current + mod) * mult, starts at base + mod
     - if min or max is None, there is no upper/lower bound (default)
     - if max is set to "base", max will be equal ot base+mod
     - descs are used to optionally describe each value interval.
@@ -1311,16 +1317,16 @@ class CounterTrait(Trait):
             now = time()
             tdiff = now - self._data["last_update"]
             current += rate * tdiff
-            value = current + self.mod
+            value = (current + self.mod) * self.mult
 
             # we must make sure so we don't overstep our bounds
             # even if .mod is included
 
             if self._passed_ratetarget(value):
-                current = self._data["ratetarget"] - self.mod
+                current = (self._data["ratetarget"] - self.mod) / self.mult
                 self._stop_timer()
             elif not self._within_boundaries(value):
-                current = self._enforce_boundaries(value) - self.mod
+                current = (self._enforce_boundaries(value) - self.mod) / self.mult
                 self._stop_timer()
             else:
                 self._data["last_update"] = now
@@ -1342,10 +1348,10 @@ class CounterTrait(Trait):
         if value is None:
             self._data["base"] = self.default_keys["base"]
         if type(value) in (int, float):
-            if self.min is not None and value + self.mod < self.min:
-                value = self.min - self.mod
-            if self.max is not None and value + self.mod > self.max:
-                value = self.max - self.mod
+            if self.min is not None and (value + self.mod) * self.mult < self.min:
+                value = (self.min - self.mod) / self.mult
+            if self.max is not None and (value + self.mod) * self.mult > self.max:
+                value = (self.max - self.mod) / self.mult
             self._data["base"] = value
 
     @property
@@ -1358,10 +1364,10 @@ class CounterTrait(Trait):
             # unsetting the boundary to default
             self._data["mod"] = self.default_keys["mod"]
         elif type(value) in (int, float):
-            if self.min is not None and value + self.base < self.min:
-                value = self.min - self.base
-            if self.max is not None and value + self.base > self.max:
-                value = self.max - self.base
+            if self.min is not None and (value + self.base) * self.mult < self.min:
+                value = (self.min - self.base) / self.mult
+            if self.max is not None and (value + self.base) * self.mult > self.max:
+                value = (self.max - self.base) / self.mult
             self._data["mod"] = value
 
     @property
@@ -1385,7 +1391,7 @@ class CounterTrait(Trait):
         elif type(value) in (int, float):
             if self.max is not None:
                 value = min(self.max, value)
-            self._data["min"] = min(value, self.base + self.mod)
+            self._data["min"] = min(value, (self.base + self.mod) * self.mult)
 
     @property
     def max(self):
@@ -1399,7 +1405,7 @@ class CounterTrait(Trait):
         elif type(value) in (int, float):
             if self.min is not None:
                 value = max(self.min, value)
-            self._data["max"] = max(value, self.base + self.mod)
+            self._data["max"] = max(value, (self.base + self.mod) * self.mult)
 
     @property
     def current(self):
@@ -1482,15 +1488,15 @@ class GaugeTrait(CounterTrait):
     """
     Gauge Trait.
 
-    This emulates a gauge-meter that empties from a base+mod value.
+    This emulates a gauge-meter that empties from a (base+mod) * mult value.
 
-    min/0                                            max=base+mod
+    min/0                                       max=(base+mod)*mult
      |-----------------------X---------------------------|
                            value
                           = current
 
     - min defaults to 0
-    - max value is always base + mad
+    - max value is always (base + mod) * mult
     - .max is an alias of .base
     - value = current and varies from min to max.
     - descs is a mapping {upper_bound_inclusive: desc}. These
@@ -1552,11 +1558,11 @@ class GaugeTrait(CounterTrait):
         """Ensures that incoming value falls within trait's range."""
         if self.min is not None and value <= self.min:
             return self.min
-        return min(self.mod + self.base, value)
+        return min((self.mod + self.base) * self.mult, value)
 
     def __str__(self):
         status = "{value:4} / {base:4}".format(value=self.value, base=self.base)
-        return "{name:12} {status} ({mod:+3})".format(name=self.name, status=status, mod=self.mod)
+        return "{name:12} {status} ({mod:+3}) (* {mult:.2f})".format(name=self.name, status=status, mod=self.mod, mult=self.mult)
 
     @property
     def base(self):
@@ -1564,10 +1570,10 @@ class GaugeTrait(CounterTrait):
 
     @base.setter
     def base(self, value):
-        """Limit so base+mod can never go below min."""
+        """Limit so (base+mod)*mult can never go below min."""
         if type(value) in (int, float):
-            if value + self.mod < self.min:
-                value = self.min - self.mod
+            if (value + self.mod) * self.mult < self.min:
+                value = (self.min - self.mod) / self.mult
             self._data["base"] = value
 
     @property
@@ -1576,10 +1582,10 @@ class GaugeTrait(CounterTrait):
 
     @mod.setter
     def mod(self, value):
-        """Limit so base+mod can never go below min."""
+        """Limit so (base+mod)*mult can never go below min."""
         if type(value) in (int, float):
-            if value + self.base < self.min:
-                value = self.min - self.base
+            if (value + self.base) * self.mult < self.min:
+                value = (self.min - self.base) / self.mult
             self._data["mod"] = value
     
     @property
@@ -1598,11 +1604,11 @@ class GaugeTrait(CounterTrait):
 
     @min.setter
     def min(self, value):
-        """Limit so min can never be greater than base+mod."""
+        """Limit so min can never be greater than (base+mod)*mult."""
         if value is None:
             self._data["min"] = self.default_keys["min"]
         elif type(value) in (int, float):
-            self._data["min"] = min(value, self.base + self.mod)
+            self._data["min"] = min(value,  (self.base + self.mod) * self.mult)
 
     @property
     def max(self):
@@ -1625,7 +1631,7 @@ class GaugeTrait(CounterTrait):
     def current(self):
         """The `current` value of the gauge."""
         return self._update_current(
-            self._enforce_boundaries(self._data.get("current", self.base + self.mod))
+            self._enforce_boundaries(self._data.get("current",  (self.base + self.mod) * self.mult))
         )
 
     @current.setter
@@ -1636,7 +1642,7 @@ class GaugeTrait(CounterTrait):
     @current.deleter
     def current(self):
         "Resets current back to 'full'"
-        self._data["current"] = self.base + self.mod
+        self._data["current"] =  (self.base + self.mod) * self.mult
 
     @property
     def value(self):

From 4dcba2f2340b4ad7d6c4ac03453abd365900929b Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Sat, 12 Feb 2022 13:28:45 -0800
Subject: [PATCH 03/10] Fixed documentation

---
 evennia/contrib/rpg/traits/traits.py | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/evennia/contrib/rpg/traits/traits.py b/evennia/contrib/rpg/traits/traits.py
index da1e5b5e9d..d528dc121a 100644
--- a/evennia/contrib/rpg/traits/traits.py
+++ b/evennia/contrib/rpg/traits/traits.py
@@ -173,9 +173,10 @@ if trait1 > trait2:
 
 `value = (base + mod) * mult`
 
-The static trait has a `base` value and an optional `mod`-ifier and 'mult'-iplier. A typical use
-of a static trait would be a Strength stat or Skill value. That is, something
-that varies slowly or not at all, and which may be modified in-place.
+The static trait has a `base` value and an optional `mod`-ifier and 'mult'-iplier.
+The modifier defaults to 0, and the multiplier to 1.0, for no change in value.
+A typical use of a static trait would be a Strength stat or Skill value. That is, 
+somethingthat varies slowly or not at all, and which may be modified in-place.
 
 ```python
 > obj.traits.add("str", "Strength", trait_type="static", base=10, mod=2)
@@ -200,15 +201,16 @@ that varies slowly or not at all, and which may be modified in-place.
     min/unset     base    base+mod                       max/unset
     |--------------|--------|---------X--------X------------|
                                   current    value
-                                             = current
-                                             + mod
+                                             = (current
+                                             + mod)
                                              * mult
 
 A counter describes a value that can move from a base. The `.current` property
 is the thing usually modified. It starts at the `.base`. One can also add a
 modifier, which is added to both the base and to current. '.value' is then formed 
-by multiplying by the multiplier. The min/max of the range are optional, a boundary 
-set to None will remove it. A suggested use for a Counter Trait would be to track skill values.
+by multiplying by the multiplier, which defaults to 1.0 for no change. The min/max 
+of the range are optional, a boundary set to None will remove it. A suggested use 
+for a Counter Trait would be to track skill values.
 
 ```python
 > obj.traits.add("hunting", "Hunting Skill", trait_type="counter",
@@ -1210,8 +1212,8 @@ class CounterTrait(Trait):
     min/unset     base    base+mod                       max/unset
      |--------------|--------|---------X--------X------------|
                                     current   value
-                                              = current
-                                              + mod
+                                              = (current
+                                              + mod)
                                               * mult
 
     - value = (current + mod) * mult, starts at base + mod

From 6246e72a7928a3d60e279e0d0dfc7541fe89c5df Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Sat, 12 Feb 2022 15:01:59 -0800
Subject: [PATCH 04/10] removed mult from checks on setting base/mod in
 counter/gauge traits; very unintuitive behavior

---
 evennia/contrib/rpg/traits/traits.py | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/evennia/contrib/rpg/traits/traits.py b/evennia/contrib/rpg/traits/traits.py
index d528dc121a..b2da738c08 100644
--- a/evennia/contrib/rpg/traits/traits.py
+++ b/evennia/contrib/rpg/traits/traits.py
@@ -1319,16 +1319,16 @@ class CounterTrait(Trait):
             now = time()
             tdiff = now - self._data["last_update"]
             current += rate * tdiff
-            value = (current + self.mod) * self.mult
+            value = (current + self.mod)
 
             # we must make sure so we don't overstep our bounds
             # even if .mod is included
 
             if self._passed_ratetarget(value):
-                current = (self._data["ratetarget"] - self.mod) / self.mult
+                current = (self._data["ratetarget"] - self.mod)
                 self._stop_timer()
             elif not self._within_boundaries(value):
-                current = (self._enforce_boundaries(value) - self.mod) / self.mult
+                current = (self._enforce_boundaries(value) - self.mod)
                 self._stop_timer()
             else:
                 self._data["last_update"] = now
@@ -1350,10 +1350,10 @@ class CounterTrait(Trait):
         if value is None:
             self._data["base"] = self.default_keys["base"]
         if type(value) in (int, float):
-            if self.min is not None and (value + self.mod) * self.mult < self.min:
-                value = (self.min - self.mod) / self.mult
-            if self.max is not None and (value + self.mod) * self.mult > self.max:
-                value = (self.max - self.mod) / self.mult
+            if self.min is not None and value + self.mod < self.min:
+                value = self.min - self.mod
+            if self.max is not None and value + self.mod > self.max:
+                value = self.max - self.mod
             self._data["base"] = value
 
     @property
@@ -1366,10 +1366,10 @@ class CounterTrait(Trait):
             # unsetting the boundary to default
             self._data["mod"] = self.default_keys["mod"]
         elif type(value) in (int, float):
-            if self.min is not None and (value + self.base) * self.mult < self.min:
-                value = (self.min - self.base) / self.mult
-            if self.max is not None and (value + self.base) * self.mult > self.max:
-                value = (self.max - self.base) / self.mult
+            if self.min is not None and value + self.base < self.min:
+                value = self.min - self.base
+            if self.max is not None and value + self.base > self.max:
+                value = self.max - self.base
             self._data["mod"] = value
 
     @property
@@ -1393,7 +1393,7 @@ class CounterTrait(Trait):
         elif type(value) in (int, float):
             if self.max is not None:
                 value = min(self.max, value)
-            self._data["min"] = min(value, (self.base + self.mod) * self.mult)
+            self._data["min"] = min(value, self.base + self.mod)
 
     @property
     def max(self):
@@ -1427,7 +1427,7 @@ class CounterTrait(Trait):
     @property
     def value(self):
         "The value of the Trait. (current + mod) * mult"
-        return self._enforce_boundaries( (self.current + self.mod) * self.mult)
+        return self._enforce_boundaries((self.current + self.mod) * self.mult)
 
     @property
     def ratetarget(self):

From d86108b2762ad96b6ff46297456f025e4642d81e Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Sat, 12 Feb 2022 15:02:28 -0800
Subject: [PATCH 05/10] added deleters for mult (resets to 1.0), fixed more
 docstring stuff

---
 evennia/contrib/rpg/traits/traits.py | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/evennia/contrib/rpg/traits/traits.py b/evennia/contrib/rpg/traits/traits.py
index b2da738c08..a8a8261086 100644
--- a/evennia/contrib/rpg/traits/traits.py
+++ b/evennia/contrib/rpg/traits/traits.py
@@ -1196,6 +1196,10 @@ class StaticTrait(Trait):
         if type(amount) in (int, float):
             self._data["mult"] = amount
 
+    @mult.deleter
+    def mult(self):
+        self._data["mult"] = 1.0
+
     @property
     def value(self):
         "The value of the Trait."
@@ -1209,14 +1213,14 @@ class CounterTrait(Trait):
     This includes modifications and min/max limits as well as the notion of a
     current value. The value can also be reset to the base value.
 
-    min/unset     base    base+mod                       max/unset
+    min/unset     base  (base+mod)*mult                  max/unset
      |--------------|--------|---------X--------X------------|
                                     current   value
                                               = (current
                                               + mod)
                                               * mult
 
-    - value = (current + mod) * mult, starts at base + mod
+    - value = (current + mod) * mult, starts at (base + mod) * mult
     - if min or max is None, there is no upper/lower bound (default)
     - if max is set to "base", max will be equal ot base+mod
     - descs are used to optionally describe each value interval.
@@ -1381,6 +1385,10 @@ class CounterTrait(Trait):
         if type(amount) in (int, float):
             self._data["mult"] = amount
 
+    @mult.deleter
+    def mult(self):
+        self._data["mult"] = 1.0
+
     @property
     def min(self):
         return self._data["min"]
@@ -1407,11 +1415,11 @@ class CounterTrait(Trait):
         elif type(value) in (int, float):
             if self.min is not None:
                 value = max(self.min, value)
-            self._data["max"] = max(value, (self.base + self.mod) * self.mult)
+            self._data["max"] = max(value, self.base + self.mod)
 
     @property
     def current(self):
-        """The `current` value of the `Trait`. This does not have .mod added."""
+        """The `current` value of the `Trait`. This does not have .mod added and is not .mult-iplied."""
         return self._update_current(self._data.get("current", self.base))
 
     @current.setter
@@ -1599,6 +1607,10 @@ class GaugeTrait(CounterTrait):
         if type(amount) in (int, float):
             self._data["mult"] = amount
 
+    @mult.deleter
+    def mult(self):
+        self._data["mult"] = 1.0
+
     @property
     def min(self):
         val = self._data["min"]

From 73022b775bfed7568573f226bb66cf8c8a7d56cf Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Sat, 12 Feb 2022 15:06:38 -0800
Subject: [PATCH 06/10] more removal of mult from base/mod setter

---
 evennia/contrib/rpg/traits/traits.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/evennia/contrib/rpg/traits/traits.py b/evennia/contrib/rpg/traits/traits.py
index a8a8261086..d64aa024d4 100644
--- a/evennia/contrib/rpg/traits/traits.py
+++ b/evennia/contrib/rpg/traits/traits.py
@@ -1580,10 +1580,10 @@ class GaugeTrait(CounterTrait):
 
     @base.setter
     def base(self, value):
-        """Limit so (base+mod)*mult can never go below min."""
+        """Limit so base+mod can never go below min."""
         if type(value) in (int, float):
-            if (value + self.mod) * self.mult < self.min:
-                value = (self.min - self.mod) / self.mult
+            if value + self.mod < self.min:
+                value = self.min - self.mod
             self._data["base"] = value
 
     @property
@@ -1592,10 +1592,10 @@ class GaugeTrait(CounterTrait):
 
     @mod.setter
     def mod(self, value):
-        """Limit so (base+mod)*mult can never go below min."""
+        """Limit so base+mod can never go below min."""
         if type(value) in (int, float):
-            if (value + self.base) * self.mult < self.min:
-                value = (self.min - self.base) / self.mult
+            if value + self.base < self.min:
+                value = self.min - self.base
             self._data["mod"] = value
     
     @property

From 7e88ce8234071e00b29e9f29619b0e76d5e83f17 Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Sat, 12 Feb 2022 16:51:27 -0800
Subject: [PATCH 07/10] static trait unit tests

---
 evennia/contrib/rpg/traits/tests.py | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/evennia/contrib/rpg/traits/tests.py b/evennia/contrib/rpg/traits/tests.py
index bb31bbfc13..cadf777627 100644
--- a/evennia/contrib/rpg/traits/tests.py
+++ b/evennia/contrib/rpg/traits/tests.py
@@ -274,13 +274,14 @@ class TestTraitStatic(_TraitHandlerBase):
             trait_type="static",
             base=1,
             mod=2,
+            mult=2.0,
             extra_val1="xvalue1",
             extra_val2="xvalue2",
         )
         self.trait = self.traithandler.get("test1")
 
     def _get_values(self):
-        return self.trait.base, self.trait.mod, self.trait.value
+        return self.trait.base, self.trait.mod, self.trait.mult, self.trait.value
 
     def test_init(self):
         self.assertEqual(
@@ -290,25 +291,33 @@ class TestTraitStatic(_TraitHandlerBase):
                 "trait_type": "static",
                 "base": 1,
                 "mod": 2,
+                "mult": 2.0,
                 "extra_val1": "xvalue1",
                 "extra_val2": "xvalue2",
             },
         )
 
     def test_value(self):
-        """value is base + mod"""
-        self.assertEqual(self._get_values(), (1, 2, 3))
+        """value is (base + mod) * mult"""
+        self.assertEqual(self._get_values(), (1, 2, 2.0, 6))
         self.trait.base += 4
-        self.assertEqual(self._get_values(), (5, 2, 7))
+        self.assertEqual(self._get_values(), (5, 2, 2.0, 14))
         self.trait.mod -= 1
-        self.assertEqual(self._get_values(), (5, 1, 6))
+        self.assertEqual(self._get_values(), (5, 1, 2.0, 12))
+        self.trait.mult += 1.0
+        self.assertEqual(self._get_values(), (5, 1, 3.0, 18))
+        self.trait.mult = 0.75
+        self.assertEqual(self._get_values(), (5, 1, 0.75, 4.5))
+
 
     def test_delete(self):
         """Deleting resets to default."""
         del self.trait.base
-        self.assertEqual(self._get_values(), (0, 2, 2))
+        self.assertEqual(self._get_values(), (0, 2, 2.0, 4))
+        del self.trait.mult
+        self.assertEqual(self._get_values(), (0, 2, 1.0, 2))
         del self.trait.mod
-        self.assertEqual(self._get_values(), (0, 0, 0))
+        self.assertEqual(self._get_values(), (0, 0, 1.0, 0))
 
 
 class TestTraitCounter(_TraitHandlerBase):

From 8d9bd15ab856aab8893f9898ec61dcb41c0eae9b Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Sun, 13 Feb 2022 00:14:42 -0800
Subject: [PATCH 08/10] tweak to static unit tests

---
 evennia/contrib/rpg/traits/tests.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/evennia/contrib/rpg/traits/tests.py b/evennia/contrib/rpg/traits/tests.py
index cadf777627..9c1f3a1597 100644
--- a/evennia/contrib/rpg/traits/tests.py
+++ b/evennia/contrib/rpg/traits/tests.py
@@ -274,7 +274,7 @@ class TestTraitStatic(_TraitHandlerBase):
             trait_type="static",
             base=1,
             mod=2,
-            mult=2.0,
+            mult=1.0,
             extra_val1="xvalue1",
             extra_val2="xvalue2",
         )
@@ -291,7 +291,7 @@ class TestTraitStatic(_TraitHandlerBase):
                 "trait_type": "static",
                 "base": 1,
                 "mod": 2,
-                "mult": 2.0,
+                "mult": 1.0,
                 "extra_val1": "xvalue1",
                 "extra_val2": "xvalue2",
             },
@@ -299,19 +299,20 @@ class TestTraitStatic(_TraitHandlerBase):
 
     def test_value(self):
         """value is (base + mod) * mult"""
-        self.assertEqual(self._get_values(), (1, 2, 2.0, 6))
+        self.assertEqual(self._get_values(), (1, 2, 1.0, 3))
         self.trait.base += 4
-        self.assertEqual(self._get_values(), (5, 2, 2.0, 14))
+        self.assertEqual(self._get_values(), (5, 2, 1.0, 7))
         self.trait.mod -= 1
-        self.assertEqual(self._get_values(), (5, 1, 2.0, 12))
+        self.assertEqual(self._get_values(), (5, 1, 1.0, 6))
         self.trait.mult += 1.0
-        self.assertEqual(self._get_values(), (5, 1, 3.0, 18))
+        self.assertEqual(self._get_values(), (5, 1, 2.0, 12))
         self.trait.mult = 0.75
         self.assertEqual(self._get_values(), (5, 1, 0.75, 4.5))
 
 
     def test_delete(self):
         """Deleting resets to default."""
+        self.trait.mult = 2.0
         del self.trait.base
         self.assertEqual(self._get_values(), (0, 2, 2.0, 4))
         del self.trait.mult

From d3c8de822d4de1c2690a9737449894e4ca5a7afc Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Sun, 13 Feb 2022 00:15:55 -0800
Subject: [PATCH 09/10] counter trait unit tests

---
 evennia/contrib/rpg/traits/tests.py | 70 ++++++++++++++++-------------
 1 file changed, 38 insertions(+), 32 deletions(-)

diff --git a/evennia/contrib/rpg/traits/tests.py b/evennia/contrib/rpg/traits/tests.py
index 9c1f3a1597..149617ad7b 100644
--- a/evennia/contrib/rpg/traits/tests.py
+++ b/evennia/contrib/rpg/traits/tests.py
@@ -334,6 +334,7 @@ class TestTraitCounter(_TraitHandlerBase):
             trait_type="counter",
             base=1,
             mod=2,
+            mult=1.0,
             min=0,
             max=10,
             extra_val1="xvalue1",
@@ -343,8 +344,8 @@ class TestTraitCounter(_TraitHandlerBase):
         self.trait = self.traithandler.get("test1")
 
     def _get_values(self):
-        """Get (base, mod, value, min, max)."""
-        return (self.trait.base, self.trait.mod, self.trait.value, self.trait.min, self.trait.max)
+        """Get (base, mod, mult, value, min, max)."""
+        return (self.trait.base, self.trait.mod, self.trait.mult, self.trait.value, self.trait.min, self.trait.max)
 
     def test_init(self):
         self.assertEqual(
@@ -354,6 +355,7 @@ class TestTraitCounter(_TraitHandlerBase):
                 "trait_type": "counter",
                 "base": 1,
                 "mod": 2,
+                "mult": 1.0,
                 "min": 0,
                 "max": 10,
                 "extra_val1": "xvalue1",
@@ -366,102 +368,105 @@ class TestTraitCounter(_TraitHandlerBase):
         )
 
     def test_value(self):
-        """value is current + mod, where current defaults to base"""
-        self.assertEqual(self._get_values(), (1, 2, 3, 0, 10))
+        """value is (current + mod) * mult, where current defaults to base"""
+        self.assertEqual(self._get_values(), (1, 2, 1.0, 3, 0, 10))
         self.trait.base += 4
-        self.assertEqual(self._get_values(), (5, 2, 7, 0, 10))
+        self.assertEqual(self._get_values(), (5, 2, 1.0, 7, 0, 10))
         self.trait.mod -= 1
-        self.assertEqual(self._get_values(), (5, 1, 6, 0, 10))
+        self.assertEqual(self._get_values(), (5, 1, 1.0, 6, 0, 10))
+        self.trait.mult += 1.0
+        self.assertEqual(self._get_values(), (5, 1, 2.0, 10, 0, 10))
 
     def test_boundaries__minmax(self):
         """Test range"""
         # should not exceed min/max values
         self.trait.base += 20
-        self.assertEqual(self._get_values(), (8, 2, 10, 0, 10))
+        self.assertEqual(self._get_values(), (8, 2, 1.0, 10, 0, 10))
         self.trait.base = 100
-        self.assertEqual(self._get_values(), (8, 2, 10, 0, 10))
+        self.assertEqual(self._get_values(), (8, 2, 1.0, 10, 0, 10))
         self.trait.base -= 40
-        self.assertEqual(self._get_values(), (-2, 2, 0, 0, 10))
+        self.assertEqual(self._get_values(), (-2, 2, 1.0, 0, 0, 10))
         self.trait.base = -100
-        self.assertEqual(self._get_values(), (-2, 2, 0, 0, 10))
+        self.assertEqual(self._get_values(), (-2, 2, 1.0, 0, 0, 10))
 
     def test_boundaries__bigmod(self):
         """add a big mod"""
         self.trait.base = 5
         self.trait.mod = 100
-        self.assertEqual(self._get_values(), (5, 5, 10, 0, 10))
+        self.assertEqual(self._get_values(), (5, 5, 1.0, 10, 0, 10))
         self.trait.mod = -100
-        self.assertEqual(self._get_values(), (5, -5, 0, 0, 10))
+        self.assertEqual(self._get_values(), (5, -5, 1.0, 0, 0, 10))
 
     def test_boundaries__change_boundaries(self):
         """Change boundaries after base/mod change"""
         self.trait.base = 5
         self.trait.mod = -100
         self.trait.min = -20
-        self.assertEqual(self._get_values(), (5, -5, 0, -20, 10))
+        self.assertEqual(self._get_values(), (5, -5, 1.0, 0, -20, 10))
         self.trait.mod -= 100
-        self.assertEqual(self._get_values(), (5, -25, -20, -20, 10))
+        self.assertEqual(self._get_values(), (5, -25, 1.0, -20, -20, 10))
         self.trait.mod = 100
         self.trait.max = 20
-        self.assertEqual(self._get_values(), (5, 5, 10, -20, 20))
+        self.assertEqual(self._get_values(), (5, 5, 1.0, 10, -20, 20))
         self.trait.mod = 100
-        self.assertEqual(self._get_values(), (5, 15, 20, -20, 20))
+        self.assertEqual(self._get_values(), (5, 15, 1.0, 20, -20, 20))
 
     def test_boundaries__disable(self):
         """Disable and re-enable boundaries"""
         self.trait.base = 5
         self.trait.mod = 100
-        self.assertEqual(self._get_values(), (5, 5, 10, 0, 10))
+        self.assertEqual(self._get_values(), (5, 5, 1.0, 10, 0, 10))
         del self.trait.max
         self.assertEqual(self.trait.max, None)
         del self.trait.min
         self.assertEqual(self.trait.min, None)
         self.trait.base = 100
-        self.assertEqual(self._get_values(), (100, 5, 105, None, None))
+        self.assertEqual(self._get_values(), (100, 5, 1.0, 105, None, None))
         self.trait.base = -200
-        self.assertEqual(self._get_values(), (-200, 5, -195, None, None))
+        self.assertEqual(self._get_values(), (-200, 5, 1.0, -195, None, None))
 
         # re-activate boundaries
         self.trait.max = 15
         self.trait.min = 10  # his is blocked since base+mod is lower
-        self.assertEqual(self._get_values(), (-200, 5, -195, -195, 15))
+        self.assertEqual(self._get_values(), (-200, 5, 1.0, -195, -195, 15))
 
     def test_boundaries__inverse(self):
         """Set inverse boundaries - limited by base"""
         self.trait.mod = 0
-        self.assertEqual(self._get_values(), (1, 0, 1, 0, 10))
+        self.assertEqual(self._get_values(), (1, 0, 1.0, 1, 0, 10))
         self.trait.min = 20  # will be set to base
-        self.assertEqual(self._get_values(), (1, 0, 1, 1, 10))
+        self.assertEqual(self._get_values(), (1, 0, 1.0, 1, 1, 10))
         self.trait.max = -20
-        self.assertEqual(self._get_values(), (1, 0, 1, 1, 1))
+        self.assertEqual(self._get_values(), (1, 0, 1.0, 1, 1, 1))
 
     def test_current(self):
         """Modifying current value"""
         self.trait.current = 5
-        self.assertEqual(self._get_values(), (1, 2, 7, 0, 10))
+        self.assertEqual(self._get_values(), (1, 2, 1.0, 7, 0, 10))
         self.trait.current = 10
-        self.assertEqual(self._get_values(), (1, 2, 10, 0, 10))
+        self.assertEqual(self._get_values(), (1, 2, 1.0, 10, 0, 10))
         self.trait.current = 12
-        self.assertEqual(self._get_values(), (1, 2, 10, 0, 10))
+        self.assertEqual(self._get_values(), (1, 2, 1.0, 10, 0, 10))
         self.trait.current = -1
-        self.assertEqual(self._get_values(), (1, 2, 2, 0, 10))
+        self.assertEqual(self._get_values(), (1, 2, 1.0, 2, 0, 10))
         self.trait.current -= 10
-        self.assertEqual(self._get_values(), (1, 2, 2, 0, 10))
+        self.assertEqual(self._get_values(), (1, 2, 1.0, 2, 0, 10))
 
     def test_delete(self):
         """Deleting resets to default."""
         del self.trait.base
-        self.assertEqual(self._get_values(), (0, 2, 2, 0, 10))
+        self.assertEqual(self._get_values(), (0, 2, 1.0, 2, 0, 10))
         del self.trait.mod
-        self.assertEqual(self._get_values(), (0, 0, 0, 0, 10))
+        self.assertEqual(self._get_values(), (0, 0, 1.0, 0, 0, 10))
         del self.trait.min
         del self.trait.max
-        self.assertEqual(self._get_values(), (0, 0, 0, None, None))
+        self.assertEqual(self._get_values(), (0, 0, 1.0, 0, None, None))
 
     def test_percentage(self):
         """Test percentage calculation"""
         self.trait.base = 8
         self.trait.mod = 2
+        self.trait.mult = 1.0
         self.trait.min = 0
         self.trait.max = 10
         self.assertEqual(self.trait.percent(), "100.0%")
@@ -513,6 +518,7 @@ class TestTraitCounterTimed(_TraitHandlerBase):
             trait_type="counter",
             base=1,
             mod=2,
+            mult=1.0,
             min=0,
             max=100,
             extra_val1="xvalue1",
@@ -595,7 +601,7 @@ class TestTraitGauge(_TraitHandlerBase):
 
     def _get_values(self):
         """Get (base, mod, value, min, max)."""
-        return (self.trait.base, self.trait.mod, self.trait.value, self.trait.min, self.trait.max)
+        return (self.trait.base, self.trait.mod, self.trait.mult, self.trait.value, self.trait.min, self.trait.max)
 
     def test_init(self):
         self.assertEqual(

From fc941a8713523c6c745055a47df25c819662b325 Mon Sep 17 00:00:00 2001
From: Tegiminis <dragonmaw@gmail.com>
Date: Mon, 14 Feb 2022 21:23:35 -0800
Subject: [PATCH 10/10] gauge trait unit tests

---
 evennia/contrib/rpg/traits/tests.py | 83 ++++++++++++++++-------------
 1 file changed, 47 insertions(+), 36 deletions(-)

diff --git a/evennia/contrib/rpg/traits/tests.py b/evennia/contrib/rpg/traits/tests.py
index 149617ad7b..bb2c430f86 100644
--- a/evennia/contrib/rpg/traits/tests.py
+++ b/evennia/contrib/rpg/traits/tests.py
@@ -487,7 +487,7 @@ class TestTraitCounter(_TraitHandlerBase):
         """Test descriptions"""
         self.trait.min = -5
         self.trait.mod = 0
-        self.assertEqual(self._get_values(), (1, 0, 1, -5, 10))
+        self.assertEqual(self._get_values(), (1, 0, 1.0, 1, -5, 10))
         self.trait.current = -2
         self.assertEqual(self.trait.desc(), "range0")
         self.trait.current = 0
@@ -591,8 +591,9 @@ class TestTraitGauge(_TraitHandlerBase):
             "test1",
             name="Test1",
             trait_type="gauge",
-            base=8,  # max = base + mod
+            base=8,  # max = (base + mod) * mult
             mod=2,
+            mult=1.0,
             extra_val1="xvalue1",
             extra_val2="xvalue2",
             descs={0: "range0", 2: "range1", 5: "range2", 7: "range3",},
@@ -611,6 +612,7 @@ class TestTraitGauge(_TraitHandlerBase):
                 "trait_type": "gauge",
                 "base": 8,
                 "mod": 2,
+                "mult": 1.0,
                 "min": 0,
                 "extra_val1": "xvalue1",
                 "extra_val2": "xvalue2",
@@ -624,71 +626,80 @@ class TestTraitGauge(_TraitHandlerBase):
     def test_value(self):
         """value is current, where current defaults to base + mod"""
         # current unset - follows base + mod
-        self.assertEqual(self._get_values(), (8, 2, 10, 0, 10))
+        self.assertEqual(self._get_values(), (8, 2, 1.0, 10, 0, 10))
         self.trait.base += 4
-        self.assertEqual(self._get_values(), (12, 2, 14, 0, 14))
+        self.assertEqual(self._get_values(), (12, 2, 1.0, 14, 0, 14))
         self.trait.mod -= 1
-        self.assertEqual(self._get_values(), (12, 1, 13, 0, 13))
+        self.assertEqual(self._get_values(), (12, 1, 1.0, 13, 0, 13))
+        self.trait.mult += 1.0
+        self.assertEqual(self._get_values(), (12, 1, 2.0, 26, 0, 26))
         # set current, decouple from base + mod
         self.trait.current = 5
-        self.assertEqual(self._get_values(), (12, 1, 5, 0, 13))
+        self.assertEqual(self._get_values(), (12, 1, 2.0, 5, 0, 26))
         self.trait.mod += 1
         self.trait.base -= 4
-        self.assertEqual(self._get_values(), (8, 2, 5, 0, 10))
+        self.trait.mult -= 1.0
+        self.assertEqual(self._get_values(), (8, 2, 1.0, 5, 0, 10))
         self.trait.min = -100
         self.trait.base = -20
-        self.assertEqual(self._get_values(), (-20, 2, -18, -100, -18))
+        self.assertEqual(self._get_values(), (-20, 2, 1.0, -18, -100, -18))
 
     def test_boundaries__minmax(self):
         """Test range"""
         # current unset - tied to base + mod
         self.trait.base += 20
-        self.assertEqual(self._get_values(), (28, 2, 30, 0, 30))
+        self.assertEqual(self._get_values(), (28, 2, 1.0, 30, 0, 30))
         # set current - decouple from base + mod
         self.trait.current = 19
-        self.assertEqual(self._get_values(), (28, 2, 19, 0, 30))
+        self.assertEqual(self._get_values(), (28, 2, 1.0, 19, 0, 30))
         # test upper bound
         self.trait.current = 100
-        self.assertEqual(self._get_values(), (28, 2, 30, 0, 30))
+        self.assertEqual(self._get_values(), (28, 2, 1.0, 30, 0, 30))
+        # with multiplier
+        self.trait.mult = 2.0
+        self.assertEqual(self._get_values(), (28, 2, 2.0, 30, 0, 60))
+        self.trait.current = 100
+        self.assertEqual(self._get_values(), (28, 2, 2.0, 60, 0, 60))
         # min defaults to 0
+        self.trait.mult = 1.0
         self.trait.current = -10
-        self.assertEqual(self._get_values(), (28, 2, 0, 0, 30))
+        self.assertEqual(self._get_values(), (28, 2, 1.0, 0, 0, 30))
         self.trait.min = -20
-        self.assertEqual(self._get_values(), (28, 2, 0, -20, 30))
+        self.assertEqual(self._get_values(), (28, 2, 1.0, 0, -20, 30))
         self.trait.current = -10
-        self.assertEqual(self._get_values(), (28, 2, -10, -20, 30))
+        self.assertEqual(self._get_values(), (28, 2, 1.0, -10, -20, 30))
 
     def test_boundaries__bigmod(self):
         """add a big mod"""
         self.trait.base = 5
         self.trait.mod = 100
-        self.assertEqual(self._get_values(), (5, 100, 105, 0, 105))
+        self.assertEqual(self._get_values(), (5, 100, 1.0, 105, 0, 105))
         # restricted by min
         self.trait.mod = -100
-        self.assertEqual(self._get_values(), (5, -5, 0, 0, 0))
+        self.assertEqual(self._get_values(), (5, -5, 1.0, 0, 0, 0))
         self.trait.min = -200
-        self.assertEqual(self._get_values(), (5, -5, 0, -200, 0))
+        self.assertEqual(self._get_values(), (5, -5, 1.0, 0, -200, 0))
 
     def test_boundaries__change_boundaries(self):
         """Change boundaries after current change"""
         self.trait.current = 20
-        self.assertEqual(self._get_values(), (8, 2, 10, 0, 10))
+        self.assertEqual(self._get_values(), (8, 2, 1.0, 10, 0, 10))
         self.trait.mod = 102
-        self.assertEqual(self._get_values(), (8, 102, 10, 0, 110))
+        self.assertEqual(self._get_values(), (8, 102, 1.0, 10, 0, 110))
         # raising min past current value will force it upwards
         self.trait.min = 20
-        self.assertEqual(self._get_values(), (8, 102, 20, 20, 110))
+        self.assertEqual(self._get_values(), (8, 102, 1.0, 20, 20, 110))
 
     def test_boundaries__disable(self):
         """Disable and re-enable boundary"""
         self.trait.base = 5
         self.trait.min = 1
-        self.assertEqual(self._get_values(), (5, 2, 7, 1, 7))
+        self.assertEqual(self._get_values(), (5, 2, 1.0, 7, 1, 7))
         del self.trait.min
-        self.assertEqual(self._get_values(), (5, 2, 7, 0, 7))
+        self.assertEqual(self._get_values(), (5, 2, 1.0, 7, 0, 7))
         del self.trait.base
         del self.trait.mod
-        self.assertEqual(self._get_values(), (0, 0, 0, 0, 0))
+        self.assertEqual(self._get_values(), (0, 0, 1.0, 0, 0, 0))
         with self.assertRaises(traits.TraitException):
             del self.trait.max
 
@@ -696,39 +707,39 @@ class TestTraitGauge(_TraitHandlerBase):
         """Try to set reversed boundaries"""
         self.trait.mod = 0
         self.trait.base = -10  # limited by min
-        self.assertEqual(self._get_values(), (0, 0, 0, 0, 0))
+        self.assertEqual(self._get_values(), (0, 0, 1.0, 0, 0, 0))
         self.trait.min = -10
-        self.assertEqual(self._get_values(), (0, 0, 0, -10, 0))
+        self.assertEqual(self._get_values(), (0, 0, 1.0, 0, -10, 0))
         self.trait.base = -10
-        self.assertEqual(self._get_values(), (-10, 0, -10, -10, -10))
+        self.assertEqual(self._get_values(), (-10, 0, 1.0, -10, -10, -10))
         self.min = 0  # limited by base + mod
-        self.assertEqual(self._get_values(), (-10, 0, -10, -10, -10))
+        self.assertEqual(self._get_values(), (-10, 0, 1.0, -10, -10, -10))
 
     def test_current(self):
         """Modifying current value"""
         self.trait.base = 10
         self.trait.current = 5
-        self.assertEqual(self._get_values(), (10, 2, 5, 0, 12))
+        self.assertEqual(self._get_values(), (10, 2, 1.0, 5, 0, 12))
         self.trait.current = 10
-        self.assertEqual(self._get_values(), (10, 2, 10, 0, 12))
+        self.assertEqual(self._get_values(), (10, 2, 1.0, 10, 0, 12))
         self.trait.current = 12
-        self.assertEqual(self._get_values(), (10, 2, 12, 0, 12))
+        self.assertEqual(self._get_values(), (10, 2, 1.0, 12, 0, 12))
         self.trait.current = 0
-        self.assertEqual(self._get_values(), (10, 2, 0, 0, 12))
+        self.assertEqual(self._get_values(), (10, 2, 1.0, 0, 0, 12))
         self.trait.current = -1
-        self.assertEqual(self._get_values(), (10, 2, 0, 0, 12))
+        self.assertEqual(self._get_values(), (10, 2, 1.0, 0, 0, 12))
 
     def test_delete(self):
         """Deleting resets to default."""
         del self.trait.mod
-        self.assertEqual(self._get_values(), (8, 0, 8, 0, 8))
+        self.assertEqual(self._get_values(), (8, 0, 1.0, 8, 0, 8))
         self.trait.mod = 2
         del self.trait.base
-        self.assertEqual(self._get_values(), (0, 2, 2, 0, 2))
+        self.assertEqual(self._get_values(), (0, 2, 1.0, 2, 0, 2))
         del self.trait.min
-        self.assertEqual(self._get_values(), (0, 2, 2, 0, 2))
+        self.assertEqual(self._get_values(), (0, 2, 1.0, 2, 0, 2))
         self.trait.min = -10
-        self.assertEqual(self._get_values(), (0, 2, 2, -10, 2))
+        self.assertEqual(self._get_values(), (0, 2, 1.0, 2, -10, 2))
         del self.trait.min
         self.assertEqual(self._get_values(), (0, 2, 2, 0, 2))