aboutsummaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CMakeLists.txt1
-rw-r--r--include/diceparserhelper.h10
-rw-r--r--include/parsingtoolbox.h41
-rw-r--r--node/replacevaluenode.cpp134
-rw-r--r--node/replacevaluenode.h50
-rw-r--r--node/switchcasenode.cpp2
-rw-r--r--node/switchcasenode.h8
-rw-r--r--parsingtoolbox.cpp31
8 files changed, 250 insertions, 27 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9afc512..af3816b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -55,6 +55,7 @@ SET( dice_sources
${CMAKE_CURRENT_SOURCE_DIR}/node/valueslistnode.cpp
${CMAKE_CURRENT_SOURCE_DIR}/node/repeaternode.cpp
${CMAKE_CURRENT_SOURCE_DIR}/node/switchcasenode.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/node/replacevaluenode.cpp
)
IF(STATIC_BUILD)
diff --git a/include/diceparserhelper.h b/include/diceparserhelper.h
index 4a481c1..1ae5c3f 100644
--- a/include/diceparserhelper.h
+++ b/include/diceparserhelper.h
@@ -1,9 +1,11 @@
#ifndef DICEPARSERHELPER_H
#define DICEPARSERHELPER_H
+class ValidatorList;
+class ExecutionNode;
+
namespace Dice
{
-
enum class CONDITION_STATE : int
{
ERROR_STATE,
@@ -51,5 +53,11 @@ enum ConditionType
AllOfThem,
OnScalar
};
+
+struct CaseInfo
+{
+ ValidatorList* validatorList;
+ ExecutionNode* node;
+};
} // namespace Dice
#endif // DICEPARSERHELPER_H
diff --git a/include/parsingtoolbox.h b/include/parsingtoolbox.h
index d83e063..595e5e1 100644
--- a/include/parsingtoolbox.h
+++ b/include/parsingtoolbox.h
@@ -41,6 +41,7 @@ class RepeaterNode;
class DiceAlias;
class ExplodeDiceNode;
class SwitchCaseNode;
+class ReplaceValueNode;
class SubtituteInfo
{
@@ -90,25 +91,26 @@ public:
};
enum OptionOperator
{
- KeepAndExplode, // K
- Keep, // k
- Reroll, // r
- RerollUntil, // R
- Explode, // e
- Sort, // s
- Count, // c
- RerollAndAdd, // a
- Merge, // m
- ifOperator, // i
- Painter, // p
- Filter, // f
- Split, // y
- Group, // g
- Occurences, // o
- Unique, // u
- Bind, // b
- AllSameExplode, // t
- SwitchCaseOption // S
+ KeepAndExplode, // K
+ Keep, // k
+ Reroll, // r
+ RerollUntil, // R
+ Explode, // e
+ Sort, // s
+ Count, // c
+ RerollAndAdd, // a
+ Merge, // m
+ ifOperator, // i
+ Painter, // p
+ Filter, // f
+ Split, // y
+ Group, // g
+ Occurences, // o
+ Unique, // u
+ Bind, // b
+ AllSameExplode, // t
+ SwitchCaseOption, // S
+ TransformOption // T
};
enum DiceOperator
{
@@ -185,6 +187,7 @@ public:
bool readOption(QString&, ExecutionNode* node); // OptionOperator& option,
bool readValuesList(QString& str, ExecutionNode*& node);
bool readSwitchCaseNode(QString& str, SwitchCaseNode* node);
+ bool readReplaceValueNode(QString& str, ReplaceValueNode* node);
// Error
bool hasError() const;
diff --git a/node/replacevaluenode.cpp b/node/replacevaluenode.cpp
new file mode 100644
index 0000000..fbad5df
--- /dev/null
+++ b/node/replacevaluenode.cpp
@@ -0,0 +1,134 @@
+/***************************************************************************
+ * Copyright (C) 2021 by Renaud Guezennec *
+ * http://www.rolisteam.org/contact *
+ * *
+ * This software is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+#include "replacevaluenode.h"
+
+#include "diceresult.h"
+#include "parsingtoolbox.h"
+#include <QDebug>
+
+ReplaceValueNode::ReplaceValueNode() : m_diceResult(new DiceResult)
+{
+ m_result= m_diceResult;
+}
+
+void ReplaceValueNode::setStopAtFirt(bool b)
+{
+ m_stopAtFirst= b;
+}
+
+void ReplaceValueNode::run(ExecutionNode* previous)
+{
+ m_previousNode= previous;
+ if(nullptr == previous)
+ {
+ m_errors.insert(Dice::ERROR_CODE::NO_PREVIOUS_ERROR,
+ QStringLiteral("No previous node before Switch/Case operator"));
+ return;
+ }
+ auto previousResult= previous->getResult();
+ m_result->setPrevious(previousResult);
+
+ if(nullptr == previousResult
+ || (!previousResult->hasResultOfType(Dice::RESULT_TYPE::SCALAR)
+ && !previousResult->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST)))
+ {
+ m_errors.insert(Dice::ERROR_CODE::NO_VALID_RESULT,
+ QStringLiteral("No scalar or dice result before Switch/Case operator"));
+ return;
+ }
+
+ QList<Die*> dieList;
+ if(previousResult->hasResultOfType(Dice::RESULT_TYPE::DICE_LIST))
+ {
+ auto diceResult= dynamic_cast<DiceResult*>(previousResult);
+ if(diceResult)
+ dieList.append(diceResult->getResultList());
+ }
+
+ for(auto die : dieList)
+ {
+ QStringList resultList;
+ for(auto const& info : qAsConst(m_branchList))
+ {
+ if(info->validatorList)
+ {
+ auto res= info->validatorList->hasValid(die, false);
+ if(!res)
+ continue;
+ }
+ else if(!resultList.isEmpty())
+ break;
+
+ auto replaceValresult= info->node->getResult();
+ if(replaceValresult)
+ die->replaceLastValue(replaceValresult->getResult(Dice::RESULT_TYPE::SCALAR).toInt());
+ break;
+ }
+ m_diceResult->insertResult(die);
+ }
+
+ if(nullptr != m_nextNode)
+ {
+ m_nextNode->run(this);
+ }
+}
+
+QString ReplaceValueNode::toString(bool withLabel) const
+{
+ if(withLabel)
+ {
+ return QString("%1 [label=\"ReplaceValueNode\"]").arg(m_id);
+ }
+ else
+ {
+ return m_id;
+ }
+}
+
+qint64 ReplaceValueNode::getPriority() const
+{
+ qint64 priority= 0;
+ if(nullptr != m_previousNode)
+ {
+ priority= m_previousNode->getPriority();
+ }
+ return priority;
+}
+
+ExecutionNode* ReplaceValueNode::getCopy() const
+{
+ ReplaceValueNode* node= new ReplaceValueNode();
+ for(auto const& info : qAsConst(m_branchList))
+ {
+ node->insertCase(info->node, info->validatorList);
+ }
+
+ if(nullptr != m_nextNode)
+ {
+ node->setNextNode(m_nextNode->getCopy());
+ }
+ return node;
+}
+
+void ReplaceValueNode::insertCase(ExecutionNode* node, ValidatorList* validator)
+{
+ std::unique_ptr<Dice::CaseInfo> info(new Dice::CaseInfo{validator, node});
+ m_branchList.push_back(std::move(info));
+}
diff --git a/node/replacevaluenode.h b/node/replacevaluenode.h
new file mode 100644
index 0000000..36bdec2
--- /dev/null
+++ b/node/replacevaluenode.h
@@ -0,0 +1,50 @@
+/***************************************************************************
+ * Copyright (C) 2021 by Renaud Guezennec *
+ * http://www.rolisteam.org/contact *
+ * *
+ * This software is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+#ifndef REPLACEVALUENODE_H
+#define REPLACEVALUENODE_H
+
+#include <memory>
+#include <vector>
+
+#include "executionnode.h"
+#include "validatorlist.h"
+
+class DiceResult;
+class ReplaceValueNode : public ExecutionNode
+{
+public:
+ ReplaceValueNode();
+ void setStopAtFirt(bool b);
+
+ void run(ExecutionNode* previous= nullptr) override;
+
+ QString toString(bool withLabel) const override;
+ qint64 getPriority() const override;
+ ExecutionNode* getCopy() const override;
+
+ void insertCase(ExecutionNode* node, ValidatorList* validator);
+
+private:
+ std::vector<std::unique_ptr<Dice::CaseInfo>> m_branchList;
+ DiceResult* m_diceResult= nullptr;
+ bool m_stopAtFirst= false;
+};
+
+#endif // REPLACEVALUENODE_H
diff --git a/node/switchcasenode.cpp b/node/switchcasenode.cpp
index 9b15ec0..0928dd2 100644
--- a/node/switchcasenode.cpp
+++ b/node/switchcasenode.cpp
@@ -147,6 +147,6 @@ ExecutionNode* SwitchCaseNode::getCopy() const
void SwitchCaseNode::insertCase(ExecutionNode* node, ValidatorList* validator)
{
- std::unique_ptr<CaseInfo> info(new CaseInfo{validator, node});
+ std::unique_ptr<Dice::CaseInfo> info(new Dice::CaseInfo{validator, node});
m_branchList.push_back(std::move(info));
}
diff --git a/node/switchcasenode.h b/node/switchcasenode.h
index 719da90..a0f658d 100644
--- a/node/switchcasenode.h
+++ b/node/switchcasenode.h
@@ -21,15 +21,11 @@
#define SWITCHCASENODE_H
#include <memory>
+#include <vector>
#include "executionnode.h"
#include "validatorlist.h"
-struct CaseInfo
-{
- ValidatorList* validatorList;
- ExecutionNode* node;
-};
class StringResult;
class SwitchCaseNode : public ExecutionNode
{
@@ -46,7 +42,7 @@ public:
void insertCase(ExecutionNode* node, ValidatorList* validator);
private:
- std::vector<std::unique_ptr<CaseInfo>> m_branchList;
+ std::vector<std::unique_ptr<Dice::CaseInfo>> m_branchList;
StringResult* m_stringResult;
bool m_stopAtFirst= false;
};
diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp
index 2656fca..d371e9b 100644
--- a/parsingtoolbox.cpp
+++ b/parsingtoolbox.cpp
@@ -48,6 +48,7 @@
#include "node/paintnode.h"
#include "node/parenthesesnode.h"
#include "node/repeaternode.h"
+#include "node/replacevaluenode.h"
#include "node/rerolldicenode.h"
#include "node/scalaroperatornode.h"
#include "node/sortresult.h"
@@ -111,6 +112,7 @@ ParsingToolBox::ParsingToolBox()
m_OptionOp.insert(QStringLiteral("b"), Bind);
m_OptionOp.insert(QStringLiteral("o"), Occurences);
m_OptionOp.insert(QStringLiteral("S"), SwitchCaseOption);
+ m_OptionOp.insert(QStringLiteral("T"), TransformOption);
m_functionMap.insert({QStringLiteral("repeat"), REPEAT});
@@ -1768,6 +1770,15 @@ bool ParsingToolBox::readOption(QString& str, ExecutionNode* previous) //,
node= scNode;
}
break;
+ case TransformOption:
+ {
+ auto scNode= new ReplaceValueNode();
+ found= readReplaceValueNode(str, scNode);
+ previous->setNextNode(scNode);
+ if(found)
+ node= scNode;
+ }
+ break;
case Bind:
{
BindNode* bindNode= new BindNode();
@@ -1963,6 +1974,26 @@ bool ParsingToolBox::readSwitchCaseNode(QString& str, SwitchCaseNode* node)
return res;
}
+bool ParsingToolBox::readReplaceValueNode(QString& str, ReplaceValueNode* node)
+{
+ bool res= false;
+ bool hasInstructionBloc= false;
+ do
+ {
+ auto validator= readValidatorList(str);
+ ExecutionNode* exeNode= nullptr;
+ hasInstructionBloc= readBlocInstruction(str, exeNode);
+ if(hasInstructionBloc)
+ {
+ node->insertCase(exeNode, validator);
+ res= true;
+ }
+
+ } while(hasInstructionBloc);
+
+ return res;
+}
+
bool ParsingToolBox::readBlocInstruction(QString& str, ExecutionNode*& resultnode)
{
if(str.startsWith('{'))