QRectF NSParser::readRect(Symbol* symbol, VariableList& variables)
{
QRectF r;
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
Symbol* fixedSymbol = searchChild(symbol, SYM_FIXED_RECT);
if (fixedSymbol)
{
r = readFixedRect(fixedSymbol, variables);
switch(nt->ruleIndex)
{
case PROD_RECT_AUTO_REVERSED:
r = Tools::autoMirror(r, isMirrored(), getTableWidth());
break;
case PROD_RECT_REVERSED:
r = Tools::autoMirror(r, true, getTableWidth());
break;
case PROD_RECT:
break;
}
}
}
return r;
}
bool NSParser::NSParser::readRectOrVar(Symbol *symbol, NSParser::VariableList &variables, QRectF& r)
{
bool result = false;
if (symbol->type == NON_TERMINAL)
{
result = true;
if (symbol->symbolIndex == SYM_RECT2)
r = readRect(symbol, variables);
else if (symbol->symbolIndex == SYM_FIXED_RECT)
r = readFixedRect(symbol, variables);
else if (symbol->symbolIndex == SYM_VAR)
result = readRectVar(symbol, variables, r);
else //SYM_RECT_OR_VAR
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
switch(nt->ruleIndex)
{
case PROD_RECT_OR_VAR:
r = readRect(searchChild(symbol, SYM_RECT2), variables);
break;
case PROD_RECT_OR_VAR2:
result = readRectVar(symbol, variables, r);
break;
default:
result = false;
break;
}
}
}
return result;
}
bool NSParser::readPointOrVar(Symbol* symbol, VariableList& variables, Tools::RPoint &point)
{
bool result = false;
if (symbol->type == NON_TERMINAL)
{
result = true;
if (symbol->symbolIndex == SYM_POINT)
point = readPoint(symbol);
else if (symbol->symbolIndex == SYM_FIXED_POINT)
point = readFixedPoint(symbol);
else if (symbol->symbolIndex == SYM_VAR)
result = readPointVar(symbol, variables, point);
else //SYM_POINT_OR_VAR
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
switch(nt->ruleIndex)
{
case PROD_POINT_OR_VAR:
point = readPoint(searchChild(symbol, SYM_POINT));
break;
case PROD_POINT_OR_VAR2:
result = readPointVar(symbol, variables, point);
break;
default:
result = false;
break;
}
}
}
return result;
}
Tools::RPoint NSParser::readPoint(Symbol* symbol)
{
Tools::RPoint point;
if (symbol->type == NON_TERMINAL)
{
if (symbol->symbolIndex == SYM_FIXED_POINT)
point = readFixedPoint(symbol);
else
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
Symbol* fixedPointSymbol = searchChild(symbol, SYM_FIXED_POINT);
if (fixedPointSymbol)
{
point = readFixedPoint(fixedPointSymbol);
switch(nt->ruleIndex)
{
case PROD_POINT_AUTO_REVERSED:
point = Tools::autoMirror(point, isMirrored(), getTableWidth());
break;
case PROD_POINT_REVERSED:
point = Tools::autoMirror(point, true, getTableWidth());
break;
case PROD_POINT:
break;
}
}
}
}
return point;
}
double NSParser::readAngleInRadian(Symbol* symbol)
{
double value = 0.0;
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
Symbol* fixedSymbol = searchChild(symbol, SYM_FIXED_ANGLE);
if (fixedSymbol)
{
value = readFixedAngleInRadian(fixedSymbol);
switch(nt->ruleIndex)
{
case PROD_ANGLE_AUTO_REVERSED:
value = Tools::autoMirror(value, isMirrored());
break;
case PROD_ANGLE_REVERSED:
value = Tools::autoMirror(value, true);
break;
case PROD_ANGLE:
break;
}
}
else
{
value = readFixedAngleInRadian(symbol);
}
}
return value;
}
void NSParser::readSensorIdentifier(Symbol *symbol, int& sensorType, int &id)
{
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
for(Symbol* child: nt->children)
{
switch(child->symbolIndex)
{
case SYM_INTEGER:
case SYM_ID:
{
Symbol* intSymbol = searchChild(child, SYM_INTEGER);
id = readInteger(intSymbol);
break;
}
case SYM_SENSOR2:
{
sensorType = readSensorType(child);
break;
}
}
}
}
}
bool NSParser::readStringOrVar(Symbol *symbol, NSParser::VariableList &variables, QString &str)
{
bool result = true;
if (symbol->symbolIndex == SYM_STRING)
str = readString(symbol);
else if (symbol->symbolIndex == SYM_VAR)
result = readStringVar(symbol, variables, str);
else //SYM_STRING_OR_VAR
{
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
switch(nt->ruleIndex)
{
case PROD_STRING_OR_VAR_STRING:
str = readString(searchChild(symbol, SYM_STRING));
break;
case PROD_STRING_OR_VAR:
result = readStringVar(symbol, variables, str);
break;
default:
result = false;
break;
}
}
else
result = false;
}
return result;
}
void DFS(int s){
std::vector<int> children;
int child = searchChild(s);
while(child!=NOT_FOUND){
}
}
int NSParser::readSubId(Symbol *symbol)
{
Symbol* intSymbol = searchChild(symbol, SYM_INTEGER, true);
if (intSymbol)
return readInteger(intSymbol);
return -1;
}
int NSParser::readSpeed(Symbol* symbol)
{
int speed = 100;
Symbol* intergerSymbol = searchChild(symbol, SYM_INTEGER);
if (intergerSymbol)
speed = readInteger(intergerSymbol);
return speed;
}
QString NSParser::readVar(Symbol* symbol)
{
QString varName;
Symbol* identifier = searchChild(symbol, SYM_IDENTIFIER);
if (identifier)
varName = readIdentifier(identifier);
return varName;
}
//progress
//funsgi run dimulai dari iterasi ke dua
string Astar:: run()
{
cout << "Iterasi ke-" << _iterasi << " :" <<endl;
//masukkan frontier ke visited
_visited.push_back(_frontier[0]->current);
_frontier.erase(_frontier.begin());
//masukkan successor ke frontier
//cek apakah punya successor atau tidak
if(!_successor.empty())
{
for(int i=0;i<_successor.size();i++)
{
_frontier.push_back(_successor[i]);
}
//frontier di sorting
sortFrontier();
//hapus daftar successor
emptySuccessor();
}
if(_frontier.empty())
{
//cetak frontier,successor,visited
cetakFrontier();
cetakSuccessor();
cetakVisited();
return "Path Not Found";
}
else if(_frontier[0]->current==_goal)
{
//cetak frontier,successor,visited
cetakFrontier();
cetakSuccessor();
cetakVisited();
return "Path : " + pathConstruction(_frontier[0]);
}
else
{
//cari successor (anak)
searchChild(_frontier[0]);
//cetak frontier,successor,visited
cetakFrontier();
cetakSuccessor();
cetakVisited();
_iterasi++;
//panggil fungsi run kembali ke iterasi berikutnya
return run();
}
}
void Astar::execute()
{
cout << endl << "Iterasi ke-" << _iterasi << " :" <<endl;
if(_startNode->current==_goal){
cout << "Start node equals to goal node" << endl;
return;
}
_frontier.push_back(this->_startNode);
searchChild(this->_startNode);
//cetak frontier,successor,visited
cetakFrontier();
cetakSuccessor();
cetakVisited();
_iterasi++;
cout << run() << endl;
cout << "Total cost: " << _frontier[0]->gx << endl;
}
double NSParser::readFixedAngleInRadian(Symbol* symbol)
{
double value = 0.0;
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
Symbol* numSymbol = searchChild(symbol, SYM_NUM);
if (numSymbol)
value = readNum(numSymbol);
switch(nt->ruleIndex)
{
case PROD_FIXED_ANGLE_RAD:
break;
case PROD_FIXED_ANGLE_DEG:
case PROD_FIXED_ANGLE:
default:
value = Tools::degreeToRadian(value);
break;
}
}
return value;
}
NSParser::ConditionInfo NSParser::readCondition(Symbol *symbol, VariableList& variables)
{
ConditionInfo info;
if (symbol->type == NON_TERMINAL)
{
Symbol* conditionSymbol = nullptr;
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
switch(nt->ruleIndex)
{
case PROD_SENSORCONDITION:
case PROD_IFCONDITION: //sensor
conditionSymbol = searchChild(symbol, SYM_SENSORCONDITION);
break;
case PROD_ORIENTATIONCONDITION_ORIENTATION:
case PROD_IFCONDITION2: //orientation
info.type = ConditionInfo::RobotOrientationCondition;
conditionSymbol = searchChild(symbol, SYM_ORIENTATIONCONDITION);
break;
case PROD_POSITIONCONDITION_POSITION:
case PROD_IFCONDITION3: //position
info.type = ConditionInfo::RobotPosCondition;
conditionSymbol = searchChild(symbol, SYM_POSITIONCONDITION);
break;
case PROD_OPPONENTCONDITION_OPPONENT:
case PROD_IFCONDITION4: //opponent
info.type = ConditionInfo::OpponentPosCondition;
conditionSymbol = searchChild(symbol, SYM_OPPONENTCONDITION);
break;
case PROD_REVERSECONDITION_STRATEGY_REVERSED:
case PROD_IFCONDITION5: //strategy reversed
info.type = ConditionInfo::ReversedStrategyCondition;
conditionSymbol = searchChild(symbol, SYM_REVERSECONDITION);
break;
case PROD_IFCONDITION_TRUE: //strategy reversed
info.type = ConditionInfo::AlwaysTrueCondition;
break;
case PROD_IFCONDITION_FALSE: //strategy reversed
info.type = ConditionInfo::AlwaysFalseCondition;
break;
}
int sensorType = Comm::UnknownedSensor;
if (conditionSymbol && conditionSymbol->type == NON_TERMINAL)
{
NonTerminal* conditionSymbolNt = static_cast<NonTerminal*>(conditionSymbol);
for(Symbol* c: conditionSymbolNt->children)
{
switch(c->symbolIndex)
{
case SYM_SENSOR_IDENTIFIER:
case SYM_SENSOR_OR_VAR:
{
readSensorOrVar(c, variables, sensorType, info.sensorId);
if (sensorType == Comm::ColorSensor)
info.type = ConditionInfo::ColorSensorValueCondition;
else if (sensorType == Comm::SharpSensor)
info.type = ConditionInfo::SharpValueCondition;
else if (sensorType == Comm::MicroswitchSensor)
info.type = ConditionInfo::MicroswitchValueCondition;
break;
if (info.sensorId <= 0)
{
info.setInvalid();
addError(NSParsingError::invalidSensorId(c));
}
}
case SYM_COLORSENSORVALUE:
case SYM_MICROSWITCHVALUE:
case SYM_SHARPVALUE:
case SYM_SENSORVALUE:
{
Comm::SensorType valueSensorType;
info.sensorValue = readSensorValue(c, valueSensorType);
if (valueSensorType != sensorType)
{
addError(NSParsingError::invalidSensorValueError(readTerminals(c), c));
info.sensorValue = -1;
info.setInvalid();
}
break;
}
case SYM_RECT_OR_VAR:
case SYM_RECT2:
case SYM_FIXED_RECT:
readRectOrVar(c, variables, info.rect);
break;
case SYM_ANGLERANGE:
readAngleRangeInRadian(c, info.angleMin, info.angleMax);
break;
case SYM_VAR:
{
QString varName = readVar(c);
if (variables.contains(varName))
{
DeclaredVariable& var = variables[varName];
if (info.type == ConditionInfo::OpponentPosCondition || info.type == ConditionInfo::RobotPosCondition)
{
//expected rect
if (var.isRect())
info.rect = var.toRect();
else
{
info.setInvalid();
addError(NSParsingError::invalidVariableTypeError(varName, "rect", c));
}
}
else
{
//expected sensor
if (var.isSensor())
var.toSensor(info.sensorId, sensorType);
if (sensorType == Comm::ColorSensor)
info.type = ConditionInfo::ColorSensorValueCondition;
else if (sensorType == Comm::SharpSensor)
info.type = ConditionInfo::SharpValueCondition;
else if (sensorType == Comm::MicroswitchSensor)
info.type = ConditionInfo::MicroswitchValueCondition;
else
{
info.setInvalid();
addError(NSParsingError::invalidVariableTypeError(varName, "sensor", c));
}
if (info.sensorId <= 0)
{
info.setInvalid();
addError(NSParsingError::invalidSensorId(c));
}
}
}
else
{
info.setInvalid();
addError(NSParsingError::undeclaredVariableError(varName, c));
}
break;
}
case SYM_CONDITIONINOPERATOR:
info.neg = static_cast<NonTerminal*>(c)->ruleIndex == PROD_CONDITIONINOPERATOR_NOT_IN;
break;
case SYM_CONDITIONISOPERATOR:
info.neg = static_cast<NonTerminal*>(c)->ruleIndex == PROD_CONDITIONISOPERATOR_IS_NOT;
break;
}
}
}
}
return info;
}
