use Game::Die::Dice;
my $input = "1D4x10";
my ($pass_to_module, $mult) = split('x', $input);
$mult = defined($mult) ? $mult : 1;
my $dice = new Games::Die::Dice($pass_to_module);
my $treasure -= $mult * $dice->roll();
[download]

Alternatively, submit a patch to the maintainers of that module so that it accepts multipliers. Something to consider though: what about rolls like "1d4x10+10"? Your current approach probably doesn't handle this...

I took a look on the CPAN at Games::Dice::Die, and then at Games::Dice. It seemed like Games::Dice had many more features. So, I took a look at the code, and realized it was easy to add the support that you wanted. I only needed to slightly change the regex and 2 lines of code!

--- Games/Dice.pm.old    2004-12-17 14:17:54.172707400 -0500
+++ Games/Dice.pm.new    2004-12-17 15:56:22.599186000 -0500
@@ -19,7 +19,7 @@
 
 
 sub roll ($) {
-    my($line, $dice_string, $sign, $offset, $sum, @throws, @result);
+    my($line, $dice_string, @throws);
 
     $line = shift;
 
@@ -34,38 +34,29 @@
                       %         # a percent sign for d% = d100
                    )
                  )
-                 (?:            # grouping-only parens
-                   ([-+xX*/bB]) # a + - * / b(est) in $2
-                   (\d+)        # an offset in $3
-                 )?             # both of those last are optional
+                 ((?:           # capture
+                   [-+xX*/bB]   # a modifier
+                   \d+          # a, number
+                 )*)            # capture
               }x;               # whitespace allowed
 
-    $dice_string = $1;
-    $sign        = $2 || '';
-    $offset      = $3 || 0;
+    @throws = roll_array( $1 );
+    return unless @throws;
 
-    $sign        = lc $sign;
-
-    @throws = roll_array( $dice_string );
-    return undef unless @throws;
-
-    if( $sign eq 'b' ) {
+    my $mod = $2;
+    if( my($offset) = ($mod =~ /[bB](\d+)/) ) {
         $offset = 0       if $offset < 0;
         $offset = @throws if $offset > @throws;
 
         @throws = sort { $b <=> $a } @throws;   # sort numerically, d
+escending
-        @result = @throws[ 0 .. $offset-1 ];    # pick off the $offse
+t first ones
-    } else {
-        @result = @throws;
+        @throws = @throws[ 0 .. $offset-1 ];    # pick off the $offse
+t first ones
+        $mod = '';
     }
 
-    $sum = 0;
-    $sum += $_ foreach @result;
-    $sum += $offset if  $sign eq '+';
-    $sum -= $offset if  $sign eq '-';
-    $sum *= $offset if ($sign eq '*' || $sign eq 'x');
-    do { $sum /= $offset; $sum = int $sum; } if $sign eq '/';
-
+    my $sum = 0;
+    $sum += $_ foreach @throws;
+    (my $expr = $mod) =~ tr/Xx/**/;
+    $sum = int eval "$sum $expr" if $expr;
     return $sum;
 }
[download]

Update: Looking at this node again, I realized that the patch would break the b syntax, and so I, uh, fixed that. I also trimmed the original author's code a bit.

Neither does yours. :)