1 files changed, 61 insertions, 51 deletions

diff --git a/src/libparser/node/explodedicenode.cpp b/src/libparser/node/explodedicenode.cpp
index 1546883..7c9708b 100644
--- a/src/libparser/node/explodedicenode.cpp
+++ b/src/libparser/node/explodedicenode.cpp
@@ -1,4 +1,5 @@
 #include "explodedicenode.h"
+#include "diceparser/parsingtoolbox.h"
 #include "validatorlist.h"
 
 ExplodeDiceNode::ExplodeDiceNode() : m_diceResult(new DiceResult())
@@ -8,66 +9,70 @@ ExplodeDiceNode::ExplodeDiceNode() : m_diceResult(new DiceResult())
 void ExplodeDiceNode::run(ExecutionNode* previous)
 {
     m_previousNode= previous;
-    if((nullptr != previous) && (nullptr != previous->getResult()))
-    {
-        DiceResult* previous_result= dynamic_cast<DiceResult*>(previous->getResult());
-        m_result->setPrevious(previous_result);
-        if(nullptr != previous_result)
-        {
-            Die* exampleDie;
-            for(auto& die : previous_result->getResultList())
-            {
-                Die* tmpdie= new Die(*die);
-                m_diceResult->insertResult(tmpdie);
-                die->displayed();
-                exampleDie= tmpdie;
-            }
+    if(!previous)
+        return;
 
-            // QList<Die*> list= m_diceResult->getResultList();
+    if(!previous->getResult())
+        return;
 
-            bool hasExploded= false;
-            std::function<void(Die*, qint64)> f= [&hasExploded, this](Die* die, qint64) {
-                if(Dice::CONDITION_STATE::ALWAYSTRUE
-                   == m_validatorList->isValidRangeSize(
-                          std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
-                {
-                    m_errors.insert(Dice::ERROR_CODE::ENDLESS_LOOP_ERROR,
-                                    QObject::tr("Condition (%1) cause an endless loop with this dice: %2")
-                                        .arg(toString(true))
-                                        .arg(QStringLiteral("d[%1,%2]")
-                                                 .arg(static_cast<int>(die->getBase()))
-                                                 .arg(static_cast<int>(die->getMaxValue()))));
-                }
-                hasExploded= true;
-                die->roll(true);
-            };
-            do
-            {
-                hasExploded= false;
-                m_validatorList->validResult(m_diceResult, false, false, f);
-            } while(hasExploded);
+    DiceResult* previous_result= dynamic_cast<DiceResult*>(previous->getResult());
+    m_result->setPrevious(previous_result);
 
-            /*for(auto& die : list)
-            {
-                if(Dice::CONDITION_STATE::ALWAYSTRUE
-                   == m_validatorList->isValidRangeSize(
-                          std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
-                {
+    if(!previous_result)
+        return;
 
-                    continue;
-                }
+    for(auto& die : previous_result->getResultList())
+    {
+        Die* tmpdie= new Die(*die);
+        m_diceResult->insertResult(tmpdie);
+        die->displayed();
+    }
 
-                while(m_validatorList->hasValid(die, false))
-                {
-                    die->roll(true);
-                }
-            }*/
+    quint64 limit= -1;
+    if(m_limit)
+    {
+        m_limit->run(this);
+        auto limitNode= ParsingToolBox::getLeafNode(m_limit);
+        auto result= limitNode->getResult();
+        if(result->hasResultOfType(Dice::RESULT_TYPE::SCALAR))
+            limit= static_cast<quint64>(result->getResult(Dice::RESULT_TYPE::SCALAR).toInt());
+    }
 
-            if(nullptr != m_nextNode)
+    bool hasExploded= false;
+    std::function<void(Die*, qint64)> f= [&hasExploded, this, limit](Die* die, qint64) {
+        static QHash<Die*, quint64> explodePerDice;
+        if(Dice::CONDITION_STATE::ALWAYSTRUE
+           == m_validatorList->isValidRangeSize(std::make_pair<qint64, qint64>(die->getBase(), die->getMaxValue())))
+        {
+            m_errors.insert(Dice::ERROR_CODE::ENDLESS_LOOP_ERROR,
+                            QObject::tr("Condition (%1) cause an endless loop with this dice: %2")
+                                .arg(toString(true))
+                                .arg(QStringLiteral("d[%1,%2]")
+                                         .arg(static_cast<int>(die->getBase()))
+                                         .arg(static_cast<int>(die->getMaxValue()))));
+        }
+        hasExploded= true;
+        if(limit >= 0)
+        {
+            auto& d= explodePerDice[die];
+            if(d == limit)
             {
-                m_nextNode->run(this);
+                hasExploded= false;
+                return;
             }
+            ++d;
         }
+        die->roll(true);
+    };
+    do
+    {
+        hasExploded= false;
+        m_validatorList->validResult(m_diceResult, false, false, f);
+    } while(hasExploded);
+
+    if(nullptr != m_nextNode)
+    {
+        m_nextNode->run(this);
     }
 }
 ExplodeDiceNode::~ExplodeDiceNode()
@@ -115,3 +120,8 @@ ExecutionNode* ExplodeDiceNode::getCopy() const
     }
     return node;
 }
+
+void ExplodeDiceNode::setLimitNode(ExecutionNode* limitNode)
+{
+    m_limit= limitNode;
+}