--- a/orpg/dieroller/utils.py	Tue Aug 17 14:53:04 2010 -0500
+++ b/orpg/dieroller/utils.py	Mon Oct 18 23:48:49 2010 -0500
@@ -32,6 +32,20 @@
 import orpg.dieroller.rollers
 from orpg.dieroller.base import die_rollers
 
+"""
+Die Roller Changes:
+I've made some changes for ease of reading. Below you see the new formula and the old depricated formula. The new formula is easier to understand
+and works a little better with math. Try this: [(2+4)+4d(6+8)+(4*4)] with both formulas. Traipse succeeds, Standard (1.7.1) fails.
+
+The new formula deals only with numbers of the Fudge roller. The math has a required process flow, which is unliked currently by me but I am not
+going to spend more time on at currently to correct it. It occurs when using paranthesis on the facet. If paranthesis are used no modifier can be added
+at the end, but you can added it before the roll.
+
+This is the standard roller formula: (Math D Numbers or Math or Fudge). If that fails the new non_stdDie looks for a regExpression formula inside
+the current die roller, set under the name. So all of that bloat to include the english language in the Gilcrease 1.8.0 remains bloat and Traipse's
+dice can be liberated to do what they want, where they want, when they want.
+"""
+
 class roller_manager(object):
     def __new__(cls):
         it = cls.__dict__.get("__it__")
@@ -55,9 +69,11 @@
 
     def completeMath(self, matches):
         s = matches.group(0)
-        return str(eval(s))
+        try: doMath = str(eval(s))
+        except: doMath = s
+        return doMath
 
-    def stdDieToDClass(self, match):
+    def stdDie_Class(self, match):
         s = match.group(0)
         num_sides = s.split('d')
         if len(num_sides) > 1: 
@@ -72,44 +88,45 @@
             return s
 
     #  Use this to convert ndm-style (3d6) dice to d_base format
-    def convertTheDieString(self, s):
-        """
-        Die Roller Changes:
-        I've made some changes for ease of reading. Below you see the new formula and the old depricated formula. The new formula is easier to understand
-        and works a little better with math. Try this: [(2+4)+4d(6+8)+(4*4)] with both formulas. Traipse succeeds, Standard (1.7.1) fails.
-
-        The new formula deals only with numbers of the Fudge roller. The math has a required process flow, which is unliked currently by me but I am not
-        going to spend more time on at currently to correct it. It occurs when using paranthesis on the facet. If paranthesis are used no modifier can be added
-        at the end, but you can added it before the roll.
-
-        This is the standard roller formula: (Math D Numbers or Math or Fudge). If that fails the new non_stdDie looks for a regExpression formula inside
-        the current die roller, set under the name. So all of that bloat to include the english language in the Gilcrease 1.8.0 remains bloat and Traipse's
-        dice can be liberated to do what they want, where they want, when they want.
-        """
-        self.result = ''
+    def stdDie(self, s):
         math = '[\(0-9\/\*\-\+\)]+'
-        reg = re.compile(math+'d\s*([0-9]+|'+math+'|[fF])')
-
+        reg = re.compile('[0-9]+d\s*([0-9]+|'+math+'|[fF])')
         #reg = re.compile("(?:\d+|\([0-9\*/\-\+]+\))\s*[a-zA-Z]+\s*[\dFf]+") ## Original
-        (result, num_matches) = reg.subn(self.stdDieToDClass, s)
+        try:
+            (result, num_matches) = reg.subn(self.stdDie_Class, s)
+            #print 'main', result, num_matches
+            if num_matches == 0 or result is None:
+                reg = re.compile(math)
+                (result, math_matches) = reg.subn(self.completeMath, s)
+                #print 'math1', result, num_matches
+                reg = re.compile('[0-9]+d\s*([0-9]+|'+math+'|[fF])')
+                (result, num_matches) = reg.subn(self.stdDie_Class, result)
+                #print 'math2', result, num_matches
+        except Exception, e: 
+            print 'Die string conversion failed,', e
+            return s
+        return str(result)
 
-        if num_matches == 0 or result is None:
-            reg = re.compile(math)
-            (result, math_matches) = reg.subn(self.completeMath, s)
+    def nonStdDie(self, s):
+        math = '[\(0-9\/\*\-\+\)]+'
+        reg = re.compile(math)
+        (result, math_matches) = reg.subn(self.completeMath, s)
 
-        if num_matches == 0 or result is None:
-            try:
-                reg = re.compile(die_rollers._rollers[self.getRoller()].regExpression)
-                (result, num_matches) = reg.subn(self.roller_class().non_stdDie, s)
-                self.result = result
-            except: pass
-        return result
+        reg = re.compile(die_rollers._rollers[self.getRoller()].regExpression)
+        (result, num_matches) = reg.subn(self.roller_class().non_stdDie, s) ## Currently skipping math
+
+        if num_matches == 0 or result is None: return s
+        else: return result
 
     def proccessRoll(self, s):
-        v = self.convertTheDieString(s)
-        try: b = str(eval(v))
-        except: 
-            if v == '': b = s
-            else: b = str(v) ##Fail safe for non standard dice.
+        ## Re arranged to allow the non standard dice to use the built in roller methods, 
+        ## not re-written roller methods.
+        b = self.stdDie(s)
+        try: b = str(eval(b))
+        except:
+            b = self.nonStdDie(s)
+            try: b = str(eval(b))
+            except: pass
         return b
 
+