1 files changed, 66 insertions, 42 deletions

diff --git a/node/repeaternode.cpp b/node/repeaternode.cpp
index 09e88bd..26fab8f 100644
--- a/node/repeaternode.cpp
+++ b/node/repeaternode.cpp
@@ -26,63 +26,87 @@
 #include "parsingtoolbox.h"
 #include "result/stringresult.h"
 
+std::vector<ExecutionNode*> makeCopy(std::vector<ExecutionNode*> cmds)
+{
+    std::vector<ExecutionNode*> copy;
+    std::transform(cmds.begin(), cmds.end(), std::back_inserter(copy),
+                   [](ExecutionNode* node) { return node->getCopy(); });
+    return copy;
+}
+
 RepeaterNode::RepeaterNode() {}
 
 void RepeaterNode::run(ExecutionNode* previousNode)
 {
     m_previousNode= previousNode;
+
+    if(nullptr == m_times || m_cmd.empty())
+        return;
+
     m_times->run(this);
     m_times= ParsingToolBox::getLeafNode(m_times);
     auto times= m_times->getResult();
     auto timeCount= times->getResult(Dice::RESULT_TYPE::SCALAR).toInt();
-    auto cmd= m_cmd->getCopy();
+    auto cmd= makeCopy(m_cmd);
+    std::vector<Result*> resultVec;
     for(int i= 0; i < timeCount; ++i)
     {
-        m_cmd->run(this);
-        auto end= ParsingToolBox::getLeafNode(cmd);
-        auto result= end->getResult();
+        std::for_each(cmd.begin(), cmd.end(), [this, &resultVec](ExecutionNode* node) {
+            node->run(this);
+            auto end= ParsingToolBox::getLeafNode(node);
+            auto leafResult= end->getResult();
 
-        if(nullptr == result)
-            continue;
+            if(nullptr == leafResult)
+                return;
 
-        if(result->hasResultOfType(Dice::RESULT_TYPE::SCALAR))
-        {
-            if(m_sumAll)
-            {
-                auto res= new ScalarResult();
-
-                m_result= res;
-            }
-            else
-            {
-                auto res= new StringResult();
-                m_result= res;
-            }
-        }
-        else if(result->hasResultOfType(Dice::RESULT_TYPE::STRING))
-        {
-            auto res= new StringResult();
-
-            m_result= res;
-        }
-        else if(result->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST))
-        {
-            if(m_sumAll)
-            {
-                auto res= new ScalarResult();
-
-                m_result= res;
-            }
+            resultVec.push_back(leafResult);
+        });
+        cmd= makeCopy(m_cmd);
+    }
+    if(m_sumAll)
+    {
+        auto scalar= new ScalarResult();
+        qreal value= 0.0;
+        std::for_each(resultVec.begin(), resultVec.end(),
+                      [&value](Result* result) { value+= result->getResult(Dice::RESULT_TYPE::SCALAR).toDouble(); });
+        scalar->setValue(value);
+        m_result= scalar;
+    }
+    else
+    {
+        auto string= new StringResult();
+        QStringList list;
+        std::for_each(resultVec.begin(), resultVec.end(), [&list](Result* result) {
+            auto value= result->getResult(Dice::RESULT_TYPE::SCALAR).toDouble();
+            auto diceList= result->getResult(Dice::RESULT_TYPE::DICE_LIST).value<QList<Die*>>();
+            auto string= result->getResult(Dice::RESULT_TYPE::STRING).toString();
+
+            if(!string.isEmpty())
+                list.append(string);
             else
             {
-                auto res= new StringResult();
-
-                m_result= res;
+                QStringList diceStr;
+                std::transform(diceList.begin(), diceList.end(), std::back_inserter(diceStr), [](Die* die) {
+                    auto values= die->getListValue();
+
+                    QStringList valuesStr;
+                    std::transform(values.begin(), values.end(), std::back_inserter(valuesStr),
+                                   [](qint64 val) { return QString::number(val); });
+
+                    if(valuesStr.size() == 1)
+                        return QStringLiteral("%1").arg(die->getValue());
+                    else
+                        return QStringLiteral("%1 [%2]").arg(die->getValue()).arg(valuesStr.join(","));
+                });
+                list.append(QStringLiteral("%1 - Details [%2]").arg(value).arg(diceStr.join(",")));
             }
-        }
-
-        cmd= m_cmd->getCopy();
+        });
+        string->setText(list.join('\n'));
+        m_result= string;
     }
+
+    if(nullptr != m_nextNode)
+        m_nextNode->run(this);
 }
 
 QString RepeaterNode::toString(bool withLabel) const
@@ -100,9 +124,9 @@ ExecutionNode* RepeaterNode::getCopy() const
     return nullptr;
 }
 
-void RepeaterNode::setCommand(ExecutionNode* cmd)
+void RepeaterNode::setCommand(const std::vector<ExecutionNode*>& cmd)
 {
-    m_cmd.reset(cmd);
+    m_cmd= cmd;
 }
 
 void RepeaterNode::setTimeNode(ExecutionNode* time)