From 4de8cf5796446b7f8b09d776e4a6a6d6b8e95cb6 Mon Sep 17 00:00:00 2001 From: Renaud G Date: Sat, 4 Jan 2014 16:24:54 +0100 Subject: -Adding range, booleancondition and countexecutenode. --- booleancondition.cpp | 35 ++++++++++ booleancondition.h | 23 +++++++ diceParser.pro | 9 +++ diceparser.cpp | 167 +++++++++++++++++++++++++++++++++++++++++----- diceparser.h | 36 +++++++++- diceresult.cpp | 5 ++ diceresult.h | 2 + main.cpp | 22 ++++-- node/countexecutenode.cpp | 33 +++++++++ node/countexecutenode.h | 22 ++++++ node/keepdiceexecnode.cpp | 27 ++++++++ node/keepdiceexecnode.h | 17 +++++ node/node.pri | 10 ++- node/sortresult.cpp | 37 ++++++++++ node/sortresult.h | 18 +++++ range.cpp | 21 ++++++ range.h | 20 ++++++ validator.cpp | 5 ++ validator.h | 13 ++++ 19 files changed, 496 insertions(+), 26 deletions(-) create mode 100644 booleancondition.cpp create mode 100644 booleancondition.h create mode 100644 node/countexecutenode.cpp create mode 100644 node/countexecutenode.h create mode 100644 node/keepdiceexecnode.cpp create mode 100644 node/keepdiceexecnode.h create mode 100644 node/sortresult.cpp create mode 100644 node/sortresult.h create mode 100644 range.cpp create mode 100644 range.h create mode 100644 validator.cpp create mode 100644 validator.h diff --git a/booleancondition.cpp b/booleancondition.cpp new file mode 100644 index 0000000..c0b4299 --- /dev/null +++ b/booleancondition.cpp @@ -0,0 +1,35 @@ +#include "booleancondition.h" + + +BooleanCondition::BooleanCondition() +{ +} +bool BooleanCondition::isValid(qint64 b) const +{ + switch(m_operator) + { + case Equal: + return (b==m_value); + case GreaterThan: + return (b>m_value); + case LesserThan: + return (b=m_value); + case LesserOrEqual: + return (b<=m_value); + + + } + return false; +} + +void BooleanCondition::setOperator(LogicOperator m) +{ + m_operator = m; +} + +void BooleanCondition::setValue(qint64 v) +{ + m_value=v; +} diff --git a/booleancondition.h b/booleancondition.h new file mode 100644 index 0000000..e757a2e --- /dev/null +++ b/booleancondition.h @@ -0,0 +1,23 @@ +#ifndef BOOLEANCONDITION_H +#define BOOLEANCONDITION_H + +#include +#include "validator.h" + +class BooleanCondition : public Validator +{ +public: + enum LogicOperator { Equal, GreaterThan, LesserThan, GreaterOrEqual, LesserOrEqual}; + BooleanCondition(); + + virtual bool isValid(qint64 b) const; + + void setOperator(LogicOperator m); + void setValue(qint64); + +private: + LogicOperator m_operator; + qint64 m_value; +}; + +#endif // BOOLEANCONDITION_H diff --git a/diceParser.pro b/diceParser.pro index e585d74..112fb9a 100644 --- a/diceParser.pro +++ b/diceParser.pro @@ -20,10 +20,19 @@ TEMPLATE = app SOURCES += main.cpp \ diceparser.cpp \ diceresult.cpp \ + range.cpp \ + booleancondition.cpp \ + validator.cpp HEADERS += \ diceparser.h \ diceresult.h \ + range.h \ + booleancondition.h \ + validator.h OTHER_FILES += README.md + + +#QMAKE_CXXFLAGS += -O0 diff --git a/diceparser.cpp b/diceparser.cpp index 6096a4d..f44f6af 100644 --- a/diceparser.cpp +++ b/diceparser.cpp @@ -1,16 +1,39 @@ #include "diceparser.h" #include #include +#include #include "node/dicerollernode.h" #include "node/startingnode.h" #include "node/scalaroperatornode.h" #include "node/numbernode.h" +#include "node/keepdiceexecnode.h" +#include "node/sortresult.h" +#include "node/countexecutenode.h" DiceParser::DiceParser() { m_mapDiceOp = new QMap(); m_mapDiceOp->insert("D",D); + + m_OptionOp = new QMap(); + m_OptionOp->insert(QObject::tr("k"),keep); + m_OptionOp->insert(QObject::tr("K"),KeepAndReRoll); + m_OptionOp->insert(QObject::tr("s"),Sort); + m_OptionOp->insert(QObject::tr("c"),Count); + + + + m_logicOp = new QMap(); + m_logicOp->insert("<",BooleanCondition::LesserThan); + m_logicOp->insert("=",BooleanCondition::Equal); + m_logicOp->insert("<=",BooleanCondition::LesserOrEqual); + m_logicOp->insert(">",BooleanCondition::GreaterThan); + m_logicOp->insert(">=",BooleanCondition::GreaterOrEqual); + + + + } void DiceParser::setCurrentNode(ExecutionNode* node) @@ -38,20 +61,8 @@ void DiceParser::parseLine(QString str) keepParsing =!str.isEmpty(); while(keepParsing) { - keepParsing = readOperator(str); - -// if(keepParsing) -// { -// keepParsing = readDiceExpression(str,execNode); - -// m_current->setNextNode(execNode); -// m_current= execNode; - -// if(keepParsing) -// { -// keepParsing =!str.isEmpty(); -// } -// } + keepParsing = readOperator(str); + keepParsing = readOption(str); } m_start->run(); @@ -103,7 +114,7 @@ bool DiceParser::readDice(QString& str,Dice& dice) } } - return false; + return false; } bool DiceParser::readDiceOperator(QString& str,DiceOperator& op) @@ -177,3 +188,129 @@ bool DiceParser::readOperator(QString& str) } return false; } +bool DiceParser::readOption(QString& str) +{ + + + if(str.isEmpty()) + { + return false; + } + + + + foreach(QString tmp, m_OptionOp->keys()) + { + + if(str.startsWith(tmp)) + { + + str=str.remove(0,tmp.size()); + int myNumber=0; + switch(m_OptionOp->value(tmp)) + { + case KeepAndReRoll: + { + if(readNumber(str,myNumber)) + { + addSort(false); + + KeepDiceExecNode* nodeK = new KeepDiceExecNode(); + nodeK->setDiceKeepNumber(myNumber); + + m_current->setNextNode(nodeK); + m_current= nodeK; + return true; + + } + } + break; + case Sort: + { + addSort(false); + return true; + } + break; + case Count: + { + Validator* validator = readValidator(str); + if(NULL!=validator) + { + CountExecuteNode* node = new CountExecuteNode(); + node->setValidator(validator); + + m_current->setNextNode(node); + m_current = node; + return true; + } + } + break; + } + } + } + return false; +} +Validator* DiceParser::readValidator(QString& str) +{ + Validator* returnVal=NULL; + if(str.startsWith("[")) + { + str=str.remove(0,1); + int start=0; + BooleanCondition::LogicOperator myLogicOp; + if(readNumber(str,start)) + { + if(str.startsWith("-")) + { + str=str.remove(0,1); + int end=0; + if(readNumber(str,end)) + { + if(str.startsWith("]")) + { + str=str.remove(0,1); + Range* range = new Range(); + range->setValue(start,end); + returnVal = range; + + } + } + } + } + else if(readLogicOperator(str,myLogicOp)) + { + int value=0; + if(readNumber(str,value)) + { + BooleanCondition* condition = new BooleanCondition(); + condition->setValue(value); + condition->setOperator(myLogicOp); + returnVal = condition; + + } + } + } + return returnVal; +} +bool DiceParser::readLogicOperator(QString& str,BooleanCondition::LogicOperator& op) +{ + foreach(QString tmp, m_logicOp->keys()) + { + if(str.startsWith(tmp)) + { + str=str.remove(0,tmp.size()); + op = m_logicOp->value(tmp); + return true; + } + } + return false; +} + +void DiceParser::addSort(bool b) +{ + SortResultNode* nodeSort = new SortResultNode(); + nodeSort->setSortAscending(b); + m_current->setNextNode(nodeSort); + m_current = nodeSort; + +} diff --git a/diceparser.h b/diceparser.h index 6833a92..1615aaf 100644 --- a/diceparser.h +++ b/diceparser.h @@ -4,6 +4,9 @@ #include #include #include "node/executionnode.h" +#include "validator.h" +#include "range.h" +#include "booleancondition.h" /** * @mainpage DiceParser @@ -28,13 +31,16 @@ class DiceParser public: /** - * @brief The DiceOperator enum gathering all dice operator + * @brief The DiceOperator enum gathering all dice operators */ enum DiceOperator {D}; + + + /** - * @brief The MathOperator enum gathering all dice option/math operator such as keep k, reroll r, explode e. + * @brief The OptionOperator enum gathering all options availables for result. */ - enum MathOperator {K,k,r,e}; + enum OptionOperator {KeepAndReRoll,keep,Reroll,Explosing,Sort,Count}; /** * @brief DiceParser default constructor @@ -83,8 +89,32 @@ private: */ void setCurrentNode(ExecutionNode* node); + /** + * @brief readOption + */ + bool readOption(QString&); + + /** + * @brief addSort + * @param b + */ + void addSort(bool b); + + /** + * @brief readValidator + * @param str + * @param validator + * @return + */ + Validator* readValidator(QString& str); + + + bool readLogicOperator(QString& str,BooleanCondition::LogicOperator& condition); + private: QMap* m_mapDiceOp; + QMap* m_OptionOp; + QMap* m_logicOp; ExecutionNode* m_start; ExecutionNode* m_current; }; diff --git a/diceresult.cpp b/diceresult.cpp index dfdd765..619ccbd 100644 --- a/diceresult.cpp +++ b/diceresult.cpp @@ -22,3 +22,8 @@ qint64 DiceResult::getSum() return sum; } +void DiceResult::setResultList(QList list) +{ + m_diceValues.clear(); + m_diceValues << list; +} diff --git a/diceresult.h b/diceresult.h index a9d36a3..9212233 100644 --- a/diceresult.h +++ b/diceresult.h @@ -11,6 +11,8 @@ public: QList& getResultList(); void insertResult(qint64); + void setResultList(QList list); + private: QList m_diceValues; diff --git a/main.cpp b/main.cpp index 479ac8a..a42115e 100644 --- a/main.cpp +++ b/main.cpp @@ -9,15 +9,25 @@ int main(int argc, char *argv[]) myParser->parseLine("3D100"); myParser->parseLine("3D100"); - //myParser->parseLine("100291D66666666"); - //myParser->parseLine("10D10g3"); - //myParser->parseLine("10g3"); - myParser->parseLine("1D8"); + // myParser->parseLine("100291D66666666"); + myParser->parseLine("10D10K3"); + myParser->parseLine("10k3"); + + /// roll 10 dice of 10 slices and sort them + myParser->parseLine("10D10s"); + + /// roll 15 dice of 10 slices and count above 7 + myParser->parseLine("15D10c[8-10]"); + + /// roll 15 dice of 10 slices condition count above 7 + myParser->parseLine("15D10c[>7]"); + + myParser->parseLine("1D8+2D6+7"); myParser->parseLine("D25"); myParser->parseLine("8+8"); - myParser->parseLine("8-88"); - myParser->parseLine("100*28"); + myParser->parseLine("88-1D20"); + myParser->parseLine("100*1D20"); myParser->parseLine("100/28"); myParser->parseLine("100/8"); myParser->parseLine("100*3"); diff --git a/node/countexecutenode.cpp b/node/countexecutenode.cpp new file mode 100644 index 0000000..fff00f2 --- /dev/null +++ b/node/countexecutenode.cpp @@ -0,0 +1,33 @@ +#include "countexecutenode.h" + +CountExecuteNode::CountExecuteNode() +{ +} +void CountExecuteNode::setValidator(Validator* validator) +{ + m_validator = validator; +} + +void CountExecuteNode::run(ExecutionNode *previous) +{ + if(NULL==previous) + { + return; + } + QList diceList=previous->getResult()->getResultList(); + qint64 sum = 0; + foreach(qint64 dice,diceList) + { + if(m_validator->isValid(dice)) + { + ++sum; + } + } + m_result.insertResult(sum); + + + if(NULL!=m_nextNode) + { + m_nextNode->run(this); + } +} diff --git a/node/countexecutenode.h b/node/countexecutenode.h new file mode 100644 index 0000000..6c971ea --- /dev/null +++ b/node/countexecutenode.h @@ -0,0 +1,22 @@ +#ifndef COUNTEXECUTENODE_H +#define COUNTEXECUTENODE_H + +#include "executionnode.h" + +#include "validator.h" + +class CountExecuteNode : public ExecutionNode +{ +public: + CountExecuteNode(); + virtual void run(ExecutionNode* previous); + + + virtual void setValidator(Validator* ); + +private: + Validator* m_validator; + +}; + +#endif // COUNTEXECUTENODE_H diff --git a/node/keepdiceexecnode.cpp b/node/keepdiceexecnode.cpp new file mode 100644 index 0000000..cd2b76e --- /dev/null +++ b/node/keepdiceexecnode.cpp @@ -0,0 +1,27 @@ +#include "keepdiceexecnode.h" + +KeepDiceExecNode::KeepDiceExecNode() +{ +} + +void KeepDiceExecNode::run(ExecutionNode* previous) +{ + if(NULL==previous) + { + return; + } + QList diceList=previous->getResult()->getResultList(); + QList diceList2=m_result.getResultList(); + + + diceList2 = diceList.mid(0,m_numberOfDice); + m_result.setResultList(diceList2); + if(NULL!=m_nextNode) + { + m_nextNode->run(this); + } +} +void KeepDiceExecNode::setDiceKeepNumber(quint64 n) +{ + m_numberOfDice = n; +} diff --git a/node/keepdiceexecnode.h b/node/keepdiceexecnode.h new file mode 100644 index 0000000..28c637d --- /dev/null +++ b/node/keepdiceexecnode.h @@ -0,0 +1,17 @@ +#ifndef KEEPDICEEXECNODE_H +#define KEEPDICEEXECNODE_H + +#include "executionnode.h" + +class KeepDiceExecNode : public ExecutionNode +{ +public: + KeepDiceExecNode(); + + virtual void run(ExecutionNode *previous); + virtual void setDiceKeepNumber(quint64 ); +private: + quint64 m_numberOfDice; +}; + +#endif // KEEPDICEEXECNODE_H diff --git a/node/node.pri b/node/node.pri index c3e1d65..fb2d9ad 100644 --- a/node/node.pri +++ b/node/node.pri @@ -4,7 +4,10 @@ HEADERS += \ node/rerolldicenode.h \ node/startingnode.h \ node/scalaroperatornode.h \ - node/numbernode.h + node/numbernode.h \ + node/sortresult.h \ + node/keepdiceexecnode.h \ + node/countexecutenode.h SOURCES += \ node/dicerollernode.cpp \ @@ -12,4 +15,7 @@ SOURCES += \ node/startingnode.cpp \ node/rerolldicenode.cpp \ node/scalaroperatornode.cpp \ - node/numbernode.cpp + node/numbernode.cpp \ + node/sortresult.cpp \ + node/keepdiceexecnode.cpp \ + node/countexecutenode.cpp diff --git a/node/sortresult.cpp b/node/sortresult.cpp new file mode 100644 index 0000000..f4364fa --- /dev/null +++ b/node/sortresult.cpp @@ -0,0 +1,37 @@ +#include "sortresult.h" + +#include + +SortResultNode::SortResultNode() +{ + m_ascending = true; +} +void SortResultNode::run(ExecutionNode* node) +{ + if(NULL==node) + { + return; + } + QList diceList=node->getResult()->getResultList(); + QList diceList2=m_result.getResultList(); + + diceList2 = diceList; + if(!m_ascending) + { + qSort(diceList2.begin(), diceList2.end(), qGreater()); + } + else + { + qSort(diceList2.begin(), diceList2.end(), qLess()); + } + m_result.setResultList(diceList2); + if(NULL!=m_nextNode) + { + m_nextNode->run(this); + } + +} +void SortResultNode::setSortAscending(bool asc) +{ + m_ascending = asc; +} diff --git a/node/sortresult.h b/node/sortresult.h new file mode 100644 index 0000000..8433eba --- /dev/null +++ b/node/sortresult.h @@ -0,0 +1,18 @@ +#ifndef SORTRESULT_H +#define SORTRESULT_H + +#include "executionnode.h" + +class SortResultNode : public ExecutionNode +{ +public: + SortResultNode(); + virtual void run(ExecutionNode*); + + + void setSortAscending(bool asc); +private: + bool m_ascending; +}; + +#endif // SORTRESULT_H diff --git a/range.cpp b/range.cpp new file mode 100644 index 0000000..0e18164 --- /dev/null +++ b/range.cpp @@ -0,0 +1,21 @@ +#include "range.h" + +Range::Range() +{ + + +} +void Range::setValue(qint64 s,qint64 e) +{ + m_start = s; + m_end=e; +} + +bool Range::isValid(qint64 m) const +{ + if((m>=m_start)&&(m<=m_end)) + { + return true; + } + return false; +} diff --git a/range.h b/range.h new file mode 100644 index 0000000..73bef2b --- /dev/null +++ b/range.h @@ -0,0 +1,20 @@ +#ifndef RANGE_H +#define RANGE_H + +#include +#include "validator.h" + +class Range : public Validator +{ +public: + Range(); + void setValue(qint64,qint64); + + virtual bool isValid(qint64 b) const; + +private: + qint64 m_start; + qint64 m_end; +}; + +#endif // RANGE_H diff --git a/validator.cpp b/validator.cpp new file mode 100644 index 0000000..a3cce1d --- /dev/null +++ b/validator.cpp @@ -0,0 +1,5 @@ +#include "validator.h" + +Validator::Validator() +{ +} diff --git a/validator.h b/validator.h new file mode 100644 index 0000000..1bdb977 --- /dev/null +++ b/validator.h @@ -0,0 +1,13 @@ +#ifndef VALIDATOR_H +#define VALIDATOR_H + +#include + +class Validator +{ +public: + Validator(); + virtual bool isValid(qint64 b) const = 0 ; +}; + +#endif // VALIDATOR_H -- cgit v1.2.3-70-g09d2